main.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 <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <stropts.h>

#include <fstream> 

#include <archon/math/vector.H>
#include <archon/util/thread.H>
#include <archon/util/ref.H>
#include <archon/util/options.H>
#include <archon/util/file.H>
#include <archon/util/polygon_mesher.H>

#include <archon/x3d/proxy/exception.H>
#include <archon/x3d/proxy/proxy.H>

using namespace std;
using namespace Archon;
using namespace Archon::Math;
using namespace Archon::Utilities;
using namespace Archon::X3D::Proxy;

namespace Archon
{
  namespace SaiTestApps
  {
    namespace Textviewer
    {
      Mutex mutex;
      Condition directoryRefresh(mutex);

      bool quit = false;

      void handleClose(Time)
      {
        quit = true;
        directoryRefresh.notifyAll();
      }

      void handleBack(Time)
      {
        directoryRefresh.notifyAll();
      }

      void handleNext(Time)
      {
        directoryRefresh.notifyAll();
      }

      class TextPage: public virtual RefObjectBase
      {
        string textString;
        Ref<Application> application;
        Ref<Transform> transform;
        Ref<X3D::Proxy::Text> text;
        Ref<Transform> nextButton;
      public:
        TextPage(Ref<Application> a) 
        {
          application = a;

          double width  = 0.210;
          double height = 0.297;

          // Create a mesh
          vector<Vector3> outline;
          outline.push_back(Vector3(0,     0,      0));
          outline.push_back(Vector3(width, 0,      0));
          outline.push_back(Vector3(width, height, 0));
          outline.push_back(Vector3(0,     height, 0));
          vector<Vector3> meshVertices;
          vector<int> meshPolygons;
          meshPolygon(outline, 0.01, meshVertices, meshPolygons);

          // Paper
          Ref<Transform> paperTransform = Transform::create(application);

          Ref<Coordinate> coord = Coordinate::create(application);
          coord->point = meshVertices;
          Ref<IndexedFaceSet> indexedFaceSet = IndexedFaceSet::create(application);
          indexedFaceSet->coord = coord;
          indexedFaceSet->coordIndex = meshPolygons;
          indexedFaceSet->solid = false;
          Ref<Shape> paperShape = Shape::create(application);
          Ref<Appearance> paperAppearance = Appearance::create(application);
          Ref<Material> paperMaterial = Material::create(application);
          paperMaterial->diffuseColor = Vector3(0.9, 0.9, 0.9);
          paperAppearance->material = paperMaterial;
          paperShape->geometry = indexedFaceSet;
          paperShape->appearance = paperAppearance;
    
          paperTransform->children.add(paperShape);

          // Text
          Ref<Transform> textTransform = Transform::create(application);
          textTransform->translation = Vector3(0.01, height-0.005, 0.001);
          textTransform->scale = Vector3(width, height, 1)/60.0;

          Ref<FontStyle> fontStyle = FontStyle::create(application);
          vector<string> family;
          family.push_back("TYPEWRITER");
          fontStyle->family = family;
          vector<string> justify;
          justify.push_back("BEGIN");
          justify.push_back("BEGIN");
          fontStyle->justify = justify;

          text = X3D::Proxy::Text::create(application);
          text->fontStyle = fontStyle;
    
          Ref<Shape> textShape = Shape::create(application);
          Ref<Appearance> textApp= Appearance::create(application);
          Ref<Material> textMaterial = Material::create(application);
          textMaterial->diffuseColor = Vector3(0, 0, 0);
          textApp->material = textMaterial;
          textShape->appearance = textApp;
          textShape->geometry = text;
          textTransform->children.add(textShape);

          // Buttons
          Ref<Transform> closeButton = Transform::create(application);
          closeButton->translation = Vector3(width-0.1, height, 0);
          closeButton->scale = Vector3(0.01, 0.01, 0.01);
          Ref<Shape> b1Shape = Shape::create(application);
          Ref<Appearance> b1Appearance = Appearance::create(application);
          Ref<Material> b1Material = Material::create(application);
          Ref<Box> b1Geometry = Box::create(application);
          b1Shape->appearance = b1Appearance;
          b1Shape->geometry = b1Geometry;
          b1Appearance->material = b1Material;
          b1Material->diffuseColor = Vector3(1, 0, 0);
          b1Material->transparency = 0.4;
          Ref<TouchSensor> b1Touch = TouchSensor::create(application);
          b1Touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(handleClose));
          closeButton->children.add(b1Shape);
          closeButton->children.add(b1Touch);
    
          nextButton = Transform::create(application);
          nextButton->translation = Vector3(width, height, 0);
          nextButton->scale = Vector3(0.01, 0.01, 0.01);
          Ref<Shape> b2Shape = Shape::create(application);
          Ref<Appearance> b2Appearance = Appearance::create(application);
          Ref<Material> b2Material = Material::create(application);
          Ref<Sphere> b2Geometry = Sphere::create(application);
          b2Shape->appearance = b2Appearance;
          b2Shape->geometry = b2Geometry;
          b2Appearance->material = b2Material;
          b2Material->diffuseColor = Vector3(0, 1, 0);
          b2Material->transparency = 0.4;
          Ref<TouchSensor> b2Touch = TouchSensor::create(application);
          b2Touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(handleNext));
          nextButton->children.add(b2Shape);
          nextButton->children.add(b2Touch);
    
          // Transform
          transform = Transform::create(application);
          transform->children.add(paperTransform);
          transform->children.add(textTransform);
          transform->children.add(closeButton);
          transform->children.add(nextButton);
        }
  
        Ref<Transform> getTransform()
        {
          return transform;
        }

        Ref<X3D::Proxy::Text> getText()
        {
          return text;
        }
  
        Ref<Transform> getNextButton()
        {
          return nextButton;
        }

      };


      int main(int argc, const char *argv[])
      {
        bool   opt_help              = false;
        int    opt_corbaEndpointPort = -1; // Auto assign
        string opt_serverName        = "archon";

        Options o;

        o.addSwitch("h", "help", opt_help, true,
                    "Describe the parameters");
        o.addConfig("p", "corba-endpoint-port", opt_corbaEndpointPort, opt_corbaEndpointPort,
                    "The TCP/IP port on which the CORBA Orb listens (-1 for auto assign)",
                    Options::wantArg_always);
        o.addConfig("n", "server-name", opt_serverName, opt_serverName,
                    "The name of the server to connect to",
                    Options::wantArg_always);

        if(o.processCommandLine(argc, argv))
        {
          cerr << "Try --help\n";
          return 1;
        }

        if(opt_help)
        {
          cout <<
            "Test Application for 3D-Console by Brian Kristiansen & Kristian Spangsege\n"
            "\n"
            "Synopsis: " << argv[0] << " FILE\n"
            "\n"
            "Available options:\n";
          cout << o.list();
          return 0;
        }

        // Treat 1st arg as URL of X3D file to load
        if(argc < 2)
        {
          cerr << "Too few arguments\n";
          cerr << "Try --help\n";
          return 1;
        }

        if(argc > 2)
        {
          cerr << "Too many aguments\n";
          cerr << "Try --help\n";
          return 1;
        }

        string name = argv[1];
        std::ifstream source(name.c_str());

        Mutex::Lock l(mutex);

        Ref<Session> session =
          Session::create(opt_serverName, opt_corbaEndpointPort);
  
        Ref<Application> application =
          Application::create(session, Uri());
  
        Ref<Group> rootGroup = Group::create(application);

        bool reachedEOF=false;
        string s;

        Ref<TextPage> textPage = new TextPage(application);
        Ref<Transform> tr = textPage->getTransform();
        Ref<X3D::Proxy::Text> text = textPage->getText();
        tr->translation = Vector3(-5, -7, 0);
        tr->scale = Vector3(60, 60, 60);
        rootGroup->children.add(tr);

        application->setRootGroup(rootGroup);
        application->launch();

        vector<string> textLines;

        for(;;)
        {
          //      session->beginUpdate();
          textLines.clear();
          for(int x=58; x>0; --x)
          {
            char ch;
            if(!source.get(ch))
            {
              reachedEOF = true;
              s = "";
            }
            else
            {
              source.putback(ch);
              getline(source, s);
              textLines.push_back(s);
            }
          }
          text->string = textLines;
          if(reachedEOF)
          {
            tr->children.remove(textPage->getNextButton());
          }
          //      session->endUpdate();
          directoryRefresh.wait();
          if(quit)
            return 0;
        }
        return 0;
      }
    }
  }
}

int main(int argc, const char *argv[]) throw()
{
  using namespace Archon::X3D;

  set_unexpected(Exception::terminal<Proxy::exceptionCatchInfo>);
  set_terminate (Exception::terminal<Proxy::exceptionCatchInfo>);

  return Archon::SaiTestApps::Textviewer::main(argc, argv);
}

---