sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
bc5d8034f1
nuttx-apps/include/graphics/twm4nx/cwindow.hxx
Alin Jerpelea 324155cd1e include: update licenses to Apache 
Gregory Nutt is has submitted the SGA

Uros Platise has submitted the ICLA

Ken Pettit has submitted the ICLA

Sebastien Lorquet has submitted the ICLA

Pierre-Noel Bouteville has submitted the ICLA

as a result we can migrate the licenses to Apache.

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2021-06-11 05:05:27 -05:00

941 lines
30 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// apps/include/graphics/twm4nx/cwindow.hxx
//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership. The
// ASF licenses this file to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance with the
// License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
//
/////////////////////////////////////////////////////////////////////////////
// Largely an original work but derives from TWM 1.0.10 in many ways:
//
// Copyright 1989,1998 The Open Group
// Copyright 1988 by Evans & Sutherland Computer Corporation,
//
// Please refer to apps/twm4nx/COPYING for detailed copyright information.
// Although not listed as a copyright holder, thanks and recognition need
// to go to Tom LaStrange, the original author of TWM.
#ifndef __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX
#define __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX
/////////////////////////////////////////////////////////////////////////////
// Included Files
/////////////////////////////////////////////////////////////////////////////
#include <cstdint>
#include <mqueue.h>
#include <nuttx/nx/nxglib.h>
#include <nuttx/nx/nxterm.h>
#include "graphics/nxwidgets/cnxtkwindow.hxx"
#include "graphics/nxwidgets/cnxtoolbar.hxx"
#include "graphics/nxwidgets/cwidgeteventhandler.hxx"
#include "graphics/nxwidgets/cwidgeteventargs.hxx"
#include "graphics/twm4nx/cwindowevent.hxx"
#include "graphics/twm4nx/ciconwidget.hxx"
#include "graphics/twm4nx/ctwm4nxevent.hxx"
/////////////////////////////////////////////////////////////////////////////
// Pre-processor Definitions
/////////////////////////////////////////////////////////////////////////////
/**
* Toolbar Icons. The Title bar contains (from left to right):
*
* 1. Menu button
* 2. Window title (text)
* 3. Minimize (Iconify) button
* 4. Resize button
* 5. Delete button
*
* There is no focus indicator
*/
#define MENU_BUTTON 0 // First on left
#define DELETE_BUTTON 1 // First on right
#define RESIZE_BUTTON 2
#define MINIMIZE_BUTTON 3
#define NTOOLBAR_BUTTONS 4
// Windows may be customized with the flags parameter to the constructor.
// These are the bits fields that may be OR'ed together in the flags.
#define NO_TOOLBAR (NTOOLBAR_BUTTONS + 0)
#define ICONMGR_WINDOW (NTOOLBAR_BUTTONS + 1)
#define MENU_WINDOW (NTOOLBAR_BUTTONS + 2)
#define HIDDEN_WINDOW (NTOOLBAR_BUTTONS + 3)
#define WFLAGS_NO_MENU_BUTTON (1 << MENU_BUTTON)
#define WFLAGS_NO_DELETE_BUTTON (1 << DELETE_BUTTON)
#define WFLAGS_NO_RESIZE_BUTTON (1 << RESIZE_BUTTON)
#define WFLAGS_NO_MINIMIZE_BUTTON (1 << MINIMIZE_BUTTON)
#define WFLAGS_NO_TOOLBAR (1 << NO_TOOLBAR)
#define WFLAGS_ICONMGR (1 << ICONMGR_WINDOW)
#define WFLAGS_MENU (1 << MENU_WINDOW)
#define WFLAGS_HIDDEN (1 << HIDDEN_WINDOW)
#define WFLAGS_HAVE_MENU_BUTTON(f) (((f) & WFLAGS_NO_MENU_BUTTON) == 0)
#define WFLAGS_HAVE_DELETE_BUTTON(f) (((f) & WFLAGS_NO_DELETE_BUTTON) == 0)
#define WFLAGS_HAVE_RESIZE_BUTTON(f) (((f) & WFLAGS_NO_RESIZE_BUTTON) == 0)
#define WFLAGS_HAVE_MINIMIZE_BUTTON(f) (((f) & WFLAGS_NO_MINIMIZE_BUTTON) == 0)
#define WFLAGS_HAVE_TOOLBAR(f) (((f) & WFLAGS_NO_TOOLBAR) == 0)
#define WFLAGS_IS_ICONMGR(f) (((f) & WFLAGS_ICONMGR) != 0)
#define WFLAGS_IS_MENU(f) (((f) & WFLAGS_MENU) != 0)
#define WFLAGS_IS_HIDDEN(f) (((f) & WFLAGS_HIDDEN) != 0)
// Buttons can be disabled temporarily while in certain absorbing states
// (such as resizing the window).
#define DISABLE_NO_BUTTONS (0)
#define DISABLE_MENU_BUTTON (1 << MENU_BUTTON)
#define DISABLE_DELETE_BUTTON (1 << DELETE_BUTTON)
#define DISABLE_RESIZE_BUTTON (1 << RESIZE_BUTTON)
#define DISABLE_MINIMIZE_BUTTON (1 << MINIMIZE_BUTTON)
/////////////////////////////////////////////////////////////////////////////
// Implementation Classes
/////////////////////////////////////////////////////////////////////////////
namespace NXWidgets
{
class CNxString; // Forward reference
class CImage; // Forward reference
class CLabel; // Forward reference
struct SRlePaletteBitmap; // Forward reference
}
namespace Twm4Nx
{
class CIconWidget; // Forward reference
class CIconMgr; // Forward reference
class CWindow; // Forward reference
struct SMenuRoot; // Forward reference
struct SMenuItem; // Forward reference
// The CWindow class implements a standard, framed window with a toolbar
// containing the standard buttons and the window title.
class CWindow : protected NXWidgets::CWidgetEventHandler,
protected IEventTap,
public CTwm4NxEvent
{
private:
CTwm4Nx *m_twm4nx; /**< Cached Twm4Nx session */
mqd_t m_eventq; /**< NxWidget event message queue */
// Primary Window
NXWidgets::CNxString m_name; /**< Name of the window */
FAR NXWidgets::CNxTkWindow *m_nxWin; /**< The contained NX primary window */
FAR CWindowEvent *m_windowEvent; /**< Cached window event reference */
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 */
bool m_modal; /**< Window is in modal state */
// Icon
FAR NXWidgets::CRlePaletteBitmap *m_iconBitMap; /**< The icon image */
FAR CIconWidget *m_iconWidget; /**< The icon widget */
FAR CIconMgr *m_iconMgr; /**< Pointer to it if this is an icon manager */
bool m_iconified; /**< Is the window an icon now ? */
// Toolbar
FAR NXWidgets::CNxToolbar *m_toolbar; /**< The tool bar sub-window */
FAR NXWidgets::CWidgetStyle m_tbStyle; /**< The tool bar widget style */
FAR NXWidgets::CLabel *m_tbTitle; /**< Toolbar title widget */
nxgl_coord_t m_tbHeight; /**< Height of the toolbar */
nxgl_coord_t m_tbLeftX; /**< Rightmost position of left buttons */
nxgl_coord_t m_tbRightX; /**< Leftmost position of right buttons */
uint8_t m_tbFlags; /**< Toolbar button customizations */
uint8_t m_tbDisables; /**< Toolbar button disables */
// List of all toolbar button images
FAR NXWidgets::CImage *m_tbButtons[NTOOLBAR_BUTTONS];
// Dragging
struct nxgl_point_s m_dragPos; /**< Last reported mouse position */
struct nxgl_size_s m_dragCSize; /**< The grab cursor size */
bool m_dragging; /**< True: Drag in-progress */
volatile bool m_clicked; /**< True: Mouse left button is clicked */
/**
* Create the main window
*
* Initially, the application window will generate no window-related events
* (redraw, mouse/touchscreen, keyboard input, etc.). After creating the
* window, the user may call the configureEvents() method to select the
* eventIDs of the events to be generated.
*
* @param winsize The initial window size
* @param winpos The initial window position
* @param flags Toolbar customizations see WFLAGS_NO_* definitions
*/
bool createMainWindow(FAR const nxgl_size_s *winsize,
FAR const nxgl_point_s *winpos,
uint8_t flags);
/**
* Calculate the height of the tool bar
*/
bool getToolbarHeight(FAR const NXWidgets::CNxString &name);
/**
* Create all toolbar buttons
*
* @param flags Toolbar customizations see WFLAGS_NO_* definitions
* @return True if the window was successfully initialize; false on
* any failure,
*/
bool createToolbarButtons(uint8_t flags);
/**
* Add buttons and title widgets to the tool bar
*
* @param name The name to use for the toolbar title
*/
bool createToolbarTitle(FAR const NXWidgets::CNxString &name);
/**
* Create the tool bar
*/
bool createToolbar(void);
/**
* Fill the toolbar background color
*/
bool fillToolbar(void);
/**
* Update the toolbar layout, resizing the title text window and
* repositioning all windows on the toolbar.
*/
bool updateToolbarLayout(void);
/**
* Disable toolbar widget drawing and widget events.
*/
bool disableToolbarWidgets(void);
/**
* Enable toolbar widget drawing and widget events.
*/
bool enableToolbarWidgets(void);
/**
* After the toolbar was grabbed, it may be dragged then dropped, or it
* may be simply "un-grabbed". Both cases are handled here.
*
* NOTE: Unlike the other event handlers, this does NOT override any
* virtual event handling methods. It just combines some common event-
* handling logic.
*
* @param x The mouse/touch X position.
* @param y The mouse/touch y position.
*/
void handleUngrabEvent(nxgl_coord_t x, nxgl_coord_t y);
/**
* Handle a mouse click event.
*
* @param e The event data.
*/
void handleClickEvent(const NXWidgets::CWidgetEventArgs &e);
/**
* Override the virtual CWidgetEventHandler::handleReleaseEvent. This
* event will fire when the title widget is released. isClicked()
* will return false for the title widget.
*
* @param e The event data.
*/
void handleReleaseEvent(const NXWidgets::CWidgetEventArgs &e);
/**
* Override the virtual CWidgetEventHandler::handleActionEvent. This
* event will fire when the image is released but before it has been
* has been drawn. isClicked() will return true for the appropriate
* images.
*
* @param e The event data.
*/
void handleActionEvent(const NXWidgets::CWidgetEventArgs &e);
/**
* 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 touchscreen touch is lost. This indicates that the
* movement 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 movement 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.
*/
bool 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 enableMovement(FAR const struct nxgl_point_s &pos,
bool enable, uintptr_t arg);
/**
* Handle the TOOLBAR_GRAB event. That corresponds to a left
* mouse click on the toolbar (other than on an icon)
*
* @param eventmsg. The received NxWidget event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool toolbarGrab(FAR struct SEventMsg *eventmsg);
/**
* Handle the WINDOW_DRAG event. That corresponds to a mouse
* movement when the window is in a grabbed state.
*
* @param eventmsg. The received NxWidget event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool windowDrag(FAR struct SEventMsg *eventmsg);
/**
* Handle the TOOLBAR_UNGRAB event. The corresponds to a mouse
* left button release while in the grabbed
*
* @param eventmsg. The received NxWidget event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool toolbarUngrab(FAR struct SEventMsg *eventmsg);
/**
* Cleanup on failure or as part of the destructor
*/
void cleanup(void);
public:
/**
* CWindow Constructor
*
* @param twm4nx. Twm4Nx session
*/
CWindow(CTwm4Nx *twm4nx);
/**
* CWindow Destructor
*/
~CWindow(void);
/**
* CWindow Initializer (unlike the constructor, this may fail)
*
* The window is initialized with all application events disabled.
* The CWindows::configureEvents() method may be called as a second
* initialization step in order to enable application events.
*
* @param name The the name of the window (and its icon)
* @param pos The initial position of the window
* @param size The initial size of the window
* @param sbitmap The Icon bitmap image. null if no icon.
* @param iconMgr Pointer to icon manager instance. To support
* multiple Icon Managers.
* @param flags Toolbar customizations see WFLAGS_NO_* definitions
* @return True if the window was successfully initialize; false on
* any failure,
*/
bool initialize(FAR const NXWidgets::CNxString &name,
FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_size_s *size,
FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap,
FAR CIconMgr *iconMgr, uint8_t flags);
/**
* Configure application window events.
*
* @param events Describes the application event configuration
* @return True is returned on success
*/
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.
* When this function returns, the state of the NX server will be the
* same as the state of the application.
*/
inline void synchronize(void)
{
m_nxWin->synchronize();
}
/**
* Get the widget control instance needed to support application drawing
* into the window.
*/
inline FAR NXWidgets::CWidgetControl *getWidgetControl()
{
return m_nxWin->getWidgetControl();
}
/**
* Get the raw window interface. This is sometimes needed for connecting
* the window to external NXWidgets applications.
*
* @return The raw window interface (NXWidgets::INxWindow)
*/
inline NXWidgets::INxWindow *getNxWindow(void)
{
return static_cast<NXWidgets::INxWindow *>(m_nxWin);
}
#ifdef CONFIG_NXTERM_NXKBDIN
/**
* By default, NX forwards keyboard input to the various widgets residing
* in the window. But NxTerm is a different usage model; In this case,
* keyboard input needs to be directed to the NxTerm character driver.
* This method can be used to enable (or disable) redirection of NX
* keyboard input from the window widgets to the NxTerm
*
* @param handle. The NXTERM handle. If non-NULL, NX keyboard
* input will be directed to the NxTerm driver using this
* handle; If NULL (the default), NX keyboard input will be
* directed to the widgets within the window.
*/
inline void redirectNxTerm(NXTERM handle)
{
m_nxWin->redirectNxTerm(handle);
}
#endif
/**
* Get the name of the window
*/
inline NXWidgets::CNxString getWindowName(void)
{
return m_name;
}
/**
* Return true if this is an Icon Manager Window
*/
inline bool isIconMgr(void)
{
return WFLAGS_IS_ICONMGR(m_tbFlags);
}
/**
* Return the Icon Manager Window instance. Supports multiple
* Icon Managers.
*
* @return The Icon Manager to which this window belongs.
*/
inline FAR CIconMgr *getIconMgr(void)
{
return m_iconMgr;
}
/**
* Get the size of the primary window. This is useful only
* for applications that need to know about the drawing area.
*
* @param size Location to return the primary window size
*/
inline bool getWindowSize(FAR struct nxgl_size_s *size)
{
return m_nxWin->getSize(size);
}
/**
* Set the size of the primary window. This is useful only
* for applications that need to control the drawing area.
*
* This method is only usable from windows that have no
* toolbar. The the window has a toolbar, then changing the
* width of the window will mess up the toolbar layout. In
* such cases, the better to use is resizeFrame() which will
* update the toolbar geometry after the resize.
*
* @param size New primary window size
*/
inline bool setWindowSize(FAR const struct nxgl_size_s *size)
{
return m_nxWin->setSize(size);
}
/**
* Get the position of the primary window. This is useful only
* for applications that need to know about the drawing area.
*
* @param pos Location to return the primary window position
*/
inline bool getWindowPosition(FAR struct nxgl_point_s *pos)
{
return m_nxWin->getPosition(pos);
}
/**
* Set the position of the primary window.
*
* @param pos The new primary window position
*/
inline bool setWindowPosition(FAR const struct nxgl_point_s *pos)
{
return m_nxWin->setPosition(pos);
}
/**
* Get the height of the tool bar
*/
inline nxgl_coord_t getToolbarHeight(void)
{
return m_tbHeight;
}
/**
* Raise the window to the top of the hierarchy.
*/
inline bool raiseWindow(void)
{
return m_nxWin->raise();
}
/**
* Lower the window to the bottom of the hierarchy.
*/
inline bool lowerWindow(void)
{
return m_nxWin->lower();
}
/**
* Return true if the window is currently being displayed
*
* @return True if the window is visible
*/
inline bool isWindowVisible(void)
{
return m_nxWin->isVisible();
}
/**
* Show a hidden window
*
* @return True if the operation was successful
*/
inline bool showWindow(void)
{
return m_nxWin->show();
}
/**
* Hide a visible window
*
* @return True if the operation was successful
*/
inline bool hideWindow(void)
{
return m_nxWin->hide();
}
/**
* Convert the position of a primary window to the position of
* the containing frame.
*/
inline void windowToFramePos(FAR const struct nxgl_point_s *winpos,
FAR struct nxgl_point_s *framepos)
{
framepos->x = winpos->x - CONFIG_NXTK_BORDERWIDTH;
framepos->y = winpos->y - m_tbHeight - CONFIG_NXTK_BORDERWIDTH;
}
/**
* Convert the position of the containing frame to the position of the
* primary window.
*/
inline void frameToWindowPos(FAR const struct nxgl_point_s *framepos,
FAR struct nxgl_point_s *winpos)
{
winpos->x = framepos->x + CONFIG_NXTK_BORDERWIDTH;
winpos->y = framepos->y + m_tbHeight + CONFIG_NXTK_BORDERWIDTH;
}
/**
* Convert the size of a primary window to the size of the containing
* frame.
*/
inline void windowToFrameSize(FAR const struct nxgl_size_s *winsize,
FAR struct nxgl_size_s *framesize)
{
framesize->w = winsize->w + 2 * CONFIG_NXTK_BORDERWIDTH;
framesize->h = winsize->h + m_tbHeight + 2 * CONFIG_NXTK_BORDERWIDTH;
}
/**
* Convert the size of the containing frame to the size of the primary window to the size of the containing
* frame.
*/
inline void frameToWindowSize(FAR const struct nxgl_size_s *framesize,
FAR struct nxgl_size_s *winsize)
{
winsize->w = framesize->w - 2 * CONFIG_NXTK_BORDERWIDTH;
winsize->h = framesize->h - m_tbHeight - 2 * CONFIG_NXTK_BORDERWIDTH;
}
/**
* Get the raw window size (including toolbar and frame)
*
* @param framesize Location to return the window frame size
* @return True if the operation was successful
*/
bool getFrameSize(FAR struct nxgl_size_s *framesize);
/**
* Update the window frame after a resize operation (includes the toolbar
* and user window)
*
* @param frameSize The new window frame size
* @param framePos The frame location which may also have changed (NULL
* may be used to preserve the current position)
* @return True if the operation was successful
*/
bool resizeFrame(FAR const struct nxgl_size_s *frameSize,
FAR const struct nxgl_point_s *framePos);
/**
* Get the raw frame position (accounting for toolbar and frame)
*
* @param framepos Location to return the window frame position
* @return True if the operation was successful
*/
bool getFramePosition(FAR struct nxgl_point_s *framepos);
/**
* Set the raw frame position (accounting for toolbar and frame)
*
* @param framepos The new raw window position
* @return True if the operation was successful
*/
bool setFramePosition(FAR const struct nxgl_point_s *framepos);
/**
* Minimize (iconify) the window
*
* @return True if the operation was successful
*/
bool iconify(void);
/**
* De-iconify the window
*
* @return True if the operation was successful
*/
bool deIconify(void);
/**
* Is the window iconified?
*
* @return True if the operation was successful
*/
inline bool isIconified(void)
{
return m_iconified;
}
/**
* Check if this window has an Icon. Menu windows, for examples, have
* no icons.
*/
inline bool hasIcon(void)
{
return (m_iconWidget != (FAR CIconWidget *)0);
}
/**
* Get the size of the icon window associated with this application
* window. This is needed for placement of the icon on the background
* window and for determining if the icon widget needs to be redraw
* when the background is redrawn.
*
* @param size Location to return the icon window size
* @return True if the icon size was returned
*/
inline void getIconWidgetSize(FAR struct nxgl_size_s &size)
{
if (m_iconWidget != (FAR CIconWidget *)0)
{
m_iconWidget->getSize(size);
}
else
{
size.w = 0;
size.h = 0;
}
}
/**
* Get the current position of the icon window associated with the
* application window. This is needed for determining if an icon
* widgets needs to be redrawn when the background is redrawn.
*
* @param pos Location to return the icon window position
* @return True if the icon position was returned
*/
inline void getIconWidgetPosition(FAR struct nxgl_point_s &pos)
{
if (m_iconWidget != (FAR CIconWidget *)0)
{
m_iconWidget->getPos(pos);
}
else
{
pos.x = 0;
pos.y = 0;
}
}
/**
* Set the new position of the icon window associated with the
* application window. This is needed for movement of the icon on the
* background window.
*
* @param pos The new location of the icon window
* @return True if the icon position was correctly set
*/
inline bool setIconWidgetPosition(FAR const struct nxgl_point_s &pos)
{
bool success = false;
if (m_iconWidget != (FAR CIconWidget *)0)
{
success = m_iconWidget->moveTo(pos.x, pos.y);
}
return success;
}
/**
* Redraw the icon.
*/
inline void redrawIcon(void)
{
if (m_iconWidget != (FAR CIconWidget *)0)
{
// Make sure that the icon is properly enabled, then redraw it
m_iconWidget->enable();
m_iconWidget->enableDrawing();
m_iconWidget->setRaisesEvents(true);
m_iconWidget->redraw();
}
}
/**
* Enable/disable toolbar buttons. Buttons may need to be disabled
* temporarily while in certain absorbing states (such as resizing the
* window).
*
* @param disables The set of buttons to enable or disable See
* DISABLE_* definitions.
*/
inline void disableToolbarButtons(uint8_t disables)
{
m_tbDisables = disables;
}
/**
* Check for widget-related toolbar events, typically button presses.
* This is called by event handling logic for events that require
* detection of widget events.
*/
inline bool pollToolbarEvents(void)
{
NXWidgets::CWidgetControl *control = m_toolbar->getWidgetControl();
// pollEvents() returns true if any interesting event occurred.
// false is not a failure.
control->pollEvents();
return true;
}
/**
* Handle EVENT_WINDOW events.
*
* @param eventmsg. The received NxWidget WINDOW event message.
* @return True if the message was properly handled. false is
* return on any failure.
*/
bool event(FAR struct SEventMsg *eventmsg);
};
///////////////////////////////////////////////////////////////////////////
// Public Function Prototypes
///////////////////////////////////////////////////////////////////////////
/**
* Return the minimum width of the toolbar window. If the window is
* resized smaller than this width, then the items in the toolbar will
* overlap.
*
* @param twm4nx The Twm4Nx session object
* @param title The window title string
* @param flags Window toolbar properties
* @return The minimum recommended window width.
*/
nxgl_coord_t minimumToolbarWidth(FAR CTwm4Nx *twm4nx,
FAR const NXWidgets::CNxString &title,
uint8_t flags);
}
#endif // __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX
Reference in New Issue View Git Blame Copy Permalink