network.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/util/text.H>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/network.H>
#include <archon/x3d/server/scene.H>
#include <archon/x3d/server/server.H>

namespace Archon
{
  namespace X3D
  {
    const NodeType *UrlObject::type = 0;
    const NodeType *SubSceneNode::type = 0;
    const NodeType *Inline::type = 0;
    const NodeType *ApplicationLink::type = 0;

    void initializeNetworkComponent()
    {
      vector<const FieldBase *> fields;

      // UrlObject

      fields.push_back(newExposedField("url", MFString::type,
                                       &UrlObject::url,
                                       &UrlObject::urlAssign,
                                       &UrlObject::urlChanged,
                                       &UrlObject::urlStamp));
      UrlObject::type =
        NodeType::newAbstract("UrlObject", false, &fields);

      fields.clear();


      // SubSceneNode

      SubSceneNode::type =
        NodeType::newAbstract("SubSceneNode", false, 0, ChildNode::type);


      // Inline

      fields.push_back(newExposedField("load", SFBool::type,
                                       &Inline::load,
                                       &Inline::loadAssign,
                                       &Inline::loadChanged,
                                       &Inline::loadStamp));
      Inline::type =
        NodeType::newConcrete("Inline", "children", Inline::instantiate,
                              &fields, SubSceneNode::type, UrlObject::type);
      fields.clear();


      // ApplicationLink

      ApplicationLink::type =
        NodeType::newConcrete("ApplicationLink", "children", ApplicationLink::instantiate,
                              0, SubSceneNode::type);
      fields.clear();
    }

    UrlObject::UrlObject()
    {
    }

    UrlObject::~UrlObject()
    {{ // The extra scope is needed to work around gcc3.2 bug #8287
      killLoaderJob();
    }}

    Ref<const Loader::Contents> UrlObject::getContents() const
    {
      Mutex::Lock l(loaderMutex);
      return contents;
    }

    void UrlObject::addUri(string u, Time stamp)
    {
      const FieldBase *f = getType()->lookupField("url");
      if(!f) ARCHON_THROW1(InternalException,
                           "Could not find field 'url' in UrlObject");
      {
        Mutex::Lock l(mutex);
        if(!isRealizedNoLock())
        {
          url.push_back(u);
          Event e(new SimpleValue<vector<string> >(MFString::type, url), stamp);
          f->set(this, &e, false);
          return;
        }
      }
      try
      {
        Mutex::Lock l(context->server->scenegraphMutex);
        url.push_back(u);
        Event e(new SimpleValue<vector<string> >(MFString::type, url), stamp);
        f->set(this, &e, true);
      }
      catch(ForwardDestroyedException &) {}
    }

    void UrlObject::LoaderJob::kill()
    {
      Loader::Job::kill(); // Ask this job to abort
      Mutex::Lock l(mutex);
      urlObject = 0;
    }

    void UrlObject::LoaderJob::onCompletion()
    {
      Ref<const Loader::Contents> c = getContents();

      Mutex::Lock l(mutex);

      // Attempt to aquire a "safe" reference
      Ref<UrlObject> safeRef(urlObject, RefSafeIncTag());
      if(!safeRef) return;

      urlObject->setContents(c);

      l.release();

      safeRef->onLoaded();
    }

    void UrlObject::setContents(Ref<const Loader::Contents> c)
    {
      Mutex::Lock l(loaderMutex);
      contents = c;
      loaderJob = 0;
    }

    void UrlObject::killLoaderJob()
    {
      Ref<LoaderJob> j;
      {
        Mutex::Lock l(loaderMutex);
        j = loaderJob;
        loaderJob.reset();
        contents.reset();
      }
      if(j) j->kill();
    }

    void UrlObject::startLoading()
    {
      if(!url.size()) return;
      Ref<ExecutionContext> c;
      Ref<Loader> loader;
      Ref<AbstractFileServer> fileServer;
      try
      {
        c = context.getRef();
        loader = c->server->getLoader();
        fileServer = c->fileServer.getRef();
      }
      catch(ForwardDestroyedException &) { return; }
      if(!loader) return;
      Ref<LoaderJob> j =
        new LoaderJob(this, loader, c->getBaseUri(),
                      url, getUriType(), fileServer);
      {
        Mutex::Lock l(loaderMutex);
        if(contents || loaderJob) return;
        loaderJob = j;
        loader->submitJob(j);
      }
    }

    bool UrlObject::urlAssign(const vector<string> &v, const Time &t)
    {
      url = v;
      urlStamp = t;

      killLoaderJob();

      /*
       * Give the derived node a chance to clean up any data
       * produced from the old URI contents such as textures and
       * script engines.
       */
      clear();

      if(mayStartLoading()) startLoading();

      return true;
    }


    Ref<SceneBase> SubSceneNode::getSubScene() const
    {
      {
        Mutex::Lock l(mutex);
        if(!isRealizedNoLock()) return subScene;
      }
      try
      {
        Mutex::Lock l(context->server->scenegraphMutex);
        return subScene;
      }
      catch(ForwardDestroyedException &) { return 0; }
    }

    void SubSceneNode::setSubScene(Ref<SceneBase> c)
    {
      if(c) c->realize();
      {
        Mutex::Lock l(mutex);
        if(!isRealizedNoLock())
        {
          subScene = c;
          return;
        }
      }
      try
      {
        Mutex::Lock l(context->server->scenegraphMutex);
        subScene = c;
      }
      catch(ForwardDestroyedException &) {}
    }

    void SubSceneNode::refForwardDestroy()
    {
      Node::refForwardDestroy();
      subScene.reset();
    }


    bool Inline::loadAssign(const bool &v, const Time &t)
    {
      load = v;
      loadStamp = t;

      if(load) startLoading();

      return true;
    }

    void Inline::onLoaded()
    {
      Ref<const Loader::Contents> c = getContents();
      if(!c) return;
      const Loader::X3DContents *d =
        dynamic_cast<const Loader::X3DContents *>(c.get());
      if(!d) ARCHON_THROW1(InternalException, "Wrong content type");
      setSubScene(d->rootScene);
    }

    void Inline::clear()
    {
      subScene.reset();
    }

    /*
    string ApplicationLink::dump(int level) const
    {
      if(!subScene) return "";
      return subScene->dump(level);
    }
    */
  }
}

---