diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 86eb1877450a061c0572c8f6f8a14f9c655c92b6..3f0ec8c5b67de4f89ed077b42dd4f27e31beb638 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -87,6 +87,7 @@ SET(VITE_HDRS
   render/Geometry.hpp
   render/Hook_event.hpp
   render/Render_opengl.hpp
+  render/Render_alternate.hpp
   render/Render_svg.hpp
   render/render_stats.hpp
   render/render_stats_opengl.hpp
@@ -166,6 +167,7 @@ SET(VITE_SRCS
   render/Hook_event.cpp
   render/Render.hpp
   render/Render_opengl.cpp
+  render/Render_alternate.cpp
   render/Render_svg.cpp
   render/render_stats_opengl.cpp
   render/render_stats_svg.cpp
diff --git a/src/common/info.cpp b/src/common/info.cpp
index 3bf559051cc3bf3c1636bf1b0f044d3e0de7ae44..33fd91fd9e9d79fb7c8e516c61ac55a844df93c5 100644
--- a/src/common/info.cpp
+++ b/src/common/info.cpp
@@ -47,32 +47,6 @@
 #include "common/common.hpp"
 #include "common/info.hpp"
 
-// void (Interface_console:: *Info::Core::launch_action)(int, void*) = NULL;
-// const int Info::Core::_STATE_UNKNOWN = -1;
-// const int Info::Core::_STATE_DISPLAY_HELP = 0;
-// const int Info::Core::_STATE_IN_AN_INTERVAL = 1; // 2^0
-// const int Info::Core::_STATE_OPEN_FILE = 2; // 2^1
-// const int Info::Core::_STATE_OPEN_FILE_IN_AN_INTERVAL = 3;
-// const int Info::Core::_STATE_EXPORT_FILE = 4; // 2^2
-// const int Info::Core::_STATE_EXPORT_FILE_IN_INTERVAL = 5;
-// const int Info::Core::_STATE_RELEASE_RENDER_AREA = 6;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_TRANSLATE = 7;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_SCALE = 8;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_CONTAINER_SCALE = 9;
-// const int Info::Core::_DRAW_OPENGL = 10;
-// const int Info::Core::_DRAW_SVG = 11;
-// const int Info::Core::_STATE_LAUNCH_GRAPHICAL_INTERFACE = 12;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_SCALE = 13;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_TRANSLATE = 14;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_TRANSLATE_Y = 15;
-// const int Info::Core::_STATE_RENDER_AREA_REGISTERED_TRANSLATE = 16;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_SCALE_Y = 17;
-// const int Info::Core::_STATE_AJUST_SCROLL_BARS = 18;
-// const int Info::Core::_STATE_REFRESH_SCROLL_BARS = 19;
-// const int Info::Core::_STATE_ZOOM_BOX_VALUE = 20;
-// const int Info::Core::_STATE_RENDER_DISPLAY_INFORMATION = 21;
-// const int Info::Core::_STATE_RENDER_UPDATE = 22;
-
 unsigned int         Info::Screen::width  = 800;
 unsigned int         Info::Screen::height = 600;
 
@@ -101,5 +75,5 @@ Element_pos Info::Render::_info_accurate = 0.0;
 bool        Info::Render::_no_arrows = false;
 bool        Info::Render::_no_events = false;
 
-QLabel*     Info::Render::_ui_render_min_value = NULL;
-QLabel*     Info::Render::_ui_render_max_value = NULL;
+//QLabel*     Info::Render::_ui_render_min_value = NULL;
+//QLabel*     Info::Render::_ui_render_max_value = NULL;
diff --git a/src/common/info.hpp b/src/common/info.hpp
index 80abd64bb3f4ee59258914609eb958153cf4472d..5199c88d796a81b4934b90f87a07e499b15cb4b5 100644
--- a/src/common/info.hpp
+++ b/src/common/info.hpp
@@ -48,7 +48,7 @@
 #define INFO_HPP
 
 class Interface_console;
-class QLabel;
+//class QLabel;
 
 /*!
  * \brief Class used to store informations.
@@ -253,13 +253,13 @@ public:
          * \brief This attribute is used to update the label which indicates
          * the minimum visible trace value.
          */
-        static QLabel* _ui_render_min_value;
+        //static QLabel* _ui_render_min_value;
 
         /*!
          * \brief This attribute is used to update the label which indicates
          * the maximum visible trace value.
          */
-        static QLabel* _ui_render_max_value;
+        //static QLabel* _ui_render_max_value;
     };
 
     
diff --git a/src/core/Core.cpp b/src/core/Core.cpp
index c962507a129924165b65ab8ae90d7579314240aa..727a5cc19ffe03e318009492c2527e518403d2a3 100644
--- a/src/core/Core.cpp
+++ b/src/core/Core.cpp
@@ -45,8 +45,6 @@
  *\brief This is the console interface C source code.
  */
 
-//#define WITH_OTF
-
 
 #include <queue>
 #include <string>
@@ -66,12 +64,9 @@
 /* -- */
 
 
-
-#include "render/Render_opengl.hpp"
 //#include "render/render.hpp"
 #include "render/Render_svg.hpp"
 #include "render/Render.hpp"
-//#include "render/Render_opengl_dl.hpp"
 /* -- */
 #include "trace/values/Values.hpp"
 #include "trace/tree/Interval.hpp"
@@ -101,6 +96,13 @@
 #include "core/Core.hpp"
 #include "interface/parsing_thread.hpp"
 /* -- */
+#ifdef WITH_VBO
+#include "render/Render_alternate.hpp"
+#else
+#include "render/Render_opengl.hpp"
+#endif
+
+
 using namespace std;
 
 #define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
@@ -211,13 +213,19 @@ bool Core::draw_trace(const string & filename, const int format){
     Parser *parser;
 
     DrawTrace drawing_ogl;
+    
+#ifdef WITH_VBO
+    Render<Render_alternate> render(_render_opengl);
+#else
     Render<Render_opengl> render(_render_opengl);
+#endif
+
 
     QTime time_elapsed;
     ostringstream buf_txt;
     int time_buf;
     time_buf = 0;
-    
+
 
     // Get the parser in function of the extension of the file
     const unsigned int position_of_dot = filename.find_last_of('.');
@@ -254,6 +262,13 @@ bool Core::draw_trace(const string & filename, const int format){
 
             
     if (NULL == _trace) { /* no trace is loaded, parse the file */
+
+        /* Init data */
+        Info::Entity::x_min          = 0;
+        Info::Entity::x_max          = 0;
+        Info::Render::_x_min_visible = 0;
+        Info::Render::_x_max_visible = 0;
+
         _trace = new Trace();
         
         // Init of the thread
@@ -633,12 +648,16 @@ void Core::launch_action(int state, void* arg) {
 
         if ( _STATE_OPEN_FILE == state)
             message << QObject::tr("Opening the file: ").toStdString ()+_file_opened << Message::endi;
-
+        
         _main_window = new Interface_graphic (this);/* launch the window interface */
         Message::set_interface (_main_window);/* define which interface will receive messages */
 
         //   format.setOverlay(true);
+#ifdef WITH_VBO
+        _render_opengl = new Render_alternate (this, _main_window, format);
+#else
         _render_opengl = new Render_opengl (this, _main_window, format);
+#endif
 
         if ( NULL == _render_opengl){
             message <<  QObject::tr("Cannot allocate memory for an OpengGL instance").toStdString () << Message::ende;
diff --git a/src/core/Core.hpp b/src/core/Core.hpp
index 3f524f6c4c1d0e00d032b2aad3e69728e7f04d91..8d32ffa43c40ae3b00d96dc31c5274afca92542f 100644
--- a/src/core/Core.hpp
+++ b/src/core/Core.hpp
@@ -47,9 +47,18 @@
 #ifndef CORE_HPP
 #define CORE_HPP
 
+
+//#define WITH_VBO
+
 class Core;
 class Interface_graphic;
+
+#ifdef WITH_VBO
+class Render_alternate;
+#else
 class Render_opengl;
+#endif
+
 class Render_svg;
 class Trace;
 #include "render/Render.hpp"
@@ -256,7 +265,11 @@ protected:
      * \brief Contains the OpenGL render instance.
      */
     /* MOD */
-       Render_opengl* _render_opengl;
+#ifdef WITH_VBO
+    Render_alternate* _render_opengl;
+#else
+    Render_opengl* _render_opengl;
+#endif
     //Render<Render_opengl>* _render_opengl;
 
     /*!
diff --git a/src/interface/Interface_graphic.cpp b/src/interface/Interface_graphic.cpp
index 198264bf819d330dcf78c4524ea0c16909a72e61..05221b41ce17f619d085e2aa17e50619cac6b7a1 100644
--- a/src/interface/Interface_graphic.cpp
+++ b/src/interface/Interface_graphic.cpp
@@ -195,8 +195,8 @@ void Interface_graphic::load_windows(){
 
     CKFP(_ui_zoom_box = qFindChild<QComboBox*>(this, "zoom_box"), "Cannot find the zoom box in the .ui file");   
 
-    CKFP(Info::Render::_ui_render_min_value = qFindChild<QLabel*>(this, "render_min_value"), "Cannot find the render_min_value label in the .ui file");
-    CKFP(Info::Render::_ui_render_max_value = qFindChild<QLabel*>(this, "render_max_value"), "Cannot find the render_max_value label in the .ui file");
+    //  CKFP(Info::Render::_ui_render_min_value = qFindChild<QLabel*>(this, "render_min_value"), "Cannot find the render_min_value label in the .ui file");
+    // CKFP(Info::Render::_ui_render_max_value = qFindChild<QLabel*>(this, "render_max_value"), "Cannot find the render_max_value label in the .ui file");
 
     /* Export window */
     CKFP(_ui_export_ok_button = qFindChild<QPushButton*>(_ui_time_selection_export, "option_export_ok"), "Cannot find the ok push button in the export dialog .ui file");   
diff --git a/src/interface/main_window.ui b/src/interface/main_window.ui
index fb3400176a1fbcc1fd4ea7dfee75abd23865ec54..992022ded20ac7f4a0e4ff2af70fdf3ae70a42bd 100644
--- a/src/interface/main_window.ui
+++ b/src/interface/main_window.ui
@@ -28,55 +28,6 @@
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QVBoxLayout" name="verticalLayout_2">
-    <item>
-     <layout class="QHBoxLayout" name="horizontalLayout">
-      <item>
-       <widget class="QLabel" name="render_min_value">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="text">
-         <string/>
-        </property>
-        <property name="textFormat">
-         <enum>Qt::RichText</enum>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <spacer name="horizontalSpacer">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-        <property name="sizeHint" stdset="0">
-         <size>
-          <width>40</width>
-          <height>20</height>
-         </size>
-        </property>
-       </spacer>
-      </item>
-      <item>
-       <widget class="QLabel" name="render_max_value">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="text">
-         <string/>
-        </property>
-        <property name="textFormat">
-         <enum>Qt::RichText</enum>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </item>
     <item>
      <layout class="QHBoxLayout" name="horizontalLayout_2">
       <item>
@@ -235,7 +186,7 @@
      <x>0</x>
      <y>0</y>
      <width>1060</width>
-     <height>27</height>
+     <height>25</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuHelp">
diff --git a/src/render/Hook_event.cpp b/src/render/Hook_event.cpp
index 1eb0b26edb8e1c8149fba60dca4dd270e7703917..9a61d15ae6fd5ead4ddcf6b590621712dd2e3ba5 100644
--- a/src/render/Hook_event.cpp
+++ b/src/render/Hook_event.cpp
@@ -253,7 +253,7 @@ void Hook_event::mouseDoubleClickEvent ( QMouseEvent * event ){
 
 
 void Hook_event::mouseMoveEvent(QMouseEvent * event){
-    //  if (!_mouse_pressed) return;
+    if (!_mouse_pressed) return;
 
     _new_mouse_x = event->x();
     _new_mouse_y = event->y();
diff --git a/src/render/Render.hpp b/src/render/Render.hpp
index 04eef9420f71368ac548e1cebf8ddac5850bc8d6..10e3bd1d5b614c17e0769912840ddf9f2c98e910 100755
--- a/src/render/Render.hpp
+++ b/src/render/Render.hpp
@@ -52,6 +52,7 @@
 #include "render/Ruler.hpp"
 #include "common/info.hpp"
 
+#include <GL/glut.h>
 
 /*!
  * \brief Structure used to store container information.
@@ -242,16 +243,20 @@ public:
         }
         
         drawing_instance->end_draw_containers();
+
     }
 
+    static int bb;
+
     /*!
      * \brief Creates and opens the display list for state draws.
      */
     inline void start_draw_states(){
         drawing_instance->start_draw_states();
-    
     }
 
+
+
     /*!
      * \brief Draw a state of the trace.
      * \param start the beginning time of the state.
@@ -262,18 +267,17 @@ public:
      * \param g the green color rate of the state.
      * \param b the blue color rate of the state.
      */
-    inline void draw_state(const Element_pos start, const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b) {
 
-        //        std::cout << __FILE__ << " " << __LINE__ << " -* " << trace_to_render_x(start) << " " << coeff_trace_render_x() << std::endl;  
+    inline void draw_state(const Element_pos start, const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b) {
+       
 
         drawing_instance->set_color(r, g, b);
-        // drawing_instance->draw_quad(start, base, _z_state, end-start, height);
+        
         drawing_instance->draw_quad(trace_to_render_x(start - Info::Render::_x_min_visible),
                                     trace_to_render_y(base),
                                     _z_state, 
                                     (end-start)*coeff_trace_render_x(), 
                                     height*coeff_trace_render_y());
-
     }
 
     /*!
@@ -449,7 +453,6 @@ public:
      */
     inline void end_draw(){
         //    std::cerr << __FILE__ << __LINE__ << " " << Info::Render::_x_min_visible << " " << Info::Render::_x_max_visible << std::endl;
-
         /* Now, draw ruler */
         Element_pos graduation_diff;
         Element_pos coeff_prefix;
diff --git a/src/render/Render_alternate.cpp b/src/render/Render_alternate.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..479780a7161afb58dbfbc40fe68170a705219385
--- /dev/null
+++ b/src/render/Render_alternate.cpp
@@ -0,0 +1,932 @@
+/*
+** This file is part of the ViTE project.
+**
+** This software is governed by the CeCILL-A license under French law
+** and abiding by the rules of distribution of free software. You can
+** use, modify and/or redistribute the software under the terms of the
+** CeCILL-A license as circulated by CEA, CNRS and INRIA at the following
+** URL: "http://www.cecill.info".
+** 
+** As a counterpart to the access to the source code and rights to copy,
+** modify and redistribute granted by the license, users are provided
+** only with a limited warranty and the software's author, the holder of
+** the economic rights, and the successive licensors have only limited
+** liability.
+** 
+** In this respect, the user's attention is drawn to the risks associated
+** with loading, using, modifying and/or developing or reproducing the
+** software by the user in light of its specific status of free software,
+** that may mean that it is complicated to manipulate, and that also
+** therefore means that it is reserved for developers and experienced
+** professionals having in-depth computer knowledge. Users are therefore
+** encouraged to load and test the software's suitability as regards
+** their requirements in conditions enabling the security of their
+** systems and/or data to be ensured and, more generally, to use and
+** operate it in the same conditions as regards security.
+** 
+** The fact that you are presently reading this means that you have had
+** knowledge of the CeCILL-A license and that you accept its terms.
+**
+**
+** ViTE developers are (for version 0.* to 1.0):
+**
+**        - COULOMB Kevin
+**        - FAVERGE Mathieu
+**        - JAZEIX Johnny
+**        - LAGRASSE Olivier
+**        - MARCOUEILLE Jule
+**        - NOISETTE Pascal
+**        - REDONDY Arthur
+**        - VUCHENER Clément 
+**
+*/
+/*!
+ *\file Render_alternate.cpp
+ */
+
+
+#include "common/common.hpp"
+#include "common/info.hpp"
+/* -- */
+//#include "render/render.hpp"
+
+#include <GL/glew.h>
+#include "render/Hook_event.hpp"
+
+#include "render/Render_alternate.hpp"
+/* -- */
+
+#include "interface/resource.hpp"
+//#include "interface/interface.hpp"
+#include "render/Render.hpp"
+#include "core/Core.hpp"
+/* -- */
+
+#include "vbo.hpp"
+
+
+using namespace std;
+
+
+#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
+
+static bool _draw_container;
+static bool _draw_ruler;
+static bool _draw_arrow;
+static bool _draw_event;
+const int Render_alternate::DRAWING_TIMER_DEFAULT = 10;
+
+/***********************************
+ *
+ *
+ *
+ * Constructor and destructor.
+ *
+ *
+ *
+ **********************************/
+
+Render_alternate::Render_alternate(Core* core, QWidget *parent, const QGLFormat& format)
+    : Hook_event((Render_opengl*)this, core, parent, format){
+
+    _arrows.clear();
+    _circles.clear();
+    _texts.clear();
+    _vbos.clear();
+
+
+    
+    setAutoFillBackground(false);
+}
+
+
+Render_alternate::~Render_alternate(){
+}
+
+/***********************************
+ *
+ *
+ *
+ * Default QGLWidget functions.
+ *
+ *
+ *
+ **********************************/
+
+void  Render_alternate::initializeGL() {
+    glClearColor(0.5f, 0.5f, 0.55f, 1.0f);
+
+    glEnable(GL_DEPTH_TEST);
+
+    glClearStencil(0);
+}
+
+void  Render_alternate::resizeGL(int width, int height) {
+    glViewport(0, 0, width, height);
+    
+    /* update informations about widget size */
+    Info::Screen::width  = width;
+    Info::Screen::height = height;
+    
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+
+
+        
+    if(DRAWING_STATE_WAITING == _state){// A wait is drawn
+        glOrtho(-50, 50, -50, 50, 0, 1000);
+    }else if (DRAWING_STATE_DRAWING == _state){// A trace is drawn 
+        glOrtho(0, Info::Render::width, 0, Info::Render::height, 0, -1000);
+    }else{
+        message << tr("Undefined value for the drawing state attribute - Render area").toStdString() << Message::ende;
+    }
+      
+
+    glMatrixMode(GL_MODELVIEW);
+}
+
+
+void  Render_alternate::paintGL(){
+ 
+    resizeGL(Render_alternate::QGLWidget::width(), Render_alternate::QGLWidget::height());
+    Render_alternate::QGLWidget::setFocus(Qt::ActiveWindowFocusReason);/* give the focus to the render area for mouse and keyboard events */
+
+  
+    glClearDepth(1.0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glLoadIdentity();
+
+   
+    if(DRAWING_STATE_WAITING == _state){/* A wait is drawn */
+        
+        /* turn around y axis */
+        _wait_angle+=0.1f;
+        if (_wait_angle>=360) _wait_angle=0.0f;
+      
+        glPushMatrix();
+      
+        glScalef(15, 15, 0);
+      
+        glRotatef(-_wait_angle,0, 1, 0);
+        glRotatef(_wait_angle_y, 1, 0, 0);
+        
+
+        glPopMatrix();
+	
+    
+    }else if (DRAWING_STATE_DRAWING == _state){/* A trace is drawn */
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+
+        glPushMatrix();
+	{
+            glTranslated(0.0, Info::Render::height, 100.0);
+	    glRotated(180.0, 1.0, 0.0, 0.0);
+	    
+
+            glPushMatrix();
+            {
+                
+                glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate, 0.0);
+                glScalef(_x_state_scale, _y_state_scale, 1.0);
+
+                for (unsigned int i=0 ; 
+                     i<_vbos.size()   ;
+                     i++){
+                    _vbos[i]->display();
+                }
+            }
+            glPopMatrix();                
+
+            call_ruler();
+
+
+             if (false == Info::Render::_no_arrows)/* display arrows */
+                 draw_stored_arrows();
+            
+             if (false == Info::Render::_no_events)/* display events */
+                 draw_stored_circles();
+                        
+        }
+        glPopMatrix();
+
+        glPushMatrix();
+        {
+            glTranslated(0.0,  0.0, 100.0);/* not accurate */
+           
+            if (_mouse_pressed){
+               
+               
+                glTranslated(0.0, 0.0, _z_container_under);
+               
+                Element_pos old_x, old_y, new_x, new_y;
+               
+ 
+
+                old_x = _mouse_x*(Info::Render::width/Info::Screen::width);
+                old_y =  Info::Render::height - _mouse_y*(Info::Render::height/Info::Screen::height);
+                new_x = _new_mouse_x*(Info::Render::width/Info::Screen::width);
+                new_y =  Info::Render::height - _new_mouse_y*(Info::Render::height/Info::Screen::height);
+
+#ifdef DEBUG_MODE_RENDER_OPENGL
+               
+                cerr << __FILE__ << " l." << __LINE__ << ":" << endl;  
+                cerr << "Selection rectangle position: (" << old_x << ", " << old_y << ") - (" << new_x << ", " << new_y << ")" << endl;  
+#endif
+               
+                glEnable(GL_BLEND);
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
+               
+                /* Square for selection */
+                glBegin(GL_QUADS);
+                {
+                    glColor4d(0.9, 1.0, 0.9, _selection_rectangle_alpha);glVertex2d(old_x, old_y);
+                    glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(old_x, new_y);
+                    glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(new_x, new_y);
+                    glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(new_x, old_y);
+                }
+                glEnd();
+              
+                glDisable(GL_BLEND);
+                               
+            }/* end  if (true==_mouse_pressed) */
+        }
+        glPopMatrix();
+
+
+
+    }else{
+        message << tr("Undefined value for the drawing state attribute - Render area").toStdString() << Message::ende;
+    }
+  
+    glFlush();
+
+
+    /* Check the errors */
+    GLenum glerror;
+    glerror = glGetError();
+    if(glerror != GL_NO_ERROR)
+        message << tr("Render area : the following OpengGL error occured: ").toStdString() << (char *)gluErrorString(glerror) << Message::endw;
+
+
+
+    if(DRAWING_STATE_WAITING == _state)/* A wait is drawn, do not take car about the ruler drawing */
+        return;
+
+    QFont arial_font = QFont("Arial", 10);
+    qglColor(Qt::white);//QColor(0, 0, 0));
+
+
+    /* Draw container text */
+    const unsigned int texts_size = _texts.size();
+    for (unsigned int i=0 ; i<texts_size ; i++){
+        const QFontMetrics metric(arial_font);
+        const QString text_elided = metric.elidedText(_texts[i].value.c_str(), Qt::ElideRight, _x_scale_container_state*Info::Screen::width/3.);
+        renderText ( render_to_screen_x(_texts[i].x * _x_scale_container_state/0.20),
+                     render_to_screen_y( trace_to_render_y(_texts[i].y) + 0.5),
+                     text_elided,
+                     arial_font);
+    }
+
+    /* Draw ruler text */
+    std::ostringstream buf_txt;
+    Element_pos graduation_diff;
+    Element_pos coeff_prefix;
+    graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+    coeff_prefix    = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+
+    //    painter.setFont(QFont("Arial", 14));
+
+    arial_font.setPointSize(14);
+
+    buf_txt.str("");/* flush the buffer */
+    buf_txt << "min: " << (double)Info::Render::_x_min_visible;
+
+    renderText (render_to_screen_x(trace_to_render_x(Info::Render::_x_min_visible)),
+                render_to_screen_y(3),
+                buf_txt.str().c_str(),
+                arial_font);
+
+    buf_txt.str("");/* flush the buffer */
+    buf_txt << "max: " << (double)Info::Render::_x_max_visible;
+
+    renderText (render_to_screen_x(trace_to_render_x(Info::Render::_x_max_visible))-130,
+                render_to_screen_y(3),
+                buf_txt.str().c_str(),
+                arial_font);
+
+    buf_txt.str("");
+    buf_txt << Ruler::get_common_part_string(Info::Render::_x_min_visible, coeff_prefix) << "--";
+
+    renderText (render_to_screen_x(
+                                   trace_to_render_x(
+                                                     (Info::Render::_x_min_visible + 
+                                                      Info::Render::_x_max_visible) / 2)), 
+                render_to_screen_y(3),
+                buf_txt.str().c_str(),
+                arial_font);
+
+    arial_font.setPointSize(10);
+
+    for (Element_pos i = Info::Render::_x_min_visible ; 
+         i < Info::Render::_x_max_visible ; 
+         i+=graduation_diff){
+
+        buf_txt.str("");/* flush the buffer */
+        buf_txt << Ruler::get_variable_part(i, coeff_prefix, 2);
+   
+        renderText (render_to_screen_x(trace_to_render_x(i)+1),
+                    render_to_screen_y(8),
+                    buf_txt.str().c_str(),
+                    arial_font);
+    }      
+}
+
+
+
+
+
+/***********************************
+ *
+ *
+ *
+ * Building functions.
+ *
+ *
+ *
+ **********************************/
+
+
+
+bool Render_alternate::build(){
+    
+    _state = DRAWING_STATE_DRAWING;/* change the drawing state */
+
+    /* disable some OpenGL features to enhance the rendering */
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_BLEND);
+
+    replace_scale(1);/* for states scaling */
+    _x_state_translate = 0;/* for states translation */
+    _y_state_scale = 1;/* for states scaling */
+    _y_state_translate = 0;/* for states translation */
+    _x_scroll_pos = 0;/* horizontal bar placed on 0 */
+    _y_scroll_pos = 0;/* vertical bar placed on 0 */
+ 
+    if (NULL == _render_instance)
+        return true;
+
+    return true;
+}
+
+
+
+bool Render_alternate::unbuild(){
+     
+    /**********************
+     *
+     * Init OpenGL features
+     *
+     **********************/
+
+    /* enable some OpenGL features*/
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   
+    glEnable(GL_TEXTURE_2D);
+
+    glEnable(GL_BLEND);/* enable blending for the alpha color */ 
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glColor3d(1.0, 1.0, 1.0);/* init color to white */
+
+
+    /*****************************
+     *
+     * Init render area attributes
+     *
+     *****************************/
+
+    _state = DRAWING_STATE_WAITING;/* change the drawing state */
+
+    _wait_angle=0.0f;/* begin with 0 rad angle */
+    _wait_angle_y=0.0f;/* begin with 0 rad angle */
+
+    /* init measurement attributes */    
+    Info::Container::x_max = 0;
+    Info::Container::y_max = 0;
+    Info::Container::x_min = 0;
+    Info::Container::y_min = 0;
+
+    //    Info::Render::_ui_render_min_value->setText("");
+    // Info::Render::_ui_render_max_value->setText("");
+
+    Info::Entity::x_max = 0;
+    Info::Entity::x_min = 0;
+    //    _state_x_max = 0;
+    _state_y_max = 0;
+    //    _state_x_min = 0;
+    _state_y_min = 0;
+
+    /* clear lists to store container texts */
+    _text_pos.clear();
+    _text_value.clear();
+
+    _arrows.clear();
+    _circles.clear();
+    _texts.clear();
+
+    for (unsigned int i=0 ; 
+         i<_vbos.size()   ;
+         i++){
+        delete _vbos[i];
+    }
+    _vbos.clear();
+
+    /* clear the event vector */
+    // _events.clear();
+
+    /* clear the arrow vector */
+    // _arrows.clear();
+    
+    /* empty the selection stack */
+    while(false == _previous_selection.empty())
+        _previous_selection.pop();
+
+    if (NULL == _render_instance)
+        return true;
+
+    /* Now, timer is set */
+    if (_wait_timer == NULL){
+        _wait_angle = 0.0f;
+        
+        /*  _wait_timer = new QTimer(this);
+        connect(_wait_timer, SIGNAL(timeout()), _render_instance, SLOT(updateGL()));
+        _wait_timer->start(_wait_spf);*/
+    }
+
+
+    return true;//_render_instance->display_unbuild();
+}
+
+
+
+
+
+/***********************************
+ *
+ *
+ *
+ * Drawing function for the wait screen.
+ *
+ *
+ *
+ **********************************/
+
+
+
+GLuint Render_alternate::draw_wait() {
+    GLuint object;
+    GLuint texture;
+
+    glGenTextures(1, &texture);/* create the texture and link it with the list previously created */   
+    
+    QFile texture_file(QString(":/img/img/logo") +  QDate::currentDate().toString("MMdd") + QString(".png"));
+  
+    if (true == texture_file.exists())/* The texture exists */
+        texture = bindTexture(QPixmap(texture_file.fileName()), GL_TEXTURE_2D);
+    else/* use the default picture */
+        texture = bindTexture(QPixmap(":/img/img/logo.png"), GL_TEXTURE_2D);
+
+   
+    /* apply some parameters on the texture */
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+   
+    glEnable(GL_TEXTURE_2D);
+
+    glEnable(GL_BLEND);/* enable blending for the alpha color */ 
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  
+    /* Now, timer is set */
+    if (_wait_timer == NULL){
+        _wait_angle = 0.0f;
+        /*
+        _wait_timer = new QTimer(this);
+        connect(_wait_timer, SIGNAL(timeout()), _render_instance, SLOT(updateGL()));
+        _wait_timer->start(_wait_spf);*/
+    }
+
+    return object;
+}
+
+
+
+
+
+void Render_alternate::call_ruler(){
+    Element_pos graduation_diff;
+    Element_pos coeff_prefix;
+    const Element_pos offset_x = _default_entity_x_translate;
+    const Element_pos offset_y = _ruler_y + _ruler_height+3.5;
+
+    update_visible_interval_value();
+    
+    graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+    coeff_prefix    = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+    
+    set_color(1.0, 1.0, 1.0);
+    
+    for (Element_pos i = Info::Render::_x_min_visible ; i < Info::Render::_x_max_visible ; i+=graduation_diff){
+        const Element_pos grad_div_by_5 = graduation_diff/5;
+        for (Element_pos j = (i+grad_div_by_5) ; j<(i+graduation_diff) ; j+= grad_div_by_5){
+            draw_line( trace_to_render_x(j) + offset_x, offset_y  ,
+                       trace_to_render_x(j) + offset_x, 2+offset_y, _z_ruler);
+        }
+
+        draw_line( trace_to_render_x(i) + offset_x, offset_y-1  ,
+                   trace_to_render_x(i) + offset_x, 4+offset_y, _z_ruler);
+    }
+    
+    glBegin(GL_QUADS);
+    {
+        glColor4d(0.0, 0.0, 1.0, 0.8);
+        glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 0, _z_ruler_under );
+        glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 8, _z_ruler_under );
+        glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 8, _z_ruler_under );
+        glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 0, _z_ruler_under );
+    }
+    glEnd();
+    
+    glBegin(GL_QUADS);
+    {
+        glColor4d(0.0, 0.0, 0.0, 1.0);
+        glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 0, _z_ruler_over );
+        glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 3, _z_ruler_over );
+        glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 3, _z_ruler_over );
+        glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 0, _z_ruler_over );
+    }
+    glEnd();
+         
+    return;
+}    
+
+
+
+void Render_alternate::set_color(float r, float g, float b){
+    _red = r;
+    _green = g;
+    _blue = b;
+}
+
+void Render_alternate::draw_text(const Element_pos x, const Element_pos y, const Element_pos, const std::string s){
+    if (_draw_ruler) return;/* do not draw text for ruler */
+
+        Container_text_ buf;
+
+        buf.x     = x;
+        buf.y     = render_to_trace_y(y);/* Cancel previous transformation. */
+        buf.value = s;
+
+        _texts.push_back(buf);
+}
+
+
+void Render_alternate::draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h){
+    int state;
+    Element_pos data[8];
+
+    Element_pos offset_x;
+    const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+    offset_x = 0;
+
+    if (!_draw_container)
+        offset_x = -_default_entity_x_translate;
+
+    data[0] = x + offset_x;
+    data[1] = y + offset_y;
+    data[2] = x + offset_x; 
+    data[3] = y + h + offset_y;
+    data[4] = x + w + offset_x;
+    data[5] = y + h + offset_y;
+    data[6] = x + w + offset_x;
+    data[7] = y + offset_y;
+
+    state = Vbo::VBO_OK;
+
+    if(NULL != _current_vbo)
+        state = _current_vbo->add(8, data);
+
+    if (Vbo::VBO_OUT_OF_MEMORY == state){
+        /* Store the current vbo */
+        _vbos.push_back(_current_vbo); 
+        
+        /* Create a new vbo */
+        _current_vbo = NULL;/* DO NOT DEALLOCATE BEFORE! */
+        _current_vbo = new Vbo(100000, _current_vbo->QUADS);
+
+        if (NULL == _current_vbo)
+            message << tr("Cannot create a Vbo for states.").toStdString() << Message::ende;
+    }
+
+    /*
+    glBegin(GL_QUADS);
+    {
+        glColor3d(_red, _green, _blue);
+        glVertex3d(x + offset_x    , y + offset_y    , z        );
+        glVertex3d(x + offset_x    , y + h + offset_y, z        );
+        glColor3d(_red/1.5         , _green/1.5      , _blue/1.5);
+        glVertex3d(x + w + offset_x, y + h + offset_y, z        );
+        glVertex3d(x + w + offset_x, y + offset_y    , z        );
+    }
+    glEnd();*/
+}
+
+void Render_alternate::draw_triangle(Element_pos , Element_pos ,
+                                  Element_pos , Element_pos ){
+}
+
+void Render_alternate::draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z){
+    if (_draw_ruler || _draw_arrow || _draw_event) return;/* do not draw line for ruler or for arrow or for event */
+
+
+    const Element_pos offset_x = -_default_entity_x_translate;
+    const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+    glBegin(GL_LINES);
+    {
+        glColor3d(_red, _green, _blue);
+        glVertex3d(x1 + offset_x, y1 + offset_y, z);
+        glVertex3d(x2 + offset_x, y2 + offset_y, z);
+    }
+    glEnd();
+}
+
+void Render_alternate::draw_circle(Element_pos /*x*/, Element_pos /*y*/, Element_pos /*z*/, Element_pos /*r*/){
+}
+
+
+void Render_alternate::start_draw(){
+    /* Init GLEW */
+    glewInit();
+    _draw_ruler = false;
+    _draw_container = false;
+    _draw_arrow = false;
+    _draw_event = false;
+
+    _current_vbo = NULL;
+   
+}
+
+void Render_alternate::start_draw_containers(){
+    _list_containers = glGenLists(1);/* create the list */
+    if (_list_containers == 0) {
+        *Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
+    }
+    
+    glNewList(_list_containers, GL_COMPILE);/* open the list */
+    _draw_container = true;
+}
+
+void Render_alternate::draw_container(const Element_pos , const Element_pos , const Element_pos , const Element_pos ){
+    
+}
+
+void Render_alternate::draw_container_text(const Element_pos , const Element_pos , const std::string ){
+}
+
+void Render_alternate::end_draw_containers(){
+    _draw_container = false;
+    glEndList();/* close the list */
+}
+
+void Render_alternate::start_draw_states(){
+    _current_vbo = NULL;
+    _current_vbo = new Vbo((1<<20), _current_vbo->QUADS);/* Allocate 1 MiB */
+
+    if (NULL == _current_vbo)
+        message << tr("Cannot create a Vbo for states.").toStdString() << Message::ende;
+}
+
+void Render_alternate::draw_state(const Element_pos , const Element_pos , const Element_pos , const Element_pos , const Element_col , const Element_col , const Element_col ){
+}
+
+void Render_alternate::end_draw_states(){
+
+    _vbos.push_back(_current_vbo);
+}
+
+void Render_alternate::start_draw_arrows(){
+    _draw_arrow = true;
+
+}
+
+void Render_alternate::draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height, const Element_col red, const Element_col green, const Element_col blue){
+
+    Arrow_ buf;
+    const Element_pos offset_x = -_default_entity_x_translate;
+    const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+    buf.start_time   = start_time   + offset_x;
+    buf.end_time     = end_time     + offset_x;
+    buf.start_height = start_height + offset_y;
+    buf.end_height   = end_height   + offset_y;
+    buf.red          = red;
+    buf.green        = green;
+    buf.blue         = blue;
+
+    _arrows.push_back(buf);
+}
+
+void Render_alternate::end_draw_arrows(){
+    _draw_arrow = false;
+}
+
+void Render_alternate::start_draw_events(){
+    _draw_event = true;
+}
+
+void Render_alternate::draw_event(const Element_pos time, const Element_pos height,  const Element_pos container_height){
+    Event_ buf;
+    const Element_pos offset_x = -_default_entity_x_translate;
+    const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+    buf.time             = time   + offset_x;
+    buf.height           = height + offset_y;
+    buf.container_height = container_height   + offset_y;
+    buf.red              = _red;
+    buf.green            = _green;
+    buf.blue             = _blue;
+
+    _circles.push_back(buf);
+}
+
+
+void Render_alternate::end_draw_events(){
+    _draw_event = false;
+}
+
+void Render_alternate::start_draw_counter(){
+}
+
+void Render_alternate::draw_counter(const Element_pos , const Element_pos ){
+}
+
+void Render_alternate::end_draw_counter(){
+}
+
+void Render_alternate::start_ruler(){
+    _draw_ruler = true;
+}
+
+void Render_alternate::end_ruler(){
+    _draw_ruler = false;
+}
+
+void Render_alternate::end_draw(){
+}
+
+
+void Render_alternate::draw_stored_texts(){
+}
+
+void Render_alternate::draw_stored_arrows(){
+
+    /* Only draw triangle. Lines are already in a display list */
+    const Element_pos coeff = 180.0f/M_PI;
+    Element_pos angle;
+    Element_pos start_time, end_time, start_height, end_height;
+    Element_pos scaled_start_time, scaled_end_time, scaled_start_height, scaled_end_height;
+
+
+
+    const unsigned int arrow_size = _arrows.size();
+    for (unsigned int i=0 ; i<arrow_size ; i++){
+        
+        start_time   = _arrows[i].start_time;// + _x_state_scale*_x_state_translate;
+        end_time     = _arrows[i].end_time;// + _x_state_scale*_x_state_translate;
+        start_height = _arrows[i].start_height;
+        end_height   = _arrows[i].end_height;
+
+        set_color(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
+        
+        scaled_start_time   = start_time   * _x_state_scale;
+        scaled_end_time     = end_time     * _x_state_scale;
+        scaled_start_height = start_height * _y_state_scale;
+        scaled_end_height   = end_height   * _y_state_scale;
+
+        glPushMatrix();
+        {
+            
+            glTranslated(_default_entity_x_translate + _x_state_scale*end_time - _x_state_translate, 
+                         _ruler_y + _ruler_height + _y_state_scale*end_height - _y_state_translate,
+                         _z_arrow);
+
+            if (start_time != end_time){
+                angle = atan2((scaled_end_height - scaled_start_height), (scaled_end_time - scaled_start_time))*coeff;/* arc tangent */
+                glRotatef(angle, 0, 0, 1);
+            }
+            else
+                glRotatef(90, 0, 0, 1);/* vertical alignment */
+       
+            glBegin(GL_TRIANGLES);
+            {
+                // glColor3d(_red, _green, _blue);
+                glVertex2d(0.0, 0.0);
+                glVertex2d(-1.2, -0.4);
+                glVertex2d(-1.2, 0.4);
+            }
+            glEnd();
+        
+        }
+        glPopMatrix();
+
+        glPushMatrix();
+        {
+            
+            glTranslated(_default_entity_x_translate - _x_state_translate,
+                         _ruler_y + _ruler_height - _y_state_translate,
+                         _z_arrow);
+            glScalef(_x_state_scale, _y_state_scale, 1.0);
+     
+            glBegin(GL_LINES);
+            {
+                glVertex2d(start_time, start_height);
+                glVertex2d(end_time  , end_height  );
+            }
+            glEnd();
+        }
+        glPopMatrix();
+    }
+}
+
+void Render_alternate::draw_stored_circles(){
+    const int step          = 20;/* 20 polygons for the circle */
+    const float angle       = M_PI/2.0f;
+    const float delta_angle = 2*M_PI/step;
+    const float radius = .5f;
+
+    const unsigned int size = _circles.size();
+
+    for (unsigned int i=0 ; i<size ; i++){
+ 
+        glPushMatrix();
+        {
+
+            set_color(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue); 
+                      
+            glTranslated(_default_entity_x_translate - _x_state_translate,
+                         _ruler_y + _ruler_height - _y_state_translate,
+                         _z_arrow);
+          
+             glScalef(_x_state_scale, _y_state_scale, 1.0); 
+       
+             /* Draw the circle */
+                
+             glBegin(GL_POLYGON);
+             {
+                 for(int j = 0 ; j < step ; j ++){
+                     glVertex2d(_circles[i].time + cos(angle+delta_angle*j)*radius/_x_state_scale,
+                                _circles[i].height + sin(angle+delta_angle*j)*(radius/_y_state_scale)*Info::Screen::width/Info::Screen::height);                 
+                 }
+             }
+             glEnd();
+             
+
+             set_color(_circles[i].red, _circles[i].green, _circles[i].blue); 
+             
+             /* Draw the sub-circle */
+             glBegin(GL_POLYGON);
+             {
+                 for(int j = 0 ; j < step ; j ++){
+                     glVertex3d(_circles[i].time + cos(angle+delta_angle*j)*radius/(1.2*_x_state_scale) ,
+                                _circles[i].height + sin(angle+delta_angle*j)*radius/(1.2*_y_state_scale)*Info::Screen::width/Info::Screen::height , 
+                                0.1);
+                 }
+             }
+             glEnd();
+             
+           
+             glLineWidth( 3.0 );
+            /* Draw the line */
+             glBegin(GL_LINES);
+            {
+                glVertex2d(_circles[i].time, _circles[i].height);
+                glVertex2d(_circles[i].time, _circles[i].height+_circles[i].container_height);
+            }
+            glEnd();
+
+            glLineWidth( 1.0 );
+
+
+        }
+        glPopMatrix();
+    }
+
+    set_color(1.0, 1.0, 1.0);
+  
+}
+    
diff --git a/src/render/Render_alternate.hpp b/src/render/Render_alternate.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..68f083903cb0e524cdeb8bf0963abb54e47892e2
--- /dev/null
+++ b/src/render/Render_alternate.hpp
@@ -0,0 +1,567 @@
+/*
+** This file is part of the ViTE project.
+**
+** This software is governed by the CeCILL-A license under French law
+** and abiding by the rules of distribution of free software. You can
+** use, modify and/or redistribute the software under the terms of the
+** CeCILL-A license as circulated by CEA, CNRS and INRIA at the following
+** URL: "http://www.cecill.info".
+** 
+** As a counterpart to the access to the source code and rights to copy,
+** modify and redistribute granted by the license, users are provided
+** only with a limited warranty and the software's author, the holder of
+** the economic rights, and the successive licensors have only limited
+** liability.
+** 
+** In this respect, the user's attention is drawn to the risks associated
+** with loading, using, modifying and/or developing or reproducing the
+** software by the user in light of its specific status of free software,
+** that may mean that it is complicated to manipulate, and that also
+** therefore means that it is reserved for developers and experienced
+** professionals having in-depth computer knowledge. Users are therefore
+** encouraged to load and test the software's suitability as regards
+** their requirements in conditions enabling the security of their
+** systems and/or data to be ensured and, more generally, to use and
+** operate it in the same conditions as regards security.
+** 
+** The fact that you are presently reading this means that you have had
+** knowledge of the CeCILL-A license and that you accept its terms.
+**
+**
+** ViTE developers are (for version 0.* to 1.0):
+**
+**        - COULOMB Kevin
+**        - FAVERGE Mathieu
+**        - JAZEIX Johnny
+**        - LAGRASSE Olivier
+**        - MARCOUEILLE Jule
+**        - NOISETTE Pascal
+**        - REDONDY Arthur
+**        - VUCHENER Clément 
+**
+*/
+/*!
+ *\file Render_alternate.hpp
+ */
+
+#ifndef RENDER_OPENGL_HPP
+#define RENDER_OPENGL_HPP
+
+#include <QGLWidget>
+
+#include "core/Core.hpp"
+#include "render/Hook_event.hpp"
+#include "render/Render_template.hpp"
+
+class Render_alternate;
+class Interface_console;
+struct Container_text_;
+class Vbo;
+
+/*!
+ * \brief Structure used to store arrow information.
+ */
+struct Arrow_{
+    /*!
+     * \brief Coordinates.
+     */
+    Element_pos start_time, end_time, start_height, end_height;
+    /*!
+     * \brief Colors.
+     */
+    Element_col red, green, blue;
+};
+
+/*!
+ * \brief Structure used to store event information.
+ */
+struct Event_{
+    /*!
+     * \brief Coordinates and radius.
+     */
+    Element_pos time, height, container_height;
+    /*!
+     * \brief Colors.
+     */
+    Element_col red, green, blue;
+};
+
+
+/*!
+ * \brief This class redefined the OpenGL widget - QGLWidget - to display the trace.
+ */
+class Render_alternate :  /*public QGLWidget,*/ public Hook_event, public Render_template
+{
+    Q_OBJECT
+    
+protected:
+    
+    /*!
+     * \brief Contains the parent instance.
+     */
+    Core* _core;
+
+    /*!
+     * \brief The waiting screen display list.
+     */
+     GLuint _wait_list;
+
+
+    /*!
+     * \brief The container GLu list.
+     */
+    GLuint _list_containers;
+    
+    /*!
+     * \brief The state GLu list.
+     */
+    GLuint _list_states;
+    
+     /*!
+      * \brief The counter GLu list.
+      */
+    GLuint _list_counters;
+
+    
+    /*!
+     * \brief The wait GLu list.
+     */
+    //  GLuint _wait_list;
+
+    float _red, _green, _blue;
+    
+    std::vector<Container_text_> _texts;
+    std::vector<Arrow_> _arrows;
+    std::vector<Event_> _circles;
+
+
+    /***********************************
+     *
+     * The wait screen drawing.
+     *
+     **********************************/
+
+    /***********************************
+     * The wait list Attributes.
+     **********************************/
+
+
+    /*!
+     * \brief Rotation angle for the wait.
+     */
+    float _wait_angle;
+
+    /*!
+     * \brief Y rotation angle for the wait.
+     */
+    float _wait_angle_y;
+
+    /*!
+     * \brief Time in ms between two frames for the waiting screen.
+     */
+    static const int DRAWING_TIMER_DEFAULT;
+
+    /*!
+     * \brief Wait animation seconds per frame.
+     */
+    int _wait_spf;
+
+
+    Vbo* _current_vbo;
+    std::vector<Vbo*> _vbos;
+
+    /*!
+     * \brief Timer to animate the wait.
+     */
+    QTimer* _wait_timer;
+
+public:
+
+    /***********************************
+     *
+     * Constructor and destructor.
+     *
+     **********************************/
+
+    /*!
+     * \brief The default constructor
+     */
+    Render_alternate(Core* core, QWidget *parent, const QGLFormat& format);
+
+    /*!
+     * \brief The destructor
+     */
+    virtual ~Render_alternate();
+
+    /*!
+     * \brief Set Statistics and Informations about input trace
+     */
+    void set_total_width(Element_pos){}
+
+    /*!
+     * \brief Set Statistics and Informations about input trace
+     */
+    void set_total_time(Times){}
+
+    /*!
+     * \brief display the scale 
+     */
+    void display_time_scale(){}
+
+
+    /***********************************
+     *
+     * Default QGLWidget functions.
+     *
+     **********************************/
+     
+    /*!
+     * \brief Call by the system to initialize the OpenGL render area.
+     */
+      void initializeGL();
+     
+    /*!
+     * \brief Call by the system when the render area was resized (occurs during a window resizement).
+     * \param width : the new width of the render area.
+     * \param height : the new height of the render area. 
+     */
+    void resizeGL(int width, int height);
+     
+    /*!
+     * \brief Call by the system each time the render area need to be updated.
+     */
+    void paintGL();
+    
+    //void paintEvent(QPaintEvent *event);
+
+    /* void initializeOverlayGL();
+    void resizeOverlayGL(int width, int height);
+    void paintOverlayGL();*/
+    
+
+    /***********************************
+     *
+     * Building functions.
+     *
+     **********************************/
+
+    /*!
+     * \brief This function constructs the trace.
+     */
+    //  bool display_build() ;
+
+    /*!
+     * \brief This function releases the trace.
+     */
+    //   bool display_unbuild() ;
+
+    /*!
+     * \brief Proceeds with the initialization of the OpenGL draw functions.
+     */
+    void start_draw();
+
+    /*!
+     * \brief Creates and opens the display list for container draws.
+     */
+    void start_draw_containers();
+
+    /*!
+     * \brief Draw a container according to the parameters
+     * \param x the x position of the container
+     * \param y the y position of the container
+     * \param w the width of the container
+     * \param h the height of the container
+     */
+    void draw_container(const Element_pos x, const Element_pos y, const Element_pos w, const Element_pos h);
+
+    /*!
+     * \brief Draw the text of a container.
+     * \param x the x position of the text.
+     * \param y the y position of the text.
+     * \param value the string value of the text.
+     *
+     * This function stores text in a list. This list will be display each time the render area need to be updated.
+     */
+    void draw_container_text(const Element_pos x, const Element_pos y, const std::string value);
+
+    /*!
+     * \brief Closes the container display list.
+     */
+    void end_draw_containers();
+     
+    /*!
+     * \brief Creates and opens the display list for stater draws.
+     */
+    void start_draw_states();
+
+    /*!
+     * \brief Draw a state of the trace.
+     * \param start the beginning time of the state.
+     * \param end the ending time of the state.
+     * \param base vertical position of the state.
+     * \param height the state height.
+     * \param r the red color rate of the state.
+     * \param g the green color rate of the state.
+     * \param b the blue color rate of the state.
+     */
+    void draw_state(const Element_pos start , const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b);
+
+    /*!
+     * \brief Closes the state display list.
+     */
+    void end_draw_states();
+
+    /*!
+     * \brief Open the arrow display list.
+     */
+    void start_draw_arrows();
+
+    /*!
+     * \brief Draw an arrow.
+     * \param start_time the beginning time of the arrow.
+     * \param end_time the ending time of the arrow.
+     * \param start_height vertical position of the begining time of the arrow.
+     * \param end_height vertical position of the ending time of the arrow.
+     *
+     * This function stores all the information of the arrow to display it each time the render area need to be updated.
+     */
+    void draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height,const Element_col red, const Element_col green, const Element_col blue);
+
+    /*!
+     * \brief Closes the arrow display list.
+     */
+    void end_draw_arrows();
+
+    /*!
+     * \brief Draw arrows contained in the Arrow_ vector
+     * \param arrows An arrow vector.
+     */
+    // void draw_stored_arrows(std::vector<Arrow_> &arrows);
+
+    void start_draw_events();
+
+    /*!
+     * \brief Draw an event.
+     * \param time time when the event occurs.
+     * \param height vertical position of the event.
+     * \param container_height information to draw event. It corresponds to the container height when they are drawn horizontally.
+     *
+     *
+     * \brief Creates and opens the display list for container draws.
+     *
+     * This function stores all the information of the event to display it each time the render area need to be updated.
+     */
+    void draw_event(const Element_pos time, const Element_pos height,  const Element_pos container_height);
+
+    void end_draw_events();
+
+
+    /*!
+     * \brief Draw events contained in the Event_ vector
+     * \param events An event vector.
+     */
+    //  void draw_stored_events(std::vector<Event_> &events);
+
+    /*!
+     * \brief Creates and opens the display list for counter draws.
+     */
+    void start_draw_counter();
+     
+    /*!
+     * \brief Draw a point of the counter.
+     * \param x x position of the point.
+     * \param y y position of the point.
+     *
+     * Each time counter is increased, this function is called with the coordinates of the new point.
+     */
+    void draw_counter(const Element_pos x, const Element_pos y);
+     
+    /*!
+     * \brief Closes the counter display list.
+     */
+    void end_draw_counter();
+
+    /*!
+     * \brief Called before ruler drawing.
+     */
+    void start_ruler();
+     
+    /*!
+     * \brief Called after ruler drawing.
+     */
+    void end_ruler();
+     
+
+    /*!
+     * \brief Do nothing (it is present for compatibility of the Render class).
+     */
+    void end_draw();
+
+    
+
+    /***********************************
+     *
+     * Render OpenGL drawing functions.
+     *
+     **********************************/
+
+    /*!
+     * \brief Display a wait on the screen if there is no file opened.
+     * \return Asset value of the wait.
+     */
+    GLuint draw_wait();
+
+    /*!
+     * \brief Draw the ruler display list.
+     */
+    void call_ruler();
+
+
+
+    /***********************************
+     *
+     * Building functions.
+     *
+     **********************************/
+
+    /*!
+     * \brief This function draws the trace.
+     */
+    bool build();
+
+    /*!
+     * \brief This function releases the trace.
+     */
+    bool unbuild();
+
+    /***********************************
+     *
+     * Displaying functions.
+     *
+     **********************************/
+
+ //    /*!
+//      * \brief Display on screen containers between container_begin and container_end.
+//      * \param container_begin integer value : id of the first container.
+//      * \param container_end integer value : id of the last container.
+//      */
+//       void display_container(Element_count container_begin, Element_count container_end) =0;
+
+//     /*!
+//      * \brief Display on screen states between timer_begin and time_end, 
+//      * container_begin and container_end and with timer width between depth_begin and depth_end.
+//      * \param time_begin floating point value : time of the first state.
+//      * \param time_end floating point value : time of the last state.
+//      * \param container_begin integer value : id of the first container.
+//      * \param container_end integer value : id of the last container.
+//      * \param depth_begin floating point value : width of the narrowest state.
+//      * \param depth_end floating point value : width of the widest state.
+//      */
+//        void display_state(Element_pos time_begin, Element_pos time_end, 
+//                        Element_count container_begin, Element_count container_end, 
+//                        Element_pos depth_begin, Element_pos depth_end) =0;
+
+//     /*!
+//      * \brief Display on screen arrows between timer_begin and time_end, 
+//      * container_begin and container_end and with timer width between depth_begin and depth_end.
+//      * \param time_begin floating point value : time of the smallest arrow time value.
+//      * \param time_end floating point value : time of the higher arrow time value.
+//      * \param container_begin integer value : id of the first container.
+//      * \param container_end integer value : id of the last container.
+//      * \param depth_begin floating point value : the narrowest difference between 
+//      * the beginning time and the ending time of the arrow.
+//      * \param depth_end floating point value : width of the widest difference between
+//      * the beginning time and the ending time of the arrow.
+//      */
+//     virtual void display_arrow(Element_pos time_begin, Element_pos time_end, 
+//                        Element_count container_begin, Element_count container_end, 
+//                        Element_pos depth_begin, Element_pos depth_end) =0;
+
+//     /*!
+//      * \brief Display on screen events between timer_begin and time_end, 
+//      * container_begin and container_end.
+//      * \param time_begin floating point value : time of the first event.
+//      * \param time_end floating point value : time of the last event.
+//      * \param container_begin integer value : id of the first container.
+//      * \param container_end integer value : id of the last container.
+//      */
+//     virtual void display_event(Element_pos time_begin, Element_pos time_end, 
+//                        Element_count container_begin, Element_count container_end) =0;  
+
+//     /*!
+//      * \brief Display on screen counters between timer_begin and time_end, 
+//      * container_begin and container_end.
+//      * \param time_begin floating point value : time of the smallest counter time value.
+//      * \param time_end floating point value : time of the higher counter time value.
+//      * \param container_begin integer value : id of the first container.
+//      * \param container_end integer value : id of the last container.
+//      */
+//     virtual void display_counter(Element_pos time_begin, Element_pos time_end, 
+//                          Element_count container_begin, Element_count container_end) =0;   
+    
+    /*!
+     * \brief Set the color for the further drawings.
+     * \param r the red value. Within [0 ; 1].
+     * \param g the green value. Within [0 ; 1].
+     * \param b the blue value. Within [0 ; 1].   
+     */
+    void set_color(float r, float g, float b);
+
+    /*!
+     * \brief Draw a text.
+     * \param x the horizontal position of the left bottom corner of the text.
+     * \param y the vertical position of the left bottom corner of the text.
+     * \param z the deep position of the text.
+     * \param s the text.
+     */
+    virtual void draw_text(const Element_pos x, const Element_pos y, const Element_pos z, const std::string s);
+
+    /*!
+     * \brief Draw a quad.
+     * \param x the horizontal position of the left bottom corner of the quad.
+     * \param y the vertical position of the left bottom corner of the quad.
+     * \param z the deep position of the quad.
+     * \param w the width of the quad.
+     * \param h the height of the quad.
+     */
+    void draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h);
+
+    /*!
+     * \brief Draw a triangle.
+     * \param x the horizontal position of the triangle center.
+     * \param y the vertical position of the triangle center.
+     * \param size the edge size.
+     * \param r the rotation of triangle. (clockwise and in degree)
+     */
+    void draw_triangle(Element_pos x, Element_pos y,
+                       Element_pos size, Element_pos r);
+    
+    /*!
+     * \brief Draw a line.
+     * \param x1 the horizontal position of the first point.
+     * \param y1 the vertical position of the firt point.
+     * \param x2 the horizontal position of the second point.
+     * \param y2 the vertical position of the second point.
+     * \param z the deep position of the triangle.
+     */
+    void draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z);
+
+    /*!
+     * \brief Draw a circle.
+     * \param x the horizontal position of the circle center.
+     * \param y the vertical position of the circle center.
+     * \param z the deep position of the circle.
+     * \param r the circle radius.
+     */
+    void draw_circle(Element_pos x, Element_pos y, Element_pos z, Element_pos r);
+
+    /* Temporary methods. Use to draw stored arrows and circles. It is to prevent scaling */
+    void draw_stored_arrows();
+    void draw_stored_circles();
+
+    void draw_stored_texts();
+};
+
+
+
+#endif
diff --git a/src/render/Render_opengl.cpp b/src/render/Render_opengl.cpp
index 7629099d2941ae32561b34ef589857d3ca9cac39..1f3578c46e7f26370570e172f3f40eaf15e6aa63 100644
--- a/src/render/Render_opengl.cpp
+++ b/src/render/Render_opengl.cpp
@@ -63,10 +63,6 @@ using namespace std;
 
 #define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
 
-static bool _draw_container;
-static bool _draw_ruler;
-static bool _draw_arrow;
-static bool _draw_event;
 const int Render_opengl::DRAWING_TIMER_DEFAULT = 10;
 
 /***********************************
@@ -204,76 +200,47 @@ void  Render_opengl::paintGL(){
             glTranslated(0.0, Info::Render::height, 100.0);
 	    glRotated(180.0, 1.0, 0.0, 0.0);
 	    
-
-
-          //   display_container(0, 0);
             glPushMatrix();
-            {
-                
-                /* Translate containers and entities of the ruler height */
-                // glTranslated(0.0, _ruler_height, 0.0);
-                //                glTranslated(- _x_state_translate, -_y_state_translate, 0.0);
-                
+            {             
                 glTranslatef(0.0f, _ruler_y + _ruler_height -_y_state_translate, 0.0);
-                // glScalef( (Info::Render::width/Info::Container::x_max)*_x_scale_container_state, _y_state_scale*(Info::Render::height-_ruler_height)/Info::Container::y_max, 0.0f);
-
                 glScalef(_x_scale_container_state/0.20, _y_state_scale, 1.0);
 
-
                 if (glIsList(_list_containers) == GL_FALSE)
                     *Message::get_instance() << tr("ERROR LIST not exist for containers.").toStdString() << Message::ende;
                 else
                     glCallList(_list_containers);
-
-
             }
             glPopMatrix();
 
-            
             glPushMatrix();
             {
-               
-                glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate, 0.0);
-
-
-                glScalef(_x_state_scale, _y_state_scale, 1.0);
+                glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate,  _z_state);
+                glScalef(_x_state_scale, _y_state_scale, 1);
 
-                   if (glIsList(_list_states) == GL_FALSE)
+                if (glIsList(_list_states) == GL_FALSE)
                     *Message::get_instance() << tr("ERROR LIST not exist for states.").toStdString() << Message::ende;
-                else
+                else{
                     glCallList(_list_states);
+                    glCallList(_list_counters);
+                }
             }
             glPopMatrix();
 
+            if (false == Info::Render::_no_arrows)/* display arrows */
+                draw_stored_arrows();
             
-            //          draw_stored_texts();
-            call_ruler();
-
-        
-//             display_state(0, 0, 0, 0, 0, 0);
-
-             if (false == Info::Render::_no_arrows)/* display arrows */
-                 draw_stored_arrows();
-//                 display_arrow(0, 0, 0, 0, 0, 0);
-            
-             if (false == Info::Render::_no_events)/* display events */
-                 draw_stored_circles();
-//                 display_event(0, 0, 0, 0);
-
-//             display_counter(0, 0, 0, 0);
-
+            if (false == Info::Render::_no_events)/* display events */
+                draw_stored_circles();
 	
             /* Untranslate ruler */
-             /*    glTranslated(0.0, -_ruler_height, 0.0);
-
             glEnable(GL_BLEND);
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
             call_ruler();
-            glDisable(GL_BLEND);*/
+            glDisable(GL_BLEND);
                         
         }
         glPopMatrix();
-
+        
         glPushMatrix();
         {
             glTranslated(0.0,  0.0, 100.0);/* not accurate */
@@ -334,6 +301,11 @@ void  Render_opengl::paintGL(){
 
 
 
+
+    if(DRAWING_STATE_WAITING == _state)/* A wait is drawn, do not take car about the ruler drawing */
+        return;
+
+
     QFont arial_font = QFont("Arial", 10);
     qglColor(Qt::white);//QColor(0, 0, 0));
 
@@ -486,8 +458,8 @@ bool Render_opengl::unbuild(){
     Info::Container::x_min = 0;
     Info::Container::y_min = 0;
 
-    Info::Render::_ui_render_min_value->setText("");
-    Info::Render::_ui_render_max_value->setText("");
+    //  Info::Render::_ui_render_min_value->setText("");
+    // Info::Render::_ui_render_max_value->setText("");
 
     Info::Entity::x_max = 0;
     Info::Entity::x_min = 0;
@@ -619,6 +591,7 @@ void Render_opengl::call_ruler(){
     graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
     coeff_prefix    = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
     
+    set_color(1.0, 1.0, 1.0);
     
     for (Element_pos i = Info::Render::_x_min_visible ; i < Info::Render::_x_max_visible ; i+=graduation_diff){
         const Element_pos grad_div_by_5 = graduation_diff/5;
@@ -660,12 +633,11 @@ void Render_opengl::set_color(float r, float g, float b){
     _red = r;
     _green = g;
     _blue = b;
-
-    glColor3d(_red, _green, _blue);
 }
 
 void Render_opengl::draw_text(const Element_pos x, const Element_pos y, const Element_pos, const std::string s){
     if (_draw_ruler) return;/* do not draw text for ruler */
+    if (_draw_state) message << "Fatal error! Cannot put text in state lists!" << Message::ende;
 
         Container_text_ buf;
 
@@ -677,23 +649,23 @@ void Render_opengl::draw_text(const Element_pos x, const Element_pos y, const El
 }
 
 
-void Render_opengl::draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h){
+void Render_opengl::draw_quad(Element_pos x, Element_pos y, Element_pos /*z*/, Element_pos w, Element_pos h){
     Element_pos offset_x;
-    const Element_pos offset_y = -_ruler_y - _ruler_height;
+    Element_pos offset_y = -_ruler_y - _ruler_height;
 
     offset_x = 0;
 
     if (!_draw_container)
         offset_x = -_default_entity_x_translate;
-
-    glBegin(GL_QUADS);
+    
+     glBegin(GL_QUADS);
     {
         glColor3d(_red, _green, _blue);
-        glVertex3d(x + offset_x    , y + offset_y    , z        );
-        glVertex3d(x + offset_x    , y + h + offset_y, z        );
-        glColor3d(_red/1.5         , _green/1.5      , _blue/1.5);
-        glVertex3d(x + w + offset_x, y + h + offset_y, z        );
-        glVertex3d(x + w + offset_x, y + offset_y    , z        );
+        glVertex2d(x + offset_x    , y + offset_y);
+        glVertex2d(x + offset_x    , y + h + offset_y);
+        glColor3d(_red/1.5         , _green/1.5  , _blue/1.5);
+        glVertex2d(x + w + offset_x, y + h + offset_y);
+        glVertex2d(x + w + offset_x, y + offset_y);
     }
     glEnd();
 }
@@ -704,7 +676,7 @@ void Render_opengl::draw_triangle(Element_pos , Element_pos ,
 
 void Render_opengl::draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z){
     if (_draw_ruler || _draw_arrow || _draw_event) return;/* do not draw line for ruler or for arrow or for event */
-
+    if (_draw_state) message << "Fatal error! Cannot put line in state lists!" << Message::ende;
 
     const Element_pos offset_x = -_default_entity_x_translate;
     const Element_pos offset_y = -_ruler_y - _ruler_height;
@@ -724,10 +696,11 @@ void Render_opengl::draw_circle(Element_pos /*x*/, Element_pos /*y*/, Element_po
 
 void Render_opengl::start_draw(){
 
-    _draw_ruler = false;
     _draw_container = false;
-    _draw_arrow = false;
-    _draw_event = false;
+    _draw_state     = false;
+    _draw_ruler     = false;
+    _draw_arrow     = false;
+    _draw_event     = false;
    
 }
 
@@ -736,9 +709,9 @@ void Render_opengl::start_draw_containers(){
     if (_list_containers == 0) {
         *Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
     }
-    
+
+    _draw_container = true;    
     glNewList(_list_containers, GL_COMPILE);/* open the list */
-    _draw_container = true;
 }
 
 void Render_opengl::draw_container(const Element_pos , const Element_pos , const Element_pos , const Element_pos ){
@@ -758,7 +731,8 @@ void Render_opengl::start_draw_states(){
     if (_list_states == 0) {
         *Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
     }
-    
+
+    _draw_state = true;    
     glNewList(_list_states, GL_COMPILE);/* open the list */
 }
 
@@ -766,7 +740,8 @@ void Render_opengl::draw_state(const Element_pos , const Element_pos , const Ele
 }
 
 void Render_opengl::end_draw_states(){
-   
+    glEndList();/* close the states list */
+    _draw_state = false;
 }
 
 void Render_opengl::start_draw_arrows(){
@@ -819,12 +794,19 @@ void Render_opengl::end_draw_events(){
 }
 
 void Render_opengl::start_draw_counter(){
+    _list_counters = glGenLists(1);/* create the list */
+    if (_list_counters == 0) {
+        *Message::get_instance() << tr("Error when creating list").toStdString() << Message::ende;
+    }
+    
+    glNewList(_list_counters, GL_COMPILE);/* open the list */
 }
 
 void Render_opengl::draw_counter(const Element_pos , const Element_pos ){
 }
 
 void Render_opengl::end_draw_counter(){
+    glEndList();/* close the list */
 }
 
 void Render_opengl::start_ruler(){
@@ -836,7 +818,6 @@ void Render_opengl::end_ruler(){
 }
 
 void Render_opengl::end_draw(){
-    glEndList();/* close the states list */
 }
 
 
@@ -861,7 +842,7 @@ void Render_opengl::draw_stored_arrows(){
         start_height = _arrows[i].start_height;
         end_height   = _arrows[i].end_height;
 
-        set_color(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
+        glColor3d(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
         
         scaled_start_time   = start_time   * _x_state_scale;
         scaled_end_time     = end_time     * _x_state_scale;
@@ -926,7 +907,7 @@ void Render_opengl::draw_stored_circles(){
         glPushMatrix();
         {
 
-            set_color(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue); 
+            glColor3d(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue); 
                       
             glTranslated(_default_entity_x_translate - _x_state_translate,
                          _ruler_y + _ruler_height - _y_state_translate,
@@ -946,7 +927,7 @@ void Render_opengl::draw_stored_circles(){
              glEnd();
              
 
-             set_color(_circles[i].red, _circles[i].green, _circles[i].blue); 
+             glColor3d(_circles[i].red, _circles[i].green, _circles[i].blue); 
              
              /* Draw the sub-circle */
              glBegin(GL_POLYGON);
@@ -975,8 +956,5 @@ void Render_opengl::draw_stored_circles(){
         }
         glPopMatrix();
     }
-
-    set_color(1.0, 1.0, 1.0);
-  
 }
     
diff --git a/src/render/Render_opengl.hpp b/src/render/Render_opengl.hpp
index 308eb79d75ca1fbc60c0d9cadca7c21a1468eb4b..330271b2b8db63723bbf8ccf67734893ab22a023 100644
--- a/src/render/Render_opengl.hpp
+++ b/src/render/Render_opengl.hpp
@@ -94,6 +94,15 @@ class Render_opengl :  /*public QGLWidget,*/ public Hook_event, public Render_te
 {
     Q_OBJECT
     
+    
+    private:
+    
+    bool _draw_container;
+    bool _draw_state;
+    bool _draw_ruler;
+    bool _draw_arrow;
+    bool _draw_event;
+    
 protected:
     
     /*!
@@ -166,6 +175,8 @@ protected:
      */
     int _wait_spf;
 
+
+
     /*!
      * \brief Timer to animate the wait.
      */
diff --git a/src/render/vbo.cpp b/src/render/vbo.cpp
index becd421293f34eb2cc6bb2e16e649134608485f4..9d7853e8bf9738e06d64e90c5e4cc6e7b2c50c06 100644
--- a/src/render/vbo.cpp
+++ b/src/render/vbo.cpp
@@ -43,14 +43,15 @@
 /*!
  *\file vbo.cpp
  */
- 
-#include "common/common.hpp"
-/* -- */
-#include "render/vbo.hpp"
-/* -- */
-using namespace std;
+ #include <GL/glew.h>
+#include <stdlib.h>
+#include <iostream>
+#include "vbo.hpp"
 
-#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
+
+#define ERROR(m) printf("%s", m);
+
+using namespace std;
 
 const int Vbo::VBO_OK              = 0;
 const int Vbo::VBO_OUT_OF_MEMORY   = 1;
@@ -70,7 +71,7 @@ Vbo::Vbo(){
 }
 
 
-Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum client_state){
+Vbo::Vbo(int nb_object, Type object_type){
 
     /* init class attributes */
 
@@ -79,13 +80,25 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
     _id = 0;
 
     _nb_object = nb_object;
-    _nb_verteces_per_object = nb_verteces_per_object;
+
+    switch (object_type){
+    case TRIANGLES:
+        _nb_verteces_per_object = 3;
+        _object_type = GL_TRIANGLES;
+        break;
+    case QUADS:
+        _nb_verteces_per_object = 4;
+        _object_type = GL_QUADS;
+        break;
+    case LINES:
+        _nb_verteces_per_object = 2;
+        _object_type = GL_LINES;
+    }
     
     /* There is _nb_object*(number_of_vertices_per_object) elements. */
-    _size =  _nb_coordinates_per_vertex*nb_verteces_per_object*_nb_object;
+    _size =  _nb_coordinates_per_vertex*_nb_verteces_per_object*_nb_object;
 
-    _object_type = object_type;
-    _client_state = client_state;
+    _client_state = GL_VERTEX_ARRAY;
 
 
     /* init OpenGL */
@@ -94,7 +107,7 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
 
     glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
     
-    glBufferData(GL_ARRAY_BUFFER, _size*sizeof(Element_pos), NULL, GL_STREAM_DRAW);/* allocate memory space inside graphic card */
+    glBufferData(GL_ARRAY_BUFFER, _size*sizeof(Data_type), NULL, GL_STREAM_DRAW);/* allocate memory space inside graphic card */
        
     glBindBuffer(GL_ARRAY_BUFFER, 0);/* deselect our vbo */
 
@@ -102,7 +115,7 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
 
 
 Vbo::~Vbo(){
-    glDeleteBuffers(1, &_id);/* release the buffer and free its memory inside graphic card */
+    glDeleteBuffers(1, &_id);/* release the buffer and free its memory inside the graphic card */
     _id = 0;
 }
 
@@ -119,7 +132,7 @@ Vbo::~Vbo(){
  *
  **********************************/
 
-int Vbo::fill_buffer(const unsigned int data_size,  const Element_pos* const data){
+int Vbo::add(const unsigned int data_size,  const Data_type* const data){
 
     glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
 
@@ -132,7 +145,7 @@ int Vbo::fill_buffer(const unsigned int data_size,  const Element_pos* const dat
 
     if ( (_cur+data_size) <= _size){
         
-        glBufferSubData(GL_ARRAY_BUFFER, _cur*sizeof(Element_pos), data_size*sizeof(Element_pos), data);
+        glBufferSubData(GL_ARRAY_BUFFER, _cur*sizeof(Data_type), data_size*sizeof(Data_type), data);
         _cur += data_size;
    
     }else{
@@ -148,7 +161,7 @@ int Vbo::fill_buffer(const unsigned int data_size,  const Element_pos* const dat
 
 
 int Vbo::get_remaining_size() const{
-    return (_size-_cur);
+    return (_size-_cur)/(_nb_verteces_per_object*_nb_coordinates_per_vertex);
 }
 
 
@@ -164,7 +177,7 @@ int Vbo::get_remaining_size() const{
   *
   **********************************/
 
-void Vbo::display_buffer() const{
+void Vbo::display() const{
 
     glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
 
@@ -212,48 +225,5 @@ void Vbo::display_buffer() const{
 void Vbo::display_info(){
 
     GLvoid* _read_buf = NULL;
-
-    message << "*** Display VBO info ***" << Message::endi;
-
-    message << "Id: " << _id << Message::endi;
-
-    message << "Current position inside vbo: " << _cur << Message::endi;
-
-    message << "Coordinates per vertex: " << _nb_coordinates_per_vertex << Message::endi;
-
-    message << "Verteces per object: " << _nb_verteces_per_object << Message::endi;
-
-    message << "Max objects per vertex buffer: " << _nb_object << Message::endi;
-
-    message << "Max size of the vbo (verteces_per_object * nb_object * sizeof(Element_pos)) in Bytes: " << _size*sizeof(Element_pos) << Message::endi;
-
-    message << "Object type: " << _object_type << Message::endi;
-
-    message << "Client state: " << _client_state << Message::endi;
-
-
-    /* Now, read the video memory */
-    message << Message::endi <<  Message::endi << "Display memory data: " << Message::endi;
-
-    glBindBuffer(GL_ARRAY_BUFFER, _id);
-
-    _read_buf = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
-    if (NULL == _read_buf){
-        message << "Cannot access data" << Message::endi;
-    }
-    else{
-        for (unsigned int i = 0 ; i< _cur ; i++)
-            message << ((Element_pos*)_read_buf)[i] << Message::endi;
-
-        message << "End display memory data" << Message::endi;
-        if (GL_FALSE == glUnmapBuffer(GL_ARRAY_BUFFER)){
-                message << "Cannot unmap the vbo" << Message::ende;
-            }
-            else{
-                _read_buf = NULL;
-            }
-    }
-
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-
+ 
 }
diff --git a/src/render/vbo.hpp b/src/render/vbo.hpp
index f85e0e67384360bf37963742d662bd3795fea954..28fac022e13235d16fa65e49b3eb0377ef5becbe 100644
--- a/src/render/vbo.hpp
+++ b/src/render/vbo.hpp
@@ -47,6 +47,12 @@
 #ifndef VBO_HPP
 #define VBO_HPP
 
+
+typedef double Data_type;
+
+
+
+
 /*!
   \def VBO_BUFFER_OFFSET(a)
   OpenGL special macro
@@ -116,6 +122,13 @@ private:
 
 public:
 
+    enum Type{
+        TRIANGLES,
+        QUADS,
+        LINES
+    };
+
+
     /***********************************
      *
      * Constructor and destructor.
@@ -129,7 +142,7 @@ public:
      * \param object_type Defines how kind of OpenGL primitive object is made.
      * \param client_state Define how kind of OpenGL buffer object belongs to.
      */
-    Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum client_state);
+    Vbo(int nb_object, Type object_type);
 
     /*!
      * \brief The destructor.
@@ -173,7 +186,7 @@ public:
      * <li><b>VBO_UNDEFINED_ERROR</b>: an error occurs but has not been identified.
      * </ul>
      */
-    int fill_buffer(const unsigned int data_size, const Element_pos* const data);
+    int add(const unsigned int data_size, const Data_type* const data);
 
 
     /*!
@@ -194,7 +207,7 @@ public:
     /*!
      * \brief Display the VBO list inside the OpenGL area.
      */
-    void display_buffer() const;
+    void display() const;
 
 
 
@@ -209,6 +222,12 @@ public:
      */
     void display_info();
 
+
+    void *operator new(size_t s){
+        std::cout << "Vbo: allocation de "<< s << " octets." << std::endl;
+        return malloc(s*sizeof(Vbo));
+    }
+
 };
 
 
@@ -222,23 +241,23 @@ public:
  *
  ****************/
 
-struct Vbo_container : public Vbo{
+// struct Vbo_container : public Vbo{
 
-public:
+// public:
 
-    /*!
-     * \brief The default constructor.
-     */
-    Vbo_container():Vbo(4, 8000, GL_QUADS, GL_VERTEX_ARRAY){
-    }
+//     /*!
+//      * \brief The default constructor.
+//      */
+//     Vbo_container():Vbo(4, 8000, GL_QUADS, GL_VERTEX_ARRAY){
+//     }
 
-    /*!
-     * \brief The destructor.
-     */
-    virtual ~Vbo_container(){
-    }
+//     /*!
+//      * \brief The destructor.
+//      */
+//     virtual ~Vbo_container(){
+//     }
 
-};
+// };
 
 
 
@@ -252,47 +271,47 @@ public:
  ****************/
 
 
-/*!
- * \brief VBO uses for triangle arrows. 
- */
-struct Vbo_arrow_triangle : public Vbo{
+// /*!
+//  * \brief VBO uses for triangle arrows. 
+//  */
+// struct Vbo_arrow_triangle : public Vbo{
 
-public:
+// public:
 
-    /*!
-     * \brief The default constructor.
-     */
-    Vbo_arrow_triangle():Vbo(3, 2000, GL_TRIANGLES, GL_VERTEX_ARRAY){
-    }
+//     /*!
+//      * \brief The default constructor.
+//      */
+//     Vbo_arrow_triangle():Vbo(3, 2000, GL_TRIANGLES, GL_VERTEX_ARRAY){
+//     }
 
-    /*!
-     * \brief The destructor.
-     */
-    virtual ~Vbo_arrow_triangle(){
-    }
-};
+//     /*!
+//      * \brief The destructor.
+//      */
+//     virtual ~Vbo_arrow_triangle(){
+//     }
+// };
 
 
 
-/*!
- * \brief VBO uses for line arrows. 
- */
-struct Vbo_arrow_line : public Vbo{
+// /*!
+//  * \brief VBO uses for line arrows. 
+//  */
+// struct Vbo_arrow_line : public Vbo{
 
-public:
+// public:
 
-    /*!
-     * \brief The default constructor.
-     */
-    Vbo_arrow_line():Vbo(2, 8000, GL_LINES, GL_VERTEX_ARRAY){
-    }
+//     /*!
+//      * \brief The default constructor.
+//      */
+//     Vbo_arrow_line():Vbo(2, 8000, GL_LINES, GL_VERTEX_ARRAY){
+//     }
 
-    /*!
-     * \brief The destructor.
-     */
-    virtual ~Vbo_arrow_line(){
-    }
-};
+//     /*!
+//      * \brief The destructor.
+//      */
+//     virtual ~Vbo_arrow_line(){
+//     }
+// };
 
 
  #endif
diff --git a/src/src.pro b/src/src.pro
index 787bd2a56f79b17febe3748d8445518b8bdcf6cd..f209dfc2629d373c44a2a393c9eb287b0070e059 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -64,6 +64,8 @@ LIBS += general/otf/otflib/.libs/libotf.a -Lgeneral/otf/otflib/.libs
 # LIBS += -lglut
 #}
 
+LIBS += -lGLEW
+
 macx {
  QMAKESPEC = macx-g++
 # QMAKE_LFLAGS += -F/System/Library/Frameworks/GLUT
@@ -97,7 +99,8 @@ HEADERS += common/common.hpp 	\
            render/render_stats.hpp \
            render/render_stats_opengl.hpp \
            render/render_stats_svg.hpp \
-#          render/vbo.hpp \
+           render/Render_alternate.hpp \
+           render/vbo.hpp \
 # Parser headers
            parser/Definition.hpp \
            parser/Line.hpp \
@@ -202,7 +205,8 @@ SOURCES += common/Message.cpp	 	\
            render/Render_svg.cpp 	\
            render/render_stats_opengl.cpp \
            render/render_stats_svg.cpp 	\
-#          render/vbo.cpp \
+           render/Render_alternate.cpp \
+           render/vbo.cpp \
 # Statistics code files
            statistics/Stats_window.cpp 	\
            statistics/Statistic.cpp	\