X3DSAX2Handlers.h

Go to the documentation of this file.

//    Copyright 2004-2019, 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 <stack>
#include <list>
#include <H3D/Field.h>
#include <H3D/Node.h>
#include <H3D/DEFNodes.h>
#include <H3D/ProtoDeclaration.h>
#include <H3D/X3D.h>
#include <H3D/H3DScriptNode.h>
 
#include <H3DUtil/Exception.h>
#include <H3DUtil/AutoRef.h>
#include <H3DUtil/AutoPtrVector.h>
 
#ifdef HAVE_XERCES
 
#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>
#include <xercesc/sax/Locator.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
 
XERCES_CPP_NAMESPACE_USE
 
#endif
 
 
namespace H3D {
  namespace X3D {
    H3D_API_EXCEPTION( XMLParseError );
 
 
#ifdef HAVE_XERCES
    class X3DSAX2Handlers : public DefaultHandler {
    public:
      X3DSAX2Handlers( DEFNodes *dn = NULL,
                       DEFNodes *_exported_nodes = NULL,
                       PrototypeVector *_proto_declarations = NULL,
                       bool _called_from_proto_declaration = false ): 
        proto_instance( NULL ),
        proto_declaration( NULL ),
        called_from_proto_declaration( _called_from_proto_declaration ),
        proto_body_count( 0 ),
        defining_proto_body( 0 ),
        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 ),
        profile_set( false ),
        meta_set( false ),
        inside_head(false),
        inside_cdata( false ) {
        
        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 );
      }
 
      virtual void endDocument();
 
      void startElement(const XMLCh* const uri, 
                        const XMLCh* const localname, 
                        const XMLCh* const qname, 
                        const Attributes& attrs);
      
      //void comment( const XMLCh *const chars, 
      //const XMLSize_t length );
 
      void startCDATA();
 
      void endCDATA();
  
      void characters( const XMLCh *const chars, 
                       const XMLSize_t length );
 
      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 );
 
      void handleProgramSettingElement( const Attributes &attrs );
 
      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 ),
          have_connect_element( false ) {
          if( node ) node->ref();
        }
 
        NodeElement( const NodeElement& ne ) {
          node = ne.node;
          container_field = ne.container_field;
          cdata = ne.cdata;
          if( node ) node->ref();
          have_connect_element = ne.have_connect_element;
        }
 
        ~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;
        }
            
        void setCDATA( const string &s ) {
          cdata = s;
        }
 
        bool haveCDATA() {
          return !cdata.empty();
        }
 
        const string &getCDATA() {
          return cdata;
        }
 
        const string &getContainerField() { 
          return container_field;
        }
 
        bool haveConnectElement() {
          return have_connect_element;
        }
 
        void setConnectElement( const bool &b ) {
          have_connect_element = b;
        }
      private:
        string container_field;
        Node *node;
        string cdata;
        bool have_connect_element;
      };
 
      string getLocationString();
 
      typedef std::stack< NodeElement > NodeElementStack;
 
      AutoRef< ProtoDeclaration > proto_declaration;
 
      bool called_from_proto_declaration;
 
      string proto_body;
 
      unsigned int proto_body_count;
 
      H3DInt32 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;
 
      AutoRefVector< H3DScriptNode > script_nodes;
 
      AutoRef<Node> resulting_node;
 
      Locator *locator;
 
      bool profile_set;
 
      bool meta_set;
      bool inside_head;
 
      bool inside_cdata;
 
      string cdata;
    };
 
    H3DAPI_API SAX2XMLReader* getNewXMLParser();
 
#endif
  } 
}
#endif