Merge lp:~unity-team/nux/nux-fix-708020 into lp:nux/2.0

[Jay Taoko]

* Added automated tests from mouse events
* Fixed double-click event: bug #708020
* Fixed: added missing functions in Layout.cpp/.h

[Tim Penhey (thumper)]

Can I strongly suggest that you reorder the two parameter SetPadding?
CSS for two values has (top and bottom, left and right) as the pair.
It would be nice to have consistency here.

It also appears that the double click time is hard coded. Is there any way to
query the system? Can people configure their double click time?

Re: line 425, why sleep for a second once you have been told that the test is
ready to go?

Also, why sleep for a second before terminating? This is just strange.

What is the purpose of tests/test-view.cpp?

Perhpas a comment at the top of the test file as to its purpose would help a
lot.

It looks like this test is testing multiple things. You are defining shaders
and recording events.

review: Needs Information

[Sam Spilsbury (smspillaz)]

On Thu, Nov 24, 2011 at 11:56 AM, Tim Penhey <email address hidden> wrote:
> Review: Needs Information
>
>
> It looks like this test is testing multiple things.  You are defining shaders
> and recording events.

The shaders in this case look like core profile shaders, eg, what's
required to make the thing render anything at all.

>
> --
> https://code.launchpad.net/~unity-team/nux/nux-fix-708020/+merge/83109
> Your team Unity Team is subscribed to branch lp:nux.
>

--
Sam Spilsbury

[Jay Taoko (jaytaoko)]

> Can I strongly suggest that you reorder the two parameter SetPadding?
> CSS for two values has (top and bottom, left and right) as the pair.
> It would be nice to have consistency here.
>

Will do.

> It also appears that the double click time is hard coded. Is there any way to
> query the system? Can people configure their double click time?

Yes, it is hard-coded for now. I need to figure out where to get it from, or simply let Unity set it.

> Re: line 425, why sleep for a second once you have been told that the test is
> ready to go?
>
> Also, why sleep for a second before terminating? This is just strange.

Due to the asynchronous nature of X, I have to resort to this. I spent some time trying to figure when I can be certain that a window is realized. But that is hard to do.
The tests are very sensible to timings. I do the need to sleep the testing thread to leave some time for the window thread to finish processing events.

> What is the purpose of tests/test-view.cpp?
>
> Perhpas a comment at the top of the test file as to its purpose would help a
> lot.

Will do.

> It looks like this test is testing multiple things. You are defining shaders
> and recording events.

Only using a shader, not testing it. The TestView class will be re-used when I do rendering tests.

[Jay Taoko (jaytaoko)]

>
> It looks like this test is testing multiple things. You are defining shaders
> and recording events.

I realized that the test will not work if the system does not have GLSL shaders support. So I am removing the shader code and using Nux custom drawing code (that supports both GLSL and ARB assembly programs).

[lp:~unity-team/nux/nux-fix-708020]

522. By Jay Taoko on 2011-11-24

* Fixes
* Made the double click time delat a non-const static in GraphicsDisplay
* Removed GLSL shader code from TestView.
* Fixed layout::SetPadding(int, int) to conform to CSS style

[Tim Penhey (thumper)]

> void Layout::SetPadding(int top_bottom_padding, int left_right_padding)
> {
> top_padding_ = top_bottom_padding < 0 ? 0 : top_bottom_padding;
> bottom_padding_ = top_bottom_padding;

Surely that should be:
    bottom_padding_ = top_padding_;

review: Approve

[Jay Taoko (jaytaoko)]

> > void Layout::SetPadding(int top_bottom_padding, int left_right_padding)
> > {
> > top_padding_ = top_bottom_padding < 0 ? 0 : top_bottom_padding;
> > bottom_padding_ = top_bottom_padding;
>
> Surely that should be:
> bottom_padding_ = top_padding_;

Right! will fix!

[lp:~unity-team/nux/nux-fix-708020]

523. By Jay Taoko on 2011-11-25

* Fix in Layout::SetPadding

=== modified file 'Nux/Layout.cpp'
--- Nux/Layout.cpp	2011-10-17 20:57:35 +0000
+++ Nux/Layout.cpp	2011-11-25 05:03:26 +0000
@@ -120,6 +120,24 @@
     bottom_padding_ = bottom < 0 ? 0 : bottom;
   }
 
+  void Layout::SetPadding(int padding)
+  {
+    top_padding_ = padding < 0 ? 0 : padding;
+    bottom_padding_ = top_padding_;
+    right_padding_ = top_padding_;
+    left_padding_ = top_padding_;
+  }
+
+  void Layout::SetPadding(int top_bottom_padding, int left_right_padding)
+  {
+    top_padding_ = top_bottom_padding < 0 ? 0 : top_bottom_padding;
+    bottom_padding_ = top_padding_;
+
+    right_padding_ = left_right_padding < 0 ? 0 : left_right_padding;
+    left_padding_ = right_padding_;
+  }
+
+
   void Layout::SetPadding(int top, int right, int bottom, int left)
   {
     top_padding_ = top < 0 ? 0 : top;
 
=== modified file 'Nux/Layout.h'
--- Nux/Layout.h	2011-10-10 01:52:00 +0000
+++ Nux/Layout.h	2011-11-25 05:03:26 +0000
@@ -117,10 +117,10 @@
         Set the left/right and top/bottom padding of the layout. \n
         Valid only for HLayout, VLayouts, HGridLayouts and VGridLayout.
 
+        @param top_bottom_padding The top/bottom padding value of the layout.
         @param left_right_padding The left/right padding value of the layout.
-        @param top_bottom_padding The top/bottom padding value of the layout.
     */
-    void SetPadding(int left_right_padding, int top_bottom_padding);
+    void SetPadding(int top_bottom_padding, int left_right_padding);
 
     virtual unsigned int GetMaxStretchFactor();
     unsigned int GetMinStretchFactor();
@@ -143,8 +143,27 @@
     //! Deprecated. Use SetTopBottomPadding,
     void SetVerticalExternalMargin(int m);
 
+    //! Set the left/right/top/bottom padding of the layout.
+    /*!
+        Set the left/right and top/bottom padding of the layout. \n
+        Valid only for HLayout, VLayouts, HGridLayouts and VGridLayout.
+
+        @param top The top padding value of the layout.
+        @param right The right padding value of the layout.
+        @param bottom The bottom padding value of the layout.
+        @param left The left padding value of the layout.
+    */
     void SetPadding(int top, int right, int bottom, int left);
 
+    //! Set the left/right/top/bottom padding of the layout.
+    /*!
+        Set the left/right/top/bottom padding of the layout. \n
+        Valid only for HLayout, VLayouts, HGridLayouts and VGridLayout.
+
+        @param padding The top/right/bottom/left padding value of the layout.
+    */
+    void SetPadding(int padding);
+
     int GetLeftPadding() const;
     int GetRightPadding() const;
     int GetTopPadding() const;
 
=== modified file 'NuxGraphics/GraphicsDisplayX11.cpp'
--- NuxGraphics/GraphicsDisplayX11.cpp	2011-11-22 07:13:53 +0000
+++ NuxGraphics/GraphicsDisplayX11.cpp	2011-11-25 05:03:26 +0000
@@ -39,24 +39,26 @@
 {
   EventToNameStruct EventToName[] =
   {
-    {NUX_NO_EVENT,               "NUX_NO_EVENT" },
-    {NUX_MOUSE_PRESSED,          "NUX_MOUSE_PRESSED" },
-    {NUX_MOUSE_RELEASED,         "NUX_MOUSE_RELEASED" },
-    {NUX_KEYDOWN,                "NUX_KEYDOWN" },
-    {NUX_KEYUP,                  "NUX_KEYUP" },
-    {NUX_MOUSE_MOVE,             "NUX_MOUSE_MOVE" },
-    {NUX_SIZE_CONFIGURATION,     "NUX_SIZE_CONFIGURATION" },
-    {NUX_WINDOW_CONFIGURATION,   "NUX_WINDOW_CONFIGURATION" },
-    {NUX_WINDOW_MAP,             "NUX_WINDOW_MAP" },
-    {NUX_WINDOW_UNMAP,           "NUX_WINDOW_UNMAP" },
-    {NUX_WINDOW_ENTER_FOCUS,     "NUX_WINDOW_ENTER_FOCUS" },
-    {NUX_WINDOW_EXIT_FOCUS,      "NUX_WINDOW_EXIT_FOCUS" },
-    {NUX_WINDOW_DIRTY,           "NUX_WINDOW_DIRTY" },
-    {NUX_WINDOW_MOUSELEAVE,      "NUX_WINDOW_MOUSELEAVE" },
-    {NUX_TERMINATE_APP,          "NUX_TERMINATE_APP" },
-    {NUX_TAKE_FOCUS,             "NUX_TAKE_FOCUS" }
+    {NUX_NO_EVENT,               "NO_EVENT" },
+    {NUX_MOUSE_PRESSED,          "MOUSE_PRESSED" },
+    {NUX_MOUSE_RELEASED,         "MOUSE_RELEASED" },
+    {NUX_KEYDOWN,                "KEYDOWN" },
+    {NUX_KEYUP,                  "KEYUP" },
+    {NUX_MOUSE_MOVE,             "MOUSE_MOVE" },
+    {NUX_SIZE_CONFIGURATION,     "SIZE_CONFIGURATION" },
+    {NUX_WINDOW_CONFIGURATION,   "WINDOW_CONFIGURATION" },
+    {NUX_WINDOW_MAP,             "WINDOW_MAP" },
+    {NUX_WINDOW_UNMAP,           "WINDOW_UNMAP" },
+    {NUX_WINDOW_ENTER_FOCUS,     "WINDOW_ENTER_FOCUS" },
+    {NUX_WINDOW_EXIT_FOCUS,      "WINDOW_EXIT_FOCUS" },
+    {NUX_WINDOW_DIRTY,           "WINDOW_DIRTY" },
+    {NUX_WINDOW_MOUSELEAVE,      "WINDOW_MOUSELEAVE" },
+    {NUX_TERMINATE_APP,          "TERMINATE_APP" },
+    {NUX_TAKE_FOCUS,             "TAKE_FOCUS" }
   };
 
+  int GraphicsDisplay::double_click_time_delay = 400; // milliseconds
+
   GraphicsDisplay::GraphicsDisplay()
     : m_X11Display(NULL)
     , m_X11Screen(0)
@@ -78,6 +80,8 @@
     , m_ScreenBitDepth(32)
     , m_GfxInterfaceCreated(false)
     , m_BestMode(-1)
+    , last_click_time_(0)
+    , double_click_counter_(0)
     , m_CreatedFromForeignWindow(false)
     , m_num_device_modes(0)
     , m_pEvent(NULL)
@@ -1002,7 +1006,7 @@
     m_GfxInterfaceCreated = false;
   }
 
-  static int mouse_move(XEvent xevent, Event *m_pEvent)
+  int GraphicsDisplay::MouseMove(XEvent xevent, Event *m_pEvent)
   {
     // Erase mouse event and mouse doubleclick events. Keep the mouse states.
     unsigned int _mouse_state = m_pEvent->e_mouse_state & 0x0F000000;
@@ -1027,12 +1031,22 @@
     return 0;
   }
 
-  static int mouse_press(XEvent xevent, Event *m_pEvent)
+  int GraphicsDisplay::MousePress(XEvent xevent, Event *m_pEvent)
   {
     // Erase mouse event and mouse double-click events. Keep the mouse states.
     ulong _mouse_state = m_pEvent->e_mouse_state & 0x0F000000;
 
-    m_pEvent->e_event = NUX_MOUSE_PRESSED;
+    Time current_time = xevent.xbutton.time;
+    if ((double_click_counter_ == 1) && (current_time - last_click_time_ < double_click_time_delay))
+    {
+      m_pEvent->e_event = NUX_MOUSE_DOUBLECLICK;
+      double_click_counter_ = 0;
+    }
+    else
+    {
+      m_pEvent->e_event = NUX_MOUSE_PRESSED;
+      double_click_counter_ = 1;
+    }
 
     // State of the button before the event
     _mouse_state |= (xevent.xbutton.state & Button1Mask) ? NUX_STATE_BUTTON1_DOWN : 0;
@@ -1082,12 +1096,12 @@
     return 0;
   }
 
-  static int mouse_release(XEvent xevent, Event *m_pEvent)
+  int GraphicsDisplay::MouseRelease(XEvent xevent, Event *m_pEvent)
   {
     // Erase mouse event and mouse double-click events. Keep the mouse states.
     ulong _mouse_state = m_pEvent->e_mouse_state & 0x0F000000;
 
-    m_pEvent->e_event = NUX_MOUSE_RELEASED;
+    m_pEvent->e_event = NUX_MOUSE_RELEASED; 
 
     // State of the button before the event
     _mouse_state |= (xevent.xbutton.state & Button1Mask) ? NUX_STATE_BUTTON1_DOWN : 0;
@@ -1116,6 +1130,7 @@
     }
 
     m_pEvent->e_mouse_state = _mouse_state;
+    last_click_time_ = xevent.xbutton.time;
 
     return 0;
   }
@@ -1526,7 +1541,7 @@
         m_pEvent->e_x_root = 0;
         m_pEvent->e_y_root = 0;
         m_pEvent->e_key_modifiers = GetModifierKeyState(xevent.xkey.state);
-        mouse_press(xevent, m_pEvent);
+        MousePress(xevent, m_pEvent);
         //nuxDebugMsg("[GraphicsDisplay::ProcessXEvents]: ButtonPress event.");
         break;
       }
@@ -1544,7 +1559,7 @@
         m_pEvent->e_x_root = 0;
         m_pEvent->e_y_root = 0;
         m_pEvent->e_key_modifiers = GetModifierKeyState(xevent.xkey.state);
-        mouse_release(xevent, m_pEvent);
+        MouseRelease(xevent, m_pEvent);
         //nuxDebugMsg("[GraphicsDisplay::ProcessXEvents]: ButtonRelease event.");
         break;
       }
@@ -1562,7 +1577,7 @@
         m_pEvent->e_x_root = 0;
         m_pEvent->e_y_root = 0;
         m_pEvent->e_key_modifiers = GetModifierKeyState(xevent.xkey.state);
-        mouse_move(xevent, m_pEvent);
+        MouseMove(xevent, m_pEvent);
         //nuxDebugMsg("[GraphicsDisplay::ProcessXEvents]: MotionNotify event.");
         break;
       }
@@ -1593,7 +1608,7 @@
         m_pEvent->e_x_root = 0;
         m_pEvent->e_y_root = 0;
         m_pEvent->e_key_modifiers = GetModifierKeyState(xevent.xkey.state);
-        mouse_move(xevent, m_pEvent);
+        MouseMove(xevent, m_pEvent);
         //nuxDebugMsg("[GraphicsDisplay::ProcessXEvents]: EnterNotify event.");
         break;
       }
 
=== modified file 'NuxGraphics/GraphicsDisplayX11.h'
--- NuxGraphics/GraphicsDisplayX11.h	2011-11-18 07:31:49 +0000
+++ NuxGraphics/GraphicsDisplayX11.h	2011-11-25 05:03:26 +0000
@@ -135,6 +135,13 @@
     int m_BestMode;
 
     bool m_CreatedFromForeignWindow;
+    Time last_click_time_;
+    /*!
+        Maximum time allowed between the end of the last click (mouse up) and the next mouse down
+        to be considered as a double click event.
+    */
+    static int double_click_time_delay; 
+    int double_click_counter_;
 
   public:
     typedef void(*GrabReleaseCallback) (bool replaced, void *user_data);
@@ -436,7 +443,9 @@
     GLXEWContext m_GLXEWContext;
 #endif
 
-    static int X11ErrorHandler(Display *display, XErrorEvent *error);
+    int MouseMove(XEvent xevent, Event *event);
+    int MousePress(XEvent xevent, Event *event);
+    int MouseRelease(XEvent xevent, Event *event);
 
     friend class DisplayAccessController;
     friend class GraphicsEngine;
 
=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2011-11-22 07:13:53 +0000
+++ tests/Makefile.am	2011-11-25 05:03:26 +0000
@@ -4,7 +4,8 @@
   gtest-nux-core \
   test-graphics-display \
   test-empty-window \
-  button-xtest
+  button-xtest \
+  mouse-events-test
 
 # Please keep alphabetical
 test_nux_SOURCES = \
@@ -108,6 +109,11 @@
 button_xtest_LDADD = $(TestLibs)
 button_xtest_LDFLAGS = -lpthread -lXtst
 
+mouse_events_test_SOURCES = mouse-events-test.cpp test-view.cpp nux_test_framework.cpp nux_automated_test_framework.cpp
+mouse_events_test_CPPFLAGS = $(TestFlags)
+mouse_events_test_LDADD = $(TestLibs)
+mouse_events_test_LDFLAGS = -lpthread -lXtst
+
 #run make test as part of make check
 check-local: test gtest test-apps
 
@@ -117,10 +123,11 @@
 gtest: gtest-nux-core
 	./gtest-nux-core
 
-test-apps: test-graphics-display test-empty-window button-xtest
+test-apps: test-graphics-display test-empty-window button-xtest mouse-events-test
 	./test-graphics-display
 	./test-empty-window
 	./button-xtest
+	./mouse-events-test
 
 check-report:
 	@gtester -k -o=test-nux-results.xml -k ./test-nux \
 
=== modified file 'tests/Readme.txt'
--- tests/Readme.txt	2011-11-21 17:24:00 +0000
+++ tests/Readme.txt	2011-11-25 05:03:26 +0000
@@ -1,5 +1,13 @@
+
+Automated Tests
+---------------
+Since the instruction for the simulated events are comming from a separate thread, the tests are very sensible
+to timing and can generate false negatives. For this reason, in some location of the code, there are sleeping periodes that have been added to allow time for events to be processed and for results to be generated.
+
+All test must be over in 20 seconds or less.
+
 Description of tests:
-
+---------------------
 graphics_display_states:
 	Test the graphics display states after it has been created.
 
@@ -7,4 +15,23 @@
 	Display an empty window and close it after 3 seconds.
 
 button_xtest:
-	Using XTest, love the mouse around the boundaries of a button view and simulate click and drag mouse events. The program close itself after a delay.
 \ No newline at end of file
+	Using XTest, love the mouse around the boundaries of a button view and simulate click and drag mouse events. The program close itself after a delay.
+
+mouse_events_test:
+	Test the following mouse events:
+		- mouse down
+		- mouse up
+		- mouse click
+		- mouse double-click
+		- mouse drag
+		- mouse enter
+		- mouse leave
+		- mouse move
+
+
+mouse_button_tests:
+	Make sure that only mouse button 1, 2 and 3 generate mouse-down and mouse-up events.
+	The artificial button event 4, 5, 6... should not generate mouse-down or mouse-up events.
+
+	
+		
 \ No newline at end of file
 
=== modified file 'tests/button-xtest.cpp'
--- tests/button-xtest.cpp	2011-11-21 17:24:00 +0000
+++ tests/button-xtest.cpp	2011-11-25 05:03:26 +0000
@@ -135,7 +135,7 @@
   int xstatus = XInitThreads();
   nuxAssertMsg(xstatus > 0, "XInitThreads has failed");
 
-  test_button = new TestButton("Button XTest", 300, 300, 15000);
+  test_button = new TestButton("Button XTest", 300, 300, 20000);
   test_button->Startup();
   test_button->UserInterfaceSetup();
 
 
=== added file 'tests/mouse-events-test.cpp'
--- tests/mouse-events-test.cpp	1970-01-01 00:00:00 +0000
+++ tests/mouse-events-test.cpp	2011-11-25 05:03:26 +0000
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2010 Inalogic Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Jay Taoko <[e-mail]>
+ *
+ */
+
+#include "Nux/Nux.h"
+#include "Nux/WindowThread.h"
+#include "Nux/VLayout.h"
+#include "Nux/Layout.h"
+#include <X11/extensions/XTest.h>
+#include <X11/keysym.h> 
+#include "nux_test_framework.h"
+#include "nux_automated_test_framework.h"
+#include "test-view.h"
+
+class EventsTest: public NuxTestFramework
+{
+public:
+  EventsTest(const char *program_name, int window_width, int window_height, int program_life_span);
+  ~EventsTest();
+
+  virtual void UserInterfaceSetup();
+  
+  void ResetEvents();
+  TestView *test_view_;
+};
+
+EventsTest::EventsTest(const char *program_name,
+  int window_width,
+  int window_height,
+  int program_life_span)
+  : NuxTestFramework(program_name, window_width, window_height, program_life_span)
+{
+  ResetEvents();
+  test_view_ = NULL;
+}
+
+EventsTest::~EventsTest()
+{
+  
+}
+
+void EventsTest::ResetEvents()
+{
+  if (test_view_)
+    test_view_->ResetEvents();
+}
+
+void EventsTest::UserInterfaceSetup()
+{
+  nux::VLayout *main_layout = new nux::VLayout(NUX_TRACKER_LOCATION);
+  test_view_ = new TestView(NUX_TRACKER_LOCATION);
+
+  main_layout->AddView(test_view_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FULL);
+  main_layout->SetPadding(10, 10);
+
+  static_cast<nux::WindowThread*>(window_thread_)->SetLayout(main_layout);
+  
+  nux::ColorLayer background(nux::Color(0xFF4D4D4D));
+  static_cast<nux::WindowThread*>(window_thread_)->SetWindowBackgroundPaintLayer(&background);
+}
+
+EventsTest *event_test = NULL;
+
+void TestingThread(nux::NThread *thread, void *user_data)
+{
+  while (event_test->ReadyToGo() == false)
+  {
+    nuxDebugMsg("Waiting to start");
+    nux::SleepForMilliseconds(300);
+  }
+
+  nux::SleepForMilliseconds(1000);
+
+  nux::WindowThread *wnd_thread = static_cast<nux::WindowThread*>(user_data);
+
+  NuxAutomatedTestFramework test(wnd_thread);
+
+  test.Startup();
+
+  // Set the mouse at coordinates (0, 0) (top-left corner) on the display
+  test.PutMouseAt(0, 0);
+
+  test.TestReportMsg(event_test->test_view_, "TestView created");
+
+  event_test->ResetEvents();
+  test.ViewSendMouseMotionToCenter(event_test->test_view_);
+
+  test.TestReportMsg(event_test->test_view_->registered_mouse_move_, "Mouse move event");
+  test.TestReportMsg(event_test->test_view_->registered_mouse_enter_, "Mouse enter event");
+  test.ViewSendMouseClick(0, 1);
+
+  test.TestReportMsg(event_test->test_view_->registered_mouse_down_, "Mouse down event");
+  test.TestReportMsg(event_test->test_view_->registered_mouse_up_, "Mouse up event");
+  test.TestReportMsg(event_test->test_view_->registered_mouse_click_, "Mouse click event");
+
+  test.ViewSendMouseDrag(event_test->test_view_, 1, 0, 0, 50, 50);
+  test.TestReportMsg(event_test->test_view_->registered_mouse_click_, "Mouse drag event");
+
+  test.ViewSendMouseMotionTo(event_test->test_view_, -5, -5);
+  test.TestReportMsg(event_test->test_view_->registered_mouse_leave_, "Mouse leave event");
+
+  event_test->test_view_->EnableDoubleClick(true);
+  test.ViewSendMouseDoubleClick(event_test->test_view_, 1);
+  test.TestReportMsg(event_test->test_view_->registered_mouse_double_click_, "Mouse double click event");
+
+  event_test->ResetEvents();
+  // Deactivate double click and test if the view still receives it.
+  event_test->test_view_->EnableDoubleClick(false);
+  test.ViewSendMouseDoubleClick(event_test->test_view_, 1);
+  test.TestReportMsg(!event_test->test_view_->registered_mouse_double_click_, "Mouse double click de-activated");
+
+  if (test.WhenDoneTerminateProgram())
+  {
+    nux::SleepForMilliseconds(1000);
+    wnd_thread->NuxMainLoopQuit();
+  }
+  nuxDebugMsg("Exit testing thread");
+}
+
+int main(int argc, char **argv)
+{
+  int xstatus = XInitThreads();
+  nuxAssertMsg(xstatus > 0, "XInitThreads has failed");
+
+  event_test = new EventsTest("Events Test", 300, 300, 20000);
+  event_test->Startup();
+  event_test->UserInterfaceSetup();
+
+  nux::SystemThread *test_thread = nux::CreateSystemThread(event_test->GetWindowThread(), &TestingThread, event_test->GetWindowThread());
+
+  test_thread->Start(event_test);
+
+  event_test->Run();
+
+  delete test_thread;
+  delete event_test;
+
+  return 0;
+}
+
 
=== modified file 'tests/nux_automated_test_framework.cpp'
--- tests/nux_automated_test_framework.cpp	2011-11-21 17:24:00 +0000
+++ tests/nux_automated_test_framework.cpp	2011-11-25 05:03:26 +0000
@@ -24,9 +24,10 @@
 #include "nux_automated_test_framework.h"
 
 
-int NuxAutomatedTestFramework::mouse_motion_time_span = 1000;
-int NuxAutomatedTestFramework::mouse_click_time_span = 300;
-int NuxAutomatedTestFramework::safety_border_inside_view = 1;
+int NuxAutomatedTestFramework::mouse_motion_time_span = 1000; // milliseconds
+int NuxAutomatedTestFramework::mouse_click_time_span = 300;   // milliseconds
+int NuxAutomatedTestFramework::minimum_sleep_time = 600;      // milliseconds
+int NuxAutomatedTestFramework::safety_border_inside_view = 1; // pixels
 
 NuxAutomatedTestFramework::NuxAutomatedTestFramework(nux::WindowThread *window_thread)
 {
@@ -85,6 +86,34 @@
   SendFakeMouseEvent(button, true);
   nux::SleepForMilliseconds(NuxAutomatedTestFramework::mouse_click_time_span);
   SendFakeMouseEvent(button, false);
+
+  XSync(display_, False);
+  nux::SleepForMilliseconds(NuxAutomatedTestFramework::minimum_sleep_time);
+}
+
+void NuxAutomatedTestFramework::ViewSendMouseDoubleClick(nux::View *view, int button)
+{
+  nux::Rect r;
+  if (view)
+  {
+    r = view->GetAbsoluteGeometry();
+    r.OffsetPosition(window_x_ + r.width/2, window_y_ + r.height/2);
+  }
+  else
+  {
+    r = window_thread_->GetWindow().GetWindowGeometry();
+    r.OffsetPosition(r.width/2, r.height/2);
+  }
+    
+  // Send the mouse to the center of the view
+  SendFakeMouseMotionEvent(r.x, r.y, NuxAutomatedTestFramework::mouse_motion_time_span);
+
+  XTestFakeButtonEvent(display_, button, true,  CurrentTime);
+  XTestFakeButtonEvent(display_, button, false,  CurrentTime);
+  XTestFakeButtonEvent(display_, button, true,  CurrentTime);
+  XTestFakeButtonEvent(display_, button, false,  CurrentTime);
+  XSync(display_, False);
+  nux::SleepForMilliseconds(NuxAutomatedTestFramework::minimum_sleep_time);
 }
 
 void NuxAutomatedTestFramework::ViewSendMouseDown(nux::View *view, int button)
@@ -112,7 +141,7 @@
     int view_center_x = r.x + r.width/2;
     int view_center_y = r.y + r.height/2;
     SendFakeMouseMotionEvent(view_center_x, view_center_y, NuxAutomatedTestFramework::mouse_motion_time_span);
-    nux::SleepForMilliseconds(600);
+    nux::SleepForMilliseconds(minimum_sleep_time);
   }
   SendFakeMouseEvent(button, true);
 }
@@ -126,7 +155,7 @@
   // int view_center_y = r.y + r.height/2;
 
   // SendFakeMouseMotionEvent(view_center_x, view_center_y, 1000);
-  // nux::SleepForMilliseconds(600);
+  // nux::SleepForMilliseconds(minimum_sleep_time);
   SendFakeMouseEvent(button, false);
 }
 
@@ -139,14 +168,14 @@
 
   // Go to first point
   SendFakeMouseMotionEvent(r0.x, r0.y, NuxAutomatedTestFramework::mouse_motion_time_span);
-  nux::SleepForMilliseconds(600);
+  nux::SleepForMilliseconds(minimum_sleep_time);
   
   // Mouse down
   ViewSendMouseDown(view, button_index);
 
   // Drag to second point
   SendFakeMouseMotionEvent(r1.x, r1.y, NuxAutomatedTestFramework::mouse_motion_time_span);
-  nux::SleepForMilliseconds(600);
+  nux::SleepForMilliseconds(minimum_sleep_time);
 
   // Mouse up
   ViewSendMouseUp(view, button_index);
@@ -338,6 +367,12 @@
   SendFakeKeyEvent(XK_Return, 0);
 }
 
+void NuxAutomatedTestFramework::PutMouseAt(int x, int y)
+{
+  XTestFakeMotionEvent(display_, XScreenNumberOfScreen(DefaultScreenOfDisplay(display_)), x, y, CurrentTime);  
+  XSync(display_, False);
+}
+
 void NuxAutomatedTestFramework::SendFakeKeyEvent(KeySym keysym, KeySym modsym)
 {
   KeyCode keycode = 0;
@@ -410,6 +445,7 @@
 
   XTestFakeMotionEvent(display_, XScreenNumberOfScreen(DefaultScreenOfDisplay(display_)), x, y, CurrentTime);  
   XSync(display_, False);
+  nux::SleepForMilliseconds(NuxAutomatedTestFramework::minimum_sleep_time);
 }
 
 void NuxAutomatedTestFramework::TestReportMsg(bool b, const char* msg)
 
=== modified file 'tests/nux_automated_test_framework.h'
--- tests/nux_automated_test_framework.h	2011-11-21 17:24:00 +0000
+++ tests/nux_automated_test_framework.h	2011-11-25 05:03:26 +0000
@@ -34,7 +34,15 @@
   void Startup();
 
   //! Simulate a mouse click event on a view.
+  /*!
+      Move the mouse to the middle of the view (if it isn't there already) and perform a click event.
+  */  
   void ViewSendMouseClick(nux::View *view, int button);
+  //! Simulate a mouse double click event on a view.
+  /*!
+      Move the mouse to the middle of the view (if it isn't there already) and perform a double click event.
+  */  
+  void ViewSendMouseDoubleClick(nux::View *view, int button);
   //! Simulate a mouse down event on a view.
   void ViewSendMouseDown(nux::View *view, int button);
   //! Simulate a mouse up event on a view.
@@ -73,6 +81,8 @@
   //! Simulate Return key.
   void ViewSendReturn();
 
+  //! Put the mouse pointer anywhere on the display.
+  void PutMouseAt(int x, int y);
 
   //! Simulate a mouse event.
   void SendFakeMouseEvent(int mouse_button_index, bool pressed);
@@ -107,9 +117,10 @@
   int window_height_;
   bool terminate_when_test_over_;
 
-  static int mouse_motion_time_span;  // in seconds
-  static int mouse_click_time_span;  // in seconds
-  static int safety_border_inside_view;  // in pixels
+  static int mouse_motion_time_span;    // in milliseconds
+  static int mouse_click_time_span;     // in milliseconds
+  static int minimum_sleep_time;        // in milliseconds   
+  static int safety_border_inside_view; // in pixels
 };
 
 #endif // NUX_AUTOMATED_TEST_FRAMEWORK_H
 
=== added file 'tests/test-view.cpp'
--- tests/test-view.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-view.cpp	2011-11-25 05:03:26 +0000
@@ -0,0 +1,132 @@
+
+#include "Nux/Nux.h"
+#include "test-view.h"
+
+/*
+  TestView:
+    This class is a Nux view that processes all mouse events that it receives. It is meant for testing simulated
+    mouse events. 
+*/
+
+NUX_IMPLEMENT_OBJECT_TYPE(TestView);
+
+TestView::TestView(NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
+{
+  ResetEvents();
+
+  normal_color_ = nux::color::Green;
+  mouse_down_color_ = nux::color::Red;
+  mouse_drag_color_ = nux::color::Yellow;
+  mouse_in_color_ = nux::color::Blue;
+  current_color_ = normal_color_;
+
+  mouse_in_ = false;
+  mouse_mouse_drag_ = false;
+  mouse_mouse_down_ = false;
+
+  mouse_down.connect(sigc::mem_fun(this, &TestView::OnMouseDown));
+  mouse_up.connect(sigc::mem_fun(this, &TestView::OnMouseUp));
+  mouse_drag.connect(sigc::mem_fun(this, &TestView::OnMouseDrag));
+  mouse_click.connect(sigc::mem_fun(this, &TestView::OnMouseClick));
+  mouse_double_click.connect(sigc::mem_fun(this, &TestView::OnMouseDoubleClick));
+  mouse_move.connect(sigc::mem_fun(this, &TestView::OnMouseMove));
+  mouse_enter.connect(sigc::mem_fun(this, &TestView::OnMouseEnter));
+  mouse_leave.connect(sigc::mem_fun(this, &TestView::OnMouseLeave));
+}
+
+TestView::~TestView()
+{
+
+}
+
+void TestView::ResetEvents()
+{
+  registered_mouse_down_          = false;
+  registered_mouse_up_            = false;
+  registered_mouse_drag_          = false;
+  registered_mouse_enter_         = false;
+  registered_mouse_leave_         = false;
+  registered_mouse_click_         = false;
+  registered_mouse_double_click_  = false;
+  registered_mouse_move_          = false;
+  registered_mouse_enter_         = false;
+  registered_mouse_leave_         = false;
+    
+}
+
+nux::Color TestView::GetColor() const
+{
+  return current_color_;
+}
+
+void TestView::Draw(nux::GraphicsEngine &graphics_engine, bool force_draw)
+{
+  nux::Geometry geo = GetGeometry();
+  graphics_engine.QRP_Color(0, 0, geo.width, geo.height, current_color_);
+}
+
+void TestView::OnMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_down_ = true;
+  current_color_ = mouse_down_color_;
+  mouse_mouse_down_ = true;
+  QueueDraw();
+}
+
+void TestView::OnMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_up_ = true;
+  if (mouse_in_)
+    current_color_ = mouse_in_color_;
+  else
+    current_color_ = normal_color_;
+
+  mouse_mouse_down_ = false;
+  mouse_mouse_drag_ = false;
+  QueueDraw();
+}
+
+void TestView::OnMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_drag_ = true;
+  current_color_ = mouse_drag_color_;
+  mouse_mouse_drag_ = true;
+  QueueDraw();
+}
+
+void TestView::OnMouseClick(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_click_ = true;
+  QueueDraw();
+}
+
+void TestView::OnMouseDoubleClick(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_double_click_ = true;
+  current_color_ = mouse_down_color_;
+  mouse_mouse_down_ = true;
+  QueueDraw();
+}
+
+void TestView::OnMouseMove(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_move_ = true;
+  QueueDraw();
+}
+
+void TestView::OnMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_enter_ = true;
+  mouse_in_ = true;
+  current_color_ = mouse_in_color_;
+  QueueDraw();
+}
+
+void TestView::OnMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags)
+{
+  registered_mouse_leave_ = true;
+  mouse_in_ = false;
+  current_color_ = normal_color_;
+  QueueDraw();
+}
 
=== added file 'tests/test-view.h'
--- tests/test-view.h	1970-01-01 00:00:00 +0000
+++ tests/test-view.h	2011-11-25 05:03:26 +0000
@@ -0,0 +1,51 @@
+
+#ifndef TEST_VIEW_H
+#define TEST_VIEW_H
+
+#include "Nux/TextureArea.h"
+
+class TestView: public nux::View
+{
+  NUX_DECLARE_OBJECT_TYPE(TestView, View);
+public:
+  TestView(NUX_FILE_LINE_PROTO);
+  ~TestView();
+
+  nux::Color GetColor() const;
+
+  void ResetEvents();
+
+  bool registered_mouse_down_;
+  bool registered_mouse_up_;
+  bool registered_mouse_drag_;
+  bool registered_mouse_click_;
+  bool registered_mouse_double_click_;
+  bool registered_mouse_move_;
+  bool registered_mouse_enter_;
+  bool registered_mouse_leave_;
+
+protected:
+  nux::Color current_color_;
+  nux::Color normal_color_;
+  nux::Color mouse_down_color_;
+  nux::Color mouse_drag_color_;
+  nux::Color mouse_in_color_;
+  
+  bool mouse_in_;
+  bool mouse_mouse_drag_;
+  bool mouse_mouse_down_;
+
+  void OnMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseClick(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseDoubleClick(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseMove(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseEnter(int x, int y, unsigned long button_flags, unsigned long key_flags);
+  void OnMouseLeave(int x, int y, unsigned long button_flags, unsigned long key_flags);
+
+  void Draw(nux::GraphicsEngine &graphics_engine, bool force_draw);
+};
+
+#endif // TEST_VIEW_H
+