X3DSAX2Handlers.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API 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.
//
//    H3D API 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 H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//

#ifndef __X3DSAX2HANDLERS_H__
#define __X3DSAX2HANDLERS_H__

#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>
#include <xercesc/sax/Locator.hpp>
#include <stack>
#include <list>
#include "Field.h"
#include "Node.h"
#include "Exception.h"
#include "DEFNodes.h"
#include "AutoRef.h"
#include "ProtoDeclaration.h"
#include "AutoPtrVector.h"
#include "X3D.h"

#ifdef _MSC_VER
#pragma comment( lib, "xerces-c_2.lib" )
#endif


XERCES_CPP_NAMESPACE_USE
namespace H3D {
  namespace X3D {
    H3D_API_EXCEPTION( XMLParseError );

    class X3DSAX2Handlers : public DefaultHandler {
    public:
      X3DSAX2Handlers( DEFNodes *dn = NULL,
                       DEFNodes *_exported_nodes = NULL,
                       PrototypeVector *_proto_declarations = NULL ): 
        proto_instance( NULL ),
        proto_declaration( NULL ),
        defining_proto_body( false ),
        defining_proto_interface( false ),
        defining_proto_connections( false ),
        defining_extern_proto( false ),
        delete_DEF_map( dn == NULL ),
        delete_exported_map( _exported_nodes == NULL ),
        delete_proto_declarations( _proto_declarations == NULL ),
        DEF_map( dn ),
        exported_nodes( _exported_nodes ),
        proto_declarations( _proto_declarations ),
        locator( NULL ){
        if( !DEF_map ) {
          DEF_map = new DEFNodes();
        }
        if( !_exported_nodes ) {
          exported_nodes = new DEFNodes();
        }
        if( !_proto_declarations ) {
          proto_declarations = new PrototypeVector;
        }
      };

      ~X3DSAX2Handlers() {
        if( delete_DEF_map ) 
          delete DEF_map;
        if( delete_exported_map )
          delete exported_nodes;
        if( delete_proto_declarations )
          delete proto_declarations;
      };

        
      void setDocumentLocator( const Locator *const _locator ) {
        locator = (Locator *)_locator;
      }
      
      inline const AutoRef<Node> &getResultingNode() { 
        return resulting_node;
      }

      virtual void startDocument () { 
        resulting_node.reset( NULL );
      }

      void startElement(const XMLCh* const uri, 
                        const XMLCh* const localname, 
                        const XMLCh* const qname, 
                        const Attributes& attrs);
        
      void endElement (const XMLCh *const uri,
                       const XMLCh *const localname,
                       const XMLCh *const qname);
      
      void warning(const SAXParseException& exc);

      void error(const SAXParseException& exc);

      void fatalError(const SAXParseException& exc);
      
      X3DPrototypeInstance *proto_instance;

    protected:
      
      void protoStartElement( const XMLCh* const uri,
                              const XMLCh* const localname, 
                              const XMLCh* const qname,
                              const Attributes& attrs );
      
      void protoEndElement( const XMLCh* const uri,
                            const XMLCh* const localname, 
                            const XMLCh* const qname );

      void handleProtoInterfaceFieldElement( const Attributes &attrs );
      
      void handleConnectElement( const Attributes &attrs, Node *parent );

      void handleRouteElement( const Attributes &attrs, 
                               bool route_no_event = false );

      Field * handleFieldElement( const Attributes &attrs, Node *parent );

      void handleImportElement( const Attributes &attrs  );
      
      void handleExportElement( const Attributes &attrs  );

      X3DPrototypeInstance* handleProtoInstanceElement( const Attributes &attrs );

      void handleFieldValueElement( const Attributes &attrs, Node *parent );

      void handleExternProtoDeclareElement( const Attributes &attrs );

      class NodeElement {
      public:
        NodeElement( Node *_node,
                     const string &_container_field = "" ):
          container_field( _container_field ),
          node( _node ) {
          if( node ) node->ref();
        }

        NodeElement( const NodeElement& ne ) {
          node = ne.node;
          container_field = ne.container_field;
          if( node ) node->ref();
        }

        ~NodeElement() {
          if( node ) node->unref();
        }
            
        void setNode( Node *n ) {
          if( n )
            n->ref();
          if( node ) 
            node->unref();
          node = n;
        }
            
        Node *getNode() { 
          return node;
        }

        void setContainerField( const string &s ) {
          container_field = s;
        }
            
        const string &getContainerField() { 
          return container_field;
        }
      private:
        string container_field;
        Node *node;
            
      };

      string getLocationString();

      typedef std::stack< NodeElement > NodeElementStack;

      ProtoDeclaration *proto_declaration;

      string proto_body;

      bool defining_proto_body;

      bool defining_proto_interface;

      bool defining_proto_connections;

      bool defining_extern_proto;

      NodeElementStack node_stack;
        
      bool delete_DEF_map;

      bool delete_exported_map;

      bool delete_proto_declarations;
        
      DEFNodes *DEF_map;

      DEFNodes *exported_nodes;

      PrototypeVector *proto_declarations;

      AutoRef<Node> resulting_node;

      Locator *locator;
        
    };
  } 
}
#endif

---