---

View.h

Go to the documentation of this file.

/*
 * Copyright (C) 2003 Eric Bohm
 *
 *This program is free software; you can redistribute it and/or modify
 *it under the terms of the GNU General Public License as published by
 *the Free Software Foundation version 2 of the License.
 * 
 *This program is distributed in the hope that it will be useful, but
 *WITHOUT ANY WARRANTY; without even the implied warranty of
 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *General Public License for more details.
 * 
 *You should have received a copy of the GNU General Public License along
 *with this program; if not, write to the Free Software Foundation, Inc.,
 *675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
#ifndef IS_VIEW_DEF_SIG
#define IS_VIEW_DEF_SIG 1

using namespace std;
#include <GL/glut.h>
//#include <stl_function.h>
#include <functional>
#include <map>

#include "Timestep.h"
#include "RGB.h"




class View
{
 private:
  unsigned int fillpoly;        
  unsigned int colormap;        
  bool showlabel;               
  bool showlength;              
  bool opaque;                  
  bool pointmode;               
  double xtri;                  
  double ytri;                  
  double ztri;                  
  double ztran;                 
  double xtran;                 
  double ytran;                 
  unsigned int currstep;        
  int filenum;                  
  int solo_chunk;               
  map <unsigned int, RGB> chunks;  
  vector <bool> uptodate_step;    

  map < unsigned int, Timestep > timesteps; 
  map < unsigned int, Timestep >::iterator now; 
  vector <Coordinate> points; 
  
 public:
  double scale;                 
  int ScreenWidth, ScreenHeight;        
  float aspect_ratio;           

  View()
    {
      fillpoly = GL_FILL;
      solo_chunk=-1;
      scale=1.0;
      colormap = 0;
      showlabel = false;
      showlength = false;
      opaque = true;
      pointmode = false;
      xtri = 1.0;
      ytri = 1.0;
      ztri = 1.0;
      scale = 1.0;
      currstep=0;
      uptodate_step.reserve(10);
      filenum = 0;
      now=timesteps.begin();
    }
  
  unsigned int get_currstep()
    {
      return currstep;
    }

  void next_step()
    {
      now++;
      display_step(now->first);
    }

  void set_solo_chunk(int chunk)
    {
      solo_chunk=chunk;
      note_update();
      display();
    }

  void prev_step()
    {
      now--;
      display_step(now->first);
    }

  void animate(int direction)
    {
      if(direction>0)
        {
          
          while(now!=timesteps.end())
            {
              display_step(now->first);
              now++;
            }
        }
      else
        {
          while(now!=timesteps.begin())
            {
              now--;
              display_step(now->first);
            }
          //      display_step(now->first);
        }
    }

  void action_view();
  void recenter();

  void display_step(unsigned int);

  void display_first()
    {
      now=timesteps.begin();
      display_step(now->first);
    }

  void display()
    {
      display_step(currstep);
    }

  void redisplay_step(unsigned int step)
    {
      if(glIsList(step))
        glCallList(step);
      else
        display_step(step);
    }

  bool loadfile(const char *filename);

  void note_update ()
    {
      uptodate_step.assign(uptodate_step.size(),false);
    }

  void toggle_fillpoly()
    {
      fillpoly = fillpoly == GL_FILL ? GL_LINE : GL_FILL;
      note_update();
    }

  void toggle_showlabel()
    {
      showlabel = showlabel ? false : true;
      note_update();
    }

  void toggle_showlength()
    {
      showlength = showlength ? false : true;
      note_update();
    }

  void toggle_opaque()
    {
      opaque = opaque ? false : true;
      note_update();
    }

  void toggle_pointmode()
    {
      pointmode = pointmode ? false : true;
      note_update();
    }

  void zoomin()
    {
      scale *= 1.1;
      note_update();
    }

  void zoomout()
    {
      scale *= 0.9;
      note_update();
    }

  void rotatecolormap()
    {
      colormap++;
      colormap = colormap % 3;
      note_update();
    }

  void rotate();


  void rotate_x(int direction)
    {
      xtri += direction;
      note_update();
    }
  void rotate_y(int direction)
    {
      ytri += direction;
      note_update();
    }
  void rotate_z(int direction)
    {
      ztri += direction;
      note_update();
    }
  void move_x(float direction)
    {
      xtran += direction;
      note_update();
    }
  void move_y(float direction)
    {
      ytran += direction;
      note_update();
    }
  void move_z(float direction)
    {
      ztran += direction;
      note_update();
    }

  void make_random_color_set();
  
};
#endif

---