/*
===========
QE_SaveProject
TTimo: whenever QE_SaveProject is called, prefs are updated and saved with the path to the project
===========
*/
qboolean QE_SaveProject( const char* filename ){
Sys_Printf( "Save project file '%s'\n", filename );
xmlNodePtr node;
xmlDocPtr doc = xmlNewDoc( (xmlChar *)"1.0" );
// create DTD node
xmlCreateIntSubset( doc, (xmlChar *)"project", NULL, (xmlChar *)"project.dtd" );
// create project node
doc->children->next = xmlNewDocNode( doc, NULL, (xmlChar *)"project", NULL );
for ( epair_t* epair = g_qeglobals.d_project_entity->epairs; epair != NULL; epair = epair->next )
{
node = xmlNewChild( doc->children->next, NULL, (xmlChar *)"key", NULL );
xmlSetProp( node, (xmlChar*)"name", (xmlChar*)epair->key );
xmlSetProp( node, (xmlChar*)"value", (xmlChar*)epair->value );
}
CreateDirectoryPath( filename );
if ( xmlSaveFormatFile( filename, doc, 1 ) != -1 ) {
xmlFreeDoc( doc );
Sys_Printf( "Setting current project in prefs to \"%s\"\n", filename );
g_PrefsDlg.m_strLastProject = filename;
g_PrefsDlg.SavePrefs();
return TRUE;
}
else
{
xmlFreeDoc( doc );
Sys_FPrintf( SYS_ERR, "failed to save project file: \"%s\"\n", filename );
return FALSE;
}
}
static xmlDocPtr
hwloc__libxml2_prepare_export(hwloc_topology_t topology)
{
struct hwloc__xml_export_state_s state;
hwloc__libxml_export_state_data_t data = (void *) state.data;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL; /* root pointer */
assert(sizeof(*data) <= sizeof(state.data));
LIBXML_TEST_VERSION;
hwloc_libxml2_disable_stderrwarnings();
/* Creates a new document, a node and set it as a root node. */
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "topology");
xmlDocSetRootElement(doc, root_node);
/* Creates a DTD declaration. Isn't mandatory. */
(void) xmlCreateIntSubset(doc, BAD_CAST "topology", NULL, BAD_CAST "hwloc.dtd");
state.new_child = hwloc__libxml_export_new_child;
state.new_prop = hwloc__libxml_export_new_prop;
state.add_content = hwloc__libxml_export_add_content;
state.end_object = hwloc__libxml_export_end_object;
data->current_node = root_node;
hwloc__xml_export_object (&state, topology, hwloc_get_root_obj(topology));
return doc;
}
static xmlDocPtr
hwloc__libxml2_prepare_export_diff(hwloc_topology_diff_t diff, const char *refname)
{
struct hwloc__xml_export_state_s state;
hwloc__libxml_export_state_data_t data = (void *) state.data;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL; /* root pointer */
assert(sizeof(*data) <= sizeof(state.data));
LIBXML_TEST_VERSION;
hwloc_libxml2_init_once();
/* Creates a new document, a node and set it as a root node. */
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "topologydiff");
if (refname)
xmlNewProp(root_node, BAD_CAST "refname", BAD_CAST refname);
xmlDocSetRootElement(doc, root_node);
/* Creates a DTD declaration. Isn't mandatory. */
(void) xmlCreateIntSubset(doc, BAD_CAST "topologydiff", NULL, BAD_CAST "hwloc.dtd");
state.new_child = hwloc__libxml_export_new_child;
state.new_prop = hwloc__libxml_export_new_prop;
state.add_content = hwloc__libxml_export_add_content;
state.end_object = hwloc__libxml_export_end_object;
data->current_node = root_node;
hwloc__xml_export_diff (&state, diff);
return doc;
}
/*
* call-seq:
* create_internal_subset(name, external_id, system_id)
*
* Create the internal subset of a document.
*
* doc.create_internal_subset("chapter", "-//OASIS//DTD DocBook XML//EN", "chapter.dtd")
* # => <!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML//EN" "chapter.dtd">
*
* doc.create_internal_subset("chapter", nil, "chapter.dtd")
* # => <!DOCTYPE chapter SYSTEM "chapter.dtd">
*/
static VALUE create_internal_subset(VALUE self, VALUE name, VALUE external_id, VALUE system_id)
{
xmlNodePtr node;
xmlDocPtr doc;
xmlDtdPtr dtd;
Data_Get_Struct(self, xmlNode, node);
doc = node->doc;
if(xmlGetIntSubset(doc)) {
rb_raise(rb_eRuntimeError, "Document already has an internal subset");
}
dtd = xmlCreateIntSubset(
doc,
NIL_P(name) ? NULL : (const xmlChar *)StringValueCStr(name),
NIL_P(external_id) ? NULL : (const xmlChar *)StringValueCStr(external_id),
NIL_P(system_id) ? NULL : (const xmlChar *)StringValueCStr(system_id)
);
if(!dtd) { return Qnil; }
return Nokogiri_wrap_xml_node(Qnil, (xmlNodePtr)dtd);
}
/* {{{ proto DOMDocumentType dom_domimplementation_create_document_type(string qualifiedName, string publicId, string systemId);
URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Level-2-Core-DOM-createDocType
Since: DOM Level 2
*/
PHP_METHOD(domimplementation, createDocumentType)
{
xmlDtd *doctype;
int ret;
size_t name_len = 0, publicid_len = 0, systemid_len = 0;
char *name = NULL, *publicid = NULL, *systemid = NULL;
xmlChar *pch1 = NULL, *pch2 = NULL, *localname = NULL;
xmlURIPtr uri;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|sss", &name, &name_len, &publicid, &publicid_len, &systemid, &systemid_len) == FAILURE) {
return;
}
if (name_len == 0) {
php_error_docref(NULL, E_WARNING, "qualifiedName is required");
RETURN_FALSE;
}
if (publicid_len > 0) {
pch1 = (xmlChar *) publicid;
}
if (systemid_len > 0) {
pch2 = (xmlChar *) systemid;
}
uri = xmlParseURI(name);
if (uri != NULL && uri->opaque != NULL) {
localname = xmlStrdup((xmlChar *) uri->opaque);
if (xmlStrchr(localname, (xmlChar) ':') != NULL) {
php_dom_throw_error(NAMESPACE_ERR, 1);
xmlFreeURI(uri);
xmlFree(localname);
RETURN_FALSE;
}
} else {
localname = xmlStrdup((xmlChar *) name);
}
/* TODO: Test that localname has no invalid chars
php_dom_throw_error(INVALID_CHARACTER_ERR,);
*/
if (uri) {
xmlFreeURI(uri);
}
doctype = xmlCreateIntSubset(NULL, localname, pch1, pch2);
xmlFree(localname);
if (doctype == NULL) {
php_error_docref(NULL, E_WARNING, "Unable to create DocumentType");
RETURN_FALSE;
}
DOM_RET_OBJ((xmlNodePtr) doctype, &ret, NULL);
}
char *
epg_to_xmltv(const struct epg *epg)
{
xmlDocPtr doc = NULL;
xmlDtdPtr dtd = NULL;
xmlNodePtr root = NULL;
xmlChar *s = NULL;
error_if(epg == NULL, error, "Param Error");
LIBXML_TEST_VERSION;
doc = xmlNewDoc((const xmlChar *)"1.0");
error_if(doc == NULL, error, "Error Creating xmlDoc");
root = xmlNewDocNode(doc, NULL, BAD_CAST "tv", NULL);
error_if(root == NULL, error, "Error creating root node");
dtd = xmlCreateIntSubset(doc, BAD_CAST "tv", NULL, BAD_CAST "epg.dtd");
error_if(dtd == NULL, error, "Error adding DTD to xmlDoc");
xmlDocSetRootElement(doc, root);
xmlNewProp(root,
BAD_CAST "generator-info-name",
BAD_CAST "tvz_epg - https://github.com/virgiliosanz/movistar_sv");
trace("%s", "Adding programmes");
_programmes_to_xml(root, epg->programmes);
trace("%s", "Adding channels");
_channels_to_xml(root, epg->channels);
trace("calling xmlDocDumpMemory chan: %zu prog: %zu",
list_count(epg->channels), list_count(epg->programmes));
int size;
xmlDocDumpMemoryEnc(doc, &s, &size, "UTF-8");
xmlCleanupParser();
return (char *)s;
error:
xmlCleanupParser();
if (s) free(s);
return NULL;
}
void Map_Write( CPtrArray *map, IDataStream *out ){
xmlChar* buf;
int len;
xmlDocPtr doc = xmlNewDoc( (xmlChar *)"1.0" );
xmlCreateIntSubset( doc, (xmlChar *)"mapq3", NULL, (xmlChar *)"mapq3.dtd" );
doc->children->next = xmlNewDocNode( doc, NULL, (xmlChar *)"mapq3", NULL );
Map_XMLWrite( map, doc->children->next );
// xmlDocDumpMemory(doc, &buf, &len);
xmlDocDumpFormatMemory( doc, &buf, &len, 1 );
xmlFreeDoc( doc );
out->Write( buf, len );
xmlFree( buf );
}
bool CSpmXml::New(const QString& strRootNode, const QString& strDTDFile)
{
Destroy();
m_pXMLDoc = xmlNewDoc(BAD_CAST "1.0");
if (0 == m_pXMLDoc)
return false;
m_pCurNode = xmlNewNode(0, BAD_CAST strRootNode.toUtf8().data());
if (0 == m_pCurNode)
return false;
xmlDocSetRootElement(m_pXMLDoc, m_pCurNode);
if (strDTDFile.size())
xmlCreateIntSubset(m_pXMLDoc, BAD_CAST strRootNode.toUtf8().data(), NULL, BAD_CAST strDTDFile.toUtf8().data());
SetModified();
return true;
}
static xmlEntityPtr
xml_process_entities (void *ctxt, const xmlChar *name)
{
gchar *path;
xmlEntityPtr entity;
xmlEntityPtr found;
xmlChar *tmp;
static xmlDocPtr entities = NULL;
entity = xmlGetPredefinedEntity (name);
if (!entity) {
if (!entities) {
/* loading HTML entities from external DTD file */
entities = xmlNewDoc (BAD_CAST "1.0");
path = g_build_filename (g_get_user_data_dir (), PACKAGE, "/dtd/html.ent", NULL);
xmlCreateIntSubset (entities, BAD_CAST "HTML entities", NULL, BAD_CAST path);
g_free (path);
entities->extSubset = xmlParseDTD (entities->intSubset->ExternalID, entities->intSubset->SystemID);
}
if (NULL != (found = xmlGetDocEntity (entities, name))) {
/* returning as faked predefined entity... */
tmp = xmlStrdup (found->content);
tmp = BAD_CAST unhtmlize ((gchar*) tmp); /* arghh ... slow... */
entity = (xmlEntityPtr) g_new0 (xmlEntity, 1);
entity->type = XML_ENTITY_DECL;
entity->name = name;
entity->orig = NULL;
entity->content = tmp;
entity->length = g_utf8_strlen ((gchar*) tmp, -1);
entity->etype = XML_INTERNAL_PREDEFINED_ENTITY;
}
}
return entity;
}
void SC_ASIYA::save_xml(string report_xml, string TGT, string REF, string METRIC, const MetricScore &m) {
vector<vector<string> > idx = TESTBED::IDX[TGT];
/* cout << "-----------------idx-------------------" << endl;
for (int i = 0; i < idx.size(); ++i) {
//cout << "\tidx[" << i << "]" << endl;
for(int j = 0; j < idx[i].size(); ++j) {
cout << "\t\tidx[" << i << "][" << j << "]: " << idx[i][j] << endl;
}
cout << endl;
}
cout << "---------------------------------------" << endl;
for(int i = 0; i < doc_scores.size(); ++i) cout << "doc_scores[" << i << "]: " << doc_scores[i] << endl;
for(int i = 0; i < seg_scores.size(); ++i) cout << "seg_scores[" << i << "]: " << seg_scores[i] << endl;*/
int i = 1;
int n_docs, n_doc_segs;
n_docs = n_doc_segs = 0;
string DOC = "-1";
string document_id = "";
// -> STORE IQREPORT
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
xmlNodePtr root_node = xmlNewNode(NULL, BAD_CAST "REPORT");
xmlDocSetRootElement(doc, root_node);
string app_name = Common::appNAME;
boost::to_lower(app_name);
string doc_type = app_name + ".dtd []"; //"!DOCTYPE " + SC_ASIYA::ROOT_ELEMENT + " \"" + app_name +".dtd\" []";
xmlDtdPtr dtd = xmlCreateIntSubset(doc, BAD_CAST SC_FORMAT::ROOT_ELEMENT.c_str(), NULL, BAD_CAST doc_type.c_str());
/*
xmlNewProp(root_node, BAD_CAST "hyp", BAD_CAST TGT.c_str());
xmlNewProp(root_node, BAD_CAST "metric", BAD_CAST METRIC.c_str());
char buffer[50];
sprintf(buffer, "%d", n_docs);
xmlNewProp(root_node, BAD_CAST "n_docs", (const xmlChar *) buffer);
sprintf(buffer, "%d", seg_scores.size());
xmlNewProp(root_node, BAD_CAST "n_segments",(const xmlChar *) buffer);
xmlNewProp(root_node, BAD_CAST "ref", BAD_CAST REF.c_str());
//double x = Common::trunk_and_trim_number(sys_score, SC_ASIYA::FLOAT_LENGTH, SC_ASIYA::FLOAT_PRECISION);
double x = sys_score;
sprintf(buffer, "%f", x);
xmlNewProp(root_node, BAD_CAST "score", (const xmlChar *) buffer);
*/
//double x;
char buffer[256];
xmlNodePtr doc_node = xmlNewChild(root_node, NULL, BAD_CAST "DOC", NULL);
while (i < idx.size()) {
if (idx[i][0] != document_id) { // NEW DOCUMENT
if (DOC != "-1") {
//x = Common::trunk_and_trim_number(doc_scores[n_docs - 1], SC_ASIYA::FLOAT_LENGTH, SC_ASIYA::FLOAT_PRECISION);
//x = m.doc_scores[n_docs-1];
xmlNewProp(doc_node, BAD_CAST "id", BAD_CAST document_id.c_str());
sprintf(buffer, "%d", n_docs);
xmlNewProp(doc_node, BAD_CAST "n", (const xmlChar *) buffer);
sprintf(buffer, "%d", n_doc_segs);
xmlNewProp(doc_node, BAD_CAST "n_segments", (const xmlChar *) buffer);
//sprintf(buffer, "%.%df", x);
//trunk_and_trim_number(m.doc_scores[n_docs-1]);
xmlNewProp(doc_node, BAD_CAST "score", (const xmlChar *) trunk_and_trim_number(m.doc_scores[n_docs-1]).c_str());
doc_node = xmlNewChild(root_node, NULL, BAD_CAST "DOC", NULL);
}
DOC = document_id = idx[i][0];
n_docs++;
n_doc_segs = 0;
}
// CREATE A SEGMENT
//x = Common::trunk_and_trim_number(seg_scores[i - 1], SC_ASIYA::FLOAT_LENGTH, SC_ASIYA::FLOAT_PRECISION);
//x = m.seg_scores[i-1];
//sprintf(buffer, "%f", x);
xmlNodePtr seg_node = xmlNewChild(doc_node, NULL, BAD_CAST "S", (const xmlChar *) trunk_and_trim_number(m.seg_scores[i-1]).c_str());
sprintf(buffer, "%d", i);
xmlNewProp(seg_node, BAD_CAST "n", (const xmlChar *) buffer);
n_doc_segs++;
i++;
}
// PASTE LAST DOC (if any)
if (DOC != "-1") {
//x = Common::trunk_and_trim_number(doc_scores[n_docs - 1], SC_ASIYA::FLOAT_LENGTH, SC_ASIYA::FLOAT_PRECISION);
//x = m.doc_scores[n_docs-1];
//doc_node = xmlNewChild(root_node, NULL, BAD_CAST "DOC", NULL);
xmlNewProp(doc_node, BAD_CAST "id", BAD_CAST document_id.c_str());
sprintf(buffer, "%d", n_docs);
xmlNewProp(doc_node, BAD_CAST "n", (const xmlChar *) buffer);
sprintf(buffer, "%d", n_doc_segs);
xmlNewProp(doc_node, BAD_CAST "n_segments", (const xmlChar *) buffer);
//sprintf(buffer, "%f", x);
xmlNewProp(doc_node, BAD_CAST "score", (const xmlChar *) trunk_and_trim_number(m.doc_scores[n_docs-1]).c_str());
}
xmlNewProp(root_node, BAD_CAST "hyp", BAD_CAST TGT.c_str());
xmlNewProp(root_node, BAD_CAST "metric", BAD_CAST METRIC.c_str());
//char buffer[50];
sprintf(buffer, "%d", n_docs);
xmlNewProp(root_node, BAD_CAST "n_docs", (const xmlChar *) buffer);
sprintf(buffer, "%d", (int)m.seg_scores.size());
xmlNewProp(root_node, BAD_CAST "n_segments",(const xmlChar *) buffer);
xmlNewProp(root_node, BAD_CAST "ref", BAD_CAST REF.c_str());
//double x = Common::trunk_and_trim_number(sys_score, SC_ASIYA::FLOAT_LENGTH, SC_ASIYA::FLOAT_PRECISION);
//x = m.sys_score;
//sprintf(buffer, "%f", x);
xmlNewProp(root_node, BAD_CAST "score", (const xmlChar *) trunk_and_trim_number(m.sys_score).c_str());
xmlSaveFormatFileEnc(report_xml.c_str(), doc, "UTF-8", 1);
xmlFreeDoc(doc);
xmlCleanupParser();
}
/*
* call-seq:
* XML::Dtd.new("DTD string") -> dtd
* XML::Dtd.new("public", "system") -> dtd
* XML::Dtd.new("name", "public", "system", document) -> external subset dtd
* XML::Dtd.new("name", "public", "system", document, false) -> internal subset dtd
* XML::Dtd.new("name", "public", "system", document, true) -> internal subset dtd
*
* Create a new Dtd from the specified public and system
* identifiers.
*/
static VALUE rxml_dtd_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE external, system, dtd_string;
xmlParserInputBufferPtr buffer;
xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
xmlChar *new_string;
xmlDtdPtr xdtd;
// 1 argument -- string --> parsujeme jako dtd
// 2 arguments -- public, system --> bude se hledat
// 3 arguments -- public, system, name --> creates an external subset (any parameter may be nil)
// 4 arguments -- public, system, name, doc --> creates an external subset (any parameter may be nil)
// 5 arguments -- public, system, name, doc, true --> creates an internal subset (all but last parameter may be nil)
switch (argc)
{
case 3:
case 4:
case 5: {
VALUE name, doc, internal;
const xmlChar *xname = NULL, *xpublic = NULL, *xsystem = NULL;
xmlDocPtr xdoc = NULL;
rb_scan_args(argc, argv, "32", &external, &system, &name, &doc, &internal);
if (external != Qnil) {
Check_Type(external, T_STRING);
xpublic = (const xmlChar*) StringValuePtr(external);
}
if (system != Qnil) {
Check_Type(system, T_STRING);
xsystem = (const xmlChar*) StringValuePtr(system);
}
if (name != Qnil) {
Check_Type(name, T_STRING);
xname = (const xmlChar*) StringValuePtr(name);
}
if (doc != Qnil) {
if (rb_obj_is_kind_of(doc, cXMLDocument) == Qfalse)
rb_raise(rb_eTypeError, "Must pass an XML::Document object");
Data_Get_Struct(doc, xmlDoc, xdoc);
}
if (internal == Qnil || internal == Qfalse)
xdtd = xmlNewDtd(xdoc, xname, xpublic, xsystem);
else
xdtd = xmlCreateIntSubset(xdoc, xname, xpublic, xsystem);
if (xdtd == NULL)
rxml_raise(&xmlLastError);
/* Document will free this dtd now. */
RDATA(self)->dfree = NULL;
DATA_PTR(self) = xdtd;
xmlSetTreeDoc((xmlNodePtr) xdtd, xdoc);
}
break;
case 2:
rb_scan_args(argc, argv, "20", &external, &system);
Check_Type(external, T_STRING);
Check_Type(system, T_STRING);
xdtd = xmlParseDTD((xmlChar*) StringValuePtr(external),
(xmlChar*) StringValuePtr(system));
if (xdtd == NULL)
rxml_raise(&xmlLastError);
DATA_PTR(self) = xdtd;
xmlSetTreeDoc((xmlNodePtr) xdtd, NULL);
break;
case 1:
rb_scan_args(argc, argv, "10", &dtd_string);
Check_Type(dtd_string, T_STRING);
/* Note that buffer is freed by xmlParserInputBufferPush*/
buffer = xmlAllocParserInputBuffer(enc);
new_string = xmlStrdup((xmlChar*) StringValuePtr(dtd_string));
xmlParserInputBufferPush(buffer, xmlStrlen(new_string),
(const char*) new_string);
xdtd = xmlIOParseDTD(NULL, buffer, enc);
if (xdtd == NULL)
rxml_raise(&xmlLastError);
xmlFree(new_string);
DATA_PTR(self) = xdtd;
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments");
}
return self;
}
/* A simple example how to create DOM. Libxml2 automagically
* allocates the necessary amount of memory to it.
*/
int
main(int argc, char **argv)
{
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL, node = NULL, node1 = NULL;/* node pointers */
xmlDtdPtr dtd = NULL; /* DTD pointer */
char buff[256];
int i, j;
LIBXML_TEST_VERSION;
/*
* Creates a new document, a node and set it as a root node
*/
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "root");
xmlDocSetRootElement(doc, root_node);
/*
* Creates a DTD declaration. Isn't mandatory.
*/
dtd = xmlCreateIntSubset(doc, BAD_CAST "root", NULL, BAD_CAST "tree2.dtd");
/*
* xmlNewChild() creates a new node, which is "attached" as child node
* of root_node node.
*/
xmlNewChild(root_node, NULL, BAD_CAST "node1",
BAD_CAST "content of node 1");
/*
* The same as above, but the new child node doesn't have a content
*/
xmlNewChild(root_node, NULL, BAD_CAST "node2", NULL);
/*
* xmlNewProp() creates attributes, which is "attached" to an node.
* It returns xmlAttrPtr, which isn't used here.
*/
node =
xmlNewChild(root_node, NULL, BAD_CAST "node3",
BAD_CAST "this node has attributes");
xmlNewProp(node, BAD_CAST "attribute", BAD_CAST "yes");
xmlNewProp(node, BAD_CAST "foo", BAD_CAST "bar");
/*
* Here goes another way to create nodes. xmlNewNode() and xmlNewText
* creates a node and a text node separately. They are "attached"
* by xmlAddChild()
*/
node = xmlNewNode(NULL, BAD_CAST "node4");
node1 = xmlNewText(BAD_CAST
"other way to create content (which is also a node)");
xmlAddChild(node, node1);
xmlAddChild(root_node, node);
/*
* A simple loop that "automates" nodes creation
*/
for (i = 5; i < 7; i++) {
sprintf(buff, "node%d", i);
node = xmlNewChild(root_node, NULL, BAD_CAST buff, NULL);
for (j = 1; j < 4; j++) {
sprintf(buff, "node%d%d", i, j);
node1 = xmlNewChild(node, NULL, BAD_CAST buff, NULL);
xmlNewProp(node1, BAD_CAST "odd", BAD_CAST((j % 2) ? "no" : "yes"));
}
}
/*
* Dumping document to stdio or file
*/
xmlSaveFormatFileEnc(argc > 1 ? argv[1] : "-", doc, "UTF-8", 1);
/*free the document */
xmlFreeDoc(doc);
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
return(0);
}
static DiaSvgRenderer *
new_svg_renderer(DiagramData *data, const char *filename)
{
DiaSvgRenderer *renderer;
SvgRenderer *svg_renderer;
FILE *file;
gchar buf[512];
time_t time_now;
Rectangle *extent;
const char *name;
xmlDtdPtr dtd;
file = g_fopen(filename, "w");
if (file==NULL) {
message_error(_("Can't open output file %s: %s\n"),
dia_message_filename(filename), strerror(errno));
return NULL;
}
fclose(file);
/* we need access to our base object */
renderer = DIA_SVG_RENDERER (g_object_new(SVG_TYPE_RENDERER, NULL));
renderer->filename = g_strdup(filename);
renderer->dash_length = 1.0;
renderer->dot_length = 0.2;
renderer->saved_line_style = LINESTYLE_SOLID;
/* apparently most svg readers don't like small values, especially not in the viewBox attribute */
renderer->scale = 20.0;
/* set up the root node */
renderer->doc = xmlNewDoc((const xmlChar *)"1.0");
renderer->doc->encoding = xmlStrdup((const xmlChar *)"UTF-8");
renderer->doc->standalone = FALSE;
dtd = xmlCreateIntSubset(renderer->doc, (const xmlChar *)"svg",
(const xmlChar *)"-//W3C//DTD SVG 1.0//EN",
(const xmlChar *)"http://www.w3.org/TR/2001/PR-SVG-20010719/DTD/svg10.dtd");
xmlAddChild((xmlNodePtr) renderer->doc, (xmlNodePtr) dtd);
renderer->root = xmlNewDocNode(renderer->doc, NULL, (const xmlChar *)"svg", NULL);
xmlAddSibling(renderer->doc->children, (xmlNodePtr) renderer->root);
/* add namespaces to make strict parsers happy, e.g. Firefox */
svg_renderer = SVG_RENDERER (renderer);
/* set the extents of the SVG document */
extent = &data->extents;
g_snprintf(buf, sizeof(buf), "%dcm",
(int)ceil((extent->right - extent->left)));
xmlSetProp(renderer->root, (const xmlChar *)"width", (xmlChar *) buf);
g_snprintf(buf, sizeof(buf), "%dcm",
(int)ceil((extent->bottom - extent->top)));
xmlSetProp(renderer->root, (const xmlChar *)"height", (xmlChar *) buf);
g_snprintf(buf, sizeof(buf), "%d %d %d %d",
(int)floor(extent->left * renderer->scale), (int)floor(extent->top * renderer->scale),
(int)ceil((extent->right - extent->left) * renderer->scale),
(int)ceil((extent->bottom - extent->top) * renderer->scale));
xmlSetProp(renderer->root, (const xmlChar *)"viewBox", (xmlChar *) buf);
xmlSetProp(renderer->root,(const xmlChar *)"xmlns", (const xmlChar *)"http://www.w3.org/2000/svg");
xmlSetProp(renderer->root,(const xmlChar *)"xmlns", (const xmlChar *)"http://www.w3.org/2000/svg");
xmlSetProp(renderer->root,(const xmlChar *)"xmlns:xlink", (const xmlChar *)"http://www.w3.org/1999/xlink");
time_now = time(NULL);
name = g_get_user_name();
#if 0
/* some comments at the top of the file ... */
xmlAddChild(renderer->root, xmlNewText("\n"));
xmlAddChild(renderer->root, xmlNewComment("Dia-Version: "VERSION));
xmlAddChild(renderer->root, xmlNewText("\n"));
g_snprintf(buf, sizeof(buf), "File: %s", dia->filename);
xmlAddChild(renderer->root, xmlNewComment(buf));
xmlAddChild(renderer->root, xmlNewText("\n"));
g_snprintf(buf, sizeof(buf), "Date: %s", ctime(&time_now));
buf[strlen(buf)-1] = '\0'; /* remove the trailing new line */
xmlAddChild(renderer->root, xmlNewComment(buf));
xmlAddChild(renderer->root, xmlNewText("\n"));
g_snprintf(buf, sizeof(buf), "For: %s", name);
xmlAddChild(renderer->root, xmlNewComment(buf));
xmlAddChild(renderer->root, xmlNewText("\n\n"));
xmlNewChild(renderer->root, NULL, "title", dia->filename);
#endif
return renderer;
}
void mtx_gauge_face_export_xml(MtxGaugeFace * gauge, const gchar * filename)
{
guint i = 0;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL;/* node pointers */
xmlDtdPtr dtd = NULL; /* DTD pointer */
MtxDispatchHelper *helper = NULL;
MtxXMLFuncs * xml_funcs = NULL;
MtxGaugeFacePrivate *priv = NULL;
g_return_if_fail(gauge);
g_return_if_fail(filename);
priv = MTX_GAUGE_FACE_GET_PRIVATE(gauge);
g_return_if_fail(priv);
LIBXML_TEST_VERSION;
/*
* Creates a new document, a node and set it as a root node
*/
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "gauge");
xmlDocSetRootElement(doc, root_node);
/*
* Creates a DTD declaration. Isn't mandatory.
*/
dtd = xmlCreateIntSubset(doc, BAD_CAST "gauge", NULL, BAD_CAST "mtxgauge.dtd");
/* Create a helper struct o bind data to for to
* trim up the XML export functions.
*/
helper = g_new0(MtxDispatchHelper, 1);
helper->gauge = gauge;
helper->root_node = root_node;
/** For each element, get the varname, the pointer to the memory
* where the data is stored in the current gauge structure, and call
* the export function defined in the xml_funcs struct passing in the
* helper struct so that the generic export functions can get the
* key names right and the memory addresses right. It looks confusing
* but it works great. See gauge-xml.h for the static struct binding
* keynames to import/export generic handler functions */
for (i=0;i<priv->xmlfunc_array->len;i++)
{
xml_funcs = g_array_index(priv->xmlfunc_array,MtxXMLFuncs *, i);
if (!xml_funcs)
continue;
helper->element_name = xml_funcs->varname;
helper->src = (gpointer)g_object_get_data(G_OBJECT(gauge),xml_funcs->varname);
if (xml_funcs->export_func)
xml_funcs->export_func(helper);
}
g_free(helper);
/*
*/
xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
/*free the document */
xmlFreeDoc(doc);
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
if (priv->xml_filename)
g_free(priv->xml_filename);
priv->xml_filename = g_strdup(filename);
}
void mate_wp_xml_save_list (AppearanceData *data) {
xmlDoc * wplist;
xmlNode * root, * wallpaper, * item;
GSList * list = NULL;
gchar * wpfile;
g_hash_table_foreach (data->wp_hash,
(GHFunc) mate_wp_list_flatten, &list);
g_hash_table_destroy (data->wp_hash);
list = g_slist_reverse (list);
wpfile = g_build_filename (g_get_home_dir (),
"/.mate2",
"backgrounds.xml",
NULL);
xmlKeepBlanksDefault (0);
wplist = xmlNewDoc ((xmlChar *)"1.0");
xmlCreateIntSubset (wplist, (xmlChar *)"wallpapers", NULL, (xmlChar *)"mate-wp-list.dtd");
root = xmlNewNode (NULL, (xmlChar *)"wallpapers");
xmlDocSetRootElement (wplist, root);
while (list != NULL) {
MateWPItem * wpitem = list->data;
const char * none = "(none)";
gchar * filename;
const gchar * scale, * shade;
gchar * pcolor, * scolor;
if (!strcmp (wpitem->filename, none) ||
(g_utf8_validate (wpitem->filename, -1, NULL) &&
g_file_test (wpitem->filename, G_FILE_TEST_EXISTS)))
filename = g_strdup (wpitem->filename);
else
filename = g_filename_to_utf8 (wpitem->filename, -1, NULL, NULL, NULL);
pcolor = gdk_color_to_string (wpitem->pcolor);
scolor = gdk_color_to_string (wpitem->scolor);
scale = wp_item_option_to_string (wpitem->options);
shade = wp_item_shading_to_string (wpitem->shade_type);
wallpaper = xmlNewChild (root, NULL, (xmlChar *)"wallpaper", NULL);
mate_wp_xml_set_bool (wallpaper, (xmlChar *)"deleted", wpitem->deleted);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"name", (xmlChar *)wpitem->name);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"filename", (xmlChar *)filename);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"options", (xmlChar *)scale);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"shade_type", (xmlChar *)shade);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"pcolor", (xmlChar *)pcolor);
item = xmlNewTextChild (wallpaper, NULL, (xmlChar *)"scolor", (xmlChar *)scolor);
g_free (pcolor);
g_free (scolor);
g_free (filename);
list = g_slist_delete_link (list, list);
mate_wp_item_free (wpitem);
}
xmlSaveFormatFile (wpfile, wplist, 1);
xmlFreeDoc (wplist);
g_free (wpfile);
}
void export_dash_xml(gchar * filename)
{
GtkWidget *dash = NULL;
GList *children = NULL;
GtkFixedChild *child = NULL;
gchar * tmpbuf = NULL;
guint i = 0;
xmlDocPtr doc = NULL; /* document pointer */
xmlNodePtr root_node = NULL;/* node pointers */
xmlNodePtr node = NULL;/* node pointers */
xmlDtdPtr dtd = NULL; /* DTD pointer */
GtkTreeIter parent;
GtkTreeIter iter;
GtkTreeModel *model = NULL;
gboolean state = FALSE;
gchar * iname = NULL;
gchar ** vector = NULL;
GtkAllocation allocation;
g_return_if_fail(filename);
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL,BAD_CAST "dashboard");
xmlDocSetRootElement(doc,root_node);
/*
* Creates a DTD declaration. Isn't mandatory.
*/
dtd = xmlCreateIntSubset(doc, BAD_CAST "dashboard", NULL, BAD_CAST "mtxdashboard.dtd");
dash = GTK_WIDGET(gtk_builder_get_object(toplevel,"dashboard"));
gtk_widget_get_allocation(dash, &allocation);
node = xmlNewChild(root_node,NULL,BAD_CAST "dash_geometry", NULL);
generic_xml_gint_export(node,"width",&allocation.width);
generic_xml_gint_export(node,"height",&allocation.height);
children = GTK_FIXED(dash)->children;
for(i=0;i<g_list_length(GTK_FIXED(dash)->children);i++)
{
child = g_list_nth_data(GTK_FIXED(dash)->children,i);
node = xmlNewChild(root_node,NULL,BAD_CAST "gauge", NULL);
gtk_widget_get_allocation(child->widget, &allocation);
generic_xml_gint_export(node,"width",&allocation.width);
generic_xml_gint_export(node,"height",&allocation.height);
generic_xml_gint_export(node,"x_offset",&child->x);
generic_xml_gint_export(node,"y_offset",&child->y);
tmpbuf = g_strrstr(mtx_gauge_face_get_xml_filename(MTX_GAUGE_FACE(child->widget)),"Gauges");
vector = g_strsplit(tmpbuf,PSEP,2);
generic_xml_gchar_export(node,"gauge_xml_name",&vector[1]);
g_strfreev(vector);
state = gtk_combo_box_get_active_iter(GTK_COMBO_BOX(OBJ_GET((child->widget),"combo")),&iter);
model = gtk_combo_box_get_model(GTK_COMBO_BOX(OBJ_GET((child->widget),"combo")));
gtk_tree_model_get(model,&iter,DATASOURCE_COL,&iname,-1);
generic_xml_gchar_export(node,"datasource",&iname);
}
xmlSaveFormatFileEnc(filename, doc, "utf-8", 1);
/*free the document */
xmlFreeDoc(doc);
/*
*Free the global variables that may
*have been allocated by the parser.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
return ;
}
int main(int argc, const char **argv)
{
struct ptbf *ret;
int debugging = 0;
xmlNodePtr root_node;
xmlDocPtr doc;
xmlNodePtr comment;
xmlNodePtr fonts;
xmlDtdPtr dtd;
int c, i, musicxml = 0;
int version = 0;
const char *input = NULL;
char *output = NULL;
poptContext pc;
int quiet = 0;
int format_output = 1;
struct poptOption options[] = {
POPT_AUTOHELP
{"debug", 'd', POPT_ARG_NONE, &debugging, 0, "Turn on debugging output" },
{"outputfile", 'o', POPT_ARG_STRING, &output, 0, "Write to specified file", "FILE" },
{"musicxml", 'm', POPT_ARG_NONE, &musicxml, 'm', "Output MusicXML" },
{"no-format", 'f', POPT_ARG_NONE, &format_output, 0, "Don't format output" },
{"quiet", 'q', POPT_ARG_NONE, &quiet, 1, "Be quiet (no output to stderr)" },
{"version", 'v', POPT_ARG_NONE, &version, 'v', "Show version information" },
POPT_TABLEEND
};
pc = poptGetContext(argv[0], argc, argv, options, 0);
poptSetOtherOptionHelp(pc, "file.ptb");
while((c = poptGetNextOpt(pc)) >= 0) {
switch(c) {
case 'v':
printf("ptb2xml Version "PACKAGE_VERSION"\n");
printf("(C) 2004-2006 Jelmer Vernooij <*****@*****.**>\n");
exit(0);
break;
}
}
ptb_set_debug(debugging);
if(!poptPeekArg(pc)) {
poptPrintUsage(pc, stderr, 0);
return -1;
}
input = poptGetArg(pc);
if (!quiet) fprintf(stderr, "Parsing %s...\n", input);
ret = ptb_read_file(input);
if(!ret) {
perror("Read error: ");
return -1;
}
if(!output) {
int baselength = strlen(input);
if (!strcmp(input + strlen(input) - 4, ".ptb")) {
baselength -= 4;
}
output = malloc(baselength + 6);
strncpy(output, input, baselength);
strcpy(output + baselength, ".xml");
}
if (!quiet) fprintf(stderr, "Building DOM tree...\n");
doc = xmlNewDoc(BAD_CAST "1.0");
root_node = xmlNewNode(NULL, BAD_CAST "powertab");
dtd = xmlCreateIntSubset(doc, "powertab", NULL, DTD_URL);
xmlDocSetRootElement(doc, root_node);
comment = xmlNewComment("\nGenerated by ptb2xml, part of ptabtools. \n"
"(C) 2004-2006 by Jelmer Vernooij <*****@*****.**>\n"
"See http://jelmer.vernstok.nl/oss/ptabtools/ for details\n");
xmlAddChild(root_node, comment);
xmlAddChild(root_node, xml_write_header(&ret->hdr));
for(i = 0; i < 2; i++) {
xmlAddChild(root_node, xml_write_instrument(ret, i));
}
fonts = xmlNewNode( NULL, "fonts"); xmlAddChild(root_node, fonts);
xmlAddChild(fonts, xml_write_font("default_font", &ret->default_font));
xmlAddChild(fonts, xml_write_font("chord_name_font", &ret->chord_name_font));
xmlAddChild(fonts, xml_write_font("tablature_font", &ret->tablature_font));
if (musicxml)
{
if (!quiet) fprintf(stderr, "Converting to MusicXML...\n");
#ifdef HAVE_XSLT
xsltStylesheetPtr stylesheet = xsltParseStylesheetFile(MUSICXMLSTYLESHEET);
doc = xsltApplyStylesheet(stylesheet, doc, NULL);
xsltFreeStylesheet(stylesheet);
#else
fprintf(stderr, "Conversion to MusicXML not possible in this version: libxslt not compiled in\n");
return -1;
#endif
}
if (!quiet) fprintf(stderr, "Writing output to %s...\n", output);
if (xmlSaveFormatFile(output, doc, format_output) < 0) {
return -1;
}
xmlFreeDoc(doc);
xmlCleanupParser();
return 0;
}
void Document::SetInternalSubset(const string &name, const string &externalID, const string &systemID)
{
xmlDtd * dtd = xmlCreateIntSubset(xml(), name.utf8(), externalID.utf8(), systemID.utf8());
if ( dtd != nullptr && dtd->_private == nullptr )
(void) Wrapped<DTD, _xmlDtd>(dtd);
}
