src/xml/repr-io.cpp

   1 #define __SP_REPR_IO_C__
   2
   3 /*
   4  * Dirty DOM-like  tree
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 1999-2002 Lauris Kaplinski
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #ifdef HAVE_CONFIG_H
  16 # include <config.h>
  17 #endif
  18
  19
  20
  21 #include "xml/repr.h"
  22 #include "xml/attribute-record.h"
  23
  24 #include "io/sys.h"
  25 #include "io/uristream.h"
  26 #include "io/gzipstream.h"
  27
  28
  29 using Inkscape::IO::Writer;
  30 using Inkscape::Util::List;
  31 using Inkscape::Util::cons;
  32 using Inkscape::XML::Document;
  33 using Inkscape::XML::Node;
  34 using Inkscape::XML::AttributeRecord;
  35
  36 static Document *sp_repr_do_read (xmlDocPtr doc, const gchar *default_ns);
  37 static Node *sp_repr_svg_read_node (xmlNodePtr node, const gchar *default_ns, GHashTable *prefix_map);
  38 static gint sp_repr_qualified_name (gchar *p, gint len, xmlNsPtr ns, const xmlChar *name, const gchar *default_ns, GHashTable *prefix_map);
  39 static void sp_repr_write_stream_root_element (Node *repr, Writer &out, gboolean add_whitespace, gchar const *default_ns);
  40 static void sp_repr_write_stream (Node *repr, Writer &out, gint indent_level, gboolean add_whitespace, Glib::QueryQuark elide_prefix);
  41 static void sp_repr_write_stream_element (Node *repr, Writer &out, gint indent_level, gboolean add_whitespace, Glib::QueryQuark elide_prefix, List<AttributeRecord const> attributes);
  42
  43 #ifdef HAVE_LIBWMF
  44 static xmlDocPtr sp_wmf_convert (const char * file_name);
  45 static char * sp_wmf_image_name (void * context);
  46 #endif /* HAVE_LIBWMF */
  47
  48
  49 class XmlSource
  50 {
  51 public:
  52     XmlSource()
  53         : filename(0),
  54           fp(0),
  55           first(false),
  56           dummy("x"),
  57           instr(0),
  58           gzin(0)
  59     {
  60     }
  61     virtual ~XmlSource()
  62     {
  63         close();
  64     }
  65
  66     void setFile( char const * filename );
  67
  68     static int readCb( void * context, char * buffer, int len);
  69     static int closeCb(void * context);
  70
  71
  72     int read( char * buffer, int len );
  73     int close();
  74 private:
  75     const char* filename;
  76     FILE* fp;
  77     bool first;
  78     Inkscape::URI dummy;
  79     Inkscape::IO::UriInputStream* instr;
  80     Inkscape::IO::GzipInputStream* gzin;
  81 };
  82
  83 void XmlSource::setFile( char const * filename ) {
  84     this->filename = filename;
  85     fp = Inkscape::IO::fopen_utf8name(filename, "r");
  86     first = true;
  87 }
  88
  89
  90 int XmlSource::readCb( void * context, char * buffer, int len )
  91 {
  92     int retVal = -1;
  93     if ( context ) {
  94         XmlSource* self = static_cast<XmlSource*>(context);
  95         retVal = self->read( buffer, len );
  96     }
  97     return retVal;
  98 }
  99
 100 int XmlSource::closeCb(void * context)
 101 {
 102     if ( context ) {
 103         XmlSource* self = static_cast<XmlSource*>(context);
 104         self->close();
 105     }
 106     return 0;
 107 }
 108
 109 int XmlSource::read( char *buffer, int len )
 110 {
 111     int retVal = 0;
 112     size_t got = 0;
 113
 114     if ( first ) {
 115         first = false;
 116         char tmp[] = {0,0};
 117         size_t some = fread( tmp, 1, 2, fp );
 118
 119         if ( (some >= 2) && (tmp[0] == 0x1f) && ((unsigned char)(tmp[1]) == 0x8b) ) {
 120             //g_message(" the file being read is gzip'd. extract it");
 121             fclose(fp);
 122             fp = 0;
 123             fp = Inkscape::IO::fopen_utf8name(filename, "r");
 124             instr = new Inkscape::IO::UriInputStream(fp, dummy);
 125             gzin = new Inkscape::IO::GzipInputStream(*instr);
 126             int single = 0;
 127             while ( (int)got < len && single >= 0 )
 128             {
 129                 single = gzin->get();
 130                 if ( single >= 0 ) {
 131                     buffer[got++] = 0x0ff & single;
 132                 } else {
 133                     break;
 134                 }
 135             }
 136             //g_message(" extracted %d bytes this pass", got );
 137         } else {
 138             memcpy( buffer, tmp, some );
 139             got = some;
 140         }
 141     } else if ( gzin ) {
 142         int single = 0;
 143         while ( (int)got < len && single >= 0 )
 144         {
 145             single = gzin->get();
 146             if ( single >= 0 ) {
 147                 buffer[got++] = 0x0ff & single;
 148             } else {
 149                 break;
 150             }
 151         }
 152         //g_message(" extracted %d bytes this pass  b", got );
 153     } else {
 154         got = fread( buffer, 1, len, fp );
 155     }
 156
 157     if ( feof(fp) ) {
 158         retVal = got;
 159     }
 160     else if ( ferror(fp) ) {
 161         retVal = -1;
 162     }
 163     else {
 164         retVal = got;
 165     }
 166
 167     return retVal;
 168 }
 169
 170 int XmlSource::close()
 171 {
 172     if ( gzin ) {
 173         gzin->close();
 174         delete gzin;
 175         gzin = 0;
 176     }
 177     if ( instr ) {
 178         instr->close();
 179         fp = 0;
 180         delete instr;
 181         instr = 0;
 182     }
 183     if ( fp ) {
 184         fclose(fp);
 185         fp = 0;
 186     }
 187     return 0;
 188 }
 189
 190 /**
 191  * Reads XML from a file, including WMF files, and returns the Document.
 192  * The default namespace can also be specified, if desired.
 193  */
 194 Document *
 195 sp_repr_read_file (const gchar * filename, const gchar *default_ns)
 196 {
 197     xmlDocPtr doc = 0;
 198     Document * rdoc = 0;
 199
 200     xmlSubstituteEntitiesDefault(1);
 201
 202     g_return_val_if_fail (filename != NULL, NULL);
 203     g_return_val_if_fail (Inkscape::IO::file_test( filename, G_FILE_TEST_EXISTS ), NULL);
 204
 205     // TODO: bulia, please look over
 206     gsize bytesRead = 0;
 207     gsize bytesWritten = 0;
 208     GError* error = NULL;
 209     // TODO: need to replace with our own fopen and reading
 210     gchar* localFilename = g_filename_from_utf8 ( filename,
 211                                  -1,  &bytesRead,  &bytesWritten, &error);
 212     g_return_val_if_fail( localFilename != NULL, NULL );
 213
 214     Inkscape::IO::dump_fopen_call( filename, "N" );
 215
 216     XmlSource src;
 217     src.setFile(filename);
 218
 219     xmlDocPtr doubleDoc = xmlReadIO( XmlSource::readCb,
 220                                      XmlSource::closeCb,
 221                                      &src,
 222                                      localFilename,
 223                                      NULL, //"UTF-8",
 224                                      XML_PARSE_NOENT );
 225
 226
 227 #ifdef HAVE_LIBWMF
 228     if (strlen (localFilename) > 4) {
 229         if ( (strcmp (localFilename + strlen (localFilename) - 4,".wmf") == 0)
 230           || (strcmp (localFilename + strlen (localFilename) - 4,".WMF") == 0))
 231             doc = sp_wmf_convert (localFilename);
 232         else
 233             doc = xmlParseFile (localFilename);
 234     }
 235     else {
 236         doc = xmlParseFile (localFilename);
 237     }
 238 #else /* !HAVE_LIBWMF */
 239     //doc = xmlParseFile (localFilename);
 240 #endif /* !HAVE_LIBWMF */
 241
 242     //rdoc = sp_repr_do_read (doc, default_ns);
 243     rdoc = sp_repr_do_read (doubleDoc, default_ns);
 244     if (doc)
 245         xmlFreeDoc (doc);
 246
 247     if ( localFilename != NULL )
 248         g_free (localFilename);
 249
 250     if ( doubleDoc != NULL )
 251     {
 252         xmlFreeDoc( doubleDoc );
 253     }
 254
 255     return rdoc;
 256 }
 257
 258 /**
 259  * Reads and parses XML from a buffer, returning it as an Document
 260  */
 261 Document *
 262 sp_repr_read_mem (const gchar * buffer, gint length, const gchar *default_ns)
 263 {
 264     xmlDocPtr doc;
 265     Document * rdoc;
 266
 267     xmlSubstituteEntitiesDefault(1);
 268
 269     g_return_val_if_fail (buffer != NULL, NULL);
 270
 271     doc = xmlParseMemory ((gchar *) buffer, length);
 272
 273     rdoc = sp_repr_do_read (doc, default_ns);
 274     if (doc)
 275         xmlFreeDoc (doc);
 276     return rdoc;
 277 }
 278
 279 namespace Inkscape {
 280
 281 struct compare_quark_ids {
 282     bool operator()(Glib::QueryQuark const &a, Glib::QueryQuark const &b) const {
 283         return a.id() < b.id();
 284     }
 285 };
 286
 287 }
 288
 289 namespace {
 290
 291 typedef std::map<Glib::QueryQuark, Glib::QueryQuark, Inkscape::compare_quark_ids> PrefixMap;
 292
 293 Glib::QueryQuark qname_prefix(Glib::QueryQuark qname) {
 294     static PrefixMap prefix_map;
 295     PrefixMap::iterator iter = prefix_map.find(qname);
 296     if ( iter != prefix_map.end() ) {
 297         return (*iter).second;
 298     } else {
 299         gchar const *name_string=g_quark_to_string(qname);
 300         gchar const *prefix_end=strchr(name_string, ':');
 301         if (prefix_end) {
 302             Glib::Quark prefix=Glib::ustring(name_string, prefix_end);
 303             prefix_map.insert(PrefixMap::value_type(qname, prefix));
 304             return prefix;
 305         } else {
 306             return GQuark(0);
 307         }
 308     }
 309 }
 310
 311 }
 312
 313 namespace {
 314
 315 void promote_to_svg_namespace(Node *repr) {
 316     if ( repr->type() == Inkscape::XML::ELEMENT_NODE ) {
 317         GQuark code = repr->code();
 318         if (!qname_prefix(code).id()) {
 319             gchar *svg_name = g_strconcat("svg:", g_quark_to_string(code), NULL);
 320             repr->setCodeUnsafe(g_quark_from_string(svg_name));
 321             g_free(svg_name);
 322         }
 323         for ( Node *child = sp_repr_children(repr) ; child ; child = sp_repr_next(child) ) {
 324             promote_to_svg_namespace(child);
 325         }
 326     }
 327 }
 328
 329 }
 330
 331 /**
 332  * Reads in a XML file to create a Document
 333  */
 334 Document *
 335 sp_repr_do_read (xmlDocPtr doc, const gchar *default_ns)
 336 {
 337     if (doc == NULL) return NULL;
 338     xmlNodePtr node=xmlDocGetRootElement (doc);
 339     if (node == NULL) return NULL;
 340
 341     GHashTable * prefix_map;
 342     prefix_map = g_hash_table_new (g_str_hash, g_str_equal);
 343
 344     GSList *reprs=NULL;
 345     Node *root=NULL;
 346
 347     for ( node = doc->children ; node != NULL ; node = node->next ) {
 348         if (node->type == XML_ELEMENT_NODE) {
 349             Node *repr=sp_repr_svg_read_node (node, default_ns, prefix_map);
 350             reprs = g_slist_append(reprs, repr);
 351
 352             if (!root) {
 353                 root = repr;
 354             } else {
 355                 root = NULL;
 356                 break;
 357             }
 358         } else if ( node->type == XML_COMMENT_NODE ) {
 359             Node *comment=sp_repr_svg_read_node(node, default_ns, prefix_map);
 360             reprs = g_slist_append(reprs, comment);
 361         }
 362     }
 363
 364     Document *rdoc=NULL;
 365
 366     if (root != NULL) {
 367         /* promote elements of SVG documents that don't use namespaces
 368          * into the SVG namespace */
 369         if ( default_ns && !strcmp(default_ns, SP_SVG_NS_URI)
 370              && !strcmp(root->name(), "svg") )
 371         {
 372             promote_to_svg_namespace(root);
 373         }
 374
 375         rdoc = sp_repr_document_new_list(reprs);
 376     }
 377
 378     for ( GSList *iter = reprs ; iter ; iter = iter->next ) {
 379         Node *repr=(Node *)iter->data;
 380         Inkscape::GC::release(repr);
 381     }
 382     g_slist_free(reprs);
 383
 384     g_hash_table_destroy (prefix_map);
 385
 386     return rdoc;
 387 }
 388
 389 gint
 390 sp_repr_qualified_name (gchar *p, gint len, xmlNsPtr ns, const xmlChar *name, const gchar *default_ns, GHashTable *prefix_map)
 391 {
 392     const xmlChar *prefix;
 393     if ( ns && ns->href ) {
 394         prefix = (xmlChar*)sp_xml_ns_uri_prefix ((gchar*)ns->href, (char*)ns->prefix);
 395         g_hash_table_insert (prefix_map, (gpointer)prefix, (gpointer)ns->href);
 396     } else {
 397         prefix = NULL;
 398     }
 399
 400     if (prefix)
 401         return g_snprintf (p, len, "%s:%s", (gchar*)prefix, name);
 402     else
 403         return g_snprintf (p, len, "%s", name);
 404 }
 405
 406 static Node *
 407 sp_repr_svg_read_node (xmlNodePtr node, const gchar *default_ns, GHashTable *prefix_map)
 408 {
 409     Node *repr, *crepr;
 410     xmlAttrPtr prop;
 411     xmlNodePtr child;
 412     gchar c[256];
 413
 414     if (node->type == XML_TEXT_NODE || node->type == XML_CDATA_SECTION_NODE) {
 415
 416         if (node->content == NULL || *(node->content) == '\0')
 417             return NULL; // empty text node
 418
 419         bool preserve = (xmlNodeGetSpacePreserve (node) == 1);
 420
 421         xmlChar *p;
 422         for (p = node->content; *p && g_ascii_isspace (*p) && !preserve; p++)
 423             ; // skip all whitespace
 424
 425         if (!(*p)) { // this is an all-whitespace node, and preserve == default
 426             return NULL; // we do not preserve all-whitespace nodes unless we are asked to
 427         }
 428
 429         Node *rdoc = sp_repr_new_text((const gchar *)node->content);
 430         return rdoc;
 431     }
 432
 433     if (node->type == XML_COMMENT_NODE)
 434         return sp_repr_new_comment((const gchar *)node->content);
 435
 436     if (node->type == XML_ENTITY_DECL) return NULL;
 437
 438     sp_repr_qualified_name (c, 256, node->ns, node->name, default_ns, prefix_map);
 439     repr = sp_repr_new (c);
 440     /* TODO remember node->ns->prefix if node->ns != NULL */
 441
 442     for (prop = node->properties; prop != NULL; prop = prop->next) {
 443         if (prop->children) {
 444             sp_repr_qualified_name (c, 256, prop->ns, prop->name, default_ns, prefix_map);
 445             repr->setAttribute(c, (gchar*)prop->children->content);
 446             /* TODO remember prop->ns->prefix if prop->ns != NULL */
 447         }
 448     }
 449
 450     if (node->content)
 451         repr->setContent((gchar*)node->content);
 452
 453     child = node->xmlChildrenNode;
 454     for (child = node->xmlChildrenNode; child != NULL; child = child->next) {
 455         crepr = sp_repr_svg_read_node (child, default_ns, prefix_map);
 456         if (crepr) {
 457             repr->appendChild(crepr);
 458             Inkscape::GC::release(crepr);
 459         }
 460     }
 461
 462     return repr;
 463 }
 464
 465 void
 466 sp_repr_save_stream (Document *doc, FILE *fp, gchar const *default_ns, bool compress)
 467 {
 468     Node *repr;
 469     const gchar *str;
 470
 471     Inkscape::URI dummy("x");
 472     Inkscape::IO::UriOutputStream bout(fp, dummy);
 473     Inkscape::IO::GzipOutputStream *gout = compress ? new Inkscape::IO::GzipOutputStream(bout) : NULL;
 474     Inkscape::IO::OutputStreamWriter *out  = compress ? new Inkscape::IO::OutputStreamWriter( *gout ) : new Inkscape::IO::OutputStreamWriter( bout );
 475
 476     /* fixme: do this The Right Way */
 477
 478     out->writeString( "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" );
 479
 480     str = ((Node *)doc)->attribute("doctype");
 481     if (str) {
 482         out->writeString( str );
 483     }
 484
 485     repr = sp_repr_document_first_child(doc);
 486     for ( repr = sp_repr_document_first_child(doc) ;
 487           repr ; repr = sp_repr_next(repr) )
 488     {
 489         if ( repr->type() == Inkscape::XML::ELEMENT_NODE ) {
 490             sp_repr_write_stream_root_element(repr, *out, TRUE, default_ns);
 491         } else if ( repr->type() == Inkscape::XML::COMMENT_NODE ) {
 492             sp_repr_write_stream(repr, *out, 0, TRUE, GQuark(0));
 493             out->writeChar( '\n' );
 494         } else {
 495             sp_repr_write_stream(repr, *out, 0, TRUE, GQuark(0));
 496         }
 497     }
 498     if ( out ) {
 499         delete out;
 500         out = NULL;
 501     }
 502     if ( gout ) {
 503         delete gout;
 504         gout = NULL;
 505     }
 506 }
 507
 508 /* Returns TRUE if file successfully saved; FALSE if not
 509  */
 510 gboolean
 511 sp_repr_save_file (Document *doc, const gchar *filename,
 512                    gchar const *default_ns)
 513 {
 514     if (filename == NULL) {
 515         return FALSE;
 516     }
 517     bool compress = false;
 518     {
 519         if (strlen (filename) > 5) {
 520             gchar tmp[] = {0,0,0,0,0,0};
 521             strncpy( tmp, filename + strlen (filename) - 5, 6 );
 522             tmp[5] = 0;
 523             if ( strcasecmp(".svgz", tmp ) == 0 )
 524             {
 525                 //g_message("TIME TO COMPRESS THE OUTPUT FOR SVGZ");
 526                 compress = true;
 527             }
 528         }
 529     }
 530
 531     Inkscape::IO::dump_fopen_call( filename, "B" );
 532     FILE *file = Inkscape::IO::fopen_utf8name(filename, "w");
 533     if (file == NULL) {
 534         return FALSE;
 535     }
 536
 537     sp_repr_save_stream (doc, file, default_ns, compress);
 538
 539     if (fclose (file) != 0) {
 540         return FALSE;
 541     }
 542
 543     return TRUE;
 544 }
 545
 546 void
 547 sp_repr_print (Node * repr)
 548 {
 549     Inkscape::IO::StdOutputStream bout;
 550     Inkscape::IO::OutputStreamWriter out(bout);
 551
 552     sp_repr_write_stream (repr, out, 0, TRUE, GQuark(0));
 553
 554     return;
 555 }
 556
 557 /* (No doubt this function already exists elsewhere.) */
 558 static void
 559 repr_quote_write (Writer &out, const gchar * val)
 560 {
 561     if (!val) return;
 562
 563     for (; *val != '\0'; val++) {
 564         switch (*val) {
 565         case '"': out.writeString( "&quot;" ); break;
 566         case '&': out.writeString( "&amp;" ); break;
 567         case '<': out.writeString( "&lt;" ); break;
 568         case '>': out.writeString( "&gt;" ); break;
 569         default: out.writeChar( *val ); break;
 570         }
 571     }
 572 }
 573
 574 namespace {
 575
 576 typedef std::map<Glib::QueryQuark, gchar const *, Inkscape::compare_quark_ids> LocalNameMap;
 577 typedef std::map<Glib::QueryQuark, Inkscape::Util::SharedCStringPtr, Inkscape::compare_quark_ids> NSMap;
 578
 579 gchar const *qname_local_name(Glib::QueryQuark qname) {
 580     static LocalNameMap local_name_map;
 581     LocalNameMap::iterator iter = local_name_map.find(qname);
 582     if ( iter != local_name_map.end() ) {
 583         return (*iter).second;
 584     } else {
 585         gchar const *name_string=g_quark_to_string(qname);
 586         gchar const *prefix_end=strchr(name_string, ':');
 587         if (prefix_end) {
 588             return prefix_end + 1;
 589         } else {
 590             return name_string;
 591         }
 592     }
 593 }
 594
 595 void add_ns_map_entry(NSMap &ns_map, Glib::QueryQuark prefix) {
 596     using Inkscape::Util::SharedCStringPtr;
 597
 598     static const Glib::QueryQuark xml_prefix("xml");
 599
 600     NSMap::iterator iter=ns_map.find(prefix);
 601     if ( iter == ns_map.end() ) {
 602         if (prefix.id()) {
 603             gchar const *uri=sp_xml_ns_prefix_uri(g_quark_to_string(prefix));
 604             if (uri) {
 605                 ns_map.insert(NSMap::value_type(prefix, SharedCStringPtr::coerce(uri)));
 606             } else if ( prefix != xml_prefix ) {
 607                 g_warning("No namespace known for normalized prefix %s", g_quark_to_string(prefix));
 608             }
 609         } else {
 610             ns_map.insert(NSMap::value_type(prefix, SharedCStringPtr()));
 611         }
 612     }
 613 }
 614
 615 void populate_ns_map(NSMap &ns_map, Node &repr) {
 616     if ( repr.type() == Inkscape::XML::ELEMENT_NODE ) {
 617         add_ns_map_entry(ns_map, qname_prefix(repr.code()));
 618         for ( List<AttributeRecord const> iter=repr.attributeList() ;
 619               iter ; ++iter )
 620         {
 621             Glib::QueryQuark prefix=qname_prefix(iter->key);
 622             if (prefix.id()) {
 623                 add_ns_map_entry(ns_map, prefix);
 624             }
 625         }
 626         for ( Node *child=sp_repr_children(&repr) ;
 627               child ; child = sp_repr_next(child) )
 628         {
 629             populate_ns_map(ns_map, *child);
 630         }
 631     }
 632 }
 633
 634 }
 635
 636 void
 637 sp_repr_write_stream_root_element (Node *repr, Writer &out, gboolean add_whitespace, gchar const *default_ns)
 638 {
 639     using Inkscape::Util::SharedCStringPtr;
 640     g_assert(repr != NULL);
 641     Glib::QueryQuark xml_prefix=g_quark_from_static_string("xml");
 642
 643     NSMap ns_map;
 644     populate_ns_map(ns_map, *repr);
 645
 646     Glib::QueryQuark elide_prefix=GQuark(0);
 647     if ( default_ns && ns_map.find(GQuark(0)) == ns_map.end() ) {
 648         elide_prefix = g_quark_from_string(sp_xml_ns_uri_prefix(default_ns, NULL));
 649     }
 650
 651     List<AttributeRecord const> attributes=repr->attributeList();
 652     for ( NSMap::iterator iter=ns_map.begin() ; iter != ns_map.end() ; ++iter )
 653     {
 654         Glib::QueryQuark prefix=(*iter).first;
 655         SharedCStringPtr ns_uri=(*iter).second;
 656
 657         if (prefix.id()) {
 658             if ( prefix != xml_prefix ) {
 659                 if ( elide_prefix == prefix ) {
 660                     attributes = cons(AttributeRecord(g_quark_from_static_string("xmlns"), ns_uri), attributes);
 661                 }
 662
 663                 Glib::ustring attr_name="xmlns:";
 664                 attr_name.append(g_quark_to_string(prefix));
 665                 GQuark key = g_quark_from_string(attr_name.c_str());
 666                 attributes = cons(AttributeRecord(key, ns_uri), attributes);
 667             }
 668         } else {
 669             // if there are non-namespaced elements, we can't globally
 670             // use a default namespace
 671             elide_prefix = GQuark(0);
 672         }
 673     }
 674
 675     return sp_repr_write_stream_element(repr, out, 0, add_whitespace, elide_prefix, attributes);
 676 }
 677
 678 void
 679 sp_repr_write_stream (Node *repr, Writer &out, gint indent_level,
 680                       gboolean add_whitespace, Glib::QueryQuark elide_prefix)
 681 {
 682     if (repr->type() == Inkscape::XML::TEXT_NODE) {
 683         repr_quote_write (out, repr->content());
 684     } else if (repr->type() == Inkscape::XML::COMMENT_NODE) {
 685         out.printf( "<!--%s-->", repr->content() );
 686     } else if (repr->type() == Inkscape::XML::ELEMENT_NODE) {
 687         sp_repr_write_stream_element(repr, out, indent_level, add_whitespace, elide_prefix, repr->attributeList());
 688     } else {
 689         g_assert_not_reached();
 690     }
 691 }
 692
 693 void
 694 sp_repr_write_stream_element (Node * repr, Writer & out, gint indent_level,
 695                               gboolean add_whitespace,
 696                               Glib::QueryQuark elide_prefix,
 697                               List<AttributeRecord const> attributes)
 698 {
 699     Node *child;
 700     gboolean loose;
 701     gint i;
 702
 703     g_return_if_fail (repr != NULL);
 704
 705     if ( indent_level > 16 )
 706         indent_level = 16;
 707
 708     if (add_whitespace) {
 709         for ( i = 0 ; i < indent_level ; i++ ) {
 710             out.writeString( "  " );
 711         }
 712     }
 713
 714     GQuark code = repr->code();
 715     gchar const *element_name;
 716     if ( elide_prefix == qname_prefix(code) ) {
 717         element_name = qname_local_name(code);
 718     } else {
 719         element_name = g_quark_to_string(code);
 720     }
 721     out.printf( "<%s", element_name );
 722
 723     // if this is a <text> element, suppress formatting whitespace
 724     // for its content and children:
 725     gchar const *xml_space_attr = repr->attribute("xml:space");
 726     if (xml_space_attr != NULL && !strcmp(xml_space_attr, "preserve")) {
 727         add_whitespace = FALSE;
 728     }
 729
 730     for ( List<AttributeRecord const> iter = attributes ;
 731           iter ; ++iter )
 732     {
 733         out.writeString("\n");
 734         for ( i = 0 ; i < indent_level + 1 ; i++ ) {
 735             out.writeString("  ");
 736         }
 737         out.printf(" %s=\"", g_quark_to_string(iter->key));
 738         repr_quote_write(out, iter->value);
 739         out.writeChar('"');
 740     }
 741
 742     loose = TRUE;
 743     for (child = repr->firstChild() ; child != NULL; child = child->next()) {
 744         if (child->type() == Inkscape::XML::TEXT_NODE) {
 745             loose = FALSE;
 746             break;
 747         }
 748     }
 749     if (repr->firstChild()) {
 750         out.writeString( ">" );
 751         if (loose && add_whitespace) {
 752             out.writeString( "\n" );
 753         }
 754         for (child = repr->firstChild(); child != NULL; child = child->next()) {
 755             sp_repr_write_stream (child, out, (loose) ? (indent_level + 1) : 0, add_whitespace, elide_prefix);
 756         }
 757
 758         if (loose && add_whitespace) {
 759             for (i = 0; i < indent_level; i++) {
 760                 out.writeString( "  " );
 761             }
 762         }
 763         out.printf( "</%s>", element_name );
 764     } else {
 765         out.writeString( " />" );
 766     }
 767
 768     // text elements cannot nest, so we can output newline
 769     // after closing text
 770
 771     if (add_whitespace || !strcmp (repr->name(), "svg:text")) {
 772         out.writeString( "\n" );
 773     }
 774 }
 775
 776
 777 /*
 778   Local Variables:
 779   mode:c++
 780   c-file-style:"stroustrup"
 781   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 782   indent-tabs-mode:nil
 783   fill-column:99
 784   End:
 785 */
 786 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :