AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

MainController.cpp

Go to the documentation of this file.

//                            MainController.cpp                              //

#include <qspinbox.h>
#include <qfiledialog.h>
#include <qstatusbar.h>
#include <qmessagebox.h>
#include <qtoolbar.h>
#include <qmenubar.h>
#include <qtoolbutton.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qlayout.h>
#include <qlcdnumber.h>
#include <qdockarea.h>
#include <qgroupbox.h>


#include <animal/event/keyEvent.h>
#include <animal/event/mouseEvent.h>
#include <animal/X3DTK/Qt/x3dTransformGUI/x3dTransformQt.h>
#include <animal/X3DTK/Qt/world/qglviewerWorld.h>
#include <iostream>
using std::cout;
using std::cerr;
using std::endl;

#include "MainController.h"

animal::World * animal::Engine::theWorld = NULL;

static const char * recordButtonDown_xpm[] =
  {
    "16 16 4 1",
    "b c #f00000",
    "a c #f00606",
    "# c #f33434",
    ". c none",
    "................",
    "................",
    "......#aa#......",
    "....#bbbbbb#....",
    "...#bbbbbbbb#...",
    "...bbbbbbbbbb...",
    "..#bbbbbbbbbb#..",
    "..abbbbbbbbbba..",
    "..abbbbbbbbbba..",
    "..#bbbbbbbbbb#..",
    "...bbbbbbbbbb...",
    "...#bbbbbbbb#...",
    "....#bbbbbb#....",
    "......#aa#......",
    "................",
    "................"
  };

static const char * recordButton_xpm[] =
  {
    "16 16 4 1",
    "b c #0000f0",
    "a c #0606f0",
    "# c #3434f3",
    ". c none",
    "................",
    "................",
    "......#aa#......",
    "....#bbbbbb#....",
    "...#bbbbbbbb#...",
    "...bbbbbbbbbb...",
    "..#bbbbbbbbbb#..",
    "..abbbbbbbbbba..",
    "..abbbbbbbbbba..",
    "..#bbbbbbbbbb#..",
    "...bbbbbbbbbb...",
    "...#bbbbbbbb#...",
    "....#bbbbbb#....",
    "......#aa#......",
    "................",
    "................"
  };

MainController::MainController(X3DTK::MainScene * mainScene, bool use_docked_windows)
    : MainControllerDesigner(NULL, NULL, Qt::WDestructiveClose|Qt::WType_TopLevel)
    , mainScene(mainScene)
    ,x3dDirectory(std::string("."))
{
  // init the viewer
  viewer->setMainController(this);
  viewer->show();

  // create the world associated to the viewer
  animal::Engine::setWorld(new X3DTK::Qt::QGLViewerWorld(viewer->camera()));

  // init the main scene
  mainScene->setMainController(this);

  // init the x3d qt tree
  x3dtreeqt->setMainController(this);
  x3dtreeqt->show();
  defineQWidgetCreationFunction(X3DTK::Qt::createTransformQWidget);

  //  Timer to call doStep()
  animTimer = new QTimer(this);
  connect(animTimer, SIGNAL(timeout()), this, SLOT(doStep()));
  // display animation rate
  connect( this, SIGNAL( animationFrequency( int ) ), update_rate_lCDNumber, SLOT( display(int) ) );

  // init the data for the animation
  go = false;
  realTime = false;
  animStep = 0.001*dt_SpinBox->value();
  displayStep = static_cast<int>(1000.0/delay_SpinBox->value());

  if( use_docked_windows )
  {
    // Create dock windows
    w1 = new QDockWindow( rightDock(), "dock1");
    w1->setResizeEnabled(true);
    x3dtreeqt->reparent(w1,0,QPoint(0,0));
    x3dtreeqt->setMaximumWidth(10000);
    w1->setWidget(x3dtreeqt);

    viewer->reparent(this,0,QPoint(0,0));
    setCentralWidget(viewer);
    viewer->setMaximumWidth(10000);

    w2 = new QDockWindow( topDock(), "dock2");
    w2->setResizeEnabled(true);
    groupBoxAnimation->reparent(w2,0,QPoint(0,0));
    w2->setWidget(groupBoxAnimation);
  }
}

// MainController::~MainController()
// {
//   //std::cerr<< "MainController::~MainController()"<<std::endl;
// }

//----------- Setters ------------
void MainController::setViewer(X3DTK::Qt::Viewer * v)
{
  if (viewer)
  {
    delete viewer;
    viewer = NULL;
  }

  if (v)
  {
    viewer = v;
    viewer->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)7, 0, 0, viewer->sizePolicy().hasHeightForWidth() ) );
    viewer->setMinimumSize( QSize( 320, 240 ) );
    viewer->setMainController(this);
    MainControllerDesignerLayout->addWidget( viewer, 1, 0 );
    viewer->show();
  }
}
void MainController::addEngine(animal::Engine * E)
{
  mainScene->addEngine(E);
  viewer->viewAll();
}

//----------- Slots for the animation -------------

void MainController::doStep()
{
  static double cumulatedTime = 0;
  static int nbSteps = 0;
  const int period = 25;

  double dt = 0.001 * clock.restart();
  cumulatedTime += dt;
  nbSteps++;
  if( nbSteps==period )
  {
    emit animationFrequency( static_cast<int>(period/cumulatedTime) );
    //cerr<<"animationFrequency = "<<static_cast<int>(period/cumulatedTime)<<endl;
    nbSteps=0;
    cumulatedTime = 0;
  }


  if(!realTime)
    dt = animStep;

  mainScene->move(dt);
  viewer->drawAfterAnimation();
}


void MainController::startStop()
{
  // go is true if the animation is playing
  go = !go;

  if (go)
  {
    // Clock for real time
    clock.restart();
    // animTimer is the timer which is connected to the slot doStep()
    animTimer->start(displayStep, FALSE);
  }
  else
    animTimer->stop();
}

void MainController::reset()
{
  mainScene->reset();
  //viewer->updateFrustum();
  viewer->updateGL();
}

void MainController::setAnimStep( int ms)
{
  // animStep simulates time step for animation if realTime is false
  animStep = 0.001*ms;
}


void MainController::setDisplayFreq( int hz)
{
  // displayStep is the time interval for calling doStep()
  if( hz==0 )
  {
    displayStep = 0;
    animTimer->changeInterval( displayStep );
  }
  else
  {
    displayStep = static_cast<int>(1000.0/hz);
    animTimer->changeInterval( displayStep );
  }
  if( !go )
    animTimer->stop();
}


void MainController::setRealTime(bool b)
{
  // realTime is true if the animation is computing in real time
  if( realTime != b )
  {
    realTime = b;
    if( realTime )
      clock.restart();
  }
}

//----------- End - Slots for the animation -------------
void MainController::activatedManipMode()
{
  std::cerr<<"MainController::activatedManipMode "<<std::endl;
}

//----------- Slots for Input/Output ------------

//void MainController::createX3dLoader( X3DTK::X3D::EngineNodeCreator *  creator)
//{
//    mainScene->initX3dLoader(creator);//new X3DTK::X3D::QLoader(creator));
//
//}

void MainController::fileOpen()
{
  fileOpen("");
}

void MainController::fileOpen(const char * filename)
{
  if (filename=="")
    openFile = QFileDialog::getOpenFileName(  x3dDirectory.data(),
               "X3D files (*.x3d)",
               this,
               "file open",
               "X3DAnimAL -- File Open" );
  else
    openFile = QString(filename);


  if (!QFile::exists(openFile))
  {
    statusBar()->message( "File not found: open abandoned" );
    return;
  }

  // Loads the file name.
  mainScene->load(openFile);
  // View all the scene
  viewer->viewAll();
  //Reset the qt x3d tree root node
  x3dtreeqt ->setSceneGraphRoot(mainScene->getX3DScene());
}

void MainController::fileInsert( X3DTK::X3D::X3DNode  * node)
{
  QString filename = QFileDialog::getOpenFileName(
                       QString::null, "X3D Files (*.x3d)", this,
                       "file insert", "X3DAnimAL -- File Insert" );
  if ( filename.isEmpty() )
    statusBar()->message( "File Insert abandoned" );
  else
  {
    // Loads the file name.
    mainScene->load(filename, node);
    // View all the scene
    viewer->viewAll();
  }
}

void MainController::fileSave()
{
  QString filename = QFileDialog::getSaveFileName(
                       QString::null, "X3D Files (*.x3d)", this,
                       "file save", "X3DAnimAL -- File Save" );
  if ( filename.isEmpty() )
    statusBar()->message( "File Save abandoned" );
  else
  {
    // Verify if the file exists
    QFile file(filename);
    if (file.exists())
    {
      switch( QMessageBox::warning( this, "File Name",
                                    "The file "+filename+" already exists.\n"
                                    "OK to overwrite it.\n\n",
                                    "Yes",
                                    "No",
                                    "Cancel",0, 1) )
      {
      case 0: // The user clicked the "Yes" button or pressed Enter
        mainScene->save(filename);
        break;
      case 1: // The user clicked the "No" or pressed Escape
        fileSave();
        break;
      case 2: // The user clicked the "Cancel"
        statusBar()->message( "File Save abandoned" );
        break;
      }
    }
    else
      mainScene->save(filename);
  }
}


void MainController::fileReload()
{
  if ( openFile.isEmpty() )
    statusBar()->message( "File Open abandoned" );
  else
  {
    // Loads the file name.
    mainScene->load( openFile);
    // View all the scene
    viewer->viewAll();
    //Reset the qt x3d tree root node
    x3dtreeqt ->setSceneGraphRoot(mainScene->getX3DScene());
  }
}

//----------- End - Slots for Input/Output ------------

//----------- Slots for GUI --------------------

void MainController::toolBarSetShown(bool b)
{
  toolBar->setShown(b);
}

void MainController::menuBarSetShown(bool b)
{
  menubar->setShown(b);
  statusBar()->setShown(b);
}

void MainController::clickedRecordButton()
{
  if (recordButton->isOn())
  {
    viewer->getViewerGUI()->move(this->x(),this->y());
    viewer->getViewerGUI()->hide();
    viewer->getViewerGUI()->show();
    recordButton->setOn(false);
  }
  else
  {
    toggleRecord(false);
  }
}

//----------- End -  Slots for GUI --------------------

//----------- Slot for display ------------------------
void MainController::display()
{
  viewer->updateGL();
}
void MainController::computeBbox()
{
  mainScene->computeBbox();
}
void MainController::viewAll()
{
  viewer->viewAll();
}
//----------- End - Slots for display -----------------

//----------- Recording state -------------------------
void MainController::toggleRecord(bool b)
{
  if (b)
  {
    if (viewer->setSnapshot(true))
    {
      recordButton->setPixmap(QPixmap(recordButtonDown_xpm));
      recordButton->setOn(true);
      viewer->getViewerGUI()->hide();
    }
    else
      switch( QMessageBox::warning( this, "Files names of captured frames",
                                    "The files names of captured frames are not valid !\nThe pattern of these names depends on the video file name.\nIf the video file name is video.mpg,\nthe pattern is video####.ppm.",
                                    "New video file name",
                                    "Quit", 0, 0, 1 ) )
      {
      case 0: // The user clicked the Retry again button or pressed Enter
        viewer->getViewerGUI()->chooseVideoName();
        break;
      case 1: // The user clicked the Quit or pressed Escape
        statusBar()->message( "Capture abandoned" );
        break;
      }
  }
  else
  {
    viewer->setSnapshot(false);
    recordButton->setPixmap(QPixmap(recordButton_xpm));
    recordButton->setOn(false);
    viewer->getViewerGUI()->move(this->x(),this->y());
    viewer->getViewerGUI()->hide();
    viewer->getViewerGUI()->show();
  }
}
//----------- End - Recording state --------------------

//-----------X3DTK::X3D::X3DNode and their item-------------
void MainController::addNode(X3DTK::X3D::X3DNode * node)
{
  x3dtreeqt->addNode(node);
}

//----------- X3D node and their corresponding QWidget --

void MainController::removeX3DQtMap(X3DTK::X3DAbstractNode* EN)
{
  if (x3dQtMap[EN])
  {
    //std::cerr<<"MainController::removeX3DQtMap"<<std::endl;
    QWidget * q = x3dQtMap[EN];

    // Erase all the node which associated QWidget is x3dQtMap[EN]
    X3DTK::MFNode nodeToErase;
    for (X3DQtMap::iterator i=x3dQtMap.begin(); i!=x3dQtMap.end(); ++i )
      if ( (*i).second == q)
      {
        nodeToErase.push_back((*i).first);
      }
    for (X3DTK::MFNode::iterator i=nodeToErase.begin(); i!=nodeToErase.end(); ++i )
      x3dQtMap.erase(*i);

    // Delete the QWidget x3dQtMap[EN]
    if(q)
      delete q;
  }

  // Remove from X3DQtMap the QWidget of X3DTK::X3D::Transform parent of X3DTK::X3D::FrameNode EN
  // In fact, X3DTK::X3D::Transform changed attributes of its associated X3DTK::X3D::FrameNode
  if (dynamic_cast<X3DTK::X3D::FrameNode *>(EN))
  {
    X3DTK::MFNode list = EN->getParentList();
    X3DTK::X3DAbstractNode * parentNode =(*list.begin());
    removeX3DQtMap(parentNode);
  }
}

QWidget * MainController::createQWidgetController(X3DTK::X3D::X3DNode * node)
{
  // Search the associated QWidget to the x3d engine node
  X3DTK::SFString string = node->getTypeName();
  for( X3DNodeQWidgetMap::iterator i=x3dNodeQWidgetMap.begin(); i!=x3dNodeQWidgetMap.end(); ++i )
    if((*i).first == string)
    {

      // The name of the node
      QString s1;
      X3DTK::SFString tmp = node->getName();
      if (tmp =="")
        s1 = QString(node->getType()->getName());
      else
        s1 = QString((node->getType()->getName()+" named "+tmp).data());

      // The dialog
      QDialog * dialog = new QDialog(this, s1);
      dialog->setCaption(s1);

      // Layout of the dialog
      QHBoxLayout * dialogLayout = new QHBoxLayout(dialog);
      dialogLayout->setAutoAdd(true);

      // The scroll bar
      QScrollView * sv = new QScrollView(dialog);
      sv->setResizePolicy(QScrollView::AutoOneFit);

      // Create the associated QWidget of the x3d node
      QWidget * Q = ((*i).second)(node, sv->viewport());
      if (Q)
      {

        QWidget::connect( Q, SIGNAL( changed() ), this, SLOT(computeBbox()));
        QWidget::connect( Q, SIGNAL( changed() ), this, SLOT(display()));

        sv->addChild(Q);
        //dialog->show();
        x3dQtMap[node] = dialog;
        return x3dQtMap[node];
      }
    }

  // How to link an x3d node to its QWidget
  std::cerr << std::endl;
  std::cerr << "Warning: a x3d node has no controller QWidget." << std::endl;
  std::cerr << "   To create an associated controller QWidget to one x3d node," << std::endl;
  std::cerr << "   see the documentation in $ANIMAL/doc/html/architecture.html#GUIController." << std::endl;

  return NULL;

}
//----------- End - X3D node and their corresponding QWidget --

//----------- Mouse and key board events -------------
void MainController::keyPressEvent(QKeyEvent *e)
{
  if (e->key()==Qt::Key_R)
  {
    viewer->getViewerGUI()->show();
  }

  animal::KeyEvent * AKE
  = new animal::KeyEvent(e->type(), e->key(), e->state());

  mainScene->keyPressEvent(AKE);

  if (animTimer->isActive())
    doStep();
}

void MainController::mouseDoubleClickEvent(QMouseEvent * e)
{
  float orig[3], dir[3];
  viewer->camera()->convertClickToLine(e->x(), e->y(), orig, dir);

  animal::MouseEvent * AME
  = new animal::MouseEvent( e->type(),
                            e->x(),
                            e->y(),
                            e->button(),
                            e->state(),
                            animal::Vec3(orig[0], orig[1], orig[2]),
                            animal::Vec3(dir[0], dir[1], dir[2]));

  mainScene->mouseDoubleClickEvent(AME);

  if (animTimer->isActive())
    doStep();
}

void MainController::mouseMoveEvent(QMouseEvent * e)
{
  float orig[3], dir[3];
  viewer->camera()->convertClickToLine(e->x(), e->y(), orig, dir);

  animal::MouseEvent * AME
  = new animal::MouseEvent( e->type(),
                            e->x(),
                            e->y(),
                            e->button(),
                            e->state(),
                            animal::Vec3(orig[0], orig[1], orig[2]),
                            animal::Vec3(dir[0], dir[1], dir[2]));
  mainScene->mouseMoveEvent(AME);

  if (animTimer->isActive())
    doStep();
}

void MainController::mousePressEvent(QMouseEvent * e)
{
  float orig[3], dir[3];
  viewer->camera()->convertClickToLine(e->x(), e->y(), orig, dir);

  animal::MouseEvent * AME
  = new animal::MouseEvent( e->type(),
                            e->x(),
                            e->y(),
                            e->button(),
                            e->state(),
                            animal::Vec3(orig[0], orig[1], orig[2]),
                            animal::Vec3(dir[0], dir[1], dir[2]));
  mainScene->mousePressEvent(AME);

  if (animTimer->isActive())
    doStep();
}

void MainController::mouseReleaseEvent(QMouseEvent * e)
{
  float orig[3], dir[3];
  viewer->camera()->convertClickToLine(e->x(), e->y(), orig, dir);

  animal::MouseEvent * AME
  = new animal::MouseEvent( e->type(),
                            e->x(),
                            e->y(),
                            e->button(),
                            e->state(),
                            animal::Vec3(orig[0], orig[1], orig[2]),
                            animal::Vec3(dir[0], dir[1], dir[2]));
  mainScene->mouseReleaseEvent(AME);

  if (animTimer->isActive())
    doStep();
}
//----------- End - Mouse and key board events -------------

// ----------  FF: picking -----------------------------
animal::ConstrainedItem* MainController::pickPoint( float origin[3], float direction[3],
    float threshold )
{
  return mainScene->pickPoint(origin, direction, threshold );
}
// ----------  end FF: picking -----------------------------


void MainController::setX3dDirectory(const std::string& d)
{
  x3dDirectory = d;
}


std::string MainController::getX3dDirectory() const
{
  return x3dDirectory;
}

---