1. /*

  2.  * @(#)MetalTabbedPaneUI.java	1.36 03/12/19

  3.  *

  4.  * Copyright 2004 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 javax.swing.*;

  11. import javax.swing.event.*;

  12. import java.awt.*;

  13. import java.awt.event.*;

  14. import javax.swing.plaf.*;

  15. import java.io.Serializable; 

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

  17. 

  18. /**

  19.  * The Metal subclass of BasicTabbedPaneUI.

  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

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

  25.  * the same version of Swing.  As of 1.4, support for long term storage

  26.  * of all JavaBeans<sup><font size="-2">TM</font></sup>

  27.  * has been added to the <code>java.beans</code> package.

  28.  * Please see {@link java.beans.XMLEncoder}.

  29.  *

  30.  * @version 1.19 08/28/98

  31.  * @author Tom Santos

  32.  */

  33. 

  34. public class MetalTabbedPaneUI extends BasicTabbedPaneUI {

  35. 

  36.     protected int minTabWidth = 40;

  37.     // Background color for unselected tabs that don't have an explicitly

  38.     // set color.

  39.     private Color unselectedBackground;

  40.     protected Color tabAreaBackground;

  41.     protected Color selectColor;

  42.     protected Color selectHighlight;

  43.     private boolean tabsOpaque = true;

  44. 

  45.     // Whether or not we're using ocean. This is cached as it is used

  46.     // extensively during painting.

  47.     private boolean ocean;

  48.     // Selected border color for ocean.

  49.     private Color oceanSelectedBorderColor;

  50. 

  51.     public static ComponentUI createUI( JComponent x ) {

  52.         return new MetalTabbedPaneUI();

  53.     }  

  54. 

  55.     protected LayoutManager createLayoutManager() {

  56. 	if (tabPane.getTabLayoutPolicy() == JTabbedPane.SCROLL_TAB_LAYOUT) {

  57.             return super.createLayoutManager(); 

  58. 	}

  59.         return new TabbedPaneLayout();

  60.     }  

  61. 

  62.     protected void installDefaults() {

  63.         super.installDefaults();

  64. 

  65.         tabAreaBackground = UIManager.getColor("TabbedPane.tabAreaBackground");

  66.         selectColor = UIManager.getColor("TabbedPane.selected");

  67.         selectHighlight = UIManager.getColor("TabbedPane.selectHighlight");

  68.         tabsOpaque = UIManager.getBoolean("TabbedPane.tabsOpaque");

  69.         unselectedBackground = UIManager.getColor(

  70.                                          "TabbedPane.unselectedBackground");

  71.         ocean = MetalLookAndFeel.usingOcean();

  72.         if (ocean) {

  73.             oceanSelectedBorderColor = UIManager.getColor(

  74.                          "TabbedPane.borderHightlightColor");

  75.         }

  76.     }

  77. 

  78. 

  79.     protected void paintTabBorder( Graphics g, int tabPlacement,

  80.                                    int tabIndex, int x, int y, int w, int h, 

  81.                                    boolean isSelected) {

  82.         int bottom = y + (h-1);

  83.         int right = x + (w-1);

  84. 

  85.         switch ( tabPlacement ) {

  86.         case LEFT:

  87.             paintLeftTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);

  88.             break;

  89.         case BOTTOM:

  90.             paintBottomTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);

  91.             break;

  92.         case RIGHT:

  93.             paintRightTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);

  94.             break;

  95.         case TOP:

  96.         default:

  97.             paintTopTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);

  98.         }

  99.     }

  100. 

  101. 

  102.     protected void paintTopTabBorder( int tabIndex, Graphics g, 

  103.                                       int x, int y, int w, int h,

  104.                                       int btm, int rght,

  105.                                       boolean isSelected ) {

  106.         int currentRun = getRunForTab( tabPane.getTabCount(), tabIndex );

  107.         int lastIndex = lastTabInRun( tabPane.getTabCount(), currentRun );

  108.         int firstIndex = tabRuns[ currentRun ];

  109. 	boolean leftToRight = MetalUtils.isLeftToRight(tabPane);

  110.         int selectedIndex = tabPane.getSelectedIndex();

  111.         int bottom = h - 1;

  112.         int right = w - 1;

  113. 

  114.         //

  115.         // Paint Gap

  116.         //

  117. 

  118.         if (shouldFillGap( currentRun, tabIndex, x, y ) ) {

  119.             g.translate( x, y );

  120. 

  121. 	    if ( leftToRight ) {

  122. 	        g.setColor( getColorForGap( currentRun, x, y + 1 ) );

  123. 		g.fillRect( 1, 0, 5, 3 );

  124. 		g.fillRect( 1, 3, 2, 2 );

  125. 	    } else {

  126. 	        g.setColor( getColorForGap( currentRun, x + w - 1, y + 1 ) );

  127. 		g.fillRect( right - 5, 0, 5, 3 );

  128. 		g.fillRect( right - 2, 3, 2, 2 );

  129. 	    }

  130. 

  131.             g.translate( -x, -y );

  132.         }

  133. 

  134.         g.translate( x, y );

  135. 

  136.         //

  137.         // Paint Border

  138.         //

  139. 

  140.         if (ocean && isSelected) {

  141.             g.setColor(oceanSelectedBorderColor);

  142.         }

  143.         else {

  144.             g.setColor( darkShadow );

  145.         }

  146. 

  147. 	if ( leftToRight ) {

  148. 

  149. 	    // Paint slant

  150. 	    g.drawLine( 1, 5, 6, 0 );

  151. 

  152. 	    // Paint top

  153. 	    g.drawLine( 6, 0, right, 0 );

  154. 

  155. 	    // Paint right

  156. 	    if ( tabIndex==lastIndex ) {

  157. 	        // last tab in run

  158. 	        g.drawLine( right, 1, right, bottom );

  159. 	    }

  160. 

  161.             if (ocean && tabIndex - 1 == selectedIndex &&

  162.                                 currentRun == getRunForTab(

  163.                                 tabPane.getTabCount(), selectedIndex)) {

  164.                 g.setColor(oceanSelectedBorderColor);

  165.             }

  166. 

  167. 	    // Paint left

  168. 	    if ( tabIndex != tabRuns[ runCount - 1 ] ) {

  169. 	        // not the first tab in the last run

  170.                 if (ocean && isSelected) {

  171.                     g.drawLine(0, 6, 0, bottom);

  172.                     g.setColor(darkShadow);

  173.                     g.drawLine(0, 0, 0, 5);

  174.                 }

  175.                 else {

  176.                     g.drawLine( 0, 0, 0, bottom );

  177.                 }

  178. 	    } else {

  179. 	        // the first tab in the last run

  180. 	        g.drawLine( 0, 6, 0, bottom );

  181. 	    }

  182. 	} else {

  183. 

  184. 	    // Paint slant

  185. 	    g.drawLine( right - 1, 5, right - 6, 0 );

  186. 

  187. 	    // Paint top

  188. 	    g.drawLine( right - 6, 0, 0, 0 );

  189. 

  190. 	    // Paint left

  191. 	    if ( tabIndex==lastIndex ) {

  192. 	        // last tab in run

  193. 	        g.drawLine( 0, 1, 0, bottom );

  194. 	    }

  195. 

  196.             // Paint right

  197.             if (ocean && tabIndex - 1 == selectedIndex &&

  198.                                 currentRun == getRunForTab(

  199.                                 tabPane.getTabCount(), selectedIndex)) {

  200.                 g.setColor(oceanSelectedBorderColor);

  201.                 g.drawLine(right, 0, right, bottom);

  202.             }

  203.             else if (ocean && isSelected) {

  204.                 g.drawLine(right, 6, right, bottom);

  205.                 if (tabIndex != 0) {

  206.                     g.setColor(darkShadow);

  207.                     g.drawLine(right, 0, right, 5);

  208.                 }

  209.             }

  210.             else {

  211.                 if ( tabIndex != tabRuns[ runCount - 1 ] ) {

  212.                     // not the first tab in the last run

  213.                     g.drawLine( right, 0, right, bottom );

  214.                 } else {

  215.                     // the first tab in the last run

  216.                     g.drawLine( right, 6, right, bottom );

  217.                 }

  218.             }

  219. 	}

  220. 

  221.         //

  222.         // Paint Highlight

  223.         //

  224. 

  225.         g.setColor( isSelected ? selectHighlight : highlight );

  226. 

  227. 	if ( leftToRight ) {

  228. 

  229. 	    // Paint slant

  230. 	    g.drawLine( 1, 6, 6, 1 );

  231. 

  232. 	    // Paint top

  233. 	    g.drawLine( 6, 1, right, 1 );

  234. 

  235. 	    // Paint left

  236. 	    g.drawLine( 1, 6, 1, bottom );

  237. 

  238. 	    // paint highlight in the gap on tab behind this one

  239. 	    // on the left end (where they all line up)

  240. 	    if ( tabIndex==firstIndex && tabIndex!=tabRuns[runCount - 1] ) {

  241. 	        //  first tab in run but not first tab in last run

  242. 	        if (tabPane.getSelectedIndex()==tabRuns[currentRun+1]) {

  243. 		    // tab in front of selected tab

  244. 		    g.setColor( selectHighlight );

  245. 		}

  246. 		else {

  247. 		    // tab in front of normal tab

  248. 		    g.setColor( highlight );

  249. 		}

  250. 		g.drawLine( 1, 0, 1, 4 );

  251. 	    }

  252. 	} else {

  253. 

  254. 	    // Paint slant

  255. 	    g.drawLine( right - 1, 6, right - 6, 1 );

  256. 

  257. 	    // Paint top

  258. 	    g.drawLine( right - 6, 1, 1, 1 );

  259. 

  260. 	    // Paint left

  261. 	    if ( tabIndex==lastIndex ) {

  262. 	        // last tab in run

  263. 	        g.drawLine( 1, 1, 1, bottom );

  264. 	    } else {

  265. 	        g.drawLine( 0, 1, 0, bottom );

  266. 	    }

  267. 	}

  268. 

  269.         g.translate( -x, -y );

  270.     }

  271. 

  272.     protected boolean shouldFillGap( int currentRun, int tabIndex, int x, int y ) {

  273.         boolean result = false;

  274. 

  275.         if (!tabsOpaque) {

  276.             return false;

  277.         }

  278.         

  279.         if ( currentRun == runCount - 2 ) {  // If it's the second to last row.

  280.             Rectangle lastTabBounds = getTabBounds( tabPane, tabPane.getTabCount() - 1 );

  281. 	    Rectangle tabBounds = getTabBounds( tabPane, tabIndex );

  282.             if (MetalUtils.isLeftToRight(tabPane)) {

  283. 	        int lastTabRight = lastTabBounds.x + lastTabBounds.width - 1;

  284. 

  285. 		// is the right edge of the last tab to the right

  286. 		// of the left edge of the current tab?

  287. 		if ( lastTabRight > tabBounds.x + 2 ) {

  288. 		    return true;

  289. 		}

  290. 	    } else {

  291. 	        int lastTabLeft = lastTabBounds.x;

  292. 		int currentTabRight = tabBounds.x + tabBounds.width - 1;

  293. 

  294. 		// is the left edge of the last tab to the left

  295. 		// of the right edge of the current tab?

  296. 		if ( lastTabLeft < currentTabRight - 2 ) {

  297. 		    return true;

  298. 		}

  299.             }

  300.         } else {

  301. 	    // fill in gap for all other rows except last row

  302.             result = currentRun != runCount - 1;

  303.         }

  304. 

  305.         return result;

  306.     }

  307. 

  308.     protected Color getColorForGap( int currentRun, int x, int y ) {

  309.         final int shadowWidth = 4;

  310.         int selectedIndex = tabPane.getSelectedIndex();

  311.         int startIndex = tabRuns[ currentRun + 1 ];

  312.         int endIndex = lastTabInRun( tabPane.getTabCount(), currentRun + 1 );

  313.         int tabOverGap = -1;

  314.         // Check each tab in the row that is 'on top' of this row

  315.         for ( int i = startIndex; i <= endIndex; ++i ) {

  316.             Rectangle tabBounds = getTabBounds( tabPane, i );

  317.             int tabLeft = tabBounds.x;

  318.             int tabRight = (tabBounds.x + tabBounds.width) - 1;

  319.             // Check to see if this tab is over the gap

  320. 	    if ( MetalUtils.isLeftToRight(tabPane) ) {

  321.                 if ( tabLeft <= x && tabRight - shadowWidth > x ) {

  322.                     if (ocean) {

  323.                         if (selectedIndex == i) {

  324.                             return oceanSelectedBorderColor;

  325.                         }

  326.                         return getUnselectedBackgroundAt(i);

  327.                     }

  328.                     return selectedIndex == i ? selectColor : getUnselectedBackgroundAt( i );

  329.                 }

  330.             }

  331.             else {

  332. 	        if ( tabLeft + shadowWidth < x && tabRight >= x ) {

  333.                     if (ocean) {

  334.                         if (selectedIndex == i) {

  335.                             return oceanSelectedBorderColor;

  336.                         }

  337.                         return getUnselectedBackgroundAt(i);

  338.                     }

  339.                     return selectedIndex == i ? selectColor : getUnselectedBackgroundAt( i );

  340.                 }

  341.             }

  342.         }

  343. 

  344.         return tabPane.getBackground();

  345.     }

  346. 

  347.     protected void paintLeftTabBorder( int tabIndex, Graphics g, 

  348.                                        int x, int y, int w, int h,

  349.                                        int btm, int rght,

  350.                                        boolean isSelected ) {

  351.         int tabCount = tabPane.getTabCount();

  352.         int currentRun = getRunForTab( tabCount, tabIndex );

  353.         int lastIndex = lastTabInRun( tabCount, currentRun );

  354.         int firstIndex = tabRuns[ currentRun ];

  355. 

  356.         g.translate( x, y );

  357. 

  358.         int bottom = h - 1;

  359.         int right = w - 1;

  360. 

  361.         //

  362.         // Paint part of the tab above

  363.         //

  364. 

  365.         if ( tabIndex != firstIndex && tabsOpaque ) {

  366.             g.setColor( tabPane.getSelectedIndex() == tabIndex - 1 ?

  367.                         selectColor :

  368.                         getUnselectedBackgroundAt( tabIndex - 1 ) );

  369.             g.fillRect( 2, 0, 4, 3 );

  370.             g.drawLine( 2, 3, 2, 3 );

  371.         }

  372. 

  373. 

  374.         //

  375.         // Paint Highlight

  376.         //

  377. 

  378.         if (ocean) {

  379.             g.setColor(isSelected ? selectHighlight :

  380.                        MetalLookAndFeel.getWhite());

  381.         }

  382.         else {

  383.             g.setColor( isSelected ? selectHighlight : highlight );

  384.         }

  385. 

  386.         // Paint slant

  387.         g.drawLine( 1, 6, 6, 1 );

  388. 

  389.         // Paint left

  390.         g.drawLine( 1, 6, 1, bottom );

  391. 

  392.         // Paint top

  393.         g.drawLine( 6, 1, right, 1 );

  394. 

  395.         if ( tabIndex != firstIndex ) {

  396.             if (ocean) {

  397.                 g.setColor(MetalLookAndFeel.getWhite());

  398.             }

  399.             g.drawLine( 1, 0, 1, 4 );

  400.         }

  401. 

  402.         //

  403.         // Paint Border

  404.         //

  405. 

  406.         if (ocean) {

  407.             if (isSelected) {

  408.                 g.setColor(oceanSelectedBorderColor);

  409.             }

  410.             else {

  411.                 g.setColor( darkShadow );

  412.             }

  413.         }

  414.         else {

  415.             g.setColor( darkShadow );

  416.         }

  417. 

  418.         // Paint slant

  419.         g.drawLine( 1, 5, 6, 0 );

  420. 

  421.         // Paint top

  422.         g.drawLine( 6, 0, right, 0 );

  423. 

  424.         // Paint bottom

  425.         if ( tabIndex == lastIndex ) {

  426.             g.drawLine( 0, bottom, right, bottom );

  427.         }

  428. 

  429.         // Paint left

  430.         if (ocean) {

  431.             if (tabPane.getSelectedIndex() == tabIndex - 1) {

  432.                 g.drawLine(0, 5, 0, bottom);

  433.                 g.setColor(oceanSelectedBorderColor);

  434.                 g.drawLine(0, 0, 0, 5);

  435.             }

  436.             else if (isSelected) {

  437.                 g.drawLine( 0, 5, 0, bottom );

  438.                 if (tabIndex != 0) {

  439.                     g.setColor(darkShadow);

  440.                     g.drawLine(0, 0, 0, 5);

  441.                 }

  442.             }

  443.             else if ( tabIndex != firstIndex ) {

  444.                 g.drawLine( 0, 0, 0, bottom );

  445.             } else {

  446.                 g.drawLine( 0, 6, 0, bottom );

  447.             }

  448.         }

  449.         else { // metal

  450.             if ( tabIndex != firstIndex ) {

  451.                 g.drawLine( 0, 0, 0, bottom );

  452.             } else {

  453.                 g.drawLine( 0, 6, 0, bottom );

  454.             }

  455.         }

  456. 

  457.         g.translate( -x, -y );

  458.     }

  459. 

  460. 

  461.     protected void paintBottomTabBorder( int tabIndex, Graphics g, 

  462.                                          int x, int y, int w, int h,

  463.                                          int btm, int rght,

  464.                                          boolean isSelected ) {

  465.         int tabCount = tabPane.getTabCount();

  466.         int currentRun = getRunForTab( tabCount, tabIndex );

  467.         int lastIndex = lastTabInRun( tabCount, currentRun );

  468.         int firstIndex = tabRuns[ currentRun ];

  469. 	boolean leftToRight = MetalUtils.isLeftToRight(tabPane);

  470. 

  471.         int bottom = h - 1;

  472.         int right = w - 1;

  473. 

  474.         //

  475.         // Paint Gap

  476.         //

  477. 

  478.         if ( shouldFillGap( currentRun, tabIndex, x, y ) ) {

  479.             g.translate( x, y );

  480. 

  481. 	    if ( leftToRight ) {

  482. 	        g.setColor( getColorForGap( currentRun, x, y ) );

  483. 		g.fillRect( 1, bottom - 4, 3, 5 );

  484. 		g.fillRect( 4, bottom - 1, 2, 2 );

  485. 	    } else {

  486. 	        g.setColor( getColorForGap( currentRun, x + w - 1, y ) );

  487. 		g.fillRect( right - 3, bottom - 3, 3, 4 );

  488. 		g.fillRect( right - 5, bottom - 1, 2, 2 );

  489. 		g.drawLine( right - 1, bottom - 4, right - 1, bottom - 4 );

  490. 	    }

  491. 

  492.             g.translate( -x, -y );

  493.         }

  494. 

  495.         g.translate( x, y );

  496. 

  497. 

  498.         //

  499.         // Paint Border

  500.         //

  501. 

  502.         if (ocean && isSelected) {

  503.             g.setColor(oceanSelectedBorderColor);

  504.         }

  505.         else {

  506.             g.setColor( darkShadow );

  507.         }

  508. 

  509. 	if ( leftToRight ) {

  510. 

  511. 	    // Paint slant

  512. 	    g.drawLine( 1, bottom - 5, 6, bottom );

  513. 

  514. 	    // Paint bottom

  515. 	    g.drawLine( 6, bottom, right, bottom );

  516. 

  517. 	    // Paint right

  518. 	    if ( tabIndex == lastIndex ) {

  519. 	        g.drawLine( right, 0, right, bottom );

  520. 	    }

  521. 

  522. 	    // Paint left

  523.             if (ocean && isSelected) {

  524.                 g.drawLine(0, 0, 0, bottom - 5);

  525.                 if ((currentRun == 0 && tabIndex != 0) ||

  526.                     (currentRun > 0 && tabIndex != tabRuns[currentRun - 1])) {

  527.                     g.setColor(darkShadow);

  528.                     g.drawLine(0, bottom - 5, 0, bottom);

  529.                 }

  530.             }

  531.             else {

  532.                 if (ocean && tabIndex == tabPane.getSelectedIndex() + 1) {

  533.                     g.setColor(oceanSelectedBorderColor);

  534.                 }

  535.                 if ( tabIndex != tabRuns[ runCount - 1 ] ) {

  536.                     g.drawLine( 0, 0, 0, bottom );

  537.                 } else {

  538.                     g.drawLine( 0, 0, 0, bottom - 6 );

  539.                 }

  540.             }

  541. 	} else {

  542. 

  543. 	    // Paint slant

  544. 	    g.drawLine( right - 1, bottom - 5, right - 6, bottom );

  545. 

  546. 	    // Paint bottom

  547. 	    g.drawLine( right - 6, bottom, 0, bottom );

  548. 

  549. 	    // Paint left

  550. 	    if ( tabIndex==lastIndex ) {

  551. 	        // last tab in run

  552. 	        g.drawLine( 0, 0, 0, bottom );

  553. 	    }

  554. 

  555. 	    // Paint right

  556.             if (ocean && tabIndex == tabPane.getSelectedIndex() + 1) {

  557.                 g.setColor(oceanSelectedBorderColor);

  558.                 g.drawLine(right, 0, right, bottom);

  559.             }

  560.             else if (ocean && isSelected) {

  561.                 g.drawLine(right, 0, right, bottom - 6);

  562.                 if (tabIndex != firstIndex) {

  563.                     g.setColor(darkShadow);

  564.                     g.drawLine(right, bottom - 5, right, bottom);

  565.                 }

  566.             }

  567. 	    else if ( tabIndex != tabRuns[ runCount - 1 ] ) {

  568. 	        // not the first tab in the last run

  569. 	        g.drawLine( right, 0, right, bottom );

  570. 	    } else {

  571. 	        // the first tab in the last run

  572. 	        g.drawLine( right, 0, right, bottom - 6 );

  573. 	    }

  574. 	}

  575. 

  576.         //

  577.         // Paint Highlight

  578.         //

  579. 

  580.         g.setColor( isSelected ? selectHighlight : highlight );

  581. 

  582. 	if ( leftToRight ) {

  583. 

  584. 	    // Paint slant

  585. 	    g.drawLine( 1, bottom - 6, 6, bottom - 1 );

  586. 

  587. 	    // Paint left

  588. 	    g.drawLine( 1, 0, 1, bottom - 6 );

  589. 

  590. 	    // paint highlight in the gap on tab behind this one

  591. 	    // on the left end (where they all line up)

  592. 	    if ( tabIndex==firstIndex && tabIndex!=tabRuns[runCount - 1] ) {

  593. 	        //  first tab in run but not first tab in last run

  594. 	        if (tabPane.getSelectedIndex()==tabRuns[currentRun+1]) {

  595. 		    // tab in front of selected tab

  596. 		    g.setColor( selectHighlight );

  597. 		}

  598. 		else {

  599. 		    // tab in front of normal tab

  600. 		    g.setColor( highlight );

  601. 		}

  602. 		g.drawLine( 1, bottom - 4, 1, bottom );

  603. 	    }

  604. 	} else {

  605. 

  606. 	    // Paint left

  607. 	    if ( tabIndex==lastIndex ) {

  608. 	        // last tab in run

  609. 	        g.drawLine( 1, 0, 1, bottom - 1 );

  610. 	    } else {

  611. 	        g.drawLine( 0, 0, 0, bottom - 1 );

  612. 	    }

  613. 	}

  614. 

  615.         g.translate( -x, -y );

  616.     }

  617. 

  618.     protected void paintRightTabBorder( int tabIndex, Graphics g, 

  619.                                         int x, int y, int w, int h,

  620.                                         int btm, int rght,

  621.                                         boolean isSelected ) {

  622.         int tabCount = tabPane.getTabCount();

  623.         int currentRun = getRunForTab( tabCount, tabIndex );

  624.         int lastIndex = lastTabInRun( tabCount, currentRun );

  625.         int firstIndex = tabRuns[ currentRun ];

  626. 

  627.         g.translate( x, y );

  628. 

  629.         int bottom = h - 1;

  630.         int right = w - 1;

  631. 

  632.         //

  633.         // Paint part of the tab above

  634.         //

  635. 

  636.         if ( tabIndex != firstIndex && tabsOpaque ) {

  637.             g.setColor( tabPane.getSelectedIndex() == tabIndex - 1 ?

  638.                         tabAreaBackground :

  639.                         getUnselectedBackgroundAt( tabIndex - 1 ) );

  640.             g.fillRect( right - 5, 0, 5, 3 );

  641.             g.fillRect( right - 2, 3, 2, 2 );

  642.         }

  643. 

  644. 

  645.         //

  646.         // Paint Highlight

  647.         //

  648. 

  649.         g.setColor( isSelected ? selectHighlight : highlight );

  650. 

  651.         // Paint slant

  652.         g.drawLine( right - 6, 1, right - 1, 6 );

  653. 

  654.         // Paint top

  655.         g.drawLine( 0, 1, right - 6, 1 );

  656. 

  657.         // Paint left

  658. 	if ( !isSelected ) {

  659. 	    g.drawLine( 0, 1, 0, bottom );

  660. 	}

  661. 

  662. 

  663.         //

  664.         // Paint Border

  665.         //

  666. 

  667.         if (ocean && isSelected) {

  668.             g.setColor(oceanSelectedBorderColor);

  669.         }

  670.         else {

  671.             g.setColor( darkShadow );

  672.         }

  673. 

  674.         // Paint bottom

  675.         if ( tabIndex == lastIndex ) {

  676.             g.drawLine( 0, bottom, right, bottom );

  677.         }

  678. 

  679.         // Paint slant

  680.         if (ocean && tabPane.getSelectedIndex() == tabIndex - 1) {

  681.             g.setColor(oceanSelectedBorderColor);

  682.         }

  683.         g.drawLine( right - 6, 0, right, 6 );

  684. 

  685.         // Paint top

  686.         g.drawLine( 0, 0, right - 6, 0 );

  687. 

  688.         // Paint right

  689.         if (ocean && isSelected) {

  690.             g.drawLine(right, 6, right, bottom);

  691.             if (tabIndex != firstIndex) {

  692.                 g.setColor(darkShadow);

  693.                 g.drawLine(right, 0, right, 5);

  694.             }

  695.         }

  696.         else if (ocean && tabPane.getSelectedIndex() == tabIndex - 1) {

  697.             g.setColor(oceanSelectedBorderColor);

  698.             g.drawLine(right, 0, right, 6);

  699.             g.setColor(darkShadow);

  700.             g.drawLine(right, 6, right, bottom);

  701.         }

  702.         else if ( tabIndex != firstIndex ) {

  703.             g.drawLine( right, 0, right, bottom );

  704.         } else {

  705.             g.drawLine( right, 6, right, bottom );

  706.         }

  707. 

  708.         g.translate( -x, -y );

  709.     }

  710. 

  711.     public void update( Graphics g, JComponent c ) {

  712. 	if ( c.isOpaque() ) {

  713. 	    g.setColor( tabAreaBackground );

  714. 	    g.fillRect( 0, 0, c.getWidth(),c.getHeight() );

  715. 	}

  716. 	paint( g, c );

  717.     }

  718. 

  719.     protected void paintTabBackground( Graphics g, int tabPlacement,

  720.                                        int tabIndex, int x, int y, int w, int h, boolean isSelected ) {

  721.         int slantWidth = h / 2;

  722.         if ( isSelected ) {

  723.             g.setColor( selectColor );

  724.         } else {

  725.             g.setColor( getUnselectedBackgroundAt( tabIndex ) );

  726.         }

  727. 

  728. 	if (MetalUtils.isLeftToRight(tabPane)) {

  729. 	    switch ( tabPlacement ) {

  730.                 case LEFT:

  731. 		    g.fillRect( x + 5, y + 1, w - 5, h - 1);

  732. 		    g.fillRect( x + 2, y + 4, 3, h - 4 );

  733. 		    break;

  734.                 case BOTTOM:

  735. 		    g.fillRect( x + 2, y, w - 2, h - 4 );

  736. 		    g.fillRect( x + 5, y + (h - 1) - 3, w - 5, 3 );

  737. 		    break;

  738.                 case RIGHT:

  739. 		    g.fillRect( x, y + 1, w - 4, h - 1);

  740. 		    g.fillRect( x + (w - 1) - 3, y + 5, 3, h - 5 );

  741. 		    break;

  742.                 case TOP:

  743.                 default:

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

  745. 		    g.fillRect( x + 2, y + 5, 2, h - 5 );

  746. 	    }

  747. 	} else {

  748. 	    switch ( tabPlacement ) {

  749.                 case LEFT:

  750. 		    g.fillRect( x + 5, y + 1, w - 5, h - 1);

  751. 		    g.fillRect( x + 2, y + 4, 3, h - 4 );

  752. 		    break;

  753.                 case BOTTOM:

  754. 		    g.fillRect( x, y, w - 5, h - 1 );

  755. 		    g.fillRect( x + (w - 1) - 4, y, 4, h - 5);

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

  757. 		    break;

  758.                 case RIGHT:

  759. 		    g.fillRect( x + 1, y + 1, w - 5, h - 1);

  760. 		    g.fillRect( x + (w - 1) - 3, y + 5, 3, h - 5 );

  761. 		    break;

  762.                 case TOP:

  763.                 default:

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

  765. 		    g.fillRect( x + (w - 1) - 3, y + 4, 3, h - 4 );

  766. 	    }

  767. 	}

  768.     }

  769. 

  770.     /**

  771.      * Overridden to do nothing for the Java L&F.

  772.      */

  773.     protected int getTabLabelShiftX( int tabPlacement, int tabIndex, boolean isSelected ) {

  774.         return 0; 

  775.     }

  776. 

  777. 

  778.     /**

  779.      * Overridden to do nothing for the Java L&F.

  780.      */

  781.     protected int getTabLabelShiftY( int tabPlacement, int tabIndex, boolean isSelected ) {

  782.         return 0; 

  783.     }

  784. 

  785. 

  786.     public void paint( Graphics g, JComponent c ) {

  787.         int tabPlacement = tabPane.getTabPlacement();

  788. 

  789.         Insets insets = c.getInsets(); Dimension size = c.getSize();

  790. 

  791.         // Paint the background for the tab area

  792.         if ( tabPane.isOpaque() ) {

  793.             Color bg = UIManager.getColor("TabbedPane.tabAreaBackground");

  794.             if (bg != null) {

  795.                 g.setColor(bg);

  796.             }

  797.             else {

  798.                 g.setColor( c.getBackground() );

  799.             }

  800.             switch ( tabPlacement ) {

  801.             case LEFT:

  802.                 g.fillRect( insets.left, insets.top, 

  803.                             calculateTabAreaWidth( tabPlacement, runCount, maxTabWidth ),

  804.                             size.height - insets.bottom - insets.top );

  805.                 break;

  806.             case BOTTOM:

  807.                 int totalTabHeight = calculateTabAreaHeight( tabPlacement, runCount, maxTabHeight );

  808.                 g.fillRect( insets.left, size.height - insets.bottom - totalTabHeight, 

  809.                             size.width - insets.left - insets.right,

  810.                             totalTabHeight );

  811.                 break;

  812.             case RIGHT:

  813.                 int totalTabWidth = calculateTabAreaWidth( tabPlacement, runCount, maxTabWidth );

  814.                 g.fillRect( size.width - insets.right - totalTabWidth,

  815.                             insets.top, totalTabWidth, 

  816.                             size.height - insets.top - insets.bottom );

  817.                 break;

  818.             case TOP:

  819.             default:

  820.                 g.fillRect( insets.left, insets.top, 

  821.                             size.width - insets.right - insets.left, 

  822.                             calculateTabAreaHeight(tabPlacement, runCount, maxTabHeight) );

  823.                 paintHighlightBelowTab();

  824.             }

  825.         }

  826. 

  827.         super.paint( g, c );

  828.     }

  829. 

  830.     protected void paintHighlightBelowTab( ) {

  831. 

  832.     }

  833. 

  834. 

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

  836.                                        Rectangle[] rects, int tabIndex, 

  837.                                        Rectangle iconRect, Rectangle textRect,

  838.                                        boolean isSelected) {

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

  840.             Rectangle tabRect = rects[tabIndex];

  841. 	    boolean lastInRun = isLastInRun( tabIndex );

  842.             g.setColor( focus );

  843.             g.translate( tabRect.x, tabRect.y );

  844.             int right = tabRect.width - 1;

  845.             int bottom = tabRect.height - 1;

  846. 	    boolean leftToRight = MetalUtils.isLeftToRight(tabPane);

  847.             switch ( tabPlacement ) {

  848.             case RIGHT:

  849.                 g.drawLine( right - 6,2 , right - 2,6 );         // slant

  850.                 g.drawLine( 1,2 , right - 6,2 );                 // top

  851.                 g.drawLine( right - 2,6 , right - 2,bottom );    // right

  852.                 g.drawLine( 1,2 , 1,bottom );                    // left

  853.                 g.drawLine( 1,bottom , right - 2,bottom );       // bottom

  854.                 break;

  855.             case BOTTOM:

  856. 	        if ( leftToRight ) {

  857. 		    g.drawLine( 2, bottom - 6, 6, bottom - 2 );   // slant

  858. 		    g.drawLine( 6, bottom - 2,

  859. 				right, bottom - 2 );              // bottom

  860. 		    g.drawLine( 2, 0, 2, bottom - 6 );            // left

  861. 		    g.drawLine( 2, 0, right, 0 );                 // top

  862. 		    g.drawLine( right, 0, right, bottom - 2 );    // right

  863. 		} else {

  864. 		    g.drawLine( right - 2, bottom - 6,

  865. 				right - 6, bottom - 2 );          // slant

  866. 		    g.drawLine( right - 2, 0,

  867. 				right - 2, bottom - 6 );          // right

  868. 		    if ( lastInRun ) {

  869. 			// last tab in run

  870. 			g.drawLine( 2, bottom - 2,

  871. 				    right - 6, bottom - 2 );      // bottom

  872. 			g.drawLine( 2, 0, right - 2, 0 );         // top

  873. 			g.drawLine( 2, 0, 2, bottom - 2 );        // left

  874. 		    } else {

  875. 			g.drawLine( 1, bottom - 2,

  876. 				    right - 6, bottom - 2 );      // bottom

  877. 			g.drawLine( 1, 0, right - 2, 0 );         // top

  878. 			g.drawLine( 1, 0, 1, bottom - 2 );        // left

  879. 		    }

  880. 		}

  881.                 break;

  882.             case LEFT:

  883.                 g.drawLine( 2, 6, 6, 2 );                         // slant

  884.                 g.drawLine( 2, 6, 2, bottom - 1);                 // left

  885.                 g.drawLine( 6, 2, right, 2 );                     // top

  886.                 g.drawLine( right, 2, right, bottom - 1 );        // right

  887.                 g.drawLine( 2, bottom - 1, 

  888.                             right, bottom - 1 );                  // bottom

  889.                 break;

  890.             case TOP:

  891.              default:

  892. 		    if ( leftToRight ) {

  893. 		        g.drawLine( 2, 6, 6, 2 );                     // slant

  894. 			g.drawLine( 2, 6, 2, bottom - 1);             // left

  895. 			g.drawLine( 6, 2, right, 2 );                 // top

  896. 			g.drawLine( right, 2, right, bottom - 1 );    // right

  897. 			g.drawLine( 2, bottom - 1,

  898. 				    right, bottom - 1 );              // bottom

  899. 		    }

  900. 		    else {

  901. 		        g.drawLine( right - 2, 6, right - 6, 2 );     // slant

  902. 			g.drawLine( right - 2, 6,

  903. 				    right - 2, bottom - 1);           // right

  904. 			if ( lastInRun ) {

  905. 			    // last tab in run

  906. 			    g.drawLine( right - 6, 2, 2, 2 );         // top

  907. 			    g.drawLine( 2, 2, 2, bottom - 1 );        // left

  908. 			    g.drawLine( right - 2, bottom - 1,

  909. 					2, bottom - 1 );              // bottom

  910. 			}

  911. 			else {

  912. 			    g.drawLine( right - 6, 2, 1, 2 );         // top

  913. 			    g.drawLine( 1, 2, 1, bottom - 1 );        // left

  914. 			    g.drawLine( right - 2, bottom - 1,

  915. 					1, bottom - 1 );              // bottom

  916. 			}

  917. 		    }

  918.             }

  919.             g.translate( -tabRect.x, -tabRect.y );

  920.         }

  921.     }

  922. 

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

  924.                                               int selectedIndex,

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

  926. 	boolean leftToRight = MetalUtils.isLeftToRight(tabPane);

  927. 	int right = x + w - 1;

  928.         Rectangle selRect = selectedIndex < 0? null :

  929. 	                       getTabBounds(selectedIndex, calcRect);

  930.         if (ocean) {

  931.             g.setColor(oceanSelectedBorderColor);

  932.         }

  933.         else {

  934.             g.setColor(selectHighlight);

  935.         }

  936. 

  937. 	// Draw unbroken line if tabs are not on TOP, OR

  938. 	// selected tab is not in run adjacent to content, OR

  939. 	// selected tab is not visible (SCROLL_TAB_LAYOUT)

  940. 	//

  941.          if (tabPlacement != TOP || selectedIndex < 0 || 

  942.             (selRect.y + selRect.height + 1 < y) ||

  943. 	    (selRect.x < x || selRect.x > x + w)) {

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

  945.             if (ocean && tabPlacement == TOP) {

  946.                 g.setColor(MetalLookAndFeel.getWhite());

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

  948.             }

  949.         } else {

  950.  	    // Break line to show visual connection to selected tab

  951. 	    boolean lastInRun = isLastInRun(selectedIndex);

  952. 

  953. 	    if ( leftToRight || lastInRun ) {

  954. 	        g.drawLine(x, y, selRect.x + 1, y);

  955. 	    } else {

  956. 	        g.drawLine(x, y, selRect.x, y);

  957. 	    }

  958. 

  959.             if (selRect.x + selRect.width < right - 1) {

  960. 	        if ( leftToRight && !lastInRun ) {

  961. 		    g.drawLine(selRect.x + selRect.width, y, right - 1, y);

  962. 		} else {

  963. 		    g.drawLine(selRect.x + selRect.width - 1, y, right - 1, y);

  964. 		}

  965.             } else {

  966. 	        g.setColor(shadow); 

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

  968.             }

  969. 

  970.             if (ocean) {

  971.                 g.setColor(MetalLookAndFeel.getWhite());

  972. 

  973.                 if ( leftToRight || lastInRun ) {

  974.                     g.drawLine(x, y + 1, selRect.x + 1, y + 1);

  975.                 } else {

  976.                     g.drawLine(x, y + 1, selRect.x, y + 1);

  977.                 }

  978. 

  979.                 if (selRect.x + selRect.width < right - 1) {

  980.                     if ( leftToRight && !lastInRun ) {

  981.                         g.drawLine(selRect.x + selRect.width, y + 1,

  982.                                    right - 1, y + 1);

  983.                     } else {

  984.                         g.drawLine(selRect.x + selRect.width - 1, y + 1,

  985.                                    right - 1, y + 1);

  986.                     }

  987.                 } else {

  988.                     g.setColor(shadow); 

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

  990.                 }

  991.             }

  992.         }

  993.     }

  994. 

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

  996.                                                 int selectedIndex,

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

  998. 	boolean leftToRight = MetalUtils.isLeftToRight(tabPane);

  999.         int bottom = y + h - 1;

  1000. 	int right = x + w - 1;

  1001.         Rectangle selRect = selectedIndex < 0? null :

  1002. 	                       getTabBounds(selectedIndex, calcRect);

  1003. 

  1004.         g.setColor(darkShadow);

  1005. 

  1006. 	// Draw unbroken line if tabs are not on BOTTOM, OR

  1007. 	// selected tab is not in run adjacent to content, OR

  1008. 	// selected tab is not visible (SCROLL_TAB_LAYOUT)

  1009. 	//

  1010.         if (tabPlacement != BOTTOM || selectedIndex < 0 ||

  1011.              (selRect.y - 1 > h) ||

  1012. 	     (selRect.x < x || selRect.x > x + w)) {

  1013.             if (ocean && tabPlacement == BOTTOM) {

  1014.                 g.setColor(oceanSelectedBorderColor);

  1015.             }

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

  1017.         } else {

  1018. 	    // Break line to show visual connection to selected tab

  1019. 	    boolean lastInRun = isLastInRun(selectedIndex);

  1020. 

  1021.             if (ocean) {

  1022.                 g.setColor(oceanSelectedBorderColor);

  1023.             }

  1024. 

  1025. 	    if ( leftToRight || lastInRun ) {

  1026. 	        g.drawLine(x, bottom, selRect.x, bottom);

  1027. 	    } else {

  1028. 	        g.drawLine(x, bottom, selRect.x - 1, bottom);

  1029. 	    }

  1030. 

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

  1032. 	        if ( leftToRight && !lastInRun ) {

  1033. 		    g.drawLine(selRect.x + selRect.width, bottom,

  1034. 			                           right, bottom);

  1035. 		} else {

  1036. 		    g.drawLine(selRect.x + selRect.width - 1, bottom,

  1037. 			                               right, bottom);

  1038. 		}

  1039.             } 

  1040.         }

  1041.     }

  1042. 

  1043.     protected void paintContentBorderLeftEdge(Graphics g, int tabPlacement,

  1044.                                               int selectedIndex,

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

  1046.         Rectangle selRect = selectedIndex < 0? null :

  1047. 	                       getTabBounds(selectedIndex, calcRect);

  1048.         if (ocean) {

  1049.             g.setColor(oceanSelectedBorderColor);

  1050.         }

  1051.         else {

  1052.             g.setColor(selectHighlight); 

  1053.         }

  1054. 

  1055. 	// Draw unbroken line if tabs are not on LEFT, OR

  1056. 	// selected tab is not in run adjacent to content, OR

  1057. 	// selected tab is not visible (SCROLL_TAB_LAYOUT)

  1058. 	//

  1059.         if (tabPlacement != LEFT || selectedIndex < 0 ||

  1060.             (selRect.x + selRect.width + 1 < x) ||

  1061. 	    (selRect.y < y || selRect.y > y + h)) {

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

  1063.             if (ocean && tabPlacement == LEFT) {

  1064.                 g.setColor(MetalLookAndFeel.getWhite());

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

  1066.             }

  1067.         } else {

  1068. 	    // Break line to show visual connection to selected tab

  1069.             g.drawLine(x, y, x, selRect.y + 1);

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

  1071. 	      g.drawLine(x, selRect.y + selRect.height + 1, 

  1072. 			 x, y+h+2);

  1073.             } 

  1074.             if (ocean) {

  1075.                 g.setColor(MetalLookAndFeel.getWhite());

  1076.                 g.drawLine(x + 1, y + 1, x + 1, selRect.y + 1);

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

  1078.                     g.drawLine(x + 1, selRect.y + selRect.height + 1, 

  1079.                                x + 1, y+h+2);

  1080.                 }

  1081.             }

  1082.         }

  1083.     }

  1084. 

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

  1086.                                                int selectedIndex,

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

  1088.         Rectangle selRect = selectedIndex < 0? null :

  1089. 	                       getTabBounds(selectedIndex, calcRect);

  1090. 

  1091.         g.setColor(darkShadow);

  1092. 	// Draw unbroken line if tabs are not on RIGHT, OR

  1093. 	// selected tab is not in run adjacent to content, OR

  1094. 	// selected tab is not visible (SCROLL_TAB_LAYOUT)

  1095. 	//

  1096.         if (tabPlacement != RIGHT || selectedIndex < 0 ||

  1097.              (selRect.x - 1 > w) ||

  1098. 	     (selRect.y < y || selRect.y > y + h)) {

  1099.             if (ocean && tabPlacement == RIGHT) {

  1100.                 g.setColor(oceanSelectedBorderColor);

  1101.             }

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

  1103.         } else {

  1104. 	    // Break line to show visual connection to selected tab

  1105.             if (ocean) {

  1106.                 g.setColor(oceanSelectedBorderColor);

  1107.             }

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

  1109. 

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

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

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

  1113.             } 

  1114.         }

  1115.     }

  1116. 

  1117.     protected int calculateMaxTabHeight( int tabPlacement ) {

  1118.         FontMetrics metrics = getFontMetrics();

  1119.         int height = metrics.getHeight();

  1120.         boolean tallerIcons = false;

  1121. 

  1122.         for ( int i = 0; i < tabPane.getTabCount(); ++i ) {

  1123.             Icon icon = tabPane.getIconAt( i );

  1124.             if ( icon != null ) {

  1125.                 if ( icon.getIconHeight() > height ) {

  1126.                     tallerIcons = true;

  1127.                     break;

  1128.                 }

  1129.             }

  1130.         }

  1131.         return super.calculateMaxTabHeight( tabPlacement ) - 

  1132.                   (tallerIcons ? (tabInsets.top + tabInsets.bottom) : 0);

  1133.     }

  1134. 

  1135. 

  1136.     protected int getTabRunOverlay( int tabPlacement ) {

  1137.         // Tab runs laid out vertically should overlap

  1138.         // at least as much as the largest slant

  1139.         if ( tabPlacement == LEFT || tabPlacement == RIGHT ) {

  1140.             int maxTabHeight = calculateMaxTabHeight(tabPlacement);

  1141.             return maxTabHeight / 2;

  1142.         }

  1143.         return 0;

  1144.     }

  1145. 

  1146.     // Don't rotate runs!

  1147.     protected boolean shouldRotateTabRuns( int tabPlacement, int selectedRun ) {

  1148.         return false;

  1149.     }

  1150. 

  1151.     // Don't pad last run

  1152.     protected boolean shouldPadTabRun( int tabPlacement, int run ) {

  1153.         return runCount > 1 && run < runCount - 1;

  1154.     }

  1155. 

  1156.     private boolean isLastInRun( int tabIndex ) {

  1157.         int run = getRunForTab( tabPane.getTabCount(), tabIndex );

  1158. 	int lastIndex = lastTabInRun( tabPane.getTabCount(), run );

  1159. 	return tabIndex == lastIndex;

  1160.     }

  1161. 

  1162.     /**

  1163.      * Returns the color to use for the specified tab.

  1164.      */

  1165.     private Color getUnselectedBackgroundAt(int index) {

  1166.         Color color = tabPane.getBackgroundAt(index);

  1167.         if (color instanceof UIResource) {

  1168.             if (unselectedBackground != null) {

  1169.                 return unselectedBackground;

  1170.             }

  1171.         }

  1172.         return color;

  1173.     }

  1174. 

  1175.     /**

  1176.      * Returns the tab index of JTabbedPane the mouse is currently over

  1177.      */

  1178.     int getRolloverTabIndex() {

  1179.     	return getRolloverTab();

  1180.     }

  1181. 

  1182.     /**

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

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

  1185.      * Instantiate it only within subclasses of MetalTabbedPaneUI.

  1186.      */  

  1187.     public class TabbedPaneLayout extends BasicTabbedPaneUI.TabbedPaneLayout {

  1188. 

  1189. 	public TabbedPaneLayout() {

  1190. 	    MetalTabbedPaneUI.this.super();

  1191. 	}

  1192. 

  1193.         protected void normalizeTabRuns( int tabPlacement, int tabCount, 

  1194.                                      int start, int max ) {

  1195.             // Only normalize the runs for top & bottom;  normalizing

  1196.             // doesn't look right for Metal's vertical tabs

  1197.             // because the last run isn't padded and it looks odd to have

  1198.             // fat tabs in the first vertical runs, but slimmer ones in the

  1199.             // last (this effect isn't noticeable for horizontal tabs).

  1200.             if ( tabPlacement == TOP || tabPlacement == BOTTOM ) {

  1201.                 super.normalizeTabRuns( tabPlacement, tabCount, start, max );

  1202.             }

  1203.         }

  1204. 

  1205.         // Don't rotate runs!

  1206.         protected void rotateTabRuns( int tabPlacement, int selectedRun ) {

  1207.         }

  1208. 

  1209.         // Don't pad selected tab

  1210.         protected void padSelectedTab( int tabPlacement, int selectedIndex ) {

  1211.         }

  1212.     }

  1213. 

  1214. }

  1215.