sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4747 42af7a65-404d-4744-a932-0658087f49c3
This commit is contained in:
patacongo 2012-05-18 23:08:34 +00:00
parent daa19c57c6
commit ad63005d6a
29 changed files with 602 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
UnitTests/nxwm/main.cxx
View File

@ -46,9 +46,12 @@
#include "ctaskbar.hxx"
#include "cstartwindow.hxx"
#include "cnxconsole.hxx"
#ifdef CONFIG_NXWM_TOUCHSCREEN
# include "ctouchscreen.hxx"
# include "ccalibration.hxx"
#include "cnxconsole.hxx"
#endif
/////////////////////////////////////////////////////////////////////////////
// Pre-processor Definitions
@ -67,11 +70,20 @@
#ifdef CONFIG_HAVE_FILENAME
# define showTestStepMemory(msg) \
_showTestStepMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
#endif
#ifdef CONFIG_NXWIDGET_MEMMONITOR
# ifdef CONFIG_HAVE_FILENAME
# define showTestCaseMemory(msg) \
_showTestCaseMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
# define showTestMemory(msg) \
_showTestMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
# endif
#else
# define initMemoryUsage()
# define showTestCaseMemory(msg)
# define showTestMemory(msg)
#endif
/////////////////////////////////////////////////////////////////////////////
// Private Types
@ -85,9 +97,11 @@ struct SNxWmTest
NxWM::CTouchscreen *touchscreen; // The touchscreen
struct NxWM::SCalibrationData calibData; // Calibration data
#endif
#ifdef CONFIG_NXWIDGET_MEMMONITOR
unsigned int mmInitial; // Initial memory usage
unsigned int mmStep; // Memory Usage at beginning of test step
unsigned int mmSubStep; // Memory Usage at beginning of test sub-step
#endif
};
/////////////////////////////////////////////////////////////////////////////
@ -112,6 +126,7 @@ extern "C" int MAIN_NAME(int argc, char *argv[]);
// Name: updateMemoryUsage
/////////////////////////////////////////////////////////////////////////////
#ifdef CONFIG_NXWIDGET_MEMMONITOR
#ifdef CONFIG_HAVE_FILENAME
static void updateMemoryUsage(unsigned int *previous,
FAR const char *file, int line,
@ -145,11 +160,13 @@ static void updateMemoryUsage(unsigned int *previous,
*previous = mmcurrent.uordblks;
}
#endif
/////////////////////////////////////////////////////////////////////////////
// Name: showTestCaseMemory
/////////////////////////////////////////////////////////////////////////////
#ifdef CONFIG_NXWIDGET_MEMMONITOR
#ifdef CONFIG_HAVE_FILENAME
static void _showTestCaseMemory(FAR const char *file, int line, FAR const char *msg)
{
@ -163,11 +180,13 @@ static void showTestCaseMemory(FAR const char *msg)
g_nxwmtest.mmSubStep = g_nxwmtest.mmInitial;
}
#endif
#endif
/////////////////////////////////////////////////////////////////////////////
// Name: showTestMemory
/////////////////////////////////////////////////////////////////////////////
#ifdef CONFIG_NXWIDGET_MEMMONITOR
#ifdef CONFIG_HAVE_FILENAME
static void _showTestMemory(FAR const char *file, int line, FAR const char *msg)
{
@ -179,11 +198,13 @@ static void showTestMemory(FAR const char *msg)
updateMemoryUsage(&g_nxwmtest.mmInitial, msg);
}
#endif
#endif
/////////////////////////////////////////////////////////////////////////////
// Name: initMemoryUsage
/////////////////////////////////////////////////////////////////////////////
#ifdef CONFIG_NXWIDGET_MEMMONITOR
static void initMemoryUsage(void)
{
struct mallinfo mmcurrent;
@ -198,6 +219,7 @@ static void initMemoryUsage(void)
g_nxwmtest.mmStep = mmcurrent.uordblks;
g_nxwmtest.mmSubStep = mmcurrent.uordblks;
}
#endif
/////////////////////////////////////////////////////////////////////////////
// Name: cleanup
@ -361,7 +383,7 @@ static bool startWindowManager(void)
return false;
}
showTestCaseMemory("AstartWindowManager: fter starting the window manager");
showTestCaseMemory("startWindowManager: After starting the window manager");
return true;
}
@ -497,12 +519,16 @@ static bool createNxConsole(void)
#ifdef CONFIG_HAVE_FILENAME
void _showTestStepMemory(FAR const char *file, int line, FAR const char *msg)
{
#ifdef CONFIG_NXWIDGET_MEMMONITOR
updateMemoryUsage(&g_nxwmtest.mmSubStep, file, line, msg);
#endif
}
#else
void showTestStepMemory(FAR const char *msg)
{
#ifdef CONFIG_NXWIDGET_MEMMONITOR
updateMemoryUsage(&g_nxwmtest.mmSubStep, msg);
#endif
}
#endif
@ -608,19 +634,23 @@ int MAIN_NAME(int argc, char *argv[])
}
#endif
// Wait a little bit for the display to stabilize. The simulation pressing of
// Wait a little bit for the display to stabilize. Then simulate pressing of
// the 'start window' icon in the task bar
#ifndef CONFIG_NXWM_TOUCHSCREEN
sleep(2);
g_nxwmtest.taskbar->clickIcon(0);
g_nxwmtest.taskbar->clickIcon(0, true);
usleep(500*1000);
g_nxwmtest.taskbar->clickIcon(0, false);
showTestCaseMemory(MAIN_STRING "After clicking the start window icon");
// Wait bit to see the result of the button press. The press the first icon
// Wait bit to see the result of the button press. Then press the first icon
// in the start menu. That should be the NxConsole icon.
sleep(2);
g_nxwmtest.startwindow->clickIcon(0);
g_nxwmtest.startwindow->clickIcon(0, true);
usleep(500*1000);
g_nxwmtest.startwindow->clickIcon(0, false);
showTestCaseMemory(MAIN_STRING "After clicking the NxConsole icon");
#endif

9
libnxwidgets/include/ibitmap.hxx
View File

@ -102,6 +102,15 @@ namespace NXWidgets
class IBitmap
{
public:
/**
* A virtual destructor is required in order to override the IBitmap
* destructor. We do this because if we delete IBitmap, we want the
* destructor of the class that inherits from IBitmap to run, not this
* one.
*/
virtual ~IBitmap(void) { }
/**
* Get the bitmap's color format.
*

8
libnxwidgets/include/ilistbox.hxx
View File

@ -102,6 +102,14 @@ namespace NXWidgets
class IListBox
{
public:
/**
* A virtual destructor is required in order to override the IListBox
* destructor. We do this because if we delete IListBox, we want the
* destructor of the class that inherits from IListBox to run, not this
* one.
*/
virtual ~IListBox(void) { }
/**
* Add a new option to the widget using default colors.

9
libnxwidgets/include/ilistdataeventhandler.hxx
View File

@ -103,6 +103,15 @@ namespace NXWidgets
class IListDataEventHandler
{
public:
/**
* A virtual destructor is required in order to override the IListDataEventHandler
* destructor. We do this because if we delete IListDataEventHandler, we want the
* destructor of the class that inherits from IListDataEventHandler to run, not this
* one.
*/
virtual ~IListDataEventHandler(void) { }
/**
* Handle data changes.
*

8
libnxwidgets/include/inxwindow.hxx
View File

@ -79,6 +79,14 @@ namespace NXWidgets
class INxWindow
{
public:
/**
* A virtual destructor is required in order to override the INxWindow
* destructor. We do this because if we delete INxWindow, we want the
* destructor of the class that inherits from INxWindow to run, not this
* one.
*/
virtual ~INxWindow(void) { }
/**
* Creates a new window. Window creation is separate from

9
libnxwidgets/include/iscrollable.hxx
View File

@ -102,6 +102,15 @@ namespace NXWidgets
class IScrollable
{
public:
/**
* A virtual destructor is required in order to override the IScrollable
* destructor. We do this because if we delete IScrollable, we want the
* destructor of the class that inherits from IScrollable to run, not this
* one.
*/
virtual ~IScrollable(void) { }
/**
* Gets the x coordinate of the virtual canvas.
*

8
libnxwidgets/include/islider.hxx
View File

@ -99,6 +99,14 @@ namespace NXWidgets
class ISlider
{
public:
/**
* A virtual destructor is required in order to override the ISlider
* destructor. We do this because if we delete ISlider, we want the
* destructor of the class that inherits from ISlider to run, not this
* one.
*/
virtual ~ISlider(void) { }
/**
* Get the smallest value that the slider can represent.

8
libnxwidgets/include/itextbox.hxx
View File

@ -115,6 +115,14 @@ namespace NXWidgets
class ITextBox
{
public:
/**
* A virtual destructor is required in order to override the ITextBox
* destructor. We do this because if we delete ITextBox, we want the
* destructor of the class that inherits from ITextBox to run, not this
* one.
*/
virtual ~ITextBox(void) { }
/**
* Sets the cursor display mode.

12
nxwm/Makefile
View File

@ -41,10 +41,16 @@ NXWIDGETDIR := $(NXWMDIR)/../libnxwidgets
ASRCS =
CSRCS =
# Window Manager
CXXSRCS = capplicationwindow.cxx ccalibration.cxx cfullscreenwindow.cxx
CXXSRCS += cnxconsole.cxx cstartwindow.cxx ctaskbar.cxx ctouchscreen.cxx
CXXSRCS += cwindowcontrol.cxx
CXXSRCS = capplicationwindow.cxx cfullscreenwindow.cxx cnxconsole.cxx
CXXSRCS += cstartwindow.cxx ctaskbar.cxx cwindowmessenger.cxx
ifeq ($(CONFIG_NXWM_TOUCHSCREEN),y)
CXXSRCS += ccalibration.cxx ctouchscreen.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

BIN
nxwm/doc/NxWM-ThreadingModel.ppt
View File

Binary file not shown.

30
nxwm/include/capplicationwindow.hxx
View File

@ -44,6 +44,7 @@
#include "cnxtkwindow.hxx"
#include "cnxtoolbar.hxx"
#include "cwidgetcontrol.hxx"
#include "cwidgeteventargs.hxx"
#include "cwidgeteventhandler.hxx"
#include "cimage.hxx"
@ -151,12 +152,19 @@ namespace NxWM
NXWidgets::INxWindow *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 *getWindowControl(void) const ;
NXWidgets::CWidgetControl *getWidgetControl(void) const;
/**
* Block further activity on this window in preparation for window
* shutdown.
*/
void block(void);
/**
* Set the window label
@ -195,21 +203,25 @@ namespace NxWM
}
/**
* Simulate a mouse click on the minimize icon. This inline 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 clickMinimizeIcon(int index);
void clickMinimizePosition(bool click);
#endif
/**
* Simulate a mouse click on the stop applicaiton icon. This inline 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 clickStopIcon(int index);
void clickStopIcon(bool click);
#endif
};
}

13
nxwm/include/ccalibration.hxx
View File

@ -52,6 +52,7 @@
#include "ctaskbar.hxx"
#include "iapplication.hxx"
#include "cfullscreenwindow.hxx"
#include "cwindowmessenger.hxx"
/****************************************************************************
* Pre-processor Definitions
@ -143,6 +144,7 @@ namespace NxWM
* CCalibration state data
*/
CWindowMessenger m_messenger; /**< Window event handler/messenger */
CTaskbar *m_taskbar; /**< The taskbar (used to terminate calibration) */
CFullScreenWindow *m_window; /**< The window for the calibration display */
CTouchscreen *m_touchscreen; /**< The touchscreen device */
@ -289,6 +291,17 @@ namespace NxWM
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

30
nxwm/include/cfullscreenwindow.hxx
View File

@ -43,6 +43,7 @@
#include <nuttx/config.h>
#include "cnxwindow.hxx"
#include "cwidgetcontrol.hxx"
#include "iapplicationwindow.hxx"
@ -115,12 +116,19 @@ namespace NxWM
NXWidgets::INxWindow *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 *getWindowControl(void) const;
NXWidgets::CWidgetControl *getWidgetControl(void) const;
/**
* Block further activity on this window in preparation for window
* shutdown.
*/
void block(void);
/**
* Set the window label
@ -147,21 +155,25 @@ namespace NxWM
void registerCallbacks(IApplicationCallback *callback);
/**
* Simulate a mouse click on the minimize icon. This inline 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 clickMinimizeIcon(int index);
void clickMinimizePosition(bool click);
#endif
/**
* Simulate a mouse click on the stop applicaiton icon. This inline 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 clickStopIcon(int index);
void clickStopIcon(bool click);
#endif
};
}

13
nxwm/include/cnxconsole.hxx
View File

@ -49,6 +49,7 @@
#include "iapplication.hxx"
#include "capplicationwindow.hxx"
#include "ctaskbar.hxx"
#include "cwindowmessenger.hxx"
/****************************************************************************
* Pre-Processor Definitions
@ -78,6 +79,7 @@ namespace NxWM
class CNxConsole : public IApplication, private IApplicationCallback
{
private:
CWindowMessenger m_messenger; /**< Window event handler/messenger */
CTaskbar *m_taskbar; /**< Reference to the "parent" taskbar */
CApplicationWindow *m_window; /**< Reference to the application window */
NXCONSOLE m_nxcon; /**< NxConsole handle */
@ -166,6 +168,17 @@ namespace NxWM
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

46
nxwm/include/cstartwindow.hxx
View File

@ -48,6 +48,7 @@
#include "iapplication.hxx"
#include "capplicationwindow.hxx"
#include "cwindowmessenger.hxx"
/****************************************************************************
* Pre-Processor Definitions
@ -115,6 +116,7 @@ namespace NxWM
* CStartWindow state data
*/
CWindowMessenger m_messenger; /**< Window event handler/messenger */
CTaskbar *m_taskbar; /**< Reference to the "parent" taskbar */
CApplicationWindow *m_window; /**< Reference to the application window */
TNxArray<struct SStartWindowSlot> m_slots; /**< List of apps in the start window */
@ -138,8 +140,8 @@ namespace NxWM
* 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.
@ -235,6 +237,17 @@ namespace NxWM
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)
@ -275,32 +288,15 @@ namespace NxWM
bool addApplication(IApplicationFactory *app);
/**
* Simulate a mouse click on the icon at index. This inline method is only
* used during automated testing of NxWM.
* 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)
inline void clickIcon(int index)
{
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 the image at its center
image->click(imagePos.x + (imageSize.w >> 1), imagePos.y + (imageSize.h >> 1));
}
}
void clickIcon(int index, bool click);
#endif
};
}

37
nxwm/include/ctaskbar.hxx
View File

@ -110,12 +110,12 @@ namespace NxWM
/**
* Create a raw window.
*
* 1) Create a dumb CWindowControl instance
* 2) Pass the dumb CWindowControl instance to the window constructor
* that inherits from INxWindow. This will "smarten" the CWindowControl
* 1) Create a dumb NXWidgets::CWidgetControl instance
* 2) Pass the dumb NXWidgets::CWidgetControl instance to the window constructor
* that inherits from INxWindow. This will "smarten" the NXWidgets::CWidgetControl
* instance with some window knowlede
* 3) Call the open() method on the window to display the window.
* 4) After that, the fully smartened CWindowControl instance can
* 4) After that, the fully smartened NXWidgets::CWidgetControl instance can
* be used to generate additional widgets by passing it to the
* widget constructor
*/
@ -398,32 +398,15 @@ namespace NxWM
void getDisplaySize(FAR struct nxgl_size_s &size);
/**
* Simulate a mouse click on the icon at index. This inline method is only
* used during automated testing of NxWM.
* 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)
inline void clickIcon(int index)
{
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 the image at its center
image->click(imagePos.x + (imageSize.w >> 1), imagePos.y + (imageSize.h >> 1));
}
}
void clickIcon(int index, bool click);
#endif
};
}

27
nxwm/include/cwindowcontrol.hxx → nxwm/include/cwindowmessenger.hxx
View File

@ -1,5 +1,5 @@
/****************************************************************************
* NxWidgets/nxwm/include/cwindowcontrol.hxx
* NxWidgets/nxwm/include/cwindowmessenger.hxx
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
@ -33,8 +33,8 @@
*
****************************************************************************/
#ifndef __INCLUDE_CWINDOWCONTROL_HXX
#define __INCLUDE_CWINDOWCONTROL_HXX
#ifndef __INCLUDE_CWINDOWMESSENGER_HXX
#define __INCLUDE_CWINDOWMESSENGER_HXX
/****************************************************************************
* Included Files
@ -70,12 +70,11 @@ namespace NxWM
class IApplication;
/**
* The class CWindowControl integrates the widget control with some special
* The class CWindowMessenger integrates the widget control with some special
* handling of mouse and keyboard inputs neesed by NxWM
*/
class CWindowControl : public NXWidgets::CWidgetControl,
private NXWidgets::CWindowEventHandler
class CWindowMessenger : public NXWidgets::CWindowEventHandler
{
private:
mqd_t m_mqd; /**< Message queue descriptor used to commincate with the
@ -102,24 +101,20 @@ namespace NxWM
public:
/**
* 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(FAR const NXWidgets::CWidgetStyle *style = (const NXWidgets::CWidgetStyle *)NULL);
CWindowMessenger(void);
/**
* Destructor.
* CWindowMessenger Destructor.
*/
~CWindowControl(void);
~CWindowMessenger(void);
/**
* 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.
@ -130,4 +125,4 @@ namespace NxWM
}
#endif // __cplusplus
#endif // __INCLUDE_CWINDOWCONTROL_HXX
#endif // __INCLUDE_CWINDOWMESSENGER_HXX

29
nxwm/include/iapplication.hxx
View File

@ -45,8 +45,7 @@
#include "cnxstring.hxx"
#include "ibitmap.hxx"
#include "cwindowcontrol.hxx"
#include "capplicationwindow.hxx"
#include "iapplicationwindow.hxx"
/****************************************************************************
* Pre-Processor Definitions
@ -93,18 +92,6 @@ namespace NxWM
virtual IApplicationWindow *getWindow(void) const = 0;
/**
* Get the window widget control.
*
* @return The widget control of the underlying window instance.
*/
virtual inline CWindowControl *getWindowControl(void) const
{
IApplicationWindow *window = getWindow();
return window->getWindowControl();
}
/**
* Get the icon associated with the application
*
@ -132,11 +119,23 @@ namespace NxWM
virtual bool run(void) = 0;
/**
* Stop the application.
* Stop the application, put all widgets in a deactivated/disabled state
* and wait to see what happens next.
*/
virtual void stop(void) = 0;
/**
* 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.
*/
virtual void destroy(void) = 0;
/**
* The application window is hidden (either it is minimized or it is
* maximized, but not at the top of the hierarchy

41
nxwm/include/iapplicationwindow.hxx
View File

@ -44,8 +44,7 @@
#include "inxwindow.hxx"
#include "cnxstring.hxx"
#include "cwindowcontrol.hxx"
#include "cwidgetcontrol.hxx"
/****************************************************************************
* Pre-Processor Definitions
@ -88,6 +87,15 @@ namespace NxWM
class IApplicationWindow
{
public:
/**
* A virtual destructor is required in order to override the IApplicationWindow
* destructor. We do this because if we delete IApplicationWindow, we want the
* destructor of the class that inherits from IApplicationWindow to run, not this
* one.
*/
virtual ~IApplicationWindow(void) { }
/**
* Initialize window. Window initialization is separate from
* object instantiation so that failures can be reported.
@ -119,12 +127,19 @@ namespace NxWM
virtual NXWidgets::INxWindow *getWindow(void) const = 0;
/**
* 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
*/
virtual CWindowControl *getWindowControl(void) const = 0;
virtual NXWidgets::CWidgetControl *getWidgetControl(void) const = 0;
/**
* Block further activity on this window in preparation for window
* shutdown.
*/
virtual void block(void) = 0;
/**
* Set the window label
@ -151,21 +166,25 @@ namespace NxWM
virtual void registerCallbacks(IApplicationCallback *callback) = 0;
/**
* Simulate a mouse click on the minimize icon. This inline 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)
virtual void clickMinimizeIcon(int index) = 0;
virtual void clickMinimizePosition(bool click) = 0;
#endif
/**
* Simulate a mouse click on the stop applicaiton icon. This inline 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)
virtual void clickStopIcon(int index) = 0;
virtual void clickStopIcon(bool click) = 0;
#endif
};
}

2
nxwm/include/nxwmconfig.hxx
View File

@ -264,7 +264,7 @@
* CONFIG_NXWM_STARTWINDOW_HSPACING - Horizontal spacing. Default: 2 rows
* CONFIG_NXWM_STARTWINDOW_ICON - The glyph to use as the start window icon
* CONFIG_NXWM_STARTWINDOW_MQNAME - The well known name of the message queue
* Used to communicated from CWindowControl tothe start window thread.
* Used to communicated from CWindowMessenger to the start window thread.
* Default: "/dev/nxwm"
* CONFIG_NXWM_STARTWINDOW_MXMSGS - The maximum number of messages to queue
* before blocking. Defualt 32

65
nxwm/src/capplicationwindow.cxx
View File

@ -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
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,11 +528,19 @@ 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
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

30
nxwm/src/ccalibration.cxx
View File

@ -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
@ -199,6 +209,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)

40
nxwm/src/cfullscreenwindow.cxx
View File

@ -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

35
nxwm/src/cnxconsole.cxx
View File

@ -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,14 +152,16 @@ 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;
}
}
/**
* Each implementation of IApplication must provide a method to recover
@ -321,6 +328,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

88
nxwm/src/cstartwindow.cxx
View File

@ -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;
}
// 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
@ -404,6 +433,47 @@ bool CStartWindow::addApplication(IApplicationFactory *app)
return true;
}
/**
* 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.

88
nxwm/src/ctaskbar.cxx
View File

@ -47,7 +47,6 @@
#include "cwidgetcontrol.hxx"
#include "cnxtkwindow.hxx"
#include "cwindowcontrol.hxx"
#include "ctaskbar.hxx"
/********************************************************************************************
@ -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();
@ -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
@ -673,6 +704,47 @@ void CTaskbar::getDisplaySize(FAR struct nxgl_size_s &size)
rect.getSize(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.
*
@ -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.

43
nxwm/src/cwindowcontrol.cxx → nxwm/src/cwindowmessenger.cxx
View File

@ -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()