---

SerialTree-libxml.cpp

//  SerialTree-libxml - GNOME libxml support for SerialTree
//  Copyright (C) 2000 rusty@sgi.com
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 2
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include <fun/SerialTree.h>

//  This should only be built if HAVE_LIBXML is defined!
#ifdef HAVE_LIBXML

#include <fun/XMLUtil.h>  //  this will go away
#include <iostream>
#include <gnome-xml/tree.h>
#include <gnome-xml/parser.h>

namespace fun {

//  copied from XMLUtil.c++, which will go away
static ostream &
operator<<(ostream &os, xmlElementType t)
{
    switch(t)
    {
        case XML_ELEMENT_NODE:       os << "ELEMENT";       break;
        case XML_ATTRIBUTE_NODE:     os << "ATTRIBUTE";     break;
        case XML_TEXT_NODE:          os << "TEXT";          break;
        case XML_CDATA_SECTION_NODE: os << "CDATA_SECTION"; break;
        case XML_ENTITY_REF_NODE:    os << "ENTITY_REF";    break;
        case XML_ENTITY_NODE:        os << "ENTITY";        break;
        case XML_PI_NODE:            os << "PI";            break;
        case XML_COMMENT_NODE:       os << "COMMENT";       break;
        case XML_DOCUMENT_NODE:      os << "DOCUMENT";      break;
        case XML_DOCUMENT_TYPE_NODE: os << "DOCUMENT_TYPE"; break;
        case XML_DOCUMENT_FRAG_NODE: os << "DOCUMENT_FRAG"; break;
        case XML_NOTATION_NODE:      os << "NOTATION";      break;
        default:                     os << "(wha??)";
    }
    return os;
}

static QString
getSerializableClass(xmlNode *np)
{
    return XMLUtil::getTextAttr(np, "class");
}

static void
setSerializableClass(xmlNode *np, const QString &cls)
{
    XMLUtil::addTextAttr(np, "class", cls);
}

SerialTree *
SerialTree::loadFromXMLFile(const QString &filename)
{
    xmlDoc *xdoc = xmlParseFile(filename);
    if(xdoc == NULL) return NULL;
//XMLUtil::dumpDoc(xdoc);

    SerialTree *root = NULL;
    Child *cp = NULL;
    xmlNode *lastcmnt = NULL;
    for(xmlNode *xnp = xdoc->root; (xnp != NULL) && root == NULL; xnp = xnp->next)
    {
//cout << "xnp->type == " << xnp->type << endl;
        switch(xnp->type)
        {
            case XML_COMMENT_NODE:
                break;
            case XML_ELEMENT_NODE:
//cout << "found root..." << endl;
                root = new SerialTree;
                cp = new Child((const char *)(xnp->name));
                childFromXMLNode(*cp, xnp);
                root->children.append(cp);
//cout << "  cp->tval->getSerializableClass() == " << cp->tval->getSerializableClass() << endl;
                if(cp->tval) cp->tval->setSerializableClass(::getSerializableClass(xnp));
//cout << "  root class is " << root->getSerializableClass() << endl;
                break;
            default:
                NOT_DONE("parseXML() doesn't handle node type " << xnp->type);
        }
    }
    return root;
}

bool
SerialTree::saveToXMLFile(const QString &filename, int mode)
{
    xmlDoc *doc = XMLUtil::newDocument();
NOT_DONE("saveToXMLFile() doesn't handle parent node right");
//  //  Actually, we'd better have only one child.
//  xmlNode *np = XMLUtil::addChild((xmlNode *)doc, XML_ELEMENT_NODE, "rustyIsABozo");
    toXMLNode((xmlNode *)doc);

//XMLUtil::dumpDoc(doc);

    XMLUtil::saveFile(doc, filename);

    XMLUtil::deleteDocument(doc);
NOT_DONE("saveToXMLFile() does no error checking");
    return true;
}

void
SerialTree::toXMLNode(void *xmlnode) const
{
    xmlNode *np = (xmlNode *)xmlnode;
    if(!getSerializableClass().isNull()) ::setSerializableClass(np, getSerializableClass());
    for(QPtrListIterator<Child> it(children); it.current(); ++it)
    {
        xmlNode *cnp = XMLUtil::addChild(np, XML_ELEMENT_NODE, it.current()->key);
        if(it.current()->sval)
        {
            XMLUtil::addChild(cnp, XML_TEXT_NODE, *(it.current()->sval));
        }
        else if(it.current()->tval)
        {
            it.current()->tval->toXMLNode(cnp);
        }
        else
        {
            NOT_DONE("toXMLNode() doesn't handle stubby children");
        }
    }
}

void
SerialTree::childFromXMLNode(Child &child, void *xmlnode)
{
    xmlNode *xnp = (xmlNode *)xmlnode;
    if(xnp->type != XML_ELEMENT_NODE)
    {
        NOT_DONE("brain damage in childFromXMLNode");
        return;
    }
//  QString name = (const char *)(xnp->name);
//  QString tc = "";
    QString valbuf;
    QString lastcmnt;
    Child *newkid = NULL;
//  NOT_DONE("not getting TreeableClass from node");

    //  Run through and concatenate all TEXT elements into a buffer.  If
    //  this has any ELEMENT children, though, toss the buffer and treat
    //  this as a non-leaf node, as SerialTree nodes can have either a
    //  value or children, not both.
    for(xmlNode *xcp = xnp->childs; xcp; xcp = xcp->next)
    {
//cout << "xcp->type == " << xcp->type << endl;
        switch(xcp->type)
        {
            case XML_COMMENT_NODE:
                lastcmnt = (const char *)xmlNodeGetContent(xcp);
//cout << "  now lastcmnt == \"" << lastcmnt << "\"" << endl;
                break;
            case XML_TEXT_NODE:
                valbuf += (const char *)xmlNodeGetContent(xcp);
//cout << "  now valbuf == \"" << valbuf << "\"" << endl;
                lastcmnt = QString();
                break;
            case XML_ELEMENT_NODE:
//cout << "  got element == \"" << xcp->name << "\"" << endl;
                valbuf = QString();
//cout << "  adding child == \"" << xcp->name << "\"" << endl;
                if(!child.tval) child.tval = new SerialTree();
//cout << "    with class " << child.tval->getSerializableClass() << endl;
                newkid = new Child((const char *)(xcp->name));
                //newkid->setComment(
                child.tval->setComment((const char *)(xcp->name), lastcmnt);
                lastcmnt = QString();
                childFromXMLNode(*newkid, xcp);
                if(newkid->tval) newkid->tval->setSerializableClass(::getSerializableClass(xcp));
//cout << "  done adding child == \"" << xcp->name << "\"" << endl;
                child.tval->children.append(newkid);
                break;
            default:
                NOT_DONE("parseXML() doesn't handle node type " << xnp->type);
        }
    }
    if(!child.tval)
    {
        //  no sub-child elements, so this must have just been text.
        child.sval = new QString(valbuf);
    }
}

}  //  namespace fun

#endif  //  HAVE_LIBXML

---