1. /*

  2.  * @(#)MetalInternalFrameTitlePane.java	1.39 01/02/09

  3.  *

  4.  * Copyright 1998-2001 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.metal;

  12. 

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import javax.swing.*;

  16. import javax.swing.border.*;

  17. import javax.swing.event.InternalFrameEvent;

  18. import java.util.EventListener;

  19. import java.beans.PropertyChangeListener;

  20. import java.beans.PropertyChangeEvent;

  21. import javax.swing.plaf.basic.BasicInternalFrameTitlePane;

  22. 

  23. 

  24. /**

  25.  * Class that manages a JLF title bar

  26.  * @version 1.39 02/09/01

  27.  * @author Steve Wilson

  28.  * @author Brian Beck

  29.  * @since 1.3

  30.  */

  31. 

  32. public class MetalInternalFrameTitlePane  extends BasicInternalFrameTitlePane {

  33. 

  34.     protected boolean isPalette = false;  	

  35.     protected Icon paletteCloseIcon;

  36.     protected int paletteTitleHeight;

  37. 

  38.     private static final Border handyEmptyBorder = new EmptyBorder(0,0,0,0);

  39. 

  40.     int buttonsWidth = 0;	

  41.     

  42.     MetalBumps activeBumps 

  43.         = new MetalBumps( 0, 0,

  44.                           MetalLookAndFeel.getPrimaryControlHighlight(),

  45.                           MetalLookAndFeel.getPrimaryControlDarkShadow(),

  46.                           MetalLookAndFeel.getPrimaryControl() );

  47.     MetalBumps inactiveBumps 

  48.         = new MetalBumps( 0, 0,

  49.                           MetalLookAndFeel.getControlHighlight(),

  50.                           MetalLookAndFeel.getControlDarkShadow(),

  51.                           MetalLookAndFeel.getControl() );

  52.     MetalBumps paletteBumps;

  53. 

  54. 					    

  55.     public MetalInternalFrameTitlePane(JInternalFrame f) {

  56.         super( f );

  57.     }

  58. 

  59.     protected void installDefaults() {

  60.         super.installDefaults();

  61.         setFont( UIManager.getFont("InternalFrame.font") );

  62.         paletteTitleHeight

  63.             = UIManager.getInt("InternalFrame.paletteTitleHeight");

  64.         paletteCloseIcon = UIManager.getIcon("InternalFrame.paletteCloseIcon");

  65.     }

  66.     

  67.     protected void createButtons() {

  68.         super.createButtons();

  69. 

  70.         Boolean paintActive = frame.isSelected() ? Boolean.TRUE:Boolean.FALSE;

  71.         iconButton.putClientProperty("paintActive", paintActive);

  72.         iconButton.setBorder(handyEmptyBorder);

  73.         iconButton.getAccessibleContext().setAccessibleName(

  74.             UIManager.getString(

  75.                 "InternalFrameTitlePane.iconifyButtonAccessibleName"));

  76.     

  77.         maxButton.putClientProperty("paintActive", paintActive);

  78.         maxButton.setBorder(handyEmptyBorder);

  79.         maxButton.getAccessibleContext().setAccessibleName(

  80.             UIManager.getString(

  81.                 "InternalFrameTitlePane.maximizeButtonAccessibleName"));

  82.         

  83.         closeButton.putClientProperty("paintActive", paintActive);

  84.         closeButton.setBorder(handyEmptyBorder);

  85.         closeButton.getAccessibleContext().setAccessibleName(

  86.             UIManager.getString(

  87.                 "InternalFrameTitlePane.closeButtonAccessibleName"));

  88. 

  89.         // The palette close icon isn't opaque while the regular close icon is.

  90.         // This makes sure palette close buttons have the right background.

  91.         closeButton.setBackground(MetalLookAndFeel.getPrimaryControlShadow());

  92.     }

  93. 

  94.     /**

  95.      * Override the parent's method to do nothing. Metal frames do not 

  96.      * have system menus.

  97.      */

  98.     protected void assembleSystemMenu() {}

  99. 

  100.     /**

  101.      * Override the parent's method to do nothing. Metal frames do not 

  102.      * have system menus.

  103.      */

  104.     protected void addSystemMenuItems(JMenu systemMenu) {}

  105. 

  106.     /**

  107.      * Override the parent's method avoid creating a menu bar. Metal frames

  108.      * do not have system menus.

  109.      */

  110.     protected void addSubComponents() {

  111.         add(iconButton);

  112.         add(maxButton);

  113.         add(closeButton);

  114.     }

  115. 

  116.     protected PropertyChangeListener createPropertyChangeListener() {

  117.         return new MetalPropertyChangeHandler();

  118.     }

  119.     

  120.     protected LayoutManager createLayout() {

  121.         return new MetalTitlePaneLayout();

  122.     }

  123. 

  124.     /*

  125.      * These accessors allow our inner classes to get at member variables

  126.      * they couldn't otherwise access.  This work's around a javac bug.

  127.      */

  128.     private JInternalFrame getFrame() { return frame; }

  129.     private JButton getIconButton() { return iconButton; }

  130.     private JButton getCloseButton() { return closeButton; }

  131.     private JButton getMaxButton() { return maxButton; }

  132. 

  133.     class MetalPropertyChangeHandler

  134.         extends BasicInternalFrameTitlePane.PropertyChangeHandler

  135.     {

  136.         public void propertyChange(PropertyChangeEvent evt) {

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

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

  139.                 Boolean b = (Boolean)evt.getNewValue();

  140.                 getIconButton().putClientProperty("paintActive", b);

  141.                 getCloseButton().putClientProperty("paintActive", b);

  142.                 getMaxButton().putClientProperty("paintActive", b);

  143.                 repaint();

  144.             }

  145.             super.propertyChange(evt);

  146.         }

  147.     }

  148. 

  149.     class MetalTitlePaneLayout implements LayoutManager {    

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

  151.         public void removeLayoutComponent(Component c) {}   

  152.         public Dimension preferredLayoutSize(Container c)  {

  153.             return getPreferredSize(c);

  154.         }

  155. 

  156.         public Dimension getPreferredSize(Container c)  {

  157.             return new Dimension(c.getSize().width, computeHeight());

  158.         }

  159.         

  160.         public Dimension minimumLayoutSize(Container c) {

  161.             return preferredLayoutSize(c);

  162.         } 

  163.     

  164.         protected int computeHeight() {      

  165.             if ( isPalette ) {

  166.                 return paletteTitleHeight;

  167.             }

  168. 	  

  169.             FontMetrics fm 

  170.                 = Toolkit.getDefaultToolkit().getFontMetrics(getFont());

  171.             int fontHeight = fm.getHeight();

  172.             fontHeight += 7;

  173.             Icon icon = getFrame().getFrameIcon();

  174.             int iconHeight = 0;

  175.             if (icon != null) iconHeight = icon.getIconHeight();

  176.             iconHeight += 5;

  177.       

  178.             int finalHeight = Math.max( fontHeight, iconHeight );

  179. 

  180.             return finalHeight;

  181.         }	

  182. 				    

  183.         public void layoutContainer(Container c) {

  184.             JInternalFrame frame = getFrame();

  185.             boolean leftToRight = MetalUtils.isLeftToRight(frame);

  186.        

  187.             int w = getWidth();

  188.             int x = leftToRight ? w : 0;

  189.             int y = 2;

  190.             int spacing;

  191.       

  192.             // assumes all buttons have the same dimensions

  193.             // these dimensions include the borders

  194.             JButton closeButton = getCloseButton();

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

  196.             int buttonWidth = closeButton.getIcon().getIconWidth();

  197. 

  198.             if(frame.isClosable()) {

  199.                 if (isPalette) {

  200.                     spacing = 3;

  201.                     x += leftToRight ? -spacing -(buttonWidth+2) : spacing;

  202.                     closeButton.setBounds(x, y, buttonWidth+2, getHeight()-4);

  203.                     if( !leftToRight ) x += (buttonWidth+2);

  204.                 } else {

  205.                     spacing = 4;

  206.                     x += leftToRight ? -spacing -buttonWidth : spacing;

  207.                     closeButton.setBounds(x, y, buttonWidth, buttonHeight);

  208.                     if( !leftToRight ) x += buttonWidth;

  209.                 }

  210.             }

  211. 

  212.             if(frame.isMaximizable() && !isPalette ) {

  213.                 JButton maxButton = getMaxButton();

  214.                 spacing = frame.isClosable() ? 10 : 4;

  215.                 x += leftToRight ? -spacing -buttonWidth : spacing;

  216.                 maxButton.setBounds(x, y, buttonWidth, buttonHeight);

  217.                 if( !leftToRight ) x += buttonWidth;

  218.             } 

  219.         

  220.             if(frame.isIconifiable() && !isPalette ) {

  221.                 JButton iconButton = getIconButton();

  222.                 spacing = frame.isMaximizable() ? 2

  223.                           : (frame.isClosable() ? 10 : 4);

  224.                 x += leftToRight ? -spacing -buttonWidth : spacing;

  225.                 iconButton.setBounds(x, y, buttonWidth, buttonHeight);      

  226.                 if( !leftToRight ) x += buttonWidth;

  227.             }

  228.         

  229.             buttonsWidth = leftToRight ? w - x : x;

  230.         } 

  231.     }

  232. 

  233.     public void paintPalette(Graphics g)  {

  234.         boolean leftToRight = MetalUtils.isLeftToRight(frame);

  235. 

  236.         int width = getWidth();

  237.         int height = getHeight();

  238.     

  239.         if (paletteBumps == null) {

  240.             paletteBumps 

  241.                 = new MetalBumps(0, 0,

  242.                                  MetalLookAndFeel.getPrimaryControlHighlight(),

  243.                                  MetalLookAndFeel.getPrimaryControlInfo(),

  244.                                  MetalLookAndFeel.getPrimaryControlShadow() );

  245.         }

  246. 

  247.         Color background = MetalLookAndFeel.getPrimaryControlShadow();     

  248.         Color darkShadow = MetalLookAndFeel.getPrimaryControlDarkShadow();

  249. 

  250.         g.setColor(background);

  251.         g.fillRect(0, 0, width, height);

  252. 

  253.         g.setColor( darkShadow );

  254.         g.drawLine ( 0, height - 1, width, height -1);

  255. 

  256.         int xOffset = leftToRight ? 4 : buttonsWidth + 4;

  257.         int bumpLength = width - buttonsWidth -2*4;

  258.         int bumpHeight = getHeight()  - 4;

  259.         paletteBumps.setBumpArea( bumpLength, bumpHeight );

  260.         paletteBumps.paintIcon( this, g, xOffset, 2);

  261.     }

  262. 

  263.     public void paintComponent(Graphics g)  {

  264.         if(isPalette) {

  265.             paintPalette(g);

  266.             return;

  267.         }

  268. 

  269.         boolean leftToRight = MetalUtils.isLeftToRight(frame);

  270.         boolean isSelected = frame.isSelected();

  271. 

  272.         int width = getWidth();

  273.         int height = getHeight();

  274.     

  275.         Color background;

  276.         Color foreground;

  277.         Color darkShadow;

  278. 

  279.         MetalBumps bumps;

  280. 

  281.         if (isSelected) {

  282.             background = MetalLookAndFeel.getWindowTitleBackground();

  283.             foreground = MetalLookAndFeel.getWindowTitleForeground();

  284.             darkShadow = MetalLookAndFeel.getPrimaryControlDarkShadow();

  285.             bumps = activeBumps;

  286.         } else {

  287.             background = MetalLookAndFeel.getWindowTitleInactiveBackground();

  288.             foreground = MetalLookAndFeel.getWindowTitleInactiveForeground();

  289.             darkShadow = MetalLookAndFeel.getControlDarkShadow();

  290.             bumps = inactiveBumps;

  291.         }

  292. 

  293.         g.setColor(background);

  294.         g.fillRect(0, 0, width, height);

  295. 

  296.         g.setColor( darkShadow );

  297.         g.drawLine ( 0, height - 1, width, height -1);

  298.         g.drawLine ( 0, 0, 0 ,0);    

  299.         g.drawLine ( width - 1, 0 , width -1, 0);

  300. 

  301. 

  302.         int titleLength = 0;

  303.         int xOffset = leftToRight ? 5 : width - 5;

  304.         String frameTitle = frame.getTitle();

  305. 

  306.         Icon icon = frame.getFrameIcon();

  307.         if ( icon != null ) {

  308.             if( !leftToRight ) 

  309.                 xOffset -= icon.getIconWidth();

  310.             int iconY = ((height / 2) - (icon.getIconHeight() /2));

  311.             icon.paintIcon(frame, g, xOffset, iconY);

  312.             xOffset += leftToRight ? icon.getIconWidth() + 5 : -5;

  313.         }

  314. 

  315.         if(frameTitle != null) {

  316.             Font f = getFont();

  317.             g.setFont(f);

  318.             FontMetrics fm = g.getFontMetrics();

  319.             int fHeight = fm.getHeight();

  320.             titleLength = fm.stringWidth(frameTitle);

  321. 

  322.             g.setColor(foreground);

  323. 

  324.             int yOffset = ( (height - fm.getHeight() ) / 2 ) + fm.getAscent();

  325.             if( !leftToRight )

  326.                 xOffset -= titleLength;

  327.             g.drawString( frameTitle, xOffset, yOffset );

  328.             xOffset += leftToRight ? titleLength + 5  : -5;

  329.         }

  330.   

  331.         int bumpXOffset;

  332.         int bumpLength;

  333.         if( leftToRight ) {

  334.             bumpLength = width - buttonsWidth - xOffset -5;

  335.             bumpXOffset = xOffset;

  336.         } else {

  337.             bumpLength = xOffset - buttonsWidth - 5;

  338.             bumpXOffset = buttonsWidth + 5;

  339.         }

  340.         int bumpYOffset = 3;

  341.         int bumpHeight = getHeight() - (2 * bumpYOffset);        

  342.         bumps.setBumpArea( bumpLength, bumpHeight );

  343.         bumps.paintIcon(this, g, bumpXOffset, bumpYOffset);

  344.     }

  345. 					     				    

  346.     public void setPalette(boolean b) {

  347.         isPalette = b;

  348. 

  349. 	if (isPalette) {

  350.             closeButton.setIcon(paletteCloseIcon);

  351.          if( frame.isMaximizable() )

  352.                 remove(maxButton);

  353.             if( frame.isIconifiable() )

  354.                 remove(iconButton);

  355.         } else {

  356.  	    closeButton.setIcon(closeIcon);

  357.             if( frame.isMaximizable() )

  358.                 add(maxButton);

  359.             if( frame.isIconifiable() )

  360.                 add(iconButton);

  361. 	}		

  362. 	revalidate();

  363. 	repaint();

  364.     }		     

  365. }