--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/ncurses/cursesm.h	Tue Mar 18 17:55:14 2025 -0400
@@ -0,0 +1,674 @@
+// * This makes emacs happy -*-Mode: C++;-*-
+/****************************************************************************
+ * Copyright 2019-2020,2022 Thomas E. Dickey                                *
+ * Copyright 1998-2012,2014 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            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
+
+/****************************************************************************
+ *   Author: Juergen Pfeifer, 1997                                          *
+ ****************************************************************************/
+
+// $Id: cursesm.h,v 1.35 2022/08/20 20:52:15 tom Exp $
+
+#ifndef NCURSES_CURSESM_H_incl
+#define NCURSES_CURSESM_H_incl 1
+
+#include <ncursesw/cursesp.h>
+
+extern "C" {
+#  include <ncursesw/menu.h>
+}
+//
+// -------------------------------------------------------------------------
+// This wraps the ITEM type of <ncursesw/menu.h>
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesMenuItem
+{
+  friend class NCursesMenu;
+
+protected:
+  ITEM *item;
+
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesMenuException) {
+    if (err != E_OK)
+      THROW(new NCursesMenuException (err));
+  }
+
+public:
+  NCursesMenuItem (const char* p_name     = NULL,
+		   const char* p_descript = NULL)
+    : item(0)
+  {
+    item = p_name ? ::new_item (p_name, p_descript) : STATIC_CAST(ITEM*)(0);
+    if (p_name && !item)
+      OnError (E_SYSTEM_ERROR);
+  }
+  // Create an item. If you pass both parameters as NULL, a delimiting
+  // item is constructed which can be used to terminate a list of
+  // NCursesMenu objects.
+
+  NCursesMenuItem& operator=(const NCursesMenuItem& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesMenuItem(const NCursesMenuItem& rhs)
+    : item(0)
+  {
+    (void) rhs;
+  }
+
+  virtual ~NCursesMenuItem () THROWS(NCursesException);
+  // Release the items memory
+
+  inline const char* name () const {
+    return ::item_name (item);
+  }
+  // Name of the item
+
+  inline const char* description () const {
+    return ::item_description (item);
+  }
+  // Description of the item
+
+  inline int (index) (void) const {
+    return ::item_index (item);
+  }
+  // Index of the item in an item array (or -1)
+
+  inline void options_on (Item_Options opts) {
+    OnError (::item_opts_on (item, opts));
+  }
+  // Switch on the items options
+
+  inline void options_off (Item_Options opts) {
+    OnError (::item_opts_off (item, opts));
+  }
+  // Switch off the item's option
+
+  inline Item_Options options () const {
+    return ::item_opts (item);
+  }
+  // Retrieve the items options
+
+  inline void set_options (Item_Options opts) {
+    OnError (::set_item_opts (item, opts));
+  }
+  // Set the items options
+
+  inline void set_value (bool f) {
+    OnError (::set_item_value (item,f));
+  }
+  // Set/Reset the items selection state
+
+  inline bool value () const {
+    return ::item_value (item);
+  }
+  // Retrieve the items selection state
+
+  inline bool visible () const {
+    return ::item_visible (item);
+  }
+  // Retrieve visibility of the item
+
+  virtual bool action();
+  // Perform an action associated with this item; you may use this in an
+  // user supplied driver for a menu; you may derive from this class and
+  // overload action() to supply items with different actions.
+  // If an action returns true, the menu will be exited. The default action
+  // is to do nothing.
+};
+
+// Prototype for an items callback function.
+typedef bool ITEMCALLBACK(NCursesMenuItem&);
+
+// If you don't like to create a child class for individual items to
+// overload action(), you may use this class and provide a callback
+// function pointer for items.
+class NCURSES_CXX_IMPEXP NCursesMenuCallbackItem : public NCursesMenuItem
+{
+private:
+  ITEMCALLBACK* p_fct;
+
+public:
+  NCursesMenuCallbackItem(ITEMCALLBACK* fct       = NULL,
+			  const char* p_name      = NULL,
+			  const char* p_descript  = NULL )
+    : NCursesMenuItem (p_name, p_descript),
+      p_fct (fct) {
+  }
+
+  NCursesMenuCallbackItem& operator=(const NCursesMenuCallbackItem& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+    }
+    return *this;
+  }
+
+  NCursesMenuCallbackItem(const NCursesMenuCallbackItem& rhs)
+    : NCursesMenuItem(rhs),
+      p_fct(0)
+  {
+  }
+
+  virtual ~NCursesMenuCallbackItem() THROWS(NCursesException);
+
+  bool action() NCURSES_OVERRIDE;
+};
+
+  // This are the built-in hook functions in this C++ binding. In C++ we use
+  // virtual member functions (see below On_..._Init and On_..._Termination)
+  // to provide this functionality in an object oriented manner.
+extern "C" {
+  void _nc_xx_mnu_init(MENU *);
+  void _nc_xx_mnu_term(MENU *);
+  void _nc_xx_itm_init(MENU *);
+  void _nc_xx_itm_term(MENU *);
+}
+
+//
+// -------------------------------------------------------------------------
+// This wraps the MENU type of <ncursesw/menu.h>
+// -------------------------------------------------------------------------
+//
+class NCURSES_CXX_IMPEXP NCursesMenu : public NCursesPanel
+{
+protected:
+  MENU *menu;
+
+private:
+  NCursesWindow* sub;   // the subwindow object
+  bool b_sub_owner;     // is this our own subwindow?
+  bool b_framed;        // has the menu a border?
+  bool b_autoDelete;    // Delete items when deleting menu?
+
+  NCursesMenuItem** my_items; // The array of items for this menu
+
+  // This structure is used for the menu's user data field to link the
+  // MENU* to the C++ object and to provide extra space for a user pointer.
+  typedef struct {
+    void*              m_user;      // the pointer for the user's data
+    const NCursesMenu* m_back;      // backward pointer to C++ object
+    const MENU*        m_owner;
+  } UserHook;
+
+  // Get the backward pointer to the C++ object from a MENU
+  static inline NCursesMenu* getHook(const MENU *m) {
+    UserHook* hook = STATIC_CAST(UserHook*)(::menu_userptr(m));
+    assert(hook != 0 && hook->m_owner==m);
+    return const_cast<NCursesMenu*>(hook->m_back);
+  }
+
+  friend void _nc_xx_mnu_init(MENU *);
+  friend void _nc_xx_mnu_term(MENU *);
+  friend void _nc_xx_itm_init(MENU *);
+  friend void _nc_xx_itm_term(MENU *);
+
+  // Calculate ITEM* array for the menu
+  ITEM** mapItems(NCursesMenuItem* nitems[]);
+
+protected:
+  // internal routines
+  inline void set_user(void *user) {
+    UserHook* uptr = STATIC_CAST(UserHook*)(::menu_userptr (menu));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==menu);
+    uptr->m_user = user;
+  }
+
+  inline void *get_user() {
+    UserHook* uptr = STATIC_CAST(UserHook*)(::menu_userptr (menu));
+    assert (uptr != 0 && uptr->m_back==this && uptr->m_owner==menu);
+    return uptr->m_user;
+  }
+
+  void InitMenu (NCursesMenuItem* menu[],
+		 bool with_frame,
+		 bool autoDeleteItems);
+
+  inline void OnError (int err) const THROW2(NCursesException const, NCursesMenuException) {
+    if (err != E_OK)
+      THROW(new NCursesMenuException (this, err));
+  }
+
+  // this wraps the menu_driver call.
+  virtual int driver (int c) ;
+
+  // 'Internal' constructor to create a menu without association to
+  // an array of items.
+  NCursesMenu( int  nlines,
+	       int  ncols,
+	       int  begin_y = 0,
+	       int  begin_x = 0)
+    : NCursesPanel(nlines,ncols,begin_y,begin_x),
+      menu (STATIC_CAST(MENU*)(0)),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+  }
+
+public:
+  // Make a full window size menu
+  NCursesMenu (NCursesMenuItem* Items[],
+	       bool with_frame=FALSE,        // Reserve space for a frame?
+	       bool autoDelete_Items=FALSE)  // Autocleanup of Items?
+    : NCursesPanel(),
+      menu(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+      InitMenu(Items, with_frame, autoDelete_Items);
+  }
+
+  // Make a menu with a window of this size.
+  NCursesMenu (NCursesMenuItem* Items[],
+	       int  nlines,
+	       int  ncols,
+	       int  begin_y = 0,
+	       int  begin_x = 0,
+	       bool with_frame=FALSE,        // Reserve space for a frame?
+	       bool autoDelete_Items=FALSE)  // Autocleanup of Items?
+    : NCursesPanel(nlines, ncols, begin_y, begin_x),
+      menu(0),
+      sub(0),
+      b_sub_owner(0),
+      b_framed(0),
+      b_autoDelete(0),
+      my_items(0)
+  {
+      InitMenu(Items, with_frame, autoDelete_Items);
+  }
+
+  NCursesMenu& operator=(const NCursesMenu& rhs)
+  {
+    if (this != &rhs) {
+      *this = rhs;
+      NCursesPanel::operator=(rhs);
+    }
+    return *this;
+  }
+
+  NCursesMenu(const NCursesMenu& rhs)
+    : NCursesPanel(rhs),
+      menu(rhs.menu),
+      sub(rhs.sub),
+      b_sub_owner(rhs.b_sub_owner),
+      b_framed(rhs.b_framed),
+      b_autoDelete(rhs.b_autoDelete),
+      my_items(rhs.my_items)
+  {
+  }
+
+  virtual ~NCursesMenu () THROWS(NCursesException);
+
+  // Retrieve the menus subwindow
+  inline NCursesWindow& subWindow() const {
+    assert(sub!=NULL);
+    return *sub;
+  }
+
+  // Set the menus subwindow
+  void setSubWindow(NCursesWindow& sub);
+
+  // Set these items for the menu
+  inline void setItems(NCursesMenuItem* Items[]) {
+    OnError(::set_menu_items(menu,mapItems(Items)));
+  }
+
+  // Remove the menu from the screen
+  inline void unpost (void) {
+    OnError (::unpost_menu (menu));
+  }
+
+  // Post the menu to the screen if flag is true, unpost it otherwise
+  inline void post(bool flag = TRUE) {
+    flag ? OnError (::post_menu(menu)) : OnError (::unpost_menu (menu));
+  }
+
+  // Get the number of rows and columns for this menu
+  inline void scale (int& mrows, int& mcols) const  {
+    OnError (::scale_menu (menu, &mrows, &mcols));
+  }
+
+  // Set the format of this menu
+  inline void set_format(int mrows, int mcols) {
+    OnError (::set_menu_format(menu, mrows, mcols));
+  }
+
+  // Get the format of this menu
+  inline void menu_format(int& rows,int& ncols) {
+    ::menu_format(menu,&rows,&ncols);
+  }
+
+  // Items of the menu
+  inline NCursesMenuItem* items() const {
+    return *my_items;
+  }
+
+  // Get the number of items in this menu
+  inline int count() const {
+    return ::item_count(menu);
+  }
+
+  // Get the current item (i.e. the one the cursor is located)
+  inline NCursesMenuItem* current_item() const {
+    return my_items[::item_index(::current_item(menu))];
+  }
+
+  // Get the marker string
+  inline const char* mark() const {
+    return ::menu_mark(menu);
+  }
+
+  // Set the marker string
+  inline void set_mark(const char *marker) {
+    OnError (::set_menu_mark (menu, marker));
+  }
+
+  // Get the name of the request code c
+  inline static const char* request_name(int c) {
+    return ::menu_request_name(c);
+  }
+
+  // Get the current pattern
+  inline char* pattern() const {
+    return ::menu_pattern(menu);
+  }
+
+  // true if there is a pattern match, false otherwise.
+  bool set_pattern (const char *pat);
+
+  // set the default attributes for the menu
+  // i.e. set fore, back and grey attribute
+  virtual void setDefaultAttributes();
+
+  // Get the menus background attributes
+  inline chtype back() const {
+    return ::menu_back(menu);
+  }
+
+  // Get the menus foreground attributes
+  inline chtype fore() const {
+    return ::menu_fore(menu);
+  }
+
+  // Get the menus grey attributes (used for unselectable items)
+  inline chtype grey() const {
+    return ::menu_grey(menu);
+  }
+
+  // Set the menus background attributes
+  inline chtype set_background(chtype a) {
+    return ::set_menu_back(menu,a);
+  }
+
+  // Set the menus foreground attributes
+  inline chtype set_foreground(chtype a) {
+    return ::set_menu_fore(menu,a);
+  }
+
+  // Set the menus grey attributes (used for unselectable items)
+  inline chtype set_grey(chtype a) {
+    return ::set_menu_grey(menu,a);
+  }
+
+  inline void options_on (Menu_Options opts) {
+    OnError (::menu_opts_on (menu,opts));
+  }
+
+  inline void options_off(Menu_Options opts) {
+    OnError (::menu_opts_off(menu,opts));
+  }
+
+  inline Menu_Options options() const {
+    return ::menu_opts(menu);
+  }
+
+  inline void set_options (Menu_Options opts) {
+    OnError (::set_menu_opts (menu,opts));
+  }
+
+  inline int pad() const {
+    return ::menu_pad(menu);
+  }
+
+  inline void set_pad (int padch) {
+    OnError (::set_menu_pad (menu, padch));
+  }
+
+  // Position the cursor to the current item
+  inline void position_cursor () const {
+    OnError (::pos_menu_cursor (menu));
+  }
+
+  // Set the current item
+  inline void set_current(NCursesMenuItem& I) {
+    OnError (::set_current_item(menu, I.item));
+  }
+
+  // Get the current top row of the menu
+  inline int top_row (void) const {
+    return ::top_row (menu);
+  }
+
+  // Set the current top row of the menu
+  inline void set_top_row (int row) {
+    OnError (::set_top_row (menu, row));
+  }
+
+  // spacing control
+  // Set the spacing for the menu
+  inline void setSpacing(int spc_description,
+			 int spc_rows,
+			 int spc_columns) {
+    OnError(::set_menu_spacing(menu,
+			       spc_description,
+			       spc_rows,
+			       spc_columns));
+  }
+
+  // Get the spacing info for the menu
+  inline void Spacing(int& spc_description,
+		      int& spc_rows,
+		      int& spc_columns) const {
+    OnError(::menu_spacing(menu,
+			   &spc_description,
+			   &spc_rows,
+			   &spc_columns));
+  }
+
+  // Decorations
+  inline void frame(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::frame(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void boldframe(const char *title=NULL, const char* btitle=NULL) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::boldframe(title,btitle);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  inline void label(const char *topLabel, const char *bottomLabel) NCURSES_OVERRIDE {
+    if (b_framed)
+      NCursesPanel::label(topLabel,bottomLabel);
+    else
+      OnError(E_SYSTEM_ERROR);
+  }
+
+  // -----
+  // Hooks
+  // -----
+
+  // Called after the menu gets repositioned in its window.
+  // This is especially true if the menu is posted.
+  virtual void On_Menu_Init();
+
+  // Called before the menu gets repositioned in its window.
+  // This is especially true if the menu is unposted.
+  virtual void On_Menu_Termination();
+
+  // Called after the item became the current item
+  virtual void On_Item_Init(NCursesMenuItem& item);
+
+  // Called before this item is left as current item.
+  virtual void On_Item_Termination(NCursesMenuItem& item);
+
+  // Provide a default key virtualization. Translate the keyboard
+  // code c into a menu request code.
+  // The default implementation provides a hopefully straightforward
+  // mapping for the most common keystrokes and menu requests.
+  virtual int virtualize(int c);
+
+
+  // Operators
+  inline NCursesMenuItem* operator[](int i) const {
+    if ( (i < 0) || (i >= ::item_count (menu)) )
+      OnError (E_BAD_ARGUMENT);
+    return (my_items[i]);
+  }
+
+  // Perform the menu's operation
+  // Return the item where you left the selection mark for a single
+  // selection menu, or NULL for a multivalued menu.
+  virtual NCursesMenuItem* operator()(void);
+
+  // --------------------
+  // Exception handlers
+  // Called by operator()
+  // --------------------
+
+  // Called if the request is denied
+  virtual void On_Request_Denied(int c) const;
+
+  // Called if the item is not selectable
+  virtual void On_Not_Selectable(int c) const;
+
+  // Called if pattern doesn't match
+  virtual void On_No_Match(int c) const;
+
+  // Called if the command is unknown
+  virtual void On_Unknown_Command(int c) const;
+
+};
+//
+// -------------------------------------------------------------------------
+// This is the typical C++ typesafe way to allow to attach
+// user data to an item of a menu. Its assumed that the user
+// data belongs to some class T. Use T as template argument
+// to create a UserItem.
+// -------------------------------------------------------------------------
+//
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserItem : public NCursesMenuItem
+{
+public:
+  NCursesUserItem (const char* p_name,
+		   const char* p_descript = NULL,
+		   const T* p_UserData    = STATIC_CAST(T*)(0))
+    : NCursesMenuItem (p_name, p_descript) {
+      if (item)
+	OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void*>(p_UserData))));
+  }
+
+  virtual ~NCursesUserItem() THROWS(NCursesException) {}
+
+  inline const T* UserData (void) const {
+    return reinterpret_cast<const T*>(::item_userptr (item));
+  };
+
+  inline virtual void setUserData(const T* p_UserData) {
+    if (item)
+      OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void *>(p_UserData))));
+  }
+};
+//
+// -------------------------------------------------------------------------
+// The same mechanism is used to attach user data to a menu
+// -------------------------------------------------------------------------
+//
+template<class T> class NCURSES_CXX_IMPEXP NCursesUserMenu : public NCursesMenu
+{
+protected:
+  NCursesUserMenu( int  nlines,
+		   int  ncols,
+		   int  begin_y = 0,
+		   int  begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0))
+    : NCursesMenu(nlines,ncols,begin_y,begin_x) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+
+public:
+  NCursesUserMenu (NCursesMenuItem* Items[],
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE,
+		   bool autoDelete_Items=FALSE)
+    : NCursesMenu (Items, with_frame, autoDelete_Items) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+
+  NCursesUserMenu (NCursesMenuItem* Items[],
+		   int nlines,
+		   int ncols,
+		   int begin_y = 0,
+		   int begin_x = 0,
+		   const T* p_UserData = STATIC_CAST(T*)(0),
+		   bool with_frame=FALSE)
+    : NCursesMenu (Items, nlines, ncols, begin_y, begin_x, with_frame) {
+      if (menu)
+	set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  };
+
+  virtual ~NCursesUserMenu() THROWS(NCursesException) {
+  };
+
+  inline T* UserData (void) {
+    return reinterpret_cast<T*>(get_user ());
+  };
+
+  inline virtual void setUserData (const T* p_UserData) {
+    if (menu)
+      set_user (const_cast<void *>(reinterpret_cast<const void*>(p_UserData)));
+  }
+};
+
+#endif /* NCURSES_CURSESM_H_incl */