some_employee.add_your_salary_to( Salary the_sum )
{ the_sum.add( my_salary );
}


interface Transaction
{ public void begin();
public void commit();

public void rollback();
public int supported_rollback_levels();
}

abstract class Visual_proxy
                     extends JComponent
                     implements Transaction
{}

interface User_interface
{ public Visual_proxy proxy( String attribute_name,
boolean is_read_only );
}

Container parent = this;
while( (parent = parent.getParent()) != null )
         if( parent instanceof MenuSite )
            break;

parent = SwingUtilites.getAncestorOfClass(MenuSite.class, this);

class Main_frame extends JFrame implements Menu_site
{
     final Menu_site.Implementation support;

     Main_frame()
     { support = new Menu_site.Implementation(this);
         //...
     }

public void add_menu( Object requester, JMenu item )
     { support.add_menu( requester, item );
     }

public void
     add_line_item(Object requester,JMenuItem item, String here)
     { support.add_line_item(requester, item, here );
     }

public void remove_my_menus( Object requester )
     { support.remove_my_menus( requester );
     }
     //...
}

1: package com.holub.ui;    2:     3: import java.util.*;    4: import java.io.*;    5: import java.awt.*;    6: import java.awt.event.*;    7: import javax.swing.*;    8:     9: import com.holub.tools.debug.Assert;   10:    11: /** A Menu_site is a frame that holds a menu bar. Other objects in   12:  *  the system (which do not have to be visual objects) can negotiate   13:  *  with the Menu_site to have menu's placed on the site's menu   14:  *  bar (or within submenus already found on the menu bar).   15:  */   16:    17: // Possible extensions:   18: // * Stack existing menus and menu items if you add one with the same   19: //   name. Restore old item from the stack when menu reverts to previous   20: //   state.   21:    22: public interface Menu_site   23: {   24:     /*****************************************************************   25:      *  Adds a menu to the menu_site's main menu bar.   26:      *  @param requester    The object that creates the menu. This   27:      *                      does not have to be a visual object.   28:      *  @param menu         The menu to be added       29:      */   30:    31:     void add_menu(Object requester, JMenu menu );   32:    33:     /*****************************************************************   34:      *  Adds a line item to a menu already on the menu_site's main   35:      *  menu bar.   36:      *   37:      *  @param requester    The object that creates the menu. This   38:      *                      does not have to be a visual object.   39:      *  @param item         The line-item to be added. This could   40:      *                      be a single JMenuItem or an entire JMenu.   41:      *  @param to_this_menu The label that identifies the menu to   42:      *                      which the item is to be added. The   43:      *                      to_this_menu string is first compared   44:      *                      against all the (invisible) menu names   45:      *                      (set with JMenuItem.setName())   46:      *                      If no match is found, then the string   47:      *                      is compared to the (visible) labels   48:      *                      (usually passed into the JMenu or JMenuItem   49:      *                      constructor). Note that all the menu names   50:      *                      are examined before any of the labels are   51:      *                      examined (by design).   52:      *                      <p>   53:      *                      The "Help" menu (identified by a label or   54:      *                      name having the value "Help"). No special   55:      *                      methods are required to manipulate it.   56:      *   57:      * @throws IllegalArgumentException (a RuntimeException) if the   58:      *                      menu specified in <code>to_this_menu</code>   59:      *                      can't be found.   60:      */   61:    62:     void add_line_item( Object requester, JMenuItem item,   63:                                                 String to_this_menu);   64:    65:     /*****************************************************************   66:      *  Removes all JMenus and JMenuItem's that were added by this   67:      *  requester. Note that the AWT JMenuBar is, itself, destroyed   68:      *  when it has no menus on it.   69:      */   70:    71:     void remove_my_menus( Object requester );   72:    73:     /*****************************************************************   74:      *  This class provides support for implementing a Menu_site.   75:      *  It has default versions of all menu-site methods, and also   76:      *  maintains the menu bar itself (which is installed   77:      *  on the frame, a reference to which is passed to the   78:      *  Implementation(JFrame) constructor). Use it like this:   79:      *   80:      * <PRE>   81:      *  class Main_frame extends JFrame implements Menu_site   82:      *  {   83:      *      final Menu_site.Implementation support;   84:      *   85:      *      Main_frame()   86:      *      {   support = new Menu_site.Implementation(this);   87:      *          //...   88:      *      }   89:      *   90:      *      public void add_menu(Object requester, JMenu item )   91:      *      {   support.add_menu( requester, item );   92:      *      }   93:      *   94:      *      public void   95:      *      add_line_item(Object requester,JMenuItem item,String here)   96:      *      {   support.add_line_item(requester, item, here );   97:      *      }   98:      *   99:      *      public void remove_my_menus(Object requester) 100:      *      {   support.remove_my_menus( requester ); 101:      *      } 102:      * } 103:      * </PRE> 104:      */ 105:  106:     public static class Implementation 107:                                 implements Menu_site, Serializable 108:     { 109:          // The "requesters" table keeps track of who requested which 110:          // menu items. It is indexed by requester and contains a 111:          // Vector of Implementation.Item objects that identify all 112:          // items added by that requester. 113:          // 114:          // The Implementation also encapsulates the menu bar itself, 115:          // which it creates and installs on its menu_frame (passed 116:          // into the constructor) when the first item is added. 117:  118:         private /*final*/ JFrame    menu_frame; 119:  120:         private JMenuBar    menu_bar    = null; 121:         private Hashtable   requesters  = new Hashtable(); 122:  123:         //------------------------------------------------------------ 124:         public Implementation( JFrame menu_frame ) 125:         {   this.menu_frame = menu_frame; 126:         } 127:         //------------------------------------------------------------ 128:         public void add_menu( Object requester, JMenu menu ) 129:         { 130:             if( menu_bar == null ) 131:                 menu_frame.setJMenuBar( menu_bar = new JMenuBar() ); 132:  133:             Item item = new Item(menu, menu_bar, is_help_menu(menu)); 134:  135:             requester_menus( requester ).addElement(item); 136:             item.attach_menu_to_container(); 137:         } 138:         //------------------------------------------------------------ 139:         public void add_line_item( Object requester, 140:                             JMenuItem line_item, String to_this_menu ) 141:         { 142:             Assert.is_true(requester    != null, "null requester"   ); 143:             Assert.is_true(line_item    != null, "null line_item"   ); 144:             Assert.is_true(to_this_menu != null, "null to_this_menu"); 145:  146:             JMenu found     = null; 147:             int  menu_count = menu_bar.getMenuCount(); 148:  149:             // Find the menu into which the line item should be 150:             // inserted. First check for a match of the (invisible) 151:             // menu names. 152:  153:             int i = 0; 154:             for(; i < menu_count; ++i ) 155:             {   found = menu_bar.getMenu(i); 156:                 if( to_this_menu.equals( found.getName() ) ) 157:                     break; 158:             } 159:  160:             // If that didn't work, check for a match of 161:             // the (visible) menu labels. 162:  163:             if( i >= menu_count ) 164:                 for( i = 0 ; i < menu_count; ++i ) 165:                 {   found = menu_bar.getMenu(i); 166:                     if( to_this_menu.equals( found.getText() ) ) 167:                         break; 168:                 } 169:  170:             // If you can't find it either place, throw an exception. 171:  172:             if( i >= menu_count ) 173:                 throw new IllegalArgumentException( 174:                             "add_line_item() can't find menu (" 175:                                             + to_this_menu + ")" ); 176:  177:             Item item = new Item( line_item, found, false ); 178:              179:             requester_menus( requester ).addElement( item ); 180:             item.attach_menu_to_container(); 181:         } 182:         //------------------------------------------------------------ 183:         public void remove_my_menus( Object requester ) 184:         { 185:             Vector menus = (Vector)( requesters.remove(requester) ); 186:  187:             if( menus != null ) 188:             {   Enumeration e = menus.elements(); 189:                 while( e.hasMoreElements() ) 190:                     ((Item)(e.nextElement())) 191:                                         .detach_menu_from_container(); 192:             } 193:         } 194:  195:         /************************************************************* 196:          * Set the default font used by the {@link #line_item} and 197:          * {@link #menu} convenience methods. If you never call this 198:          * method, 10-point, SanSerif, bold is used. 199:          */ 200:         static public void setFont( Font menu_font ) 201:         {   Implementation.menu_font = menu_font; 202:         } 203:  204:         static private Font menu_font = 205:                                 new Font("SansSerif", Font.BOLD, 10); 206:  207:         /************************************************************* 208:          * This is a convenience method that manufactures menu items 209:          * with text labels. The font used is a bit more tractable 210:          * than the default Java look-and-feel font. 211:          */ 212:         static public JMenuItem line_item(String text, 213:                                                 ActionListener action) 214:         {   JMenuItem item = new JMenuItem( text ); 215:             item.setFont( menu_font ); 216:             item.addActionListener( action ); 217:             return item; 218:         } 219:         /************************************************************* 220:          * This is a convenience method that manufactures JMenu's 221:          * that use the same font as the line items manufactured by 222:          * {@link #line_item}. 223:          */ 224:         static public JMenu menu(String text) 225:         {   JMenu item = new JMenu( text ); 226:             item.setFont( menu_font ); 227:             return item; 228:         } 229:  230:         //============================================================ 231:         // Private support methods and classes 232:  233:         /************************************************************* 234:          * The menu_bar_contents vector contains references to the 235:          * various menus that comprise the menu bar. This kluge is 236:          * necessary because Swing does not yet support the notion 237:          * of a Help menu, and it won't let you insert menus anywhere 238:          * other than the far right of the menu bar, where the Help 239:          * menu should be. Consequently, when a new menu is added to 240:          * a menu bar, you need to clear out the existing menu bar 241:          * and rebuild it from scratch. The menu_bar_has_help 242:          * indicates that a help menu has been installed (It's 243:          * assumed to be at the far right of the menu bar.) 244:          */ 245:  246:         private final LinkedList menu_bar_contents = new LinkedList(); 247:  248:         /************************************************************* 249:          * An Item makes the association between a line item or 250:          * submenu and the MenuBar or Menu that contains it. You can 251:          * ask an Item to add or remove itself from its container. 252:          * All the weirdness associated with help menus is handled 253:          * here. 254:          */ 255:  256:         private final class Item implements Serializable 257:         {   258:             private final JMenuItem line_item; 259:             private       Object    container; 260:             private final boolean   is_help_menu; 261:  262:             public Item( JMenuItem line_item, Object container, 263:                                                 boolean is_help_menu) 264:             {   265:                 Assert.is_true( container instanceof JMenu    || 266:                                 container instanceof JMenuBar ); 267:  268:                 this.line_item      = line_item; 269:                 this.container      = container; 270:                 this.is_help_menu   = is_help_menu; 271:             } 272:  273:             /******************************************************** 274:              * Attach a menu item to it's container (either a menu 275:              * bar or a menu). Items are added at the end of the 276:              * <code>menu_bar_contents</code> list unless a help 277:              * menu exists, in which case items are added at 278:              * the penultimate position. 279:              */ 280:  281:             public final void attach_menu_to_container() 282:             { 283:                 if( container instanceof JMenu ) 284:                     ((JMenu)container).add( line_item ); 285:                 else 286:                 { 287:                     if( menu_bar_contents.size() <= 0 ) 288:                     {   289:                         menu_bar_contents.add( this ); 290:                         ((JMenuBar)container).add( line_item ); 291:                     } 292:                     else 293:                     {   Item last = 294:                                 (Item)( menu_bar_contents.getLast() ); 295:                         if( !last.is_help_menu ) 296:                         {   menu_bar_contents.add(this); 297:                             ((JMenuBar)container).add( line_item ); 298:                         } 299:                         else    // remove the help menu, add the new 300:                         {       // item, then put the help menu back 301:                                 // (following the new item). 302:  303:                             menu_bar_contents.removeLast(); 304:                             menu_bar_contents.add( this ); 305:                             menu_bar_contents.add( last ); 306:                             container = regenerate(); 307:                         } 308:                     } 309:                 } 310:             } 311:  312:             /******************************************************** 313:              * Remove the current menu item from its container 314:              * (either a menu bar or a menu). 315:              */ 316:             public final void detach_menu_from_container() 317:             {   318:                 if( container instanceof JMenu ) 319:                 {   ((JMenu)container).remove( line_item ); 320:                 } 321:                 else 322:                 {   ((JMenuBar)container).remove( line_item ); 323:                     menu_bar_contents.remove( this ); 324:                     container = regenerate(); 325:                 } 326:             } 327:  328:  329:             /******************************************************** 330:              * Replace the old menu bar with a new one that reflects 331:              * the current state of the <code>menu_bar_contents</code> 332:              * list. 333:              */ 334:             private JMenuBar regenerate() 335:             { 336:                 // Create the new menu bar and populate it from 337:                 // the current-contents list. 338:  339:                 menu_bar = new JMenuBar(); 340:                 ListIterator i = menu_bar_contents.listIterator(0); 341:                 while( i.hasNext() ) 342:                     menu_bar.add( ((Item)(i.next())).line_item ); 343:  344:                 // Replace the old menu bar with the new one. 345:                 // Calling setVisible causes the menu bar to be 346:                 // redrawn with a minimum amount of flicker. Without 347:                 // it, the redraw doesn't happen at all. 348:  349:                 menu_frame.setJMenuBar( menu_bar ); 350:                 menu_frame.setVisible( true ); 351:  352:                 return menu_bar; 353:             } 354:         } 355:         /************************************************************ 356:          * Return a vector of menu items associated with a given 357:          * requester. A new (empty) vector is created and returned 358:          * if there are no menus associated with the requester at 359:          * present. 360:          */ 361:         private Vector requester_menus( Object requester ) 362:         { 363:             Assert.is_true( requester  != null, "Bad argument"  ); 364:             Assert.is_true( requesters != null, "No requesters" ); 365:  366:             Vector menus = (Vector)( requesters.get(requester) ); 367:             if( menus == null ) 368:             {   menus = new Vector(); 369:                 requesters.put( requester, menus ); 370:             } 371:             return menus; 372:         } 373:         /************************************************************ 374:          * Return true if the menu passed as an argument is the 375:          * "help" menu. The name "help" is not case sensitive. 376:          */ 377:         private boolean is_help_menu( JMenu menu ) 378:         { 379:             String s = menu.getName(); 380:             if( s != null && s.toLowerCase().equals("help") ) 381:                 return true; 382:  383:             s = menu.getText(); 384:             return (s != null && s.toLowerCase().equals("help")); 385:         } 386:     } 387:  388:     /*************************************************************** 389:      * This inner class tests the Menu_site.Implementation. Do not 390:      * Ship Menu_site$Test.class with the applications. Test the 391:      * code by invoking "java com.holub.tools.Menu_site\$Test". 392:      * The test code creates three menus: 393:      *  o   A Help menu that contains three line items, each added in 394:      *      a different way. Nothing happens when these are selected. 395:      *  o   A "Removal" menu that disappears when selected. 396:      *  o   A "Main" menu that initially contains a single line item 397:      *      called "Add an Item." Selecting this item adds a "Remove 398:      *      Menus" Item to the "Main" menu. Selecting that removes 399:      *      both the Main and Help (but not the "Removal") menus. 400:      */ 401:  402:     static class Test extends JFrame implements Menu_site 403:     { 404:         static Test instance; 405:  406:         Test() 407:         {   setSize( 400, 200 );     408:             addWindowListener 409:             (   new WindowAdapter() 410:                 {   public void windowClosing( WindowEvent e ) 411:                     {   System.exit(1); 412:                     } 413:                 } 414:             ); 415:             show(); 416:         } 417:         //------------------------------------------------------------ 418:         final Menu_site.Implementation support 419:                                 = new Menu_site.Implementation(this); 420:  421:         public void add_menu(Object requester, JMenu item ) 422:         {   support.add_menu( requester, item ); 423:         } 424:  425:         public void 426:         add_line_item(Object requester, JMenuItem item, 427:                                                 String to_this_menu) 428:         {   support.add_line_item(requester, item, to_this_menu ); 429:         } 430:  431:         public void remove_my_menus(Object requester) 432:         {   support.remove_my_menus( requester ); 433:         } 434:  435:         //------------------------------------------------------------ 436:         static class Remove_listener implements ActionListener 437:         {   public void actionPerformed( ActionEvent e ) 438:             {   instance.remove_my_menus( instance ); 439:             } 440:         } 441:  442:         static public void main( String[] args ) 443:         { 444:             instance = new Test(); 445:  446:             JMenu main_menu = new JMenu( "Main" ); 447:             instance.add_menu( instance, main_menu ); 448:  449:             JMenuItem add_an_item_menu = new JMenuItem( 450:                                             "Add Line Item to Menu" ); 451:             add_an_item_menu.addActionListener 452:             (   new ActionListener() 453:                 {   public void actionPerformed( ActionEvent e ) 454:                     { 455:                         JMenuItem remove_menus = new JMenuItem( 456:                                         "Remove Main and Help menus"); 457:  458:                         remove_menus.addActionListener 459:                         (  new ActionListener() 460:                            { public void actionPerformed(ActionEvent e) 461:                              {  instance.remove_my_menus(instance); 462:                              } 463:                            } 464:                         ); 465:  466:                         // Add line item via menu site 467:                         instance.add_line_item(instance, 468:                                                 remove_menus, "Main"); 469:                     } 470:                 } 471:             ); 472:  473:             // Add this line-item directly to the "Main" menu (without 474:             // going through the menu site) just to make sure that 475:             // we can. 476:  477:             main_menu.add( add_an_item_menu ); 478:  479:             // Create a help menu. Do it in the middle of things 480:             // to make sure that it ends up on the far right. 481:             // Use all three mechanisms for adding menu items directly 482:             // using the menu's "name," and using the menu's "text"). 483:  484:             JMenu help = new JMenu("Help"); // "Help" is the menu text 485:             help.setName("HelpMenu");       // "HelpMenu" is the 486:                                             // (invisible) menu name 487:  488:             JMenuItem help_by_text= new JMenuItem("Added using text"); 489:             JMenuItem help_by_name= new JMenuItem("Added using name"); 490:             JMenuItem help_direct = new JMenuItem("Added directly"); 491:  492:             ActionListener help_listener = 493:                 new ActionListener() 494:                 {  public void actionPerformed(ActionEvent e) 495:                        {  System.out.println("No help available"); } 496:                 }; 497:  498:             help_by_text.addActionListener( help_listener ); 499:             help_by_name.addActionListener( help_listener ); 500:             help_direct.addActionListener ( help_listener ); 501:                  502:             instance.add_menu     ( instance, help ); 503:  504:             help    .add          (help_direct                       ); 505:             instance.add_line_item(instance, help_by_text, "Help"    ); 506:             instance.add_line_item(instance, help_by_name, "HelpMenu"); 507:  508:             // Create a second "requester" and have it add a Removal 509:             // menu with the name Removal_menu. Picking that menu 510:             // will remove only the menu for the current requester. 511:  512:             final int x[] = new int[1]; 513:  514:             JMenu remove_menu = new JMenu("Removal"); 515:             remove_menu.setName( "Removal_menu" ); 516:             instance.add_menu( x, remove_menu ); 517:  518:             // Create and add a line item to the Removal_menu by name 519:             // (the earlier example used the Label). 520:  521:             JMenuItem remove_me = new JMenuItem("Click_to_Remove_Me"); 522:             remove_me.addActionListener 523:             (   new ActionListener() 524:                 {   public void actionPerformed( ActionEvent e ) 525:                     {   instance.remove_my_menus(x); 526:                     } 527:                 } 528:             ); 529:             instance.add_line_item( x, remove_me, "Removal_menu" ); 530:         } 531:     } 532: }