ncurses 5.7 - patch 20100724
[ncurses.git] / c++ / cursesm.h
index 26e0b4ce2b02e677335bb388ee2826f2bf5766aa..d9c2273e6f6f9dbdab28afc88ddcf1213f15639f 100644 (file)
@@ -1,6 +1,6 @@
 // * This makes emacs happy -*-Mode: C++;-*-
 /****************************************************************************
- * Copyright (c) 1998,1999 Free Software Foundation, Inc.                   *
+ * Copyright (c) 1998-2003,2005 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@gmx.net> 1997                 *
+ *   Author: Juergen Pfeifer, 1997                                          *
  ****************************************************************************/
 
-// $Id: cursesm.h,v 1.13 1999/10/30 23:59:37 tom Exp $
+// $Id: cursesm.h,v 1.25 2005/08/13 18:10:36 tom Exp $
 
-#ifndef _CURSESM_H
-#define _CURSESM_H
+#ifndef NCURSES_CURSESM_H_incl
+#define NCURSES_CURSESM_H_incl 1
 
 #include <cursesp.h>
 
@@ -46,9 +46,10 @@ extern "C" {
 // This wraps the ITEM type of <menu.h>
 // -------------------------------------------------------------------------
 //
-class NCursesMenuItem {
+class NCURSES_IMPEXP NCursesMenuItem
+{
   friend class NCursesMenu;
-  
+
 protected:
   ITEM *item;
 
@@ -59,15 +60,30 @@ protected:
 
 public:
   NCursesMenuItem (const char* p_name     = NULL,
-                  const char* p_descript = NULL ) { 
-    item = p_name ? ::new_item (p_name, p_descript) : (ITEM*)0; 
+                  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)
+  {
+  }
+
   virtual ~NCursesMenuItem ();
   // Release the items memory
 
@@ -80,19 +96,19 @@ public:
     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 options) {
-    OnError (::item_opts_on (item, options));
+  inline void options_on (Item_Options opts) {
+    OnError (::item_opts_on (item, opts));
   }
   // Switch on the items options
 
-  inline void options_off (Item_Options options) {
-    OnError (::item_opts_off (item, options));
+  inline void options_off (Item_Options opts) {
+    OnError (::item_opts_off (item, opts));
   }
   // Switch off the item's option
 
@@ -101,8 +117,8 @@ public:
   }
   // Retrieve the items options
 
-  inline void set_options (Item_Options options) {
-    OnError (::set_item_opts (item, options));
+  inline void set_options (Item_Options opts) {
+    OnError (::set_item_opts (item, opts));
   }
   // Set the items options
 
@@ -115,7 +131,7 @@ public:
     return ::item_value (item);
   }
   // Retrieve the items selection state
-  
+
   inline bool visible () const {
     return ::item_visible (item);
   }
@@ -135,7 +151,8 @@ 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 NCursesMenuCallbackItem : public NCursesMenuItem {
+class NCURSES_IMPEXP NCursesMenuCallbackItem : public NCursesMenuItem
+{
 private:
   ITEMCALLBACK* p_fct;
 
@@ -146,17 +163,43 @@ public:
     : 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();
 
   bool action();
 };
+
+  // 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 <menu.h>
 // -------------------------------------------------------------------------
 //
-class NCursesMenu : public NCursesPanel {
+class NCURSES_IMPEXP NCursesMenu : public NCursesPanel
+{
 protected:
   MENU *menu;
 
@@ -178,36 +221,33 @@ private:
 
   // Get the backward pointer to the C++ object from a MENU
   static inline NCursesMenu* getHook(const MENU *m) {
-    UserHook* hook = (UserHook*)::menu_userptr(m);
+    UserHook* hook = STATIC_CAST(UserHook*)(::menu_userptr(m));
     assert(hook != 0 && hook->m_owner==m);
-    return (NCursesMenu*)(hook->m_back);
+    return const_cast<NCursesMenu*>(hook->m_back);
   }
 
-  // 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.
-  static void mnu_init(MENU *);
-  static void mnu_term(MENU *);
-  static void itm_init(MENU *);
-  static void itm_term(MENU *);
-  
+  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 
+  // internal routines
   inline void set_user(void *user) {
-    UserHook* uptr = (UserHook*)::menu_userptr (menu);
+    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 = (UserHook*)::menu_userptr (menu);
+    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);
@@ -216,18 +256,24 @@ protected:
     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  lines, 
-              int  cols, 
-              int  begin_y = 0, 
-              int  begin_x = 0) 
-    : NCursesPanel(lines,cols,begin_y,begin_x), 
-      menu ((MENU*)0) {
+  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:
@@ -235,22 +281,56 @@ public:
   NCursesMenu (NCursesMenuItem* Items[],
               bool with_frame=FALSE,        // Reserve space for a frame?
               bool autoDelete_Items=FALSE)  // Autocleanup of Items?
-    : NCursesPanel() {
+    : 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  lines, 
-              int  cols, 
-              int  begin_y = 0, 
+  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(lines, cols, begin_y, begin_x) {
+    : 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 ();
 
   // Retrieve the menus subwindow
@@ -264,17 +344,17 @@ public:
 
   // Set these items for the menu
   inline void setItems(NCursesMenuItem* Items[]) {
-    OnError(::set_menu_items(menu,mapItems(Items)));    
+    OnError(::set_menu_items(menu,mapItems(Items)));
   }
 
   // Remove the menu from the screen
-  inline void unpost (void) { 
-    OnError (::unpost_menu (menu)); 
+  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)); 
+    flag ? OnError (::post_menu(menu)) : OnError (::unpost_menu (menu));
   }
 
   // Get the numer of rows and columns for this menu
@@ -286,35 +366,35 @@ public:
   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& cols) { 
-    ::menu_format(menu,&rows,&cols); 
+  inline void menu_format(int& rows,int& ncols) {
+    ::menu_format(menu,&rows,&ncols);
   }
-  
+
   // Items of the menu
   inline NCursesMenuItem* items() const {
-    return *my_items; 
+    return *my_items;
   }
 
   // Get the number of items in this menu
   inline int count() const {
-    return ::item_count(menu); 
+    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 *mark) {
-    OnError (::set_menu_mark (menu, mark));
+  inline void set_mark(const char *marker) {
+    OnError (::set_menu_mark (menu, marker));
   }
 
   // Get the name of the request code c
@@ -363,7 +443,7 @@ public:
   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));
   }
@@ -375,7 +455,7 @@ public:
   inline Menu_Options options() const {
     return ::menu_opts(menu);
   }
-  
+
   inline void set_options (Menu_Options opts) {
     OnError (::set_menu_opts (menu,opts));
   }
@@ -387,7 +467,7 @@ public:
   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));
@@ -418,7 +498,7 @@ public:
                               spc_rows,
                               spc_columns));
   }
-  
+
   // Get the spacing info for the menu
   inline void Spacing(int& spc_description,
                      int& spc_rows,
@@ -443,7 +523,7 @@ public:
     else
       OnError(E_SYSTEM_ERROR);
   }
-  
+
   inline void label(const char *topLabel, const char *bottomLabel) {
     if (b_framed)
       NCursesPanel::label(topLabel,bottomLabel);
@@ -468,7 +548,7 @@ public:
 
   // 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
@@ -495,7 +575,7 @@ public:
 
   // 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;
 
@@ -514,26 +594,26 @@ public:
 // to create a UserItem.
 // -------------------------------------------------------------------------
 //
-template<class T> class NCursesUserItem : public NCursesMenuItem
+template<class T> class NCURSES_IMPEXP NCursesUserItem : public NCursesMenuItem
 {
 public:
   NCursesUserItem (const char* p_name,
                   const char* p_descript = NULL,
-                  const T* p_UserData    = (T*)0)
+                  const T* p_UserData    = STATIC_CAST(T*)(0))
     : NCursesMenuItem (p_name, p_descript) {
       if (item)
-       OnError (::set_item_userptr (item, (void *)p_UserData));
-  };
+       OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void*>(p_UserData))));
+  }
 
-  virtual ~NCursesUserItem() {};
+  virtual ~NCursesUserItem() {}
 
   inline const T* UserData (void) const {
-    return (const T*)::item_userptr (item);
+    return reinterpret_cast<const T*>(::item_userptr (item));
   };
 
   inline virtual void setUserData(const T* p_UserData) {
     if (item)
-      OnError (::set_item_userptr (item, (void *)p_UserData));
+      OnError (::set_item_userptr (item, const_cast<void *>(reinterpret_cast<const void *>(p_UserData))));
   }
 };
 //
@@ -541,52 +621,52 @@ public:
 // The same mechanism is used to attach user data to a menu
 // -------------------------------------------------------------------------
 //
-template<class T> class NCursesUserMenu : public NCursesMenu
+template<class T> class NCURSES_IMPEXP NCursesUserMenu : public NCursesMenu
 {
 protected:
-  NCursesUserMenu( int  lines, 
-                  int  cols, 
-                  int  begin_y = 0, 
+  NCursesUserMenu( int  nlines,
+                  int  ncols,
+                  int  begin_y = 0,
                   int  begin_x = 0,
-                  const T* p_UserData = (T*)0) 
-    : NCursesMenu(lines,cols,begin_y,begin_x) {
+                  const T* p_UserData = STATIC_CAST(T*)(0))
+    : NCursesMenu(nlines,ncols,begin_y,begin_x) {
       if (menu)
-       set_user ((void *)p_UserData);
+       set_user (const_cast<void *>(p_UserData));
   }
 
 public:
   NCursesUserMenu (NCursesMenuItem Items[],
-                  const T* p_UserData = (T*)0,
+                  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 ((void *)p_UserData);
+       set_user (const_cast<void *>(p_UserData));
   };
-  
+
   NCursesUserMenu (NCursesMenuItem Items[],
-                  int lines, 
-                  int cols, 
-                  int begin_y = 0, 
+                  int nlines,
+                  int ncols,
+                  int begin_y = 0,
                   int begin_x = 0,
-                  const T* p_UserData = (T*)0,
+                  const T* p_UserData = STATIC_CAST(T*)(0),
                   bool with_frame=FALSE)
-    : NCursesMenu (Items, lines, cols, begin_y, begin_x, with_frame) {
+    : NCursesMenu (Items, nlines, ncols, begin_y, begin_x, with_frame) {
       if (menu)
-       set_user ((void *)p_UserData);
-  };  
-  
+       set_user (const_cast<void *>(p_UserData));
+  };
+
   virtual ~NCursesUserMenu() {
   };
-  
+
   inline T* UserData (void) const {
-    return (T*)get_user ();
+    return reinterpret_cast<T*>(get_user ());
   };
 
   inline virtual void setUserData (const T* p_UserData) {
     if (menu)
-      set_user ((void *)p_UserData);
+      set_user (const_cast<void *>(p_UserData));
   }
 };
 
-#endif // _CURSESM_H
+#endif /* NCURSES_CURSESM_H_incl */