Add a hex calculator example to NxWM

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

13 files changed, 1478 insertions, 9 deletions

diff --git a/NxWidgets/ChangeLog.txt b/NxWidgets/ChangeLog.txt
index b763d5ee5..ecee1021c 100644
--- a/NxWidgets/ChangeLog.txt
+++ b/NxWidgets/ChangeLog.txt
@@ -140,3 +140,5 @@
   when a new window is started.  It should stay in a maximized state
   so that it will re-appear with the window above it is closed or
   minimized.
+* NxWM::CHexCalculator:  Add a hexadecimal/decimal calculator
+  example.
diff --git a/NxWidgets/Doxygen/Doxyfile b/NxWidgets/Doxygen/Doxyfile
index 0451ce6a0..979f5720f 100644
--- a/NxWidgets/Doxygen/Doxyfile
+++ b/NxWidgets/Doxygen/Doxyfile
@@ -31,7 +31,7 @@ PROJECT_NAME           = NXWidgets
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER         = "1.0"
+PROJECT_NUMBER         = "1.1"
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
 # base path where the generated documentation will be put.
@@ -574,7 +574,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories
 # with spaces.
 
-INPUT                  = "../libnxwidgets"
+INPUT                  = "../libnxwidgets" "../nxwm"
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
diff --git a/NxWidgets/UnitTests/nxwm/main.cxx b/NxWidgets/UnitTests/nxwm/main.cxx
index 3cc85dc43..f61252904 100644
--- a/NxWidgets/UnitTests/nxwm/main.cxx
+++ b/NxWidgets/UnitTests/nxwm/main.cxx
@@ -47,6 +47,7 @@
 #include "ctaskbar.hxx"
 #include "cstartwindow.hxx"
 #include "cnxconsole.hxx"
+#include "chexcalculator.hxx"
 
 #ifdef CONFIG_NXWM_TOUCHSCREEN
 #  include "ctouchscreen.hxx"
@@ -541,6 +542,35 @@ static bool createNxConsole(void)
 }
 
 /////////////////////////////////////////////////////////////////////////////
+// Name: createHexCalculator
+/////////////////////////////////////////////////////////////////////////////
+
+static bool createHexCalculator(void)
+{
+  // Add the hex calculator application to the start window
+
+  printf("createHexCalculator: Creating the hex calculator application\n");
+  NxWM::CHexCalculatorFactory *calculator = new  NxWM::CHexCalculatorFactory(g_nxwmtest.taskbar);
+  if (!calculator)
+    {
+      printf("createHexCalculator: ERROR: Failed to instantiate CHexCalculatorFactory\n");
+      return false;
+    }
+  showTestCaseMemory("createHexCalculator: After creating the hex calculator application");
+
+  printf("createHexCalculator: Adding the hex calculator application to the start window\n");
+  if (!g_nxwmtest.startwindow->addApplication(calculator))
+    {
+      printf("createHexCalculator: ERROR: Failed to add CNxConsoleFactory to the start window\n");
+      delete calculator;
+      return false;
+    }
+
+  showTestCaseMemory("createHexCalculator: After adding the hex calculator application");
+  return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////
 // Public Functions
 /////////////////////////////////////////////////////////////////////////////
 
@@ -645,6 +675,14 @@ int MAIN_NAME(int argc, char *argv[])
       testCleanUpAndExit(EXIT_FAILURE);
     }
 
+  // Create the hex calculator application and add it to the start window
+
+  if (!createHexCalculator())
+    {
+      printf(MAIN_STRING "ERROR: Failed to create the hex calculator application\n");
+      testCleanUpAndExit(EXIT_FAILURE);
+    }
+
   // Call CTaskBar::startWindowManager to start the display with applications in place.
 
   if (!startWindowManager())
diff --git a/NxWidgets/libnxwidgets/doc/mainpage.h b/NxWidgets/libnxwidgets/doc/mainpage.h
index 9eb5ded83..ccd399e6a 100644
--- a/NxWidgets/libnxwidgets/doc/mainpage.h
+++ b/NxWidgets/libnxwidgets/doc/mainpage.h
@@ -47,4 +47,37 @@
  * Some of the graphic objects supported by NXWidgets include labels,
  * buttons, text boxes, button arrays, check boxes, cycle buttons, images,
  * sliders, scrollable list boxes, progress bars, and more.
+ *
+ * \subsection NXWM\
+ *
+ * NxWM isthe tiny window manager based on NX and NxWidgets. NxWM is a true
+ * multiple window manager but only one window is displayed at a time. This
+ * simplification helps performance on LCD based products (in the same way
+ * that a tiled window manager helps) and also makes the best use of small
+ * displays. It is awkward from a human factors point-of-view trying to
+ * manage multiple windows on a small display.
+ *
+ *  The window manager consists of a task bar with icons representing the
+ *  running tasks. If you touch the task's icon, it comes to the top. Each
+ *  window has a toolbar with (1) a title, (2) a minimize button, and (3) a
+ *  stop application button using the standard icons for these things. User
+ *  input via a touchscreen or mouse and keyboard is supported.
+ *
+ *  There is always a start window that is available in the task bar. When
+ *  you touch the start window icon, it brings up the start window containing
+ *  icons representing all of the available applications. If you touch an
+ *  icon in the start window, it will be started and added to the task bar.
+ *
+ *  There is a base class that defines an add-on application and an interface
+ *  that supports incorporation of new applications. The only application
+ *  that is provided is NxConsole. This is an NSH session running in a window.
+ *  You should be able to select the NX icon in the start menu and create as
+ *  many NSH sessions in windows as you want. (keybard input still comes
+ *  through serial).
+ *
+ *  Note 1: NwWM requires NuttX-6.18 or above.
+ *
+ *  Note 2: Many of the fundamental classes in NxWidgets derive from the Antony
+ *  Dzeryn's "Woopsi" project: http://woopsi.org/ which also has a BSD style
+ *  license. See the COPYING file for details.
  */
diff --git a/NxWidgets/nxwm/Makefile b/NxWidgets/nxwm/Makefile
index 01b8d4513..6b2e4ce77 100644
--- a/NxWidgets/nxwm/Makefile
+++ b/NxWidgets/nxwm/Makefile
@@ -44,20 +44,31 @@ CSRCS =
 
 
 # Window Manager
-CXXSRCS  = capplicationwindow.cxx cfullscreenwindow.cxx cnxconsole.cxx
-CXXSRCS += cstartwindow.cxx ctaskbar.cxx cwindowmessenger.cxx
+CXXSRCS  = capplicationwindow.cxx cfullscreenwindow.cxx ctaskbar.cxx cwindowmessenger.cxx
+
+# Device support
 
 ifeq ($(CONFIG_NXWM_TOUCHSCREEN),y)
-CXXSRCS += ccalibration.cxx ctouchscreen.cxx
+CXXSRCS += ctouchscreen.cxx
 endif
 
 ifeq ($(CONFIG_NXWM_KEYBOARD),y)
 CXXSRCS += ckeyboard.cxx
 endif
 
+# Applications
+
+CXXSRCS  = cstartwindow.cxx cnxconsole.cxx chexcalculator.cxx
+
+ifeq ($(CONFIG_NXWM_TOUCHSCREEN),y)
+CXXSRCS += ccalibration.cxx
+endif
+
+
 # Images
-CXXSRCS += glyph_calibration.cxx glyph_cmd.cxx glyph_minimize.cxx glyph_nsh.cxx
-CXXSRCS += glyph_play.cxx glyph_start.cxx glyph_stop.cxx
+CXXSRCS += glyph_calculator.cxx glyph_calibration.cxx glyph_cmd.cxx
+CXXSRCS += glyph_minimize.cxx glyph_nsh.cxx glyph_play.cxx glyph_start.cxx
+CXXSRCS += glyph_stop.cxx
 
 SRCS = $(ASRCS) $(CSRCS) $(CXXSRCS)
 
diff --git a/NxWidgets/nxwm/images/calculator.png b/NxWidgets/nxwm/images/calculator.png
new file mode 100644
index 000000000..fe3ad3e86
--- /dev/null
+++ b/NxWidgets/nxwm/images/calculator.png
diff --git a/NxWidgets/nxwm/include/chexcalculator.hxx b/NxWidgets/nxwm/include/chexcalculator.hxx
new file mode 100644
index 000000000..d73e17faf
--- /dev/null
+++ b/NxWidgets/nxwm/include/chexcalculator.hxx
@@ -0,0 +1,276 @@
+/****************************************************************************
+ * NxWidgets/nxwm/include/chexcalculator.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_CHEXCALCULATOR_HXX
+#define __INCLUDE_CHEXCALCULATOR_HXX
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+ 
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <nuttx/nx/nxtk.h>
+#include <nuttx/nx/nxconsole.h>
+
+#include "cbuttonarray.hxx"
+#include "clabel.hxx"
+
+#include "iapplication.hxx"
+#include "capplicationwindow.hxx"
+#include "ctaskbar.hxx"
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+#define NXWM_HEXCALCULATOR_NROWS    6
+#define NXWM_HEXCALCULATOR_NCOLUMNS 6
+
+/****************************************************************************
+ * Implementation Classes
+ ****************************************************************************/
+
+#if defined(__cplusplus)
+
+namespace NxWM
+{
+  /**
+   * This class implements the NxConsole application.
+   */
+
+  class CHexCalculator : public  IApplication,
+                         private IApplicationCallback,
+                         private NXWidgets::CWidgetEventHandler
+  {
+  private:
+    CTaskbar                *m_taskbar;    /**< Reference to the "parent" taskbar */
+    CApplicationWindow      *m_window;     /**< Reference to the application window */
+    NXWidgets::CButtonArray *m_keypad;     /**< The calculator keyboard */
+    NXWidgets::CLabel       *m_text;       /**< The accumulator text display */
+    struct nxgl_size_s       m_windowSize; /**< The size of the calculator window */
+    struct nxgl_size_s       m_keypadSize; /**< The size the calculator keypad */
+    struct nxgl_size_s       m_buttonSize; /**< The size of one calculator button */
+    struct nxgl_size_s       m_textSize;   /**< The size of the calculator textbox */
+    struct nxgl_point_s      m_keypadPos;  /**< The position the calculator keypad */
+    struct nxgl_point_s      m_textPos;    /**< The position of the calculator textbox */
+    uint64_t                 m_operand;    /**< Previously entered operand */
+    uint64_t                 m_accum;      /**< The current accumulated value */
+    uint64_t                 m_memory;     /**< The current value in memory */
+    uint8_t                  m_pending;    /**< The pending operation */
+    bool                     m_hexMode;    /**< True if in hex mode */
+
+   /**
+    * Select the geometry of the calculator given the current window size.
+    * Only called as part of construction.
+    */
+
+   inline void setGeometry(void);
+
+    /**
+     * Create the calculator keypad.  Only start as part of the applicaiton
+     * start method.
+     */
+
+   inline bool createCalculator(void);
+
+    /**
+     * Applies labels to the keys.
+     */
+
+    void labelKeypad(void);
+
+    /**
+     * Show the current value of the accumulator.
+     */
+
+    void updateText(void);
+
+    /**
+     * Called when the window minimize button is pressed.
+     */
+
+    void minimize(void);
+
+    /**
+     * Called when the window minimize close is pressed.
+     */
+
+    void close(void);
+
+    /**
+     * Handle a widget action event.  For CImage, this is a button pre-
+     * release event.
+     *
+     * @param e The event data.
+     */
+
+    void handleActionEvent(const NXWidgets::CWidgetEventArgs &e);
+
+  public:
+    /**
+     * CHexCalculator constructor
+     *
+     * @param window.  The application window
+     *
+     * @param taskbar.  A pointer to the parent task bar instance
+     * @param window.  The window to be used by this application.
+     */
+
+    CHexCalculator(CTaskbar *taskbar, CApplicationWindow *window);
+
+    /**
+     * CHexCalculator destructor
+     */
+
+    ~CHexCalculator(void);
+
+    /**
+     * Each implementation of IApplication must provide a method to recover
+     * the contained CApplicationWindow instance.
+     */
+
+    IApplicationWindow *getWindow(void) const;
+
+    /**
+     * Get the icon associated with the application
+     *
+     * @return An instance if IBitmap that may be used to rend the
+     *   application's icon.  This is an new IBitmap instance that must
+     *   be deleted by the caller when it is no long needed.
+     */
+
+    NXWidgets::IBitmap *getIcon(void);
+
+    /**
+     * Get the name string associated with the application
+     *
+     * @return A copy if CNxString that contains the name of the application.
+     */
+
+    NXWidgets::CNxString getName(void);
+
+    /**
+     * Start the application (perhaps in the minimized state).
+     *
+     * @return True if the application was successfully started.
+     */
+
+    bool run(void);
+
+    /**
+     * Stop the application.
+     */
+
+    void 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 destroy(void);
+
+    /**
+     * The application window is hidden (either it is minimized or it is
+     * maximized, but not at the top of the hierarchy
+     */
+
+    void hide(void);
+
+    /**
+     * Redraw the entire window.  The application has been maximized or
+     * otherwise moved to the top of the hierarchy.  This method is call from
+     * CTaskbar when the application window must be displayed
+     */
+
+    void redraw(void);
+
+    /**
+     * Report of this is a "normal" window or a full screen window.  The
+     * primary purpose of this method is so that window manager will know
+     * whether or not it show draw the task bar.
+     *
+     * @return True if this is a full screen window.
+     */
+
+    bool isFullScreen(void) const;
+  };
+
+  class CHexCalculatorFactory : public IApplicationFactory
+  {
+  private:
+    CTaskbar *m_taskbar;  /**< The taskbar */
+
+  public:
+    /**
+     * CHexCalculatorFactory Constructor
+     *
+     * @param taskbar.  The taskbar instance used to terminate calibration
+     */
+
+    CHexCalculatorFactory(CTaskbar *taskbar);
+
+    /**
+     * CHexCalculatorFactory Destructor
+     */
+
+    inline ~CHexCalculatorFactory(void) { }
+
+    /**
+     * Create a new instance of an CHexCalculator (as IApplication).
+     */
+
+    IApplication *create(void);
+
+    /**
+     * Get the icon associated with the application
+     *
+     * @return An instance if IBitmap that may be used to rend the
+     *   application's icon.  This is an new IBitmap instance that must
+     *   be deleted by the caller when it is no long needed.
+     */
+
+    NXWidgets::IBitmap *getIcon(void);
+  };
+}
+#endif // __cplusplus
+
+#endif // __INCLUDE_CHEXCALCULATOR_HXX
diff --git a/NxWidgets/nxwm/include/cstartwindow.hxx b/NxWidgets/nxwm/include/cstartwindow.hxx
index c7a812abf..671b01087 100644
--- a/NxWidgets/nxwm/include/cstartwindow.hxx
+++ b/NxWidgets/nxwm/include/cstartwindow.hxx
@@ -172,7 +172,8 @@ namespace NxWM
     void removeAllApplications(void);
 
     /**
-     * Handle a widget action event.  For CImage, this is a mouse button pre-release event.
+     * Handle a widget action event.  For CButtonArray, this is a mouse
+     * button pre-release event.
      *
      * @param e The event data.
      */
diff --git a/NxWidgets/nxwm/include/nxwmconfig.hxx b/NxWidgets/nxwm/include/nxwmconfig.hxx
index 8a7700af4..ad51e7884 100644
--- a/NxWidgets/nxwm/include/nxwmconfig.hxx
+++ b/NxWidgets/nxwm/include/nxwmconfig.hxx
@@ -509,6 +509,24 @@
 #  define CONFIG_NXWM_CALIBRATION_LISTENERSTACK 2048
 #endif
 
+/* Hexcalculator applications ***********************************************/
+/**
+ * Calibration display settings:
+ *
+ * CONFIG_NXWM_HEXCALCULATOR_BACKGROUNDCOLOR - The background color of the
+ *   calculator display.  Default:  Same as CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR
+ * CONFIG_NXWM_HEXCALCULATOR_ICON - The ICON to use for the hex calculator
+ *   application.  Default:  NxWM::g_calculatorBitmap
+ */
+
+#ifndef CONFIG_NXWM_HEXCALCULATOR_BACKGROUNDCOLOR
+#  define CONFIG_NXWM_HEXCALCULATOR_BACKGROUNDCOLOR CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR
+#endif
+
+#ifndef CONFIG_NXWM_HEXCALCULATOR_ICON
+#  define CONFIG_NXWM_HEXCALCULATOR_ICON NxWM::g_calculatorBitmap
+#endif
+
 /****************************************************************************
  * Global Function Prototypes
  ****************************************************************************/
diff --git a/NxWidgets/nxwm/include/nxwmglyphs.hxx b/NxWidgets/nxwm/include/nxwmglyphs.hxx
index 64f9a5262..7db02fd17 100644
--- a/NxWidgets/nxwm/include/nxwmglyphs.hxx
+++ b/NxWidgets/nxwm/include/nxwmglyphs.hxx
@@ -57,6 +57,7 @@
 
 namespace NxWM
 {
+  extern const struct NXWidgets::SRlePaletteBitmap g_calculatorBitmap;
   extern const struct NXWidgets::SRlePaletteBitmap g_calibrationBitmap;
   extern const struct NXWidgets::SRlePaletteBitmap g_cmdBitmap;
   extern const struct NXWidgets::SRlePaletteBitmap g_minimizeBitmap;
diff --git a/NxWidgets/nxwm/src/ccalibration.cxx b/NxWidgets/nxwm/src/ccalibration.cxx
index 8ba8d0173..32aeb5ee6 100644
--- a/NxWidgets/nxwm/src/ccalibration.cxx
+++ b/NxWidgets/nxwm/src/ccalibration.cxx
@@ -536,7 +536,7 @@ void CCalibration::stateMachine(void)
           // Fill the entire window with the background color
 
           port->drawFilledRect(0, 0, windowSize.w, windowSize.h,
-                               CONFIG_NXWM_DEFAULT_BACKGROUNDCOLOR);
+                               CONFIG_NXWM_CALIBRATION_BACKGROUNDCOLOR);
 
           // Then draw the first calibration screen
 
diff --git a/NxWidgets/nxwm/src/chexcalculator.cxx b/NxWidgets/nxwm/src/chexcalculator.cxx
new file mode 100644
index 000000000..0217574e2
--- /dev/null
+++ b/NxWidgets/nxwm/src/chexcalculator.cxx
@@ -0,0 +1,898 @@
+/********************************************************************************************
+ * NxWidgets/nxwm/src/chexcalculator.cxx
+ *
+ *   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.
+ *
+ ********************************************************************************************/
+
+/********************************************************************************************
+ * Included Files
+ ********************************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <cstdio>
+#include <debug.h>
+
+#include "cwidgetcontrol.hxx"
+
+#include "nxwmconfig.hxx"
+#include "nxwmglyphs.hxx"
+#include "chexcalculator.hxx"
+
+/********************************************************************************************
+ * Pre-Processor Definitions
+ ********************************************************************************************/
+
+/********************************************************************************************
+ * Private Types
+ ********************************************************************************************/
+
+/********************************************************************************************
+ * Private Data
+ ********************************************************************************************/
+
+namespace NxWM
+{
+  /**
+   * This enumeration value describes a key
+   */
+
+  enum EKeyType
+  {
+    KEY_NONE = 0,    // Used to represent no pending operation
+
+    // Values: {0-9, A-F}
+
+    KEY_VALUE,       // Key is a value
+
+    // Unary operators
+
+    KEY_NOT,         // 1's complement
+    KEY_NEGATE,      // 2's complement
+
+    // Binary operators
+
+    KEY_XOR,         // Exclusive OR
+    KEY_DIVIDE,      // Division
+    KEY_RSH,         // Right shift
+    KEY_LSH,         // Left shift
+    KEY_MULTIPLY,    // Multiplication
+    KEY_AND,         // Bit-wise AND
+    KEY_OR,          // Bit-wise OR
+    KEY_MINUS,       // Subtraction
+    KEY_PLUS,        // Additions
+
+    // Special operations
+ 
+    KEY_EQUAL,       // Equal/Enter key
+ 
+    KEY_DECIMAL,     // Decimal mode
+    KEY_HEXADECIMAL, // Hexadecimal mode
+
+    KEY_MRECALL,   // Recall from memory
+    KEY_MPLUS,     // Add to memory
+    KEY_MMINUS,    // Subtract from memory
+
+    KEY_MCLR,      // Clear memory
+    KEY_CLRENTRY,  // Clear entry
+    KEY_CLR        // Clear all
+  };
+
+  /**
+   * This structure value describes a key
+   */
+
+  struct SKeyDesc
+  {
+    uint16_t hexMode : 1;  // Key applies in hex mode
+    uint16_t decMode : 1;  // Key applies in decimal mode
+    uint16_t keyType : 5;  // Describes the key (see enum EKeyType)
+    uint16_t value   : 4;  // Value (if the key has an associated value)
+  };
+
+  /**
+   * This array provides the possible labels for each key
+   */
+
+  static FAR const char *g_labels[NXWM_HEXCALCULATOR_NCOLUMNS*NXWM_HEXCALCULATOR_NROWS] =
+  {
+     "MR",  "M+",  "M-",  "MC", "CE", "C",
+     "A",   "B",   "C",   "D",  "E",  "F",
+     "NOT", "XOR", "7",   "8",  "9",  "/",
+     "RSH", "LSH", "4",   "5",  "6",  "*",
+     "AND", "OR",  "1",   "2",  "3",  "-",
+     "DEC", "HEX", "+/-", "0",  "=",  "+"
+  };
+
+  /**
+   * This array manages the behavior when each key is pressed
+   */
+
+  static struct SKeyDesc g_keyDesc[NXWM_HEXCALCULATOR_NCOLUMNS*NXWM_HEXCALCULATOR_NROWS] =
+  {
+    {1, 1, KEY_MRECALL,     0},
+    {1, 1, KEY_MPLUS,       0},
+    {1, 1, KEY_MMINUS,      0},
+    {1, 1, KEY_MCLR,        0},
+    {1, 1, KEY_CLRENTRY,    0},
+    {1, 1, KEY_CLR,         0},
+
+    {1, 0, KEY_VALUE,       10},
+    {1, 0, KEY_VALUE,       11},
+    {1, 0, KEY_VALUE,       12},
+    {1, 0, KEY_VALUE,       13},
+    {1, 0, KEY_VALUE,       14},
+    {1, 0, KEY_VALUE,       15},
+
+    {1, 0, KEY_NOT,         0},
+    {1, 0, KEY_XOR,         0},
+    {1, 1, KEY_VALUE,       7},
+    {1, 1, KEY_VALUE,       8},
+    {1, 1, KEY_VALUE,       9},
+    {1, 1, KEY_DIVIDE,      0},
+
+    {1, 0, KEY_RSH,         0},
+    {1, 0, KEY_LSH,         0},
+    {1, 1, KEY_VALUE,       4},
+    {1, 1, KEY_VALUE,       5},
+    {1, 1, KEY_VALUE,       6},
+    {1, 1, KEY_MULTIPLY,    0},
+
+    {1, 0, KEY_AND,         0},
+    {1, 0, KEY_OR,          0},
+    {1, 1, KEY_VALUE,       1},
+    {1, 1, KEY_VALUE,       2},
+    {1, 1, KEY_VALUE,       3},
+    {1, 1, KEY_MINUS,       0},
+
+    {1, 0, KEY_DECIMAL,     0},
+    {0, 1, KEY_HEXADECIMAL, 0},
+    {1, 1, KEY_NEGATE,      0},
+    {1, 1, KEY_VALUE,       0},
+    {1, 1, KEY_EQUAL,       0},
+    {1, 1, KEY_PLUS,        0}
+  };
+}
+
+/********************************************************************************************
+ * Private Functions
+ ********************************************************************************************/
+
+/********************************************************************************************
+ * CHexCalculator Method Implementations
+ ********************************************************************************************/
+
+using namespace NxWM;
+
+/**
+ * CHexCalculator constructor
+ *
+ * @param window.  The application window
+ */
+
+CHexCalculator::CHexCalculator(CTaskbar *taskbar, CApplicationWindow *window)
+{
+  // Save the constructor data
+
+  m_taskbar = taskbar;
+  m_window  = window;
+
+  // Nullify widgets that will be instantiated when the window is started
+
+  m_keypad  = (NXWidgets::CButtonArray *)0;
+  m_text    = (NXWidgets::CLabel       *)0;
+
+  // Reset other values
+
+  m_operand  = 0;                  // No previously entered operand
+  m_accum    = 0;                  // The accumulator is initially zero
+  m_memory   = 0;                  // No value in memory
+  m_pending  = (uint8_t)KEY_NONE;  // No pending operation */
+  m_hexMode  = 0;                  // Decimal mode
+
+  // Add our personalized window label
+
+  NXWidgets::CNxString myName = getName();
+  window->setWindowLabel(myName);
+
+  // Add our callbacks with the application window
+
+  window->registerCallbacks(static_cast<IApplicationCallback *>(this));
+
+  // Set the geometry of the calculator
+
+  setGeometry();
+}
+
+/**
+ * CHexCalculator destructor
+ *
+ * @param window.  The application window
+ */
+
+CHexCalculator::~CHexCalculator(void)
+{
+  // Destroy widgets 
+
+  if (m_text)
+    {
+      delete m_text;
+    }
+
+  if (m_keypad)
+    {
+      delete m_keypad;
+    }
+
+  // Although we didn't create it, we are responsible for deleting the
+  // application window
+
+  delete m_window;
+}
+
+/**
+ * Each implementation of IApplication must provide a method to recover
+ * the contained CApplicationWindow instance.
+ */
+
+IApplicationWindow *CHexCalculator::getWindow(void) const
+{
+  return static_cast<IApplicationWindow*>(m_window);
+}
+
+/**
+ * Get the icon associated with the application
+ *
+ * @return An instance if IBitmap that may be used to rend the
+ *   application's icon.  This is an new IBitmap instance that must
+ *   be deleted by the caller when it is no long needed.
+ */
+
+NXWidgets::IBitmap *CHexCalculator::getIcon(void)
+{
+  NXWidgets::CRlePaletteBitmap *bitmap =
+    new NXWidgets::CRlePaletteBitmap(&CONFIG_NXWM_HEXCALCULATOR_ICON);
+
+  return bitmap;
+}
+
+/**
+ * Get the name string associated with the application
+ *
+ * @return A copy if CNxString that contains the name of the application.
+ */
+
+NXWidgets::CNxString CHexCalculator::getName(void)
+{
+  return NXWidgets::CNxString("Hex Calculator");
+}
+
+/**
+ * Start the application (perhaps in the minimized state).
+ *
+ * @return True if the application was successfully started.
+ */
+
+bool CHexCalculator::run(void)
+{
+  // Create the widgets (if we have not already done so)
+
+  if (!m_keypad)
+    {
+      // Create the widgets
+
+    if (!createCalculator())
+      {
+        gdbg("ERROR: Failed to create widgets\n");
+        return false;
+      }
+
+      // Apply initial labels
+
+      labelKeypad();
+    }
+
+  return true;
+}
+
+/**
+ * Stop the application.
+ */
+
+void CHexCalculator::stop(void)
+{
+  // Just disable further drawing
+
+  m_keypad->disableDrawing();
+  m_keypad->setRaisesEvents(false);
+
+  m_text->disableDrawing();
+}
+
+/**
+ * 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 CHexCalculator::destroy(void)
+{
+  // Make sure that the widgets are stopped
+
+  stop();
+
+  // Block any further window messages
+
+  m_window->block(this);
+}
+
+/**
+ * The application window is hidden (either it is minimized or it is
+ * maximized, but not at the top of the hierarchy
+ */
+
+void CHexCalculator::hide(void)
+{
+  // Disable drawing and events
+
+  stop();
+}
+
+/**
+ * Redraw the entire window.  The application has been maximized or
+ * otherwise moved to the top of the hierarchy.  This method is call from
+ * CTaskbar when the application window must be displayed
+ */
+
+void CHexCalculator::redraw(void)
+{
+  // Get the widget control associated with the application window
+
+  NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
+
+  // Get the CCGraphicsPort instance for this window
+
+  NXWidgets::CGraphicsPort *port = control->getGraphicsPort();
+
+  // Fill the entire window with the background color
+
+  port->drawFilledRect(0, 0, m_windowSize.w, m_windowSize.h,
+                       CONFIG_NXWM_HEXCALCULATOR_BACKGROUNDCOLOR);
+
+  // Enable and redraw widgets
+
+  m_keypad->enableDrawing();
+  m_keypad->redraw();
+  m_keypad->setRaisesEvents(true);
+
+  m_text->enableDrawing();
+  m_text->redraw();
+}
+
+/**
+ * Report of this is a "normal" window or a full screen window.  The
+ * primary purpose of this method is so that window manager will know
+ * whether or not it show draw the task bar.
+ *
+ * @return True if this is a full screen window.
+ */
+
+bool CHexCalculator::isFullScreen(void) const
+{
+  return m_window->isFullScreen();
+}
+
+/**
+ * Select the geometry of the calculator given the current window size.
+ */
+
+void CHexCalculator::setGeometry(void)
+{
+  // Recover the NXTK window instance contained in the application window
+
+  NXWidgets::INxWindow *window = m_window->getWindow();
+
+  // Get the size of the window
+
+  (void)window->getSize(&m_windowSize);
+
+  // Pick a height and width of a button to fill the entire window.
+  // For the height, we will assume that the text window is 1.5 times
+  // as high as a button
+
+  m_buttonSize.w = m_windowSize.w / NXWM_HEXCALCULATOR_NCOLUMNS;
+  m_buttonSize.h = (m_windowSize.h << 1) / (2 * NXWM_HEXCALCULATOR_NROWS + 3);
+
+  // Limit aspect ratio.  (1) Button should no be taller than it is wide,
+  // (2) Button should be no more than twice as wide as it is tall.
+
+  if (m_buttonSize.h > m_buttonSize.w)
+    {
+      m_buttonSize.h = m_buttonSize.w;
+    }
+  else if (m_buttonSize.w > (m_buttonSize.h << 1))
+    {
+      m_buttonSize.w = (m_buttonSize.h << 1);
+    }
+
+  // Get the size of the entry calculator m_keypad
+
+  m_keypadSize.w = NXWM_HEXCALCULATOR_NCOLUMNS * m_buttonSize.w;
+  m_keypadSize.h = NXWM_HEXCALCULATOR_NROWS * m_buttonSize.h;
+
+  // Get the size of the text box.  Same width as the m_keypad
+
+  m_textSize.w   = m_keypadSize.w;
+  m_textSize.h   = m_windowSize.h - NXWM_HEXCALCULATOR_NROWS * m_buttonSize.h;
+
+  // Limit the height of the text box to twice the height of a button.
+
+  if (m_textSize.h > (m_buttonSize.h << 1))
+    {
+      m_textSize.h = (m_buttonSize.h << 1);
+    }
+
+  // Pick an X/Y position such that the m_keypad+textbox will be centered
+  // in the display
+
+  struct nxgl_point_s calculatorPos;
+  calculatorPos.x = (m_windowSize.w - m_keypadSize.w) >> 1;
+  calculatorPos.y = (m_windowSize.h - m_textSize.h - m_keypadSize.h) >> 1;
+
+  // Now pick the set of the text box and the m_keypad
+
+  m_textPos.x = calculatorPos.x;
+  m_textPos.y = calculatorPos.y;
+
+  m_keypadPos.x = calculatorPos.x;
+  m_keypadPos.y = calculatorPos.y + m_textSize.h;
+}
+
+/**
+ * Create the calculator widgets.  Only start as part of the applicaiton
+ * start method.
+ */
+
+bool CHexCalculator::createCalculator(void)
+{
+  // Get the widget control associated with the application window
+
+  NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
+
+  // Create the button array
+
+  m_keypad = new NXWidgets::CButtonArray(control,
+                                         m_keypadPos.x, m_keypadPos.y,
+                                         NXWM_HEXCALCULATOR_NCOLUMNS,
+                                         NXWM_HEXCALCULATOR_NROWS,
+                                         m_buttonSize.w, m_buttonSize.h);
+  if (!m_keypad)
+    {
+      gdbg("ERROR: Failed to create CButtonArray\n");
+      return false;
+    }
+
+  // Disable drawing and events until we are asked to redraw the window
+
+  m_keypad->disableDrawing();
+  m_keypad->setRaisesEvents(false);
+
+  // Register to receive events from the keypad
+
+  m_keypad->addWidgetEventHandler(this);
+
+  // Create a label to show the accumulator.  A simple label is used
+  // because the power of a text box is un-necessary in this application.
+
+  m_text = new NXWidgets::CLabel(control,
+                                 m_textPos.x, m_textPos.y,
+                                 m_textSize.w, m_textSize.h,
+                                 "0");
+  if (!m_text)
+    {
+      gdbg("ERROR: Failed to create CLabel\n");
+      return false;
+    }
+
+  // Align text on the left
+
+  m_text->setTextAlignmentHoriz(NXWidgets::CLabel::TEXT_ALIGNMENT_HORIZ_RIGHT);
+
+  // Disable drawing and events until we are asked to redraw the window
+
+  m_text->disableDrawing();
+  m_text->setRaisesEvents(false);
+  return true;
+}
+
+/**
+ * Applies labels to the keys.
+ */
+
+void CHexCalculator::labelKeypad(void)
+{
+  // Make sure that drawing is disabled from this operation
+
+  bool isEnabled = m_keypad->isDrawingEnabled();
+  m_keypad->disableDrawing();
+
+  // Add the labels to each button.
+
+  for (int j = 0; j < NXWM_HEXCALCULATOR_NROWS; j++)
+    {
+      for (int i = 0; i < NXWM_HEXCALCULATOR_NCOLUMNS; i++)
+        {
+          int index = j * NXWM_HEXCALCULATOR_NCOLUMNS + i;
+
+          // What mode are we in?  Does the button label appear in this mode?
+
+          FAR const char *label;
+          if ((m_hexMode && g_keyDesc[index].hexMode) ||
+              (!m_hexMode && g_keyDesc[index].decMode))
+            {
+              label = g_labels[index];
+            }
+          else
+            {
+              label = "";
+            }
+          
+          // Set the text in the label
+
+          m_keypad->setText(i, j, label);
+        }
+    }
+
+  // Then redraw the display
+
+  if (isEnabled)
+    {
+      m_keypad->enableDrawing();
+      m_keypad->redraw();
+    }
+}
+
+/**
+ * Show the current value of the accumulator.
+ */
+
+void CHexCalculator::updateText(void)
+{
+  char buffer[24];
+
+  if (m_hexMode)
+    {
+      snprintf(buffer, 24, "%16lx", m_accum);
+    }
+  else
+    {
+      snprintf(buffer, 24, "%ld", m_accum);
+    }
+
+  // setText will perform the redraw as well
+
+  m_text->setText(buffer);
+}
+
+/**
+ * Called when the window minimize button is pressed.
+ */
+
+void CHexCalculator::minimize(void)
+{
+  m_taskbar->minimizeApplication(static_cast<IApplication*>(this));
+}
+
+/**
+ * Called when the window close button is pressed.
+ */
+
+void CHexCalculator::close(void)
+{
+  m_taskbar->stopApplication(static_cast<IApplication*>(this));
+}
+
+/**
+ * Handle a widget action event.  For CButtonArray, this is a button pre-
+ * release event.
+ *
+ * @param e The event data.
+ */
+
+void CHexCalculator::handleActionEvent(const NXWidgets::CWidgetEventArgs &e)
+{
+  // A button should now be clicked
+
+  int column;
+  int row;
+
+  if (m_keypad->isButtonClicked(column, row))
+    {
+      // Handle the key according to its type
+
+      int index = row * NXWM_HEXCALCULATOR_NCOLUMNS + column;
+
+      // First, make sure that the keypress is valid in this mode
+
+      if ((m_hexMode && !g_keyDesc[index].hexMode) ||
+          (!m_hexMode && !g_keyDesc[index].decMode))
+        {
+          // Ignore the key in this mode
+
+          return;
+        }
+
+      // Process the keypress
+
+      switch (g_keyDesc[index].keyType)
+        {
+          // Values: {0-9, A-F}
+
+          case KEY_VALUE:       // Key is a value
+            {
+              m_accum <<= 4;
+              m_accum |= (uint64_t)g_keyDesc[index].value;
+              updateText();
+            }
+            break;
+
+          // Unary operators
+
+          case KEY_NOT:         // 1's complement
+            {
+              m_accum = ~m_accum;
+              updateText();
+            }
+            break;
+
+          case KEY_NEGATE:      // 2's complement
+            {
+              m_accum = -m_accum;
+              updateText();
+            }
+            break;
+
+          // Binary operators
+
+          case KEY_XOR:         // Exclusive OR
+          case KEY_DIVIDE:      // Division
+          case KEY_RSH:         // Right shift
+          case KEY_LSH:         // Left shift
+          case KEY_MULTIPLY:    // Multiplication
+          case KEY_AND:         // Bit-wise AND
+          case KEY_OR:          // Bit-wise OR
+          case KEY_MINUS:       // Subtraction
+          case KEY_PLUS:        // Additions
+            {
+              m_operand = m_accum;
+              m_accum   = 0;
+              m_pending = g_keyDesc[index].keyType;
+              updateText();
+            }
+            break;
+
+          // Special operations
+ 
+          case KEY_EQUAL:       // Equal/Enter key
+            {
+              switch (m_pending)
+                {
+                case KEY_NONE:        // Do nothing if there is no pending operation
+                  return;
+
+                case KEY_XOR:         // Exclusive OR
+                  m_accum ^= m_operand;
+                  break;
+
+                case KEY_DIVIDE:      // Division
+                  m_accum = m_operand / m_accum;
+                  break;
+
+                case KEY_RSH:         // Right shift
+                  m_accum = m_operand >> m_accum;
+                  break;
+
+                case KEY_LSH:         // Left shift
+                  m_accum = m_operand << m_accum;
+                  break;
+
+                case KEY_MULTIPLY:    // Multiplication
+                  m_accum *= m_operand;
+                  break;
+
+                case KEY_AND:         // Bit-wise AND
+                  m_accum &= m_operand;
+                  break;
+
+                case KEY_OR:          // Bit-wise OR
+                  m_accum |= m_operand;
+                  break;
+
+                case KEY_MINUS:       // Subtraction
+                  m_accum = m_operand - m_accum;
+                  break;
+
+                case KEY_PLUS:        // Additions
+                  m_accum += m_operand;
+                  break;
+
+                default:
+                  gdbg("ERROR: Unexpected pending operation %d\n", m_pending);
+                  m_pending = KEY_NONE;
+                  return;
+                }
+               
+              m_operand = 0;
+              m_pending = KEY_NONE;
+              updateText();
+            }
+            break;
+ 
+          case KEY_DECIMAL:     // Decimal mode
+            {
+              if (m_hexMode)
+                {
+                  m_hexMode = false;
+                  labelKeypad();
+                  m_keypad->redraw();
+                }
+            }
+            break;
+
+          case KEY_HEXADECIMAL: // Hexadecimal mode
+            {
+              if (!m_hexMode)
+                {
+                  m_hexMode = true;
+                  labelKeypad();
+                  m_keypad->redraw();
+                }
+            }
+            break;
+
+          case KEY_MRECALL:   // Recall from memory
+            {
+               m_accum = m_memory;
+               updateText();
+            }
+            break;
+
+          case KEY_MPLUS:     // Add to memory
+            {
+               m_memory += m_accum;
+            }
+            break;
+
+          case KEY_MMINUS:    // Subtract from memory
+            {
+               m_memory -= m_accum;
+            }
+            break;
+
+          case KEY_MCLR:      // Clear memory
+            {
+               m_memory = 0;
+            }
+            break;
+
+          case KEY_CLRENTRY:  // Clear entry
+            {
+               m_accum = 0;
+               updateText();
+            }
+            break;
+
+          case KEY_CLR:       // Clear all
+            {
+               m_accum   = 0;
+               m_operand = 0;
+               m_pending = KEY_NONE;
+               updateText();
+            }
+            break;
+
+          case KEY_NONE:
+          default:
+            gdbg("ERROR: Invalid key type %d\n", g_keyDesc[index].keyType);
+            break;
+        }
+    }
+}
+
+/**
+ * CHexCalculatorFactory Constructor
+ *
+ * @param taskbar.  The taskbar instance used to terminate the console
+ */
+
+CHexCalculatorFactory::CHexCalculatorFactory(CTaskbar *taskbar)
+{
+  m_taskbar = taskbar;
+}
+
+/**
+ * Create a new instance of an CHexCalculator (as IApplication).
+ */
+
+IApplication *CHexCalculatorFactory::create(void)
+{
+  // Call CTaskBar::openFullScreenWindow to create a application window for
+  // the NxConsole application
+
+  CApplicationWindow *window = m_taskbar->openApplicationWindow();
+  if (!window)
+    {
+      gdbg("ERROR: Failed to create CApplicationWindow\n");
+      return (IApplication *)0;
+    }
+
+  // Open the window (it is hot in here)
+
+  if (!window->open())
+    {
+      gdbg("ERROR: Failed to open CApplicationWindow\n");
+      delete window;
+      return (IApplication *)0;
+    }
+
+  // Instantiate the application, providing the window to the application's
+  // constructor
+
+  CHexCalculator *hexCalculator = new CHexCalculator(m_taskbar, window);
+  if (!hexCalculator)
+    {
+      gdbg("ERROR: Failed to instantiate CHexCalculator\n");
+      delete window;
+      return (IApplication *)0;
+    }
+
+  return static_cast<IApplication*>(hexCalculator);
+}
+
+/**
+ * Get the icon associated with the application
+ *
+ * @return An instance if IBitmap that may be used to rend the
+ *   application's icon.  This is an new IBitmap instance that must
+ *   be deleted by the caller when it is no long needed.
+ */
+
+NXWidgets::IBitmap *CHexCalculatorFactory::getIcon(void)
+{
+  NXWidgets::CRlePaletteBitmap *bitmap =
+    new NXWidgets::CRlePaletteBitmap(&CONFIG_NXWM_HEXCALCULATOR_ICON);
+
+  return bitmap;
+}
diff --git a/NxWidgets/nxwm/src/glyph_calculator.cxx b/NxWidgets/nxwm/src/glyph_calculator.cxx
new file mode 100644
index 000000000..3d8bb97bd
--- /dev/null
+++ b/NxWidgets/nxwm/src/glyph_calculator.cxx
@@ -0,0 +1,191 @@
+/********************************************************************************************
+ * NxWidgets/nxwm/src/glyph_calculator.cxx
+ *
+ *   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.
+ *
+ ********************************************************************************************/
+
+/********************************************************************************************
+ * Included Files
+ ********************************************************************************************/
+ 
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <nuttx/nx/nxglib.h>
+#include <nuttx/fb.h>
+#include <nuttx/rgbcolors.h>
+
+#include "crlepalettebitmap.hxx"
+
+#include "nxwmconfig.hxx"
+#include "nxwmglyphs.hxx"
+
+/********************************************************************************************
+ * Pre-Processor Definitions
+ ********************************************************************************************/
+
+#define BITMAP_NROWS     25
+#define BITMAP_NCOLUMNS  24
+#define BITMAP_NLUTCODES 8
+
+/********************************************************************************************
+ * Private Bitmap Data
+ ********************************************************************************************/
+
+using namespace NxWM;
+
+/* RGB24 (8-8-8) Colors */
+
+#if CONFIG_NXWIDGETS_BPP == 24 ||  CONFIG_NXWIDGETS_BPP == 32
+
+static const uint32_t g_calculatorNormalLut[BITMAP_NLUTCODES] =
+{
+  0xfcfcfc, 0xb8bcbc, 0xf8f8f8, 0x6890c8, 0x384c80, 0xe8e8e8, 0x646464, 0x909090  /* Codes 0-7 */
+};
+
+static const uint32_t g_calculatorBrightlLut[BITMAP_NLUTCODES] =
+{
+  0xffffff, 0xc9cccc, 0xf9f9f9, 0x8dabd5, 0x69789f, 0xededed, 0x8a8a8a, 0xababab  /* Codes 0-7 */
+};
+
+/* RGB16 (565) Colors (four of the colors in this map are duplicates) */
+
+#elif CONFIG_NXWIDGETS_BPP == 16
+
+static const uint16_t g_calculatorNormalLut[BITMAP_NLUTCODES] =
+{
+  0xffff, 0xbdf7, 0xffdf, 0x6c99, 0x3a70, 0xef5d, 0x632c, 0x9492  /* Codes 0-7 */
+};
+
+static const uint16_t g_calculatorBrightlLut[BITMAP_NLUTCODES] =
+{
+  0xffff, 0xce79, 0xffdf, 0x8d5a, 0x6bd3, 0xef7d, 0x8c51, 0xad55  /* Codes 0-7 */
+};
+
+/* 8-bit color lookups.  NOTE:  This is really dumb!  The lookup index is 8-bits and it used
+ * to lookup an 8-bit value.  There is no savings in that!  It would be better to just put
+ * the 8-bit color/greyscale value in the run-length encoded image and save the cost of these
+ * pointless lookups.  But these p;ointless lookups do make the logic compatible with the
+ * 16- and 24-bit types.
+ */
+
+#elif CONFIG_NXWIDGETS_BPP == 8
+#  ifdef CONFIG_NXWIDGETS_GREYSCALE
+
+static const uint8_t g_calculatorNormalLut[BITMAP_NLUTCODES] =
+{
+  0xfc, 0xba, 0xf8, 0x8a, 0x4b, 0xe8, 0x64, 0x90  /* Codes 0-7 */
+};
+
+static const uint8_t g_calculatorBrightlLut[BITMAP_NLUTCODES] =
+{
+  0xff, 0xcb, 0xf9, 0xa6, 0x77, 0xed, 0x8a, 0xab  /* Codes 0-7 */
+};
+
+#  else /* CONFIG_NXWIDGETS_GREYSCALE */
+
+static const nxgl_mxpixel_t g_calculatorNormalLut[BITMAP_NLUTCODES] =
+{
+  0xff, 0xb7, 0xff, 0x73, 0x2a, 0xff, 0x6d, 0x92  /* Codes 0-7 */
+};
+
+static const nxgl_mxpixel_t g_calculatorBrightlLut[BITMAP_NLUTCODES] =
+{
+  0xff, 0xdb, 0xff, 0x97, 0x6e, 0xff, 0x92, 0xb6  /* Codes 0-7 */
+};
+
+#  endif /* CONFIG_NXWIDGETS_GREYSCALE */
+#else
+# error "Unsupport pixel format"
+#endif
+
+static const struct NXWidgets::SRlePaletteBitmapEntry g_calculatorRleEntries[] =
+{
+  { 23,   0}, {  1,   1},                                                                          /* Row 0 */
+  {  1,   0}, { 21,   1}, {  1,   2}, {  1,   1},                                                  /* Row 1 */
+  {  1,   0}, {  1,   1}, { 19,   3}, {  1,   4}, {  1,   0}, {  1,   1},                          /* Row 2 */
+  {  1,   0}, {  1,   1}, { 19,   3}, {  1,   4}, {  1,   0}, {  1,   1},                          /* Row 3 */
+  {  1,   0}, {  1,   1}, { 19,   3}, {  1,   4}, {  1,   0}, {  1,   1},                          /* Row 4 */
+  {  1,   0}, {  1,   1}, { 19,   3}, {  1,   4}, {  1,   0}, {  1,   1},                          /* Row 5 */
+  {  1,   0}, {  1,   1}, { 19,   3}, {  1,   4}, {  1,   0}, {  1,   1},                          /* Row 6 */
+  {  1,   2}, {  1,   1}, { 20,   4}, {  1,   0}, {  1,   1},                                      /* Row 7 */
+  {  1,   2}, {  1,   1}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6},  /* Row 8 */
+  {  4,   5}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 9 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 10 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 11 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, { 20,   6}, {  1,   0}, {  1,   1},                                      /* Row 12 */
+  {  1,   0}, {  1,   1}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6},  /* Row 13 */
+  {  4,   5}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 14 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 15 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 16 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   0}, {  1,   1}, { 20,   6}, {  1,   0}, {  1,   1},                                      /* Row 17 */
+  {  1,   2}, {  1,   1}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6}, {  4,   5}, {  1,   6},  /* Row 18 */
+  {  4,   5}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   2}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 19 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   2}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 20 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   2}, {  1,   1}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6},  /* Row 21 */
+  {  1,   5}, {  3,   7}, {  1,   6}, {  1,   5}, {  3,   7}, {  1,   6}, {  1,   0}, {  1,   1},
+  {  1,   2}, {  1,   1}, { 20,   6}, {  1,   0}, {  1,   1},                                      /* Row 22 */
+  { 23,   0}, {  1,   1},                                                                          /* Row 23 */
+  { 24,   1}                                                                                       /* Row 24 */
+};
+
+/********************************************************************************************
+ * Public Bitmap Structure Defintions
+ ********************************************************************************************/
+
+const struct NXWidgets::SRlePaletteBitmap NxWM::g_calculatorBitmap =
+{
+  CONFIG_NXWIDGETS_BPP,     // bpp    - Bits per pixel
+  CONFIG_NXWIDGETS_FMT,     // fmt    - Color format
+  BITMAP_NLUTCODES,         // nlut   - Number of colors in the lLook-Up Table (LUT)
+  BITMAP_NCOLUMNS,          // width  - Width in pixels 
+  BITMAP_NROWS,             // height - Height in rows
+  {                         // lut    - Pointer to the beginning of the Look-Up Table (LUT)
+    g_calculatorNormalLut,  //          Index 0: Unselected LUT
+    g_calculatorBrightlLut, //          Index 1: Selected LUT
+  },
+  g_calculatorRleEntries    // data   - Pointer to the beginning of the RLE data
+};