GLUTCallbackFunctions.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------

// Last Change: 2004/06/14
//     Version: 0.2

//--------------------------------------------------------------------includes-
#include "../src/main.h"
#include "../src/Graph.h"
#include "../src/RadialLayout.h"
#include "../src/GLUTCallbackFunctions.h"

//----------------------------------------------------------------file globals-
int main_window;

Graph *graph_;
RadialLayout *radial_layout_;

GLuint screen_width_;
GLuint screen_height_;

GLuint selected_animation_speed_;
GLint selected_render_mode_;

GLuint clicked_object_id_ = 0;
GLuint motion_object_id_ = 0;

bool is_animation_mode_active_ = false;
bool is_fullscreen_mode_on_ = false;

bool is_animation_running_ = false;
GLuint num_iterations_ = 0;

GLint last_x_pos_;
GLint last_y_pos_;

bool is_reset_rotation_ = true;
GLfloat x_rotation_ = 0.0;
GLfloat y_rotation_ = 0.0;
GLfloat z_rotation_ = 0.0;

bool is_left_mouse_button_down_ = true;
int is_caption_enabled_ = true;

//--------------------------------------------------------------myGLUTInitFunc-
//
// This is the callback function for the GLUT initializations.
// @param graph The graph to draw.
// @param radial_layout The radiallayout to draw.
// @param screen_width The screen width.
// @param screen_height The screen height.
//
void createGLUTWindow(Graph *graph, RadialLayout *radial_layout,
                      GLuint screen_width, GLuint screen_height)
{
  screen_width_ = screen_width <= 0 ? 100 : screen_width;
  screen_height_ = screen_height <= 0 ? 100 : screen_height;
  if (graph == NULL)
  {
    cerr << "Graph is NULL." << endl;
    exit(0);
  }
  graph_ = graph;

  if (radial_layout == NULL)
  {
    cerr << "Radial Layout is NULL." << endl;
    exit(0);
  }
  radial_layout_ = radial_layout;

  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutInitWindowPosition(50, 50);
  glutInitWindowSize(800, 600);
  main_window = glutCreateWindow("InfoViz: Animated Radial Tree Exploration");

    // assign the GLUT callback functions
  glutDisplayFunc(renderScene);

  glutReshapeFunc(myGLUTReshapeFunc);
  glutKeyboardFunc(myGLUTKeyboardEventFunc);
  glutMouseFunc(myGLUTMouseEventFunc);
  glutMotionFunc(myGlutMotion);

  // create graph
  graph_->createGraph("Hallo");
    // create the GLUI
  createGLUI();
    // run the GLUT main moop and wait for events
  glutMainLoop();
}

//------------------------------------------------------------------createGLUI-
//
// This creates the GLUI for the application.
//
void createGLUI()
{
//exit(3434);
  GLUI *glui_window = GLUI_Master.create_glui("Menu");
    // for he animation speed

  GLUI_Spinner *animation_speed_spinner =
    glui_window->add_spinner("Speed:", GLUI_SPINNER_INT,
                             &selected_animation_speed_);

  animation_speed_spinner->set_int_limits(100, 2000);

    // for he render mode
  GLUI_Panel *radio_group_panel = glui_window->add_panel("Render Mode");
  GLUI_RadioGroup *render_mode_radio_group =
    glui_window->add_radiogroup_to_panel(radio_group_panel,
                                         &selected_render_mode_, 1,
                                         (GLUI_Update_CB)updateRenderMode);

    // put on the GLUI
  glui_window->add_checkbox("Enable Caption", &is_caption_enabled_, 2,
                             (GLUI_Update_CB)toggleCaptionEnabling);
  glui_window->add_radiobutton_to_group(render_mode_radio_group,
                                        "Ivan's Version");
  glui_window->add_radiobutton_to_group(render_mode_radio_group,
                                        "Laura's Version");
  glui_window->add_button("Demo", 0, (GLUI_Update_CB)startDemoMode);
  glui_window->add_button("Reset Rotation", 0,
                          (GLUI_Update_CB)resetSceneRotation);
  glui_window->add_separator();
  glui_window->add_button("Quit", 0, (GLUI_Update_CB)exit);

  glui_window->set_main_gfx_window(main_window);

    // register the idle callback with GLUI (not with GLUT!)
  GLUI_Master.set_glutIdleFunc(myGLUTIdleFunc);
}

//-----------------------------------------------------------------renderScene-
//
// This renders the entire scene into OpenGL.
//
void renderScene()
{
  if ((is_animation_running_ == false)
    && (is_animation_mode_active_ == true))
  {
    num_iterations_ = 1;
    is_animation_running_ = true;
    graph_->setAnimationMode(true);
  }
  if (num_iterations_ <= selected_animation_speed_)
  {
    ++num_iterations_;
  }
  
  graph_->setAnimationSpeed(&selected_animation_speed_);

  GLfloat width_height_aspect =
    (GLfloat)screen_width_ / (GLfloat)screen_height_;

  glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //glMatrixMode(GL_PROJECTION);
  //glLoadIdentity();
  glFrustum(-width_height_aspect * 0.04, width_height_aspect * 0.04, -0.04,
            0.04, 0.1, 15.0);

  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity(); // reset the view

  //        position  view      up vector
  gluLookAt(0, 0, 6,  0, 0, 0,   0, 1, 0);
  
  // number of circles
  GLint num_circles = 10;

  // radius of the starting circle
  GLfloat radius = -0.1f;
  GLUquadricObj *qobj;
  qobj = gluNewQuadric();

  if (is_reset_rotation_ == true)
  {
    glRotatef(0.0f, 0.0f, 1.0f, 0.0f);
    glRotatef(0.0f, 1.0f, 0.0f, 0.0f);
    glRotatef(0.0f, 0.0f, 0.0f, 1.0f);
    is_reset_rotation_ = false;
    y_rotation_ = 0.0f;
    x_rotation_ = 0.0f;
    last_y_pos_ = 0.0f;
    last_x_pos_ = 0.0f;
    myGlutMotion(last_x_pos_, last_y_pos_);
  }
  else
  {
    glRotatef(y_rotation_, 0.0f, 1.0f, 0.0f);
    glRotatef(x_rotation_, 1.0f, 0.0f, 0.0f);
    glRotatef(0.0f, 0.0f, 0.0f, 1.0f);
  }
  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
  glEnable(GL_LINE_SMOOTH);
  gluQuadricNormals(qobj, GLU_SMOOTH);
  glDisable(GL_BLEND);
  radial_layout_ -> setNumberDisplayedRings(num_circles);
  radial_layout_ -> setRadiusOfRing(1, radius);
  radial_layout_ -> renderRadialLayout(qobj);

  glInitNames();
  glPushName(0);
  graph_->setSceneRotation(x_rotation_, y_rotation_, z_rotation_);
  graph_->drawGraph(qobj);
  glColor3f(1.0f, 1.0f, 1.0f);
  glDisable(GL_LINE_SMOOTH);

  // swap buffers
  glutSwapBuffers(); 
  gluDeleteQuadric(qobj);
}

//--------------------------------------------------------------myGLUTIdleFunc-
//
// This creates the GLUI for the application.
//
void myGLUTIdleFunc()
{
    // the current window is undefined during an idle callback; therefore we
    // need to explicitly change it if necessary
  if (glutGetWindow() != main_window)
  {
    glutSetWindow(main_window);
  }
  glutPostRedisplay();
}

//-----------------------------------------------------------myGLUTReshapeFunc-
//
// This reshapes the OpenGL window to specified resolution.
//
void myGLUTReshapeFunc(GLint screen_width, GLint screen_height)
{
  GLfloat width_height_aspect =
    (GLfloat)screen_width / (GLfloat)screen_height;

  glViewport(0, 0, screen_width, screen_height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  glutPostRedisplay();
}

//------------------------------------------------------------updateRenderMode-
//
// This updates the render mode.
//
void updateRenderMode()
{
  graph_->toggleRenderMode();
}

//------------------------------------------------------------updateRenderMode-
//
// This starts the demo mode.
//
void startDemoMode()
{
  if (is_animation_mode_active_ == false)
  {
    num_iterations_ = 1;
    is_animation_mode_active_ = true;
    is_animation_running_ = true;
    graph_->setAnimationMode(true);
  }
  else
  {
    is_animation_mode_active_ = false;
  }
}

//-----------------------------------------------------myGLUTKeyboardEventFunc-
//
// This handles the key board events.
// @param key The user-typed key.
// @param x_pos The keyboard's x position.
// @param y_pos The keyboard's y position.
//
void myGLUTKeyboardEventFunc(unsigned char key, int x_pos, int y_pos)
{
  switch(key)
  {
  case 27 :
  case 'q' :
    exit(0);
  case GLUT_KEY_F1 :
    if (!is_fullscreen_mode_on_)
    {
      glutFullScreen();
      is_fullscreen_mode_on_ = true;
    }
    else
    {
      glutReshapeWindow(800, 600);
      is_fullscreen_mode_on_ = false;
    }
    break;
  case 'a' :
    startDemoMode();
    break;
  case 'm' :
    graph_->toggleRenderMode();
    break;
  default :
    break;
  };
}

//--------------------------------------------------------myGLUTMouseEventFunc-
//
// This handles the mouse events.
// @param button Holds the flag which mouse button has been clicked.
// @param state Indicates whether the mouse button is up or down.
// @param x_pos The mouse cursor's x position.
// @param y_pos The mouse cursor's y position.
//
void myGLUTMouseEventFunc(int button, int state, int x_pos, int y_pos)
{
  if (button == GLUT_LEFT_BUTTON)
  {
    cout << x_pos << " " << y_pos << endl;
      // Here we pass in the cursors X and Y co-ordinates to test
      // an object under the mouse.
    clicked_object_id_ = retrieveObjectID(x_pos, y_pos);
    graph_->highlightNodeIfSelected(clicked_object_id_);

    if ((graph_->isANodeClicked(clicked_object_id_))
        && (is_animation_running_ == false))
    {
      num_iterations_ = 1;
      is_animation_running_ = true;
      graph_->setCenterNode(clicked_object_id_);
    }
  }
  if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
  {
    is_left_mouse_button_down_ = true;
  }
  else// (button == GLUT_LEFT_BUTTON && state == GLUT_UP)
  {
    is_left_mouse_button_down_ = false;
  }
}

//------------------------------------------------------------retrieveObjectID-
//
// This finds the object which was clicked by the user given the x, y
// coordinates.
// @param x_coord The x coordinate of the viewport.
// @param y_coord The y coordinate of the viewport.
//
int retrieveObjectID(int x_coord, int y_coord)
{
  int objectsFound = 0;
  int viewportCoords[4] = {0};

  unsigned int selectBuffer[1024] = {0};

  glSelectBuffer(1024, selectBuffer);
  glGetIntegerv(GL_VIEWPORT, viewportCoords);

  glMatrixMode(GL_PROJECTION);  
  glPushMatrix();
  glRenderMode(GL_SELECT);
  glLoadIdentity();
  gluPickMatrix(x_coord, viewportCoords[3] - y_coord, 2, 2, viewportCoords);

  gluPerspective(45.0f,(float)screen_width_/(float)screen_height_,0.1f,150.0f);
  glMatrixMode(GL_MODELVIEW);

  renderScene();

  objectsFound = glRenderMode(GL_RENDER);
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  glMatrixMode(GL_MODELVIEW);

  if (objectsFound > 0)
  {
    unsigned int lowestDepth = selectBuffer[1];

    int selectedObject = selectBuffer[3];

      // Return the selected object
    return selectedObject;
  }
  return 0;
}

//----------------------------------------------------------------myGlutMotion-
//
// This is the callback function for the motions in the scene.
// @param x_pos The x position of the viewport.
// @param y_pos The y position of the viewport.
//
void myGlutMotion(int x_pos, int y_pos)
{
  if (!is_left_mouse_button_down_)
  {
    x_rotation_ += (GLfloat) (y_pos - last_y_pos_);
    y_rotation_ += (GLfloat) (x_pos - last_x_pos_);

    last_x_pos_ = x_pos;
    last_y_pos_ = y_pos;

    if ((last_x_pos_ == screen_width_ / 2) ||
        (last_y_pos_ == screen_height_ / 2))
    {
    }
    else
    {
      if (((x_pos - screen_width_ / 2) * (last_y_pos_ - screen_height_ / 2)
           - (last_x_pos_ - screen_width_ / 2) * (y_pos - screen_height_ / 2))
          > 0)
      {
        z_rotation_ += (GLfloat) ((abs(x_pos - last_x_pos_)
                                   + abs(y_pos - last_y_pos_)));
      }
      else
      {
        z_rotation_ += (GLfloat) (-1*(abs(x_pos - last_x_pos_)
                                      + abs(y_pos - last_y_pos_)));
      }
    }

    glutPostRedisplay();
  }
}

//----------------------------------------------------------resetSceneRotation-
//
// This resets the rotation of the entire scene.
//
void resetSceneRotation()
{
  is_reset_rotation_ = true;
}

//--------------------------------------------------------toggleCaptionEnabling-
//
// This toggles the caption of the nodes. If enablen the caption's will be
// displayed.
//
void toggleCaptionEnabling()
{
  graph_->toggleCaptionMode();
}

// eof

---