1. /*

  2.  * @(#)MotifTabbedPaneUI.java	1.43 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 com.sun.java.swing.plaf.motif;

  12. 

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import javax.swing.*;

  16. import javax.swing.event.*;

  17. import javax.swing.plaf.*;

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

  19. import java.io.Serializable; 

  20. 

  21. /**

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

  23.  * <p>

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

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

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

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

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

  29.  * long term persistence.

  30.  *

  31.  * @version 1.43 02/02/00

  32.  * @author Amy Fowler

  33.  * @author Philip Milne

  34.  */

  35. public class MotifTabbedPaneUI extends BasicTabbedPaneUI

  36. {

  37. 

  38. // Instance variables initialized at installation

  39. 

  40.     protected Color unselectedTabBackground;

  41.     protected Color unselectedTabForeground;

  42.     protected Color unselectedTabShadow;

  43.     protected Color unselectedTabHighlight;

  44. 

  45. 

  46. // UI creation

  47. 

  48.     public static ComponentUI createUI(JComponent tabbedPane) {

  49.         return new MotifTabbedPaneUI();

  50.     }

  51. 

  52. 

  53. // UI Installation/De-installation

  54. 

  55. 

  56.     protected void installDefaults() {

  57.         super.installDefaults();

  58. 

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

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

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

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

  63.     }

  64. 

  65.     protected void uninstallDefaults() {

  66.         super.uninstallDefaults();

  67. 

  68.         unselectedTabBackground = null;

  69.         unselectedTabForeground = null;

  70.         unselectedTabShadow = null;

  71.         unselectedTabHighlight = null;

  72.     }

  73. 

  74. // UI Rendering

  75. 

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

  77.                                             int selectedIndex, 

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

  79. 

  80.         g.setColor(lightHighlight);

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

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

  83.         } else {

  84.             Rectangle selRect = rects[selectedIndex];

  85. 

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

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

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

  89.                            x+w-2, y);

  90.             } 

  91.         }

  92.     }

  93. 

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

  95.                                                int selectedIndex,

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

  97.         g.setColor(shadow);

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

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

  100.         } else {

  101.             Rectangle selRect = rects[selectedIndex];

  102. 

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

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

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

  106.             } 

  107.         }

  108.     }

  109. 

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

  111.                                                int selectedIndex,

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

  113. 

  114.         g.setColor(shadow);

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

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

  117.         } else {

  118.             Rectangle selRect = rects[selectedIndex];

  119. 

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

  121. 

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

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

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

  125.             } 

  126.         }

  127.     }

  128. 

  129.     protected void paintTabBackground(Graphics g,

  130.                                       int tabPlacement, int tabIndex,

  131.                                       int x, int y, int w, int h,

  132. 		 		      boolean isSelected ) {

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

  134.         switch(tabPlacement) {

  135.           case LEFT:

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

  137.               break;

  138.           case RIGHT:

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

  140.               break;

  141.           case BOTTOM:

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

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

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

  145.               break;

  146.           case TOP:

  147.           default:

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

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

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

  151.         }

  152. 

  153.     }

  154. 

  155.     protected void paintTabBorder(Graphics g,

  156.                                   int tabPlacement, int tabIndex,

  157.                                   int x, int y, int w, int h,

  158. 				  boolean isSelected) { 

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

  160. 

  161.         switch(tabPlacement) {

  162.           case LEFT:

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

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

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

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

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

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

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

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

  171.               break;

  172.           case RIGHT:

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

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

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

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

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

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

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

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

  181.               break;

  182.           case BOTTOM:

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

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

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

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

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

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

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

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

  191.               break;

  192.           case TOP:

  193.           default:

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

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

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

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

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

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

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

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

  202.         }

  203. 

  204.     }

  205. 

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

  207.                                        Rectangle[] rects, int tabIndex, 

  208.                                        Rectangle iconRect, Rectangle textRect,

  209.                                        boolean isSelected) {

  210.         Rectangle tabRect = rects[tabIndex];

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

  212.             int x, y, w, h;

  213. 	    g.setColor(focus);

  214.             switch(tabPlacement) {

  215.               case LEFT:

  216.                   x = tabRect.x + 3;

  217.                   y = tabRect.y + 3;

  218.                   w = tabRect.width - 6;

  219.                   h = tabRect.height - 7;

  220.                   break;

  221.               case RIGHT:

  222.                   x = tabRect.x + 2;

  223.                   y = tabRect.y + 3;

  224.                   w = tabRect.width - 6;

  225.                   h = tabRect.height - 7;

  226.                   break;

  227.               case BOTTOM:

  228.                   x = tabRect.x + 3;

  229.                   y = tabRect.y + 2;

  230.                   w = tabRect.width - 7;

  231.                   h = tabRect.height - 6;

  232.                   break;

  233.               case TOP:

  234.               default:

  235.                   x = tabRect.x + 3;

  236.                   y = tabRect.y + 3;

  237.                   w = tabRect.width - 7;

  238.                   h = tabRect.height - 6;

  239.             }

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

  241.         }

  242.     }

  243. 

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

  245.         return run*3;

  246.     }

  247. 

  248.     protected int getTabRunOverlay(int tabPlacement) {

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

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

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

  252.         return tabRunOverlay;

  253.     } 

  254.        

  255. }