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

Squashed commit of the following:

Browse Source 
apps/graphics/twm4nx:  Rename IDragEvent interface to IEventTap.  I intend to reuse this interface for window resizing as well as dragging.

    apps/graphics/twm4nx:  Some trivial elimination of some unused logic in CResize.
This commit is contained in:
Gregory Nutt 2019-05-14 16:55:02 -06:00
parent f57ea060ea
commit 7d28294b45
6 changed files with 159 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
graphics/twm4nx/src/cresize.cxx
View File

@ -167,28 +167,6 @@ bool CResize::initialize(void)
return true; return true;
} }
void CResize::resizeFromCenter(FAR CWindow *cwin)
{
// Get the current frame size and position
struct nxgl_point_s winpos;
if (!cwin->getFramePosition(&winpos))
{
return;
}
struct nxgl_size_s winsize;
if (!cwin->getFrameSize(&winsize))
{
return;
}
FAR CResize *resize = m_twm4nx->getResize();
resize->addingSize(&winsize);
resize->menuStartResize(cwin, &winpos, &winsize);
}
/** /**
* Begin a window resize operation * Begin a window resize operation
* *
@ -212,8 +190,6 @@ void CResize::startResize(FAR struct SEventMsg *eventmsg, FAR CWindow *cwin)
return; return;
} }
m_dragpos.x += 0;
m_dragpos.y += 0;
m_origpos.x = m_dragpos.x; m_origpos.x = m_dragpos.x;
m_origpos.y = m_dragpos.y; m_origpos.y = m_dragpos.y;
m_origsize.w = m_dragsize.w; m_origsize.w = m_dragsize.w;
@ -257,88 +233,6 @@ void CResize::startResize(FAR struct SEventMsg *eventmsg, FAR CWindow *cwin)
} }
} }
void CResize::menuStartResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *pos,
FAR struct nxgl_size_s *size)
{
m_dragpos.x = pos->x;
m_dragpos.y = pos->y;
m_origpos.x = m_dragpos.x;
m_origpos.y = m_dragpos.y;
m_origsize.w = size->w;
m_origsize.h = size->h;
m_dragsize.w = size->w;
m_dragsize.h = size->h;
m_clamp.pt1.x = 0;
m_clamp.pt1.y = 0;
m_clamp.pt2.x = 0;
m_clamp.pt2.y = 0;
m_delta.x = 0;
m_delta.y = 0;
m_last.w = 0;
m_last.h = 0;
FAR CFonts *fonts = m_twm4nx->getFonts();
FAR NXWidgets::CNxFont *sizeFont = fonts->getSizeFont();
// Set the window size
struct nxgl_size_s winsize;
winsize.w = m_stringWidth + CONFIG_TWM4NX_ICONMGR_HSPACING * 2;
winsize.h = sizeFont->getHeight() + CONFIG_TWM4NX_ICONMGR_VSPACING * 2;
if (!setWindowSize(&winsize))
{
twmerr("ERROR: setWindowSize() failed\n");
return;
}
// Move the size window it to the top of the hieararchy
m_sizeWindow->raise();
updateSizeLabel(cwin, &m_origsize);
// Set the new frame position and size
if (!cwin->resizeFrame(&m_dragsize, &m_dragpos))
{
twmerr("ERROR: Failed to resize frame\n");
}
}
/**
* Begin a window resize operation
*
* @param cwin the Twm4Nx window pointer
*/
void CResize::addStartResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *pos,
FAR struct nxgl_size_s *size)
{
m_dragpos.x = pos->x;
m_dragpos.y = pos->y;
m_origpos.x = m_dragpos.x;
m_origpos.y = m_dragpos.y;
m_origsize.w = size->w;
m_origsize.h = size->h;
m_dragsize.w = m_origsize.w;
m_dragsize.h = m_origsize.h;
m_clamp.pt1.x = 0;
m_clamp.pt1.y = 0;
m_clamp.pt2.x = 0;
m_clamp.pt2.y = 0;
m_delta.x = 0;
m_delta.y = 0;
m_last.w = 0;
m_last.h = 0;
m_last.w = 0;
m_last.h = 0;
updateSizeLabel(cwin, &m_origsize);
}
/** /**
* @param cwin The current Twm4Nx window * @param cwin The current Twm4Nx window
* @param root The X position in the root window * @param root The X position in the root window
@ -908,7 +802,7 @@ bool CResize::event(FAR struct SEventMsg *eventmsg)
eventmsg->context == EVENT_CONTEXT_WINDOW || eventmsg->context == EVENT_CONTEXT_WINDOW ||
eventmsg->context == EVENT_CONTEXT_TOOLBAR) eventmsg->context == EVENT_CONTEXT_TOOLBAR)
{ {
resizeFromCenter(cwin); menuStartResize(cwin);
} }
else else
{ {
@ -1105,6 +999,66 @@ bool CResize::setWindowSize(FAR struct nxgl_size_s *size)
return true; return true;
} }
void CResize::menuStartResize(FAR CWindow *cwin)
{
// Get the current frame size and position
struct nxgl_point_s windowPos;
if (!cwin->getFramePosition(&windowPos))
{
return;
}
struct nxgl_size_s windowSize;
if (!cwin->getFrameSize(&windowSize))
{
return;
}
m_dragpos.x = windowPos.x;
m_dragpos.y = windowPos.y;
m_origpos.x = windowPos.x;
m_origpos.y = windowPos.y;
m_origsize.w = windowSize.w;
m_origsize.h = windowSize.h;
m_dragsize.w = windowSize.w;
m_dragsize.h = windowSize.h;
m_clamp.pt1.x = 0;
m_clamp.pt1.y = 0;
m_clamp.pt2.x = 0;
m_clamp.pt2.y = 0;
m_delta.x = 0;
m_delta.y = 0;
m_last.w = 0;
m_last.h = 0;
FAR CFonts *fonts = m_twm4nx->getFonts();
FAR NXWidgets::CNxFont *sizeFont = fonts->getSizeFont();
// Set the window size
windowSize.w = m_stringWidth + CONFIG_TWM4NX_ICONMGR_HSPACING * 2;
windowSize.h = sizeFont->getHeight() + CONFIG_TWM4NX_ICONMGR_VSPACING * 2;
if (!setWindowSize(&windowSize))
{
twmerr("ERROR: setWindowSize() failed\n");
return;
}
// Move the size window it to the top of the hieararchy
m_sizeWindow->raise();
updateSizeLabel(cwin, &m_origsize);
// Set the new frame position and size
if (!cwin->resizeFrame(&m_dragsize, &m_dragpos))
{
twmerr("ERROR: Failed to resize frame\n");
}
}
/** /**
* Update the size show in the size dimension label. * Update the size show in the size dimension label.
* *

14
graphics/twm4nx/src/cwindow.cxx
View File

@ -796,7 +796,7 @@ bool CWindow::createMainWindow(FAR const nxgl_size_s *winsize,
// handler // handler
m_windowEvent = new CWindowEvent(m_twm4nx, this, m_appEvents); m_windowEvent = new CWindowEvent(m_twm4nx, this, m_appEvents);
m_windowEvent->registerDragEventHandler(this, (uintptr_t)1); m_windowEvent->installEventTap(this, (uintptr_t)1);
// 4. Create the window. Handling provided flags. NOTE: that menu windows // 4. Create the window. Handling provided flags. NOTE: that menu windows
// are always created hidden and in the iconified state (although they // are always created hidden and in the iconified state (although they
@ -901,7 +901,7 @@ bool CWindow::createToolbar(void)
events.closeEvent = EVENT_SYSTEM_NOP; events.closeEvent = EVENT_SYSTEM_NOP;
FAR CWindowEvent *control = new CWindowEvent(m_twm4nx, this, events); FAR CWindowEvent *control = new CWindowEvent(m_twm4nx, this, events);
control->registerDragEventHandler(this, (uintptr_t)0); control->installEventTap(this, (uintptr_t)0);
// 3. Get the toolbar sub-window from the framed window // 3. Get the toolbar sub-window from the framed window
@ -1443,7 +1443,7 @@ void CWindow::handleActionEvent(const NXWidgets::CWidgetEventArgs &e)
* This function is called when there is any moved of the mouse or * This function is called when there is any moved of the mouse or
* touch position that would indicate that the object is being moved. * touch position that would indicate that the object is being moved.
* *
* This function overrides the virtual IDragEvent::dragEvent method. * This function overrides the virtual IEventTap::moveEvent method.
* *
* @param pos The current mouse/touch X/Y position in toolbar relative * @param pos The current mouse/touch X/Y position in toolbar relative
* coordinates. * coordinates.
@ -1452,7 +1452,7 @@ void CWindow::handleActionEvent(const NXWidgets::CWidgetEventArgs &e)
* a drag event in progress * a drag event in progress
*/ */
bool CWindow::dragEvent(FAR const struct nxgl_point_s &pos, bool CWindow::moveEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg) uintptr_t arg)
{ {
twminfo("m_dragging=%u pos=(%d,%d)\n", m_dragging, pos.x, pos.y); twminfo("m_dragging=%u pos=(%d,%d)\n", m_dragging, pos.x, pos.y);
@ -1503,7 +1503,7 @@ bool CWindow::dragEvent(FAR const struct nxgl_point_s &pos,
* if the touchscrreen touch is lost. This indicates that the * if the touchscrreen touch is lost. This indicates that the
* dragging sequence is complete. * dragging sequence is complete.
* *
* This function overrides the virtual IDragEvent::dropEvent method. * This function overrides the virtual IEventTap::dropEvent method.
* *
* @param pos The last mouse/touch X/Y position in toolbar relative * @param pos The last mouse/touch X/Y position in toolbar relative
* coordinates. * coordinates.
@ -1548,7 +1548,7 @@ bool CWindow::dropEvent(FAR const struct nxgl_point_s &pos,
* @return True: If the dragging is enabled. * @return True: If the dragging is enabled.
*/ */
bool CWindow::isDragging(uintptr_t arg) bool CWindow::isActive(uintptr_t arg)
{ {
return m_clicked; return m_clicked;
} }
@ -1560,7 +1560,7 @@ bool CWindow::isDragging(uintptr_t arg)
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
*/ */
void CWindow::setDragging(bool enable, uintptr_t arg) void CWindow::enableMovement(bool enable, uintptr_t arg)
{ {
m_clicked = enable; m_clicked = enable;
} }

68
graphics/twm4nx/src/cwindowevent.cxx
View File

@ -120,8 +120,8 @@ CWindowEvent::CWindowEvent(FAR CTwm4Nx *twm4nx, FAR CWindow *client,
// Dragging // Dragging
m_dragHandler = (FAR IDragEvent *)0; // No drag handler callbacks m_tapHandler = (FAR IEventTap *)0; // No event tap handler callbacks
m_dragArg = (uintptr_t)0; // No callback argument m_tapArg = (uintptr_t)0; // No callback argument
// Open a message queue to send raw NX events. This cannot fail! // Open a message queue to send raw NX events. This cannot fail!
@ -205,8 +205,8 @@ void CWindowEvent::handleRedrawEvent(FAR const nxgl_rect_s *nxRect,
* toolbar, but can easily move into the main window (or even outside * toolbar, but can easily move into the main window (or even outside
* of the window!). To these case, there may be two instances of * of the window!). To these case, there may be two instances of
* CWindowEvent, one for the toolbar and one for the main window. The * CWindowEvent, one for the toolbar and one for the main window. The
* IDragEvent implementation (along with the user arguement) can keep a * IEventTap implementation (along with the user arguement) can keep a
* consistent drag context across both instances. * consistent movement context across both instances.
* *
* NOTE: NX will continually forward the mouse events to the same raw * NOTE: NX will continually forward the mouse events to the same raw
* window in all cases.. even when the mouse position moves outside of * window in all cases.. even when the mouse position moves outside of
@ -217,75 +217,75 @@ void CWindowEvent::handleRedrawEvent(FAR const nxgl_rect_s *nxRect,
void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos, void CWindowEvent::handleMouseEvent(FAR const struct nxgl_point_s *pos,
uint8_t buttons) uint8_t buttons)
{ {
// Check if dragging can be supported // Check if There is an active tap on mouse events
if (m_dragHandler != (FAR IDragEvent *)0) if (m_tapHandler != (FAR IEventTap *)0)
{ {
twminfo("Mouse input: dragging=%u\n", twminfo("Mouse input: active=%u\n",
m_dragHandler->isDragging(m_dragArg)); m_tapHandler->isActive(m_tapArg));
// STATE LEFT BUTTON ACTION // STATE LEFT BUTTON ACTION
// dragging clicked dragEvent // active clicked moveEvent
// dragging released dropEvent // active released dropEvent
// NOT dragging clicked May be detected as a grab // NOT active clicked May be detected as a grab
// NOT dragging released None // NOT active released None
if (m_dragHandler->isDragging(m_dragArg)) if (m_tapHandler->isActive(m_tapArg))
{ {
// The new drag position in window relative display coordinates // The new movement position in window relative display coordinates
struct nxgl_point_s dragPos; struct nxgl_point_s movePos;
dragPos.x = pos->x; movePos.x = pos->x;
dragPos.y = pos->y; movePos.y = pos->y;
// Is the left button still pressed? // Is the left button still pressed?
if ((buttons & MOUSE_BUTTON_1) != 0) if ((buttons & MOUSE_BUTTON_1) != 0)
{ {
twminfo("Continue dragging (%d,%d) buttons=%02x m_dragHandler=%p\n", twminfo("Continue movemenht (%d,%d) buttons=%02x m_tapHandler=%p\n",
dragPos.x, dragPos.y, buttons, m_dragHandler); movePos.x, movePos.y, buttons, m_tapHandler);
// Yes.. generate a drag event if we have a drag event handler // Yes.. generate a movment event if we have a tap event handler
if (m_dragHandler->dragEvent(dragPos, m_dragArg)) if (m_tapHandler->moveEvent(movePos, m_tapArg))
{ {
// Skip the input poll until the drag completes // Skip the input poll until the movment completes
return; return;
} }
} }
else else
{ {
twminfo("Stop dragging (%d,%d) buttons=%02x m_dragHandler=%p\n", twminfo("Stop movement (%d,%d) buttons=%02x m_tapHandler=%p\n",
dragPos.x, dragPos.y, buttons, m_dragHandler); movePos.x, movePos.y, buttons, m_tapHandler);
// No.. then we are no longer dragging // No.. then the tap is no longer active
m_dragHandler->setDragging(false, m_dragArg); m_tapHandler->enableMovement(false, m_tapArg);
// Generate a dropEvent // Generate a dropEvent
if (m_dragHandler->dropEvent(dragPos, m_dragArg)) if (m_tapHandler->dropEvent(movePos, m_tapArg))
{ {
// If the drop event was processed then skip the // If the drop event was processed then skip the
// input poll until AFTER the drag completes // input poll until AFTER the movement completes
return; return;
} }
} }
} }
// If we are not currently dragging but the left button is pressed, then // If we are not currently moving anything but the left button is
// start the drag event // pressed, then start a movement event
else if ((buttons & MOUSE_BUTTON_1) != 0) else if ((buttons & MOUSE_BUTTON_1) != 0)
{ {
// Indicate that we are (or may be) dragging // Indicate that we are (or may be) moving
m_dragHandler->setDragging(true, m_dragArg); m_tapHandler->enableMovement(true, m_tapArg);
twminfo("Start dragging (%d,%d) buttons=%02x m_dragHandler=%p\n", twminfo("Start moving (%d,%d) buttons=%02x m_tapHandler=%p\n",
pos->x, pos->y, buttons, m_dragHandler); pos->x, pos->y, buttons, m_tapHandler);
// But take no other actions until the window recognizes the grab // But take no other actions until the window recognizes the grab
} }

19
include/graphics/twm4nx/cresize.hxx
View File

@ -85,8 +85,6 @@ namespace Twm4Nx
struct nxgl_rect_s m_clamp; struct nxgl_rect_s m_clamp;
struct nxgl_point_s m_delta; struct nxgl_point_s m_delta;
struct nxgl_size_s m_last; struct nxgl_size_s m_last;
struct nxgl_point_s m_addingPos;
struct nxgl_size_s m_addingSize;
int m_stringWidth; /**< Size of current size string */ int m_stringWidth; /**< Size of current size string */
/** /**
@ -107,8 +105,6 @@ namespace Twm4Nx
bool setWindowSize(FAR struct nxgl_size_s *size); bool setWindowSize(FAR struct nxgl_size_s *size);
void resizeFromCenter(FAR CWindow *win);
/** /**
* Begin a window resize operation * Begin a window resize operation
* @param ev the event structure (button press) * @param ev the event structure (button press)
@ -116,10 +112,7 @@ namespace Twm4Nx
*/ */
void startResize(FAR struct SEventMsg *eventmsg, FAR CWindow *cwin); void startResize(FAR struct SEventMsg *eventmsg, FAR CWindow *cwin);
void menuStartResize(FAR CWindow *cwin);
void menuStartResize(FAR CWindow *cwin,
FAR struct nxgl_point_s *pos,
FAR struct nxgl_size_s *size);
/** /**
* Update the size show in the size dimension label. * Update the size show in the size dimension label.
@ -155,16 +148,6 @@ namespace Twm4Nx
bool initialize(void); bool initialize(void);
/**
* What is this?
*/
void addingSize(FAR struct nxgl_size_s *size)
{
m_addingSize.w = size->w;
m_addingSize.h = size->h;
}
/** /**
* Begin a window resize operation * Begin a window resize operation
* *

32
include/graphics/twm4nx/cwindow.hxx
View File

@ -134,7 +134,7 @@ namespace Twm4Nx
// containing the standard buttons and the window title. // containing the standard buttons and the window title.
class CWindow : protected NXWidgets::CWidgetEventHandler, class CWindow : protected NXWidgets::CWidgetEventHandler,
protected IDragEvent, protected IEventTap,
public CTwm4NxEvent public CTwm4NxEvent
{ {
private: private:
@ -290,55 +290,55 @@ namespace Twm4Nx
void handleActionEvent(const NXWidgets::CWidgetEventArgs &e); void handleActionEvent(const NXWidgets::CWidgetEventArgs &e);
/** /**
* This function is called when there is any moved of the mouse or * This function is called when there is any movement of the mouse or
* touch position that would indicate that the object is being moved. * touch position that would indicate that the object is being moved.
* *
* This function overrides the virtual IDragEvent::dragEvent method. * This function overrides the virtual IEventTap::moveEvent method.
* *
* @param pos The current mouse/touch X/Y position. * @param pos The current mouse/touch X/Y position.
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: if the drage event was processed; false it is was * @return True: if the movement event was processed; false it is was
* ignored. The event should be ignored if there is not actually * ignored. The event should be ignored if there is not actually
* a drag event in progress * a movement event in progress
*/ */
bool dragEvent(FAR const struct nxgl_point_s &pos, bool moveEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg); uintptr_t arg);
/** /**
* This function is called if the mouse left button is released or * This function is called if the mouse left button is released or
* if the touchscrreen touch is lost. This indicates that the * if the touchscrreen touch is lost. This indicates that the
* dragging sequence is complete. * movement sequence is complete.
* *
* This function overrides the virtual IDragEvent::dropEvent method. * This function overrides the virtual IEventTap::dropEvent method.
* *
* @param pos The last mouse/touch X/Y position. * @param pos The last mouse/touch X/Y position.
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: if the drage event was processed; false it is was * @return True: if the drop event was processed; false it is was
* ignored. The event should be ignored if there is not actually * ignored. The event should be ignored if there is not actually
* a drag event in progress * a movement event in progress
*/ */
bool dropEvent(FAR const struct nxgl_point_s &pos, bool dropEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg); uintptr_t arg);
/** /**
* Is dragging enabled? * Is the tap enabled?
* *
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: If the dragging is enabled. * @return True: If the the tap is enabled.
*/ */
bool isDragging(uintptr_t arg); bool isActive(uintptr_t arg);
/** /**
* Enable/disable dragging * Enable/disable the tap
* *
* @param enable. True: Enable dragging * @param enable. True: Enable the tap
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
*/ */
void setDragging(bool enable, uintptr_t arg); void enableMovement(bool enable, uintptr_t arg);
/** /**
* Handle the TOOLBAR_GRAB event. That corresponds to a left * Handle the TOOLBAR_GRAB event. That corresponds to a left

65
include/graphics/twm4nx/cwindowevent.hxx
View File

@ -74,11 +74,11 @@ namespace Twm4Nx
}; };
/** /**
* This abstract base class provides add on methods to support dragging * This abstract base class provides add on methods to support movement
* of a window. * of a window.
*/ */
class IDragEvent class IEventTap
{ {
public: public:
/** /**
@ -88,58 +88,58 @@ namespace Twm4Nx
* one. * one.
*/ */
virtual ~IDragEvent(void) virtual ~IEventTap(void)
{ {
} }
/** /**
* This function is called when there is any moved of the mouse or * This function is called when there is any movement of the mouse or
* touch position that would indicate that the object is being moved. * touch position that would indicate that the object is being moved.
* *
* @param pos The current mouse/touch X/Y position in toolbar relative * @param pos The current mouse/touch X/Y position in toolbar relative
* coordinates. * coordinates.
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: if the drag event was processed; false it is was * @return True: if the movement event was processed; false it is was
* ignored. The event should be ignored if there is not actually * ignored. The event should be ignored if there is not actually
* a drag event in progress * a movement event in progress
*/ */
virtual bool dragEvent(FAR const struct nxgl_point_s &pos, virtual bool moveEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg) = 0; uintptr_t arg) = 0;
/** /**
* This function is called if the mouse left button is released or * This function is called if the mouse left button is released or
* if the touchscrreen touch is lost. This indicates that the * if the touchscreen touch is lost. This indicates that the
* dragging sequence is complete. * movement sequence is complete.
* *
* @param pos The last mouse/touch X/Y position in toolbar relative * @param pos The last mouse/touch X/Y position in toolbar relative
* coordinates. * coordinates.
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: If the drag event was processed; false it is was * @return True: If the movement event was processed; false it is was
* ignored. The event should be ignored if there is not actually * ignored. The event should be ignored if there is not actually
* a drag event in progress * a movement event in progress
*/ */
virtual bool dropEvent(FAR const struct nxgl_point_s &pos, virtual bool dropEvent(FAR const struct nxgl_point_s &pos,
uintptr_t arg) = 0; uintptr_t arg) = 0;
/** /**
* Is dragging enabled? * Is the tap active?
* *
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
* @return True: If the dragging is enabled. * @return True: If the tap is enabled.
*/ */
virtual bool isDragging(uintptr_t arg) = 0; virtual bool isActive(uintptr_t arg) = 0;
/** /**
* Enable/disable dragging * Enable/disable movement
* *
* @param enable. True: Enable dragging * @param enable. True: Enable movement
* @param arg The user-argument provided that accompanies the callback * @param arg The user-argument provided that accompanies the callback
*/ */
virtual void setDragging(bool enable, uintptr_t arg) = 0; virtual void enableMovement(bool enable, uintptr_t arg) = 0;
}; };
/** /**
@ -162,8 +162,8 @@ namespace Twm4Nx
// Dragging // Dragging
FAR IDragEvent *m_dragHandler; /**< Drag event handlers (may be NULL) */ FAR IEventTap *m_tapHandler; /**< Event tap handlers (may be NULL) */
uintptr_t m_dragArg; /**< User argument associated with callback */ uintptr_t m_tapArg; /**< User argument associated with callback */
// Override CWidgetEventHandler virtual methods /////////////////////// // Override CWidgetEventHandler virtual methods ///////////////////////
@ -226,20 +226,35 @@ namespace Twm4Nx
~CWindowEvent(void); ~CWindowEvent(void);
/** /**
* Register an IDragEvent instance to provide callbacks when mouse * Register an IEventTap instance to provide callbacks when mouse
* movement is received. A mouse movement with the left button down * movement is received. A mouse movement with the left button down
* or a touchscreen touch movement are treated as a drag event. * or a touchscreen touch movement are treated as a drag event.
* Release of the mouse left button or loss of the touchscreen touch * Release of the mouse left button or loss of the touchscreen touch
* is treated as a drop event. * is treated as a drop event.
* *
* @param cb A reference to the IDragEvent callback interface. * @param tapHandler A reference to the IEventTap callback interface.
* @param arg The argument returned with the IEventTap callbacks.
*/ */
inline void registerDragEventHandler(FAR IDragEvent *dragHandler, inline void installEventTap(FAR IEventTap *tapHandler, uintptr_t arg)
uintptr_t arg)
{ {
m_dragHandler = dragHandler; m_tapHandler = tapHandler;
m_dragArg = arg; m_tapArg = 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_tapHandler = tapHandler;
m_tapArg = arg;
} }
/** /**