1. /*

  2.  * @(#)BasicInternalFrameTitlePane.java	1.53 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 javax.swing.plaf.basic;

  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.41 01/18/01

  35.  * @author David Kloba

  36.  * @author Steve Wilson

  37.  */

  38. public class BasicInternalFrameTitlePane extends JComponent

  39. {

  40.     protected JMenuBar menuBar;

  41.     protected JButton iconButton;

  42.     protected JButton maxButton;

  43.     protected JButton closeButton;

  44. 

  45.     protected JMenu windowMenu;

  46.     protected JInternalFrame frame;

  47. 

  48.     protected Color selectedTitleColor;

  49.     protected Color selectedTextColor;

  50.     protected Color notSelectedTitleColor;

  51.     protected Color notSelectedTextColor;

  52. 

  53.     protected Icon maxIcon;

  54.     protected Icon minIcon;

  55.     protected Icon iconIcon;

  56.     protected Icon closeIcon;

  57. 

  58.     protected PropertyChangeListener propertyChangeListener;

  59. 

  60.     protected Action closeAction;

  61.     protected Action maximizeAction;

  62.     protected Action iconifyAction;

  63.     protected Action restoreAction;

  64.     protected Action moveAction;

  65.     protected Action sizeAction;

  66. 

  67.     protected static final String CLOSE_CMD =

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

  69.     protected static final String ICONIFY_CMD =

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

  71.     protected static final String RESTORE_CMD =

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

  73.     protected static final String MAXIMIZE_CMD =

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

  75.     protected static final String MOVE_CMD =

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

  77.     protected static final String SIZE_CMD =

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

  79. 

  80.     private String closeButtonToolTip;

  81.     private String iconButtonToolTip;

  82.     private String restoreButtonToolTip;

  83.     private String maxButtonToolTip;

  84. 

  85.     public BasicInternalFrameTitlePane(JInternalFrame f) {

  86. 	frame = f;

  87. 	installTitlePane();

  88.     }

  89. 

  90.     protected void installTitlePane() {

  91. 	installDefaults();

  92.         installListeners();

  93.         

  94. 	createActions();

  95. 	enableActions();

  96. 	createActionMap();

  97. 

  98. 	setLayout(createLayout());

  99. 

  100. 	assembleSystemMenu();

  101. 	createButtons();

  102. 	addSubComponents();

  103. 

  104.     }

  105. 

  106.     protected void addSubComponents() {

  107. 	add(menuBar);

  108. 	add(iconButton);

  109. 	add(maxButton);

  110. 	add(closeButton);

  111.     }

  112. 

  113.     protected void createActions() {

  114. 	maximizeAction = new MaximizeAction();

  115. 	iconifyAction = new IconifyAction();

  116. 	closeAction = new CloseAction();

  117. 	restoreAction = new RestoreAction();

  118. 	moveAction = new MoveAction();

  119. 	sizeAction = new SizeAction();

  120.     }

  121. 

  122.     ActionMap createActionMap() {

  123. 	ActionMap map = new ActionMapUIResource();

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

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

  126. 	return map;

  127.     }

  128. 

  129.     protected void installListeners() {

  130.         if( propertyChangeListener == null ) {

  131.             propertyChangeListener = createPropertyChangeListener();

  132.         }

  133. 	frame.addPropertyChangeListener(propertyChangeListener);

  134.     }

  135. 

  136.     protected void uninstallListeners() {

  137. 	frame.removePropertyChangeListener(propertyChangeListener);

  138.     }

  139. 

  140.     protected void installDefaults() {

  141.         maxIcon = UIManager.getIcon("InternalFrame.maximizeIcon");

  142. 	minIcon = UIManager.getIcon("InternalFrame.minimizeIcon");

  143. 	iconIcon = UIManager.getIcon("InternalFrame.iconifyIcon");

  144. 	closeIcon = UIManager.getIcon("InternalFrame.closeIcon");

  145. 

  146. 	selectedTitleColor = UIManager.getColor("InternalFrame.activeTitleBackground");

  147. 	selectedTextColor = UIManager.getColor("InternalFrame.activeTitleForeground");

  148. 	notSelectedTitleColor = UIManager.getColor("InternalFrame.inactiveTitleBackground");

  149. 	notSelectedTextColor = UIManager.getColor("InternalFrame.inactiveTitleForeground");

  150.         setFont(UIManager.getFont("InternalFrame.titleFont"));

  151.         closeButtonToolTip =

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

  153.         iconButtonToolTip =

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

  155.         restoreButtonToolTip =

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

  157.         maxButtonToolTip =

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

  159.     }

  160. 

  161. 

  162.     protected void uninstallDefaults() {

  163.     }

  164. 

  165.     protected void createButtons() {

  166. 	iconButton = new NoFocusButton();

  167. 	iconButton.addActionListener(iconifyAction);

  168.         if (iconButtonToolTip != null && iconButtonToolTip.length() != 0) {

  169.             iconButton.setToolTipText(iconButtonToolTip);

  170.         }

  171. 

  172. 	maxButton = new NoFocusButton();

  173. 	maxButton.addActionListener(maximizeAction);

  174. 

  175. 	closeButton = new NoFocusButton();  

  176. 	closeButton.addActionListener(closeAction);

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

  178.             closeButton.setToolTipText(closeButtonToolTip);

  179.         }

  180. 

  181.         setButtonIcons();

  182.     }

  183. 

  184.     protected void setButtonIcons() {

  185.         if(frame.isIcon()) {

  186.             iconButton.setIcon(minIcon);

  187.             if (restoreButtonToolTip != null &&

  188.                     restoreButtonToolTip.length() != 0) {

  189.                 iconButton.setToolTipText(restoreButtonToolTip);

  190.             }

  191.             maxButton.setIcon(maxIcon);

  192.             if (maxButtonToolTip != null && maxButtonToolTip.length() != 0) {

  193.                 maxButton.setToolTipText(maxButtonToolTip);

  194.             }

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

  196. 	    iconButton.setIcon(iconIcon);

  197. 	    maxButton.setIcon(minIcon);

  198.             if (restoreButtonToolTip != null &&

  199.                     restoreButtonToolTip.length() != 0) {

  200.                 maxButton.setToolTipText(restoreButtonToolTip);

  201.             }

  202.         } else {

  203. 	    iconButton.setIcon(iconIcon);

  204.             if (iconButtonToolTip != null && iconButtonToolTip.length() != 0) {

  205.                 iconButton.setToolTipText(iconButtonToolTip);

  206.             }

  207. 	    maxButton.setIcon(maxIcon);

  208.             if (maxButtonToolTip != null && maxButtonToolTip.length() != 0) {

  209.                 maxButton.setToolTipText(maxButtonToolTip);

  210.             }

  211.         }

  212. 

  213. 	closeButton.setIcon(closeIcon);

  214.     }

  215. 

  216.     protected void assembleSystemMenu() {

  217.         menuBar = createSystemMenuBar();

  218. 	windowMenu = createSystemMenu();	    

  219. 	menuBar.add(windowMenu);

  220. 	addSystemMenuItems(windowMenu);

  221. 	enableActions();

  222.     }

  223. 

  224.     protected void addSystemMenuItems(JMenu systemMenu) {

  225.         JMenuItem mi = (JMenuItem)systemMenu.add(restoreAction);

  226. 	mi.setMnemonic('R');

  227. 	mi = (JMenuItem)systemMenu.add(moveAction);

  228. 	mi.setMnemonic('M');

  229. 	mi = (JMenuItem)systemMenu.add(sizeAction);

  230. 	mi.setMnemonic('S');

  231. 	mi = (JMenuItem)systemMenu.add(iconifyAction);

  232. 	mi.setMnemonic('n');

  233. 	mi = (JMenuItem)systemMenu.add(maximizeAction);

  234. 	mi.setMnemonic('x');

  235. 	systemMenu.add(new JSeparator());

  236. 	mi = (JMenuItem)systemMenu.add(closeAction);

  237. 	mi.setMnemonic('C');

  238.     }

  239. 

  240.     protected JMenu createSystemMenu() {

  241. 	return new JMenu("    ");

  242.     }

  243. 

  244.     protected JMenuBar createSystemMenuBar() {

  245. 	menuBar = new SystemMenuBar();

  246. 	menuBar.setBorderPainted(false);

  247. 	return menuBar;

  248.     }

  249.       

  250.     protected void showSystemMenu(){

  251. 	//      windowMenu.setPopupMenuVisible(true);

  252.       //      windowMenu.setVisible(true);

  253.       windowMenu.doClick();

  254.     }

  255. 

  256.     public void paintComponent(Graphics g)  {

  257. 	paintTitleBackground(g);

  258. 

  259. 	if(frame.getTitle() != null) {

  260. 	    boolean isSelected = frame.isSelected();

  261. 	    Font f = g.getFont();

  262. 	    g.setFont(getFont());

  263. 	    if(isSelected)

  264. 		g.setColor(selectedTextColor);

  265. 	    else

  266. 		g.setColor(notSelectedTextColor);

  267. 

  268.             // Center text vertically.

  269. 	    FontMetrics fm = g.getFontMetrics();

  270.             int baseline = (getHeight() + fm.getAscent() - fm.getLeading() -

  271.                     fm.getDescent()) / 2;

  272. 

  273.             int titleX;

  274.             Rectangle r = new Rectangle(0, 0, 0, 0);

  275.             if (frame.isIconifiable())  r = iconButton.getBounds();

  276.             else if (frame.isMaximizable())  r = maxButton.getBounds();

  277.             else if (frame.isClosable())  r = closeButton.getBounds();

  278. 	    int titleW;

  279. 	

  280.             String title = frame.getTitle();

  281.             if( BasicGraphicsUtils.isLeftToRight(frame) ) {

  282.               if (r.x == 0)  r.x = frame.getWidth()-frame.getInsets().right;

  283.               titleX = menuBar.getX() + menuBar.getWidth() + 2;

  284.               titleW = r.x - titleX - 3;

  285.               title = getTitle(frame.getTitle(), fm, titleW);

  286.             } else {

  287.                 titleX = menuBar.getX() - 2

  288.                          - SwingUtilities.computeStringWidth(fm,title);

  289.             }

  290.             

  291. 	    g.drawString(title, titleX, baseline);

  292. 	    g.setFont(f);

  293. 	}

  294.     }

  295. 

  296.    /**

  297.     * Invoked from paintComponent.

  298.     * Paints the background of the titlepane.  All text and icons will

  299.     * then be rendered on top of this background.

  300.     * @param g the graphics to use to render the background

  301.     * @since 1.4

  302.     */

  303.     protected void paintTitleBackground(Graphics g) {

  304. 	boolean isSelected = frame.isSelected();

  305. 

  306. 	if(isSelected)

  307. 	    g.setColor(selectedTitleColor);

  308. 	else

  309. 	    g.setColor(notSelectedTitleColor);

  310. 	g.fillRect(0, 0, getWidth(), getHeight());

  311.     }

  312. 

  313.     protected String getTitle(String text, FontMetrics fm, int availTextWidth) {

  314.         if ( (text == null) || (text.equals("")) )  return "";

  315.         int textWidth = SwingUtilities.computeStringWidth(fm, text);

  316.         String clipString = "...";

  317.         if (textWidth > availTextWidth) {

  318.             int totalWidth = SwingUtilities.computeStringWidth(fm, clipString);

  319.             int nChars;

  320.             for(nChars = 0; nChars < text.length(); nChars++) {

  321.                 totalWidth += fm.charWidth(text.charAt(nChars));

  322.                 if (totalWidth > availTextWidth) {

  323.                     break;

  324.                 }

  325.             }

  326.             text = text.substring(0, nChars) + clipString;

  327.         }

  328.         return text;

  329.       }

  330. 

  331.     /**

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

  333.      * be treated like a regular Frame.

  334.      */

  335.     protected void postClosingEvent(JInternalFrame frame) {

  336.         InternalFrameEvent e = new InternalFrameEvent(

  337.             frame, InternalFrameEvent.INTERNAL_FRAME_CLOSING);

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

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

  340.             try {

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

  342.                 return;

  343.             } catch (SecurityException se) {

  344.                 // Use dispatchEvent instead.

  345.             }

  346.         }

  347.         frame.dispatchEvent(e);

  348.     }

  349. 

  350. 

  351.     protected void enableActions() {

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

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

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

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

  356. 	sizeAction.setEnabled(false);

  357. 	moveAction.setEnabled(false);

  358.     }

  359. 

  360. 

  361.     protected PropertyChangeListener createPropertyChangeListener() {

  362.         return new PropertyChangeHandler();

  363.     }

  364. 

  365.     protected LayoutManager createLayout() {

  366.         return new TitlePaneLayout();

  367.     }

  368. 

  369. 

  370.     /**

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

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

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

  374.      */

  375.     public class PropertyChangeHandler implements PropertyChangeListener {

  376.         public void propertyChange(PropertyChangeEvent evt) {

  377. 

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

  379. 

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

  381. 	        repaint();

  382. 		return;

  383. 	    } 

  384. 

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

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

  387. 		setButtonIcons();

  388. 		enableActions();

  389. 		return;

  390. 	    }

  391. 

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

  393.                 if( (Boolean)evt.getNewValue() == Boolean.TRUE )

  394.                     add(closeButton);

  395.                 else

  396.                     remove(closeButton);

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

  398.                 if( (Boolean)evt.getNewValue() == Boolean.TRUE )

  399.                     add(maxButton);

  400.                 else

  401.                     remove(maxButton);

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

  403.                 if( (Boolean)evt.getNewValue() == Boolean.TRUE )

  404.                     add(iconButton);

  405.                 else

  406.                     remove(iconButton);

  407.             }

  408. 	    enableActions();

  409.             

  410.             revalidate();

  411.             repaint();

  412. 	}

  413. 

  414.     }  // end PropertyHandler class

  415. 

  416.     /**

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

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

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

  420.      */

  421.     public class TitlePaneLayout implements LayoutManager {

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

  423.         public void removeLayoutComponent(Component c) {}    

  424.         public Dimension preferredLayoutSize(Container c)  {

  425. 	    return minimumLayoutSize(c);

  426. 	}

  427.     

  428.         public Dimension minimumLayoutSize(Container c) {

  429.             // Calculate width.

  430.             int width = 22;

  431.  

  432.             if (frame.isClosable()) {

  433.                 width += 19;

  434.             }

  435.             if (frame.isMaximizable()) {

  436.                 width += 19;

  437.             }

  438.             if (frame.isIconifiable()) {

  439.                 width += 19;

  440.             }

  441. 

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

  443.             String frameTitle = frame.getTitle();

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

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

  446. 

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

  448.             if (title_length > 3) {

  449.                 int subtitle_w =

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

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

  452.             } else {

  453.                 width += title_w;

  454.             }

  455. 

  456.             // Calculate height.

  457.             Icon icon = frame.getFrameIcon();

  458.             int fontHeight = fm.getHeight();

  459.             fontHeight += 2;

  460.             int iconHeight = 0;

  461.             if (icon != null) {

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

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

  464.             }

  465.             iconHeight += 2;

  466.       

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

  468. 

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

  470. 

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

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

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

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

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

  476.             }

  477.             return dim;

  478. 	}

  479.     

  480.         public void layoutContainer(Container c) {

  481.             boolean leftToRight = BasicGraphicsUtils.isLeftToRight(frame);

  482.             

  483. 	    int w = getWidth();

  484.             int h = getHeight();

  485.             int x;

  486. 

  487.             int buttonHeight = closeButton.getIcon().getIconHeight();

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

  489. 

  490.             Icon icon = frame.getFrameIcon();

  491.             int iconHeight = 0;

  492.             if (icon != null) {

  493.                 iconHeight = icon.getIconHeight();

  494.             }

  495.             x = (leftToRight) ? 2 : w - 16 - 2;

  496.             menuBar.setBounds(x, (h - iconHeight) / 2, 16, 16);

  497. 

  498.             x = (leftToRight) ? w - 16 - 2 : 2;

  499.             

  500. 	    if (frame.isClosable()) {

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

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

  503. 	    } 

  504.             

  505. 	    if(frame.isMaximizable()) {

  506. 	        maxButton.setBounds(x, (h - buttonHeight) / 2, 16, 14);

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

  508. 	    }

  509.         

  510. 	    if(frame.isIconifiable()) {

  511. 	        iconButton.setBounds(x, (h - buttonHeight) / 2, 16, 14);

  512. 	    } 

  513. 	}

  514.     } // end TitlePaneLayout

  515. 

  516.     /**

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

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

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

  520.      */  

  521.     public class CloseAction extends AbstractAction {

  522.         public CloseAction() {

  523. 	    super(CLOSE_CMD);

  524.         }

  525. 

  526.         public void actionPerformed(ActionEvent e) {

  527. 	    if(frame.isClosable()) {

  528. 		frame.doDefaultCloseAction();

  529. 	    }

  530. 	}      

  531.     } // end CloseAction

  532. 

  533.     /**

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

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

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

  537.      */

  538.     public class MaximizeAction extends AbstractAction {

  539.         public MaximizeAction() {

  540. 	    super(MAXIMIZE_CMD);

  541.         }

  542. 

  543.         public void actionPerformed(ActionEvent e) {

  544. 	    if(frame.isMaximizable()) {

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

  546. 		    try { frame.setMaximum(true); } catch (PropertyVetoException e5) { }

  547. 		} else {

  548. 		    try { 

  549. 		        frame.setMaximum(false); 

  550. 		    } catch (PropertyVetoException e6) { }

  551. 		}

  552. 	    }

  553. 	}

  554.     } // MaximizeAction

  555. 

  556.     /**

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

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

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

  560.      */

  561.     public class IconifyAction extends AbstractAction {

  562.         public IconifyAction() {

  563. 	    super(ICONIFY_CMD);

  564.         }

  565. 

  566.         public void actionPerformed(ActionEvent e) {

  567. 	    if(frame.isIconifiable()) {

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

  569. 		try { frame.setIcon(true); } catch (PropertyVetoException e1) { }

  570. 	      } else{

  571. 		try { frame.setIcon(false); } catch (PropertyVetoException e1) { }

  572. 	      }

  573. 	    }

  574. 	}

  575.     } // end IconifyAction

  576. 

  577.     /**

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

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

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

  581.      */

  582.     public class RestoreAction extends AbstractAction {

  583.         public RestoreAction() {

  584. 	    super(RESTORE_CMD);

  585.         }

  586. 

  587.         public void actionPerformed(ActionEvent e) {

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

  589. 	        try { frame.setMaximum(false); } catch (PropertyVetoException e4) { }

  590. 	    } 

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

  592. 	      try { frame.setIcon(false); } catch (PropertyVetoException e4) { }

  593. 	    }

  594. 	}      

  595.     } // end RestoreAction

  596. 

  597.     /**

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

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

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

  601.      */

  602.     public class MoveAction extends AbstractAction {

  603.         public MoveAction() {

  604. 	    super(MOVE_CMD);

  605.         }

  606. 

  607.         public void actionPerformed(ActionEvent e) {

  608. 	    // This action is currently undefined

  609. 	}      

  610.     } // end MoveAction

  611. 

  612.     /*

  613.      * Handles showing and hiding the system menu.

  614.      */

  615.     private class ShowSystemMenuAction extends AbstractAction {

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

  617. 	

  618. 	public ShowSystemMenuAction(boolean show) {

  619. 	    this.show = show;

  620. 	}

  621. 

  622.         public void actionPerformed(ActionEvent e) {

  623. 	    if (show) {

  624. 		windowMenu.doClick();

  625. 	    } else {

  626. 		windowMenu.setVisible(false);

  627. 	    }

  628. 	}      

  629.     }

  630. 

  631.     /**

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

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

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

  635.      */

  636.     public class SizeAction extends AbstractAction {

  637.         public SizeAction() {

  638. 	    super(SIZE_CMD);

  639.         }

  640. 

  641.         public void actionPerformed(ActionEvent e) {

  642. 	    // This action is currently undefined

  643. 	}      

  644.     } // end SizeAction

  645. 

  646. 

  647.     /**

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

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

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

  651.      */

  652.     public class SystemMenuBar extends JMenuBar {

  653. 	public boolean isFocusTraversable() { return false; }

  654. 	public void requestFocus() {}

  655. 	public void paint(Graphics g) {

  656. 	    Icon icon = frame.getFrameIcon();

  657. 	    if (icon == null) {

  658. 	      icon = UIManager.getIcon("InternalFrame.icon");

  659. 	    }

  660. 	    if (icon != null) {

  661. 	        // Resize to 16x16 if necessary.

  662. 	        if (icon instanceof ImageIcon && (icon.getIconWidth() > 16 || icon.getIconHeight() > 16)) {

  663. 		    Image img = ((ImageIcon)icon).getImage();

  664. 		    ((ImageIcon)icon).setImage(img.getScaledInstance(16, 16, Image.SCALE_SMOOTH));

  665. 		}

  666. 		icon.paintIcon(this, g, 0, 0);

  667. 	    }

  668. 	}

  669. 

  670. 	public boolean isOpaque() { 

  671. 	    return true; 

  672. 	}

  673.     } // end SystemMenuBar

  674. 

  675. 

  676.     private class NoFocusButton extends JButton {

  677.         public NoFocusButton() {

  678.             setFocusPainted(false);

  679.             setMargin(new Insets(0,0,0,0));

  680. 	    setOpaque(true);

  681.         }

  682. 	public boolean isFocusTraversable() { return false; }

  683. 	public void requestFocus() {};

  684.     };  // end NoFocusButton

  685. 

  686. }   // End Title Pane Class

  687.