event.C

Go to the documentation of this file.

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <archon/x3d/server/event.H>
#include <archon/x3d/server/scene.H>

namespace Archon
{
  namespace X3D
  {
    void Route::cascadeEvent(const Event *e) const
    {
      try
      {
        Ref<NodeBase> n = targetNode.getRef();
        targetField->set(n.get(), e, true);
      }
      catch(ForwardDestroyedException &) {}
    }

    Ref<NodeBase> Route::getSourceNode() const
    {
      return sourceNode.getRef();
    }

    const FieldBase *Route::getSourceField() const
    {
      return sourceField;
    }

    void Route::add(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                    Ref<NodeBase> targetNode, const FieldBase *targetField)
      throw(AccessException, TypeException, ContextException)
    {
      // Field input/output capabilities
      if(!sourceField->getIsEventSource() ||
         !targetField->getIsEventTarget()) ARCHON_THROW(AccessException);

      // Self reference is redundant and must be ignored
      if(sourceNode == targetNode && sourceField == targetField) return;

      // Type conformance
      const FieldType *fieldType = sourceField->getType();
      if(fieldType != targetField->getType()) ARCHON_THROW(TypeException);

      // Injective node type restriction
      if(const NodeFieldBase *sourceNodeField =
         dynamic_cast<const NodeFieldBase *>(sourceField))
      {
        const NodeFieldBase *targetNodeField =
          dynamic_cast<const NodeFieldBase *>(targetField);
        if(!sourceNodeField->getNodeType()->
           isDerivedFrom(targetNodeField->getNodeType()))
          ARCHON_THROW(TypeException);
      }

      try
      {
        Ref<ExecutionContext> context = sourceNode->context.getRef();
        if(context != targetNode->context.getRef())
          ARCHON_THROW(ContextException);

        Route *r = new Route(sourceNode, sourceField, targetNode, targetField);
        Ref<RouteTail> t(dynamic_cast<RouteTail *>(r));
        Ref<RouteHead> h(dynamic_cast<RouteHead *>(r));
        if(sourceField->addRoute(sourceNode.get(), t.get()))
        {
          targetNode->realize();
          targetNode->addRouteTarget(h);
          context->add(r);
        }
      }
      catch(ForwardDestroyedException &) {}
    }

    bool Route::del(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                    Ref<NodeBase> targetNode, const FieldBase *targetField)
      throw(ContextException)
    {
      if(sourceNode->context != targetNode->context)
        ARCHON_THROW(ContextException);
      Route r(sourceNode, sourceField, targetNode, targetField);
      return sourceField->delRouteMatch(sourceNode.get(), &r);
    }

    void Route::refDispose(Mutex::Lock &l)
    {
      if(getTailCountNoLock() == 0)
      {
        if(getHeadCountNoLock() == 0)
        {
          l.release();
          try
          {
            sourceNode->context->remove(this);
          }
          catch(ForwardDestroyedException &) {}
          delete this;
          return;
        }
        Ref<RouteHead> h(this, RefNoLockTag());
        l.release();
        try
        {
          targetNode->removeRouteTarget(h);
        }
        catch(ForwardDestroyedException &) {}
        return;
      }
      Ref<RouteTail> t(this, RefNoLockTag());
      l.release();
      try
      {
        Ref<NodeBase> n = sourceNode.getRef();
        sourceField->delRoute(n.get(), t.get());
      }
      catch(ForwardDestroyedException &) {}
    }

    Route::~Route() {}

    Route::Route(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                 Ref<NodeBase> targetNode, const FieldBase *targetField):
      RouteTail(sourceNode, sourceField),
      RouteHead(targetNode, targetField)
    {
    }

    bool Route::match(const RouteTail *r) const
    {
      const Route *s = dynamic_cast<const Route *>(r);
      return s && s->targetNode == targetNode &&
        s->targetField == targetField;
    }
  }
}

---