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:  The Icon Manager now adds a Main Menu entry that will de-iconify the Icon Manager or raise to the top of the hieararchy if not iconfified.  This is useful when there are many open windows.

    apps/graphics/twm4nx:  In resize operation, don't let window get narrower than the minimum toolbar width.

    apps/graphics/twm4nx:  Add logic so that the main menu is place at (or near) the position where the background was clicked.

    apps/graphics/twm4nx:  Better integrate menus and iconifiction:  Bringup up a menu is like de-iconifcation, except there is no icon to be erases; taking down a menu is like iconification except that there is no icon to present.

    apps/graphics/nxwidgets:  Add methods to all windows to query if a window is visible or hidden.

    apps/graphics/twm4nx:  Use NxWidgets methods which work in all contexts instead of trying to come up with a way to know if a window is displayed through complex flags.
This commit is contained in:
Gregory Nutt 2019-05-09 13:31:12 -06:00
parent fea0109ab3
commit 06f479c471
20 changed files with 661 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
graphics/twm4nx/src/ciconmgr.cxx
View File

@ -64,6 +64,7 @@
#include "graphics/twm4nx/cfonts.hxx" #include "graphics/twm4nx/cfonts.hxx"
#include "graphics/twm4nx/cresize.hxx" #include "graphics/twm4nx/cresize.hxx"
#include "graphics/twm4nx/cmenus.hxx" #include "graphics/twm4nx/cmenus.hxx"
#include "graphics/twm4nx/cmainmenu.hxx"
#include "graphics/twm4nx/cwindow.hxx" #include "graphics/twm4nx/cwindow.hxx"
#include "graphics/twm4nx/cwindowevent.hxx" #include "graphics/twm4nx/cwindowevent.hxx"
#include "graphics/twm4nx/cwindowfactory.hxx" #include "graphics/twm4nx/cwindowfactory.hxx"
@ -168,13 +169,38 @@ bool CIconMgr::initialize(FAR const char *prefix)
return true; return true;
} }
/**
* Add Icon Manager menu items to the Main menu. This is really a
* part of the logic that belongs in initialize() but cannot be
* executed in that context because it assumes that the Main Menu
* logic is ready.
*
* @return True on success
*/
bool CIconMgr::addMenuItems(void)
{
// Add the Icon Manager entry to the Main Menu. This provides a quick
// way to de-iconfigy or to bring the Icon Manager to the top in a
// crowded desktop.
FAR CMainMenu *cmain = m_twm4nx->getMainMenu();
if (!cmain->addApplication(this))
{
twmerr("ERROR: Failed to add to the Main Menu\n");
return false;
}
return true;
}
/** /**
* Add a window to an icon manager * Add a window to an icon manager
* *
* @param win the TWM window structure * @param win the TWM window structure
*/ */
bool CIconMgr::add(FAR CWindow *cwin) bool CIconMgr::addWindow(FAR CWindow *cwin)
{ {
// Don't add the icon manager to itself // Don't add the icon manager to itself
@ -210,7 +236,9 @@ bool CIconMgr::add(FAR CWindow *cwin)
nxgl_coord_t rowHeight = getRowHeight(); nxgl_coord_t rowHeight = getRowHeight();
// Increase the Icon Manager window size, if necessary // Increase the height of the Icon Manager window, if necessary
// REVISIT: Should also set an optimal width. Currently just uses
// the defaults set when the window was created!
struct nxgl_size_s windowSize; struct nxgl_size_s windowSize;
if (!m_window->getWindowSize(&windowSize)) if (!m_window->getWindowSize(&windowSize))
@ -223,7 +251,7 @@ bool CIconMgr::add(FAR CWindow *cwin)
if (newHeight != windowSize.h) if (newHeight != windowSize.h)
{ {
windowSize.h = rowHeight * m_nWindows; windowSize.h = rowHeight * m_nWindows;
m_window->setWindowSize(&windowSize); // REVISIT: use resizeFrame() m_window->setWindowSize(&windowSize); // REVISIT: use resizeFrame()?
} }
} }
@ -251,11 +279,14 @@ bool CIconMgr::add(FAR CWindow *cwin)
* @param win the TWM window structure * @param win the TWM window structure
*/ */
void CIconMgr::remove(FAR struct SWindow *win) void CIconMgr::removeWindow(FAR CWindow *cwin)
{ {
FAR struct SWindowEntry *wentry = win->wentry; if (cwin != (FAR CWindow *)0)
{
// Find the entry containing this Window
if (wentry != NULL) FAR struct SWindowEntry *wentry = findEntry(cwin);
if (wentry != (FAR struct SWindowEntry *)0)
{ {
// Remove the list from the window structure // Remove the list from the window structure
@ -270,6 +301,7 @@ void CIconMgr::remove(FAR struct SWindow *win)
std::free(wentry); std::free(wentry);
pack(); pack();
} }
}
} }
/** /**
@ -470,6 +502,33 @@ bool CIconMgr::event(FAR struct SEventMsg *eventmsg)
switch (eventmsg->eventID) switch (eventmsg->eventID)
{ {
case EVENT_ICONMGR_DEICONIFY: // De-iconify or raise the Icon Manager
{
// Is the Icon manager conified?
if (m_window->isIconified())
{
// Yes.. De-iconify it
if (!m_window->deIconify())
{
twmerr("ERROR: Failed to de-iconify\n");
success = false;
}
}
else
{
// No.. Just bring it to the top of the hierachy
if (!m_window->raiseWindow())
{
twmerr("ERROR: Failed to raise window\n");
success = false;
}
}
}
break;
default: default:
success = false; success = false;
break; break;
@ -506,18 +565,17 @@ nxgl_coord_t CIconMgr::getRowHeight(void)
bool CIconMgr::createIconManagerWindow(FAR const char *prefix) bool CIconMgr::createIconManagerWindow(FAR const char *prefix)
{ {
static FAR const char *rootName = "Icon Manager";
// Create the icon manager name using any prefix provided by the creator // Create the icon manager name using any prefix provided by the creator
FAR char *allocName = (FAR char *)0;
if (prefix != (FAR const char *)0) if (prefix != (FAR const char *)0)
{ {
std::asprintf(&allocName, "%s %s", prefix, rootName); m_name.setText(prefix);
m_name.append(" Icon Manager");
}
else
{
m_name.setText("Icon Manager");
} }
FAR const char *name = (allocName == (FAR char *)0) ? rootName : allocName;
// Create the icon manager window. Customizations: // Create the icon manager window. Customizations:
// //
@ -526,16 +584,16 @@ bool CIconMgr::createIconManagerWindow(FAR const char *prefix)
// WFLAGS_NO_DELETE_BUTTON: The user cannot delete the Icon Manager window // WFLAGS_NO_DELETE_BUTTON: The user cannot delete the Icon Manager window
// WFLAGS_NO_RESIZE_BUTTON: The user cannot control the Icon Manager // WFLAGS_NO_RESIZE_BUTTON: The user cannot control the Icon Manager
// window size // window size
// WFLAGS_IS_ICONMGR: Yes, this is the Icon Manager window // WFLAGS_ICONMGR: Yes, this is the Icon Manager window
// WFLAGS_HIDDEN_WINDOW: The window is created in the hidden state // WFLAGS_HIDDEN: The window is created in the hidden state
CWindowFactory *factory = m_twm4nx->getWindowFactory(); CWindowFactory *factory = m_twm4nx->getWindowFactory();
uint8_t wflags = (WFLAGS_NO_MENU_BUTTON | WFLAGS_NO_DELETE_BUTTON | uint8_t wflags = (WFLAGS_NO_MENU_BUTTON | WFLAGS_NO_DELETE_BUTTON |
WFLAGS_NO_RESIZE_BUTTON | WFLAGS_IS_ICONMGR | WFLAGS_NO_RESIZE_BUTTON | WFLAGS_ICONMGR |
WFLAGS_HIDDEN_WINDOW); WFLAGS_HIDDEN);
m_window = factory->createWindow(name, &CONFIG_TWM4NX_ICONMGR_IMAGE, m_window = factory->createWindow(m_name, &CONFIG_TWM4NX_ICONMGR_IMAGE,
this, wflags); this, wflags);
if (m_window == (FAR CWindow *)0) if (m_window == (FAR CWindow *)0)
@ -544,13 +602,6 @@ bool CIconMgr::createIconManagerWindow(FAR const char *prefix)
return false; return false;
} }
// Free any temporary name strings
if (allocName != (FAR char *)0)
{
std::free(allocName);
}
// Adjust the height of the window (and probably the width too?) // Adjust the height of the window (and probably the width too?)
// The height of one row is determined (mostly) by the font height // The height of one row is determined (mostly) by the font height
@ -751,6 +802,38 @@ void CIconMgr::removeEntry(FAR struct SWindowEntry *wentry)
} }
} }
/**
* Find an entry in the icon manager
*
* @param cwin The window to find
* @return The incon manager entry (unless an error occurred)
*/
FAR struct SWindowEntry *CIconMgr::findEntry(FAR CWindow *cwin)
{
// Check each entry
FAR struct SWindowEntry *wentry;
for (wentry = m_head;
wentry != (FAR struct SWindowEntry *)0;
wentry = wentry->flink)
{
// Does this entry carry the window we are looking for?
if (wentry->cwin == cwin)
{
// Yes.. return the reference to this entry
return wentry;
}
}
// No matching entry found
return wentry;
}
/** /**
* Set active window * Set active window
* *

2
graphics/twm4nx/src/ciconwidget.cxx
View File

@ -712,7 +712,7 @@ bool CIconWidget::iconDrag(FAR struct SEventMsg *eventmsg)
if (!moveTo(newpos.x, newpos.y)) if (!moveTo(newpos.x, newpos.y))
{ {
gerr("ERROR: moveTo() failed\n"); twmerr("ERROR: moveTo() failed\n");
return false; return false;
} }

138
graphics/twm4nx/src/cmainmenu.cxx
View File

@ -45,11 +45,12 @@
#include <graphics/nxwidgets/cnxstring.hxx> #include <graphics/nxwidgets/cnxstring.hxx>
#include <graphics/twm4nx/twm4nx_widgetevents.hxx> #include <graphics/twm4nx/twm4nx_config.hxx>
#include <graphics/twm4nx/iapplication.hxx> #include <graphics/twm4nx/iapplication.hxx>
#include <graphics/twm4nx/ctwm4nx.hxx> #include <graphics/twm4nx/ctwm4nx.hxx>
#include <graphics/twm4nx/cmenus.hxx> #include <graphics/twm4nx/cmenus.hxx>
#include <graphics/twm4nx/cmainmenu.hxx> #include <graphics/twm4nx/cmainmenu.hxx>
#include <graphics/twm4nx/twm4nx_widgetevents.hxx>
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Implementation Class Definition // Implementation Class Definition
@ -98,14 +99,14 @@ bool CMainMenu::initialize(void)
m_mainMenu = new CMenus(m_twm4nx); m_mainMenu = new CMenus(m_twm4nx);
if (m_mainMenu == (FAR CMenus *)0) if (m_mainMenu == (FAR CMenus *)0)
{ {
gerr("ERROR: Failed to create the CMenus instance\n"); twmerr("ERROR: Failed to create the CMenus instance\n");
return false; return false;
} }
NXWidgets::CNxString menuName("Main Menu"); NXWidgets::CNxString menuName("Main Menu");
if (!m_mainMenu->initialize(menuName)) if (!m_mainMenu->initialize(menuName))
{ {
gerr("ERROR: Failed to initialize the CMenus instance\n"); twmerr("ERROR: Failed to initialize the CMenus instance\n");
delete m_mainMenu; delete m_mainMenu;
m_mainMenu = (FAR CMenus *)0; m_mainMenu = (FAR CMenus *)0;
return false; return false;
@ -131,7 +132,7 @@ bool CMainMenu::addApplication(FAR IApplication *app)
if (mmitem == (FAR struct SMainMenuItem *)0) if (mmitem == (FAR struct SMainMenuItem *)0)
{ {
gerr("ERROR: Failed to allocate the main menu entry\n"); twmerr("ERROR: Failed to allocate the main menu entry\n");
return false; return false;
} }
@ -141,13 +142,12 @@ bool CMainMenu::addApplication(FAR IApplication *app)
// Add the new menu item to the main menu // Add the new menu item to the main menu
FAR NXWidgets::CNxString appName; FAR NXWidgets::CNxString appName = app->getName();
app->getName(appName);
if (!m_mainMenu->addMenuItem(appName, app->getSubMenu(), if (!m_mainMenu->addMenuItem(appName, app->getSubMenu(),
app->getEventHandler(), app->getEvent())) app->getEventHandler(), app->getEvent()))
{ {
gerr("ERROR: addMenuItem failed\n"); twmerr("ERROR: addMenuItem failed\n");
std::free(mmitem); std::free(mmitem);
return false; return false;
} }
@ -181,12 +181,24 @@ bool CMainMenu::event(FAR struct SEventMsg *eventmsg)
if (!m_mainMenu->isVisible()) if (!m_mainMenu->isVisible())
{ {
// No.. then make it visible now // No.. then make it visible now
// First, we select a position as close to the background click
// as possible
// REVISIT: Need to reset the menu to its initial state success = selectMainMenuPosition(eventmsg->pos);
// REVISIT: Need to position the main menu as close as if (!success)
// possible to the click position in eventmsg. {
twmerr("ERROR: selectMainMenuPosition() failed\n");
}
else
{
// Make the main menu visible
m_mainMenu->show(); // Make the main menu visible success = m_mainMenu->show();
if (!success)
{
twmerr("ERROR: Failed to show the menu\n");
}
}
} }
break; break;
@ -256,3 +268,107 @@ void CMainMenu::removeEntry(FAR struct SMainMenuItem *mmitem)
mmitem->flink = NULL; mmitem->flink = NULL;
mmitem->blink = NULL; mmitem->blink = NULL;
} }
/**
* Select a position for the Main Menu which is as close as possible
* the background click position.
*
* @param clickPos The background click position
*/
bool CMainMenu::selectMainMenuPosition(FAR const struct nxgl_point_s &clickPos)
{
// Get the size of the main menu frame
struct nxgl_size_s frameSize;
m_mainMenu->getFrameSize(&frameSize);
// Get the size of the display
struct nxgl_size_s displaySize;
m_twm4nx->getDisplaySize(&displaySize);
// Determine the best new Y position for the menu.
struct nxgl_point_s framePos;
// Check if the menu does not fit on the display. This is really an error
// condition since menu items are not accessible
//
// REVISIT: Consider using a scrolling text box to handle this case.
if (frameSize.h > displaySize.h)
{
// Just position at the top of the display so that at least the
// toolbar will be visible
framePos.y = 0;
}
// Try to position the menu at the same Y position as the background click
else if (clickPos.y + frameSize.h <= displaySize.h)
{
framePos.y = clickPos.y;
}
// Otherwise, set the Y position so that the entire menu is on the display
// with the bottom of the menu at the bottom of the display.
else
{
framePos.y = displaySize.h - frameSize.h;
}
// Determine the best new Y position for the menu.
// Check if the menu does not fit on the display. This is really unlikely.
if (frameSize.w > displaySize.w)
{
// Just position at the right of the display so that at least the
// toolbar minimize button will be visible
framePos.x = displaySize.w - frameSize.w; // Negative position!
}
// Try to position the menu at the same X position as the background click
// So that it appears to the right of the click position.
else if (clickPos.x + frameSize.w <= displaySize.w)
{
framePos.x = clickPos.x;
}
// Try to position the menu at the same X position as the background click
// So that it appears to the left of the click position.
else if (clickPos.x >= frameSize.w)
{
framePos.x = clickPos.x - frameSize.w;
}
// Otherwise, set the X position so that the entire menu is on the display
// on the left or right of the display. This cases are not possible unless
// the width of the menu is greater than half of the width of the display.
else if (clickPos.x > displaySize.w / 2)
{
// Position at the right of the display
framePos.x = displaySize.w - frameSize.w;
}
else
{
// Position at the left of the display
framePos.x = 0;
}
// And, finally, set the new main menu frame position
twminfo("Click position: (%d,%d) Main menu position: (%d,%d)\n",
clickPos.x, clickPos.y, framePos.x, framePos.y);
return m_mainMenu->setFramePosition(&framePos);
}

41
graphics/twm4nx/src/cmenus.cxx
View File

@ -84,12 +84,15 @@
// WFLAGS_NO_MENU_BUTTON: No menu buttons on menus // WFLAGS_NO_MENU_BUTTON: No menu buttons on menus
// WFLAGS_NO_DELETE_BUTTON: Menus cannot be deleted in this manner. // WFLAGS_NO_DELETE_BUTTON: Menus cannot be deleted in this manner.
// WFLAGS_NO_RESIZE_BUTTON: Menus cannot be resized // WFLAGS_NO_RESIZE_BUTTON: Menus cannot be resized
// WFLAGS_HIDDEN_WINDOW: Menu windows are always created in the // WFLAGS_MENU: Menu windows are always created in the
// hidden state. When the menu is selected, // hidden and iconifed state. When the menu is
// then it should be shown. // selected, then it should be de-iconfied to
// be shown.
// WFLAGS_HIDDEN: Redundant
#define MENU_WINDOW_FLAGS (WFLAGS_NO_MENU_BUTTON | WFLAGS_NO_DELETE_BUTTON | \ #define MENU_WINDOW_FLAGS (WFLAGS_NO_MENU_BUTTON | WFLAGS_NO_DELETE_BUTTON | \
WFLAGS_NO_RESIZE_BUTTON | WFLAGS_HIDDEN_WINDOW) WFLAGS_NO_RESIZE_BUTTON | WFLAGS_MENU | \
WFLAGS_HIDDEN)
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Class Implementations // Class Implementations
@ -117,7 +120,6 @@ CMenus::CMenus(CTwm4Nx *twm4nx)
m_nMenuItems = 0; // No menu items yet m_nMenuItems = 0; // No menu items yet
m_menuDepth = 0; // No menus up m_menuDepth = 0; // No menus up
m_entryHeight = 0; // Menu entry height m_entryHeight = 0; // Menu entry height
m_visible = false; // Menu not visible
m_menuPull = false; // No pull right entry m_menuPull = false; // No pull right entry
// Windows // Windows
@ -491,7 +493,7 @@ bool CMenus::createMenuWindow(void)
m_menuWindow = new CWindow(m_twm4nx); m_menuWindow = new CWindow(m_twm4nx);
if (m_menuWindow == (FAR CWindow *)0) if (m_menuWindow == (FAR CWindow *)0)
{ {
gerr("ERRR: Failed to instantiate menu window\n"); twmerr("ERRR: Failed to instantiate menu window\n");
return false; return false;
} }
@ -508,7 +510,7 @@ bool CMenus::createMenuWindow(void)
(FAR const struct NXWidgets::SRlePaletteBitmap *)0, (FAR const struct NXWidgets::SRlePaletteBitmap *)0,
(FAR CIconMgr *)0, MENU_WINDOW_FLAGS)) (FAR CIconMgr *)0, MENU_WINDOW_FLAGS))
{ {
gerr("ERRR: Failed to initialize menu window\n"); twmerr("ERRR: Failed to initialize menu window\n");
delete m_menuWindow; delete m_menuWindow;
m_menuWindow = (FAR CWindow *)0; m_menuWindow = (FAR CWindow *)0;
return false; return false;
@ -518,12 +520,12 @@ bool CMenus::createMenuWindow(void)
} }
/** /**
* Calculate the optimal menu window size * Calculate the optimal menu frame size
* *
* @result True is returned on success * @param frameSize The location to return the calculated frame size
*/ */
void CMenus::getMenuWindowSize(FAR struct nxgl_size_s &size) void CMenus::getMenuFrameSize(FAR struct nxgl_size_s &frameSize)
{ {
CFonts *fonts = m_twm4nx->getFonts(); CFonts *fonts = m_twm4nx->getFonts();
FAR NXWidgets::CNxFont *menuFont = fonts->getMenuFont(); FAR NXWidgets::CNxFont *menuFont = fonts->getMenuFont();
@ -566,9 +568,7 @@ void CMenus::getMenuWindowSize(FAR struct nxgl_size_s &size)
struct nxgl_size_s displaySize; struct nxgl_size_s displaySize;
m_twm4nx->getDisplaySize(&displaySize); m_twm4nx->getDisplaySize(&displaySize);
struct nxgl_size_s frameSize;
menuToFrameSize(&menuSize, &frameSize); menuToFrameSize(&menuSize, &frameSize);
if (frameSize.w > displaySize.w) if (frameSize.w > displaySize.w)
{ {
frameSize.w = displaySize.w; frameSize.w = displaySize.w;
@ -578,9 +578,18 @@ void CMenus::getMenuWindowSize(FAR struct nxgl_size_s &size)
{ {
frameSize.h = displaySize.h; frameSize.h = displaySize.h;
} }
}
// Set the new menu window size /**
* Calculate the optimal menu window size
*
* @param frameSize The location to return the calculated window size
*/
void CMenus::getMenuWindowSize(FAR struct nxgl_size_s &size)
{
struct nxgl_size_s frameSize;
getMenuFrameSize(frameSize);
frameToMenuSize(&frameSize, &size); frameToMenuSize(&frameSize, &size);
} }
@ -594,10 +603,10 @@ bool CMenus::setMenuWindowSize(void)
{ {
// Get the optimal menu window size // Get the optimal menu window size
struct nxgl_size_s menuSize; struct nxgl_size_s frameSize;
getMenuWindowSize(menuSize); getMenuFrameSize(frameSize);
if (!m_menuWindow->setWindowSize(&menuSize)) if (!m_menuWindow->resizeFrame(&frameSize, (FAR const struct nxgl_point_s *)0))
{ {
twmerr("ERROR: Failed to set window size\n"); twmerr("ERROR: Failed to set window size\n");
return false; return false;

20
graphics/twm4nx/src/cnxterm.cxx
View File

@ -217,7 +217,7 @@ bool CNxTerm::run(void)
if (m_pid >= 0 || m_nxterm != 0) if (m_pid >= 0 || m_nxterm != 0)
{ {
gerr("ERROR: All ready running or connected\n"); twmerr("ERROR: All ready running or connected\n");
return false; return false;
} }
@ -227,7 +227,7 @@ bool CNxTerm::run(void)
{ {
// This might fail if a signal is received while we are waiting. // This might fail if a signal is received while we are waiting.
gerr("ERROR: Failed to get semaphore\n"); twmerr("ERROR: Failed to get semaphore\n");
return false; return false;
} }
@ -273,7 +273,7 @@ bool CNxTerm::run(void)
bool result = true; bool result = true;
if (m_pid < 0) if (m_pid < 0)
{ {
gerr("ERROR: Failed to create the NxTerm task\n"); twmerr("ERROR: Failed to create the NxTerm task\n");
result = false; result = false;
} }
else else
@ -304,7 +304,7 @@ bool CNxTerm::run(void)
// sem_timedwait failed OR the NxTerm task reported a // sem_timedwait failed OR the NxTerm task reported a
// failure. Stop the application // failure. Stop the application
gerr("ERROR: Failed start the NxTerm task\n"); twmerr("ERROR: Failed start the NxTerm task\n");
stop(); stop();
result = false; result = false;
} }
@ -452,7 +452,7 @@ int CNxTerm::nxterm(int argc, char *argv[])
if (on_exit(exitHandler, g_nxtermvars.console) != 0) if (on_exit(exitHandler, g_nxtermvars.console) != 0)
{ {
gerr("ERROR: on_exit failed\n"); twmerr("ERROR: on_exit failed\n");
goto errout; goto errout;
} }
@ -469,7 +469,7 @@ int CNxTerm::nxterm(int argc, char *argv[])
ret = boardctl(BOARDIOC_NXTERM, (uintptr_t)&nxcreate); ret = boardctl(BOARDIOC_NXTERM, (uintptr_t)&nxcreate);
if (ret < 0) if (ret < 0)
{ {
gerr("ERROR: boardctl(BOARDIOC_NXTERM) failed: %d\n", errno); twmerr("ERROR: boardctl(BOARDIOC_NXTERM) failed: %d\n", errno);
goto errout; goto errout;
} }
@ -494,7 +494,7 @@ int CNxTerm::nxterm(int argc, char *argv[])
#endif #endif
if (fd < 0) if (fd < 0)
{ {
gerr("ERROR: Failed open the console device\n"); twmerr("ERROR: Failed open the console device\n");
(void)unlink(devname); (void)unlink(devname);
goto errout; goto errout;
} }
@ -623,7 +623,7 @@ IApplication *CNxTermFactory::create(void)
CApplicationWindow *window = m_twm4nx->openApplicationWindow(); CApplicationWindow *window = m_twm4nx->openApplicationWindow();
if (!window) if (!window)
{ {
gerr("ERROR: Failed to create CApplicationWindow\n"); twmerr("ERROR: Failed to create CApplicationWindow\n");
return (IApplication *)0; return (IApplication *)0;
} }
@ -631,7 +631,7 @@ IApplication *CNxTermFactory::create(void)
if (!window->open()) if (!window->open())
{ {
gerr("ERROR: Failed to open CApplicationWindow\n"); twmerr("ERROR: Failed to open CApplicationWindow\n");
delete window; delete window;
return (IApplication *)0; return (IApplication *)0;
} }
@ -642,7 +642,7 @@ IApplication *CNxTermFactory::create(void)
CNxTerm *nxterm = new CNxTerm(m_twm4nx, window); CNxTerm *nxterm = new CNxTerm(m_twm4nx, window);
if (!nxterm) if (!nxterm)
{ {
gerr("ERROR: Failed to instantiate CNxTerm\n"); twmerr("ERROR: Failed to instantiate CNxTerm\n");
delete window; delete window;
return (IApplication *)0; return (IApplication *)0;
} }

9
graphics/twm4nx/src/ctwm4nx.cxx
View File

@ -309,6 +309,15 @@ bool CTwm4Nx::run(void)
return false; return false;
} }
// Now, complete the initialization of some preceding instances that
// depend on the Main Menu being in place
if (!m_iconmgr->addMenuItems())
{
cleanup();
return false;
}
// Cache a CResize instance for use across the session // Cache a CResize instance for use across the session
m_resize = new CResize(this); m_resize = new CResize(this);

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

@ -139,6 +139,7 @@ CWindow::CWindow(CTwm4Nx *twm4nx)
m_nxWin = (FAR NXWidgets::CNxTkWindow *)0; m_nxWin = (FAR NXWidgets::CNxTkWindow *)0;
m_toolbar = (FAR NXWidgets::CNxToolbar *)0; m_toolbar = (FAR NXWidgets::CNxToolbar *)0;
m_minWidth = 1;
m_zoom = ZOOM_NONE; m_zoom = ZOOM_NONE;
m_modal = false; m_modal = false;
@ -223,6 +224,15 @@ bool CWindow::initialize(FAR const NXWidgets::CNxString &name,
m_name.setText(name); m_name.setText(name);
} }
// Get the minimum window size. We need this minimum later for resizing.
// If there is no toolbar, leave the minimum at one pixel as it was set by
// the constructor.
if (WFLAGS_HAVE_TOOLBAR(flags))
{
m_minWidth = minimumToolbarWidth(m_twm4nx, m_name, flags);
}
// Do initial clip to the maximum window size // Do initial clip to the maximum window size
struct nxgl_size_s maxWindow; struct nxgl_size_s maxWindow;
@ -348,38 +358,6 @@ bool CWindow::initialize(FAR const NXWidgets::CNxString &name,
return true; return true;
} }
/**
* CWindow Initializer (unlike the constructor, this may fail)
*
* @param name The the name of the window (and its icon)
* @param pos The initialize 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
* @param flags Toolbar customizations see WFLAGS_NO_* definition
* @return True if the window was successfully initialize; false on
* any failure,
*/
bool CWindow::initialize(FAR const char *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)
{
NXWidgets::CNxString nxname;
if (name == (FAR const char *)0)
{
nxname.setText(GNoName);
}
else
{
nxname.setText(name);
}
return initialize(nxname, pos, size, sbitmap, iconMgr, flags);
}
/** /**
* Get the raw window size (including toolbar and frame) * Get the raw window size (including toolbar and frame)
* *
@ -406,12 +384,12 @@ bool CWindow::getFrameSize(FAR struct nxgl_size_s *framesize)
* Update the window frame after a resize operation (includes the toolbar * Update the window frame after a resize operation (includes the toolbar
* and user window) * and user window)
* *
* @param size The new window frame size * @param frameSize The new window frame size
* @param pos The frame location which may also have changed * @param framePos The frame location which may also have changed
*/ */
bool CWindow::resizeFrame(FAR const struct nxgl_size_s *size, bool CWindow::resizeFrame(FAR const struct nxgl_size_s *frameSize,
FAR struct nxgl_point_s *pos) FAR const struct nxgl_point_s *framePos)
{ {
// Account for toolbar and border // Account for toolbar and border
@ -419,25 +397,25 @@ bool CWindow::resizeFrame(FAR const struct nxgl_size_s *size,
delta.w = 2 * CONFIG_NXTK_BORDERWIDTH; delta.w = 2 * CONFIG_NXTK_BORDERWIDTH;
delta.h = m_tbHeight + 2 * CONFIG_NXTK_BORDERWIDTH; delta.h = m_tbHeight + 2 * CONFIG_NXTK_BORDERWIDTH;
// Don't set the window size smaller than one pixel // Don't set the window size smaller than the minimum window size
struct nxgl_size_s winsize; struct nxgl_size_s winsize;
if (size->w <= delta.w) if (frameSize->w <= m_minWidth + delta.w)
{ {
winsize.w = 1; winsize.w = m_minWidth;
} }
else else
{ {
winsize.w = size->w - delta.w; winsize.w = frameSize->w - delta.w;
} }
if (size->h <= delta.h) if (frameSize->h <= delta.h)
{ {
winsize.h = 1; winsize.h = 1;
} }
else else
{ {
winsize.h = size->h - delta.h; winsize.h = frameSize->h - delta.h;
} }
// Set the usable window size // Set the usable window size
@ -449,14 +427,17 @@ bool CWindow::resizeFrame(FAR const struct nxgl_size_s *size,
return false; return false;
} }
if (framePos != (FAR const struct nxgl_point_s *)0)
{
// Set the new frame position (in case it changed too) // Set the new frame position (in case it changed too)
success = setFramePosition(pos); success = setFramePosition(framePos);
if (!success) if (!success)
{ {
twmerr("ERROR: Failed to setSize()\n"); twmerr("ERROR: Failed to setFramePosition()\n");
return false; return false;
} }
}
// Synchronize with the NX server to make sure that the new geometry is // Synchronize with the NX server to make sure that the new geometry is
// truly in effect. // truly in effect.
@ -508,7 +489,13 @@ bool CWindow::setFramePosition(FAR const struct nxgl_point_s *framepos)
return m_nxWin->setPosition(&winpos); return m_nxWin->setPosition(&winpos);
} }
void CWindow::iconify(void) /**
* Minimize (iconify) the window
*
* @return True if the operation was successful
*/
bool CWindow::iconify(void)
{ {
if (!isIconified()) if (!isIconified())
{ {
@ -522,6 +509,8 @@ void CWindow::iconify(void)
m_iconified = true; m_iconified = true;
m_nxWin->hide(); m_nxWin->hide();
// Menu windows don't have an icon
if (m_iconWidget != (FAR CIconWidget *)0) if (m_iconWidget != (FAR CIconWidget *)0)
{ {
// Enable and redraw the icon widget and lower the main window // Enable and redraw the icon widget and lower the main window
@ -534,9 +523,17 @@ void CWindow::iconify(void)
m_nxWin->synchronize(); m_nxWin->synchronize();
} }
return true;
} }
void CWindow::deIconify(void) /**
* De-iconify the window
*
* @return True if the operation was successful
*/
bool CWindow::deIconify(void)
{ {
// De-iconify the window // De-iconify the window
@ -570,7 +567,7 @@ void CWindow::deIconify(void)
FAR CBackground *backgd = m_twm4nx->getBackground(); FAR CBackground *backgd = m_twm4nx->getBackground();
if (!backgd->redrawBackgroundWindow(&rect, false)) if (!backgd->redrawBackgroundWindow(&rect, false))
{ {
gerr("ERROR: redrawBackgroundWindow() failed\n"); twmerr("ERROR: redrawBackgroundWindow() failed\n");
} }
} }
@ -578,6 +575,8 @@ void CWindow::deIconify(void)
m_nxWin->synchronize(); m_nxWin->synchronize();
} }
return true;
} }
/** /**
@ -604,7 +603,7 @@ bool CWindow::event(FAR struct SEventMsg *eventmsg)
case EVENT_WINDOW_DEICONIFY: // De-iconify and raise the main window case EVENT_WINDOW_DEICONIFY: // De-iconify and raise the main window
{ {
deIconify(); success = deIconify();
} }
break; break;
@ -627,7 +626,7 @@ bool CWindow::event(FAR struct SEventMsg *eventmsg)
{ {
// Minimize (iconify) the window // Minimize (iconify) the window
iconify(); success = iconify();
} }
break; break;
@ -723,10 +722,12 @@ bool CWindow::createMainWindow(FAR const nxgl_size_s *winsize,
FAR CWindowEvent *control = new CWindowEvent(m_twm4nx, (FAR void *)this); FAR CWindowEvent *control = new CWindowEvent(m_twm4nx, (FAR void *)this);
control->registerDragEventHandler(this, (uintptr_t)1); control->registerDragEventHandler(this, (uintptr_t)1);
// 4. Create the window // 4. Create the window. Handling provided flags. NOTE: that menu windows
// are always created hidden and in the iconified state (although they
// have no icons)
uint8_t cflags = NXBE_WINDOW_RAMBACKED; uint8_t cflags = NXBE_WINDOW_RAMBACKED;
if (WFLAGS_IS_HIDDEN_WINDOW(flags)) if (WFLAGS_IS_HIDDEN(flags) | WFLAGS_IS_MENU(flags))
{ {
cflags |= NXBE_WINDOW_HIDDEN; cflags |= NXBE_WINDOW_HIDDEN;
} }
@ -760,6 +761,10 @@ bool CWindow::createMainWindow(FAR const nxgl_size_s *winsize,
return false; return false;
} }
// Menu windows are always created hidden and in the iconified state
// (although they have no icons)
m_iconified = WFLAGS_IS_MENU(flags);
return true; return true;
} }
@ -1542,7 +1547,7 @@ bool CWindow::windowDrag(FAR struct SEventMsg *eventmsg)
struct nxgl_point_s oldPos; struct nxgl_point_s oldPos;
if (!getFramePosition(&oldPos)) if (!getFramePosition(&oldPos))
{ {
gerr("ERROR: getFramePosition() failed\n") ; twmerr("ERROR: getFramePosition() failed\n") ;
return false; return false;
} }
@ -1592,7 +1597,7 @@ bool CWindow::windowDrag(FAR struct SEventMsg *eventmsg)
{ {
if (!setFramePosition(&newPos)) if (!setFramePosition(&newPos))
{ {
gerr("ERROR: setFramePosition failed\n"); twmerr("ERROR: setFramePosition failed\n");
return false; return false;
} }

34
graphics/twm4nx/src/cwindowfactory.cxx
View File

@ -106,11 +106,11 @@ CWindowFactory::~CWindowFactory(void)
*/ */
FAR CWindow * FAR CWindow *
CWindowFactory::createWindow(FAR const char *name, CWindowFactory::createWindow(FAR NXWidgets::CNxString &name,
FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap, FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap,
FAR CIconMgr *iconMgr, uint8_t flags) FAR CIconMgr *iconMgr, uint8_t flags)
{ {
twminfo("name=%p\n", name); twminfo("flags=%02x\n", flags);
// Allocate a container for the Twm4NX window // Allocate a container for the Twm4NX window
@ -118,8 +118,7 @@ FAR CWindow *
(FAR struct SWindow *)std::zalloc(sizeof(struct SWindow)); (FAR struct SWindow *)std::zalloc(sizeof(struct SWindow));
if (win == (FAR struct SWindow *)0) if (win == (FAR struct SWindow *)0)
{ {
twmerr("ERROR: Unable to allocate memory to manage window %s\n", twmerr("ERROR: Unable to allocate memory to manage window\n");
name);
return (FAR CWindow *)0; return (FAR CWindow *)0;
} }
@ -180,16 +179,20 @@ FAR CWindow *
m_winpos.x += 30; m_winpos.x += 30;
m_winpos.y += 30; m_winpos.y += 30;
// Add the window into the Twm4Nx window list // Add the window into the window list
addWindow(win); addWindowContainer(win);
// Add the window container to the icon manager // Add the window to the icon manager if it is a regular window (i.e., if
// it is not the Icon Manager Window and it is not a Menu Window)
if (!WFLAGS_IS_ICONMGR(flags) && !WFLAGS_IS_MENU(flags))
{
CIconMgr *iconmgr = m_twm4nx->getIconMgr(); CIconMgr *iconmgr = m_twm4nx->getIconMgr();
DEBUGASSERT(iconmgr != (CIconMgr *)0); DEBUGASSERT(iconmgr != (CIconMgr *)0);
(void)iconmgr->add(win->cwin); (void)iconmgr->addWindow(win->cwin);
}
// Return the contained window // Return the contained window
@ -226,9 +229,18 @@ void CWindowFactory::destroyWindow(FAR CWindow *cwin)
{ {
// Remove the window container from the window list // Remove the window container from the window list
removeWindow(win); removeWindowContainer(win);
} }
// Remove the window from the Icon Manager
// Add the window to the icon manager
CIconMgr *iconmgr = m_twm4nx->getIconMgr();
DEBUGASSERT(iconmgr != (CIconMgr *)0);
(void)iconmgr->removeWindow(cwin);
// Delete the contained CWindow instance // Delete the contained CWindow instance
delete cwin; delete cwin;
@ -297,7 +309,7 @@ bool CWindowFactory::event(FAR struct SEventMsg *eventmsg)
* @param win. The window container to be added to the list. * @param win. The window container to be added to the list.
*/ */
void CWindowFactory::addWindow(FAR struct SWindow *win) void CWindowFactory::addWindowContainer(FAR struct SWindow *win)
{ {
win->blink = (FAR struct SWindow *)0; win->blink = (FAR struct SWindow *)0;
win->flink = m_windowHead; win->flink = m_windowHead;
@ -316,7 +328,7 @@ void CWindowFactory::addWindow(FAR struct SWindow *win)
* @param win. The window container to be removed from the list. * @param win. The window container to be removed from the list.
*/ */
void CWindowFactory::removeWindow(FAR struct SWindow *win) void CWindowFactory::removeWindowContainer(FAR struct SWindow *win)
{ {
FAR struct SWindow *prev = win->blink; FAR struct SWindow *prev = win->blink;
FAR struct SWindow *next = win->flink; FAR struct SWindow *next = win->flink;

13
include/graphics/nxwidgets/cbgwindow.hxx
View File

@ -228,6 +228,19 @@ namespace NXWidgets
return false; return false;
} }
/**
* Return true if the window is currently being displayed
*
* @return Always returns true.
*/
inline bool isVisible(void)
{
// The background is always visible (although perhaps obscured)
return true;
}
/** /**
* Show a hidden window * Show a hidden window
* *

11
include/graphics/nxwidgets/cnxtkwindow.hxx
View File

@ -248,6 +248,17 @@ namespace NXWidgets
return nxtk_lower(m_hNxTkWindow) == OK; return nxtk_lower(m_hNxTkWindow) == OK;
} }
/**
* Return true if the window is currently being displayed
*
* @return True if the window is visible
*/
inline bool isVisible(void)
{
return !nxtk_ishidden(m_hNxTkWindow);
}
/** /**
* Show a hidden window * Show a hidden window
* *

25
include/graphics/nxwidgets/cnxtoolbar.hxx
View File

@ -222,31 +222,38 @@ namespace NXWidgets
} }
/** /**
* Show a hidden window. The toolbar is a component of the containing, * Return true if the toolbar is currently being displayed
*
* @return True if the window is visible
*/
inline bool isVisible(void)
{
return !nxtk_ishidden(m_hNxTkWindow);
}
/**
* Show a hidden toolbar. The toolbar is a component of the containing,
* parent, framed window. It cannot be shown separately. * parent, framed window. It cannot be shown separately.
* *
* @return Always returns false. * @return True on success, false on any failure.
*/ */
inline bool show(void) inline bool show(void)
{ {
// The background is always visible (although perhaps obscured) return nxtk_setvisibility(m_hNxTkWindow, false) == OK;
return false;
} }
/** /**
* Hide a visible window. The toolbar is a component of the containing, * Hide a visible window. The toolbar is a component of the containing,
* parent, framed window. It cannot be hidden separately. * parent, framed window. It cannot be hidden separately.
* *
* @return Always returns false. * @return True on success, false on any failure.
*/ */
inline bool hide(void) inline bool hide(void)
{ {
// The background cannot be hidden return nxtk_setvisibility(m_hNxTkWindow, true) == OK;
return false;
} }
/** /**

11
include/graphics/nxwidgets/cnxwindow.hxx
View File

@ -217,6 +217,17 @@ namespace NXWidgets
return nx_lower(m_hNxWindow) == OK; return nx_lower(m_hNxWindow) == OK;
} }
/**
* Return true if the window is currently being displayed
*
* @return True if the window is visible
*/
inline bool isVisible(void)
{
return !nx_ishidden(m_hNxWindow);
}
/** /**
* Show a hidden window * Show a hidden window
* *

8
include/graphics/nxwidgets/inxwindow.hxx
View File

@ -190,6 +190,14 @@ namespace NXWidgets
virtual bool lower(void) = 0; virtual bool lower(void) = 0;
/**
* Return true if the window is currently being displayed
*
* @return True if the window is visible
*/
virtual bool isVisible(void) = 0;
/** /**
* Show a hidden window * Show a hidden window
* *

113
include/graphics/twm4nx/ciconmgr.hxx
View File

@ -52,7 +52,9 @@
#include <nuttx/nx/nxglib.h> #include <nuttx/nx/nxglib.h>
#include "graphics/twm4nx/cwindow.hxx" #include "graphics/twm4nx/cwindow.hxx"
#include "graphics/twm4nx/ctwm4nxevent.hxx" #include "graphics/twm4nx/cmainmenu.hxx"
#include "graphics/twm4nx/iapplication.hxx"
#include "graphics/twm4nx/twm4nx_widgetevents.hxx"
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Implementation Classes // Implementation Classes
@ -83,12 +85,15 @@ namespace Twm4Nx
bool down; bool down;
}; };
class CIconMgr : protected NXWidgets::CWidgetEventHandler, public CTwm4NxEvent class CIconMgr : protected NXWidgets::CWidgetEventHandler,
protected IApplication,
public CTwm4NxEvent
{ {
private: private:
FAR CTwm4Nx *m_twm4nx; /**< Cached Twm4Nx session */ FAR CTwm4Nx *m_twm4nx; /**< Cached Twm4Nx session */
mqd_t m_eventq; /**< NxWidget event message queue */ mqd_t m_eventq; /**< NxWidget event message queue */
NXWidgets::CNxString m_name; /**< The Icon Manager name */
FAR struct SWindowEntry *m_head; /**< Head of the window list */ FAR struct SWindowEntry *m_head; /**< Head of the window list */
FAR struct SWindowEntry *m_tail; /**< Tail of the window list */ FAR struct SWindowEntry *m_tail; /**< Tail of the window list */
FAR struct SWindowEntry *m_active; /**< The active entry */ FAR struct SWindowEntry *m_active; /**< The active entry */
@ -138,6 +143,15 @@ namespace Twm4Nx
void removeEntry(FAR struct SWindowEntry *wentry); void removeEntry(FAR struct SWindowEntry *wentry);
/**
* Find an entry in the icon manager
*
* @param cwin The window to find
* @return The incon manager entry (unless an error occurred)
*/
FAR struct SWindowEntry *findEntry(FAR CWindow *cwin);
/** /**
* Set active window * Set active window
* *
@ -161,13 +175,82 @@ namespace Twm4Nx
void freeWEntry(FAR struct SWindowEntry *wentry); void freeWEntry(FAR struct SWindowEntry *wentry);
/** /**
* Handle a widget action event. This will be a button pre-release event. * Handle a widget action event, overriding the CWidgetEventHandler
* method. This will indicate a button pre-release event.
* *
* @param e The event data. * @param e The event data.
*/ */
void handleActionEvent(const NXWidgets::CWidgetEventArgs &e); void handleActionEvent(const NXWidgets::CWidgetEventArgs &e);
/**
* Return the name of the application. This is the string that will
* appear in the Main Menu item. This overrides the method from
* IApplication
*
* @param name The name of the application.
*/
inline const NXWidgets::CNxString getName(void)
{
return m_name;
}
/**
* Return any submenu item associated with the menu entry. If a non-
* null value is returned, then this sub-menu will be brought up when
* the menu entry is selected. Otherwise, the start() method will be
* called. These two behaviors are mutually exlusive. This overrides
* the method from IApplication.
*
* @return This implementation will always return a null value.
*/
inline FAR CMenus *getSubMenu(void)
{
return (FAR CMenus *)0;
}
/**
* This is the application start up function. This function will be
* called when its menu entry has been selected in order to start the
* application. This function will not be called in this implementation
*
* @param twm4nx The Twm4Nx session object. Use with care! The CTwm4Nx
* logic runs on a different thread and some of the methods of the
* class may not be thread safe.
*/
inline void start(FAR CTwm4Nx *twm4nx)
{
}
/**
* External applications may provide their own event handler that runs
* when the the menu item is selection. If so, then this method will
* return the instance of CTwm4NxEvent that will handle the event. This
* method always returns NULL in this case.
*
* @return. null is always returned in this impementation.
*/
inline FAR CTwm4NxEvent *getEventHandler(void)
{
return (FAR CTwm4NxEvent *)0;
}
/**
* Get the Twm4Nx event that will be generated when the menu item is
* selected.
*
* @return. This function returns .
*/
inline uint16_t getEvent(void)
{
return EVENT_ICONMGR_DEICONIFY;
}
public: public:
/** /**
@ -186,28 +269,40 @@ namespace Twm4Nx
~CIconMgr(void); ~CIconMgr(void);
/** /**
* Create and initialize the icon manager window * Create and initialize the icon manager window.
* *
* @param name The prefix for this icon manager name * @param name The prefix for this icon manager name
* @return True on success
*/ */
bool initialize(FAR const char *prefix); bool initialize(FAR const char *prefix);
/** /**
* Add a window to an the icon manager * Add Icon Manager menu items to the Main menu. This is really a
* part of the logic that belongs in initialize() but cannot be
* executed in that context because it assumes that the Main Menu
* logic is ready.
* *
* @param win the TWM window structure * @return True on success
*/ */
bool add(FAR CWindow *win); bool addMenuItems(void);
/**
* Add a window to an the icon manager
*
* @param cwin the TWM window structure
*/
bool addWindow(FAR CWindow *cwin);
/** /**
* Remove a window from the icon manager * Remove a window from the icon manager
* *
* @param win the TWM window structure * @param cwin the TWM window structure
*/ */
void remove(FAR struct SWindow *win); void removeWindow(FAR CWindow *cwin);
/** /**
* Hide the icon manager * Hide the icon manager

10
include/graphics/twm4nx/cmainmenu.hxx
View File

@ -101,6 +101,16 @@ namespace Twm4Nx
void removeEntry(FAR struct SMainMenuItem *mmitem); void removeEntry(FAR struct SMainMenuItem *mmitem);
/**
* Select a position for the Main Menu which is as close as possible
* the background click position.
*
* @param clickPos The background click position
* @return True is returned if the position was set correctly
*/
bool selectMainMenuPosition(FAR const struct nxgl_point_s &clickPos);
public: public:
/** /**

70
include/graphics/twm4nx/cmenus.hxx
View File

@ -123,7 +123,6 @@ namespace Twm4Nx
uint16_t m_nMenuItems; /**< Number of items in the menu */ uint16_t m_nMenuItems; /**< Number of items in the menu */
uint8_t m_menuDepth; /**< Number of menus up */ uint8_t m_menuDepth; /**< Number of menus up */
bool m_menuPull; /**< Is there a pull right entry? */ bool m_menuPull; /**< Is there a pull right entry? */
bool m_visible; /**< True: The menu is visible */
char m_info[INFO_LINES][INFO_SIZE]; char m_info[INFO_LINES][INFO_SIZE];
void identify(FAR CWindow *cwin); void identify(FAR CWindow *cwin);
@ -185,10 +184,18 @@ namespace Twm4Nx
bool createMenuWindow(void); bool createMenuWindow(void);
/**
* Calculate the optimal menu frame size
*
* @param frameSize The location to return the calculated frame size
*/
void getMenuFrameSize(FAR struct nxgl_size_s &frameSize);
/** /**
* Calculate the optimal menu window size * Calculate the optimal menu window size
* *
* @result True is returned on success * @param size The location to return the calculated window size
*/ */
void getMenuWindowSize(FAR struct nxgl_size_s &size); void getMenuWindowSize(FAR struct nxgl_size_s &size);
@ -298,28 +305,62 @@ namespace Twm4Nx
FAR CTwm4NxEvent *handler, uint16_t event); FAR CTwm4NxEvent *handler, uint16_t event);
/** /**
* Return true if the main menu is currently being displayed * Return the size of the menu window frame
*
* @param frameSize The location in which to return the current menu
* window frame size.
* @result True is returned on success
*/
bool getFrameSize(FAR struct nxgl_size_s *frameSize)
{
return m_menuWindow->getFrameSize(frameSize);
}
/**
* Set the position of the menu window frame
*
* @param framePos The new menum window frame position
* @result True is returned on success
*/
bool getFramePosition(FAR struct nxgl_point_s *framePos)
{
return m_menuWindow->getFramePosition(framePos);
}
/**
* Set the position of the menu window frame
*
* @param framePos The new menum window frame position
* @result True is returned on success
*/
bool setFramePosition(FAR const struct nxgl_point_s *framePos)
{
return m_menuWindow->setFramePosition(framePos);
}
/**
* Return true if the menu is currently being displayed
*
* @return True if the menu is visible
*/ */
inline bool isVisible(void) inline bool isVisible(void)
{ {
return m_visible; return !m_menuWindow->isIconified();
} }
/** /**
* Make the menu visible. * Make the menu visible.
* *
* @return True if the main menu is shown. * @return True if the menu is shown.
*/ */
inline bool show(void) inline bool show(void)
{ {
if (!m_visible) return m_menuWindow->deIconify();
{
m_visible = m_menuWindow->showWindow();
}
return m_visible;
} }
/** /**
@ -330,12 +371,7 @@ namespace Twm4Nx
inline bool hide(void) inline bool hide(void)
{ {
if (m_visible) return m_menuWindow->iconify();
{
m_visible = !m_menuWindow->hideWindow();
}
return !m_visible;
} }
/** /**

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

@ -88,23 +88,26 @@
#define NO_TOOLBAR (NTOOLBAR_BUTTONS + 0) #define NO_TOOLBAR (NTOOLBAR_BUTTONS + 0)
#define ICONMGR_WINDOW (NTOOLBAR_BUTTONS + 1) #define ICONMGR_WINDOW (NTOOLBAR_BUTTONS + 1)
#define HIDDEN_WINDOW (NTOOLBAR_BUTTONS + 2) #define MENU_WINDOW (NTOOLBAR_BUTTONS + 2)
#define HIDDEN_WINDOW (NTOOLBAR_BUTTONS + 3)
#define WFLAGS_NO_MENU_BUTTON (1 << MENU_BUTTON) #define WFLAGS_NO_MENU_BUTTON (1 << MENU_BUTTON)
#define WFLAGS_NO_DELETE_BUTTON (1 << DELETE_BUTTON) #define WFLAGS_NO_DELETE_BUTTON (1 << DELETE_BUTTON)
#define WFLAGS_NO_RESIZE_BUTTON (1 << RESIZE_BUTTON) #define WFLAGS_NO_RESIZE_BUTTON (1 << RESIZE_BUTTON)
#define WFLAGS_NO_MINIMIZE_BUTTON (1 << MINIMIZE_BUTTON) #define WFLAGS_NO_MINIMIZE_BUTTON (1 << MINIMIZE_BUTTON)
#define WFLAGS_NO_TOOLBAR (1 << NO_TOOLBAR) #define WFLAGS_NO_TOOLBAR (1 << NO_TOOLBAR)
#define WFLAGS_IS_ICONMGR (1 << ICONMGR_WINDOW) #define WFLAGS_ICONMGR (1 << ICONMGR_WINDOW)
#define WFLAGS_HIDDEN_WINDOW (1 << HIDDEN_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_MENU_BUTTON(f) (((f) & WFLAGS_NO_MENU_BUTTON) == 0)
#define WFLAGS_HAVE_DELETE_BUTTON(f) (((f) & WFLAGS_NO_DELETE_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_RESIZE_BUTTON(f) (((f) & WFLAGS_NO_RESIZE_BUTTON) == 0)
#define WFLAGS_HAVE_MINIMIZE_BUTTON(f) (((f) & WFLAGS_NO_MINIMIZE_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_HAVE_TOOLBAR(f) (((f) & WFLAGS_NO_TOOLBAR) == 0)
#define WFLAGS_IS_ICONMGR_WINDOW(f) (((f) & WFLAGS_IS_ICONMGR) != 0) #define WFLAGS_IS_ICONMGR(f) (((f) & WFLAGS_ICONMGR) != 0)
#define WFLAGS_IS_HIDDEN_WINDOW(f) (((f) & WFLAGS_HIDDEN_WINDOW) != 0) #define WFLAGS_IS_MENU(f) (((f) & WFLAGS_MENU) != 0)
#define WFLAGS_IS_HIDDEN(f) (((f) & WFLAGS_HIDDEN) != 0)
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Implementation Classes // Implementation Classes
@ -141,6 +144,7 @@ namespace Twm4Nx
NXWidgets::CNxString m_name; /**< Name of the window */ NXWidgets::CNxString m_name; /**< Name of the window */
FAR NXWidgets::CNxTkWindow *m_nxWin; /**< The contained NX primary window */ FAR NXWidgets::CNxTkWindow *m_nxWin; /**< The contained NX primary window */
nxgl_coord_t m_minWidth; /**< The minimum width of the window */
uint16_t m_zoom; /**< Window zoom: ZOOM_NONE or EVENT_RESIZE_* */ 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 zoom: ZOOM_NONE or EVENT_RESIZE_* */
@ -403,12 +407,6 @@ namespace Twm4Nx
FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap, FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap,
FAR CIconMgr *iconMgr, uint8_t flags); FAR CIconMgr *iconMgr, uint8_t flags);
bool initialize(FAR const char *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 = 0);
/** /**
* Synchronize the window with the NX server. This function will delay * 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. * until the the NX server has caught up with all of the queued requests.
@ -446,7 +444,7 @@ namespace Twm4Nx
inline bool isIconMgr(void) inline bool isIconMgr(void)
{ {
return WFLAGS_IS_ICONMGR_WINDOW(m_tbFlags); return WFLAGS_IS_ICONMGR(m_tbFlags);
} }
/** /**
@ -532,16 +530,32 @@ namespace Twm4Nx
return m_nxWin->lower(); 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 * Show a hidden window
*
* @return True if the operation was successful
*/ */
inline bool showWindow(void) inline bool showWindow(void)
{ {
return m_nxWin->show(); return m_nxWin->show();
} }
/** /**
* Hide a visible window * Hide a visible window
*
* @return True if the operation was successful
*/ */
inline bool hideWindow(void) inline bool hideWindow(void)
@ -601,6 +615,7 @@ namespace Twm4Nx
* Get the raw window size (including toolbar and frame) * Get the raw window size (including toolbar and frame)
* *
* @param framesize Location to return the window frame size * @param framesize Location to return the window frame size
* @return True if the operation was successful
*/ */
bool getFrameSize(FAR struct nxgl_size_s *framesize); bool getFrameSize(FAR struct nxgl_size_s *framesize);
@ -609,17 +624,20 @@ namespace Twm4Nx
* Update the window frame after a resize operation (includes the toolbar * Update the window frame after a resize operation (includes the toolbar
* and user window) * and user window)
* *
* @param size The new window frame size * @param frameSize The new window frame size
* @param pos The frame location which may also have changed * @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, bool resizeFrame(FAR const struct nxgl_size_s *frameSize,
FAR struct nxgl_point_s *framepos); FAR const struct nxgl_point_s *framePos);
/** /**
* Get the raw frame position (accounting for toolbar and frame) * Get the raw frame position (accounting for toolbar and frame)
* *
* @param framepos Location to return the window frame position * @param framepos Location to return the window frame position
* @return True if the operation was successful
*/ */
bool getFramePosition(FAR struct nxgl_point_s *framepos); bool getFramePosition(FAR struct nxgl_point_s *framepos);
@ -628,22 +646,31 @@ namespace Twm4Nx
* Set the raw frame position (accounting for toolbar and frame) * Set the raw frame position (accounting for toolbar and frame)
* *
* @param framepos The new raw window position * @param framepos The new raw window position
* @return True if the operation was successful
*/ */
bool setFramePosition(FAR const struct nxgl_point_s *framepos); bool setFramePosition(FAR const struct nxgl_point_s *framepos);
/* Minimize (iconify) the window */ /**
* Minimize (iconify) the window
*
* @return True if the operation was successful
*/
void iconify(void); bool iconify(void);
/** /**
* De-iconify the window * De-iconify the window
*
* @return True if the operation was successful
*/ */
void deIconify(void); bool deIconify(void);
/** /**
* Is the window iconified? * Is the window iconified?
*
* @return True if the operation was successful
*/ */
inline bool isIconified(void) inline bool isIconified(void)
@ -653,6 +680,8 @@ namespace Twm4Nx
/** /**
* Has the Icon moved? * Has the Icon moved?
*
* @return True if the operation was successful
*/ */
inline bool hasIconMoved(void) inline bool hasIconMoved(void)

6
include/graphics/twm4nx/cwindowfactory.hxx
View File

@ -100,7 +100,7 @@ namespace Twm4Nx
* @param win. The window container to be added to the list. * @param win. The window container to be added to the list.
*/ */
void addWindow(FAR struct SWindow *win); void addWindowContainer(FAR struct SWindow *win);
/** /**
* Remove a window container from the window list. * Remove a window container from the window list.
@ -108,7 +108,7 @@ namespace Twm4Nx
* @param win. The window container to be removed from the list. * @param win. The window container to be removed from the list.
*/ */
void removeWindow(FAR struct SWindow *win); void removeWindowContainer(FAR struct SWindow *win);
/** /**
* Find the window container that contains the specified window. * Find the window container that contains the specified window.
@ -147,7 +147,7 @@ namespace Twm4Nx
*/ */
FAR CWindow * FAR CWindow *
createWindow(FAR const char *name, createWindow(FAR NXWidgets::CNxString &name,
FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap, FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap,
FAR CIconMgr *iconMgr, uint8_t flags); FAR CIconMgr *iconMgr, uint8_t flags);

4
include/graphics/twm4nx/iapplication.hxx
View File

@ -83,10 +83,10 @@ namespace Twm4Nx
* Return the name of the application. This is the string that will * Return the name of the application. This is the string that will
* appear in the Main Menu item. * appear in the Main Menu item.
* *
* @param name The name of the application. * @return The name of the application.
*/ */
virtual void getName(const NXWidgets::CNxString &text) = 0; virtual const NXWidgets::CNxString getName(void) = 0;
/** /**
* Return any submenu item associated with the menu entry. If a non- * Return any submenu item associated with the menu entry. If a non-

11
include/graphics/twm4nx/twm4nx_widgetevents.hxx
View File

@ -122,6 +122,8 @@ namespace Twm4Nx
// Recipient == ICONMGR // Recipient == ICONMGR
EVENT_ICONMGR_DEICONIFY = 0x3000, /**< De-iconify or raise the Icon Manager */
// Recipient == MENU // Recipient == MENU
EVENT_MENU_IDENTIFY = 0x4000, /**< Describe the window */ EVENT_MENU_IDENTIFY = 0x4000, /**< Describe the window */
@ -176,10 +178,10 @@ namespace Twm4Nx
}; };
// Contexts for button press events. These basically identify the sender // Contexts for events. These basically identify the source of the event
// of the event message. // message.
enum EButtonContext enum EEventContext
{ {
EVENT_CONTEXT_WINDOW = 0, EVENT_CONTEXT_WINDOW = 0,
EVENT_CONTEXT_TOOLBAR, EVENT_CONTEXT_TOOLBAR,
@ -187,8 +189,7 @@ namespace Twm4Nx
EVENT_CONTEXT_ICON, EVENT_CONTEXT_ICON,
EVENT_CONTEXT_FRAME, EVENT_CONTEXT_FRAME,
EVENT_CONTEXT_ICONMGR, EVENT_CONTEXT_ICONMGR,
EVENT_CONTEXT_NAME, EVENT_CONTEXT_MENU,
EVENT_CONTEXT_IDENTIFY,
NUM_CONTEXTS NUM_CONTEXTS
}; };