Patch: One more AWT patch
Tom Tromey
tromey@redhat.com
Mon Dec 25 23:14:00 GMT 2000
Here's one more AWT patch with some more new code.
2000-12-26 Tom Tromey <tromey@redhat.com>
* java/awt/MenuItem.java (paramString): Now protected.
* java/awt/MenuShortcut.java: Implements Serializable.
* java/awt/MenuBar.java: Rewrote from scratch.
* java/awt/MenuComponent.java (removeNotify): Wrote.
Implements Serializable.
* java/awt/GridBagConstraints.java (GridBagConstraints): New
constructor.
* java/awt/CheckboxMenuItem.java: Wrote.
Tom
Index: java/awt/CheckboxMenuItem.java
===================================================================
RCS file: /cvs/gcc/egcs/libjava/java/awt/CheckboxMenuItem.java,v
retrieving revision 1.1
diff -u -r1.1 CheckboxMenuItem.java
--- CheckboxMenuItem.java 2000/08/03 12:09:38 1.1
+++ CheckboxMenuItem.java 2000/12/26 07:13:01
@@ -7,9 +7,127 @@
details. */
package java.awt;
+import java.awt.peer.CheckboxMenuItemPeer;
+import java.awt.event.ItemListener;
+import java.awt.event.ItemEvent;
-/* A very incomplete placeholder. */
-
-public class CheckboxMenuItem extends MenuItem
+/** This implements a menu item which keeps track of a boolean state.
+ * @author Tom Tromey <tromey@redhat.com>
+ * @date December 25, 2000
+ */
+public class CheckboxMenuItem extends MenuItem implements ItemSelectable
{
+ /** Create a new CheckboxMenuItem.
+ * @param label The checkbox label. A null value is the same as "";
+ * null is the default.
+ * @param state The initial check state; defaults to false.
+ */
+ public CheckboxMenuItem ()
+ {
+ this (null, false);
+ }
+
+ public CheckboxMenuItem (String label)
+ {
+ this (label, false);
+ }
+
+ public CheckboxMenuItem (String label, boolean state)
+ {
+ this.label = label;
+ this.state = state;
+ }
+
+ /** Add a listener for item events.
+ * @param listener The listener to add.
+ */
+ public synchronized void addItemListener (ItemListener listener)
+ {
+ listeners = AWTEventMulticaster.add (listeners, listener);
+ }
+
+ /** This creates the component's peer. */
+ public void addNotify ()
+ {
+ if (peer != null)
+ {
+ // This choice of toolkit seems unsatisfying, but I'm not sure
+ // what else to do.
+ peer = Toolkit.getDefaultToolkit ().createCheckboxMenuItem (this);
+ }
+ }
+
+ /** Returns this checkbox's label if this checkbox is selected. */
+ public Object[] getSelectedObjects ()
+ {
+ Object[] r;
+ if (state)
+ {
+ r = new Object[1];
+ r[0] = label;
+ }
+ else
+ r = new Object[0];
+ return r;
+ }
+
+ /** Returns the current state of this checkbox. */
+ public boolean getState ()
+ {
+ return state;
+ }
+
+ /** Generates a String representation of this Checkbox's state. */
+ public String paramString ()
+ {
+ return ("[" + getClass ().getName ()
+ + "state=" + state + ","
+ + "label=" + label + "]");
+ }
+
+ /** Process an event for this Checkbox.
+ * @param event The event the process.
+ */
+ protected void processEvent (AWTEvent event)
+ {
+ if (event instanceof ItemEvent)
+ processItemEvent ((ItemEvent) event);
+ else
+ super.processEvent (event);
+ }
+
+ /** Process an item event for this Checkbox.
+ * @param event The ItemEvent to process
+ */
+ protected void processItemEvent (ItemEvent event)
+ {
+ if (listeners != null)
+ listeners.itemStateChanged (event);
+ }
+
+ /** Remove an item listener.
+ * @param listener Item listener to remove.
+ */
+ public synchronized void removeItemListener (ItemListener listener)
+ {
+ listeners = AWTEventMulticaster.remove (listeners, listener);
+ }
+
+ /** Set the checkbox's state.
+ * @param state The new state.
+ */
+ public void setState (boolean state)
+ {
+ this.state = state;
+ if (peer != null)
+ {
+ CheckboxMenuItemPeer cp = (CheckboxMenuItemPeer) peer;
+ cp.setState (state);
+ }
+ }
+
+ // Private state.
+ String label;
+ boolean state;
+ ItemListener listeners;
}
Index: java/awt/GridBagConstraints.java
===================================================================
RCS file: /cvs/gcc/egcs/libjava/java/awt/GridBagConstraints.java,v
retrieving revision 1.2
diff -u -r1.2 GridBagConstraints.java
--- GridBagConstraints.java 2000/12/07 00:46:13 1.2
+++ GridBagConstraints.java 2000/12/26 07:13:01
@@ -86,4 +86,25 @@
this.weightx = 0;
this.weighty = 0;
}
+
+ /** Create a new GridBagConstraints object with the indicated
+ * parameters. */
+ public GridBagConstraints (int gridx, int gridy,
+ int gridwidth, int gridheight,
+ double weightx, double weighty,
+ int anchor, int fill,
+ Insets insets, int ipadx, int ipady)
+ {
+ this.anchor = anchor;
+ this.fill = fill;
+ this.gridx = gridx;
+ this.gridy = gridy;
+ this.gridwidth = gridwidth;
+ this.gridheight = gridheight;
+ this.ipadx = ipadx;
+ this.ipady = ipady;
+ this.insets = insets;
+ this.weightx = weightx;
+ this.weighty = weighty;
+ }
}
Index: java/awt/MenuBar.java
===================================================================
RCS file: /cvs/gcc/egcs/libjava/java/awt/MenuBar.java,v
retrieving revision 1.5
diff -u -r1.5 MenuBar.java
--- MenuBar.java 2000/03/24 09:09:56 1.5
+++ MenuBar.java 2000/12/26 07:13:01
@@ -8,40 +8,281 @@
package java.awt;
-/* A very incomplete placeholder. */
+import java.awt.peer.MenuBarPeer;
+import java.util.Vector;
+import java.util.Enumeration;
+import java.util.NoSuchElementException;
-public class MenuBar extends MenuComponent implements MenuContainer
+/** This class implements a MenuBar, such as might appear across the
+ * top of a window.
+ * @author Tom Tromey <tromey@redhat.com>
+ * @date December 25, 2000
+ */
+public class MenuBar extends MenuComponent implements MenuContainer
{
- Menu[] menus;
- int count;
+ /** Create a new MenuBar. */
+ public MenuBar ()
+ {
+ menus = new Vector ();
+ }
+
+ /** Add a menu to this MenuBar. If the menu has already has a
+ * parent, it is first removed from its old parent before being
+ * added.
+ * @param menu The menu to add.
+ * @returns menu
+ */
+ public synchronized Menu add (Menu menu)
+ {
+ if (menu.parent != null)
+ menu.parent.remove (menu);
+
+ menu.parent = this;
+ menus.add (menu);
+
+ if (peer != null)
+ {
+ MenuBarPeer mp = (MenuBarPeer) peer;
+ mp.add (menu);
+ }
+
+ return menu;
+ }
+
+ /** This creates the component's peer. */
+ public void addNotify ()
+ {
+ if (peer != null)
+ {
+ // This choice of toolkit seems unsatisfying, but I'm not sure
+ // what else to do.
+ peer = Toolkit.getDefaultToolkit ().createMenuBar (this);
+ }
+ }
+
+ /** @deprecated Use getMenuCount() instead. */
+ public int countMenus ()
+ {
+ return getMenuCount ();
+ }
+
+ /** Delete a keyboard shortcut.
+ * @param shortcut The short cut which should be deleted from all
+ * menus on this MenuBar.
+ */
+ public void deleteShortcut (MenuShortcut shortcut)
+ {
+ MenuItem it;
+ // This is a slow implementation, but it probably doesn't matter.
+ while ((it = getShortcutMenuItem (shortcut)) != null)
+ it.deleteShortcut ();
+ }
+
+ /** Returns the current Help menu. */
+ public Menu getHelpMenu ()
+ {
+ return help_menu;
+ }
- public synchronized Menu add (Menu m)
+ /** Returns a menu from this object.
+ * @param index Index of menu to return.
+ */
+ public Menu getMenu (int index)
{
- if (menus == null)
- menus = new Menu[1];
- else if (count == menus.length)
+ return (Menu) menus.get (index);
+ }
+
+ /** Returns the number of menus on this MenuBar. */
+ public int getMenuCount ()
+ {
+ return menus.size ();
+ }
+
+ /** Returns the menu item on this MenuBar with the specified
+ * shortcut.
+ * @param shortcut Shortcut to look for
+ */
+ public MenuItem getShortcutMenuItem (MenuShortcut shortcut)
+ {
+ Enumeration m = new MenuEnumeration (this);
+ while (m.hasMoreElements ())
{
- Menu[] newMenus = new Menu[2 * count];
- System.arraycopy(menus, 0, newMenus, 0, count);
+ MenuItem item = (MenuItem) m.nextElement ();
+ if (item.getShortcut () == shortcut)
+ return item;
}
- menus[count++] = m;
- return m;
+ return null;
}
- public void remove (MenuComponent comp)
+ /** Remove a menu from the menu bar. If the menu is specified by
+ * component (and not index), and does not exist on the menu, then
+ * the method does nothing. If the removed menu has a peer, it is
+ * destroyed.
+ * @param menu The menu to remove
+ * @param index The index of the menu to remove
+ */
+ public synchronized void remove (MenuComponent menu)
{
- for (int i = count; --i >= 0; )
+ int s = menus.size ();
+ for (int i = 0; i < s; ++i)
{
- if (menus[i] == comp)
+ if (menus.get (i) == menu)
{
- System.arraycopy(menus, i, menus, i+1, count-i-1);
- count--;
- // FIXME: destroy peer
- return;
+ remove (i);
+ break;
}
}
}
+
+ public synchronized void remove (int index)
+ {
+ Menu m = (Menu) menus.get (index);
+ menus.remove (index);
+ m.removeNotify ();
+ m.parent = null;
+
+ if (peer != null)
+ {
+ MenuBarPeer mp = (MenuBarPeer) peer;
+ mp.remove (index);
+ }
+ }
+
+ /** Set the Help menu for this MenuBar. If a Help menu already
+ * exists, it is first removed.
+ * @param menu The new Help menu.
+ */
+ public synchronized void setHelpMenu (Menu menu)
+ {
+ if (help_menu != null)
+ {
+ help_menu.removeNotify ();
+ help_menu.parent = null;
+ }
+
+ if (menu.parent != null)
+ menu.parent.remove (menu);
+ if (menu.parent != null)
+ menu.parent.remove (menu);
+ menu.parent = this;
+
+ if (peer != null)
+ {
+ MenuBarPeer mp = (MenuBarPeer) peer;
+ mp.addHelpMenu (menu);
+ }
+ }
+
+ /** Returns an Enumeration which lists the keyboard shortcuts
+ * associated with menu items on this MenuBar.
+ */
+ public synchronized Enumeration shortcuts ()
+ {
+ return new ShortcutEnumeration (new MenuEnumeration (this));
+ }
+
+ // Iterate over the items of a menu.
+ private static class MenuEnumeration implements Enumeration
+ {
+ // Enumerate over the menu's items.
+ Enumeration main;
+ // Enumerate over a submenu.
+ Enumeration sub;
+ // Menubar so we can keep track of help menu too.
+ MenuBar menubar;
+
+ MenuEnumeration (Menu m)
+ {
+ sub = null;
+ menubar = null;
+ main = m.items.elements ();
+ }
+
+ MenuEnumeration (MenuBar mb)
+ {
+ sub = null;
+ menubar = mb;
+ main = mb.menus.elements ();
+ }
+
+ public boolean hasMoreElements ()
+ {
+ boolean r = false;
+ if (sub != null)
+ r = sub.hasMoreElements ();
+ if (! r)
+ r = main.hasMoreElements ();
+ if (! r && menubar != null)
+ {
+ if (menubar.help_menu != null)
+ {
+ main = new MenuEnumeration (menubar.help_menu);
+ r = main.hasMoreElements ();
+ }
+ menubar = null;
+ }
+ return r;
+ }
+
+ public Object nextElement () throws NoSuchElementException
+ {
+ while (true)
+ {
+ if (! sub.hasMoreElements ())
+ sub = null;
+ else
+ return sub.nextElement ();
+
+ if (! main.hasMoreElements () && menubar != null
+ && menubar.help_menu != null)
+ {
+ main = new MenuEnumeration (menubar.help_menu);
+ menubar = null;
+ }
+
+ Object r = main.nextElement ();
+ if (r instanceof Menu)
+ {
+ sub = new MenuEnumeration ((Menu) r);
+ continue;
+ }
+
+ return r;
+ }
+ }
+ }
+
+ // This is an enumeration that shadows another enumeration and
+ // returns the shortcut for each item returned. I wonder if we're
+ // only supposed to return unique shortcuts? If so then we could
+ // keep a hash table here and remove duplicates.
+ private static class ShortcutEnumeration implements Enumeration
+ {
+ Enumeration back;
+
+ ShortcutEnumeration (Enumeration back)
+ {
+ this.back = back;
+ }
+
+ public boolean hasMoreElements ()
+ {
+ return back.hasMoreElements ();
+ }
+
+ public Object nextElement () throws NoSuchElementException
+ {
+ while (true)
+ {
+ MenuItem item = (MenuItem) back.nextElement ();
+ if (item.getShortcut () != null)
+ return item.getShortcut ();
+ }
+ }
+ }
- public Font getFont() { return null; } // FIXME
- public boolean postEvent(Event evt) { return false; } // FIXME
+ // We use Vector because it makes enumerating easier than ArrayList
+ // in this case.
+ Vector menus;
+ Menu help_menu;
}
Index: java/awt/MenuComponent.java
===================================================================
RCS file: /cvs/gcc/egcs/libjava/java/awt/MenuComponent.java,v
retrieving revision 1.4
diff -u -r1.4 MenuComponent.java
--- MenuComponent.java 2000/07/12 03:32:06 1.4
+++ MenuComponent.java 2000/12/26 07:13:01
@@ -10,7 +10,7 @@
/* Status: partially complete, untested. */
-public abstract class MenuComponent
+public abstract class MenuComponent implements java.io.Serializable
{
// Fields from the serialization spec. Decalare others "transient".
Font font;
@@ -71,7 +71,9 @@
public void removeNotify()
{
- // FIXME
+ if (peer != null)
+ peer.dispose ();
+ peer = null;
}
/** @deprecated Replaced by dispatchEvent(AWTEvent) */
Index: java/awt/MenuShortcut.java
===================================================================
RCS file: /cvs/gcc/egcs/libjava/java/awt/MenuShortcut.java,v
retrieving revision 1.1
diff -u -r1.1 MenuShortcut.java
--- MenuShortcut.java 2000/07/12 03:32:06 1.1
+++ MenuShortcut.java 2000/12/26 07:13:01
@@ -12,7 +12,7 @@
/* Status: Complete, except for hashCode(). Untested. */
-public class MenuShortcut
+public class MenuShortcut implements java.io.Serializable
{
// Fields from the serialization spec. Decalare others "transient".
int key;
More information about the Java-patches
mailing list