// * this is for making emacs happy: -*-Mode: C++;-*-
/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright 2019,2020 Thomas E. Dickey *
+ * Copyright 1998-2011,2017 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
****************************************************************************/
/****************************************************************************
- * Author: Juergen Pfeifer <Juergen.Pfeifer@T-Online.de> 1997 *
+ * Author: Juergen Pfeifer, 1997 *
****************************************************************************/
+#include "internal.h"
#include "cursesm.h"
#include "cursesapp.h"
-#include "internal.h"
-MODULE_ID("$Id: cursesm.cc,v 1.8 1998/02/11 12:13:40 tom Exp $")
-
-NCursesMenuItem::~NCursesMenuItem() {
+MODULE_ID("$Id: cursesm.cc,v 1.26 2020/02/02 23:34:34 tom Exp $")
+
+NCursesMenuItem::~NCursesMenuItem() THROWS(NCursesException)
+{
if (item)
OnError(::free_item(item));
}
-bool
-NCursesMenuItem::action() {
+bool
+NCursesMenuItem::action()
+{
return FALSE;
-};
+}
-NCursesMenuCallbackItem::~NCursesMenuCallbackItem() {
+NCursesMenuCallbackItem::~NCursesMenuCallbackItem() THROWS(NCursesException)
+{
}
-bool
-NCursesMenuCallbackItem::action() {
+bool
+NCursesMenuCallbackItem::action()
+{
if (p_fct)
return p_fct (*this);
else
/* Internal hook functions. They will route the hook
* calls to virtual methods of the NCursesMenu class,
- * so in C++ providing a hook is done simply by
+ * so in C++ providing a hook is done simply by
* implementing a virtual method in a derived class
*/
void
-NCursesMenu::mnu_init(MENU *m) {
- getHook(m)->On_Menu_Init();
+_nc_xx_mnu_init(MENU *m)
+{
+ NCursesMenu::getHook(m)->On_Menu_Init();
}
void
-NCursesMenu::mnu_term(MENU *m) {
- getHook(m)->On_Menu_Termination();
+_nc_xx_mnu_term(MENU *m)
+{
+ NCursesMenu::getHook(m)->On_Menu_Termination();
}
void
-NCursesMenu::itm_init(MENU *m) {
- NCursesMenu* M = getHook(m);
+_nc_xx_itm_init(MENU *m)
+{
+ NCursesMenu* M = NCursesMenu::getHook(m);
M->On_Item_Init (*(M->current_item ()));
}
void
-NCursesMenu::itm_term(MENU *m) {
- NCursesMenu* M = getHook(m);
+_nc_xx_itm_term(MENU *m)
+{
+ NCursesMenu* M = NCursesMenu::getHook(m);
M->On_Item_Termination (*(M->current_item ()));
}
* objects.
*/
ITEM**
-NCursesMenu::mapItems(NCursesMenuItem* nitems[]) {
+NCursesMenu::mapItems(NCursesMenuItem* nitems[])
+{
int itemCount = 0,lcv;
-
+
for (lcv=0; nitems[lcv]->item; ++lcv)
++itemCount;
-
- ITEM** items = new ITEM*[itemCount + 1];
-
+
+ ITEM** itemArray = new ITEM*[itemCount + 1];
+
for (lcv=0;nitems[lcv]->item;++lcv) {
- items[lcv] = nitems[lcv]->item;
+ itemArray[lcv] = nitems[lcv]->item;
}
- items[lcv] = NULL;
-
+ itemArray[lcv] = NULL;
+
my_items = nitems;
-
+
if (menu)
- delete[] ::menu_items(menu);
- return items;
+ delete[] ::menu_items(menu);
+ return itemArray;
}
void
NCursesMenu::InitMenu(NCursesMenuItem* nitems[],
bool with_frame,
- bool autoDelete_Items) {
+ bool autoDelete_Items)
+{
int mrows, mcols;
-
+
keypad(TRUE);
meta(TRUE);
b_framed = with_frame;
b_autoDelete = autoDelete_Items;
- menu = (MENU*)0;
+ menu = static_cast<MENU*>(0);
menu = ::new_menu(mapItems(nitems));
if (!menu)
OnError (E_SYSTEM_ERROR);
-
+
UserHook* hook = new UserHook;
hook->m_user = NULL;
hook->m_back = this;
hook->m_owner = menu;
- ::set_menu_userptr(menu,(void*)hook);
-
- ::set_menu_init (menu, NCursesMenu::mnu_init);
- ::set_menu_term (menu, NCursesMenu::mnu_term);
- ::set_item_init (menu, NCursesMenu::itm_init);
- ::set_item_term (menu, NCursesMenu::itm_term);
-
+ ::set_menu_userptr(menu, static_cast<void*>(hook));
+
+ ::set_menu_init (menu, _nc_xx_mnu_init);
+ ::set_menu_term (menu, _nc_xx_mnu_term);
+ ::set_item_init (menu, _nc_xx_itm_init);
+ ::set_item_term (menu, _nc_xx_itm_term);
+
scale(mrows, mcols);
::set_menu_win(menu, w);
-
+
if (with_frame) {
if ((mrows > height()-2) || (mcols > width()-2))
- OnError(E_NO_ROOM);
+ OnError(E_NO_ROOM);
sub = new NCursesWindow(*this,mrows,mcols,1,1,'r');
::set_menu_sub(menu, sub->w);
b_sub_owner = TRUE;
}
else {
- sub = (NCursesWindow*)0;
+ sub = static_cast<NCursesWindow*>(0);
b_sub_owner = FALSE;
}
setDefaultAttributes();
}
void
-NCursesMenu::setDefaultAttributes() {
+NCursesMenu::setDefaultAttributes()
+{
NCursesApplication* S = NCursesApplication::getApplication();
if (S) {
::set_menu_fore(menu, S->foregrounds());
}
}
-NCursesMenu::~NCursesMenu() {
- UserHook* hook = (UserHook*)::menu_userptr(menu);
+NCursesMenu::~NCursesMenu() THROWS(NCursesException)
+{
+ UserHook* hook = reinterpret_cast<UserHook*>(::menu_userptr(menu));
delete hook;
if (b_sub_owner) {
+ ::set_menu_sub(menu, static_cast<WINDOW *>(0));
delete sub;
- ::set_menu_sub(menu,(WINDOW *)0);
}
if (menu) {
ITEM** itms = ::menu_items(menu);
int cnt = count();
- OnError(::set_menu_items(menu,(ITEM**)0));
+ OnError(::set_menu_items(menu, static_cast<ITEM**>(0)));
if (b_autoDelete) {
if (cnt>0) {
for (int i=0; i <= cnt; i++)
- delete my_items[i];
+ delete my_items[i];
}
delete[] my_items;
}
::free_menu(menu);
// It's essential to do this after free_menu()
- delete[] itms;
+ delete[] itms;
}
}
void
-NCursesMenu::setSubWindow(NCursesWindow& nsub) {
+NCursesMenu::setSubWindow(NCursesWindow& nsub)
+{
if (!isDescendant(nsub))
OnError(E_SYSTEM_ERROR);
else {
}
bool
-NCursesMenu::set_pattern (const char *pat) {
+NCursesMenu::set_pattern (const char *pat)
+{
int res = ::set_menu_pattern (menu, pat);
switch(res) {
case E_OK:
}
// call the menu driver and do basic error checking.
-int
-NCursesMenu::driver (int c) {
+int
+NCursesMenu::driver (int c)
+{
int res = ::menu_driver (menu, c);
switch (res) {
case E_OK:
// The default implementation provides a hopefully straightforward
// mapping for the most common keystrokes and menu requests.
// -------------------------------------------------------------------------
-int
-NCursesMenu::virtualize(int c) {
+int
+NCursesMenu::virtualize(int c)
+{
switch(c) {
case CTRL('X') : return(CMD_QUIT); // eXit
}
NCursesMenuItem*
-NCursesMenu::operator()(void) {
+NCursesMenu::operator()(void)
+{
int drvCmnd;
int err;
int c;
post();
show();
refresh();
-
- while (!b_action && ((drvCmnd = virtualize((c=getch()))) != CMD_QUIT)) {
+
+ while (!b_action && ((drvCmnd = virtualize((c=getKey()))) != CMD_QUIT)) {
switch((err=driver(drvCmnd))) {
case E_REQUEST_DENIED:
if (drvCmnd == CMD_ACTION) {
if (options() & O_ONEVALUE) {
NCursesMenuItem* itm = current_item();
- assert(itm);
+ assert(itm != 0);
if (itm->options() & O_SELECTABLE)
- b_action = itm->action();
+ {
+ b_action = itm->action();
+ refresh();
+ }
else
On_Not_Selectable(c);
}
NCursesMenuItem* itm = my_items[i];
if (itm->value()) {
b_action |= itm->action();
+ refresh();
}
}
}
}
void
-NCursesMenu::On_Menu_Init() {
+NCursesMenu::On_Menu_Init()
+{
}
void
-NCursesMenu::On_Menu_Termination() {
+NCursesMenu::On_Menu_Termination()
+{
}
void
-NCursesMenu::On_Item_Init(NCursesMenuItem& item) {
+NCursesMenu::On_Item_Init(NCursesMenuItem& item)
+{
+ (void) item;
}
void
-NCursesMenu::On_Item_Termination(NCursesMenuItem& item) {
+NCursesMenu::On_Item_Termination(NCursesMenuItem& item)
+{
+ (void) item;
}
void
-NCursesMenu::On_Request_Denied(int c) const {
- beep();
+NCursesMenu::On_Request_Denied(int c) const
+{
+ (void) c;
+ ::beep();
}
void
-NCursesMenu::On_Not_Selectable(int c) const {
- beep();
+NCursesMenu::On_Not_Selectable(int c) const
+{
+ (void) c;
+ ::beep();
}
void
-NCursesMenu::On_No_Match(int c) const {
- beep();
+NCursesMenu::On_No_Match(int c) const
+{
+ (void) c;
+ ::beep();
}
void
-NCursesMenu::On_Unknown_Command(int c) const {
- beep();
+NCursesMenu::On_Unknown_Command(int c) const
+{
+ (void) c;
+ ::beep();
}
-
projects / ncurses.git / blobdiff