1. /*

  2.  * @(#)SynthInternalFrameTitlePane.java	1.14 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.gtk;

  9. 

  10. import java.awt.*;

  11. import java.awt.event.*;

  12. import javax.swing.*;

  13. import javax.swing.plaf.*;

  14. import javax.swing.border.*;

  15. import javax.swing.event.InternalFrameEvent;

  16. import java.util.EventListener;

  17. import java.beans.PropertyChangeListener;

  18. import java.beans.PropertyChangeEvent;

  19. import java.beans.VetoableChangeListener;

  20. import java.beans.PropertyVetoException;

  21. 

  22. /**

  23.  * The class that manages a basic title bar

  24.  * <p>

  25.  * <strong>Warning:</strong>

  26.  * Serialized objects of this class will not be compatible with

  27.  * future Swing releases. The current serialization support is

  28.  * appropriate for short term storage or RMI between applications running

  29.  * the same version of Swing.  As of 1.4, support for long term storage

  30.  * of all JavaBeans<sup><font size="-2">TM</font></sup>

  31.  * has been added to the <code>java.beans</code> package.

  32.  * Please see {@link java.beans.XMLEncoder}.

  33.  *

  34.  * @version 1.14 01/23/03

  35.  *  (originally from version 1.52 of BasicInternalFrameTitlePane)

  36.  * @author David Kloba

  37.  * @author Joshua Outwater

  38.  * @author Steve Wilson

  39.  */

  40. class SynthInternalFrameTitlePane extends JComponent implements SynthUI {

  41.     protected JButton minimizeButton;

  42.     protected JButton maximizeButton;

  43.     protected JButton closeButton;

  44. 

  45.     protected JPopupMenu systemPopupMenu;

  46.     protected JButton menuButton;

  47. 

  48.     protected JInternalFrame frame;

  49. 

  50.     protected Icon maximizeIcon;

  51.     protected Icon restoreIcon;

  52.     protected Icon minimizeIcon;

  53.     protected Icon closeIcon;

  54. 

  55.     protected PropertyChangeListener propertyChangeListener;

  56. 

  57.     protected Action closeAction;

  58.     protected Action maximizeAction;

  59.     protected Action iconifyAction;

  60.     protected Action restoreAction;

  61.     protected Action moveAction;

  62.     protected Action sizeAction;

  63. 

  64.     // PENDING: This should be looked up as needed.

  65.     protected static final String CLOSE_CMD =

  66.         UIManager.getString("InternalFrameTitlePane.closeButtonText");

  67.     protected static final String ICONIFY_CMD =

  68.         UIManager.getString("InternalFrameTitlePane.minimizeButtonText");

  69.     protected static final String RESTORE_CMD =

  70.         UIManager.getString("InternalFrameTitlePane.restoreButtonText");

  71.     protected static final String MAXIMIZE_CMD =

  72.         UIManager.getString("InternalFrameTitlePane.maximizeButtonText");

  73.     protected static final String MOVE_CMD =

  74.         UIManager.getString("InternalFrameTitlePane.moveButtonText");

  75.     protected static final String SIZE_CMD =

  76.         UIManager.getString("InternalFrameTitlePane.sizeButtonText");

  77. 

  78.     private String closeButtonToolTip;

  79.     private String minimizeButtonToolTip;

  80.     private String restoreButtonToolTip;

  81.     private String maximizeButtonToolTip;

  82. 

  83.     private SynthStyle style;

  84. 

  85.     public SynthInternalFrameTitlePane(JInternalFrame f) {

  86.         fetchStyle(this);

  87. 

  88. 	frame = f;

  89. 	installTitlePane();

  90. 

  91. 	menuButton.setName("InternalFrameTitlePane.menuButton");

  92.         minimizeButton.setName("InternalFrameTitlePane.iconifyButton");

  93.         maximizeButton.setName("InternalFrameTitlePane.maximizeButton");

  94.         closeButton.setName("InternalFrameTitlePane.closeButton");

  95.     }

  96. 

  97.     public String getUIClassID() {

  98.         return "InternalFrameTitlePaneUI";

  99.     }

  100. 

  101.     protected void installTitlePane() {

  102. 	installDefaults();

  103.         installListeners();

  104.         

  105. 	createActions();

  106. 	enableActions();

  107. 	createActionMap();

  108. 

  109. 	setLayout(createLayout());

  110. 

  111. 	assembleSystemMenu();

  112. 	createButtons();

  113. 	addSubComponents();

  114. 

  115.     }

  116. 

  117.     public SynthContext getContext(JComponent c) {

  118.         return getContext(c, getComponentState(c));

  119.     }

  120. 

  121.     public SynthContext getContext(JComponent c, int state) {

  122.         return SynthContext.getContext(SynthContext.class, c,

  123.                     SynthLookAndFeel.getRegion(c), style, state);

  124.     }

  125. 

  126.     private Region getRegion(JComponent c) {

  127.         return SynthLookAndFeel.getRegion(c);

  128.     }

  129. 

  130.     private int getComponentState(JComponent c) {

  131.         if (frame != null) {

  132.             if (frame.isSelected()) {

  133.                 return SELECTED;

  134.             }

  135.         }

  136.         return SynthLookAndFeel.getComponentState(c);

  137.     }

  138. 

  139.     protected void addSubComponents() {

  140. 	add(menuButton);

  141. 	add(minimizeButton);

  142. 	add(maximizeButton);

  143. 	add(closeButton);

  144.     }

  145. 

  146.     protected void createActions() {

  147. 	maximizeAction = new MaximizeAction();

  148. 	iconifyAction = new IconifyAction();

  149. 	closeAction = new CloseAction();

  150. 	restoreAction = new RestoreAction();

  151. 	moveAction = new MoveAction();

  152. 	sizeAction = new SizeAction();

  153.     }

  154. 

  155.     ActionMap createActionMap() {

  156. 	ActionMap map = new ActionMapUIResource();

  157. 	map.put("showSystemMenu", new ShowSystemMenuAction(true));

  158. 	map.put("hideSystemMenu", new ShowSystemMenuAction(false));

  159. 	return map;

  160.     }

  161. 

  162.     protected void installListeners() {

  163.         if(propertyChangeListener == null) {

  164.             propertyChangeListener = createPropertyChangeListener();

  165.         }

  166. 	frame.addPropertyChangeListener(propertyChangeListener);

  167.     }

  168. 

  169.     protected void uninstallListeners() {

  170. 	frame.removePropertyChangeListener(propertyChangeListener);

  171.     }

  172. 

  173.     private void fetchStyle(JComponent c) {

  174.         SynthContext context = getContext(this, ENABLED);

  175.         SynthStyle oldStyle = style;

  176.         style = SynthLookAndFeel.updateStyle(context, this);

  177.         if (style != oldStyle) {

  178.             maximizeIcon = style.getIcon(context,"InternalFrameTitlePane.maximizeIcon");

  179.             restoreIcon = style.getIcon(context,"InternalFrameTitlePane.restoreIcon");

  180.             minimizeIcon = style.getIcon(context,"InternalFrameTitlePane.iconifyIcon");

  181.             closeIcon = style.getIcon(context,"InternalFrameTitlePane.closeIcon");

  182.         }

  183.         context.dispose();

  184.     }

  185. 

  186.     protected void installDefaults() {

  187.         closeButtonToolTip =

  188.                 UIManager.getString("InternalFrame.closeButtonToolTip");

  189.         minimizeButtonToolTip =

  190.                 UIManager.getString("InternalFrame.iconButtonToolTip");

  191.         restoreButtonToolTip =

  192.                 UIManager.getString("InternalFrame.restoreButtonToolTip");

  193.         maximizeButtonToolTip =

  194.                 UIManager.getString("InternalFrame.maxButtonToolTip");

  195.     }

  196. 

  197. 

  198.     protected void uninstallDefaults() {

  199.         SynthContext context = getContext(this, ENABLED);

  200. 

  201.         style.uninstallDefaults(context);

  202.         context.dispose();

  203.         style = null;

  204.     }

  205. 

  206.     protected void createButtons() {

  207. 	minimizeButton = createNoFocusButton();

  208. 	minimizeButton.addActionListener(iconifyAction);

  209.         if (minimizeButtonToolTip != null && minimizeButtonToolTip.length() != 0) {

  210.             minimizeButton.setToolTipText(minimizeButtonToolTip);

  211.         }

  212. 

  213. 	maximizeButton = createNoFocusButton();

  214. 	maximizeButton.addActionListener(maximizeAction);

  215. 

  216. 	closeButton = createNoFocusButton();  

  217. 	closeButton.addActionListener(closeAction);

  218.         if (closeButtonToolTip != null && closeButtonToolTip.length() != 0) {

  219.             closeButton.setToolTipText(closeButtonToolTip);

  220.         }

  221. 

  222.         setButtonIcons();

  223.     }

  224. 

  225.     protected void setButtonIcons() {

  226.         if(frame.isIcon()) {

  227. 	    if (restoreIcon != null) {

  228. 		minimizeButton.setIcon(restoreIcon);

  229. 	    }

  230.             if (restoreButtonToolTip != null && restoreButtonToolTip.length() != 0) {

  231.                 minimizeButton.setToolTipText(restoreButtonToolTip);

  232.             }

  233. 	    if (maximizeIcon != null) {

  234. 		maximizeButton.setIcon(maximizeIcon);

  235. 	    }

  236.             if (maximizeButtonToolTip != null && maximizeButtonToolTip.length() != 0) {

  237.                 maximizeButton.setToolTipText(maximizeButtonToolTip);

  238.             }

  239.         } else if (frame.isMaximum()) {

  240. 	    if (minimizeIcon != null) {

  241. 		minimizeButton.setIcon(minimizeIcon);

  242. 	    }

  243.             if (minimizeButtonToolTip != null && minimizeButtonToolTip.length() != 0) {

  244.                 minimizeButton.setToolTipText(minimizeButtonToolTip);

  245.             }

  246. 	    if (restoreIcon != null) {

  247. 		maximizeButton.setIcon(restoreIcon);

  248. 	    }

  249.             if (restoreButtonToolTip != null && restoreButtonToolTip.length() != 0) {

  250.                 maximizeButton.setToolTipText(restoreButtonToolTip);

  251.             }

  252.         } else {

  253. 	    if (minimizeIcon != null) {

  254. 		minimizeButton.setIcon(minimizeIcon);

  255. 	    }

  256.             if (minimizeButtonToolTip != null && minimizeButtonToolTip.length() != 0) {

  257.                 minimizeButton.setToolTipText(minimizeButtonToolTip);

  258.             }

  259. 	    if (maximizeIcon != null) {

  260. 		maximizeButton.setIcon(maximizeIcon);

  261. 	    }

  262.             if (maximizeButtonToolTip != null && maximizeButtonToolTip.length() != 0) {

  263.                 maximizeButton.setToolTipText(maximizeButtonToolTip);

  264.             }

  265.         }

  266. 	if (closeIcon != null) {

  267. 	    closeButton.setIcon(closeIcon);

  268. 	}

  269.     }

  270. 

  271.     protected void assembleSystemMenu() {

  272.         systemPopupMenu = new JPopupMenu();

  273.         addSystemMenuItems(systemPopupMenu);

  274. 	enableActions();

  275.         menuButton = createNoFocusButton();

  276. 	menuButton.setIcon(frame.getFrameIcon());

  277.         menuButton.addMouseListener(new MouseAdapter() {

  278.             public void mousePressed(MouseEvent e) {

  279.                 Dimension dim = new Dimension();

  280.                 Border border = frame.getBorder();

  281.                 if (border != null) {

  282.                     dim.width += border.getBorderInsets(frame).left +

  283.                                  border.getBorderInsets(frame).right;

  284.                     dim.height += border.getBorderInsets(frame).bottom +

  285.                                   border.getBorderInsets(frame).top;

  286.                 }

  287.                 if (!frame.isIcon()) {

  288.                     systemPopupMenu.show(e.getComponent(),

  289.                         getX() - dim.width,

  290.                         getY() + getHeight() - dim.height);

  291.                 } else {

  292.                     systemPopupMenu.show(e.getComponent(),

  293.                         getX() - dim.width,

  294.                         getY() - systemPopupMenu.getPreferredSize().height -

  295.                             dim.height);

  296.                 }

  297.             }

  298.         });

  299.     }

  300. 

  301.     protected void addSystemMenuItems(JPopupMenu menu) {

  302.         // PENDING: this should all be localizable!

  303.         JMenuItem mi = (JMenuItem)menu.add(restoreAction);

  304. 	mi.setMnemonic('R');

  305. 	mi = (JMenuItem)menu.add(moveAction);

  306. 	mi.setMnemonic('M');

  307. 	mi = (JMenuItem)menu.add(sizeAction);

  308. 	mi.setMnemonic('S');

  309. 	mi = (JMenuItem)menu.add(iconifyAction);

  310. 	mi.setMnemonic('n');

  311. 	mi = (JMenuItem)menu.add(maximizeAction);

  312. 	mi.setMnemonic('x');

  313. 	menu.add(new JSeparator());

  314. 	mi = (JMenuItem)menu.add(closeAction);

  315. 	mi.setMnemonic('C');

  316.     }

  317. 

  318.     // SynthInternalFrameTitlePane has no UI, we'll invoke paint on it.

  319.     public void paintComponent(Graphics g) {

  320.         SynthContext context = getContext(this);

  321.         SynthLookAndFeel.update(context, g);

  322.         context.dispose();

  323.     }

  324. 

  325.     /**

  326.      * Post a WINDOW_CLOSING-like event to the frame, so that it can

  327.      * be treated like a regular Frame.

  328.      */

  329.     protected void postClosingEvent(JInternalFrame frame) {

  330.         InternalFrameEvent e = new InternalFrameEvent(

  331.             frame, InternalFrameEvent.INTERNAL_FRAME_CLOSING);

  332.         // Try posting event, unless there's a SecurityManager.

  333.         if (JInternalFrame.class.getClassLoader() == null) {

  334.             try {

  335.                 Toolkit.getDefaultToolkit().getSystemEventQueue().postEvent(e);

  336.                 return;

  337.             } catch (SecurityException se) {

  338.                 // Use dispatchEvent instead.

  339.             }

  340.         }

  341.         frame.dispatchEvent(e);

  342.     }

  343. 

  344. 

  345.     protected void enableActions() {

  346.         restoreAction.setEnabled(frame.isMaximum() || frame.isIcon());

  347.         maximizeAction.setEnabled(frame.isMaximizable() && !frame.isMaximum());

  348.         iconifyAction.setEnabled(frame.isIconifiable() && !frame.isIcon());

  349.         closeAction.setEnabled(frame.isClosable());

  350.         sizeAction.setEnabled(false);

  351.         moveAction.setEnabled(false);

  352.     }

  353. 

  354. 

  355.     protected PropertyChangeListener createPropertyChangeListener() {

  356.         return new PropertyChangeHandler();

  357.     }

  358. 

  359.     protected LayoutManager createLayout() {

  360.         SynthContext context = getContext(this);

  361. 	LayoutManager lm =

  362. 	    (LayoutManager)style.get(context, "InternalFrameTitlePane.titlePaneLayout");

  363. 	context.dispose();

  364.         return (lm != null) ? lm : new TitlePaneLayout();

  365.     }

  366. 

  367. 

  368.     /**

  369.      * This inner class is marked "public" due to a compiler bug.

  370.      * This class should be treated as a "protected" inner class.

  371.      * Instantiate it only within subclasses of <Foo>.

  372.      */

  373.     class PropertyChangeHandler implements PropertyChangeListener {

  374.         public void propertyChange(PropertyChangeEvent evt) {

  375. 

  376.             String prop = (String)evt.getPropertyName();

  377. 

  378.             if (SynthLookAndFeel.shouldUpdateStyle(evt)) {

  379.                 fetchStyle(SynthInternalFrameTitlePane.this);

  380.             }

  381.             if (JInternalFrame.IS_SELECTED_PROPERTY.equals(prop)) {

  382.                 repaint();

  383.                 return;

  384.             } 

  385. 

  386.             if (JInternalFrame.IS_ICON_PROPERTY.equals(prop) ||

  387.                     JInternalFrame.IS_MAXIMUM_PROPERTY.equals(prop)) {

  388.                 setButtonIcons();

  389.                 enableActions();

  390.                 return;

  391.             }

  392. 

  393.             if (prop.equals("closable")) {

  394.                 if ((Boolean)evt.getNewValue() == Boolean.TRUE) {

  395.                     add(closeButton);

  396.                 } else {

  397.                     remove(closeButton);

  398.                 }

  399.             } else if (prop.equals("maximizable")) {

  400.                 if ((Boolean)evt.getNewValue() == Boolean.TRUE) {

  401.                     add(maximizeButton);

  402.                 } else {

  403.                     remove(maximizeButton);

  404.                 }

  405.             } else if (prop.equals("iconable")) {

  406.                 if ((Boolean)evt.getNewValue() == Boolean.TRUE) {

  407.                     add(minimizeButton);

  408.                 } else {

  409.                     remove(minimizeButton);

  410.                 }

  411.             }

  412.             enableActions();

  413. 

  414.             revalidate();

  415.             repaint();

  416.         }

  417. 

  418.     }  // end PropertyHandler class

  419. 

  420.     /**

  421.      * This inner class is marked "public" due to a compiler bug.

  422.      * This class should be treated as a "protected" inner class.

  423.      * Instantiate it only within subclasses of <Foo>.

  424.      */

  425.     class TitlePaneLayout implements LayoutManager {

  426.         public void addLayoutComponent(String name, Component c) {}

  427.         public void removeLayoutComponent(Component c) {}    

  428.         public Dimension preferredLayoutSize(Container c)  {

  429. 	    return minimumLayoutSize(c);

  430. 	}

  431.     

  432.         public Dimension minimumLayoutSize(Container c) {

  433.             // Calculate width.

  434.             int width = 22;

  435.  

  436.             if (frame.isClosable()) {

  437.                 width += 19;

  438.             }

  439.             if (frame.isMaximizable()) {

  440.                 width += 19;

  441.             }

  442.             if (frame.isIconifiable()) {

  443.                 width += 19;

  444.             }

  445. 

  446.             FontMetrics fm = getFontMetrics(getFont());

  447.             String frameTitle = frame.getTitle();

  448.             int title_w = frameTitle != null ? fm.stringWidth(frameTitle) : 0;

  449.             int title_length = frameTitle != null ? frameTitle.length() : 0;

  450. 

  451.             // Leave room for three characters in the title.

  452.             if (title_length > 3) {

  453.                 int subtitle_w =

  454.                     fm.stringWidth(frameTitle.substring(0, 3) + "...");

  455.                 width += (title_w < subtitle_w) ? title_w : subtitle_w;

  456.             } else {

  457.                 width += title_w;

  458.             }

  459. 

  460.             // Calculate height.

  461.             Icon icon = frame.getFrameIcon();

  462.             int fontHeight = fm.getHeight();

  463.             fontHeight += 2;

  464.             int iconHeight = 0;

  465.             if (icon != null) {

  466.                 // SystemMenuBar forces the icon to be 16x16 or less.

  467.                 iconHeight = Math.min(icon.getIconHeight(), 16);

  468.             }

  469.             iconHeight += 2;

  470.       

  471.             int height = Math.max( fontHeight, iconHeight );

  472. 

  473.             Dimension dim = new Dimension(width, height);

  474. 

  475.             // Take into account the border insets if any.

  476.             if (getBorder() != null) {

  477.                 Insets insets = getBorder().getBorderInsets(c);

  478.                 dim.height += insets.top + insets.bottom;

  479.                 dim.width += insets.left + insets.right;

  480.             }

  481.             return dim;

  482. 	}

  483.     

  484.         public void layoutContainer(Container c) {

  485.             boolean leftToRight = SynthLookAndFeel.isLeftToRight(frame);

  486. 

  487.             int w = getWidth();

  488.             int h = getHeight();

  489.             int x;

  490. 

  491.             Icon closeIcon = closeButton.getIcon();

  492.             int buttonHeight = (closeIcon != null) ? closeIcon.getIconHeight(): 12;

  493. 	    if (buttonHeight == 0) {

  494. 		buttonHeight = 12;

  495. 	    }

  496.             //int buttonWidth = closeButton.getIcon().getIconWidth();

  497. 

  498.             Icon icon = frame.getFrameIcon();

  499.             int iconHeight = (icon != null) ? icon.getIconHeight() : buttonHeight;

  500. 

  501. 	    Insets insets = frame.getInsets();

  502. 

  503.             x = (leftToRight) ? insets.left : w - 16 - insets.right;

  504.             menuButton.setBounds(x, (h - iconHeight) / 2, 16, 14);

  505. 

  506.             x = (leftToRight) ? w - 16 - insets.right : insets.left;

  507. 

  508.             if (frame.isClosable()) {

  509.                 closeButton.setBounds(x, (h - buttonHeight) / 2, 16, 14);

  510.                 x += (leftToRight) ? -(16 + 2) : 16 + 2;

  511.             } 

  512. 

  513.             if (frame.isMaximizable()) {

  514.                 maximizeButton.setBounds(x, (h - buttonHeight) / 2, 16, 14);

  515.                 x += (leftToRight) ? -(16 + 2) : 16 + 2;

  516.             }

  517. 

  518.             if (frame.isIconifiable()) {

  519.                 minimizeButton.setBounds(x, (h - buttonHeight) / 2, 16, 14);

  520.             } 

  521.         }

  522.     } // end TitlePaneLayout

  523. 

  524.     /**

  525.      * This inner class is marked "public" due to a compiler bug.

  526.      * This class should be treated as a "protected" inner class.

  527.      * Instantiate it only within subclasses of <Foo>.

  528.      */  

  529.     class CloseAction extends AbstractAction {

  530.         public CloseAction() {

  531.             super(CLOSE_CMD);

  532.         }

  533. 

  534.         public void actionPerformed(ActionEvent e) {

  535.             if(frame.isClosable()) {

  536.                 frame.doDefaultCloseAction();

  537.             }

  538.         }      

  539.     } // end CloseAction

  540. 

  541.     /**

  542.      * This inner class is marked "public" due to a compiler bug.

  543.      * This class should be treated as a "protected" inner class.

  544.      * Instantiate it only within subclasses of <Foo>.

  545.      */

  546.     class MaximizeAction extends AbstractAction {

  547.         public MaximizeAction() {

  548. 	    super(MAXIMIZE_CMD);

  549.         }

  550. 

  551.         public void actionPerformed(ActionEvent e) {

  552.             if (frame.isMaximizable()) {

  553.                 if (!frame.isMaximum()) {

  554.                     try {

  555.                         frame.setMaximum(true);

  556.                     } catch (PropertyVetoException e5) { }

  557.                 } else {

  558.                     try { 

  559.                         frame.setMaximum(false); 

  560.                     } catch (PropertyVetoException e6) { }

  561.                 }

  562.             }

  563.         }

  564.     } // MaximizeAction

  565. 

  566.     /**

  567.      * This inner class is marked "public" due to a compiler bug.

  568.      * This class should be treated as a "protected" inner class.

  569.      * Instantiate it only within subclasses of <Foo>.

  570.      */

  571.     class IconifyAction extends AbstractAction {

  572.         public IconifyAction() {

  573. 	    super(ICONIFY_CMD);

  574.         }

  575. 

  576.         public void actionPerformed(ActionEvent e) {

  577.             if (frame.isIconifiable()) {

  578.                 if (!frame.isIcon()) {

  579.                     try {

  580.                         frame.setIcon(true);

  581.                     } catch (PropertyVetoException e1) { }

  582.                 } else{

  583.                     try {

  584.                         frame.setIcon(false);

  585.                     } catch (PropertyVetoException e1) { }

  586.                 }

  587.             }

  588. 	}

  589.     } // end IconifyAction

  590. 

  591.     /**

  592.      * This inner class is marked "public" due to a compiler bug.

  593.      * This class should be treated as a "protected" inner class.

  594.      * Instantiate it only within subclasses of <Foo>.

  595.      */

  596.     class RestoreAction extends AbstractAction {

  597.         public RestoreAction() {

  598. 	    super(RESTORE_CMD);

  599.         }

  600. 

  601.         public void actionPerformed(ActionEvent e) {

  602.             if (frame.isMaximizable() && frame.isMaximum()) {

  603.                 try {

  604.                     frame.setMaximum(false);

  605.                 } catch (PropertyVetoException e4) { }

  606.             } 

  607.             else if (frame.isIconifiable() && frame.isIcon()) {

  608.                 try {

  609.                     frame.setIcon(false);

  610.                 } catch (PropertyVetoException e4) { }

  611.             }

  612.        }      

  613.     } // end RestoreAction

  614. 

  615.     /**

  616.      * This inner class is marked "public" due to a compiler bug.

  617.      * This class should be treated as a "protected" inner class.

  618.      * Instantiate it only within subclasses of <Foo>.

  619.      */

  620.     class MoveAction extends AbstractAction {

  621.         public MoveAction() {

  622.             super(MOVE_CMD);

  623.         }

  624. 

  625.         public void actionPerformed(ActionEvent e) {

  626.             // This action is currently undefined

  627. 	}      

  628.     } // end MoveAction

  629. 

  630.     /*

  631.      * Handles showing and hiding the system menu.

  632.      */

  633.     private class ShowSystemMenuAction extends AbstractAction {

  634.         private boolean show;	// whether to show the menu

  635. 

  636.         public ShowSystemMenuAction(boolean show) {

  637.             this.show = show;

  638.         }

  639. 

  640.         public void actionPerformed(ActionEvent e) {

  641.             if (show) {

  642.                 // TODO: FIX THIS!!!

  643.             } else {

  644.                 systemPopupMenu.setVisible(false);

  645.             }

  646.         }      

  647.     }

  648. 

  649.     /**

  650.      * This inner class is marked "public" due to a compiler bug.

  651.      * This class should be treated as a "protected" inner class.

  652.      * Instantiate it only within subclasses of <Foo>.

  653.      */

  654.     class SizeAction extends AbstractAction {

  655.         public SizeAction() {

  656.             super(SIZE_CMD);

  657.         }

  658. 

  659.         public void actionPerformed(ActionEvent e) {

  660.             // This action is currently undefined

  661.         }      

  662.     } // end SizeAction

  663. 

  664. 

  665.     private JButton createNoFocusButton() {

  666.         JButton button = new JButton();

  667.         button.setFocusable(false);

  668.         button.setMargin(new Insets(0,0,0,0));

  669.         return button;

  670.     }

  671. }   // End Title Pane Class