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 <iostream> 

#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/text.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 Filebrowser
    {
      Mutex mutex;
      Condition directoryRefresh(mutex);
      
      string path;
      
      Ref<Shape> inactiveBoxShape;
      Ref<Shape> activeBoxShape;
      
      void handleSignalIO(int s)
      {
        directoryRefresh.notifyAll();
      }
      
      void handleBack(Time)
      {
        {
          Mutex::Lock l(mutex);
          chdir("..");
          path = File::getCWD();
        }
        directoryRefresh.notifyAll();
      }
      
      void handleSubdir(Time, string dir)
      {
        {
          Mutex::Lock l(mutex);
          chdir(dir.c_str());
          path = File::getCWD();
        }
        directoryRefresh.notifyAll();
      }
      
      void handleText(Time, string file)
      {
        {
          cerr << "FILE=" << file << "\n";
          Mutex::Lock l(mutex);
          string s = "archon_textviewer " + file + " &";
          system(s.c_str());
        }
      }
      
      void handleX3D(Time, string file)
      {
        {
          cerr << "FILE=" << file << "\n";
          Mutex::Lock l(mutex);
          string s = "archon_x3d_viewer " + file + " &";
          system(s.c_str());
        }
      }
      
      void handlePDB(Time, string file)
      {
        {
          cerr << "FILE=" << file << "\n";
          Mutex::Lock l(mutex);
          string s = "archon_molecule " + file + " &";
          system(s.c_str());
        }
      }
      
      void handleExecutable(Time, string file)
      {
        {
          cerr << "FILE=" << file << "\n";
          Mutex::Lock l(mutex);
          string s = file + " &";
          system(s.c_str());
        }
      }
      
      class TextBox: public virtual RefObjectBase
      {
        string textString;
        Ref<Application> application;
        Ref<Transform> transform;
      public:
        TextBox(string s, Ref<Application> a) 
        {
          textString = s;
          application = a;
          
          // Box
          Ref<Transform> boxTransform = Transform::create(application);
          boxTransform->scale = Vector3(3, 0.8, 0.1);
          boxTransform->children.add(inactiveBoxShape);
          
          // Text
          Ref<Transform> textTransform = Transform::create(application);
          textTransform->translation = Vector3(-2.9, 0, 0.11);
          
          Ref<FontStyle> fontStyle = FontStyle::create(application);
          vector<string> justifyStrings;
          justifyStrings.push_back("BEGIN");
          justifyStrings.push_back("MIDDLE");
          fontStyle->justify = justifyStrings;
          
          Ref<X3D::Proxy::Text> text = X3D::Proxy::Text::create(application);
          text->string.add(textString);
          text->maxExtent = 5.8;
          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.7, 0.7, 0.2);
          textApp->material = textMaterial;
          textShape->appearance = textApp;
          textShape->geometry = text;
          textTransform->children.add(textShape);

          // Transform
          transform = Transform::create(application);
          transform->children.add(boxTransform);
          transform->children.add(textTransform);
        }
  
        Ref<Transform> getTransform()
        {
          return transform;
        }

      };


      class FileScan
      {
      private:
        DIR *fd;
  
      public:
        FileScan(string s, void(*func)(int))
        { 
          struct sigaction sa;
          sa.sa_handler = func;
    
          if(sigaction(SIGIO, &sa, 0))
          {
            cerr << "Signal handler NOT installed\n";
            abort();
          }

          fd = opendir(s.c_str()); 
          int fd_dir = dirfd(fd);
          if(fd_dir == -1)
          {
            cerr << "Directory -> FD failed\n";
            abort();
          }
    
          if(fcntl(fd_dir, F_SETFL, O_ASYNC) == -1)
          {
            cerr << "IOCTL NOT called succesfully\n";
            abort();
          }

          if(fcntl(fd_dir, F_NOTIFY, DN_MULTISHOT|DN_CREATE|DN_DELETE|DN_RENAME) == -1)
          {
            cerr << "IOCTL NOT called succesfully\n";
            abort();
          }
        }
  
        ~FileScan()
        {
          if(fd)
            if(closedir(fd))
            {
              cerr << "IO-operation (close) failed.\n";
              abort();
            }
        }
      };

      int fileSort(const void *a, const void *b)
      {
        struct stat a_filestat;
        struct stat b_filestat;

  
        lstat((*(const struct dirent **)(a))->d_name, &a_filestat);
        lstat((*(const struct dirent **)(b))->d_name, &b_filestat);
  
        if(S_ISDIR(a_filestat.st_mode) && !S_ISDIR(b_filestat.st_mode))
          return -1;
        else if(!S_ISDIR(a_filestat.st_mode) && S_ISDIR(b_filestat.st_mode))
          return 1;
        else
          return alphasort(a, b);
      }

      void drawDirectory(string fullPath, Ref<Application> application, Ref<GroupingNode> rootGroup)
      {
        struct stat filestat;
        struct dirent **namelist;
        int n;
        int radius=30;
        int x=0;
        int y=11;
        vector<Ref<ChildNode> > children0;
        Ref<Transform> rootTransform;

        // Setup Point light
        Ref<Transform> lightTransform = Transform::create(application);
        lightTransform->translation = Vector3(0, 10, 0);
        Ref<PointLight> light = PointLight::create(application);
        light->location = Vector3(0, 10, 0);
        light->on = true;
        light->color = Vector3(1, 1, 1);
        light->intensity = 0.7;
        lightTransform->children.add(light);
        children0.push_back(lightTransform);
 
        n = scandir(fullPath.c_str(), &namelist, 0, fileSort);
        if(n < 0)
        {
          cerr << "scandir error\n";
          abort();
        }
        else 
        {
          for(int i=0;i<n;++i)
          {
            if(strcmp(namelist[i]->d_name,".") == 0) 
            {
              free(namelist[i]);
              continue;
            }
      
            rootTransform = Transform::create(application);
            rootTransform->rotation = Rotation3(Vector3(0, -1, 0), x*6.05/radius);
            rootTransform->translation = Vector3(0, 0, 0);

            if(strcmp(namelist[i]->d_name,"..") == 0) 
            {

              Ref<TextBox> textBox = new TextBox("../", application);
              Ref<Transform> tr = textBox->getTransform();
              tr->translation = Vector3(0, y*1.8, -radius);

              Ref<TouchSensor> touch = TouchSensor::create(application);
              touch->touchTime.registerInterest<SFTime>(new FuncCaller<SFTime>(handleBack));
              rootTransform->children.add(tr);
              rootTransform->children.add(touch);
              children0.push_back(rootTransform);

              free(namelist[i]);
              y--;
              if(y<1)
              {
                y=11;
                x++;
              } 
              continue;
            }

            string s;
            if(fullPath == "/")
              s = fullPath + static_cast<string>(namelist[i]->d_name);
            else
              s = fullPath + "/" + static_cast<string>(namelist[i]->d_name);
            lstat(s.c_str(), &filestat);
            int perm = access(s.c_str(), X_OK);
      
            s = static_cast<string>(namelist[i]->d_name);
      
            if(S_ISDIR(filestat.st_mode))
            {
              Ref<TextBox> textBox = new TextBox(s + "/", application);
              Ref<Transform> tr = textBox->getTransform();
              tr->setTranslation(Vector3(0, y*1.8, -radius));

              if(perm==0)
              {
                Ref<TouchSensor> touch = TouchSensor::create(application);
                touch->touchTime.registerInterest<SFTime>(new CookieFuncCaller<SFTime, string>(handleSubdir, s));
                rootTransform->children.add(touch);
              }
              rootTransform->children.add(tr);
            }
            else
            {
              Ref<TextBox> textBox = new TextBox(s, application);
              Ref<Transform> tr = textBox->getTransform();
              tr->translation = Vector3(0, y*1.8, -radius);

              if(perm==0)
              {
                Ref<TouchSensor> touch = TouchSensor::create(application);
                touch->touchTime.registerInterest<SFTime>(new CookieFuncCaller<SFTime, string>(handleExecutable, s));
                rootTransform->children.add(touch);
              }
              else if(Archon::Utilities::Text::isSuffixOf(".x3d", s, true))
              {
                Ref<TouchSensor> touch = TouchSensor::create(application);
                touch->touchTime.registerInterest<SFTime>(new CookieFuncCaller<SFTime, string>(handleX3D, s));
                rootTransform->children.add(touch);
              }
              else if(Archon::Utilities::Text::isSuffixOf(".pdb", s, true))
              {
                Ref<TouchSensor> touch = TouchSensor::create(application);
                touch->touchTime.registerInterest<SFTime>(new CookieFuncCaller<SFTime, string>(handlePDB, s));
                rootTransform->children.add(touch);
              }
              else
              {
                Ref<TouchSensor> touch = TouchSensor::create(application);
                touch->touchTime.registerInterest<SFTime>(new CookieFuncCaller<SFTime, string>(handleText, s));
                rootTransform->children.add(touch);
              }

              rootTransform->children.add(tr);
            }
            children0.push_back(rootTransform);
            free(namelist[i]);
            y--;
            if(y<1)
            {
              y=11;
              x++;
            } 
          }
          free(namelist);
        }

        children0.push_back(rootTransform);
        rootGroup->children = children0;
      }

      int main(int argc, const char *argv[]) throw()
      {
        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] << "\n"
            "\n"
            "Available options:\n";
          cout << o.list();
          return 0;
        }

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

        if(argc == 2)
        {
          path = argv[1];
          chdir(argv[1]);
        }
        else path = File::getCWD();

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

        inactiveBoxShape = Shape::create(application);
        Ref<Appearance> inactiveAppearance = Appearance::create(application);
        Ref<Material> inactiveMaterial = Material::create(application);
        inactiveMaterial->diffuseColor = Vector3(0.3, 0.3, 0.8);
        inactiveMaterial->transparency = 0.7;
        inactiveAppearance->material = inactiveMaterial;
        Ref<Box> inactiveBox = Box::create(application);
        inactiveBoxShape->geometry = inactiveBox;
        inactiveBoxShape->appearance = inactiveAppearance;

        activeBoxShape = Shape::create(application);
        Ref<Appearance> activeAppearance = Appearance::create(application);
        Ref<Material> activeMaterial = Material::create(application);
        activeMaterial->diffuseColor = Vector3(0.5, 0.5, 0.8);
        activeMaterial->transparency = 0.2;
        activeAppearance->material = activeMaterial;
        Ref<Box> activeBox = Box::create(application);
        activeBoxShape->geometry = activeBox;
        activeBoxShape->appearance = activeAppearance;

        Ref<Transform> rootTransform = Transform::create(application);
        rootTransform->scale = Vector3(.8, .8, .8);
        rootTransform->translation = Vector3(0, -7, 4);

        rootGroup->children.add(rootTransform);

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

        for(;;)
        {
          FileScan fs(path, handleSignalIO);
          session->beginUpdate();
          drawDirectory(path, application, rootTransform);
          session->endUpdate();
          directoryRefresh.wait();
        }

        return 0;
      }
    }
  }
}

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

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

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

---