dark0707
/
px4-firmware
forked from Archive/PX4-Autopilot
1
0
Fork 0
Code Pull Requests 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 

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@4747 7fd9a85b-ad96-42d3-883c-3090e2eb8679
This commit is contained in:
patacongo 2012-05-18 23:08:34 +00:00
parent ae3a9e76b5
commit 2acf00c2cd
33 changed files with 621 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
NxWidgets/UnitTests/nxwm/main.cxx
View File

@ -46,10 +46,13 @@
#include "ctaskbar.hxx"
#include "cstartwindow.hxx"
#include "ctouchscreen.hxx"
#include "ccalibration.hxx"
#include "cnxconsole.hxx"
#ifdef CONFIG_NXWM_TOUCHSCREEN
# include "ctouchscreen.hxx"
# include "ccalibration.hxx"
#endif
/////////////////////////////////////////////////////////////////////////////
// Pre-processor Definitions
/////////////////////////////////////////////////////////////////////////////
@ -67,10 +70,19 @@
#ifdef CONFIG_HAVE_FILENAME
# define showTestStepMemory(msg) \
_showTestStepMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
# define showTestCaseMemory(msg) \
_showTestCaseMemory((FAR const char*)__FILE__, (int)__LINE__, msg)
# define showTestMemory(msg) \
_showTestMemory((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
/////////////////////////////////////////////////////////////////////////////
@ -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
NxWidgets/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
NxWidgets/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
NxWidgets/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
NxWidgets/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
NxWidgets/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
NxWidgets/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
NxWidgets/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.

2
NxWidgets/libnxwidgets/src/ccallback.cxx
View File

@ -36,7 +36,7 @@
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>

2
NxWidgets/libnxwidgets/src/cnxwindow.cxx
View File

@ -36,7 +36,7 @@
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>

12
NxWidgets/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
NxWidgets/nxwm/doc/NxWM-ThreadingModel.ppt
View File

Binary file not shown.

30
NxWidgets/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
NxWidgets/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
NxWidgets/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
};
}

21
NxWidgets/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,10 +79,11 @@ namespace NxWM
class CNxConsole : public IApplication, private IApplicationCallback
{
private:
CTaskbar *m_taskbar; /**< Reference to the "parent" taskbar */
CApplicationWindow *m_window; /**< Reference to the application window */
NXCONSOLE m_nxcon; /**< NxConsole handle */
pid_t m_pid; /**< Task ID of the NxConsole thread */
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 */
pid_t m_pid; /**< Task ID of the NxConsole thread */
/**
* This is the NxConsole task. This function first redirects output to the
@ -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

56
NxWidgets/nxwm/include/cstartwindow.hxx
View File

@ -48,6 +48,7 @@
#include "iapplication.hxx"
#include "capplicationwindow.hxx"
#include "cwindowmessenger.hxx"
/****************************************************************************
* Pre-Processor Definitions
@ -115,11 +116,12 @@ namespace NxWM
* CStartWindow state data
*/
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 */
struct nxgl_size_s m_iconSize; /**< A box big enough to hold the largest icon */
pid_t m_taskId; /**< ID of the start window task */
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 */
struct nxgl_size_s m_iconSize; /**< A box big enough to hold the largest icon */
pid_t m_taskId; /**< ID of the start window task */
/**
* This is the start window task. This function receives window events from
@ -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
NxWidgets/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
NxWidgets/nxwm/include/cwindowcontrol.hxx → NxWidgets/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
NxWidgets/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
NxWidgets/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
NxWidgets/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

73
NxWidgets/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
m_minimizeImage->click(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
if (click)
{
m_minimizeImage->click(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
}
else
{
m_minimizeImage->release(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
}
}
#endif
/**
* Simulate a mouse click on the stop applicaiton icon. This method is only
* used during automated testing of NxWM.
* Simulate a mouse click or release on the stop icon. This method
* is only available for automated testing of NxWM.
*
* @param click. True to click; false to release;
*/
#if defined(CONFIG_NXWM_UNITTEST) && !defined(CONFIG_NXWM_TOUCHSCREEN)
void CApplicationWindow::clickStopIcon(int index)
void CApplicationWindow::clickStopIcon(bool click)
{
// The stop icon will not be available for "persistent" applications
@ -501,10 +528,18 @@ void CApplicationWindow::clickStopIcon(int index)
struct nxgl_point_s imagePos;
m_stopImage->getPos(imagePos);
// And click the image at its center
// And click or release the image at its center
m_stopImage->click(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
if (click)
{
m_stopImage->click(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
}
else
{
m_stopImage->release(imagePos.x + (imageSize.w >> 1),
imagePos.y + (imageSize.h >> 1));
}
}
}
#endif

30
NxWidgets/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
NxWidgets/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

37
NxWidgets/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,13 +152,15 @@ CNxConsole::~CNxConsole(void)
stop();
// Remove ourself from the window callback
NXWidgets::CWidgetControl *control = m_window->getWidgetControl();
control->removeWindowEventHandler(&m_messenger);
// Although we didn't create it, we are responsible for deleting the
// application window
if (m_window)
{
delete m_window;
}
delete m_window;
}
/**
@ -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

90
NxWidgets/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;
}
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.

100
NxWidgets/nxwm/src/ctaskbar.cxx
View File

@ -47,7 +47,6 @@
#include "cwidgetcontrol.hxx"
#include "cnxtkwindow.hxx"
#include "cwindowcontrol.hxx"
#include "ctaskbar.hxx"
/********************************************************************************************
@ -68,11 +67,11 @@ using namespace NxWM;
CTaskbar::CTaskbar(void)
{
m_taskbar = (NXWidgets::CNxWindow *)0;
m_background = (NXWidgets::CNxWindow *)0;
m_backImage = (NXWidgets::CImage *)0;
m_topApp = (IApplication *)0;
m_started = false;
m_taskbar = (NXWidgets::CNxWindow *)0;
m_background = (NXWidgets::CNxWindow *)0;
m_backImage = (NXWidgets::CImage *)0;
m_topApp = (IApplication *)0;
m_started = false;
}
/**
@ -81,6 +80,9 @@ CTaskbar::CTaskbar(void)
CTaskbar::~CTaskbar(void)
{
// The disconnect,putting the instance back in the state that it
// was before it was constructed.
disconnect();
}
@ -107,7 +109,8 @@ bool CTaskbar::connect(void)
}
/**
* Disconnect from the server
* Disconnect from the server. This method restores the taskbar to the
* same state that it was in when it was constructed.
*/
void CTaskbar::disconnect(void)
@ -141,6 +144,7 @@ void CTaskbar::disconnect(void)
// Then delete the task bar window
delete m_taskbar;
m_taskbar = (NXWidgets::CNxWindow *)0;
}
if (m_background)
@ -157,8 +161,22 @@ void CTaskbar::disconnect(void)
// Then delete the background
delete m_background;
m_background = (NXWidgets::CNxWindow *)0;
}
// Delete the background image
if (m_backImage)
{
delete m_backImage;
m_backImage = (NXWidgets::CImage *)0;
}
// Reset other variables
m_topApp = (IApplication *)0;
m_started = false;
// And disconnect from the server
CNxServer::disconnect();
@ -279,7 +297,9 @@ bool CTaskbar::startWindowManager(void)
continue;
}
// Hide all appliations except for the top application
// Hide all applications except for the top application. NOTE:
// topIndex may still be -1, meaning that there is no application
// and that all applications should be hidden.
if (i != topIndex)
{
@ -303,6 +323,17 @@ bool CTaskbar::startWindowManager(void)
i++;
}
// If there is no top appliation (i.e., no applications or all applications
// are minimized), then draw the background image
if (!m_topApp)
{
if (!redrawBackgroundWindow())
{
return false;
}
}
// Draw the taskbar. It will be draw at a higher level than the application.
return redrawTaskbarWindow();
@ -418,7 +449,7 @@ bool CTaskbar::startApplication(IApplication *app, bool minimized)
{
// Get the widget control associated with the task bar window
NXWidgets::CWidgetControl *control = m_taskbar->getWidgetControl();
NXWidgets::CWidgetControl *control = m_taskbar->getWidgetControl();
// Get the bitmap icon that goes with this application
@ -633,10 +664,10 @@ bool CTaskbar::stopApplication(IApplication *app)
}
}
// destroy the application
// Destroy the application (actually, this just sets up the application for
// later destruction.
CWindowControl *control = app->getWindowControl();
control->destroy(app);
app->destroy();
// Re-draw the new top, non-minimized application
@ -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
NxWidgets/nxwm/src/cwindowcontrol.cxx → NxWidgets/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()

14
nuttx/configs/sim/nxwm/defconfig
View File

@ -162,6 +162,7 @@ CONFIG_SIM_TOUCHSCREEN=n
# the worker thread. Default: 4
# CONFIG_SCHED_WAITPID - Enable the waitpid() API
# CONFIG_SCHED_ATEXIT - Enabled the atexit() API
# CONFIG_SCHED_ONEXIT - Enabled the on_exit() API
#
#CONFIG_APPS_DIR=
CONFIG_DEBUG=n
@ -195,6 +196,7 @@ CONFIG_SCHED_WORKPERIOD=(50*1000)
CONFIG_SCHED_WORKSTACKSIZE=8192
CONFIG_SCHED_WAITPID=y
CONFIG_SCHED_ATEXIT=n
CONFIG_SCHED_ONEXIT=y
#
# The following can be used to disable categories of
@ -557,11 +559,14 @@ CONFIG_NX_MXCLIENTMSGS=16
# NxWidgets / NxWM
#
# Use all defaults except
# 1. Need an especially big server stack size to work with X
# 2. Make the NxWidgets background color match the NxWM back color
# 3. Taskbar on the left
# 4. Bigger stack for NxConsole
# 1. 32 bits-per-pixel
# 2. Need an especially big server stack size to work with X
# 3. Make the NxWidgets background color match the NxWM back color
# 4. Taskbar on the left
# 5. Bigger stack for NxConsole
# 6. No touchscreen
#
CONFIG_NXWIDGETS_BPP=32
CONFIG_NXWIDGETS_SERVERSTACK=16384
CONFIG_NXWIDGETS_LISTENERSTACK=8192
CONFIG_NXWIDGETS_DEFAULT_BACKGROUNDCOLOR=MKRGB(148,189,215)
@ -571,6 +576,7 @@ CONFIG_NXWIDGETS_DEFAULT_SHADOWEDGECOLOR=MKRGB(35,58,73)
CONFIG_NXWM_TASKBAR_LEFT=y
CONFIG_NXWM_NXCONSOLE_STACKSIZE=8192
CONFIG_NXWM_UNITTEST=y
CONFIG_NXWM_TOUCHSCREEN=n
#
# NxConsole Configuration Settings:

4
nuttx/configs/stm3240g-eval/nxwm/defconfig
View File

@ -512,7 +512,7 @@ CONFIG_HAVE_LIBM=n
# the worker thread. Default: 4
# CONFIG_SCHED_WAITPID - Enable the waitpid() API
# CONFIG_SCHED_ATEXIT - Enabled the atexit() API
# CONFIG_SCHED_ONEXIT - Enabled the atexit() API
# CONFIG_SCHED_ONEXIT - Enabled the on_exit() API
#
#CONFIG_APPS_DIR=
CONFIG_DEBUG=n
@ -710,7 +710,7 @@ CONFIG_NAME_MAX=32
CONFIG_STDIO_BUFFER_SIZE=64
CONFIG_STDIO_LINEBUFFER=y
CONFIG_NUNGET_CHARS=2
CONFIG_PREALLOC_MQ_MSGS=8
CONFIG_PREALLOC_MQ_MSGS=32
CONFIG_MQ_MAXMSGSIZE=48
CONFIG_MAX_WDOGPARMS=2
CONFIG_PREALLOC_WDOGS=8

2
nuttx/fs/nfs/rpc.h
View File

@ -171,7 +171,7 @@ struct auth_unix
struct rpc_call_header
{
uint32_t rp_xid; /* request transaction id */
int32_t rp_direction; /* call direction (0) */
int32_t rp_direction; /* call direction (0) */
uint32_t rp_rpcvers; /* rpc version (2) */
uint32_t rp_prog; /* program */
uint32_t rp_vers; /* version */

7
nuttx/graphics/nxmu/nx_disconnect.c
View File

@ -90,6 +90,7 @@ void nx_disconnect(NXHANDLE handle)
{
FAR struct nxfe_conn_s *conn = (FAR struct nxfe_conn_s *)handle;
struct nxsvrmsg_s outmsg;
int ret;
/* Inform the server that this client no longer exists */
@ -98,6 +99,10 @@ void nx_disconnect(NXHANDLE handle)
/* We will finish the teardown upon receipt of the DISCONNECTED message */
return nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_s));
ret = nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_s));
if (ret < 0)
{
gdbg("ERROR: nxmu_sendserver() returned %d\n", ret);
}
}