Final refactoring and implementation of delayed window deletion logic. Works worse now, but the changes are important and need to be checked in now

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4747 42af7a65-404d-4744-a932-0658087f49c3

7 files changed, 327 insertions, 86 deletions

diff --git a/NxWidgets/nxwm/src/capplicationwindow.cxx b/NxWidgets/nxwm/src/capplicationwindow.cxx
index 15d4a4a9d..c0bc9ed62 100644
--- a/NxWidgets/nxwm/src/capplicationwindow.cxx
+++ b/NxWidgets/nxwm/src/capplicationwindow.cxx
@@ -47,7 +47,6 @@
 
 #include "nxwmconfig.hxx"
 #include "nxwmglyphs.hxx"
-#include "cwindowcontrol.hxx"
 #include "capplicationwindow.hxx"
 
 /********************************************************************************************
@@ -153,9 +152,9 @@ CApplicationWindow::~CApplicationWindow(void)
 
 bool CApplicationWindow::open(void)
 {
-  // Create one of our special window controls for the tool bar
+  // Create a widget control for the tool bar
 
-  CWindowControl *control = new CWindowControl();
+  NXWidgets::CWidgetControl *control = new NXWidgets::CWidgetControl();
   if (!control)
     {
       return false;
@@ -414,15 +413,31 @@ NXWidgets::INxWindow *CApplicationWindow::getWindow(void) const
 }
 
 /**
- * Recover the contained window control
+ * Recover the contained widget control
  *
- * @return.  The window control used by this application
+ * @return.  The widget control used by this application
  */
 
-CWindowControl *CApplicationWindow::getWindowControl(void) const
+NXWidgets::CWidgetControl *CApplicationWindow::getWidgetControl(void) const
 {
+  return m_window->getWidgetControl();
+}
+
+/**
+ * Block further activity on this window in preparation for window
+ * shutdown.
+ */
+
+void CApplicationWindow::block(void)
+{
+  // Get the widget control from the NXWidgets::CNxWindow instance
+
   NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
-  return static_cast<CWindowControl*>(control);
+
+  // And then block further reporting activity on the underlying
+  // NX framed window
+
+  nxtk_block(control->getWindowHandle());
 }
 
 /**
@@ -459,12 +474,14 @@ void CApplicationWindow::registerCallbacks(IApplicationCallback *callback)
 }
 
 /**
- * Simulate a mouse click on the minimize icon.  This method is only
- * used during automated testing of NxWM.
+ * Simulate a mouse click or release on the minimize icon.  This method
+ * is only available for automated testing of NxWM.
+ *
+ * @param click.  True to click; false to release;
  */
 
 #if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
-void CApplicationWindow::clickMinimizeIcon(int index)
+void CApplicationWindow::clickMinimizePosition(bool click)
 {
   // Get the size and position of the widget
 
@@ -474,20 +491,30 @@ void CApplicationWindow::clickMinimizeIcon(int index)
   struct nxgl_point_s imagePos;
   m_minimizeImage->getPos(imagePos);
 
-  // And click the image at its center
+  // And click or release the image at its center
 
-  m_minimizeImage->click(imagePos.x + (imageSize.w >> 1),
-                         imagePos.y + (imageSize.h >> 1));
+  if (click)
+    {
+      m_minimizeImage->click(imagePos.x + (imageSize.w >> 1),
+                             imagePos.y + (imageSize.h >> 1));
+    }
+  else
+    {
+      m_minimizeImage->release(imagePos.x + (imageSize.w >> 1),
+                               imagePos.y + (imageSize.h >> 1));
+    }
 }
 #endif
 
 /**
- * Simulate a mouse click on the stop applicaiton icon.  This method is only
- * used during automated testing of NxWM.
+ * Simulate a mouse click or release on the stop icon.  This method
+ * is only available for automated testing of NxWM.
+ *
+ * @param click.  True to click; false to release;
  */
 
 #if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
-void CApplicationWindow::clickStopIcon(int index)
+void CApplicationWindow::clickStopIcon(bool click)
 {
   // The stop icon will not be available for "persistent" applications
 
@@ -501,10 +528,18 @@ void CApplicationWindow::clickStopIcon(int index)
       struct nxgl_point_s imagePos;
       m_stopImage->getPos(imagePos);
 
-      // And click the image at its center
+      // And click or release the image at its center
 
-      m_stopImage->click(imagePos.x + (imageSize.w >> 1),
-                         imagePos.y + (imageSize.h >> 1));
+      if (click)
+        {
+          m_stopImage->click(imagePos.x + (imageSize.w >> 1),
+                             imagePos.y + (imageSize.h >> 1));
+        }
+      else
+        {
+          m_stopImage->release(imagePos.x + (imageSize.w >> 1),
+                               imagePos.y + (imageSize.h >> 1));
+        }
     }
 }
 #endif
diff --git a/NxWidgets/nxwm/src/ccalibration.cxx b/NxWidgets/nxwm/src/ccalibration.cxx
index 248aca838..d93f56a47 100644
--- a/NxWidgets/nxwm/src/ccalibration.cxx
+++ b/NxWidgets/nxwm/src/ccalibration.cxx
@@ -99,6 +99,11 @@ CCalibration::CCalibration(CTaskbar *taskbar, CFullScreenWindow *window,
   m_calthread     = CALTHREAD_NOTRUNNING;
   m_calphase      = CALPHASE_NOT_STARTED;
   m_touched       = false;
+
+  // Add our messenger as the window callback
+
+  NXWidgets::CWidgetControl *control =  window->getWidgetControl();
+  control->addWindowEventHandler(&m_messenger);
 }
 
 /**
@@ -112,6 +117,11 @@ CCalibration::~CCalibration(void)
 
   stop();
 
+  // Remove ourself from the window callback
+
+  NXWidgets::CWidgetControl *control =  m_window->getWidgetControl();
+  control->removeWindowEventHandler(&m_messenger);
+
   // Although we did not create the window, the rule is that I have to dispose
   // of it
 
@@ -200,6 +210,26 @@ void CCalibration::stop(void)
 }
 
 /**
+ * Destroy the application and free all of its resources.  This method
+ * will initiate blocking of messages from the NX server.  The server
+ * will flush the window message queue and reply with the blocked
+ * message.  When the block message is received by CWindowMessenger,
+ * it will send the destroy message to the start window task which
+ * will, finally, safely delete the application.
+ */
+
+void CCalibration::destroy(void)
+{
+  // Block any further window messages
+
+  m_window->block();
+
+  // Make sure that the application is stopped
+
+  stop();
+}
+
+/**
  * The application window is hidden (either it is minimized or it is
  * maximized, but it is not at the top of the hierarchy)
  */
diff --git a/NxWidgets/nxwm/src/cfullscreenwindow.cxx b/NxWidgets/nxwm/src/cfullscreenwindow.cxx
index 40647d8e9..0c34166c0 100644
--- a/NxWidgets/nxwm/src/cfullscreenwindow.cxx
+++ b/NxWidgets/nxwm/src/cfullscreenwindow.cxx
@@ -128,15 +128,31 @@ NXWidgets::INxWindow *CFullScreenWindow::getWindow(void) const
 }
 
 /**
- * Recover the contained window control
+ * Recover the contained widget control
  *
- * @return.  The window control used by this application
+ * @return.  The widget control used by this application
  */
 
-CWindowControl *CFullScreenWindow::getWindowControl(void) const
+NXWidgets::CWidgetControl *CFullScreenWindow::getWidgetControl(void) const
 {
+  return m_window->getWidgetControl();
+}
+
+/**
+ * Block further activity on this window in preparation for window
+ * shutdown.
+ */
+
+void CFullScreenWindow::block(void)
+{
+  // Get the widget control from the NXWidgets::CNxWindow instance
+
   NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
-  return static_cast<CWindowControl*>(control);
+
+  // And then block further reporting activity on the underlying
+  // NX raw window
+
+  nx_block(control->getWindowHandle());
 }
 
 /**
@@ -171,23 +187,27 @@ void CFullScreenWindow::registerCallbacks(IApplicationCallback *callback)
 }
 
 /**
- * Simulate a mouse click on the minimize icon.  This method is only
- * used during automated testing of NxWM.
+ * Simulate a mouse click or release on the minimize icon.  This method
+ * is only available for automated testing of NxWM.
+ *
+ * @param click.  True to click; false to release;
  */
 
 #if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
-void CFullScreenWindow::clickMinimizeIcon(int index)
+void CFullScreenWindow::clickMinimizePosition(bool click)
 {
 }
 #endif
 
 /**
- * Simulate a mouse click on the stop applicaiton icon.  This method is only
- * used during automated testing of NxWM.
+ * Simulate a mouse click or release on the stop icon.  This method
+ * is only available for automated testing of NxWM.
+ *
+ * @param click.  True to click; false to release;
  */
 
 #if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
-void CFullScreenWindow::clickStopIcon(int index)
+void CFullScreenWindow::clickStopIcon(bool click)
 {
 }
 #endif
diff --git a/NxWidgets/nxwm/src/cnxconsole.cxx b/NxWidgets/nxwm/src/cnxconsole.cxx
index 577bf661e..64321ddfb 100644
--- a/NxWidgets/nxwm/src/cnxconsole.cxx
+++ b/NxWidgets/nxwm/src/cnxconsole.cxx
@@ -129,9 +129,14 @@ CNxConsole::CNxConsole(CTaskbar *taskbar, CApplicationWindow *window)
   NXWidgets::CNxString myName = getName();
   window->setWindowLabel(myName);
 
-  // Add our callbacks to the application window
+  // Add our callbacks with the application window
 
   window->registerCallbacks(static_cast<IApplicationCallback *>(this));
+
+  // Add our messenger as the window callback
+
+  NXWidgets::CWidgetControl *control =  window->getWidgetControl();
+  control->addWindowEventHandler(&m_messenger);
 }
 
 /**
@@ -147,13 +152,15 @@ CNxConsole::~CNxConsole(void)
 
   stop();
 
+  // Remove ourself from the window callback
+
+  NXWidgets::CWidgetControl *control =  m_window->getWidgetControl();
+  control->removeWindowEventHandler(&m_messenger);
+
   // Although we didn't create it, we are responsible for deleting the
   // application window
 
-  if (m_window)
-    {
-      delete m_window;
-    }
+  delete m_window;
 }
 
 /**
@@ -322,6 +329,26 @@ void CNxConsole::stop(void)
 }
 
 /**
+ * Destroy the application and free all of its resources.  This method
+ * will initiate blocking of messages from the NX server.  The server
+ * will flush the window message queue and reply with the blocked
+ * message.  When the block message is received by CWindowMessenger,
+ * it will send the destroy message to the start window task which
+ * will, finally, safely delete the application.
+ */
+
+void CNxConsole::destroy(void)
+{
+  // Block any further window messages
+
+  m_window->block();
+
+  // Make sure that the application is stopped
+
+  stop();
+}
+
+/**
  * The application window is hidden (either it is minimized or it is
  * maximized, but not at the top of the hierarchy
  */
diff --git a/NxWidgets/nxwm/src/cstartwindow.cxx b/NxWidgets/nxwm/src/cstartwindow.cxx
index 2b7ecbe66..3dfab5097 100644
--- a/NxWidgets/nxwm/src/cstartwindow.cxx
+++ b/NxWidgets/nxwm/src/cstartwindow.cxx
@@ -99,6 +99,11 @@ CStartWindow::CStartWindow(CTaskbar *taskbar, CApplicationWindow *window)
   // Add our callbacks to the application window
 
   window->registerCallbacks(static_cast<IApplicationCallback *>(this));
+
+  // Add our messenger as the window callback
+
+  NXWidgets::CWidgetControl *control =  window->getWidgetControl();
+  control->addWindowEventHandler(&m_messenger);
 }
 
 /**
@@ -112,13 +117,15 @@ CStartWindow::~CStartWindow(void)
 
   stop();
 
+  // Remove ourself from the window callback
+
+  NXWidgets::CWidgetControl *control =  m_window->getWidgetControl();
+  control->removeWindowEventHandler(&m_messenger);
+
   // Although we didn't create it, we are responsible for deleting the
   // application window
 
-  if (m_window)
-    {
-      delete m_window;
-    }
+  delete m_window;
 
   // Then stop and delete all applications
 
@@ -211,6 +218,28 @@ void CStartWindow::stop(void)
       task_delete(pid);
     }
 }
+/**
+ * Destroy the application and free all of its resources.  This method
+ * will initiate blocking of messages from the NX server.  The server
+ * will flush the window message queue and reply with the blocked
+ * message.  When the block message is received by CWindowMessenger,
+ * it will send the destroy message to the start window task which
+ * will, finally, safely delete the application.
+ */
+
+void CStartWindow::destroy(void)
+{
+  // What are we doing?  This should never happen because the start
+  // window task is persistent!
+
+  // Block any further window messages
+
+  m_window->block();
+
+  // Make sure that the application is stopped
+
+  stop();
+}
 
 /**
  * The application window is hidden (either it is minimized or it is
@@ -405,6 +434,47 @@ bool CStartWindow::addApplication(IApplicationFactory *app)
 }
 
 /**
+ * Simulate a mouse click or release on the icon at index.  This method
+ * is only available during automated testing of NxWM.
+ *
+ * @param index.  Selects the icon in the start window
+ * @param click.  True to click and false to release
+ */
+
+#if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
+void CStartWindow::clickIcon(int index, bool click)
+{
+  if (index < m_slots.size())
+   {
+      // Get the image widget at this index
+
+      NXWidgets::CImage *image = m_slots.at(index).image;
+
+      // Get the size and position of the widget
+
+      struct nxgl_size_s imageSize;
+      image->getSize(imageSize);
+
+      struct nxgl_point_s imagePos;
+      image->getPos(imagePos);
+
+      // And click or release the image at its center
+
+      if (click)
+        {
+          image->click(imagePos.x + (imageSize.w >> 1),
+                       imagePos.y + (imageSize.h >> 1));
+        }
+      else
+        {
+          image->release(imagePos.x + (imageSize.w >> 1),
+                         imagePos.y + (imageSize.h >> 1));
+        }
+    }
+}
+#endif
+
+/**
  * Called when the window minimize button is pressed.
  */
 
@@ -523,11 +593,11 @@ void CStartWindow::handleActionEvent(const NXWidgets::CWidgetEventArgs &e)
                 }
               else
                 {
-                  // If we cannot start the app.  Destroy the
-                  // instance we created and see what happens next.
+                  // If we cannot start the app.  Destroy the instance we
+                  // created and see what happens next.  Could be interesting.
 
-                  CWindowControl *control = app->getWindowControl();
-                  control->destroy(app);
+                  app->stop();
+                  app->destroy();
                 }
             }
         }
@@ -548,8 +618,8 @@ void CStartWindow::handleActionEvent(const NXWidgets::CWidgetEventArgs &e)
  * 4. NXWidgets::CWidgetControl records the new state data and raises a
  *    window event.
  * 5. NXWidgets::CWindowEventHandlerList will give the event to
- *    NxWM::CWindowControl.
- * 6. NxWM::CWindowControl will send the a message on a well-known message
+ *    NxWM::CWindowMessenger.
+ * 6. NxWM::CWindowMessenger will send the a message on a well-known message
  *    queue.
  * 7. This CStartWindow::startWindow task will receive and process that
  *    message.
diff --git a/NxWidgets/nxwm/src/ctaskbar.cxx b/NxWidgets/nxwm/src/ctaskbar.cxx
index ab686f81c..b4df0bb86 100644
--- a/NxWidgets/nxwm/src/ctaskbar.cxx
+++ b/NxWidgets/nxwm/src/ctaskbar.cxx
@@ -47,7 +47,6 @@
 #include "cwidgetcontrol.hxx"
 #include "cnxtkwindow.hxx"
 
-#include "cwindowcontrol.hxx"
 #include "ctaskbar.hxx"
 
 /********************************************************************************************
@@ -68,11 +67,11 @@ using namespace NxWM;
 
 CTaskbar::CTaskbar(void)
 {
-  m_taskbar       = (NXWidgets::CNxWindow *)0;
-  m_background    = (NXWidgets::CNxWindow *)0;
-  m_backImage     = (NXWidgets::CImage    *)0;
-  m_topApp        = (IApplication         *)0;
-  m_started       = false;
+  m_taskbar     = (NXWidgets::CNxWindow *)0;
+  m_background  = (NXWidgets::CNxWindow *)0;
+  m_backImage   = (NXWidgets::CImage    *)0;
+  m_topApp      = (IApplication         *)0;
+  m_started     = false;
 }
 
 /**
@@ -81,6 +80,9 @@ CTaskbar::CTaskbar(void)
 
 CTaskbar::~CTaskbar(void)
 {
+  // The disconnect,putting the instance back in the state that it
+  // was before it was constructed.
+
   disconnect();
 }
 
@@ -107,7 +109,8 @@ bool CTaskbar::connect(void)
 }
 
 /**
- * Disconnect from the server
+ * Disconnect from the server.  This method restores the taskbar to the
+ * same state that it was in when it was constructed.
  */
 
 void CTaskbar::disconnect(void)
@@ -141,6 +144,7 @@ void CTaskbar::disconnect(void)
       // Then delete the task bar window
 
       delete m_taskbar;
+      m_taskbar = (NXWidgets::CNxWindow *)0;
     }
 
   if (m_background)
@@ -157,8 +161,22 @@ void CTaskbar::disconnect(void)
       // Then delete the background
 
       delete m_background;
+      m_background = (NXWidgets::CNxWindow *)0;
+    }
+
+  // Delete the background image
+
+  if (m_backImage)
+    {
+      delete m_backImage;
+      m_backImage = (NXWidgets::CImage *)0;
     }
 
+  // Reset other variables
+
+  m_topApp  = (IApplication *)0;
+  m_started = false;
+
   // And disconnect from the server
 
   CNxServer::disconnect();
@@ -279,7 +297,9 @@ bool CTaskbar::startWindowManager(void)
               continue;
             }
 
-          // Hide all appliations except for the top application
+          // Hide all applications except for the top application.  NOTE:
+          // topIndex may still be -1, meaning that there is no application
+          // and that all applications should be hidden.
 
           if (i != topIndex)
             {
@@ -303,6 +323,17 @@ bool CTaskbar::startWindowManager(void)
           i++;
         }
 
+      // If there is no top appliation (i.e., no applications or all applications
+      // are minimized), then draw the background image
+
+      if (!m_topApp)
+        {
+          if (!redrawBackgroundWindow())
+            {
+              return false;
+            }
+        }
+
       // Draw the taskbar.  It will be draw at a higher level than the application.
 
       return redrawTaskbarWindow();
@@ -418,7 +449,7 @@ bool CTaskbar::startApplication(IApplication *app, bool minimized)
 {
   // Get the widget control associated with the task bar window
 
-  NXWidgets::CWidgetControl *control =  m_taskbar->getWidgetControl();
+  NXWidgets::CWidgetControl *control = m_taskbar->getWidgetControl();
 
   // Get the bitmap icon that goes with this application
 
@@ -633,10 +664,10 @@ bool CTaskbar::stopApplication(IApplication *app)
         }
     }
 
-  // destroy the application
+  // Destroy the application (actually, this just sets up the application for
+  // later destruction.
 
-  CWindowControl *control = app->getWindowControl();
-  control->destroy(app);
+  app->destroy();
 
   // Re-draw the new top, non-minimized application
 
@@ -674,6 +705,47 @@ void CTaskbar::getDisplaySize(FAR struct nxgl_size_s &size)
 }
 
 /**
+ * Simulate a mouse click or release on the icon at index.  This method
+ * is only available during automated testing of NxWM.
+ *
+ * @param index.  Selects the icon in the start window
+ * @param click.  True to click and false to release
+ */
+
+#if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
+void CTaskbar::clickIcon(int index, bool click)
+{
+  if (index < m_slots.size())
+    {
+      // Get the image widget at this index
+
+      NXWidgets::CImage *image = m_slots.at(index).image;
+
+      // Get the size and position of the widget
+
+      struct nxgl_size_s imageSize;
+      image->getSize(imageSize);
+
+      struct nxgl_point_s imagePos;
+      image->getPos(imagePos);
+
+      // And click or release the image at its center
+
+      if (click)
+        {
+          image->click(imagePos.x + (imageSize.w >> 1),
+                       imagePos.y + (imageSize.h >> 1));
+        }
+      else
+        {
+          image->release(imagePos.x + (imageSize.w >> 1),
+                         imagePos.y + (imageSize.h >> 1));
+        }
+    }
+}
+#endif
+
+/**
  * Create a raw window. 
  *
  * 1) Create a dumb CWigetControl instance
@@ -690,7 +762,7 @@ NXWidgets::CNxWindow *CTaskbar::openRawWindow(void)
 {
   // Initialize the widget control using the default style
 
-  CWindowControl *control = new CWindowControl((NXWidgets::CWidgetStyle *)NULL);
+  NXWidgets::CWidgetControl *control = new NXWidgets::CWidgetControl((NXWidgets::CWidgetStyle *)NULL);
 
   // Get an (uninitialized) instance of the background window as a class
   // that derives from INxWindow.
@@ -727,7 +799,7 @@ NXWidgets::CNxTkWindow *CTaskbar::openFramedWindow(void)
 {
   // Initialize the widget control using the default style
 
-  CWindowControl *control = new CWindowControl((NXWidgets::CWidgetStyle *)NULL);
+  NXWidgets::CWidgetControl *control = new NXWidgets::CWidgetControl((NXWidgets::CWidgetStyle *)NULL);
 
   // Get an (uninitialized) instance of the framed window as a class
   // that derives from INxWindow.
diff --git a/NxWidgets/nxwm/src/cwindowcontrol.cxx b/NxWidgets/nxwm/src/cwindowmessenger.cxx
index 6c2144bad..4e458566d 100644
--- a/NxWidgets/nxwm/src/cwindowcontrol.cxx
+++ b/NxWidgets/nxwm/src/cwindowmessenger.cxx
@@ -1,5 +1,5 @@
 /********************************************************************************************
- * NxWidgets/nxwm/src/cwindowcontrol.cxx
+ * NxWidgets/nxwm/src/cwindowmessenger.cxx
  *
  *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
@@ -46,28 +46,23 @@
 
 #include "nxwmconfig.hxx"
 #include "cstartwindow.hxx"
-#include "cwindowcontrol.hxx"
+#include "cwindowmessenger.hxx"
 
 /********************************************************************************************
  * Pre-Processor Definitions
  ********************************************************************************************/
 
 /********************************************************************************************
- * CWindowControl Method Implementations
+ * CWindowMessenger Method Implementations
  ********************************************************************************************/
 
 using namespace NxWM;
 
 /**
- * Constructor
- *
- * @param style The default style that all widgets on this display
- *   should use.  If this is not specified, the widget will use the
- *   values stored in the defaultCWidgetStyle object.
+ * CWindowMessenger Constructor
  */
 
-CWindowControl::CWindowControl(FAR const NXWidgets::CWidgetStyle *style)
-: NXWidgets::CWidgetControl(style)
+CWindowMessenger::CWindowMessenger(void)
 {
   // Open a message queue to communicate with the start window task.  We need to create
   // the message queue if it does not exist.
@@ -82,36 +77,28 @@ CWindowControl::CWindowControl(FAR const NXWidgets::CWidgetStyle *style)
     {
       gdbg("ERROR: mq_open(%s) failed: %d\n", g_startWindowMqName, errno);
     }
-
-  // Add ourself as the window callback
-
-  addWindowEventHandler(this);
 }
 
 /**
- * Destructor.
+ * CWindowMessenger Destructor.
  */
 
-CWindowControl::~CWindowControl(void)
+CWindowMessenger::~CWindowMessenger(void)
 {
   // Close the message queue
 
   (void)mq_close(m_mqd);
- 
-  // Remove ourself from the window callback
-
-  removeWindowEventHandler(this);
 }
 
 /**
  * Destroy the application window and everything in it.  This is
- * handled by CWindowControl (vs just calling the destructors) because
+ * handled by CWindowMessenger (vs just calling the destructors) because
  * in the case where an application destroys itself (because of pressing
  * the stop button), then we need to unwind and get out of the application
  * logic before destroying all of its objects.
  */
 
-void CWindowControl::destroy(IApplication *app)
+void CWindowMessenger::destroy(IApplication *app)
 {
   // Send a message to destroy the window isntance at a later time
 
@@ -135,7 +122,7 @@ void CWindowControl::destroy(IApplication *app)
  */
 
 #ifdef CONFIG_NX_MOUSE
-void CWindowControl::handleMouseEvent(void)
+void CWindowMessenger::handleMouseEvent(void)
 {
   // The logic path here is tortuous but flexible:
   //
@@ -157,8 +144,8 @@ void CWindowControl::handleMouseEvent(void)
   //  7. NXWidgets::CWidgetControl records the new state data and raises a
   //     window event.
   //  8. NXWidgets::CWindowEventHandlerList will give the event to this method
-  //     NxWM::CWindowControl.
-  //  9. This NxWM::CWindowControl method will send the a message on a well-
+  //     NxWM::CWindowMessenger.
+  //  9. This NxWM::CWindowMessenger method will send the a message on a well-
   //     known message queue.
   // 10. This CStartWindow::startWindow task will receive and process that
   //     message by calling CWidgetControl::pollEvents()
@@ -181,7 +168,7 @@ void CWindowControl::handleMouseEvent(void)
  */
 
 #ifdef CONFIG_NX_KBD
-void CWindowControl::handleKeyboardEvent(void)
+void CWindowMessenger::handleKeyboardEvent(void)
 {
   // The logic path here is tortuous but flexible:
   //
@@ -203,8 +190,8 @@ void CWindowControl::handleKeyboardEvent(void)
   //  7. NXWidgets::CWidgetControl records the new state data and raises a
   //     window event.
   //  8. NXWidgets::CWindowEventHandlerList will give the event to this method
-  //     NxWM::CWindowControl.
-  //  9. This NxWM::CWindowControl method will send the a message on a well-
+  //     NxWM::CWindowMessenger.
+  //  9. This NxWM::CWindowMessenger method will send the a message on a well-
   //     known message queue.
   // 10. This CStartWindow::startWindow task will receive and process that
   //     message by calling CWidgetControl::pollEvents()