1. /*

  2.  * @(#)MotifTabbedPaneUI.java	1.42 01/11/29

  3.  *

  4.  * Copyright 2002 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.motif;

  9. 

  10. import java.awt.*;

  11. import java.awt.event.*;

  12. import javax.swing.*;

  13. import javax.swing.event.*;

  14. import javax.swing.plaf.*;

  15. import javax.swing.plaf.basic.BasicTabbedPaneUI;

  16. import java.io.Serializable; 

  17. 

  18. /**

  19.  * A Motif L&F implementation of TabbedPaneUI.

  20.  * <p>

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

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

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

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

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

  26.  * long term persistence.

  27.  *

  28.  * @version 1.42 11/29/01

  29.  * @author Amy Fowler

  30.  * @author Philip Milne

  31.  */

  32. public class MotifTabbedPaneUI extends BasicTabbedPaneUI

  33. {

  34. 

  35. // Instance variables initialized at installation

  36. 

  37.     protected Color unselectedTabBackground;

  38.     protected Color unselectedTabForeground;

  39.     protected Color unselectedTabShadow;

  40.     protected Color unselectedTabHighlight;

  41. 

  42. 

  43. // UI creation

  44. 

  45.     public static ComponentUI createUI(JComponent tabbedPane) {

  46.         return new MotifTabbedPaneUI();

  47.     }

  48. 

  49. 

  50. // UI Installation/De-installation

  51. 

  52. 

  53.     protected void installDefaults() {

  54.         super.installDefaults();

  55. 

  56.         unselectedTabBackground = UIManager.getColor("TabbedPane.unselectedTabBackground");

  57.         unselectedTabForeground = UIManager.getColor("TabbedPane.unselectedTabForeground");

  58.         unselectedTabShadow = UIManager.getColor("TabbedPane.unselectedTabShadow");

  59.         unselectedTabHighlight = UIManager.getColor("TabbedPane.unselectedTabHighlight");

  60.     }

  61. 

  62.     protected void uninstallDefaults() {

  63.         super.uninstallDefaults();

  64. 

  65.         unselectedTabBackground = null;

  66.         unselectedTabForeground = null;

  67.         unselectedTabShadow = null;

  68.         unselectedTabHighlight = null;

  69.     }

  70. 

  71. // UI Rendering

  72. 

  73.    protected void paintContentBorderTopEdge(Graphics g, int tabPlacement,

  74.                                             int selectedIndex, 

  75.                                             int x, int y, int w, int h) {

  76. 

  77.         g.setColor(lightHighlight);

  78.         if (tabPlacement != TOP || selectedIndex < 0) {

  79.             g.drawLine(x, y, x+w-2, y);

  80.         } else {

  81.             Rectangle selRect = rects[selectedIndex];

  82. 

  83.             g.drawLine(x, y, selRect.x - 1, y);

  84.             if (selRect.x + selRect.width < x + w - 2) {

  85.                 g.drawLine(selRect.x + selRect.width, y, 

  86.                            x+w-2, y);

  87.             } 

  88.         }

  89.     }

  90. 

  91.     protected void paintContentBorderBottomEdge(Graphics g, int tabPlacement,

  92.                                                int selectedIndex,

  93.                                                int x, int y, int w, int h) { 

  94.         g.setColor(shadow);

  95.         if (tabPlacement != BOTTOM || selectedIndex < 0) {

  96.             g.drawLine(x+1, y+h-1, x+w-1, y+h-1);

  97.         } else {

  98.             Rectangle selRect = rects[selectedIndex];

  99. 

  100.             g.drawLine(x+1, y+h-1, selRect.x - 1, y+h-1);

  101.             if (selRect.x + selRect.width < x + w - 2) {

  102.                 g.drawLine(selRect.x + selRect.width, y+h-1, x+w-2, y+h-1);

  103.             } 

  104.         }

  105.     }

  106. 

  107.     protected void paintContentBorderRightEdge(Graphics g, int tabPlacement,

  108.                                                int selectedIndex,

  109.                                                int x, int y, int w, int h) { 

  110. 

  111.         g.setColor(shadow);

  112.         if (tabPlacement != RIGHT || selectedIndex < 0) {

  113.             g.drawLine(x+w-1, y+1, x+w-1, y+h-1);

  114.         } else {

  115.             Rectangle selRect = rects[selectedIndex];

  116. 

  117.             g.drawLine(x+w-1, y+1, x+w-1, selRect.y - 1);

  118. 

  119.             if (selRect.y + selRect.height < y + h - 2 ) {

  120.                 g.drawLine(x+w-1, selRect.y + selRect.height, 

  121.                            x+w-1, y+h-2);

  122.             } 

  123.         }

  124.     }

  125. 

  126.     protected void paintTabBackground(Graphics g,

  127.                                       int tabPlacement, int tabIndex,

  128.                                       int x, int y, int w, int h,

  129. 		 		      boolean isSelected ) {

  130.         g.setColor(isSelected? tabPane.getBackgroundAt(tabIndex) : unselectedTabBackground);

  131.         switch(tabPlacement) {

  132.           case LEFT:

  133.               g.fillRect(x+1, y+1, w-1, h-2);

  134.               break;

  135.           case RIGHT:

  136.               g.fillRect(x, y+1, w-1, h-2);

  137.               break;

  138.           case BOTTOM:

  139.               g.fillRect(x+1, y, w-2, h-3);

  140.               g.drawLine(x+2, y+h-3, x+w-3, y+h-3);

  141.               g.drawLine(x+3, y+h-2, x+w-4, y+h-2);

  142.               break;

  143.           case TOP:

  144.           default:

  145.               g.fillRect(x+1, y+3, w-2, h-3);

  146.               g.drawLine(x+2, y+2, x+w-3, y+2);

  147.               g.drawLine(x+3, y+1, x+w-4, y+1);

  148.         }

  149. 

  150.     }

  151. 

  152.     protected void paintTabBorder(Graphics g,

  153.                                   int tabPlacement, int tabIndex,

  154.                                   int x, int y, int w, int h,

  155. 				  boolean isSelected) { 

  156.         g.setColor(isSelected? lightHighlight : unselectedTabHighlight);

  157. 

  158.         switch(tabPlacement) {

  159.           case LEFT:

  160.               g.drawLine(x, y+2, x, y+h-3);

  161.               g.drawLine(x+1, y+1, x+1, y+2);

  162.               g.drawLine(x+2, y, x+2, y+1);

  163.               g.drawLine(x+3, y, x+w-1, y);

  164.               g.setColor(isSelected? shadow : unselectedTabShadow);

  165.               g.drawLine(x+1, y+h-3, x+1, y+h-2);

  166.               g.drawLine(x+2, y+h-2, x+2, y+h-1);

  167.               g.drawLine(x+3, y+h-1, x+w-1, y+h-1);

  168.               break;

  169.           case RIGHT:

  170.               g.drawLine(x, y, x+w-3, y);

  171.               g.setColor(isSelected? shadow : unselectedTabShadow);

  172.               g.drawLine(x+w-3, y, x+w-3, y+1);

  173.               g.drawLine(x+w-2, y+1, x+w-2, y+2);

  174.               g.drawLine(x+w-1, y+2, x+w-1, y+h-3);

  175.               g.drawLine(x+w-2, y+h-3, x+w-2, y+h-2);

  176.               g.drawLine(x+w-3, y+h-2, x+w-3, y+h-1);

  177.               g.drawLine(x, y+h-1, x+w-3, y+h-1);

  178.               break;

  179.           case BOTTOM:

  180.               g.drawLine(x, y, x, y+h-3);

  181.               g.drawLine(x+1, y+h-3, x+1, y+h-2);

  182.               g.drawLine(x+2, y+h-2, x+2, y+h-1);

  183.               g.setColor(isSelected? shadow : unselectedTabShadow);

  184.               g.drawLine(x+3, y+h-1, x+w-4, y+h-1);

  185.               g.drawLine(x+w-3, y+h-2, x+w-3, y+h-1);

  186.               g.drawLine(x+w-2, y+h-3, x+w-2, y+h-2);

  187.               g.drawLine(x+w-1, y, x+w-1, y+h-3);

  188.               break;

  189.           case TOP:

  190.           default:

  191.               g.drawLine(x, y+2, x, y+h-1);

  192.               g.drawLine(x+1, y+1, x+1, y+2);

  193.               g.drawLine(x+2, y, x+2, y+1);

  194.               g.drawLine(x+3, y, x+w-4, y);

  195.               g.setColor(isSelected? shadow : unselectedTabShadow);

  196.               g.drawLine(x+w-3, y, x+w-3, y+1);

  197.               g.drawLine(x+w-2, y+1, x+w-2, y+2);

  198.               g.drawLine(x+w-1, y+2, x+w-1, y+h-1);

  199.         }

  200. 

  201.     }

  202. 

  203.     protected void paintFocusIndicator(Graphics g, int tabPlacement,

  204.                                        Rectangle[] rects, int tabIndex, 

  205.                                        Rectangle iconRect, Rectangle textRect,

  206.                                        boolean isSelected) {

  207.         Rectangle tabRect = rects[tabIndex];

  208.         if (tabPane.hasFocus() && isSelected) {

  209.             int x, y, w, h;

  210. 	    g.setColor(focus);

  211.             switch(tabPlacement) {

  212.               case LEFT:

  213.                   x = tabRect.x + 3;

  214.                   y = tabRect.y + 3;

  215.                   w = tabRect.width - 6;

  216.                   h = tabRect.height - 7;

  217.                   break;

  218.               case RIGHT:

  219.                   x = tabRect.x + 2;

  220.                   y = tabRect.y + 3;

  221.                   w = tabRect.width - 6;

  222.                   h = tabRect.height - 7;

  223.                   break;

  224.               case BOTTOM:

  225.                   x = tabRect.x + 3;

  226.                   y = tabRect.y + 2;

  227.                   w = tabRect.width - 7;

  228.                   h = tabRect.height - 6;

  229.                   break;

  230.               case TOP:

  231.               default:

  232.                   x = tabRect.x + 3;

  233.                   y = tabRect.y + 3;

  234.                   w = tabRect.width - 7;

  235.                   h = tabRect.height - 6;

  236.             }

  237.             g.drawRect(x, y, w, h);

  238.         }

  239.     }

  240. 

  241.     protected int getTabRunIndent(int tabPlacement, int run) {

  242.         return run*3;

  243.     }

  244. 

  245.     protected int getTabRunOverlay(int tabPlacement) {

  246.         tabRunOverlay = (tabPlacement == LEFT || tabPlacement == RIGHT)?

  247.             (int)Math.round((float)maxTabWidth * .10) :

  248.             (int)Math.round((float)maxTabHeight * .22);

  249.         return tabRunOverlay;

  250.     } 

  251.        

  252. }