Changes to Fl_Menu_::add() so that you should be able to add to any menu,

including one that was set with menu(). It copies the static menu if necessary and keeps track of the size of the menu so it can reallocate the array exactly when necessary. This should make modifying the items in a menu much more predictable and usefule. I don't know if these changes will go cleanly into 2.0. Probably not. git-svn-id: file:///fltk/svn/fltk/branches/branch-1.0@550 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
1999-04-19 07:01:24 +00:00 · 1999-04-19 07:01:24 +00:00 · add808d7c2
parent 405f8fba3a
commit add808d7c2
5 changed files with 183 additions and 113 deletions
--- a/documentation/Fl_Menu_.html
+++ b/documentation/Fl_Menu_.html
@ -24,10 +24,12 @@ Currently FLTK provides you with <A href=Fl_Menu_Button.html#Fl_Menu_Button>
 <TT>Fl_Menu_Button</TT></A>, <A href=Fl_Menu_Bar.html#Fl_Menu_Bar><TT>
 Fl_Menu_Bar</TT></A>, and <A href=functions.html#Fl_Choice><TT>Fl_Choice</TT>
 </A>. 
-<P>The class contains a pointer to an array of structures of type <A href=Fl_Menu_Item.html#Fl_Menu_Item>
-<TT>Fl_Menu_Item</TT></A>. These describe the contents of the menu. 
- Usually the array is a large initialization constant, but there are 
-methods to build it dynamically. </P>
+
+<P>The class contains a pointer to an array of structures of type <A
+href=Fl_Menu_Item.html#Fl_Menu_Item> <TT>Fl_Menu_Item</TT></A>.  The
+array may either be supplied directly by the user program, or it may
+be "private": a dynamically allocated array managed by the Fl_Menu_.
+
 <H3>Methods</H3>
 <CENTER>
 <TABLE width=90%>
@ -68,26 +70,104 @@ methods to build it dynamically. </P>
 </TD></TR>
 </TABLE>
 </CENTER>
+
 <H4><A name=Fl_Menu_.Fl_Menu_>Fl_Menu_::Fl_Menu_(int x, int y, int w, 
 int h, const char *label = 0)</A></H4>
- Creates a new <TT>Fl_Menu_</TT> widget using the given position, size, 
-and label string. The default boxtype is <TT>FL_NO_BOX</TT>. 
+
+Creates a new <TT>Fl_Menu_</TT> widget using the given position, size,
+and label string.<tt>  menu()</tt> is initialized to null.
+
 <H4><A name=Fl_Menu_.~Fl_Menu_>virtual Fl_Menu_::~Fl_Menu_()</A></H4>
- Destroys the menu and its items. 
-<H4><A name=Fl_Menu_.menu>const Fl_Menu_Item* Fl_Menu_::menu() const
-<BR> void Fl_Menu_::menu(const Fl_Menu_Item*)</A></H4>
- Get or set the menu array directly.  Setting it to <TT>NULL</TT>
- indicates that you want the widget to allocate its own array. 
-<H4><A name=Fl_Menu_.copy>void Fl_Menu_::copy(const Fl_Menu_Item*)</A></H4>
- Set the menu array to a copy of the passed array.  This copy will be
- deleted when the Fl_Menu_ is deleted.
+
+If the menu array is private the memory it uses is freed.
+
+<H4><A name=Fl_Menu_.menu>const Fl_Menu_Item* Fl_Menu_::menu()
+const</a></h4>
+
+Returns a pointer to the array of Fl_Menu_Items.  This will either be
+the value passed to <tt>menu(value)</tt> or the private copy.
+
+<h4>void Fl_Menu_::menu(const Fl_Menu_Item*)</H4>
+Set the menu array pointer directly.  If the old menu is private it is
+deleted.  <tt>NULL</tt> is allowed and acts the same as a zero-length
+menu.  If you try to modify the array (with add(), replace(), or
+delete()) a private copy is automatically done.
+
+<H4><A name=Fl_Menu_.copy>void Fl_Menu_::copy(const
+Fl_Menu_Item*)</A></H4>
+The menu is set to a private copy of the passed Fl_Menu_Item array.
+This is useful if you want to modify the flags of the menu items.
+
+<H4><A name=Fl_Menu_.clear>void Fl_Menu_::clear()</A></H4>
+Same as <tt>menu(NULL)</tt>, set the array pointer to null, indicating
+a zero-length menu.
+
+<H4><A name=Fl_Menu_.size>int Fl_Menu_::size() const</A></H4>
+
+This returns the number of Fl_Menu_Item structures that make up the
+menu, correctly counting submenus.  This includes the "terminator"
+item at the end.  To copy a menu array you need to copy
+<tt>size()*sizeof(Fl_Menu_Item)</tt> bytes.  If the menu is
+<TT>NULL</TT> this returns zero (an empty menu will return 1).
+
+<H4><A name=Fl_Menu_.add>int Fl_Menu_::add(const char* label, const
+char* shortcut, Fl_Callback*, void *user_data=0, int flags=0)</a></h4>
+
+Adds a new menu item, with a <TT>title</TT> string, <TT> shortcut</TT>
+string, <TT>callback</TT>, argument to the callback, and flags.  If
+the menu array was directly set with menu(x) then copy() is done to
+make a private array.
+
+<P>Text is a string of the form &quot;foo/bar/baz&quot;, this example
+will result in a submenu called &quot;foo&quot; and one in that called
+&quot;bar&quot; and and entry called &quot;baz&quot;.  The text is
+copied to new memory and can be freed.  The other arguments (including
+the shortcut) are copied into the menu item unchanged. </P>
+
+<P>If an item exists already with that name then it is replaced with 
+this new one.  Otherwise this new one is added to the end of the 
+correct menu or submenu.  The return value is the offset into the array 
+that the new entry was placed at.</P>
+
+<P>The return value is the index into the array that the entry was put. </P>
+
+<h4>int Fl_Menu_::add(const char *)</A></H4>
+
+<P>The passed string is split at any '|' characters and then <TT>
+add(s,0,0,0,0)</TT> is done with each section.  This is often useful
+if you are just using the value, and is compatable with Forms
+and other GL programs. </P>
+
+<H4><A name=Fl_Menu_.replace>void Fl_Menu_::replace(int n, const char *)</A>
+</H4>
+
+Changes the text of item <TT>n</TT>.  This is the only way to get
+slash into an add()'ed menu item.  If the menu array was directly set
+with menu(x) then copy() is done to make a private array.
+
+<H4><A name=Fl_Menu_.remove>void Fl_Menu_::remove(int n)</A></H4>
+
+Deletes item <TT>n</TT> from the menu.  If the menu array was directly
+set with menu(x) then copy() is done to make a private array.
+
+<H4><A name=Fl_Menu_.shortcut>void Fl_Menu_::shortcut(int i, int n);</A></H4>
+
+Changes the shortcut of item <TT>i</TT> to <TT>n</TT>.
+
+<H4><A name=Fl_Menu_.mode>void Fl_Menu_::mode(int i, int x);</A></H4>
+
+Changes the flags of item <TT>i</TT>.  For a list of the flags, see <a
+href=Fl_Menu_Item.html>Fl_Menu_Item</a>.
+
 <H4><A name=Fl_Menu_.value>int Fl_Menu_::value() const
 <BR> int Fl_Menu_::value(int)
+<BR> const Fl_Menu_Item* mvalue() const
 <BR> int Fl_Menu_::value(const Fl_Menu_Item*)</A></H4>
 The value is the index into <TT>menu()</TT> of the last item chosen by 
 the user.  It is zero initially.  You can set it as an integer, or set 
 it with a pointer to a menu item.  The set routines return non-zero if 
 the new value is different than the old one. 
+
 <H4><A name=Fl_Menu_.test_shortcut>const Fl_Menu_Item* 
 Fl_Menu_::test_shortcut()</A></H4>
 Only call this in response to <TT>FL_SHORTCUT events</TT>.  If the 
@ -102,56 +182,11 @@ have to be visible (ie the window it is in can be hidden, or it does
 not have to be put in a window at all). 
 <P>Currently there can be only one <TT>global()</TT>menu.  Setting a new 
 one will replace the old one.  There is no way to remove the <TT>
-global()</TT> setting (including destroying the menu). </TT></P>
+global()</TT> setting (so don't destroy the widget!)</P>
 <H4><A name=Fl_Menu_.text>const char* Fl_Menu_::text() const
 <BR> const char* Fl_Menu_::text(int i) const</A></H4>
 Returns the title of the last item chosen, or of item <TT>i</TT>. 
-<H4><A name=Fl_Menu_.size>int Fl_Menu_::size() const</A></H4>
- This returns <TT>menu()-&gt;size()</TT>, which is
-the number of Fl_Menu_Item structures that make up this menu,
-correctly counting submenus.  This includes the "terminator" item at
-the end.  So to copy a menu you need to copy
-<tt>size()*sizeof(Fl_Menu_Item)</tt> bytes.  If the menu is <TT>
-NULL</TT> this returns zero (an empty menu will return 1).
-<H4><A name=Fl_Menu_.add>int Fl_Menu_::add(const char *,const char 
-*,Fl_Callback *,void *v=0,int f=0)
-<BR> int Fl_Menu_::add(const char *)</A></H4>
- The first form adds a new menu item, with a <TT>title</TT> string, <TT>
-shortcut</TT> string, <TT>callback</TT>, argument to the callback, and 
-flags.  If <TT>menu()</TT> was originally set with <TT>NULL</TT> then 
-space is allocated for the new item.  If instead you gave it an array 
-then the array must have enough empty space for the new item.  The 
-title string is copied, but the shortcut is not. 
-<P>The second form splits the string at any | characters and then does <TT>
-add(s,0,0,0,0)</TT> with each section.  This is often useful if you are 
-just using the value, and is compatable with some Forms programs. </P>
-<P>Text is a string of the form &quot;foo/bar/baz&quot;, this example will result 
-in a submenu called &quot;foo&quot; and one in that called &quot;bar&quot; and and entry 
-called &quot;baz&quot;.  The text is copied to new memory and can be freed.  The 
-other arguments are copied into the menu item unchanged. </P>
-<P>If an item exists already with that name then it is replaced with 
-this new one.  Otherwise this new one is added to the end of the 
-correct menu or submenu.  The return value is the offset into the array 
-that the new entry was placed at. </P>
-<P>No bounds checking is done, the table must be big enough for all the 
-entries you plan to add.  Don't forget that there is a <TT>NULL</TT>
- terminator on the end, and the first time a item is added to a submenu 
-three items are added (the title and the <TT>NULL</TT> terminator, as 
-well as the actual menu item) </P>
-<P>The return value is the index into the array that the entry was put. </P>
-<H4><A name=Fl_Menu_.clear>void Fl_Menu_::clear()</A></H4>
- Delete all the menu items.  Don't do this if you used <TT>menu(x)</TT>
- to set it to your own array.  You should do this before destroying the <TT>
-Fl_Menu_</TT> widget if it uses it's own array. 
-<H4><A name=Fl_Menu_.replace>void Fl_Menu_::replace(int n, const char *)</A>
-</H4>
- Changes the text of item <TT>n</TT>.  The passed string is copied. 
-<H4><A name=Fl_Menu_.remove>void Fl_Menu_::remove(int n)</A></H4>
- Deletes item <TT>n</TT> from the menu. 
-<H4><A name=Fl_Menu_.shortcut>void Fl_Menu_::shortcut(int i, int n);</A></H4>
- Changes the shortcut of item <TT>i</TT> to <TT>n</TT>. 
-<H4><A name=Fl_Menu_.mode>void Fl_Menu_::mode(int i,int x);</A></H4>
- Changes the flags of item <TT>i</TT>. 
+
 <H4><A name=Fl_Menu_.textcolor>Fl_Color Fl_Menu_::textcolor() const
 <BR> void Fl_Menu_::textcolor(Fl_Color)</A></H4>
 Get or set the current color of menu item labels. 
--- a/documentation/Fl_Menu_Item.html
+++ b/documentation/Fl_Menu_Item.html
@ -274,7 +274,7 @@ provided to position the menu.  The menu is made at least <TT>W</TT>
 found, the menu is aligned just below the rectangle (like a pulldown 
 menu). 
 <P>The <TT>title</TT> and <TT>menubar</TT> arguments are used 
-internally by the <TT>Fl_Menu_</TT> widget. </P>
+internally by the <TT>Fl_Menu_Bar</TT> widget. </P>
 <H4><A name=Fl_Menu_Item.test_shortcut>const Fl_Menu_Item* 
 Fl_Menu_Item::test_shortcut() const</A></H4>
 This is designed to be called by a widgets <TT>handle()</TT> method in 
--- a/src/Fl_Menu_.cxx
+++ b/src/Fl_Menu_.cxx
@ -1,5 +1,5 @@
 //
-// "$Id: Fl_Menu_.cxx,v 1.7.2.2 1999/04/08 19:13:02 carl Exp $"
+// "$Id: Fl_Menu_.cxx,v 1.7.2.3 1999/04/19 07:01:23 bill Exp $"
 //
 // Common menu code for the Fast Light Tool Kit (FLTK).
 //
@ -113,16 +113,13 @@ void Fl_Menu_::menu(const Fl_Menu_Item* m) {
 }

 void Fl_Menu_::copy(const Fl_Menu_Item* m, void* user_data) {
-  int i, s = m->size(), n=s;
-  for (i=0; n; n>>=1, i++);
-  n = 1 << i;
+  int n = m->size();
  Fl_Menu_Item* newMenu = new Fl_Menu_Item[n];
-  memcpy(newMenu, m, s*sizeof(Fl_Menu_Item));
-  memset(newMenu+s, 0, (n-s)*sizeof(Fl_Menu_Item));
+  memcpy(newMenu, m, n*sizeof(Fl_Menu_Item));
  menu(newMenu);
-  alloc = 1; // make destructor free it
+  alloc = 1; // make destructor free array, but not strings
  // for convienence, provide way to change all the user data pointers:
-  if (user_data) for (; s--;) {
+  if (user_data) for (; n--;) {
    if (newMenu->callback_) newMenu->user_data_ = user_data;
    newMenu++;
  }
@ -132,11 +129,18 @@ Fl_Menu_::~Fl_Menu_() {
  clear();
 }

+// Fl_Menu::add() uses this to indicate the owner of the dynamically-
+// expanding array.  We must not free this array:
+Fl_Menu_* fl_menu_array_owner = 0;
+
 void Fl_Menu_::clear() {
  if (alloc) {
    if (alloc>1) for (int i = size(); i--;)
      if (menu_[i].text) free((void*)menu_[i].text);
-    delete[] menu_;
+    if (this == fl_menu_array_owner)
+      fl_menu_array_owner = 0;
+    else
+      delete[] menu_;
    menu_ = 0;
    value_ = 0;
    alloc = 0;
@ -144,5 +148,5 @@ void Fl_Menu_::clear() {
 }

 //
-// End of "$Id: Fl_Menu_.cxx,v 1.7.2.2 1999/04/08 19:13:02 carl Exp $".
+// End of "$Id: Fl_Menu_.cxx,v 1.7.2.3 1999/04/19 07:01:23 bill Exp $".
 //
--- a/src/Fl_Menu_add.cxx
+++ b/src/Fl_Menu_add.cxx
@ -1,5 +1,5 @@
 //
-// "$Id: Fl_Menu_add.cxx,v 1.9 1999/03/09 06:46:36 bill Exp $"
+// "$Id: Fl_Menu_add.cxx,v 1.9.2.1 1999/04/19 07:01:23 bill Exp $"
 //
 // Menu utilities for the Fast Light Tool Kit (FLTK).
 //
@ -24,12 +24,11 @@
 //

 // Methods to alter the menu in an Fl_Menu_ widget.
-// This code is seperated so that it is not linked in if not used.

-// These functions are for emulation of Forms and for dynamically
-// changing the menus.  They are in this source file so they are
-// not linked in if not used, which is what will happen if the
-// the program only uses constant menu tables.
+// These are for Forms emulation and for dynamically changing the
+// menus.  They are in this source file so they are not linked in if
+// not used, which is what will happen if the the program only uses
+// constant menu tables.

 // Not at all guaranteed to be Forms compatable, especially with any
 // string with a % sign in it!
@ -38,34 +37,34 @@
 #include <string.h>
 #include <stdlib.h>

-// always allocate this much initially:
-#define INITIAL_MENU_SIZE 15
+// If the array is this, we will double-reallocate as necessary:
+static Fl_Menu_Item* local_array = 0;
+static int local_array_alloc = 0; // number allocated
+static int local_array_size = 0; // == size(local_array)
+extern Fl_Menu_* fl_menu_array_owner; // in Fl_Menu_.cxx

-// if this local pointer is set, array is reallocated and put here:
-static Fl_Menu_Item** alloc;
+// For historical reasons there are matching methods that work on a
+// user-allocated array of Fl_Menu_Item.  These methods are quite
+// depreciated and should not be used.  These old methods use the
+// above pointers to detect if the array belongs to an Fl_Menu_
+// widget, and if so it reallocates as necessary.

-// Insert a single Fl_Menu_Item into an array at offset n.  If ::alloc
-// is not zero, the array may be reallocated.  This is done each time
-// it's size passes through a power of 2.  The new (or old) array is
-// returned.
-// Notice that size does not count the trailing null item, so one more
-// item than you think must be copied.
+// Insert a single Fl_Menu_Item into an array of size at offset n,
+// if this is local_array it will be reallocated if needed.
 static Fl_Menu_Item* insert(
  Fl_Menu_Item* array, int size,
  int n,
  const char *text,
-  int flags) {
-  // If new size is a power of two, we reallocate to the next power
-  // of two:
-  if (alloc && size >= INITIAL_MENU_SIZE && !((size+1)&size)) {
-    Fl_Menu_Item* newarray = new Fl_Menu_Item[(size+1)*2];
-    memcpy(newarray, array, (size+1)*sizeof(Fl_Menu_Item));
-    memset(newarray+size+1, 0, (size+1)*sizeof(Fl_Menu_Item));
-    delete[] array;
-    *alloc = array = newarray;
+  int flags
+) {
+  if (array == local_array && size >= local_array_alloc) {
+    local_array_alloc = 2*size;
+    Fl_Menu_Item* newarray = new Fl_Menu_Item[local_array_alloc];
+    memmove(newarray, array, size*sizeof(Fl_Menu_Item));
+    local_array = array = newarray;
  }
  // move all the later items:
-  memmove(array+n+1, array+n, sizeof(Fl_Menu_Item)*(size-n+1));
+  memmove(array+n+1, array+n, sizeof(Fl_Menu_Item)*(size-n));
  // create the new item:
  Fl_Menu_Item* m = array+n;
  m->text = text ? strdup(text) : 0;
@ -85,15 +84,15 @@ int Fl_Menu_Item::add(
  int shortcut,
  Fl_Callback *cb,	
  void *data,
-  int flags)
-{
+  int flags
+) {
  Fl_Menu_Item *array = this;
  Fl_Menu_Item *m = this;
  const char *p;
  char *q;
  char buf[1024];

-  int size = array->size();
+  int size = array==local_array ? local_array_size : array->size();
  int flags1 = 0;
  char* item;
  for (;;) {    /* do all the supermenus: */
@ -145,25 +144,54 @@ int Fl_Menu_Item::add(
  m->user_data_ = data;
  m->flags = flags|flags1;

+  if (array == local_array) local_array_size = size;
  return m-array;
 }

 int Fl_Menu_::add(const char *t, int s, Fl_Callback *c,void *v,int f) {
-  int n = value_ ? value_ - menu_ : 0;
-  if (!menu_) {
-    alloc = 2; // indicates that the strings can be freed
-    menu_ = new Fl_Menu_Item[INITIAL_MENU_SIZE+1];
-    menu_[0].text = 0;
+  // make this widget own the local array:
+  if (this != fl_menu_array_owner) {
+    if (fl_menu_array_owner) {
+      Fl_Menu_* o = fl_menu_array_owner;
+      // the previous owner get's its own correctly-sized array:
+      int value_offset = o->value_-local_array;
+      int n = local_array_size;
+      Fl_Menu_Item* newMenu = o->menu_ = new Fl_Menu_Item[n];
+      memcpy(newMenu, local_array, n*sizeof(Fl_Menu_Item));
+      if (o->value_) o->value_ = newMenu+value_offset;
+    }
+    if (menu_) {
+      // this already has a menu array, use it as the local one:
+      delete[] local_array;
+      if (!alloc) copy(menu_); // duplicate a user-provided static array
+      // add to the menu's current array:
+      local_array_alloc = local_array_size = size();
+      local_array = menu_;
+    } else {
+      // start with a blank array:
+      alloc = 2; // indicates that the strings can be freed
+      if (local_array) {
+	menu_ = local_array;
+      } else {
+	local_array_alloc = 15;
+	local_array = menu_ = new Fl_Menu_Item[local_array_alloc];
+      }
+      menu_[0].text = 0;
+      local_array_size = 1;
+    }
+    fl_menu_array_owner = this;
  }
-  if (alloc) ::alloc = &menu_;
  int r = menu_->add(t,s,c,v,f);
-  ::alloc = 0;
-  if (value_) value_ = menu_+n;
+  // if it rellocated array we must fix the pointer:
+  int value_offset = value_-menu_;
+  menu_ = local_array; // in case it reallocated it
+  if (value_) value_ = menu_+value_offset;
  return r;
 }

 // This is a Forms (and SGI GL library) compatable add function, it
-// adds strings of the form "name\tshortcut|name\tshortcut|..."
+// adds many menu items, with '|' seperating the menu items, and tab
+// seperating the menu item names from an optional shortcut string.
 int Fl_Menu_::add(const char *str) {
  char buf[128];
  int r = 0;
@ -183,6 +211,7 @@ int Fl_Menu_::add(const char *str) {

 void Fl_Menu_::replace(int i, const char *str) {
  if (i<0 || i>=size()) return;
+  if (!alloc) copy(menu_);
  if (alloc > 1) {
    free((void *)menu_[i].text);
    str = strdup(str);
@ -193,10 +222,11 @@ void Fl_Menu_::replace(int i, const char *str) {
 void Fl_Menu_::remove(int i) {
  int n = size();
  if (i<0 || i>=n) return;
+  if (!alloc) copy(menu_);
  if (alloc > 1) free((void *)menu_[i].text);
  memmove(&menu_[i],&menu_[i+1],(n-i)*sizeof(Fl_Menu_Item));
 }

 //
-// End of "$Id: Fl_Menu_add.cxx,v 1.9 1999/03/09 06:46:36 bill Exp $".
+// End of "$Id: Fl_Menu_add.cxx,v 1.9.2.1 1999/04/19 07:01:23 bill Exp $".
 //
--- a/test/subwindow.cxx
+++ b/test/subwindow.cxx
@ -1,5 +1,5 @@
 //
-// "$Id: subwindow.cxx,v 1.5 1999/02/03 08:43:35 bill Exp $"
+// "$Id: subwindow.cxx,v 1.5.2.1 1999/04/19 07:01:24 bill Exp $"
 //
 // Nested window test program for the Fast Light Tool Kit (FLTK).
 //
@ -165,10 +165,11 @@ int main(int, char **) {
  popup = new Fl_Menu_Button(0,0,400,400);
  popup->type(Fl_Menu_Button::POPUP3);
  popup->add("This|is|a popup|menu");
+  popup->add(bigmess);
  window->show();
  return Fl::run();
 }

 //
-// End of "$Id: subwindow.cxx,v 1.5 1999/02/03 08:43:35 bill Exp $".
+// End of "$Id: subwindow.cxx,v 1.5.2.1 1999/04/19 07:01:24 bill Exp $".
 //