diff --git a/src/cairo_widget.cc b/src/cairo_widget.cc
index fb4a387..26dff27 100644
--- a/src/cairo_widget.cc
+++ b/src/cairo_widget.cc
@@ -130,24 +130,27 @@ CairoWidget::on_size_request(Gtk::Requisition* requisition)
   // Gtk+ asks the desired widget dimension
 
   // std::cout << " on_size_request, requisition->width : " << requisition->width << ", requisition->height : " << requisition->height << std::endl;
+
+  _client_w = requisition->width;
+  _client_h = requisition->height;
+
   calc_widget_size(_client_w, _client_h);
+
   requisition->width  = _client_w;
   requisition->height = _client_h;
-
 }
 
 
 bool
 CairoWidget::on_expose_event(GdkEventExpose* event)
 {
-   // std::cout << " on_expose_event START...";
+  // std::cout << " on_expose_event START...";
   if (event == NULL || event->count > 0)
     return false;
   // std::cout << " on_expose_event CONTINUE." << std::endl;
-    
-    int actual_w = get_width();
-    int actual_h = get_height();
-    
+
+  int actual_w = get_width();
+  int actual_h = get_height();
     // std::cout << " get_width() : " << actual_w << ", get_height() : " << actual_h << std::endl;
     // std::cout << " _client_w : " << _client_w << ", _client_h : " << _client_h << std::endl;
     // std::cout << " _pixmap_w : " << _pixmap_w << ", _pixmap_h : " << _pixmap_h << std::endl;
@@ -163,9 +166,10 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
       // previdence in the code: allocate more than actually needed
       _pixmap_w = (size_t) (_client_w*1.2);
       _pixmap_h = (size_t) (_client_h*1.2);
-      std::cout << " on_expose_event CREATE Pixmap. w : " << _pixmap_w << ", h : " << _pixmap_h<< std::endl;
+      // std::cout << " on_expose_event CREATE Pixmap. w : " << _pixmap_w << ", h : " << _pixmap_h<< std::endl;
       _buf = Gdk::Pixmap::create(get_window(), _pixmap_w, _pixmap_h);
     }
+
   
     // Draw the widget background as the first thing.
     // I've seen this is how it's done in the very Gtk+ toolkit
@@ -176,50 +180,23 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
                   GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_IN,
                   NULL, (GtkWidget*)this->gobj(), "through",
                   0, 0, _client_w, _client_h);
-  
+
     cairo_t* ctx = gdk_cairo_create(_buf->gobj());
-  
+
     // Determine the final drawing dimensions before to start drawing
     _draw_w = _draw_h = 0; // default no scaling
-    calc_drawing_size(_draw_w, _draw_h);
+    calc_drawing_size(ctx, _draw_w, _draw_h);
+
+    calc_scale_factors();
+
     // do the drawing...
-    if(_scaling_mode!=scaling_none && _draw_w>0 && _draw_h>0)
-    {
-      double sx = (double)_client_w/(double)_draw_w;
-      double sy = (double)_client_h/(double)_draw_h;
-      switch(_scaling_mode)
-      {
-        case scaling_none:
-          sx = sy = 1.0;
-          break;
-        case scaling_to_w:
-          sy = sx;
-          break;
-        case scaling_to_h:
-          sx = sy;
-          break;
-        case scaling_min:
-          if(sx<=sy)
-            sy = sx;
-          else
-            sx = sy;
-          break;
-        case scaling_max:
-          if(sx>=sy)
-            sy = sx;
-          else
-            sx = sy;
-          break;
-        case scaling_all:
-          // nothing to do...
-          break;
-      }
-      cairo_scale(ctx, sx, sy);
-    }
+    cairo_scale(ctx, _scale_x, _scale_y);
+
     // std::cout << " on_expose_event Dimensions, w : " << _draw_w << ", h : " << _draw_h << std::endl;
     draw_widget(ctx);
     cairo_destroy(ctx);
   }
+
   // calculated dinamically on update():
   // set_size_request(_draw_w, _draw_h);
 
@@ -235,6 +212,47 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
   return true;
 }
 
+void
+CairoWidget::calc_scale_factors()
+{
+  if(_scaling_mode!=scaling_none && _draw_w!=0 && _draw_h!=0)
+  {
+    _scale_x = (double)_client_w/(double)_draw_w;
+    _scale_y = (double)_client_h/(double)_draw_h;
+    switch(_scaling_mode)
+    {
+      case scaling_none: // not necessary!
+        _scale_x = _scale_y = 1.0;
+        break;
+      case scaling_to_w:
+        _scale_y = _scale_x;
+        break;
+      case scaling_to_h:
+        _scale_x = _scale_y;
+        break;
+      case scaling_min:
+        if(_scale_x<=_scale_y)
+          _scale_y = _scale_x;
+        else
+          _scale_x = _scale_y;
+        break;
+      case scaling_max:
+        if(_scale_x>=_scale_y)
+          _scale_y = _scale_x;
+        else
+          _scale_x = _scale_y;
+        break;
+      case scaling_all:
+        // nothing to do...
+        break;
+    }
+  }
+  else
+  {
+    _scale_x = _scale_y = 1.0;
+  }
+}
+
 bool
 CairoWidget::on_button_press_event(GdkEventButton* event)
 {
@@ -249,13 +267,42 @@ CairoWidget::redraw()
   queue_draw();
 }
 
-
 void
-CairoWidget::calc_drawing_size(size_t& width, size_t& height) const
+CairoWidget::resize_redraw()
 {
+  
+  // std::cout << " resize_redraw BEGIN width: " << get_width() << ", height: " << get_height() << std::endl;
+  if(_buf)
+  {
+    cairo_t* ctx = gdk_cairo_create(_buf->gobj());
+
+    if(ctx)
+    {
+      // Determine the final drawing dimensions before to start drawing
+      _draw_w = _draw_h = 0; // default no scaling
+      calc_drawing_size(ctx, _draw_w, _draw_h);
+  
+      calc_scale_factors();
+  
+      set_size_request((int)_scale_x*_draw_w, (int)_scale_y*_draw_h);
+      cairo_destroy(ctx);
+      //std::cout << " resize_redraw DO  width: " << _scale_x*_draw_w << ", height: " << _scale_y*_draw_h << std::endl;
+    }
+  }
+
+  // Force redraw
+  _need_redraw = true;
+  queue_draw();
 }
 
 void
-CairoWidget::calc_widget_size(size_t& width, size_t& height) const
+CairoWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
 {
 }
+
+
+void
+CairoWidget::calc_widget_size(size_t& width, size_t& height)
+{
+}
+
diff --git a/src/cairo_widget.hh b/src/cairo_widget.hh
index 63591c4..f74f34a 100644
--- a/src/cairo_widget.hh
+++ b/src/cairo_widget.hh
@@ -24,6 +24,7 @@
 #include "config.h"
 
 #include <cairo.h>
+#include <gtkmm/drawingarea.h>
 #include <gtkmm/widget.h>
 #include <gdkmm/pixmap.h>
 
@@ -44,14 +45,24 @@ namespace sgpem
 
     CairoWidget();
     virtual ~CairoWidget();
+
+    // scaling related functions
     scaling_mode set_scaling_mode(scaling_mode scaling_mode);
     scaling_mode get_scaling_mode();
-    void change_scaling_mode();
+
+    // need for redrawing the widget (double buffering related)
     void redraw();
 
+    // need for auto resizing and redrawing the widget (double buffering related)
+    void resize_redraw();
+    
+    // TODO - temporary: will be removed soon
+    // void change_scaling_mode();
+
   protected:
     typedef unsigned int    size_t;
 
+    // implements fundamental widget's method
     virtual void on_realize();
     virtual void on_size_allocate(const Gtk::Allocation& allocation);
     virtual void on_size_request(Gtk::Requisition* request);
@@ -62,10 +73,12 @@ namespace sgpem
     virtual void draw_widget(cairo_t* ctx) = 0;
 
     // with this method CairoWidget tells the needed drawing dimensions
-    virtual void calc_drawing_size(size_t& width, size_t& height) const;
+    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
 
     // with this method CairoWidget tells the needed widgwt dimensions
-    virtual void calc_widget_size(size_t& width, size_t& height) const;
+    virtual void calc_widget_size(size_t& width, size_t& height);
+
+    void calc_scale_factors();
 
     typedef Gdk::Rectangle                           area_t;
     typedef sigc::mem_functor0<void, CairoWidget>    method0_t;
@@ -75,12 +88,18 @@ namespace sgpem
   private:
     // The width and height the widget will assume, must be determined
     // before starting drawing by calc_size()
+    // drawing dimensions required
     mutable size_t      _draw_w;
     mutable size_t      _draw_h;
+    // window client area
     mutable size_t      _client_w;
     mutable size_t      _client_h;
+    // pixmap client area
     mutable size_t      _pixmap_w;
     mutable size_t      _pixmap_h;
+    // cairo scale factors
+    mutable double      _scale_x;
+    mutable double      _scale_y;
 
     mutable bool        _need_redraw;
     scaling_mode        _scaling_mode;
diff --git a/src/simulation_widget.cc b/src/simulation_widget.cc
index 37447fd..a5affd9 100644
--- a/src/simulation_widget.cc
+++ b/src/simulation_widget.cc
@@ -57,7 +57,8 @@ SimulationWidget::update(const Simulation& changed_simulation)
   _simulation = &changed_simulation;
 
   // Force redraw
-  redraw();
+  //redraw();
+  resize_redraw();
 }
 
 
@@ -71,24 +72,63 @@ SimulationWidget::draw_widget(cairo_t* ctx)
   std::cout << " draw_widget continue " << std::endl;
   
   */
-  const  History& hist = Simulation::get_instance().get_history();
+  
+  const  Simulation& simu = Simulation::get_instance();
+  double top_margin = _y_unit;
+  double left_margin = _x_unit;
+  double top_graph_margin    =  1.0 * _y_unit; //3.0 * _y_unit;
+  double left_graph_margin   = 11.0 * _x_unit;
+  double process_label_delta =  1.0 * _y_unit;
+  double process_bar_delta   =  1.0 * _y_unit;
+  double process_bar_height  =  1.0 * _y_unit;
+  double process_height = process_bar_height + 2*process_bar_delta;
+  Simulation::state sim_state = simu.get_state();
+  const  History& hist = simu.get_history();
   const  Environment::Processes& processes = hist.get_last_environment().get_processes();
   int    nproc = processes.size();
   double text_maxw = 0;
   bool*  terminated = 0;
+  cairo_text_extents_t extents;
+
+  // evaluate minimum x and y extensions
+  /*
+  // show simulation title
+  Glib::ustring title;
+  switch(sim_state)
+  {
+    case Simulation::state_running:
+      title = "Simulation Running";
+      break;
+    case Simulation::state_paused:
+      title = "Simulation Paused";
+      break;
+    case Simulation::state_stopped:
+      title = "Simulation Stopped";
+      break;
+  }
+  cairo_text_extents(ctx, title.c_str(), &extents);
+  cairo_move_to(ctx, left_margin, extents.height + top_margin);
+  cairo_show_text(ctx,title.c_str());
+  */
+
   if(nproc>0)
     terminated = new bool[nproc];
-  
+
+  // show processes names...
+  // set clip region to cut long names
+  cairo_rectangle(ctx, 0, top_graph_margin, left_graph_margin - _x_unit, nproc*process_height);
+  cairo_clip(ctx); // set the rectangular clip region
   for(int i=0; i<nproc; i++)
   {
-    cairo_text_extents_t extents;
+    // cairo_text_extents_t extents;
     cairo_text_extents(ctx, processes[i]->get_name().c_str(), &extents);
     if(text_maxw<extents.width)
       text_maxw=extents.width;
-    cairo_move_to(ctx, _x_unit, extents.height + (3*i+1)*_y_unit);
+    cairo_move_to(ctx, left_margin, extents.height + top_graph_margin + process_height*i + process_label_delta);
     cairo_show_text(ctx,processes[i]->get_name().c_str());
     terminated[i] = false;
   }
+  cairo_reset_clip(ctx); // remove clip region
 
   if(_simulation && hist.get_size()>0
       /* && _simulation->get_state()!=Simulation::state_stopped */ )
@@ -96,13 +136,38 @@ SimulationWidget::draw_widget(cairo_t* ctx)
     // std::cout << " draw_widget not_stop " << std::endl;
     unsigned int pos = _simulation->get_front();
 
+    // show grid
+    cairo_save(ctx);
+    cairo_set_line_width(ctx, 0.5*cairo_get_line_width(ctx));
+    // nproc+1 horizontal lines
+    for(int i=0; i<=nproc; i++)
+    {
+      cairo_move_to(ctx, left_graph_margin, top_graph_margin + process_height*i);
+      cairo_line_to(ctx, left_graph_margin + (pos+2)*_x_unit, top_graph_margin + process_height*i);
+    }
+     // opening vertical line
+    cairo_move_to(ctx, left_graph_margin, top_graph_margin);
+    cairo_line_to(ctx, left_graph_margin, top_graph_margin + process_height*nproc);
+    cairo_stroke(ctx);
+
+     // closing vertical line
+    if(sim_state!=Simulation::state_stopped)
+    {
+      double dashes = 1.5;
+      cairo_set_dash(ctx, &dashes, 1, 0.0);
+    }
+    cairo_move_to(ctx, left_graph_margin + (pos+2)*_x_unit, top_graph_margin);
+    cairo_line_to(ctx, left_graph_margin + (pos+2)*_x_unit, top_graph_margin + process_height*nproc);
+    cairo_stroke(ctx);
+    cairo_restore(ctx);
+
     for(int t=1; t<=pos; t++)
     {
       const Environment::Processes& processes = hist.get_environment_at(t).get_processes();
-      double xpos = text_maxw + (1 + t)*_x_unit;
+      double xpos = left_graph_margin + t*_x_unit;
       for(int i=0; i<nproc; i++)
       {
-        double ypos = (3*i+1)*_y_unit;
+        double ypos = top_graph_margin + process_height*i + process_bar_delta;
         Schedulable::state st = processes[i]->get_state();
         switch(st)
         {
@@ -135,20 +200,57 @@ SimulationWidget::draw_widget(cairo_t* ctx)
         }
       }
     }
+
+
+    cairo_save(ctx);
+    cairo_set_source_rgb(ctx, 0, 0, 0);
+    cairo_set_line_width(ctx, 0.25*cairo_get_line_width(ctx));
+    for(int t=0; t<=pos; t++)
+    {
+      cairo_move_to(ctx, left_graph_margin + (t+1)*_x_unit, top_graph_margin + process_height*nproc);
+      cairo_rel_line_to(ctx, 0, 0.5 * _y_unit);
+      Glib::ustring val;
+      int_to_string(t, val);
+      cairo_move_to(ctx, left_graph_margin + (t+1)*_x_unit,
+          top_graph_margin + process_height*nproc + _y_unit + extents.height);
+      cairo_show_text(ctx,val.c_str());
+    }
+    cairo_stroke(ctx);
+    cairo_restore(ctx);
+
+    /*
+    int w = left_graph_margin + (pos+4)*_x_unit;
+    int h = top_graph_margin + process_height*nproc + 4*_y_unit;
+    if(get_height()<h || get_width()<w)
+      set_size_request(w,h);
+    */
   }
   delete[] terminated;
+
 }
 
 
 void
-SimulationWidget::calc_drawing_size(size_t& width, size_t& height) const
+SimulationWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
 {
   if(!_simulation)
     return;
   const History& hist = _simulation->get_history();
   const Environment::Processes& processes = hist.get_last_environment().get_processes();
-  width  = (10 + 1 + hist.get_size()) * _x_unit;
-  height = 3 * processes.size() * _y_unit;
+  int pos = _simulation->get_front();
+  cairo_text_extents_t extents;
+
+  // std::cout << " x_unit: " << std::endl;
+  Glib::ustring val("999");
+  cairo_text_extents(ctx, val.c_str(), &extents);
+  if(_x_unit<extents.width)
+    _x_unit=extents.width;
+  if(_y_unit<extents.height)
+    _y_unit=extents.height;
+
+  // left margin, labels, graph
+  width  = (1.0 + 11.0 + 3.0 + pos) * _x_unit;
+  height = (1.0 + 3.0 * processes.size() + 3.0) * _y_unit;
 }
 
 /*
diff --git a/src/simulation_widget.hh b/src/simulation_widget.hh
index 9a73413..22ab95b 100644
--- a/src/simulation_widget.hh
+++ b/src/simulation_widget.hh
@@ -41,8 +41,8 @@ namespace sgpem
 
     void draw_widget(cairo_t* ctx);
 
-    virtual void calc_drawing_size(size_t& width, size_t& height) const;
-    // void calc_size(const History& history, size_t& width, size_t& height) const;
+    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
+
   private:
     int _x_unit;
     int _y_unit;
diff --git a/src/testsuite/test-cairo_widget.cc b/src/testsuite/test-cairo_widget.cc
index 5adad9c..04b5cc0 100644
--- a/src/testsuite/test-cairo_widget.cc
+++ b/src/testsuite/test-cairo_widget.cc
@@ -60,7 +60,7 @@ namespace sgpem
     void draw_widget(cairo_t* ctx);
     void change_scaling_mode();
 
-    virtual void calc_drawing_size(size_t& width, size_t& height) const;
+    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
     // void calc_size(const History& history, size_t& width, size_t& height) const;
   private:
     int _desired_w;
@@ -103,18 +103,18 @@ TestWidget::draw_widget(cairo_t* ctx)
   // NOTE: just to try
   CairoElements ce(ctx);
 
-  Rectangle area(10, 10, _desired_w-10, _desired_h/2);
+  Rectangle area( 10, 10, _desired_w-10, _desired_h/2 );
   ce.draw_container(area);
   Color red(1, 0, 0 );
-  Point center1(_desired_w/4, _desired_h/4*3);
+  Point center1(_desired_w/4, _desired_h/4*3 );
   ce.draw_3dsphere(center1, _desired_w/10, red);
   
   Color yellow(1, 1, 0);
   Point center2(_desired_w/4*2, _desired_h/4*3);
   ce.draw_3dsphere(center2, _desired_w/10, yellow);
 
-  Color green(0, 1, 0);
-  Point center3(_desired_w/4*3, _desired_h/4*3);
+  Color green(0, 1, 0 );
+  Point center3(_desired_w/4*3, _desired_h/4*3 );
   ce.draw_3dsphere(center3, _desired_w/10, green);
 
   // show text
@@ -153,7 +153,7 @@ TestWidget::draw_widget(cairo_t* ctx)
 
 
 void
-TestWidget::calc_drawing_size(size_t& width, size_t& height) const
+TestWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
 {
   // FIXME: write me
   // some magic here!
@@ -183,6 +183,7 @@ TestWidget::change_scaling_mode()
       break;
   }
   redraw();
+  // resize_redraw();
 }
 
 
diff --git a/src/testsuite/test-simulation_widget.cc b/src/testsuite/test-simulation_widget.cc
index 4502d43..6e8f0e6 100644
--- a/src/testsuite/test-simulation_widget.cc
+++ b/src/testsuite/test-simulation_widget.cc
@@ -24,21 +24,20 @@
 #include "config.h"
 #include "gettext.h"
 
+#include <glibmm/main.h>
 #include <glibmm/module.h>
 #include <glibmm/ustring.h>
 #include <glibmm/thread.h>
 #include <gtkmm/box.h>
 #include <gtkmm/button.h>
+#include <gtkmm/checkbutton.h>
 #include <gtkmm/main.h>
+#include <gtkmm/scrolledwindow.h>
 #include <gtkmm/window.h>
 
 #include <cassert>
 #include <iostream>
 
-/*
-#include "backend/concrete_environment.hh"
-#include "backend/concrete_history.hh"
-*/
 #include "backend/cpu_policies_gatekeeper.hh"
 #include "backend/cpu_policy.hh"
 #include "backend/cpu_policy_manager.hh"
@@ -52,20 +51,18 @@
 #include "cairo_elements.hh"
 #include "cairo_widget.hh"
 #include "simulation_widget.hh"
-// #include "backend/concrete_history.hh"
 
 using namespace sgpem;
 using namespace std;
 using Glib::ustring;
 
 
+
 // ------------------------------------------------------
 //
 // PRRPolicy class
 //
 // ------------------------------------------------------
-
-
 /** An hard-coded Priority Round Robin policy
   * it adds a new constructor taking the quantum size (time slice)*/
 
@@ -102,16 +99,6 @@ public:
     ReadyQueue* sl = Scheduler::get_instance().get_ready_queue();
     if(sl && sl->size()>=2)
     {
-      /*
-      cout << " sort_queue time: " << Simulation::get_instance().get_front() << endl;
-      for (int i = 0; i < sl->size(); i++)
-      {
-        cout << "  i: " << i << " name: " << sl->get_item_at(i).get_name()
-             << " pr: " << sl->get_item_at(i).get_current_priority()
-             << " last: " << sl->get_item_at(i).get_last_acquisition()
-             << endl;
-      }
-      */
       for (int i = 0; i < sl->size(); i++)
       {
         for (int j = 0; j < sl->size() - 1; j++)
@@ -125,25 +112,15 @@ public:
         }
 
       }
-      /*
-      cout << "after" << endl;
-      for (int i = 0; i < sl->size(); i++)
-      {
-        cout << "  i: " << i << " name: " << sl->get_item_at(i).get_name()
-             << " pr: " << sl->get_item_at(i).get_current_priority()
-             << " last: " << sl->get_item_at(i).get_last_acquisition()
-             << endl;
-      }
-      cout << endl;
-      */
     }
-
   }
 
+  /*
   int get_id() const
   {
     return 42;
   }
+  */
 
   virtual Glib::ustring get_description() const
   {
@@ -178,18 +155,17 @@ public:
 protected:
 
   PolicyParameters _parameters;
-  int _id;
+  // int _id;
   int _quantum;
 private:
 
   static PRRPolicy* _instance;
-
-
 };
 
 PRRPolicy* PRRPolicy::_instance=0;
 
 
+
 // ------------------------------------------------------
 //
 // DummyPolicyManager class
@@ -246,25 +222,13 @@ protected:
 
 
 
-// insert some resources, processes, threads, requests, subrequests
-void fillHistory(History &hist);
-
-// print entire environment into the passed ostream
-void dumpEnvironment(const Environment& env, ostream &os);
-
-Glib::ustring get_schedulable_state_name(Schedulable::state st);
-
-Glib::ustring get_request_state_name(Request::state st);
-
-Glib::ustring get_simulation_state_name(Simulation::state st);
-
 
+/*
 // ------------------------------------------------------
 //
 // TestWidget class
 //
 // ------------------------------------------------------
-
 namespace sgpem
 {
   class TestWidget : public SimulationObserver, public CairoWidget
@@ -429,12 +393,14 @@ TestWidget::change_scaling_mode()
   }
   redraw();
 }
-
+*/
 
 // ------------------------------------------------------
 //
 // MainWindow class
 //
+// contains and controls the tested widget
+//
 // ------------------------------------------------------
 class MainWindow : public Gtk::Window
 {
@@ -445,18 +411,27 @@ public:
 protected:
   virtual void on_button_start_clicked();
   virtual void on_button_stop_clicked();
+  virtual void on_button_pause_clicked();
+  virtual void on_button_runmode_clicked();
+  virtual bool on_timer_timeout();
 
-  TestWidget  _test_widget;
+  // TestWidget  _test_widget;
   SimulationWidget  _simulation_widget;
   Gtk::Button _start_button;
   Gtk::Button _stop_button;
+  Gtk::Button _pause_button;
+  Gtk::CheckButton _runmode_button;
   Gtk::HBox   _buttons_box;
   Gtk::VBox   _main_box;
+  Gtk::ScrolledWindow _scroller;
+  Simulation::state _sim_state;
 };
 
 
-MainWindow::MainWindow() : _start_button("Start"), _stop_button("Stop")
+MainWindow::MainWindow() : _start_button("Start"), _stop_button("Stop"),
+  _pause_button("Pause"),  _runmode_button("Continue")
 {
+  _sim_state = Simulation::state_stopped;
   // This just sets the title of our new window.
   set_title("Simulation Widget Test");
   add(_main_box);
@@ -464,18 +439,43 @@ MainWindow::MainWindow() : _start_button("Start"), _stop_button("Stop")
   _start_button.show();
   _buttons_box.pack_start(_stop_button);
   _stop_button.show();
+  _buttons_box.pack_start(_pause_button);
+  _pause_button.show();
+  _buttons_box.pack_start(_runmode_button);
+  _runmode_button.set_active(false);
+  _runmode_button.show();
 
   _main_box.pack_start(_buttons_box, Gtk::PACK_SHRINK);
   _buttons_box.show();
   // _main_box.pack_start(_test_widget);
   // _test_widget.show();
-  _main_box.pack_start(_simulation_widget);
+  _scroller.add(_simulation_widget);
+  _scroller.show();
+
+  _main_box.pack_start(_scroller);
   _simulation_widget.show();
   _main_box.show();
   // Simulation::get_instance().attach(_simulation_widget);
-
+/*
   _start_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_start_clicked) );
   _stop_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_stop_clicked) );
+  _pause_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_pause_clicked) );
+  _runmode_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_runmode_clicked) );
+*/
+  // connect after standard signal handler
+  _start_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_start_clicked), true );
+  _stop_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_stop_clicked), true );
+  _pause_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_pause_clicked), true );
+  _runmode_button.signal_clicked().connect( sigc::mem_fun(*this, &MainWindow::on_button_runmode_clicked), true );
+
+  Glib::signal_timeout().connect(sigc::mem_fun(*this, &MainWindow::on_timer_timeout), 1000);
+
+ //is equivalent to:
+ /*
+ const Glib::RefPtr<Glib::TimeoutSource> timeout_source = Glib::TimeoutSource::create(1000);
+ timeout_source->connect(sigc::ptr_fun(&timeout_handler));
+ timeout_source->attach(Glib::MainContext::get_default());
+ */
 }
 
 MainWindow::~MainWindow()
@@ -484,17 +484,89 @@ MainWindow::~MainWindow()
 
 void MainWindow::on_button_start_clicked()
 {
-  Simulation::get_instance().run();
+  if(_sim_state == Simulation::state_stopped
+    || _sim_state == Simulation::state_paused)
+  {
+    if(!_runmode_button.get_active()) 
+    {
+      // one step - drive directly simulation
+      Simulation& simu = Simulation::get_instance();
+      simu.run();
+      _sim_state = simu.get_state();
+      // _simulation_widget.redraw();
+    }
+    else
+    {
+      _sim_state = Simulation::state_running;
+    }
+  }
 }
 void MainWindow::on_button_stop_clicked()
 {
-  Simulation::get_instance().stop();
-  _simulation_widget.redraw();
+  if(_sim_state == Simulation::state_running
+    || _sim_state == Simulation::state_paused)
+  {
+    _sim_state = Simulation::state_stopped;
+    Simulation::get_instance().stop();
+    // _simulation_widget.redraw();
+  }
+}
+void MainWindow::on_button_pause_clicked()
+{
+  if(_sim_state == Simulation::state_running)
+  {
+    _sim_state = Simulation::state_paused;
+  }
+  else if(_sim_state == Simulation::state_paused)
+  {
+    _sim_state = Simulation::state_running;
+  }
+}
+void MainWindow::on_button_runmode_clicked()
+{
+}
+
+bool MainWindow::on_timer_timeout()
+{
+  // std::cout << "Timer sim stat= " << _sim_state << endl;
+  if(_sim_state == Simulation::state_running)
+  {
+    Simulation& simu = Simulation::get_instance();
+    simu.run();
+    // _simulation_widget.redraw();
+    if(simu.get_state()==Simulation::state_stopped)
+      _sim_state = Simulation::state_stopped;
+  }
+  return true;
 }
 
 
 
+// utility functions...
 
+// insert some resources, processes, threads, requests, subrequests
+void fillHistory(History &hist);
+
+// print entire environment into the passed ostream
+void dumpEnvironment(const Environment& env, ostream &os);
+
+// return the Schedulable::state readable string
+Glib::ustring get_schedulable_state_name(Schedulable::state st);
+
+// return the Request::state readable string
+Glib::ustring get_request_state_name(Request::state st);
+
+// return the Simulation::state readable string
+Glib::ustring get_simulation_state_name(Simulation::state st);
+
+
+
+
+// ------------------------------------------------------
+//
+// MainWindow class
+//
+// ------------------------------------------------------
 
 int
 main(int argc, char** argv)
@@ -516,24 +588,19 @@ main(int argc, char** argv)
   info << "gets history \n";
 
   DummyPolicyManager dummy_manager;
-  /*
-  DummyPolicy dummy_policy;
-  PRRPolicy PRR_Policy;
-  */
 
   const std::vector<CPUPolicy*>& policies =  dummy_manager.get_avail_policies();
   CPUPolicy* pol = policies[0];
   info << "policy " << pol->get_name() << endl;
-  // CPUPoliciesGatekeeper::get_instance().register_manager(&dummy_manager);
+  
   fillHistory(hist);
   info << "history filled \n";
 
-  // CPUPoliciesGatekeeper::get_instance().activate_policy(&hist, pol);
   simu.set_policy(pol);
   info << "policy activated \n";
 
   simu.set_mode(false);
-  simu.set_timer(100);
+  simu.set_timer(0);
   info << "simulation set_mode single step\n";
 
   info << "START environment dump \n";
@@ -541,11 +608,10 @@ main(int argc, char** argv)
   info << "END environment dump \n";
   info << "simulation state: " << get_simulation_state_name(simu.get_state()) << endl;
 
-  // Gtk::Window win;
   MainWindow win;
 
   win.set_border_width(10);
-  win.resize (700, 200);
+  win.resize (400, 200);
 
   Gtk::Main::run(win);
   return 0;