Squashed commit of the following:

apps/graphics/twm4nx:  Fix a bad width calculation.

    apps/graphics/twm4nx:  Debugging resize.  Only partially functional.

    apps/graphics/twm4nx:  Forgot to install the IEventTap instance.  No resizing kind of works, but I can't get out of it!  There is a basic problem in the window needs to be updated for the new size and there is no mechanism in place to do that (at least not with RAM backed windows).

    apps/graphics/twm4nx:  Add missing part of the resize logic.  Initial testing is mixed.  The resize window appears, but nothing else good happens.  No hardfaults though.

    apps/graphics/twm4nx:  This is a complete redesign of the CResize class.  Unverified on initial commit.

    apps/graphics/twm4nx:  Commit of in-progress resize changes
This commit is contained in:
Gregory Nutt 2019-05-15 17:21:25 -06:00
parent e6b642308f
commit 11fc2e4621
10 changed files with 798 additions and 886 deletions

View File

@ -35,13 +35,10 @@ STATUS
needs to be done to have a complete system (hence, it is marked
EXPERIMENTAL). The kinds of things that need to done are:
1. Update some logic that is only fragmentary for things like resizing.
Resizing events should be be generated when user pulls to right,
left, top, bottom, etc. None of that is implemented.
2. Right click should bring up a window list (like the icon manager???)
3. For TWM-like behavior, a window frame and toolbar should be highlighted
1. Right click should bring up a window list (like the icon manager???)
2. For TWM-like behavior, a window frame and toolbar should be highlighted
when the window has focus.
4. A right click on the toolbar should bring up a window-specific menu.
3. A right click on the toolbar should bring up a window-specific menu.
2019-05-02: Some testing progress. The system comes up, connects to and
initializes the VNC window. For some reason, the VNC client breaks the
connection. The server is no longer connected so Twm4Nx constipates and
@ -59,7 +56,7 @@ STATUS
the Icon Manager window to the top of the hierarchy. That latter option
is only meaningful when the desktop is very crowded.
2019-05-13: Added the NxTerm application. If enabled via
CONFIG_TWM4XN_NXTERM, there will now be a "NuttShell" enty in the Main
CONFIG_TWM4XN_NXTERM, there will now be a "NuttShell" entry in the Main
Menu. When pressed, this will bring up an NSH session in a Twm4Nx
window.
2019-05-14: We can now move an icon on the desktop. Includes logic to
@ -67,14 +64,20 @@ STATUS
later is an issue. The background image image widget needs to be
removed; it can occlude a dektop icon. We need to paint the image
directly on the background without the use of a widget.
2019-05-15: Resizing now seems to work correctly in Twm4Nx. It is still
not usable, however. When the window size is extended, the newly exposed
regions must initialized with meaningul data. This is a problem in NX.
Normally, NX generates a redraw callback whenever the application needs
to redraw a region the the display. However, with RAM-backed windows,
all callbacks are suppressed. That is okay in all cases except for a
resize. The missing callback leaves the new window region improperly
initialized.
Issues:
Here are all known issues and features that are missing:
TWM Compatibilities Issues:
1. There is no way to resize a window. Resizing events should be be
generated when user pulls to right, left, top, bottom, etc. None of
that is implemented.
1. Resizing works a little differently in Twm4Nx.
2. Right click should bring up a window list
3. For TWM-like behavior, a window frame and toolbar should be highlighted
when the window has focus.
@ -105,4 +108,5 @@ Issues:
of columns and the size of a generic name string.
Enhancement Ideas:
10. How about a full-screen mode?
10. How about a full-screen mode? This would just be a shortcut for
the existing resize logic.

View File

@ -467,7 +467,7 @@ void CIconWidget::handleUngrabEvent(const NXWidgets::CWidgetEventArgs &e)
msg.obj = (FAR void *)this;
msg.pos.x = e.getX();
msg.pos.y = e.getY();
msg.context = EVENT_CONTEXT_ICON;
msg.context = EVENT_CONTEXT_ICONWIDGET;
msg.handler = (FAR void *)0;
// NOTE that we cannot block because we are on the same thread
@ -505,7 +505,7 @@ void CIconWidget::handleDragEvent(const NXWidgets::CWidgetEventArgs &e)
msg.obj = (FAR void *)this;
msg.pos.x = e.getX();
msg.pos.y = e.getY();
msg.context = EVENT_CONTEXT_ICON;
msg.context = EVENT_CONTEXT_ICONWIDGET;
msg.handler = (FAR void *)0;
// NOTE that we cannot block because we are on the same thread
@ -564,7 +564,7 @@ void CIconWidget::handleClickEvent(const NXWidgets::CWidgetEventArgs &e)
msg.obj = (FAR void *)this;
msg.pos.x = e.getX();
msg.pos.y = e.getY();
msg.context = EVENT_CONTEXT_ICON;
msg.context = EVENT_CONTEXT_ICONWIDGET;
msg.handler = (FAR void *)0;
// NOTE that we cannot block because we are on the same thread

File diff suppressed because it is too large Load Diff

View File

@ -112,7 +112,7 @@ struct SToolbarInfo GToolBarInfo[NTOOLBAR_BUTTONS] =
},
[RESIZE_BUTTON] =
{
&CONFIG_TWM4NX_RESIZE_IMAGE, true, EVENT_TOOLBAR_RESIZE
&CONFIG_TWM4NX_RESIZE_IMAGE, true, EVENT_RESIZE_BUTTON
},
[MINIMIZE_BUTTON] =
{
@ -141,7 +141,6 @@ CWindow::CWindow(CTwm4Nx *twm4nx)
m_toolbar = (FAR NXWidgets::CNxToolbar *)0;
m_windowEvent = (FAR CWindowEvent *)0;
m_minWidth = 1;
m_zoom = ZOOM_NONE;
m_modal = false;
// Events
@ -680,12 +679,6 @@ bool CWindow::event(FAR struct SEventMsg *eventmsg)
}
break;
case EVENT_TOOLBAR_RESIZE: // Toolbar resize button released
{
// REVISIT: Not yet implemented (but don't raise an error)
}
break;
case EVENT_TOOLBAR_TERMINATE: // Toolbar terminate button pressed
if (isIconMgr())
{
@ -701,7 +694,7 @@ bool CWindow::event(FAR struct SEventMsg *eventmsg)
{
twminfo("Close event...\n");
// Send the application specific [pre-]close vent
// Send the application specific [pre-]close event
struct SEventMsg outmsg;
outmsg.eventID = m_appEvents.closeEvent;
@ -1556,11 +1549,21 @@ bool CWindow::isActive(uintptr_t arg)
/**
* Enable/disable dragging
*
* True is provided when (1) isActive() returns false, but (2) a mouse
* report with a left-click is received.
* False is provided when (1) isActive() returns true, but (2) a mouse
* report without a left-click is received.
*
* In the latter is redundant since dropEvent() will be called immediately
* afterward.
*
* @param pos. The mouse position at the time of the click or release
* @param enable. True: Enable dragging
* @param arg The user-argument provided that accompanies the callback
*/
void CWindow::enableMovement(bool enable, uintptr_t arg)
void CWindow::enableMovement(FAR const struct nxgl_point_s &pos,
bool enable, uintptr_t arg)
{
m_clicked = enable;
}

View File

@ -224,6 +224,12 @@ void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos,
twminfo("Mouse input: active=%u\n",
m_tapHandler->isActive(m_tapArg));
// The new mouse position in window relative display coordinates
struct nxgl_point_s mousePos;
mousePos.x = pos->x;
mousePos.y = pos->y;
// STATE LEFT BUTTON ACTION
// active clicked moveEvent
// active released dropEvent
@ -232,22 +238,16 @@ void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos,
if (m_tapHandler->isActive(m_tapArg))
{
// The new movement position in window relative display coordinates
struct nxgl_point_s movePos;
movePos.x = pos->x;
movePos.y = pos->y;
// Is the left button still pressed?
if ((buttons & MOUSE_BUTTON_1) != 0)
{
twminfo("Continue movemenht (%d,%d) buttons=%02x m_tapHandler=%p\n",
movePos.x, movePos.y, buttons, m_tapHandler);
mousePos.x, mousePos.y, buttons, m_tapHandler);
// Yes.. generate a movment event if we have a tap event handler
if (m_tapHandler->moveEvent(movePos, m_tapArg))
if (m_tapHandler->moveEvent(mousePos, m_tapArg))
{
// Skip the input poll until the movment completes
@ -257,15 +257,15 @@ void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos,
else
{
twminfo("Stop movement (%d,%d) buttons=%02x m_tapHandler=%p\n",
movePos.x, movePos.y, buttons, m_tapHandler);
mousePos.x, mousePos.y, buttons, m_tapHandler);
// No.. then the tap is no longer active
m_tapHandler->enableMovement(false, m_tapArg);
m_tapHandler->enableMovement(mousePos, false, m_tapArg);
// Generate a dropEvent
if (m_tapHandler->dropEvent(movePos, m_tapArg))
if (m_tapHandler->dropEvent(mousePos, m_tapArg))
{
// If the drop event was processed then skip the
// input poll until AFTER the movement completes
@ -282,7 +282,7 @@ void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos,
{
// Indicate that we are (or may be) moving
m_tapHandler->enableMovement(true, m_tapArg);
m_tapHandler->enableMovement(mousePos, true, m_tapArg);
twminfo("Start moving (%d,%d) buttons=%02x m_tapHandler=%p\n",
pos->x, pos->y, buttons, m_tapHandler);

View File

@ -53,6 +53,7 @@
#include <nuttx/nx/nxglib.h>
#include "graphics/twm4nx/ctwm4nxevent.hxx"
#include "graphics/twm4nx/cwindowevent.hxx"
/////////////////////////////////////////////////////////////////////////////
// Implementation Classes
@ -69,7 +70,16 @@ namespace Twm4Nx
class CWindow; // Forward reference
struct SEventMsg; // Forward reference
class CResize : protected NXWidgets::CWidgetEventHandler, public CTwm4NxEvent
// The CResize class is, logically, a part of CWindow. It is brought out
// separately only to minimize the complexity of CWindows (and because it
// matches the original partitioning of TWM). The downside is that (1) CWindow
// instances have to be passed un-necessarily, and (2) the precludes the
// possibiity of resizing two window simultaneous. That latter is not
// currenlty supported anyway.
class CResize : protected NXWidgets::CWidgetEventHandler,
protected IEventTap,
public CTwm4NxEvent
{
private:
@ -78,14 +88,15 @@ namespace Twm4Nx
FAR NXWidgets::CNxTkWindow *m_sizeWindow; /**< The resize dimensions window */
FAR NXWidgets::CLabel *m_sizeLabel; /**< Resize dimension label */
FAR CWindow *m_resizeWindow; /**< The window being resized */
struct nxgl_point_s m_origpos; /**< Original position */
struct nxgl_size_s m_origsize; /**< Original size */
struct nxgl_point_s m_dragpos; /**< Dragged position */
struct nxgl_size_s m_dragsize; /**< Dragged size */
struct nxgl_rect_s m_clamp;
struct nxgl_point_s m_delta;
struct nxgl_size_s m_last;
int m_stringWidth; /**< Size of current size string */
FAR IEventTap *m_savedTap; /**< Saved IEventTap */
uintptr_t m_savedTapArg; /**< Saved IEventTap argument */
struct nxgl_point_s m_lastPos; /**< Last window position */
struct nxgl_size_s m_lastSize; /**< Last window size */
struct nxgl_point_s m_mousePos; /**< Last mouse position */
bool m_resizing; /**< Resize in progress */
bool m_resized; /**< The size has changed */
bool m_mouseValid; /**< True: m_mousePos is valid */
volatile bool m_paused; /**< The window was un-clicked */
/**
* Create the size window
@ -105,23 +116,136 @@ namespace Twm4Nx
bool setWindowSize(FAR struct nxgl_size_s *size);
/**
* Begin a window resize operation
* @param ev the event structure (button press)
* @param cwin the TWM window pointer
*/
void startResize(FAR struct SEventMsg *eventmsg, FAR CWindow *cwin);
void menuStartResize(FAR CWindow *cwin);
/**
* Update the size show in the size dimension label.
*
* @param cwin The current window be resized
* @param size The size of the rubber band
*/
void updateSizeLabel(FAR CWindow *cwin, FAR struct nxgl_size_s *size);
void updateSizeLabel(FAR struct nxgl_size_s &size);
/**
* This function handles the EVENT_RESIZE_BUTTON event. It will start a
* new resize sequence. This occurs the first time that the toolbar
* resize icon is clicked.
*
* @param msg. The received NxWidget RESIZE event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool startResize(FAR struct SEventMsg *eventmsg);
/**
* This function handles the EVENT_RESIZE_MOVE event. It will update
* the resize information based on the new mouse position.
*
* @param msg. The received NxWidget RESIZE event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool updateSize(FAR struct SEventMsg *eventmsg);
/**
* This function handles the EVENT_RESIZE_PAUSE event. This occurs
* when the window is un-clicked. Another click in the window
* will resume the resize operation.
*
* @param msg. The received NxWidget RESIZE event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool pauseResize(FAR struct SEventMsg *eventmsg);
/**
* This function handles the EVENT_RESIZE_RESUME event. This occurs
* when the window is clicked while paused.
*
* @param msg. The received NxWidget RESIZE event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool resumeResize(FAR struct SEventMsg *eventmsg);
/**
* This function handles the EVENT_RESIZE_STOP event. It will
* terminate a resize sequence. This occurs when the resize button
* is pressed a second time.
*
* @param msg. The received NxWidget RESIZE event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool endResize(FAR struct SEventMsg *eventmsg);
/**
* This function is called when there is any movement of the mouse or
* touch position that would indicate that the object is being moved.
*
* This function overrides the virtual IEventTap::moveEvent method.
*
* @param pos The current mouse/touch X/Y position.
* @param arg The user-argument provided that accompanies the callback
* @return True: if the movement event was processed; false it was
* ignored. The event should be ignored if there is not actually
* a movement event in progress
*/
bool moveEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg);
/**
* This function is called if the mouse left button is released or
* if the touchscrreen touch is lost. This indicates that the
* resize sequence is complete.
*
* This function overrides the virtual IEventTap::dropEvent method.
*
* @param pos The last mouse/touch X/Y position.
* @param arg The user-argument provided that accompanies the callback
* @return True: if the drop event was processed; false it was
* ignored. The event should be ignored if there is not actually
* a resize event in progress
*/
bool dropEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg);
/**
* Is the tap enabled?
*
* @param arg The user-argument provided that accompanies the callback
* @return True: If the the tap is enabled.
*/
inline bool isActive(uintptr_t arg)
{
return (!m_paused && m_resizing);
}
/**
* Enable/disable the resizing. The disable event will cause resizing
* to be paused.
*
* True is provided when (1) isActive() returns false, but (2) a mouse
* report with a left-click is received.
* False is provided when (1) isActive() returns true, but (2) a mouse
* report without a left-click is received.
*
* In the latter is redundant since dropEvent() will be called immediately
* afterward.
*
* @param pos. The mouse position at the time of the click or release
* @param enable. True: Enable movement
* @param arg The user-argument provided that accompanies the callback
*/
void enableMovement(FAR const struct nxgl_point_s &pos,
bool enable, uintptr_t arg);
public:
@ -139,6 +263,15 @@ namespace Twm4Nx
~CResize(void);
/**
* @return True if resize is in-progress
*/
inline bool resizing(void)
{
return m_resizing;
}
/**
* CResize Initializer. Performs the parts of the CResize construction
* that may fail.
@ -148,84 +281,6 @@ namespace Twm4Nx
bool initialize(void);
/**
* Begin a window resize operation
*
* @param cwin the Twm4Nx window pointer
*/
void addStartResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *pos,
FAR struct nxgl_size_s *size);
/**
* @param cwin The current Twm4Nx window
* @param root The X position in the root window
*/
void menuDoResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *root);
/**
* Resize the window. This is called for each motion event while we are
* resizing
*
* @param cwin The current Twm4Nx window
* @param root The X position in the root window
*/
void doResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *root);
/**
* Finish the resize operation
*/
void endResize(FAR CWindow *cwin);
void menuEndResize(FAR CWindow *cwin);
/**
* Adjust the given width and height to account for the constraints imposed
* by size hints.
*/
// REVISIT: Only used internally. Used to be used to handle prompt
// for window size vs. automatically sizing.
void constrainSize(FAR CWindow *cwin, FAR nxgl_size_s *size);
/**
* Set window sizes.
*
* Special Considerations:
* This routine will check to make sure the window is not completely off the
* display, if it is, it'll bring some of it back on.
*
* The cwin->frame_XXX variables should NOT be updated with the values of
* x,y,w,h prior to calling this routine, since the new values are compared
* against the old to see whether a synthetic ConfigureNotify event should be
* sent. (It should be sent if the window was moved but not resized.)
*
* @param cwin The CWiondow instance
* @param pos The position of the upper-left outer corner of the frame
* @param size The size of the frame window
*/
void setupWindow(FAR CWindow *cwin,
FAR struct nxgl_point_s *pos,
FAR struct nxgl_size_s *size);
/**
* Zooms window to full height of screen or to full height and width of screen.
* (Toggles so that it can undo the zoom - even when switching between fullZoom
* and vertical zoom.)
*
* @param cwin the TWM window pointer
*/
void fullZoom(FAR CWindow *cwin, int flag);
/**
* Handle RESIZE events.
*

View File

@ -66,14 +66,6 @@
#include "graphics/twm4nx/cwindowevent.hxx"
#include "graphics/twm4nx/twm4nx_events.hxx"
/////////////////////////////////////////////////////////////////////////////
// Pre-processor Definitions
/////////////////////////////////////////////////////////////////////////////
// Defines for zooming/unzooming
#define ZOOM_NONE 0
/////////////////////////////////////////////////////////////////////////////
// Implementation Classes
/////////////////////////////////////////////////////////////////////////////

View File

@ -149,8 +149,7 @@ namespace Twm4Nx
FAR void *m_eventObj; /**< Object reference that accompanies events */
nxgl_coord_t m_minWidth; /**< The minimum width of the window */
struct SAppEvents m_appEvents; /**< Application event information */
uint16_t m_zoom; /**< Window zoom: ZOOM_NONE or EVENT_RESIZE_* */
bool m_modal; /**< Window zoom: ZOOM_NONE or EVENT_RESIZE_* */
bool m_modal; /**< Window is in modal state */
// Icon
@ -332,13 +331,23 @@ namespace Twm4Nx
bool isActive(uintptr_t arg);
/**
* Enable/disable the tap
* Enable/disable dragging
*
* @param enable. True: Enable the tap
* True is provided when (1) isActive() returns false, but (2) a mouse
* report with a left-click is received.
* False is provided when (1) isActive() returns true, but (2) a mouse
* report without a left-click is received.
*
* In the latter is redundant since dropEvent() will be called immediately
* afterward.
*
* @param pos. The mouse position at the time of the click or release
* @param enable. True: Enable dragging
* @param arg The user-argument provided that accompanies the callback
*/
void enableMovement(bool enable, uintptr_t arg);
void enableMovement(FAR const struct nxgl_point_s &pos,
bool enable, uintptr_t arg);
/**
* Handle the TOOLBAR_GRAB event. That corresponds to a left
@ -428,6 +437,36 @@ namespace Twm4Nx
bool configureEvents(FAR const struct SAppEvents &events);
/**
* Register an IEventTap instance to provide callbacks when mouse
* movement is received. A mouse movement with the left button down
* or a touchscreen touch movement are treated as a drag event.
* Release of the mouse left button or loss of the touchscreen touch
* is treated as a drop event.
*
* @param tapHandler A reference to the IEventTap callback interface.
* @param arg The argument returned with the IEventTap callbacks.
*/
inline void installEventTap(FAR IEventTap *tapHandler, uintptr_t arg)
{
m_windowEvent->installEventTap(tapHandler, arg);
}
/**
* Return the installed event tap. This is useful if you want to
* install a different event tap, then restore the event tap returned
* by this method when you are finished.
*
* @param tapHandler The location to return IEventTap callback interface.
* @param arg The loation to return the IEventTap argument
*/
inline void getEventTap(FAR IEventTap *&tapHandler, uintptr_t &arg)
{
m_windowEvent->getEventTap(tapHandler, arg);
}
/**
* Synchronize the window with the NX server. This function will delay
* until the the NX server has caught up with all of the queued requests.
@ -810,26 +849,6 @@ namespace Twm4Nx
}
}
/**
* Get zoom
*/
inline uint16_t getZoom(void)
{
return m_zoom;
}
/**
* Set zoom
*
* @param zoom The new zoom setting
*/
inline void setZoom(uint16_t zoom)
{
m_zoom = zoom;
}
/**
* Check for widget-related toolbar events, typically button presses.
* This is called by event handling logic for events that require

View File

@ -86,6 +86,11 @@ namespace Twm4Nx
* 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.
*
* CAREFUL: All of these methods will run on the thread of execution
* of the listener thread. The safest design for the implementation
* of these methods would be to send a messsage to main Twm4Nx thread
* event handler for movement processing.
*/
virtual ~IEventTap(void)
@ -133,13 +138,23 @@ namespace Twm4Nx
virtual bool isActive(uintptr_t arg) = 0;
/**
* Enable/disable movement
* Enable/disable the tap.
*
* True is provided when (1) isActive() returns false, but (2) a mouse
* report with a left-click is received.
* False is provided when (1) isActive() returns true, but (2) a mouse
* report without a left-click is received.
*
* In the latter is redundant since dropEvent() will be called immediately
* afterward.
*
* @param pos. The mouse position at the time of the click or release
* @param enable. True: Enable movement
* @param arg The user-argument provided that accompanies the callback
*/
virtual void enableMovement(bool enable, uintptr_t arg) = 0;
virtual void enableMovement(FAR const struct nxgl_point_s &pos,
bool enable, uintptr_t arg) = 0;
};
/**

View File

@ -156,22 +156,18 @@ namespace Twm4Nx
EVENT_TOOLBAR_UNGRAB = 0x7002, /**< Release click on title widget */
EVENT_TOOLBAR_MENU = 0x7003, /**< Toolbar menu button released */
EVENT_TOOLBAR_MINIMIZE = 0x7004, /**< Toolbar minimize button released */
EVENT_TOOLBAR_RESIZE = 0x7005, /**< Toolbar resize button released */
EVENT_TOOLBAR_TERMINATE = 0x7006, /**< Toolbar delete button released */
EVENT_TOOLBAR_TERMINATE = 0x7005, /**< Toolbar delete button released */
// Recipient == BORDER
// Recipient == RESIZE
EVENT_RESIZE_XYINPUT = 0x9000, /**< Poll for widget mouse/touch events */
EVENT_RESIZE_START = 0x9001, /**< Start window resize */
EVENT_RESIZE_VERTZOOM = 0x9002, /**< Zoom vertically only */
EVENT_RESIZE_HORIZOOM = 0x9003, /**< Zoom horizontally only */
EVENT_RESIZE_FULLZOOM = 0x9004, /**< Zoom both vertically and horizontally */
EVENT_RESIZE_LEFTZOOM = 0x9005, /**< Zoom left only */
EVENT_RESIZE_RIGHTZOOM = 0x9006, /**< Zoom right only */
EVENT_RESIZE_TOPZOOM = 0x9007, /**< Zoom top only */
EVENT_RESIZE_BOTTOMZOOM = 0x9008, /**< Zoom bottom only */
EVENT_RESIZE_BUTTON = 0x9001, /**< Start or stop a resize sequence */
EVENT_RESIZE_MOVE = 0x9002, /**< Mouse movement during a resize sequence */
EVENT_RESIZE_PAUSE = 0x9003, /**< Pause resize operation when unclicked */
EVENT_RESIZE_RESUME = 0x9004, /**< Resume resize operation when re-clicked */
EVENT_RESIZE_STOP = 0x9005, /**< End a resize sequence on second press */
// Recipient == APP
// All application defined events must (1) use recepient == EVENT_RECIPIENT_APP,
@ -187,10 +183,10 @@ namespace Twm4Nx
EVENT_CONTEXT_WINDOW = 0,
EVENT_CONTEXT_TOOLBAR,
EVENT_CONTEXT_BACKGROUND,
EVENT_CONTEXT_ICON,
EVENT_CONTEXT_FRAME,
EVENT_CONTEXT_ICONWIDGET,
EVENT_CONTEXT_ICONMGR,
EVENT_CONTEXT_MENU,
EVENT_CONTEXT_RESIZE,
NUM_CONTEXTS
};