1. /*

  2.  * @(#)MetalInternalFrameTitlePane.java	1.51 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.metal;

  9. 

  10. import java.awt.*;

  11. import java.awt.event.*;

  12. import javax.swing.*;

  13. import javax.swing.border.*;

  14. import javax.swing.event.InternalFrameEvent;

  15. import java.util.EventListener;

  16. import java.beans.PropertyChangeListener;

  17. import java.beans.PropertyChangeEvent;

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

  19. 

  20. 

  21. /**

  22.  * Class that manages a JLF title bar

  23.  * @version 1.51 01/23/03

  24.  * @author Steve Wilson

  25.  * @author Brian Beck

  26.  * @since 1.3

  27.  */

  28. 

  29. public class MetalInternalFrameTitlePane  extends BasicInternalFrameTitlePane {

  30. 

  31.     protected boolean isPalette = false;  	

  32.     protected Icon paletteCloseIcon;

  33.     protected int paletteTitleHeight;

  34. 

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

  36. 

  37.     /**

  38.      * Key used to lookup Color from UIManager. If this is null,

  39.      * <code>getWindowTitleBackground</code> is used.

  40.      */

  41.     private String selectedBackgroundKey;

  42.     /**

  43.      * Key used to lookup Color from UIManager. If this is null,

  44.      * <code>getWindowTitleForeground</code> is used.

  45.      */

  46.     private String selectedForegroundKey;

  47.     /**

  48.      * Key used to lookup shadow color from UIManager. If this is null,

  49.      * <code>getPrimaryControlDarkShadow</code> is used.

  50.      */

  51.     private String selectedShadowKey;

  52.     /**

  53.      * Boolean indicating the state of the <code>JInternalFrame</code>s

  54.      * closable property at <code>updateUI</code> time.

  55.      */

  56.     private boolean wasClosable;

  57. 

  58.     int buttonsWidth = 0;	

  59.     

  60.     MetalBumps activeBumps 

  61.         = new MetalBumps( 0, 0,

  62.                           MetalLookAndFeel.getPrimaryControlHighlight(),

  63.                           MetalLookAndFeel.getPrimaryControlDarkShadow(),

  64.                           MetalLookAndFeel.getPrimaryControl() );

  65.     MetalBumps inactiveBumps 

  66.         = new MetalBumps( 0, 0,

  67.                           MetalLookAndFeel.getControlHighlight(),

  68.                           MetalLookAndFeel.getControlDarkShadow(),

  69.                           MetalLookAndFeel.getControl() );

  70.     MetalBumps paletteBumps;

  71. 

  72.     private Color activeBumpsHighlight = MetalLookAndFeel.

  73.                              getPrimaryControlHighlight();

  74.     private Color activeBumpsShadow = MetalLookAndFeel.

  75.                              getPrimaryControlDarkShadow();

  76. 					    

  77.     public MetalInternalFrameTitlePane(JInternalFrame f) {

  78.         super( f );

  79.     }

  80. 

  81.     public void addNotify() {

  82.         super.addNotify();

  83.         // This is done here instead of in installDefaults as I was worried

  84.         // that the BasicInternalFrameUI might not be fully initialized, and

  85.         // that if this resets the closable state the BasicInternalFrameUI

  86.         // Listeners that get notified might be in an odd/uninitialized state.

  87.         updateOptionPaneState();

  88.     }

  89. 

  90.     protected void installDefaults() {

  91.         super.installDefaults();

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

  93.         paletteTitleHeight

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

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

  96.         wasClosable = frame.isClosable();

  97.         selectedForegroundKey = selectedBackgroundKey = null;

  98.     }

  99.     

  100.     protected void uninstallDefaults() {

  101.         super.uninstallDefaults();

  102.         if (wasClosable != frame.isClosable()) {

  103.             frame.setClosable(wasClosable);

  104.         }

  105.     }

  106. 

  107.     protected void createButtons() {

  108.         super.createButtons();

  109. 

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

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

  112.         iconButton.setBorder(handyEmptyBorder);

  113.         iconButton.getAccessibleContext().setAccessibleName(

  114.             UIManager.getString(

  115.                 "InternalFrameTitlePane.iconifyButtonAccessibleName"));

  116.     

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

  118.         maxButton.setBorder(handyEmptyBorder);

  119.         maxButton.getAccessibleContext().setAccessibleName(

  120.             UIManager.getString("InternalFrameTitlePane.maximizeButtonAccessibleName"));

  121.         

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

  123.         closeButton.setBorder(handyEmptyBorder);

  124.         closeButton.getAccessibleContext().setAccessibleName(

  125.             UIManager.getString("InternalFrameTitlePane.closeButtonAccessibleName"));

  126. 

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

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

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

  130.     }

  131. 

  132.     /**

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

  134.      * have system menus.

  135.      */

  136.     protected void assembleSystemMenu() {}

  137. 

  138.     /**

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

  140.      * have system menus.

  141.      */

  142.     protected void addSystemMenuItems(JMenu systemMenu) {}

  143. 

  144.     /**

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

  146.      * have system menus.

  147.      */

  148.     protected void showSystemMenu() {}

  149. 

  150.     /**

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

  152.      * do not have system menus.

  153.      */

  154.     protected void addSubComponents() {

  155.         add(iconButton);

  156.         add(maxButton);

  157.         add(closeButton);

  158.     }

  159. 

  160.     protected PropertyChangeListener createPropertyChangeListener() {

  161.         return new MetalPropertyChangeHandler();

  162.     }

  163.     

  164.     protected LayoutManager createLayout() {

  165.         return new MetalTitlePaneLayout();

  166.     }

  167. 

  168.     class MetalPropertyChangeHandler

  169.         extends BasicInternalFrameTitlePane.PropertyChangeHandler

  170.     {

  171.         public void propertyChange(PropertyChangeEvent evt) {

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

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

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

  175.                 iconButton.putClientProperty("paintActive", b);

  176.                 closeButton.putClientProperty("paintActive", b);

  177.                 maxButton.putClientProperty("paintActive", b);

  178.             }

  179.             else if ("JInternalFrame.messageType".equals(prop)) {

  180.                 updateOptionPaneState();

  181.                 frame.repaint();

  182.             }

  183.             super.propertyChange(evt);

  184.         }

  185.     }

  186. 

  187.     class MetalTitlePaneLayout extends TitlePaneLayout {    

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

  189.         public void removeLayoutComponent(Component c) {}   

  190.         public Dimension preferredLayoutSize(Container c)  {

  191.             return minimumLayoutSize(c);

  192.         }

  193. 

  194.         public Dimension minimumLayoutSize(Container c) {

  195.             // Compute width.

  196.             int width = 30;

  197.             if (frame.isClosable()) {

  198.                 width += 21;

  199.             }

  200.             if (frame.isMaximizable()) {

  201.                 width += 16 + (frame.isClosable() ? 10 : 4);

  202.             }

  203.             if (frame.isIconifiable()) {

  204.                 width += 16 + (frame.isMaximizable() ? 2 :

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

  206.             }

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

  208.             String frameTitle = frame.getTitle();

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

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

  211. 

  212.             if (title_length > 2) {

  213.                 int subtitle_w =

  214.                     fm.stringWidth(frame.getTitle().substring(0, 2) + "...");

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

  216.             }

  217.             else {

  218.                 width += title_w;

  219.             }

  220. 

  221.             // Compute height.

  222.             int height = 0;

  223.             if (isPalette) {

  224.                 height = paletteTitleHeight;

  225.             } else {

  226.                 int fontHeight = fm.getHeight();

  227.                 fontHeight += 7;

  228.                 Icon icon = frame.getFrameIcon();

  229.                 int iconHeight = 0;

  230.                 if (icon != null) {

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

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

  233.                 }

  234.                 iconHeight += 5;

  235.                 height = Math.max(fontHeight, iconHeight);

  236.             }

  237. 

  238.             return new Dimension(width, height);

  239.         } 

  240.     

  241.         public void layoutContainer(Container c) {

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

  243.        

  244.             int w = getWidth();

  245.             int x = leftToRight ? w : 0;

  246.             int y = 2;

  247.             int spacing;

  248.       

  249.             // assumes all buttons have the same dimensions

  250.             // these dimensions include the borders

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

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

  253. 

  254.             if(frame.isClosable()) {

  255.                 if (isPalette) {

  256.                     spacing = 3;

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

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

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

  260.                 } else {

  261.                     spacing = 4;

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

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

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

  265.                 }

  266.             }

  267. 

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

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

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

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

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

  273.             } 

  274.         

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

  276.                 spacing = frame.isMaximizable() ? 2

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

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

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

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

  281.             }

  282.         

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

  284.         } 

  285.     }

  286. 

  287.     public void paintPalette(Graphics g)  {

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

  289. 

  290.         int width = getWidth();

  291.         int height = getHeight();

  292.     

  293.         if (paletteBumps == null) {

  294.             paletteBumps 

  295.                 = new MetalBumps(0, 0,

  296.                                  MetalLookAndFeel.getPrimaryControlHighlight(),

  297.                                  MetalLookAndFeel.getPrimaryControlInfo(),

  298.                                  MetalLookAndFeel.getPrimaryControlShadow() );

  299.         }

  300. 

  301.         Color background = MetalLookAndFeel.getPrimaryControlShadow();     

  302.         Color darkShadow = MetalLookAndFeel.getPrimaryControlDarkShadow();

  303. 

  304.         g.setColor(background);

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

  306. 

  307.         g.setColor( darkShadow );

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

  309. 

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

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

  312.         int bumpHeight = getHeight()  - 4;

  313.         paletteBumps.setBumpArea( bumpLength, bumpHeight );

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

  315.     }

  316. 

  317.     public void paintComponent(Graphics g)  {

  318.         if(isPalette) {

  319.             paintPalette(g);

  320.             return;

  321.         }

  322. 

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

  324.         boolean isSelected = frame.isSelected();

  325. 

  326.         int width = getWidth();

  327.         int height = getHeight();

  328.     

  329.         Color background = null;

  330.         Color foreground = null;

  331.         Color shadow = null;

  332. 

  333.         MetalBumps bumps;

  334. 

  335.         if (isSelected) {

  336.             if (selectedBackgroundKey != null) {

  337.                 background = UIManager.getColor(selectedBackgroundKey);

  338.             }

  339.             if (background == null) {

  340.                 background = MetalLookAndFeel.getWindowTitleBackground();

  341.             }

  342.             if (selectedForegroundKey != null) {

  343.                 foreground = UIManager.getColor(selectedForegroundKey);

  344.             }

  345.             if (selectedShadowKey != null) {

  346.                 shadow = UIManager.getColor(selectedShadowKey);

  347.             }

  348.             if (shadow == null) {

  349.                 shadow = MetalLookAndFeel.getPrimaryControlDarkShadow();

  350.             }

  351.             if (foreground == null) {

  352.                 foreground = MetalLookAndFeel.getWindowTitleForeground();

  353.             }

  354.             activeBumps.setBumpColors(activeBumpsHighlight, activeBumpsShadow,

  355.                                       background);

  356.             bumps = activeBumps;

  357.         } else {

  358.             background = MetalLookAndFeel.getWindowTitleInactiveBackground();

  359.             foreground = MetalLookAndFeel.getWindowTitleInactiveForeground();

  360.             shadow = MetalLookAndFeel.getControlDarkShadow();

  361.             bumps = inactiveBumps;

  362.         }

  363. 

  364.         g.setColor(background);

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

  366. 

  367.         g.setColor( shadow );

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

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

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

  371. 

  372. 

  373.         int titleLength = 0;

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

  375.         String frameTitle = frame.getTitle();

  376. 

  377.         Icon icon = frame.getFrameIcon();

  378.         if ( icon != null ) {

  379.             if( !leftToRight ) 

  380.                 xOffset -= icon.getIconWidth();

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

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

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

  384.         }

  385. 

  386.         if(frameTitle != null) {

  387.             Font f = getFont();

  388.             g.setFont(f);

  389.             FontMetrics fm = g.getFontMetrics();

  390.             int fHeight = fm.getHeight();

  391. 

  392.             g.setColor(foreground);

  393. 

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

  395. 

  396.             Rectangle rect = new Rectangle(0, 0, 0, 0);

  397.             if (frame.isIconifiable()) { rect = iconButton.getBounds(); }

  398.             else if (frame.isMaximizable()) { rect = maxButton.getBounds(); }

  399.             else if (frame.isClosable()) { rect = closeButton.getBounds(); }

  400.             int titleW;

  401. 

  402.             if( leftToRight ) {

  403.               if (rect.x == 0) {

  404. 		rect.x = frame.getWidth()-frame.getInsets().right-2;

  405. 	      }

  406.               titleW = rect.x - xOffset - 4;

  407.               frameTitle = getTitle(frameTitle, fm, titleW);

  408.             } else {

  409.               titleW = xOffset - rect.x - rect.width - 4;

  410.               frameTitle = getTitle(frameTitle, fm, titleW);

  411.               xOffset -= SwingUtilities.computeStringWidth(fm, frameTitle);

  412.             }

  413. 

  414.             titleLength = SwingUtilities.computeStringWidth(fm, frameTitle);

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

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

  417.         }

  418.   

  419.         int bumpXOffset;

  420.         int bumpLength;

  421.         if( leftToRight ) {

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

  423.             bumpXOffset = xOffset;

  424.         } else {

  425.             bumpLength = xOffset - buttonsWidth - 5;

  426.             bumpXOffset = buttonsWidth + 5;

  427.         }

  428.         int bumpYOffset = 3;

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

  430.         bumps.setBumpArea( bumpLength, bumpHeight );

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

  432.     }

  433. 					     				    

  434.     public void setPalette(boolean b) {

  435.         isPalette = b;

  436. 

  437. 	if (isPalette) {

  438.             closeButton.setIcon(paletteCloseIcon);

  439.          if( frame.isMaximizable() )

  440.                 remove(maxButton);

  441.             if( frame.isIconifiable() )

  442.                 remove(iconButton);

  443.         } else {

  444.  	    closeButton.setIcon(closeIcon);

  445.             if( frame.isMaximizable() )

  446.                 add(maxButton);

  447.             if( frame.isIconifiable() )

  448.                 add(iconButton);

  449. 	}		

  450. 	revalidate();

  451. 	repaint();

  452.     }		     

  453. 

  454.     /**

  455.      * Updates any state dependant upon the JInternalFrame being shown in

  456.      * a <code>JOptionPane</code>.

  457.      */

  458.     private void updateOptionPaneState() {

  459.         int type = -2;

  460.         boolean closable = wasClosable;

  461.         Object obj = frame.getClientProperty("JInternalFrame.messageType");

  462. 

  463.         if (obj == null) {

  464.             // Don't change the closable state unless in an JOptionPane.

  465.             return;

  466.         }

  467.         if (obj instanceof Integer) {

  468.             type = ((Integer) obj).intValue();

  469.         }

  470.         switch (type) {

  471.         case JOptionPane.ERROR_MESSAGE:

  472.             selectedBackgroundKey =

  473.                               "OptionPane.errorDialog.titlePane.background";

  474.             selectedForegroundKey =

  475.                               "OptionPane.errorDialog.titlePane.foreground";

  476.             selectedShadowKey = "OptionPane.errorDialog.titlePane.shadow";

  477.             closable = false;

  478.             break;

  479.         case JOptionPane.QUESTION_MESSAGE:

  480.             selectedBackgroundKey =

  481.                             "OptionPane.questionDialog.titlePane.background";

  482.             selectedForegroundKey =

  483.                     "OptionPane.questionDialog.titlePane.foreground";

  484.             selectedShadowKey =

  485.                           "OptionPane.questionDialog.titlePane.shadow";

  486.             closable = false;

  487.             break;

  488.         case JOptionPane.WARNING_MESSAGE:

  489.             selectedBackgroundKey =

  490.                               "OptionPane.warningDialog.titlePane.background";

  491.             selectedForegroundKey =

  492.                               "OptionPane.warningDialog.titlePane.foreground";

  493.             selectedShadowKey = "OptionPane.warningDialog.titlePane.shadow";

  494.             closable = false;

  495.             break;

  496.         case JOptionPane.INFORMATION_MESSAGE:

  497.         case JOptionPane.PLAIN_MESSAGE:

  498.             selectedBackgroundKey = selectedForegroundKey = selectedShadowKey =

  499.                                     null;

  500.             closable = false;

  501.             break;

  502.         default:

  503.             selectedBackgroundKey = selectedForegroundKey = selectedShadowKey =

  504.                                     null;

  505.             break;

  506.         }

  507.         if (closable != frame.isClosable()) {

  508.             frame.setClosable(closable);

  509.         }

  510.     }

  511. }