1. /*

  2.  * @(#)BasicInternalFrameTitlePane.java	1.33 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package javax.swing.plaf.basic;

  12. 

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import javax.swing.*;

  16. import javax.swing.plaf.*;

  17. import javax.swing.border.*;

  18. import javax.swing.event.InternalFrameEvent;

  19. import java.util.EventListener;

  20. import java.beans.PropertyChangeListener;

  21. import java.beans.PropertyChangeEvent;

  22. import java.beans.VetoableChangeListener;

  23. import java.beans.PropertyVetoException;

  24. 

  25. /**

  26.  * The class that manages a basic title bar

  27.  * <p>

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

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

  30.  * future Swing releases.  The current serialization support is appropriate

  31.  * for short term storage or RMI between applications running the same

  32.  * version of Swing.  A future release of Swing will provide support for

  33.  * long term persistence.

  34.  *

  35.  * @version 1.33 02/02/00

  36.  * @author David Kloba

  37.  * @author Steve Wilson

  38.  */

  39. public class BasicInternalFrameTitlePane extends JComponent

  40. {

  41.     protected JMenuBar menuBar;

  42.     protected JButton iconButton;

  43.     protected JButton maxButton;

  44.     protected JButton closeButton;

  45. 

  46.     protected JMenu windowMenu;

  47.     protected JInternalFrame frame;

  48. 

  49.     protected Color selectedTitleColor;

  50.     protected Color selectedTextColor;

  51.     protected Color notSelectedTitleColor;

  52.     protected Color notSelectedTextColor;

  53. 

  54.     protected Icon maxIcon;

  55.     protected Icon minIcon;

  56.     protected Icon iconIcon;

  57.     protected Icon closeIcon;

  58. 

  59.     protected PropertyChangeListener propertyChangeListener;

  60. 

  61.     protected Action closeAction;

  62.     protected Action maximizeAction;

  63.     protected Action iconifyAction;

  64.     protected Action restoreAction;

  65.     protected Action moveAction;

  66.     protected Action sizeAction;

  67. 

  68.     protected static final String CLOSE_CMD = "Close";

  69.     protected static final String ICONIFY_CMD = "Minimize";

  70.     protected static final String RESTORE_CMD = "Restore";

  71.     protected static final String MAXIMIZE_CMD = "Maximize";

  72.     protected static final String MOVE_CMD = "Move";  

  73.     protected static final String SIZE_CMD = "Size";  

  74. 

  75.     public BasicInternalFrameTitlePane(JInternalFrame f) {

  76. 	frame = f;

  77. 	installTitlePane();

  78.     }

  79. 

  80.     protected void installTitlePane() {

  81. 	installDefaults();

  82.         

  83.         // Installing listeners must be done in addNotify because they are

  84.         // uninstalled in removeNotify. Internal frames (and their title panes)

  85.         // get removed and re-added to their parent every time they are

  86.         // selected,  although this is an implementation detail that may

  87.         // eventually change.  Installing the defaults should not happen in

  88.         // addNotify however because changes in the default LAF would be picked

  89.         // up every time a frame was selected.

  90. 

  91. 

  92. 	createActions();

  93. 	enableActions();

  94. 	createActionMap();

  95. 

  96. 	setLayout(createLayout());

  97. 

  98. 	assembleSystemMenu();

  99. 	createButtons();

  100. 	addSubComponents();

  101. 

  102.     }

  103. 

  104.     protected void addSubComponents() {

  105. 	add(menuBar);

  106. 	add(iconButton);

  107. 	add(maxButton);

  108. 	add(closeButton);

  109. 

  110.     }

  111. 

  112.     protected void createActions() {

  113. 	maximizeAction = new MaximizeAction();

  114. 	iconifyAction = new IconifyAction();

  115. 	closeAction = new CloseAction();

  116. 	restoreAction = new RestoreAction();

  117. 	moveAction = new MoveAction();

  118. 	sizeAction = new SizeAction();

  119.     }

  120. 

  121.     ActionMap createActionMap() {

  122. 	ActionMap map = new ActionMapUIResource();

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

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

  125. 	return map;

  126.     }

  127. 

  128.     protected void installListeners() {

  129.         if( propertyChangeListener == null ) {

  130.             propertyChangeListener = createPropertyChangeListener();

  131.         }

  132. 	frame.addPropertyChangeListener(propertyChangeListener);

  133.     }

  134. 

  135.     protected void uninstallListeners() {

  136. 	frame.removePropertyChangeListener(propertyChangeListener);

  137.     }

  138. 

  139.     protected void installDefaults() {

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

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

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

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

  144. 

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

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

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

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

  149.     }

  150. 

  151. 

  152.     protected void uninstallDefaults() {

  153.     }

  154. 

  155. 

  156.     public void addNotify() {

  157. 	super.addNotify();

  158. 	installListeners();

  159. 	addSystemMenuItems(windowMenu);

  160. 	enableActions();

  161.     }

  162. 

  163.     public void removeNotify() {

  164. 	super.removeNotify();

  165. 	if (windowMenu!=null) {

  166. 	    windowMenu.removeAll();

  167. 	}

  168. 	uninstallDefaults();

  169.         uninstallListeners();

  170.     }

  171. 

  172.     protected void createButtons() {

  173. 	iconButton = new NoFocusButton();

  174. 	iconButton.addActionListener(iconifyAction);

  175. 

  176. 	maxButton = new NoFocusButton();

  177. 	maxButton.addActionListener(maximizeAction);

  178. 

  179. 	closeButton = new NoFocusButton();  

  180. 	closeButton.addActionListener(closeAction);

  181. 

  182.         setButtonIcons();

  183.     }

  184. 

  185.     protected void setButtonIcons() {

  186. 	if(frame.isIcon()) {

  187. 	    iconButton.setIcon(minIcon);

  188. 	    maxButton.setIcon(maxIcon);

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

  190. 	    iconButton.setIcon(iconIcon);

  191. 	    maxButton.setIcon(minIcon);

  192.         } else {

  193. 	    iconButton.setIcon(iconIcon);

  194. 	    maxButton.setIcon(maxIcon);

  195.         }

  196. 

  197. 	closeButton.setIcon(closeIcon);

  198.     }

  199. 

  200. 

  201.     protected void assembleSystemMenu() {

  202.         menuBar = createSystemMenuBar();

  203. 	windowMenu = createSystemMenu();	    

  204. 	menuBar.add(windowMenu);

  205. 	// moved to addNotify - addSystemMenuItems(windowMenu);

  206. 	enableActions();

  207.     }

  208. 

  209.     protected void addSystemMenuItems(JMenu systemMenu) {

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

  211. 	mi.setMnemonic('R');

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

  213. 	mi.setMnemonic('M');

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

  215. 	mi.setMnemonic('S');

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

  217. 	mi.setMnemonic('n');

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

  219. 	mi.setMnemonic('x');

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

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

  222. 	mi.setMnemonic('C');

  223.     }

  224. 

  225.     protected JMenu createSystemMenu() {

  226. 	return new JMenu("    ");

  227.     }

  228. 

  229.     protected JMenuBar createSystemMenuBar() {

  230. 	menuBar = new SystemMenuBar();

  231. 	menuBar.setBorderPainted(false);

  232. 	return menuBar;

  233.     }

  234.       

  235.     protected void showSystemMenu(){

  236. 	//      windowMenu.setPopupMenuVisible(true);

  237.       //      windowMenu.setVisible(true);

  238.       windowMenu.doClick();

  239.     }

  240. 

  241.     public void paintComponent(Graphics g)  {

  242. 	boolean isSelected = frame.isSelected();

  243. 

  244. 	if(isSelected)

  245. 	    g.setColor(selectedTitleColor);

  246. 	else

  247. 	    g.setColor(notSelectedTitleColor);

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

  249. 

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

  251. 	    Font f = g.getFont();

  252. 	    g.setFont(UIManager.getFont("InternalFrame.titleFont"));

  253. 	    if(isSelected)

  254. 		g.setColor(selectedTextColor);

  255. 	    else

  256. 		g.setColor(notSelectedTextColor);

  257. 

  258.             // Center text vertically.

  259. 	    FontMetrics fm = g.getFontMetrics();

  260.             int fmHeight = fm.getHeight() - fm.getLeading();

  261.             int baseline = (18 - fmHeight) / 2 + 

  262.                 fm.getAscent() + fm.getLeading();

  263. 

  264.             int titleX;

  265.             String title = frame.getTitle();

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

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

  268.             } else {

  269.                 titleX = menuBar.getX() - 2

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

  271.             }

  272.             

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

  274. 	    g.setFont(f);

  275. 	}

  276.     }

  277. 

  278.     /**

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

  280.      * be treated like a regular Frame.

  281.      */

  282.     protected void postClosingEvent(JInternalFrame frame) {

  283.         InternalFrameEvent e = new InternalFrameEvent(

  284.             frame, InternalFrameEvent.INTERNAL_FRAME_CLOSING);

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

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

  287.             try {

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

  289.                 return;

  290.             } catch (SecurityException se) {

  291.                 // Use dispatchEvent instead.

  292.             }

  293.         }

  294.         frame.dispatchEvent(e);

  295.     }

  296. 

  297. 

  298.     protected void enableActions() {

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

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

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

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

  303. 	sizeAction.setEnabled(false);

  304. 	moveAction.setEnabled(false);

  305.     }

  306. 

  307. 

  308.     protected PropertyChangeListener createPropertyChangeListener() {

  309.         return new PropertyChangeHandler();

  310.     }

  311. 

  312.     protected LayoutManager createLayout() {

  313.         return new TitlePaneLayout();

  314.     }

  315. 

  316. 

  317.     /**

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

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

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

  321.      */

  322.     public class PropertyChangeHandler implements PropertyChangeListener {

  323.         public void propertyChange(PropertyChangeEvent evt) {

  324. 

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

  326. 

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

  328. 	        repaint();

  329. 		return;

  330. 	    } 

  331. 

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

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

  334. 		setButtonIcons();

  335. 		enableActions();

  336. 		return;

  337. 	    }

  338. 

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

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

  341.                     add(closeButton);

  342.                 else

  343.                     remove(closeButton);

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

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

  346.                     add(maxButton);

  347.                 else

  348.                     remove(maxButton);

  349.             } else if( prop.equals("iconifiable") ) {

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

  351.                     add(iconButton);

  352.                 else

  353.                     remove(iconButton);

  354.             }

  355. 	    enableActions();

  356.             

  357.             revalidate();

  358.             repaint();

  359. 	}

  360. 

  361.     }  // end PropertyHandler class

  362. 

  363.     /**

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

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

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

  367.      */

  368.     public class TitlePaneLayout implements LayoutManager {

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

  370.         public void removeLayoutComponent(Component c) {}    

  371.         public Dimension preferredLayoutSize(Container c)  {

  372. 	    return new Dimension(100, 18);

  373. 	}

  374.     

  375.         public Dimension minimumLayoutSize(Container c) {

  376. 	    return preferredLayoutSize(c);

  377. 	}

  378.     

  379.         public void layoutContainer(Container c) {

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

  381.             

  382. 	    int w = getWidth();

  383.             int x;

  384. 

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

  386.             menuBar.setBounds(x, 1, 16, 16);

  387. 

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

  389.             

  390. 	    if(frame.isClosable()) {

  391.                 closeButton.setBounds(x, 2, 16, 14);

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

  393. 	    } 

  394.             

  395. 	    if(frame.isMaximizable()) {

  396. 	        maxButton.setBounds(x, 2, 16, 14);

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

  398. 	    }

  399.         

  400. 	    if(frame.isIconifiable()) {

  401. 	        iconButton.setBounds(x, 2, 16, 14);

  402. 	    } 

  403. 	}

  404.     } // end TitlePaneLayout

  405. 

  406.     /**

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

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

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

  410.      */  

  411.     public class CloseAction extends AbstractAction {

  412.         public CloseAction() {

  413. 	    super(CLOSE_CMD);

  414.         }

  415. 

  416.         public void actionPerformed(ActionEvent e) {

  417. 	    if(frame.isClosable()) {

  418. 		frame.doDefaultCloseAction();

  419. 	    }

  420. 	}      

  421.     } // end CloseAction

  422. 

  423.     /**

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

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

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

  427.      */

  428.     public class MaximizeAction extends AbstractAction {

  429.         public MaximizeAction() {

  430. 	    super(MAXIMIZE_CMD);

  431.         }

  432. 

  433.         public void actionPerformed(ActionEvent e) {

  434. 	    if(frame.isMaximizable()) {

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

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

  437. 		} else {

  438. 		    try { 

  439. 		        frame.setMaximum(false); 

  440. 		    } catch (PropertyVetoException e6) { }

  441. 		}

  442. 	    }

  443. 	}

  444.     } // MaximizeAction

  445. 

  446.     /**

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

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

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

  450.      */

  451.     public class IconifyAction extends AbstractAction {

  452.         public IconifyAction() {

  453. 	    super(ICONIFY_CMD);

  454.         }

  455. 

  456.         public void actionPerformed(ActionEvent e) {

  457. 	    if(frame.isIconifiable()) {

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

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

  460. 	      } else{

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

  462. 	      }

  463. 	    }

  464. 	}

  465.     } // end IconifyAction

  466. 

  467.     /**

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

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

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

  471.      */

  472.     public class RestoreAction extends AbstractAction {

  473.         public RestoreAction() {

  474. 	    super(RESTORE_CMD);

  475.         }

  476. 

  477.         public void actionPerformed(ActionEvent e) {

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

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

  480. 	    } 

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

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

  483. 	    }

  484. 	}      

  485.     } // end RestoreAction

  486. 

  487.     /**

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

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

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

  491.      */

  492.     public class MoveAction extends AbstractAction {

  493.         public MoveAction() {

  494. 	    super(MOVE_CMD);

  495.         }

  496. 

  497.         public void actionPerformed(ActionEvent e) {

  498. 	    // This action is currently undefined

  499. 	}      

  500.     } // end MoveAction

  501. 

  502.     /*

  503.      * Handles showing and hiding the system menu.

  504.      */

  505.     private class ShowSystemMenuAction extends AbstractAction {

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

  507. 	

  508. 	public ShowSystemMenuAction(boolean show) {

  509. 	    this.show = show;

  510. 	}

  511. 

  512.         public void actionPerformed(ActionEvent e) {

  513. 	    if (show) {

  514. 		windowMenu.doClick();

  515. 	    } else {

  516. 		windowMenu.setVisible(false);

  517. 	    }

  518. 	}      

  519.     }

  520. 

  521.     /**

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

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

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

  525.      */

  526.     public class SizeAction extends AbstractAction {

  527.         public SizeAction() {

  528. 	    super(SIZE_CMD);

  529.         }

  530. 

  531.         public void actionPerformed(ActionEvent e) {

  532. 	    // This action is currently undefined

  533. 	}      

  534.     } // end SizeAction

  535. 

  536. 

  537.     /**

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

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

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

  541.      */

  542.     public class SystemMenuBar extends JMenuBar {

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

  544. 	public void requestFocus() {}

  545. 	public void paint(Graphics g) {

  546. 	    Icon icon = frame.getFrameIcon();

  547. 	    if (icon == null) {

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

  549. 	    }

  550. 	    if (icon != null) {

  551. 	        // Resize to 16x16 if necessary.

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

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

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

  555. 		}

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

  557. 	    }

  558. 	}

  559. 

  560. 	public boolean isOpaque() { 

  561. 	    return true; 

  562. 	}

  563.     } // end SystemMenuBar

  564. 

  565. 

  566.     private class NoFocusButton extends JButton {

  567.       public NoFocusButton() { setFocusPainted(false); }

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

  569. 	public void requestFocus() {};

  570.         public boolean isOpaque() { return true; }

  571.     };  // end NoFocusButton

  572. 

  573. }   // End Title Pane Class

  574.