NxWidgets: Remove modal loops, Add CWindowEventHandler*. NxWM: Add support for full screen applications

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

5 files changed, 373 insertions, 58 deletions

diff --git a/NxWidgets/libnxwidgets/include/cnxwidget.hxx b/NxWidgets/libnxwidgets/include/cnxwidget.hxx
index d29830c0a..4c470cfb2 100644
--- a/NxWidgets/libnxwidgets/include/cnxwidget.hxx
+++ b/NxWidgets/libnxwidgets/include/cnxwidget.hxx
@@ -154,7 +154,6 @@ namespace NXWidgets
       uint8_t visibleRegionCacheInvalid : 1;  /**< True if the region cache is invalid. */
       uint8_t hidden          : 1;       /**< True if the widget is hidden. */
       uint8_t doubleClickable : 1;       /**< True if the widget can be double-clicked. */
-      uint8_t modal           : 1;       /**< True if the widget is modal. */
     } Flags;
 
     /**
@@ -565,14 +564,6 @@ namespace NXWidgets
     }
 
     /**
-     * Is the widget modal?  Only true if the Widget singleton is also modal.
-     *
-     * @return True if the widget is modal.
-     */
-
-    const bool isModal(void) const;
-
-    /**
      * Get the width of the widget.
      *
      * @return The widget width.
@@ -1298,21 +1289,6 @@ namespace NXWidgets
     bool removeChild(CNxWidget *widget);
 
     /**
-     * Run the widget modally.
-     */
-
-    void goModal(void);
-
-    /**
-     * Stop the widget running modally.
-     */
-
-    inline void stopModal(void)
-    {
-      m_flags.modal = false;
-    }
-
-    /**
      * Get the child widget at the specified index.
      *
      * @param index Index of the child to retrieve.
diff --git a/NxWidgets/libnxwidgets/include/cwidgetcontrol.hxx b/NxWidgets/libnxwidgets/include/cwidgetcontrol.hxx
index aedec610e..4a54469d8 100644
--- a/NxWidgets/libnxwidgets/include/cwidgetcontrol.hxx
+++ b/NxWidgets/libnxwidgets/include/cwidgetcontrol.hxx
@@ -52,6 +52,8 @@
 #include "cnxwidget.hxx"
 #include "crect.hxx"
 #include "cwidgetstyle.hxx"
+#include "cwindoweventhandler.hxx"
+#include "cwindoweventhandlerlist.hxx"
 #include "tnxarray.hxx"
 
 /****************************************************************************
@@ -165,11 +167,15 @@ namespace NXWidgets
                                                        awaiting deletion. */
     TNxArray<CNxWidget*>        m_widgets;        /**< List of controlled
                                                        widgets. */
-    bool                        m_modal;          /**< True: in modal loop */
     bool                        m_haveGeometry;   /**< True: indicates that we
                                                        have valid geometry data. */
-    sem_t                       m_modalSem;       /**< Modal loops waits for
+#ifdef CONFIG_NXWIDGET_EVENTWAIT
+    bool                        m_waiting;        /**< True: Extternal logic waiting for
+                                                       window event */
+    sem_t                       m_waitSem;        /**< External loops waits for
                                                        events on this semaphore */
+#endif
+
     /**
      * I/O
      */
@@ -198,6 +204,7 @@ namespace NXWidgets
 #ifdef CONFIG_NX_MULTIUSER
     sem_t                       m_geoSem;         /**< Posted when geometry is valid */
 #endif
+    CWindowEventHandlerList     m_eventHandlers;  /**< List of event handlers. */
 
     /**
      * Style
@@ -227,15 +234,15 @@ namespace NXWidgets
     /**
      * Pass clicks to the widget hierarchy.  Closes the context menu if
      * the clicked widget is not the context menu.  If a single widget
-     * is supplied, only that widget is sent the click.  That widget
-     * should be running modally.
+     * is supplied, only that widget is sent the click.
      *
      * @param x Click xcoordinate.
      * @param y Click ycoordinate.
-     * @param widget Pointer to a modally-running widget or NULL.
+     * @param widget. Specific widget to poll.  Use NULL to run the
+     *    all widgets in the window.
      */
 
-    void handleLeftClick(nxgl_coord_t x, nxgl_coord_t y, CNxWidget* widget);
+    void handleLeftClick(nxgl_coord_t x, nxgl_coord_t y, CNxWidget *widget);
 
     /**
      * Get the index of the specified controlled widget.
@@ -255,8 +262,8 @@ namespace NXWidgets
     /**
      * Process mouse/touchscreen events and send throughout the hierarchy.
      *
-     * @param widget to process, used for modal widgets; omit this parameter
-     *    to run the whole system.
+     * @param widget.  Specific widget to poll.  Use NULL to run the
+     *    all widgets in the window.
      * @return True means a mouse event occurred
      */
 
@@ -279,10 +286,12 @@ namespace NXWidgets
     bool pollCursorControlEvents(void);
 
     /**
-     * Wake up the modal loop
+     * Wake up and external logic that is waiting for a window event.
      */
 
-    void wakeupModalLoop(void);
+#ifdef CONFIG_NXWIDGET_EVENTWAIT
+    void postWindowEvent(void);
+#endif
 
     /**
      * Take the geometry semaphore (handling signal interruptions)
@@ -340,42 +349,62 @@ namespace NXWidgets
     ~CWidgetControl(void);
 
     /**
-     * Run the widget modally.  This will run the CWidgetControl
-     * application until stopModal() is called.
-     */
- 
-    void goModal(void);
-
-    /**
-     * Wait for an interesting modal event to occur (like a mouse or keyboard event)
+     * Wait for an interesting window event to occur (like a mouse or keyboard event)
+     * Caller's should exercise care to assure that the test for waiting and this
+     * call are "atomic" .. perhaps by locking the scheduler like:
+     *
+     *  sched_lock();
+     *  <check for events>
+     *  if (<no interesting events>)
+     *    {
+     *      window->waitForWindowEvent();
+     *    }
+     *  sched_unlock();
      */
 
-    void waitForModalEvent(void);
+#ifdef CONFIG_NXWIDGET_EVENTWAIT
+    void waitForWindowEvent(void);
+#endif
 
     /**
-     * Is the widget modal?  Only true if the Widget singleton is also modal.
+     * Is external logic awaiting for a window event?
      *
-     * @return True if the widget is modal.
+     * @return True if the widget if external logic is waiting.
      */
 
-    inline const bool isModal(void) const
+#ifdef CONFIG_NXWIDGET_EVENTWAIT
+    inline const bool isWaiting(void) const
     {
-      return m_modal;
+      return m_waiting;
     }
-    
-    /**
-     * Stop the widget running modally.
-     */
-
-    void stopModal(void);
+#endif
 
     /**
      * Run all code that needs to take place on a periodic basis.
-     * This is normally called from and is the main body of goModal()
-     * with widget == NULL.
+     * This method normally called externally... either periodically
+     * or when a window event is detected.  If CONFIG_NXWIDGET_EVENTWAIT
+     * is defined, then external logic want call waitWindow event and
+     * when awakened, they chould call this function.  As an example:
+     *
+     *   for (;;)
+     *     {
+     *       sched_lock(); // Make the sequence atomic
+     *       if (!window->pollEvents(0))
+     *         {
+     *           window->waitWindowEvent();
+     *         }
+     *       sched_unlock();
+     *     }
+     *
+     * This method is just a wrapper simply calls the followi.
+     *
+     *   processDeleteQueue()
+     *   pollMouseEvents(widget)
+     *   pollKeyboardEvents()
+     *   pollCursorControlEvents()
      *
-     * @param widget Sub-widget to run, used for modal widgets; omit
-     *        this parameter to run the whole system.
+     * @param widget.  Specific widget to poll.  Use NULL to run the
+     *    all widgets in the window.
      * @return True means some interesting event occurred
      */
  
@@ -551,8 +580,10 @@ namespace NXWidgets
     * @param nCh The number of characters that are available in pStr[].
     * @param pStr The array of characters.
     */
-    
+
+#ifdef CONFIG_NX_KBD
     void newKeyboardEvent(uint8_t nCh, FAR const uint8_t *pStr);
+#endif
 
    /**
     * This event means that cursor control data is available for the window.
@@ -673,6 +704,29 @@ namespace NXWidgets
    {
      return m_port;
    }
+
+   /**
+    * Adds a window event handler.  The window handler will receive
+    * notification all NX events received by this window\.
+    *
+    * @param eventHandler A pointer to the event handler.
+    */
+
+   inline void addWindowEventHandler(CWindowEventHandler *eventHandler)
+   {
+     m_eventHandlers.addWindowEventHandler(eventHandler);
+   }
+
+   /**
+    * Remove a window event handler.
+    *
+    * @param eventHandler A pointer to the event handler to remove.
+    */
+
+   inline void removeWindowEventHandler(CWindowEventHandler *eventHandler)
+   {
+     m_eventHandlers.removeWindowEventHandler(eventHandler);  
+   }
   };
 }
 
diff --git a/NxWidgets/libnxwidgets/include/cwindoweventhandler.hxx b/NxWidgets/libnxwidgets/include/cwindoweventhandler.hxx
new file mode 100644
index 000000000..1cea0ba68
--- /dev/null
+++ b/NxWidgets/libnxwidgets/include/cwindoweventhandler.hxx
@@ -0,0 +1,113 @@
+/****************************************************************************
+ * NxWidgets/libnxwidgets/include/cwindoweventhandler.hxx
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
+ *    me be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __INCLUDE_CWINDOWEVENTHANDLER_HXX
+#define __INCLUDE_CWINDOWEVENTHANDLER_HXX
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include "nxconfig.hxx"
+ 
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+ 
+/****************************************************************************
+ * Implementation Classes
+ ****************************************************************************/
+ 
+#if defined(__cplusplus)
+
+namespace NXWidgets
+{
+  class CNxWidget;
+
+  /**
+   * Base CWindowEventHandler class, intended to be subclassed.  Any class that
+   * needs to listen for window events should inherit from this class.
+   */
+
+  class CWindowEventHandler
+  {
+  public:
+    /**
+     * Constructor.
+     */
+
+    inline CWindowEventHandler() { }
+    
+    /**
+     * Destructor.
+     */
+
+    virtual inline ~CWindowEventHandler() { }
+    
+    /**
+     * Handle a NX window redraw request event
+     */
+
+    virtual void handleRedrawEvent(void) { }
+
+    /**
+     * Handle a NX window position/size change event
+     */
+ 
+    virtual void handleGeometryEvent(void) { }
+
+    /**
+     * Handle an NX window mouse input event.
+     *
+     * @param e The event data.
+     */
+
+#ifdef CONFIG_NX_MOUSE
+    virtual void handleMouseEvent(void) { }
+#endif
+
+    /**
+     * Handle a NX window keyboard input event.
+     */
+
+#ifdef CONFIG_NX_KBD
+    virtual void handleKeyboardEvent(void) { }
+#endif
+  };
+}
+
+#endif // __cplusplus
+
+#endif // __INCLUDE_CWINDOWEVENTHANDLER_HXX
diff --git a/NxWidgets/libnxwidgets/include/cwindoweventhandlerlist.hxx b/NxWidgets/libnxwidgets/include/cwindoweventhandlerlist.hxx
new file mode 100644
index 000000000..582805691
--- /dev/null
+++ b/NxWidgets/libnxwidgets/include/cwindoweventhandlerlist.hxx
@@ -0,0 +1,168 @@
+/****************************************************************************
+ * NxWidgets/libnxwidgets/include/cwindoweventhandlerlist.hxx
+ *
+ *   Copyright (C) 2012 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX, NxWidgets, nor the names of its contributors
+ *    me be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __INCLUDE_CWINDOWEVENTHANDLERLIST_HXX
+#define __INCLUDE_CWINDOWEVENTHANDLERLIST_HXX
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+ 
+#include <nuttx/config.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <nuttx/nx/nxglib.h>
+
+#include "cwindoweventhandler.hxx"
+#include "tnxarray.hxx"
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+ 
+/****************************************************************************
+ * Implementation Classes
+ ****************************************************************************/
+ 
+#if defined(__cplusplus)
+
+namespace NXWidgets
+{
+  class CListDataItem;
+
+  /**
+   * List of window event handlers.
+   */
+  class CWindowEventHandlerList
+  {
+  protected:
+    TNxArray<CWindowEventHandler*> m_eventHandlers; /**< List of event handlers */
+
+    /**
+     * Return the index to the window event handler.
+     */
+ 
+    bool findWindowEventHandler(CWindowEventHandler *eventHandler, int &index);
+
+  public:
+
+    /**
+     * Constructor.
+     *
+     * @param widget The owning widget.
+     */
+ 
+    CWindowEventHandlerList(void) { }
+
+    /**
+     * Destructor.
+     */
+
+    inline ~CWindowEventHandlerList(void) { }
+    
+    /**
+     * Get the event handler at the specified index.
+     *
+     * @param index The index of the event handler.
+     * @return The event handler at the specified index.
+     */
+
+    inline CWindowEventHandler *at(const int index) const
+    {
+      return m_eventHandlers.at(index);
+    }
+
+    /**
+     * Get the size of the array.
+     *
+     * @return The size of the array.
+     */
+
+    inline const nxgl_coord_t size(void) const
+    {
+      return m_eventHandlers.size();
+    }
+
+    /**
+     * Adds a window event handler.  The event handler will receive
+     * all events raised by this object.
+     * @param eventHandler A pointer to the event handler.
+     */
+ 
+    void addWindowEventHandler(CWindowEventHandler *eventHandler);
+
+    /**
+     * Remove a window event handler.
+     *
+     * @param eventHandler A pointer to the event handler to remove.
+     */
+
+    void removeWindowEventHandler(CWindowEventHandler *eventHandler);
+
+    /**
+     * Raise the NX window redraw event.
+     */
+
+    void raiseRedrawEvent(void);
+
+    /**
+     * Raise an NX window position/size change event.
+     */
+
+    void raiseGeometryEvent(void);
+
+    /**
+     * Raise an NX mouse window input event.
+     */
+
+#ifdef CONFIG_NX_MOUSE
+    void raiseMouseEvent(void);
+#endif
+
+    /**
+     * Raise an NX keybord input event
+     */
+
+#ifdef CONFIG_NX_KBD
+    void raiseKeyboardEvent(void);
+#endif
+  };
+}
+
+#endif // __cplusplus
+
+#endif // __INCLUDE_CWINDOWEVENTHANDLERLIST_HXX
diff --git a/NxWidgets/libnxwidgets/include/nxconfig.hxx b/NxWidgets/libnxwidgets/include/nxconfig.hxx
index 5d3752fd0..5ab883ab1 100644
--- a/NxWidgets/libnxwidgets/include/nxconfig.hxx
+++ b/NxWidgets/libnxwidgets/include/nxconfig.hxx
@@ -85,6 +85,10 @@
  * mode).  Default 2048
  * CONFIG_NXWIDGETS_LISTENERSTACK - NX listener thread stack size (in multi-user
  * mode).  Default 2048
+ * CONFIG_NXWIDGET_EVENTWAIT - Build in support for external window event, modal
+ *   loop management logic.  This includes methods to wait for windows events
+ *   to occur so that looping logic can sleep until something interesting
+ *   happens with the window.
  *
  * NXWidget Configuration
  *