From b3b90f82f43dba90b2f2f00d87165519d95c4268 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Tue, 26 Dec 2000 07:18:16 +0000 Subject: [PATCH] MenuItem.java (paramString): Now protected. * 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. From-SVN: r38488 --- libjava/ChangeLog | 16 ++ libjava/java/awt/CheckboxMenuItem.java | 124 +++++++++++++- libjava/java/awt/GridBagConstraints.java | 21 +++ libjava/java/awt/MenuBar.java | 283 ++++++++++++++++++++++++++++--- libjava/java/awt/MenuComponent.java | 6 +- libjava/java/awt/MenuShortcut.java | 2 +- 6 files changed, 425 insertions(+), 27 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index f7544c2..ac7344f0 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,19 @@ +2000-12-26 Tom Tromey + + * 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. + 2000-12-25 Tom Tromey * java/awt/MenuContainer.java: Fixed typo. diff --git a/libjava/java/awt/CheckboxMenuItem.java b/libjava/java/awt/CheckboxMenuItem.java index a98c94a..83941a7 100644 --- a/libjava/java/awt/CheckboxMenuItem.java +++ b/libjava/java/awt/CheckboxMenuItem.java @@ -7,9 +7,127 @@ Libgcj License. Please consult the file "LIBGCJ_LICENSE" for 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 + * @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; } diff --git a/libjava/java/awt/GridBagConstraints.java b/libjava/java/awt/GridBagConstraints.java index 6aa75d4..2c34cc9 100644 --- a/libjava/java/awt/GridBagConstraints.java +++ b/libjava/java/awt/GridBagConstraints.java @@ -86,4 +86,25 @@ public class GridBagConstraints implements Cloneable, Serializable 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; + } } diff --git a/libjava/java/awt/MenuBar.java b/libjava/java/awt/MenuBar.java index ce7d3bc..6e25bc9 100644 --- a/libjava/java/awt/MenuBar.java +++ b/libjava/java/awt/MenuBar.java @@ -8,40 +8,281 @@ details. */ 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 + * @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 Font getFont() { return null; } // FIXME - public boolean postEvent(Event evt) { return false; } // FIXME + 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 (); + } + } + } + + // We use Vector because it makes enumerating easier than ArrayList + // in this case. + Vector menus; + Menu help_menu; } diff --git a/libjava/java/awt/MenuComponent.java b/libjava/java/awt/MenuComponent.java index 5c0ea69..a6905ed 100644 --- a/libjava/java/awt/MenuComponent.java +++ b/libjava/java/awt/MenuComponent.java @@ -10,7 +10,7 @@ package java.awt; /* 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 abstract class MenuComponent public void removeNotify() { - // FIXME + if (peer != null) + peer.dispose (); + peer = null; } /** @deprecated Replaced by dispatchEvent(AWTEvent) */ diff --git a/libjava/java/awt/MenuShortcut.java b/libjava/java/awt/MenuShortcut.java index b198926..289e10c 100644 --- a/libjava/java/awt/MenuShortcut.java +++ b/libjava/java/awt/MenuShortcut.java @@ -12,7 +12,7 @@ import java.awt.event.KeyEvent; /* 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; -- 2.7.4