Merge lp:~unity-team/nux/nux-timer-backend-fixes into lp:nux

[Jay Taoko]

* Refactoring Nux timer API: Some cleanup and update were required for the animation framework.

* Refactoring Nux timer API: Some cleanup and update were required for the animation framework.

[Jay Taoko (jaytaoko)]

review: Approve

=== modified file 'Nux/AnimatedTextureArea.cpp'
--- Nux/AnimatedTextureArea.cpp	2012-06-26 13:59:18 +0000
+++ Nux/AnimatedTextureArea.cpp	2012-07-12 13:45:35 +0000
@@ -37,7 +37,7 @@
     mouse_drag.connect(sigc::mem_fun(this, &AnimatedTextureArea::RecvMouseDrag));
 
     m_TimerFunctor = new TimerFunctor();
-    m_TimerFunctor->time_expires.connect(sigc::mem_fun(this, &AnimatedTextureArea::TimerNextFrame));
+    m_TimerFunctor->tick.connect(sigc::mem_fun(this, &AnimatedTextureArea::TimerNextFrame));
   }
 
   AnimatedTextureArea::~AnimatedTextureArea()
@@ -106,7 +106,7 @@
       m_TimerHandler = 0;
     }
 
-    m_TimerHandler = GetTimer().AddTimerHandler(41, m_TimerFunctor, 0);
+    m_TimerHandler = GetTimer().AddOneShotTimer(41, m_TimerFunctor, 0);
     QueueDraw();
   }
 
@@ -128,7 +128,7 @@
       ObjectPtr<IOpenGLBaseTexture> Texture2D = Texture->m_Texture; //Texture->m_Texture.CastRef<IOpenGLAnimatedTexture>();
 
       AnimatedTexture->PresentNextFrame();
-      m_TimerHandler = GetTimer().AddTimerHandler(41, m_TimerFunctor, 0);
+      m_TimerHandler = GetTimer().AddOneShotTimer(41, m_TimerFunctor, 0);
     }
 
     QueueDraw();
 
=== modified file 'Nux/ColorPreview.cpp'
--- Nux/ColorPreview.cpp	2011-10-17 20:57:35 +0000
+++ Nux/ColorPreview.cpp	2012-07-12 13:45:35 +0000
@@ -61,7 +61,7 @@
     SetCompositionLayout(m_hlayout);
 
     m_ChangeDetectionTimer = new TimerFunctor();
-    m_ChangeDetectionTimer->time_expires.connect(sigc::mem_fun(this, &ColorPreview::RecvTimer));
+    m_ChangeDetectionTimer->tick.connect(sigc::mem_fun(this, &ColorPreview::RecvTimer));
     m_ChangeTimerHandler = 0;
   }
 
@@ -100,7 +100,7 @@
     m_DialogThreadProxy->SetColor(m_Color);
     m_DialogThreadProxy->Start();
 
-    m_ChangeTimerHandler = GetTimer().AddTimerHandler(33, m_ChangeDetectionTimer, this);
+    m_ChangeTimerHandler = GetTimer().AddOneShotTimer(33, m_ChangeDetectionTimer, this);
   }
 
   void ColorPreview::RecvTimer(void *v)
@@ -114,7 +114,7 @@
 
     if (m_DialogThreadProxy->IsActive())
     {
-      m_ChangeTimerHandler = GetTimer().AddTimerHandler(33, m_ChangeDetectionTimer, this);
+      m_ChangeTimerHandler = GetTimer().AddOneShotTimer(33, m_ChangeDetectionTimer, this);
     }
     else
     {
 
=== modified file 'Nux/EditTextBox.cpp'
--- Nux/EditTextBox.cpp	2011-12-14 02:01:43 +0000
+++ Nux/EditTextBox.cpp	2012-07-12 13:45:35 +0000
@@ -70,10 +70,10 @@
     SetLayout(hlayout);
 
     m_BlinkTimerFunctor = new TimerFunctor();
-    m_BlinkTimerFunctor->time_expires.connect(sigc::mem_fun(this, &EditTextBox::BlinkCursorTimerInterrupt));
+    m_BlinkTimerFunctor->tick.connect(sigc::mem_fun(this, &EditTextBox::BlinkCursorTimerInterrupt));
 
     m_ScrollTimerFunctor = new TimerFunctor();
-    m_ScrollTimerFunctor->time_expires.connect(sigc::mem_fun(this, &EditTextBox::ScrollTimerInterrupt));
+    m_ScrollTimerFunctor->tick.connect(sigc::mem_fun(this, &EditTextBox::ScrollTimerInterrupt));
 
     SetAcceptKeyboardEvent(true);
     EnableDoubleClick(true);
@@ -102,7 +102,7 @@
     if (((X < base.x) && (m_KeyboardHandler.GetCursorPosition() > 0)) ||
          ((X > base.x + base.GetWidth()) && (m_KeyboardHandler.GetCursorPosition() < m_KeyboardHandler.GetLength())))
     {
-      m_ScrollTimerHandler = GetTimer().AddTimerHandler(50, m_ScrollTimerFunctor, this);
+      m_ScrollTimerHandler = GetTimer().AddOneShotTimer(50, m_ScrollTimerFunctor, this);
     }
     else
     {
@@ -120,7 +120,7 @@
   void EditTextBox::BlinkCursorTimerInterrupt(void *v)
   {
     GetTimer().RemoveTimerHandler(m_BlinkTimerHandler);
-    m_BlinkTimerHandler = GetTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);
+    m_BlinkTimerHandler = GetTimer().AddOneShotTimer(500, m_BlinkTimerFunctor, this);
     BlinkCursor = !BlinkCursor;
     QueueDraw();
   }
@@ -135,7 +135,7 @@
 
   void EditTextBox::StartBlinkCursor(bool BlinkState)
   {
-    m_BlinkTimerHandler = GetTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);
+    m_BlinkTimerHandler = GetTimer().AddOneShotTimer(500, m_BlinkTimerFunctor, this);
     BlinkCursor = BlinkState;
     QueueDraw();
   }
@@ -292,7 +292,7 @@
 
     if ((!m_ScrollTimerHandler.IsValid()) && ((X < base.x) || (X > base.x + base.GetWidth())))
     {
-      m_ScrollTimerHandler = GetTimer().AddTimerHandler(25, m_ScrollTimerFunctor, this);
+      m_ScrollTimerHandler = GetTimer().AddOneShotTimer(25, m_ScrollTimerFunctor, this);
     }
     else if ((X >= base.x) && (X < base.x + base.GetWidth()))
     {
@@ -439,7 +439,7 @@
     text_input_mode_  = false;
     
     EnteringKeyboardFocus();
-    m_BlinkTimerHandler = GetTimer().AddTimerHandler(500, m_BlinkTimerFunctor, this);
+    m_BlinkTimerHandler = GetTimer().AddOneShotTimer(500, m_BlinkTimerFunctor, this);
   }
 
   void EditTextBox::RecvEndKeyFocus()
 
=== modified file 'Nux/HScrollBar.cpp'
--- Nux/HScrollBar.cpp	2011-10-17 20:57:35 +0000
+++ Nux/HScrollBar.cpp	2012-07-12 13:45:35 +0000
@@ -90,15 +90,15 @@
     hlayout->AddView(_scroll_right_button, 0, eCenter, eFix);
 
     callback = new TimerFunctor;
-    callback->time_expires.connect(sigc::mem_fun(this, &HScrollBar::HScrollBarHandler));
+    callback->tick.connect(sigc::mem_fun(this, &HScrollBar::HScrollBarHandler));
     left_callback = new TimerFunctor;
-    left_callback->time_expires.connect(sigc::mem_fun(this, &HScrollBar::ScrollLeft));
+    left_callback->tick.connect(sigc::mem_fun(this, &HScrollBar::ScrollLeft));
     right_callback = new TimerFunctor;
-    right_callback->time_expires.connect(sigc::mem_fun(this, &HScrollBar::ScrollRight));
+    right_callback->tick.connect(sigc::mem_fun(this, &HScrollBar::ScrollRight));
     trackleft_callback = new TimerFunctor;
-    trackleft_callback->time_expires.connect(sigc::mem_fun(this, &HScrollBar::TrackLeft));
+    trackleft_callback->tick.connect(sigc::mem_fun(this, &HScrollBar::TrackLeft));
     trackright_callback = new TimerFunctor;
-    trackright_callback->time_expires.connect(sigc::mem_fun(this, &HScrollBar::TrackRight));
+    trackright_callback->tick.connect(sigc::mem_fun(this, &HScrollBar::TrackRight));
 
     SetLayout(hlayout);
     SetAcceptMouseWheelEvent(true);
@@ -130,7 +130,7 @@
       else
       {
         scrollbar->QueueDraw();
-        GetTimer().AddTimerHandler(10, callback, scrollbar);
+        GetTimer().AddOneShotTimer(10, callback, scrollbar);
       }
     }
 
@@ -146,7 +146,7 @@
       else
       {
         scrollbar->QueueDraw();
-        GetTimer().AddTimerHandler(10, callback, scrollbar);
+        GetTimer().AddOneShotTimer(10, callback, scrollbar);
       }
     }
   }
@@ -158,7 +158,7 @@
     if (AtMaximum())
       RecvEndScrollRight(0, 0, 0, 0);
     else
-      m_RightTimerHandler = GetTimer().AddTimerHandler(10, right_callback, this);
+      m_RightTimerHandler = GetTimer().AddOneShotTimer(10, right_callback, this);
 
     QueueDraw();
   }
@@ -170,7 +170,7 @@
     if (AtMaximum())
       RecvEndScrollLeft(0, 0, 0, 0);
     else
-      m_LeftTimerHandler = GetTimer().AddTimerHandler(10, left_callback, this);
+      m_LeftTimerHandler = GetTimer().AddOneShotTimer(10, left_callback, this);
 
     QueueDraw();
   }
@@ -180,7 +180,7 @@
     if (m_TrackMouseCoord.x < _slider->GetBaseX() - _track->GetBaseX())
     {
       OnScrollLeft.emit(container_width_, 1);
-      m_TrackLeftTimerHandler  = GetTimer().AddTimerHandler(10, trackleft_callback, this);
+      m_TrackLeftTimerHandler  = GetTimer().AddOneShotTimer(10, trackleft_callback, this);
       QueueDraw();
     }
   }
@@ -190,7 +190,7 @@
     if (m_TrackMouseCoord.x > _slider->GetBaseX() + _slider->GetBaseWidth() - _track->GetBaseX())
     {
       OnScrollRight.emit(container_width_, 1);
-      m_TrackRightTimerHandler  = GetTimer().AddTimerHandler(10, trackright_callback, this);
+      m_TrackRightTimerHandler  = GetTimer().AddOneShotTimer(10, trackright_callback, this);
       QueueDraw();
     }
   }
@@ -377,14 +377,14 @@
     //sigVScrollBarSliderMouseDown.emit();
     b_MouseDownTimer = true;
     b_MouseUpTimer = false;
-    GetTimer().AddTimerHandler(10, callback, this);
+    GetTimer().AddOneShotTimer(10, callback, this);
   }
 
   void HScrollBar::OnSliderMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
     b_MouseDownTimer = false;
     b_MouseUpTimer = true;
-    GetTimer().AddTimerHandler(10, callback, this);
+    GetTimer().AddOneShotTimer(10, callback, this);
   }
 
   void HScrollBar::OnSliderMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
 
=== modified file 'Nux/MainLoopGLib.cpp'
--- Nux/MainLoopGLib.cpp	2011-12-22 06:23:58 +0000
+++ Nux/MainLoopGLib.cpp	2012-07-12 13:45:35 +0000
@@ -289,7 +289,7 @@
         return 0;
       }
 
-      GSource *timeout_source;
+      GSource* timeout_source;
 
       //create a new time-out source
       timeout_source = g_timeout_source_new(duration);
 
=== modified file 'Nux/NumericValuator.cpp'
--- Nux/NumericValuator.cpp	2011-10-10 01:52:00 +0000
+++ Nux/NumericValuator.cpp	2012-07-12 13:45:35 +0000
@@ -131,7 +131,7 @@
 
     if (m_fValue < m_DoubleValidator.GetMaximum())
     {
-      m_UpTimerHandler = GetTimer().AddTimerHandler(100, m_UpTimerCallback, 0);
+      m_UpTimerHandler = GetTimer().AddOneShotTimer(100, m_UpTimerCallback, 0);
       QueueDraw();
     }
   }
@@ -144,7 +144,7 @@
 
     if (m_fValue > m_DoubleValidator.GetMinimum())
     {
-      m_DownTimerHandler = GetTimer().AddTimerHandler(100, m_DownTimerCallback, 0);
+      m_DownTimerHandler = GetTimer().AddOneShotTimer(100, m_DownTimerCallback, 0);
       QueueDraw();
     }
   }
 
=== modified file 'Nux/ProgramFramework/ProgramTemplate.cpp'
--- Nux/ProgramFramework/ProgramTemplate.cpp	2012-01-27 22:37:13 +0000
+++ Nux/ProgramFramework/ProgramTemplate.cpp	2012-07-12 13:45:35 +0000
@@ -89,8 +89,8 @@
   if (program_life_span_ > 0)
   {
     timeout_signal_ = new nux::TimeOutSignal();
-    timeout_signal_->time_expires.connect(sigc::mem_fun(this, &ProgramTemplate::ProgramExitCall));
-    window_thread_->GetTimerHandler().AddTimerHandler(program_life_span_, timeout_signal_, NULL, NULL);
+    timeout_signal_->tick.connect(sigc::mem_fun(this, &ProgramTemplate::ProgramExitCall));
+    window_thread_->GetTimerHandler().AddOneShotTimer(program_life_span_, timeout_signal_, NULL, NULL);
   }
 
   window_thread_->Run(NULL);
 
=== modified file 'Nux/SpinBox.cpp'
--- Nux/SpinBox.cpp	2011-10-10 01:52:00 +0000
+++ Nux/SpinBox.cpp	2012-07-12 13:45:35 +0000
@@ -187,9 +187,9 @@
     if (m_iValue < m_IntValidator.GetMaximum())
     {
       if (m_UpTimerHandler.IsValid())
-        m_UpTimerHandler = GetTimer().AddTimerHandler(100, m_UpTimerCallback, 0);
+        m_UpTimerHandler = GetTimer().AddOneShotTimer(100, m_UpTimerCallback, 0);
       else
-        m_UpTimerHandler = GetTimer().AddTimerHandler(800, m_UpTimerCallback, 0);
+        m_UpTimerHandler = GetTimer().AddOneShotTimer(800, m_UpTimerCallback, 0);
 
       QueueDraw();
     }
@@ -206,9 +206,9 @@
     if (m_iValue > m_IntValidator.GetMinimum())
     {
       if (m_DownTimerHandler.IsValid())
-        m_DownTimerHandler = GetTimer().AddTimerHandler(100, m_DownTimerCallback, 0);
+        m_DownTimerHandler = GetTimer().AddOneShotTimer(100, m_DownTimerCallback, 0);
       else
-        m_DownTimerHandler = GetTimer().AddTimerHandler(800, m_DownTimerCallback, 0);
+        m_DownTimerHandler = GetTimer().AddOneShotTimer(800, m_DownTimerCallback, 0);
 
       QueueDraw();
     }
 
=== modified file 'Nux/SpinBoxDouble.cpp'
--- Nux/SpinBoxDouble.cpp	2011-10-10 01:52:00 +0000
+++ Nux/SpinBoxDouble.cpp	2012-07-12 13:45:35 +0000
@@ -194,9 +194,9 @@
     if (m_Value < m_DoubleValidator.GetMaximum())
     {
       if (m_UpTimerHandler.IsValid())
-        m_UpTimerHandler = GetTimer().AddTimerHandler(100, m_UpTimerCallback, 0);
+        m_UpTimerHandler = GetTimer().AddOneShotTimer(100, m_UpTimerCallback, 0);
       else
-        m_UpTimerHandler = GetTimer().AddTimerHandler(800, m_UpTimerCallback, 0);
+        m_UpTimerHandler = GetTimer().AddOneShotTimer(800, m_UpTimerCallback, 0);
 
       QueueDraw();
     }
@@ -213,9 +213,9 @@
     if (m_Value > m_DoubleValidator.GetMinimum())
     {
       if (m_DownTimerHandler.IsValid())
-        m_DownTimerHandler = GetTimer().AddTimerHandler(100, m_DownTimerCallback, 0);
+        m_DownTimerHandler = GetTimer().AddOneShotTimer(100, m_DownTimerCallback, 0);
       else
-        m_DownTimerHandler = GetTimer().AddTimerHandler(800, m_DownTimerCallback, 0);
+        m_DownTimerHandler = GetTimer().AddOneShotTimer(800, m_DownTimerCallback, 0);
 
       QueueDraw();
     }
 
=== modified file 'Nux/SpinBox_Logic.cpp'
--- Nux/SpinBox_Logic.cpp	2011-10-17 20:57:35 +0000
+++ Nux/SpinBox_Logic.cpp	2012-07-12 13:45:35 +0000
@@ -64,9 +64,9 @@
     m_EditLine->mouse_leave.connect(sigc::mem_fun(this, &SpinBox_Logic::RecvMouseLeave));
 
     m_UpTimerCallback = new TimerFunctor;
-    m_UpTimerCallback->time_expires.connect(sigc::mem_fun(this, &SpinBox_Logic::TimerSpinUpBtn));
+    m_UpTimerCallback->tick.connect(sigc::mem_fun(this, &SpinBox_Logic::TimerSpinUpBtn));
     m_DownTimerCallback = new TimerFunctor;
-    m_DownTimerCallback->time_expires.connect(sigc::mem_fun(this, &SpinBox_Logic::TimerSpinDownBtn));
+    m_DownTimerCallback->tick.connect(sigc::mem_fun(this, &SpinBox_Logic::TimerSpinDownBtn));
   }
 
   SpinBox_Logic::~SpinBox_Logic()
 
=== modified file 'Nux/TabView.cpp'
--- Nux/TabView.cpp	2011-10-21 22:06:35 +0000
+++ Nux/TabView.cpp	2012-07-12 13:45:35 +0000
@@ -123,9 +123,9 @@
 
 
     tabright_callback = new TimerFunctor;
-    tabright_callback->time_expires.connect(sigc::mem_fun(this, &TabView::RecvTabRightTimerExpired));
+    tabright_callback->tick.connect(sigc::mem_fun(this, &TabView::RecvTabRightTimerExpired));
     tableft_callback = new TimerFunctor;
-    tableft_callback->time_expires.connect(sigc::mem_fun(this, &TabView::RecvTabLeftTimerExpired));
+    tableft_callback->tick.connect(sigc::mem_fun(this, &TabView::RecvTabLeftTimerExpired));
   }
 
   TabView::~TabView()
@@ -518,13 +518,13 @@
   void TabView::RecvTabRightTimerExpired(void *v)
   {
     TranslateTabLayout(-10);
-    m_TabRightTimerHandler = GetTimer().AddTimerHandler(10, tabright_callback, this);
+    m_TabRightTimerHandler = GetTimer().AddOneShotTimer(10, tabright_callback, this);
   }
 
   void TabView::RecvTabLeftTimerExpired(void *v)
   {
     TranslateTabLayout(10);
-    m_TabLeftTimerHandler = GetTimer().AddTimerHandler(10, tableft_callback, this);
+    m_TabLeftTimerHandler = GetTimer().AddOneShotTimer(10, tableft_callback, this);
   }
 
   bool TabView::AcceptKeyNavFocus()
 
=== modified file 'Nux/TimerProc.cpp'
--- Nux/TimerProc.cpp	2011-12-29 18:06:53 +0000
+++ Nux/TimerProc.cpp	2012-07-12 13:45:35 +0000
@@ -55,6 +55,7 @@
 
     //! Delay before the callback expires
     TimeStruct      when;
+    gint64          ms_time; // milliseconds 
     void            *CallbackData;
     TimeOutSignal    *timeout_signal;
 
@@ -67,16 +68,18 @@
     int             Period;                 //!< The periode of the timer interuption(in milliseconds).
     int             Duration;               //!< How long the timer will be running from start to finish(in milliseconds);
     int             ElapsedTime;            //!< Elapsed time during execution(in milliseconds).
-    bool            MarkedForRemoval;
+    bool            marked_for_removal_;
     BaseWindow      *Window;                 //!< BaseWindow from where the timer was created.
     TimerObject     *next;
     TimerObject     *prev;
     unsigned int           glibid;
     unsigned int           uid;
+    TimerHandler::TimerState      state_;
   };
 
   TimerObject::TimerObject()
   {
+    ms_time         = 0;
     Type            = 0;
     CallbackData    = 0;
     timeout_signal   = 0;
@@ -86,12 +89,13 @@
     ElapsedTime     = 0;
     ScheduledIteration       = 0;
     ProgressIterationCount  = 0;
-    MarkedForRemoval = 0;
+    marked_for_removal_ = 0;
     Window          = 0;
     next            = 0;
     prev            = 0;
     glibid          = 0;
     uid             = 0;
+    state_          = TimerHandler::TIMER_STATE_STOPED;
   }
 
   TimerHandle::TimerHandle()
@@ -168,14 +172,13 @@
 ////////////////////////////////////////////////////
   TimerHandler::TimerHandler(WindowThread* window_thread)
   : window_thread_(window_thread)
+  , is_processing_timers_(false)
+  , timer_object_queue_(NULL)
   {
-    m_timer_object_queue = 0;
-    m_IsProceesingTimers = false;
   }
 
   TimerHandler::~TimerHandler()
   {
-
   }
 
   void TimerHandler::StartEarlyTimerObjects()
@@ -184,8 +187,7 @@
     for (it = _early_timer_objects.begin(); it != _early_timer_objects.end(); it++)
     {
       TimerObject *timer_object = *it;
-      TimeRightNow(&timer_object->when);
-      Addmillisecs(&timer_object->when, timer_object->Period);
+      timer_object->ms_time = g_get_monotonic_time() / 1000;
 
 #if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
         timer_object->glibid = GetWindowThread()->AddTimeout(timer_object->Period);
@@ -195,17 +197,17 @@
     _early_timer_objects.clear();
   }
 
-  TimerHandle TimerHandler::AddTimerHandler(unsigned int Period, TimeOutSignal *timeout_signal, void *Data, WindowThread* window_thread)
+  TimerHandle TimerHandler::AddOneShotTimer(unsigned int Period, TimeOutSignal* timeout_signal, void* Data, WindowThread* window_thread)
   {
     TimerObject *timer_object = new TimerObject();
 
-    TimeRightNow(&timer_object->when);
-    Addmillisecs(&timer_object->when, Period);
+    timer_object->ms_time = g_get_monotonic_time() / 1000;
 
     timer_object->CallbackData  = Data;
     timer_object->timeout_signal = timeout_signal;
     timer_object->Period        = Period;
     timer_object->Type          = TIMERTYPE_PERIODIC;
+    timer_object->state_        = TimerHandler::TIMER_STATE_RUNNING;
     if (window_thread)
       timer_object->Window        = window_thread->GetWindowCompositor().GetProcessingTopView();
     else
@@ -225,10 +227,10 @@
         _early_timer_objects.push_back(timer_object);
         // Probably trying to set a timeout before Glib main context and loop have been created.
         // Sometimes later, this timer will be examined when ExecTimerHandler is called.
-        // This happens when trying to set a callback before the mainloop has been initialized.
+        // This happens when trying to set a callback before the main loop has been initialized.
       }
 
-      //nuxDebugMsg("[TimerHandler::AddTimerHandler] Adding Timeout ID: %d", timer_object->glibid);
+      //nuxDebugMsg("[TimerHandler::AddOneShotTimer] Adding Timeout ID: %d", timer_object->glibid);
     }
 #endif
 
@@ -236,17 +238,18 @@
     return handle;
   }
 
-  TimerHandle TimerHandler::AddPeriodicTimerHandler(unsigned int Period, int Duration, TimeOutSignal *timeout_signal, void *Data)
+  TimerHandle TimerHandler::AddDurationTimer(unsigned int Period, int Duration, TimeOutSignal *timeout_signal, void *Data)
   {
-    TimerObject *timer_object = new TimerObject();
-    TimeRightNow(&timer_object->when);
-    Addmillisecs(&timer_object->when, Period);
+    TimerObject* timer_object = new TimerObject();
+
+    timer_object->ms_time = g_get_monotonic_time() / 1000;
     timer_object->CallbackData = Data;
     timer_object->timeout_signal = timeout_signal;
 
-    timer_object->Period = Period;
-    timer_object->Duration = (Duration < 0) ? -1 : Duration;
-    timer_object->Type = TIMERTYPE_DURATION;
+    timer_object->Period    = Period;
+    timer_object->Duration  = (Duration < 0) ? -1 : Duration;
+    timer_object->Type      = TIMERTYPE_DURATION;
+    timer_object->state_    = TimerHandler::TIMER_STATE_RUNNING;
     AddHandle(timer_object);
 
 #if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
@@ -261,7 +264,7 @@
         // This happens when trying to set a callback before the mainloop has been initialized.
       }
 
-      //nuxDebugMsg("[TimerHandler::AddTimerHandler] Adding Timeout ID: %d", timer_object->glibid);
+      //nuxDebugMsg("[TimerHandler::AddOneShotTimer] Adding Timeout ID: %d", timer_object->glibid);
     }
 #endif
 
@@ -269,17 +272,18 @@
     return handle;
   }
 
-  TimerHandle TimerHandler::AddCountIterationTimerHandler(unsigned int Period, int NumberOfIterations, TimeOutSignal *timeout_signal, void *Data)
+  TimerHandle TimerHandler::AddIterativeTimer(unsigned int Period, int NumberOfIterations, TimeOutSignal *timeout_signal, void *Data)
   {
-    TimerObject *timer_object = new TimerObject();
-    TimeRightNow(&timer_object->when);
-    Addmillisecs(&timer_object->when, Period);
+    TimerObject* timer_object = new TimerObject();
+
+    timer_object->ms_time = g_get_monotonic_time() / 1000;
     timer_object->CallbackData = Data;
     timer_object->timeout_signal = timeout_signal;
 
-    timer_object->Period = Period;
+    timer_object->Period              = Period;
     timer_object->ScheduledIteration  = (NumberOfIterations < 0) ? -1 : NumberOfIterations;
-    timer_object->Type = TIMERTYPE_ITERATION;
+    timer_object->Type                = TIMERTYPE_ITERATION;
+    timer_object->state_              = TimerHandler::TIMER_STATE_RUNNING;
     AddHandle(timer_object);
 
 #if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
@@ -294,7 +298,7 @@
         // This happens when trying to set a callback before the mainloop has been initialized.
       }
 
-      //nuxDebugMsg("[TimerHandler::AddTimerHandler] Adding Timeout ID: %d", timer_object->glibid);
+      //nuxDebugMsg("[TimerHandler::AddOneShotTimer] Adding Timeout ID: %d", timer_object->glibid);
     }
 #endif
     TimerHandle handle(timer_object);
@@ -302,7 +306,7 @@
   }
 
 // Sort timers and add them to the queue
-  TimerObject *TimerHandler::AddHandle(TimerObject *timer_object)
+  TimerObject *TimerHandler::AddHandle(TimerObject* timer_object)
   {
     if (timer_object == NULL)
       return NULL;
@@ -313,26 +317,26 @@
 
     // If the queue is empty or the new timer will expire sooner than the first timer in the queue
     // then add the new timer at the start of the queue.
-    if ((m_timer_object_queue == NULL) || TimeIsGreater(m_timer_object_queue->when, timer_object->when))
+    if ((timer_object_queue_ == NULL) || (timer_object_queue_->ms_time > timer_object->ms_time))
     {
       // Add the timer timer_object at the head of the queue
-      timer_object->next = m_timer_object_queue;
+      timer_object->next = timer_object_queue_;
 
-      if (m_timer_object_queue)
-        m_timer_object_queue->prev = timer_object;
+      if (timer_object_queue_)
+        timer_object_queue_->prev = timer_object;
 
       timer_object->prev = 0;
-      m_timer_object_queue = timer_object;
+      timer_object_queue_ = timer_object;
 
       return timer_object;
     }
 
-    TimerObject *tmp = m_timer_object_queue;
+    TimerObject *tmp = timer_object_queue_;
 
     while (tmp->next != NULL)
     {
       // Is the time to wait for tmp->next to expire smaller than for timer_object
-      if (TimeIsGreater(timer_object->when, tmp->next->when))
+      if (timer_object->ms_time > tmp->next->ms_time)
       {
         // keep searching
         tmp = tmp->next;
@@ -356,7 +360,7 @@
   unsigned int TimerHandler::GetNumPendingHandler()
   {
     unsigned int count = 0;
-    TimerObject *head = m_timer_object_queue;
+    TimerObject *head = timer_object_queue_;
 
     while (head)
     {
@@ -367,20 +371,20 @@
     return count;
   }
 
-  bool TimerHandler::RemoveTimerHandler(TimerHandle &timer_object)
+  bool TimerHandler::RemoveTimerHandler(TimerHandle &handle)
   {
-    NUX_RETURN_VALUE_IF_NULL(timer_object.m_d, false);
-    NUX_RETURN_VALUE_IF_NULL(m_timer_object_queue, false);
-
-    TimerObject *tmp;
-
-    tmp = m_timer_object_queue;
+    NUX_RETURN_VALUE_IF_NULL(handle.m_d, false);
+    NUX_RETURN_VALUE_IF_NULL(timer_object_queue_, false);
+
+    TimerObject* tmp;
+
+    tmp = timer_object_queue_;
 
     while (tmp)
     {
-      if ((tmp == timer_object.m_d) && (tmp->uid == timer_object.m_d->uid))
+      if ((tmp == handle.m_d) && (tmp->uid == handle.m_d->uid))
       {
-        if (!m_IsProceesingTimers)
+        if (!is_processing_timers_)
         {
           if (tmp->next)
             tmp->next->prev = tmp->prev;
@@ -388,63 +392,138 @@
           if (tmp->prev)
             tmp->prev->next = tmp->next;
 
-          if ((timer_object.m_d == m_timer_object_queue) && (timer_object.m_d->uid == m_timer_object_queue->uid))
-            m_timer_object_queue = timer_object.m_d->next;
-
-          NUX_SAFE_DELETE(timer_object.m_d);
-        }
-        else
-        {
-          timer_object.m_d->MarkedForRemoval = true;
-        }
-
-        return true;
-      }
-
-      tmp = tmp->next;
-    }
-
-    return false;
-  }
-
-#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
+          if ((handle.m_d == timer_object_queue_) && (handle.m_d->uid == timer_object_queue_->uid))
+            timer_object_queue_ = handle.m_d->next;
+
+          NUX_SAFE_DELETE(handle.m_d);
+        }
+        else
+        {
+          handle.m_d->marked_for_removal_ = true;
+        }
+
+        return true;
+      }
+
+      tmp = tmp->next;
+    }
+
+    return false;
+  }
+
+  bool TimerHandler::PauseTimer(TimerHandle& handle)
+  {
+    NUX_RETURN_VALUE_IF_NULL(handle.m_d, false);
+    NUX_RETURN_VALUE_IF_NULL(timer_object_queue_, false);
+
+    if (handle.m_d->state_ != TimerHandler::TIMER_STATE_RUNNING)
+    {
+      return false;
+    }
+
+    TimerObject* tmp;
+
+    // Pointer to the start of the queue.
+    tmp = timer_object_queue_;
+
+    // Search for the timer handle
+    while (tmp)
+    {
+      if ((tmp == handle.m_d) && (tmp->uid == handle.m_d->uid))
+      {
+        handle.m_d->state_ = TimerHandler::TIMER_STATE_PAUSED;
+
+
+        if (!is_processing_timers_)
+        {
+          gint64 ms_time_now = g_get_monotonic_time() / 1000;
+          
+          if (handle.m_d->Type == TIMERTYPE_PERIODIC)
+          {
+            handle.m_d->ElapsedTime += (ms_time_now - handle.m_d->ms_time);
+            handle.m_d->ProgressDelta = float(handle.m_d->ElapsedTime) / float(handle.m_d->Period);
+
+            if (handle.m_d->Param + handle.m_d->ProgressDelta > 1.0f)
+              handle.m_d->ProgressDelta = 1.0f - handle.m_d->Param;
+
+            handle.m_d->Param = float(handle.m_d->ElapsedTime) / float(handle.m_d->Period);
+          }
+        }
+
+        return true;
+      }
+
+      tmp = tmp->next;
+    }
+    return false;
+  }
+
+  bool TimerHandler::ResumeTimer(TimerHandle& handle)
+  {
+    NUX_RETURN_VALUE_IF_NULL(handle.m_d, false);
+    NUX_RETURN_VALUE_IF_NULL(timer_object_queue_, false);
+
+    if (handle.m_d->state_ != TimerHandler::TIMER_STATE_PAUSED)
+    {
+      return false;
+    }
+
+    TimerObject* tmp;
+
+    // Pointer to the start of the queue.
+    tmp = timer_object_queue_;
+
+    // Search for the timer handle
+    while (tmp)
+    {
+      if ((tmp == handle.m_d) && (tmp->uid == handle.m_d->uid))
+      {
+        handle.m_d->state_ = TimerHandler::TIMER_STATE_RUNNING;
+
+        if (handle.m_d->Type == TIMERTYPE_PERIODIC)
+        {
+          handle.m_d->glibid = GetWindowThread()->AddTimeout(handle.m_d->Period * (1.0f - handle.m_d->Param));
+        }
+        else
+        {
+          handle.m_d->glibid = GetWindowThread()->AddTimeout(handle.m_d->Period);
+        }
+
+        handle.m_d->ms_time = g_get_monotonic_time() / 1000;
+
+        if (handle.m_d->glibid == 0)
+        {
+          _early_timer_objects.push_back(handle.m_d);
+        }
+        return true;
+      }
+
+      tmp = tmp->next;
+    }
+    return false;
+  }
+
   int TimerHandler::ExecTimerHandler(unsigned int timer_id)
-#else
-  int TimerHandler::ExecTimerHandler()
-#endif
   {
-    NUX_RETURN_VALUE_IF_NULL(m_timer_object_queue, 0);
+    NUX_RETURN_VALUE_IF_NULL(timer_object_queue_, 0);
 
     bool repeat = false;
-    TimerObject *timer_object = m_timer_object_queue;
-    TimeStruct now;
-
-    int timer_executed = 0;
-
-    TimeRightNow(&now);
-
-    m_IsProceesingTimers = true;
+    // Pointer to the start of the timer handler queue.
+    TimerObject* timer_object = timer_object_queue_;
+
+    is_processing_timers_ = true;
 
     while (timer_object != NULL)
     {
-#if (defined(NUX_OS_LINUX) || defined(NUX_USE_GLIB_LOOP_ON_WINDOWS)) && (!defined(NUX_DISABLE_GLIB_LOOP))
-
-      if ((/*TimeIsGreater(now, timer_object->when) ||*/ (timer_object->glibid == timer_id)) && (timer_object->MarkedForRemoval == false))
-#else
-      if (TimeIsGreater(now, timer_object->when))
-#endif
+      if ((timer_object->glibid == timer_id) && (timer_object->marked_for_removal_ == false))
       {
-        long elaps = now.sec - timer_object->when.sec;
-        long uelaps = now.usec - timer_object->when.usec;
-
-        if (uelaps < 0)
+        if (timer_object->state_ != TIMER_STATE_RUNNING)
         {
-          uelaps += 1000000;
-          //nuxAssert(elaps > 0);
-          elaps -= 1;
+          return false;
         }
+        // Find the first timer object that 
 
-        timer_object->ElapsedTime += timer_object->Period; //elaps * 1000 + uelaps / 1000; // milliseconds
+        timer_object->ElapsedTime += timer_object->Period;
 
         if (timer_object->Type == TIMERTYPE_PERIODIC)
         {
@@ -484,15 +563,20 @@
           nuxAssertMsg(0, "[TimerHandler::ExecTimerHandler] Unknown timer type.");
         }
 
+
         if (timer_object->Param > 1.0f)
+        {
+          // correction.
           timer_object->Param = 1.0f;
+        }
 
-        timer_object->MarkedForRemoval = false;
+        timer_object->marked_for_removal_ = false;
 
         if (timer_object->timeout_signal != 0)
         {
+          // Execute the signal
           GetWindowThread()->GetWindowCompositor().SetProcessingTopView(timer_object->Window);
-          timer_object->timeout_signal->time_expires.emit(timer_object->CallbackData);
+          timer_object->timeout_signal->tick.emit(timer_object->CallbackData);
           GetWindowThread()->GetWindowCompositor().SetProcessingTopView(NULL);          
           // Reset glibid to 0. glibid is not null, if this element ever happened to be at the head of the queue
           // and we set a timer for it.
@@ -500,56 +584,68 @@
           //timer_object->glibid = 0;
         }
 
-        TimerObject *expired_handler = 0;
+        TimerObject* expired_handler = 0;
 
-        if (timer_object->MarkedForRemoval)
+        if (timer_object->marked_for_removal_)
         {
           // RemoveTimerHandler was called during the callback execution
           expired_handler = timer_object;
         }
         else if (timer_object->Type == TIMERTYPE_PERIODIC)
         {
+          // A one shot timer expires after the first execution.
           expired_handler = timer_object;
         }
         else if ((timer_object->Type == TIMERTYPE_DURATION) && (timer_object->Param >= 1.0f))
         {
+          // A timer delay timer expires after the duration of the timer as expired.
           expired_handler = timer_object;
         }
         else if ((timer_object->Type == TIMERTYPE_ITERATION) && (timer_object->ProgressIterationCount >= timer_object->ScheduledIteration))
         {
+          // An iterative timer expires after the timer as been executedN times.
           expired_handler = timer_object;
         }
 
-        if (expired_handler)
-        {
+        if (!expired_handler && (timer_object->state_ == TIMER_STATE_PAUSED))
+        {
+          // The state has been changed to "paused".
+          return false;
+        }
+
+        if(expired_handler)
+        {
+          GetWindowThread()->GetWindowCompositor().SetProcessingTopView(timer_object->Window);
+          timer_object->timeout_signal->expired.emit(timer_object->CallbackData);
+          GetWindowThread()->GetWindowCompositor().SetProcessingTopView(NULL);          
+
+          timer_object->state_ = TIMER_STATE_STOPED;
+
           if (timer_object->next)
             timer_object->next->prev = timer_object->prev;
 
           if (timer_object->prev)
             timer_object->prev->next = timer_object->next;
 
-          if ((timer_object == m_timer_object_queue) && (timer_object->uid == m_timer_object_queue->uid))
+          if ((timer_object == timer_object_queue_) && (timer_object->uid == timer_object_queue_->uid))
           {
             // timer_object is the first element of the queue.
-            m_timer_object_queue = timer_object->next;
+            timer_object_queue_ = timer_object->next;
 
-            if (m_timer_object_queue)
+            if (timer_object_queue_)
             {
-              m_timer_object_queue->prev = 0;
+              timer_object_queue_->prev = 0;
             }
           }
 
           timer_object = timer_object->next;
-
           delete expired_handler;
         }
         else
         {
           repeat = true;
-          //timer_object = timer_object->next;
         }
 
-        timer_executed++;
         break;
       }
       else
@@ -558,24 +654,14 @@
       }
     }
 
-//     // Look at the head of the queue and set a glib timeout for the first element, if one wasn't set already.
-//     if (m_timer_object_queue && (m_timer_object_queue->glibid == 0))
-//     {
-//         // How long(in milliseconds) between now and the moment the timeout expires?
-//         unsigned int time_difference = TimeDiff(now, m_timer_object_queue->when);
-//
-//         m_timer_object_queue->glibid = GetWindowThread()->AddTimeout(time_difference);
-//         //nuxDebugMsg("[TimerHandler::ExecTimerHandler] Adding Timeout ID: %d", m_timer_object_queue->glibid);
-//     }
-
     // Purge handles that have been marked for removal
-    timer_object = m_timer_object_queue;
+    timer_object = timer_object_queue_;
 
     while (timer_object)
     {
-      if (timer_object->MarkedForRemoval)
+      if (timer_object->marked_for_removal_)
       {
-        TimerObject *expired_handler = timer_object;
+        TimerObject* expired_handler = timer_object;
 
         if (timer_object->next)
           timer_object->next->prev = timer_object->prev;
@@ -585,11 +671,11 @@
         else
         {
           // timer_object is the first element of the queue.
-          m_timer_object_queue = timer_object->next;
+          timer_object_queue_ = timer_object->next;
 
-          if (m_timer_object_queue)
+          if (timer_object_queue_)
           {
-            m_timer_object_queue->prev = 0;
+            timer_object_queue_->prev = 0;
           }
         }
 
@@ -602,14 +688,13 @@
       }
     }
 
-    m_IsProceesingTimers = false;
-    //return timer_executed;
+    is_processing_timers_ = false;
     return repeat;
   }
 
   bool TimerHandler::FindTimerHandle(TimerHandle &timer_object)
   {
-    TimerObject *tmp = m_timer_object_queue;
+    TimerObject *tmp = timer_object_queue_;
 
     while (tmp)
     {
@@ -630,7 +715,7 @@
     TimeStruct now;
     TimeStruct delay;
 
-    if (m_timer_object_queue == NULL)
+    if (timer_object_queue_ == NULL)
     {
       // The return value of this function is only valid if there _are_ timers active.
       return 0;
@@ -639,14 +724,14 @@
     {
       TimeRightNow(&now);
 
-      if (TimeIsGreater(now, m_timer_object_queue->when))
+      if (TimeIsGreater(now, timer_object_queue_->when))
       {
         return 0;
       }
       else
       {
-        delay.sec = m_timer_object_queue->when.sec - now.sec;
-        delay.usec = m_timer_object_queue->when.usec - now.usec;
+        delay.sec = timer_object_queue_->when.sec - now.sec;
+        delay.usec = timer_object_queue_->when.usec - now.usec;
 
         // make sure that usec cannot be less than -1000000 before applying this code
         if (delay.usec < 0)
 
=== modified file 'Nux/TimerProc.h'
--- Nux/TimerProc.h	2011-12-29 18:06:53 +0000
+++ Nux/TimerProc.h	2012-07-12 13:45:35 +0000
@@ -33,7 +33,8 @@
   class TimeOutSignal : public sigc::trackable
   {
   public:
-    sigc::signal<void, void *> time_expires;
+    sigc::signal<void, void *> tick;
+    sigc::signal<void, void *> expired;
   };
   typedef TimeOutSignal TimerFunctor;
 
@@ -77,6 +78,13 @@
       TIMERTYPE_ITERATION,
     };
 
+    typedef enum
+    {
+      TIMER_STATE_STOPED,
+      TIMER_STATE_PAUSED,
+      TIMER_STATE_RUNNING,
+    } TimerState;
+
     TimerHandler(WindowThread *window_thread);
     ~TimerHandler();
 
@@ -85,38 +93,38 @@
       Add a timer callback to the timer manager. When the timer expires, the callback function is executed.
       The returned TimerObject should not be deleted by the caller.
 
-      @param Milliseconds   Period delay before the callback is executed.
-      @param timeout_signal       The callback to execute when the timer expires.
+      @param Milliseconds   period Time before the timer ticks. The timer ticks only once and then it expires.
+      @param timeout_signal The callback to execute when the timer expires.
       @param Data           The callback data
-      @param window_thread  Thread safety mesure. Pass the WindowThread associated to this TimerHandler if it is called from a different thread than the one where the main thread was created.
+      @param window_thread  Thread safety measure. Pass the WindowThread associated to this TimerHandler if it is called from a different thread than the one where the main thread was created.
       @return               A handle to the timer.
     */
-    TimerHandle AddTimerHandler (unsigned int Period, TimeOutSignal *timeout_signal, void *Data, WindowThread* window_thread = NULL);
+    TimerHandle AddOneShotTimer(unsigned int period, TimeOutSignal *timeout_signal, void *Data, WindowThread* window_thread = NULL);
     //! Add a periodic timer callback.
     /*!
       Add a timer callback to the timer manager. Every time the timer expires, the callback function is executed.
       The returned TimerHandle should not be deleted by the caller.
 
-      @param Milliseconds   Period delay before the callback is executed.
+      @param Milliseconds   period Time between the timer ticks. The timer will tick 'NumberOfIteration' times.
       @param Duration       The duration over which the timer is repeated.
-      @param timeout_signal       The callback to execute when the timer expires.
+      @param timeout_signal The callback to execute when the timer expires.
       @param Data           The callback data
       @return               A handle to the timer.
     */
-    TimerHandle AddPeriodicTimerHandler (unsigned int Period, int Duration, TimeOutSignal *timeout_signal, void *Data);
+    TimerHandle AddDurationTimer(unsigned int period, int Duration, TimeOutSignal *timeout_signal, void *Data);
     //! Add a timer callback to be called a finite number of time.
     /*!
       Add a timer callback to the timer manager. The timer callback will be call N times exactly.
       Every time the timer expires, the callback function is executed.
       The returned TimerHandle should not be deleted by the caller.
 
-      @param Milliseconds       Period delay before the callback is executed.
-      @param NumberOfIteration  The number of time to repeat the the wait period.
-      @param timeout_signal           The callback to execute when the timer expires.
+      @param Milliseconds       period Time between the timer ticks. The timer will tick 'NumberOfIteration' times.
+      @param NumberOfIteration  The number of time to repeat the wait period.
+      @param timeout_signal     The callback to execute when the timer expires.
       @param Data               The callback data
       @return                   A handle to the timer.
     */
-    TimerHandle AddCountIterationTimerHandler (unsigned int Period, int NumberOfIteration, TimeOutSignal *timeout_signal, void *Data);
+    TimerHandle AddIterativeTimer(unsigned int period, int NumberOfIteration, TimeOutSignal *timeout_signal, void *Data);
 
     //! Search for a timer handle.
     /*!
@@ -125,14 +133,31 @@
       @param handle             Timer handle to search.
       @return                   Return true if the timer is found; false otherwise.
     */
-    bool FindTimerHandle (TimerHandle &handle);
+    bool FindTimerHandle(TimerHandle& handle);
 
     //! Remove a timer;
     /*!
-      @param handle Timer handle to search.
-      @return Return True if the timer is found.
-    */
-    bool RemoveTimerHandler (TimerHandle &handle);
+        This call stops the timer.
+        @param handle Timer handle to search.
+        @return Return True if the timer is found.
+    */
+    bool RemoveTimerHandler(TimerHandle& handle);
+
+    //! Pause a timer.
+    /*!
+        This call pauses a timer.
+        @param handle Timer handle to look for.
+        @return True if the timer is paused.
+    */
+    bool PauseTimer(TimerHandle& handle);
+
+    //! Resume the execution of a timer.
+    /*!
+        This call resumes the execution of a timer.
+        @param handle Timer handle to look for.
+        @return True if the timer execution has resumed..
+    */
+    bool ResumeTimer(TimerHandle& handle);
 
     //! Return the delay until the next timer expires.
     /*!
@@ -150,14 +175,20 @@
     void StartEarlyTimerObjects();
 
   private:
+    // Prevent copy constructor.
+    TimerHandler(const TimerHandler&);
+
+    // Prevent assignment operator.
+    TimerHandler& operator = (const TimerHandler&);
+
     WindowThread *window_thread_; //!< The WindowThread to which this object belongs.
 
-    bool m_IsProceesingTimers;
-    TimerObject *AddHandle (TimerObject *handle);
+    bool is_processing_timers_;
+    TimerObject* AddHandle(TimerObject *handle);
     unsigned int GetNumPendingHandler();
 
     //! Single linked list of timer delays.
-    TimerObject *m_timer_object_queue;
+    TimerObject* timer_object_queue_;
     std::list<TimerObject*> _early_timer_objects;  //!< timer objects that couldn't be started because the main loop is not runing yet.
   };
 
 
=== modified file 'Nux/VScrollBar.cpp'
--- Nux/VScrollBar.cpp	2012-01-02 20:56:41 +0000
+++ Nux/VScrollBar.cpp	2012-07-12 13:45:35 +0000
@@ -91,15 +91,15 @@
     vlayout->AddView(_scroll_down_button, 0, eCenter, eFix);
 
     callback = new TimerFunctor;
-    callback->time_expires.connect(sigc::mem_fun(this, &VScrollBar::VScrollBarHandler));
+    callback->tick.connect(sigc::mem_fun(this, &VScrollBar::VScrollBarHandler));
     up_callback = new TimerFunctor;
-    up_callback->time_expires.connect(sigc::mem_fun(this, &VScrollBar::ScrollUp));
+    up_callback->tick.connect(sigc::mem_fun(this, &VScrollBar::ScrollUp));
     down_callback = new TimerFunctor;
-    down_callback->time_expires.connect(sigc::mem_fun(this, &VScrollBar::ScrollDown));
+    down_callback->tick.connect(sigc::mem_fun(this, &VScrollBar::ScrollDown));
     trackup_callback = new TimerFunctor;
-    trackup_callback->time_expires.connect(sigc::mem_fun(this, &VScrollBar::TrackUp));
+    trackup_callback->tick.connect(sigc::mem_fun(this, &VScrollBar::TrackUp));
     trackdown_callback = new TimerFunctor;
-    trackdown_callback->time_expires.connect(sigc::mem_fun(this, &VScrollBar::TrackDown));
+    trackdown_callback->tick.connect(sigc::mem_fun(this, &VScrollBar::TrackDown));
 
     SetLayout(vlayout);
     SetAcceptMouseWheelEvent(true);
@@ -132,7 +132,7 @@
       else
       {
         scrollbar->QueueDraw();
-        GetTimer().AddTimerHandler(10, callback, scrollbar);
+        GetTimer().AddOneShotTimer(10, callback, scrollbar);
       }
     }
 
@@ -148,7 +148,7 @@
       else
       {
         scrollbar->QueueDraw();
-        GetTimer().AddTimerHandler(10, callback, scrollbar);
+        GetTimer().AddOneShotTimer(10, callback, scrollbar);
       }
     }
 
@@ -162,7 +162,7 @@
     if (AtMaximum())
       RecvEndScrollDown(0, 0, 0, 0);
     else
-      m_DownTimerHandler = GetTimer().AddTimerHandler(10, down_callback, this);
+      m_DownTimerHandler = GetTimer().AddOneShotTimer(10, down_callback, this);
 
     QueueDraw();
   }
@@ -174,7 +174,7 @@
     if (AtMaximum())
       RecvEndScrollUp(0, 0, 0, 0);
     else
-      m_UpTimerHandler = GetTimer().AddTimerHandler(10, up_callback, this);
+      m_UpTimerHandler = GetTimer().AddOneShotTimer(10, up_callback, this);
 
     QueueDraw();
   }
@@ -184,7 +184,7 @@
     if (m_TrackMouseCoord.y < _slider->GetBaseY() - _track->GetBaseY())
     {
       OnScrollUp.emit(container_height_, 1);
-      m_TrackUpTimerHandler  = GetTimer().AddTimerHandler(10, trackup_callback, this);
+      m_TrackUpTimerHandler  = GetTimer().AddOneShotTimer(10, trackup_callback, this);
       QueueDraw();
     }
   }
@@ -194,7 +194,7 @@
     if (m_TrackMouseCoord.y > _slider->GetBaseY() + _slider->GetBaseHeight() - _track->GetBaseY())
     {
       OnScrollDown.emit(container_height_, 1);
-      m_TrackDownTimerHandler  = GetTimer().AddTimerHandler(10, trackdown_callback, this);
+      m_TrackDownTimerHandler  = GetTimer().AddOneShotTimer(10, trackdown_callback, this);
       QueueDraw();
     }
   }
@@ -396,14 +396,14 @@
     //sigVScrollBarSliderMouseDown.emit();
     b_MouseDownTimer = true;
     b_MouseUpTimer = false;
-    GetTimer().AddTimerHandler(10, callback, this);
+    GetTimer().AddOneShotTimer(10, callback, this);
   }
 
   void VScrollBar::OnSliderMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
   {
     b_MouseDownTimer = false;
     b_MouseUpTimer = true;
-    GetTimer().AddTimerHandler(10, callback, this);
+    GetTimer().AddOneShotTimer(10, callback, this);
   }
 
   void VScrollBar::OnSliderMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
 
=== modified file 'Nux/WindowThread.cpp'
--- Nux/WindowThread.cpp	2012-06-11 14:27:57 +0000
+++ Nux/WindowThread.cpp	2012-07-12 13:45:35 +0000
@@ -105,7 +105,7 @@
     _inside_main_loop = false;
     _inside_timer_loop = false;
     async_wake_up_signal_ = new TimerFunctor();
-    async_wake_up_signal_->time_expires.connect(sigc::mem_fun(this, &WindowThread::AsyncWakeUpCallback));
+    async_wake_up_signal_->tick.connect(sigc::mem_fun(this, &WindowThread::AsyncWakeUpCallback));
   }
 
   WindowThread::~WindowThread()
@@ -152,7 +152,7 @@
       return TimerHandle();
 
     // Use "this->" because if called from a different thread, GetTimer and GetWindowThread are invalid.
-    TimerHandle handle = this->GetTimerHandler().AddTimerHandler(time_ms, timeout_signal, user_data, this);
+    TimerHandle handle = this->GetTimerHandler().AddOneShotTimer(time_ms, timeout_signal, user_data, this);
 
     return handle;
   }
@@ -196,7 +196,7 @@
       if ((_inside_main_loop == false) && (_inside_timer_loop == false) && (_pending_wake_up_timer == false))
       {
         _pending_wake_up_timer = true;
-        async_wake_up_timer_handle_ = this->GetTimerHandler().AddTimerHandler(0, async_wake_up_signal_, this);
+        async_wake_up_timer_handle_ = this->GetTimerHandler().AddOneShotTimer(0, async_wake_up_signal_, this);
       }
     }
   }