2006-03-20 Roman Kennke <kennke@aicas.com>

	* javax/swing/plaf/metal/MetalTabbedPaneUI.java
	(TabbedPaneLayout.normalizeTabRuns): New method.
	(createLayoutManager): Return the Metal TabbedPaneLayout, not super.
	(paintTabBorder): Replaced if-else chain with switch.
	(paintTopTabBorder): Rewritten to correctly paint tab. Also support
	Ocean theme.
	(paintBottomTabBorder): Rewritten to correctly paint tab. Also support
	Ocean theme.
	(paintLeftTabBorder): Rewritten to correctly paint tab. Also support
	Ocean theme.
	(paintRightTabBorder): Rewritten to correctly paint tab. Also support
	Ocean theme.
	(paintTabBackground): Fetch background color from the TabbedPane.
	Fixed painting and improved by not using fillPolygon, and instead
	using fillRectangle. Replaced if-else chain with switch.
	(calculateMaxTabHeight): Added overridden method with FIXME.
	(getTabRunOverlay): Overridden to provide overlay for LEFT or RIGHT
	placement.
	(paintContentBorderTopEdge): Added stub with FIXME.
	(paintContentBorderBottomEdge): Added stub with FIXME.
	(paintContentBorderLeftEdge): Added stub with FIXME.
	(paintContentBorderRightEdge): Added stub with FIXME.

1 files changed, 468 insertions, 101 deletions

diff --git a/javax/swing/plaf/metal/MetalTabbedPaneUI.java b/javax/swing/plaf/metal/MetalTabbedPaneUI.java
index c6c46ffe6..18fe2a14d 100644
--- a/javax/swing/plaf/metal/MetalTabbedPaneUI.java
+++ b/javax/swing/plaf/metal/MetalTabbedPaneUI.java
@@ -101,6 +101,17 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
       // do nothing, because the selected tab does not have extra padding in 
       // the MetalLookAndFeel
     }
+
+    /**
+     * Overridden because tab runs are only normalized for TOP and BOTTOM
+     * tab placement in the Metal L&F.
+     */
+    protected void normalizeTabRuns(int tabPlacement, int tabCount, int start,
+                                    int max)
+    {
+      if (tabPlacement == TOP || tabPlacement == BOTTOM)
+        super.normalizeTabRuns(tabPlacement, tabCount, start, max);
+    }
   }
 
   /**
@@ -153,7 +164,7 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
    */
   protected LayoutManager createLayoutManager()
   {
-    return super.createLayoutManager();
+    return new TabbedPaneLayout();
   }
   
   /**
@@ -172,16 +183,24 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
   protected void paintTabBorder(Graphics g, int tabPlacement, int tabIndex, 
           int x, int y, int w, int h, boolean isSelected) 
   {
-    if (tabPlacement == TOP)
-      paintTopTabBorder(tabIndex, g, x, y, w, h, 0, 0, isSelected);
-    else if (tabPlacement == LEFT) 
-      paintLeftTabBorder(tabIndex, g, x, y, w, h, 0, 0, isSelected);
-    else if (tabPlacement == BOTTOM)
-      paintBottomTabBorder(tabIndex, g, x, y, w, h, 0, 0, isSelected);
-    else if (tabPlacement == RIGHT)
-      paintRightTabBorder(tabIndex, g, x, y, w, h, 0, 0, isSelected);
-    else 
-      throw new AssertionError("Unrecognised 'tabPlacement' argument.");
+    int bottom = y + h - 1;
+    int right = x + w - 1;
+
+    switch (tabPlacement)
+    {
+    case LEFT: 
+      paintLeftTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);
+      break;
+    case BOTTOM:
+      paintBottomTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);
+      break;
+    case  RIGHT:
+      paintRightTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);
+      break;
+    case TOP:
+    default: 
+      paintTopTabBorder(tabIndex, g, x, y, w, h, bottom, right, isSelected);
+    }
   }
 
   /**
@@ -194,35 +213,90 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
    * @param y  the y-coordinate for the tab's bounding rectangle.
    * @param w  the width for the tab's bounding rectangle.
    * @param h  the height for the tab's bounding rectangle.
-   * @param btm  ???
-   * @param rght  ???
+   * @param btm  the y coordinate of the bottom border
+   * @param rght the x coordinate of the right border
    * @param isSelected  indicates whether the tab is selected.
    */
   protected void paintTopTabBorder(int tabIndex, Graphics g, int x, int y,
       int w, int h, int btm, int rght, boolean isSelected)
   {
-    int currentRun = getRunForTab(tabPane.getTabCount(), tabIndex);
+    int tabCount = tabPane.getTabCount();
+    int currentRun = getRunForTab(tabCount, tabIndex);
+    int right = w - 1;
+    int bottom = h - 1;
+
+    // Paint gap.
     if (shouldFillGap(currentRun, tabIndex, x, y))
       {
         g.translate(x, y);
-        g.setColor(getColorForGap(currentRun, x, y));
+        g.setColor(getColorForGap(currentRun, x, y + 1));
         g.fillRect(1, 0, 5, 3);
         g.fillRect(1, 3, 2, 2);
         g.translate(-x, -y);
       }
-    
-    if (isSelected)
-    {
-      g.setColor(MetalLookAndFeel.getControlHighlight());
-      g.drawLine(x + 1, y + h, x + 1, y + 6);      
-      g.drawLine(x + 1, y + 6, x + 6, y + 1);
-      g.drawLine(x + 6, y + 1, x + w - 1, y + 1);
-    }
-    g.setColor(MetalLookAndFeel.getControlDarkShadow());
-    g.drawLine(x, y + h - 1, x, y + 6);
-    g.drawLine(x, y + 6, x + 6, y);
-    g.drawLine(x + 6, y, x + w, y);
-    g.drawLine(x + w, y, x + w, y + h - 1);
+
+    g.translate(x, y);
+
+    boolean isOcean = MetalLookAndFeel.getCurrentTheme() instanceof OceanTheme;
+    Color oceanSelectedBorder =
+      UIManager.getColor("TabbedPane.borderHightlightColor");
+    if (isOcean && isSelected)
+      g.setColor(oceanSelectedBorder);
+    else
+      g.setColor(darkShadow);
+
+    // Slant
+    g.drawLine(1, 5, 6, 0);
+    // Top.
+    g.drawLine(6, 0, right, 0);
+    // Right.
+    int lastIndex = lastTabInRun(tabCount, currentRun);
+    if (tabIndex == lastIndex)
+      g.drawLine(right, 1, right, bottom);
+    // Left.
+    int selectedIndex = tabPane.getSelectedIndex();
+    if (isOcean && tabIndex - 1 == selectedIndex
+        && currentRun == getRunForTab(tabCount, selectedIndex))
+      {
+        g.setColor(oceanSelectedBorder);
+      }
+    if (tabIndex != tabRuns[runCount - 1])
+      {
+        if (isOcean && isSelected)
+          {
+            g.drawLine(0, 6, 0, bottom);
+            g.setColor(darkShadow);
+            g.drawLine(0, 0, 0, 5);
+          }
+        else
+          {
+            g.drawLine(0, 0, 0, bottom);
+          }
+      }
+    else
+      {
+        g.drawLine(0, 6, 0, bottom);
+      }
+
+    // Paint the highlight.
+    g.setColor(isSelected ? selectHighlight : highlight);
+    // Slant.
+    g.drawLine(1, 6, 6, 1);
+    // Top.
+    g.drawLine(6, 1, right, 1);
+    // Left.
+    g.drawLine(1, 6, 1, bottom);
+    int firstIndex = tabRuns[currentRun];
+    if (tabIndex == firstIndex && tabIndex != tabRuns[runCount - 1])
+      {
+        if (tabPane.getSelectedIndex() == tabRuns[currentRun + 1])
+          g.setColor(selectHighlight);
+        else
+          g.setColor(highlight);
+        g.drawLine(1, 0, 1, 4);
+      }
+
+    g.translate(-x, -y);
   }
   
   /**
@@ -242,18 +316,115 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
   protected void paintLeftTabBorder(int tabIndex, Graphics g, int x, int y,
       int w, int h, int btm, int rght, boolean isSelected)
   {
-    if (isSelected)
-    {
-      g.setColor(MetalLookAndFeel.getControlHighlight());
-      g.drawLine(x + 1, y + h, x + 1, y + 6);      
-      g.drawLine(x + 1, y + 6, x + 6, y + 1);
-      g.drawLine(x + 6, y + 1, x + w - 1, y + 1);
-    }
-    g.setColor(MetalLookAndFeel.getControlDarkShadow());
-    g.drawLine(x, y + h, x, y + 6);
-    g.drawLine(x, y + 6, x + 6, y);
-    g.drawLine(x + 6, y, x + w - 1, y);
-    g.drawLine(x, y + h, x + w - 1, y + h);
+    g.translate(x, y);
+    int bottom = h - 1;
+    int right = w - 1;
+
+    
+    int tabCount = tabPane.getTabCount();
+    int currentRun = getRunForTab(tabCount, tabIndex);
+    int firstIndex = tabRuns[currentRun];
+
+    // Paint the part of the above tab.
+    if (tabIndex != firstIndex)
+      {
+        Color c;
+        if (tabPane.getSelectedIndex() == tabIndex - 1)
+          c = selectColor;
+        else
+          c = UIManager.getColor("TabbedPane.unselectedBackground");
+        g.setColor(c);
+        g.fillRect(2, 0, 4, 3);
+        g.drawLine(2, 3, 2, 3);
+      }
+
+    // Paint the highlight.
+    boolean isOcean = MetalLookAndFeel.getCurrentTheme() instanceof OceanTheme;
+    if (isOcean)
+      {
+        g.setColor(isSelected ? selectHighlight : MetalLookAndFeel.getWhite());
+      }
+    else
+      {
+        g.setColor(isSelected ? selectHighlight : highlight);
+      }
+    // Slant.
+    g.drawLine(1, 6, 6, 1);
+    // Left.
+    g.drawLine(1, 6, 1, bottom);
+    // Top.
+    g.drawLine(6, 1, right, 1);
+    if (tabIndex != firstIndex)
+      {
+        if (isOcean)
+          {
+            g.setColor(MetalLookAndFeel.getWhite());
+          }
+        g.drawLine(1, 0, 1, 4);
+      }
+
+    // Paint border.
+    Color oceanSelectedBorder =
+      UIManager.getColor("TabbedPane.borderHightlightColor");
+    if (isOcean && isSelected)
+      {
+        g.setColor(oceanSelectedBorder);
+      }
+    else
+      {
+        g.setColor(darkShadow);
+      }
+
+    // Slant.
+    g.drawLine(1, 5, 6, 0);
+    // Top.
+    g.drawLine(6, 0, right, 0);
+    // Bottom.
+    int lastIndex = lastTabInRun(tabCount, currentRun);
+    if (tabIndex == lastIndex)
+      {
+        g.drawLine(0, bottom, right, bottom);
+      }
+    // Left.
+    if (isOcean)
+      {
+        if (tabPane.getSelectedIndex() == tabIndex - 1)
+          {
+            g.drawLine(0, 5, 0, bottom);
+            g.setColor(oceanSelectedBorder);
+            g.drawLine(0, 0, 0, 5);
+          }
+        else if (isSelected)
+          {
+            g.drawLine(0, 5, 0, bottom);
+            if (tabIndex != 0)
+              {
+                g.setColor(darkShadow);
+                g.drawLine(0, 0, 0, 5);
+              }
+          }
+        else if (tabIndex != firstIndex)
+          {
+            g.drawLine(0, 0, 0, bottom);
+          }
+        else
+          {
+            g.drawLine(0, 6, 0, bottom);
+          }
+      }
+    else
+      {
+        if (tabIndex != firstIndex)
+          {
+            g.drawLine(0, 0, 0, bottom);
+          }
+        else
+          {
+            g.drawLine(0, 6, 0, bottom);
+          }
+      }
+
+    g.translate(-x, -y);
   }
   
   /**
@@ -273,17 +444,92 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
   protected void paintRightTabBorder(int tabIndex, Graphics g, int x, int y,
       int w, int h, int btm, int rght, boolean isSelected)
   {
-    if (isSelected)
-    {
-      g.setColor(MetalLookAndFeel.getControlHighlight());
-      g.drawLine(x, y + 1, x + w - 7, y + 1);      
-      g.drawLine(x + w - 7, y + 1, x + w - 1, y + 7);
-    }
-    g.setColor(MetalLookAndFeel.getControlDarkShadow());
-    g.drawLine(x, y, x + w - 7, y);
-    g.drawLine(x + w - 7, y, x + w - 1, y + 6);
-    g.drawLine(x + w - 1, y + 6, x + w - 1, y + h - 1);
-    g.drawLine(x + w - 1, y + h, x, y + h);
+    g.translate(x, y);
+    int bottom = h - 1;
+    int right = w - 1;
+
+    int tabCount = tabPane.getTabCount();
+    int currentRun = getRunForTab(tabCount, tabIndex);
+    int firstIndex = tabRuns[currentRun];
+
+    // Paint part of the above tab.
+    if (tabIndex != firstIndex)
+      {
+        Color c;
+        if (tabPane.getSelectedIndex() == tabIndex - 1)
+          c = UIManager.getColor("TabbedPane.tabAreaBackground");
+        else
+          c = UIManager.getColor("TabbedPane.unselectedBackground");
+        g.fillRect(right - 5, 0, 5, 3);
+        g.fillRect(right - 2, 3, 2, 2);
+      }
+
+    // Paint highlight.
+    g.setColor(isSelected ? selectHighlight : highlight);
+
+    // Slant.
+    g.drawLine(right - 6, 1, right - 1, 6);
+    // Top.
+    g.drawLine(0, 1, right - 6, 1);
+    // Left.
+    if (! isSelected)
+      {
+        g.drawLine(0, 1, 0, bottom);
+      }
+
+    // Paint border.
+    boolean isOcean = MetalLookAndFeel.getCurrentTheme() instanceof OceanTheme;
+    Color oceanSelectedBorder =
+      UIManager.getColor("TabbedPane.borderHightlightColor");
+    if (isOcean && isSelected)
+      {
+        g.setColor(oceanSelectedBorder);
+      }
+    else
+      {
+        g.setColor(darkShadow);
+      }
+
+    // Bottom.
+    int lastIndex = lastTabInRun(tabCount, currentRun);
+    if (tabIndex == lastIndex)
+      {
+        g.drawLine(0, bottom, right, bottom);
+      }
+    // Slant.
+    if (isOcean && tabPane.getSelectedIndex() == tabIndex - 1)
+      {
+        g.setColor(oceanSelectedBorder);
+      }
+    g.drawLine(right - 6, 0, right, 6);
+    // Top.
+    g.drawLine(0, 0, right - 6, 0);
+    // Right.
+    if (isOcean && isSelected)
+      {
+        g.drawLine(right, 6, right, bottom);
+        if (tabIndex != firstIndex)
+          {
+            g.setColor(darkShadow);
+            g.drawLine(right, 0, right, 5);
+          }
+      }
+    else if (isOcean && tabPane.getSelectedIndex() == tabIndex - 1)
+      {
+        g.setColor(oceanSelectedBorder);
+        g.drawLine(right, 0, right, 6);
+        g.setColor(darkShadow);
+        g.drawLine(right, 6, right, bottom);
+      }
+    else if (tabIndex != firstIndex)
+      {
+        g.drawLine(right, 0, right, bottom);
+      }
+    else
+      {
+        g.drawLine(right, 6, right, bottom);
+      }
+    g.translate(-x, -y);
   }
   
   /**
@@ -303,27 +549,94 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
   protected void paintBottomTabBorder(int tabIndex, Graphics g, int x, int y,
       int w, int h, int btm, int rght, boolean isSelected)
   {
-    int currentRun = getRunForTab(tabPane.getTabCount(), tabIndex);
+    int bottom = h - 1;
+    int right = w - 1;
+
+    int tabCount = tabPane.getTabCount();
+    int currentRun = getRunForTab(tabCount, tabIndex);
+    // Paint gap if necessary.
     if (shouldFillGap(currentRun, tabIndex, x, y))
       {
         g.translate(x, y);
         g.setColor(getColorForGap(currentRun, x, y));
-        g.fillRect(1, h - 5, 3, 5);
-        g.fillRect(4, h - 2, 2, 2);
+        g.fillRect(1, bottom - 4, 3, 5);
+        g.fillRect(4, bottom - 1, 2, 2);
         g.translate(-x, -y);
       }
-    
-    if (isSelected)
-    {
-      g.setColor(MetalLookAndFeel.getControlHighlight());
-      g.drawLine(x + 1, y, x + 1, y + h - 7);      
-      g.drawLine(x + 1, y + h - 7, x + 7, y + h - 1);
-    }
-    g.setColor(MetalLookAndFeel.getControlDarkShadow());
-    g.drawLine(x, y, x, y + h - 7);
-    g.drawLine(x, y + h - 7, x + 6, y + h - 1);
-    g.drawLine(x + 6, y + h - 1, x + w, y + h - 1);
-    g.drawLine(x + w, y + h - 1, x + w, y);
+
+    g.translate(x, y);
+
+    // Paint border.
+    boolean isOcean = MetalLookAndFeel.getCurrentTheme() instanceof OceanTheme;
+    Color oceanSelectedBorder =
+      UIManager.getColor("TabbedPane.borderHightlightColor");
+    if (isOcean && isSelected)
+      {
+        g.setColor(oceanSelectedBorder);
+      }
+    else
+      {
+        g.setColor(darkShadow);
+      }
+    // Slant.
+    g.drawLine(1, bottom - 5, 6, bottom);
+    // Bottom.
+    g.drawLine(6, bottom, right, bottom);
+    // Right.
+    int lastIndex = lastTabInRun(tabCount, currentRun);
+    if (tabIndex == lastIndex)
+      {
+        g.drawLine(right, 0, right, bottom);
+      }
+    // Left.
+    if (isOcean && isSelected)
+      {
+        g.drawLine(0, 0, 0, bottom - 5);
+        if ((currentRun == 0 && tabIndex != 0)
+            || (currentRun > 0 && tabIndex != tabRuns[currentRun - 1]))
+          {
+            g.setColor(darkShadow);
+            g.drawLine(0, bottom - 5, 0, bottom);
+          }
+      }
+    else
+      {
+        if (isOcean && tabIndex == tabPane.getSelectedIndex()+ 1)
+          {
+            g.setColor(oceanSelectedBorder);
+          }
+        if (tabIndex != tabRuns[runCount- 1])
+          {
+            g.drawLine(0, 0, 0, bottom);
+          }
+        else
+          {
+            g.drawLine(0, 0, 0, bottom - 6);
+          }
+      }
+
+    // Paint highlight.
+    g.setColor(isSelected ? selectHighlight : highlight);
+    // Slant.
+    g.drawLine(1, bottom - 6, 6, bottom - 1);
+    // Left.
+    g.drawLine(1, 0, 1, bottom - 6);
+
+    int firstIndex = tabRuns[currentRun];
+    if (tabIndex == firstIndex && tabIndex != tabRuns[runCount - 1])
+      {
+        if (tabPane.getSelectedIndex() == tabRuns[currentRun + 1])
+          {
+            g.setColor(selectHighlight);
+          }
+        else
+          {
+            g.setColor(highlight);
+          }
+        g.drawLine(1, bottom - 4, 1, bottom);
+      }
+
+    g.translate(-x, -y);
   }
 
   /**
@@ -343,42 +656,29 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
       int tabIndex, int x, int y, int w, int h, boolean isSelected)
   {
     if (isSelected)
-      g.setColor(UIManager.getColor("TabbedPane.selected"));
+      g.setColor(selectColor);
     else
-      {
-        // This is only present in the OceanTheme, so we must check if it
-        // is actually there
-        Color background = UIManager.getColor("TabbedPane.unselectedBackground");
-        if (background == null)
-          background = UIManager.getColor("TabbedPane.background");
-        g.setColor(background);
-      }
-    int[] px, py;
-    if (tabPlacement == TOP) 
-      {
-        px = new int[] {x + 6, x + w - 1, x + w -1, x + 2, x + 2};
-        py = new int[] {y + 2, y + 2, y + h - 1, y + h -1, y + 6};
-      }
-    else if (tabPlacement == LEFT)
-      {
-        px = new int[] {x + 6, x + w - 1, x + w -1, x + 2, x + 2};
-        py = new int[] {y + 2, y + 2, y + h - 1, y + h -1, y + 6};
-      }
-    else if (tabPlacement == BOTTOM)
-      {
-        px = new int[] {x + 2, x + w - 1, x + w -1, x + 8, x + 2};
-        py = new int[] {y, y, y + h - 1, y + h -1, y + h - 7};
-      }
-    else if (tabPlacement == RIGHT)
-      {
-        px = new int[] {x + 2, x + w - 7, x + w - 1, x + w - 1, x + 2};
-        py = new int[] {y + 2, y + 2, y + 7, y + h -1, y + h - 1};
-      }
-    else 
-      throw new AssertionError("Unrecognised 'tabPlacement' argument.");
-    g.fillPolygon(px, py, 5);
-    hg = g;
-    paintHighlightBelowTab();
+      g.setColor(tabPane.getBackgroundAt(tabIndex));
+
+    switch (tabPlacement)
+    {
+      case LEFT:
+        g.fillRect(x + 5, y + 1, w - 5, h - 1);
+        g.fillRect(x + 2, y + 4, 3, h - 4);
+        break;
+      case BOTTOM:
+        g.fillRect(x + 2, y, w - 2, h - 3);
+        g.fillRect(x + 5, y + h - 4, w - 5, 3);
+        break;
+      case RIGHT:
+        g.fillRect(x, y + 1, w - 4, h - 1);
+        g.fillRect(x + w - 4, y + 5, 3, h - 5);
+        break;
+      case TOP:
+      default:
+        g.fillRect(x + 4, y + 2, w - 4, h - 2);
+        g.fillRect(x + 2, y + 5, 2, h - 5);
+    }
   }
   
   /**
@@ -487,4 +787,71 @@ public class MetalTabbedPaneUI extends BasicTabbedPaneUI
     // false because tab runs are not rotated in the MetalLookAndFeel
     return false;
   }
+
+  protected int calculateMaxTabHeight(int tabPlacement)
+  {
+    // FIXME: Why is this overridden?
+    return super.calculateMaxTabHeight(tabPlacement);
+  }
+
+  /**
+   * Returns the amount of overlay among the tabs. In
+   * the Metal L&F the overlay for LEFT and RIGHT placement
+   * is half of the maxTabHeight. For TOP and BOTTOM placement
+   * the tabs do not overlay.
+   *
+   * @param tabPlacement the placement
+   *
+   * @return the amount of overlay among the tabs
+   */
+  protected int getTabRunOverlay(int tabPlacement)
+  {
+    int overlay = 0;
+    if (tabPlacement == LEFT || tabPlacement == RIGHT)
+      {
+        int maxHeight = calculateMaxTabHeight(tabPlacement);
+        overlay = maxTabHeight / 2;
+      }
+    return overlay;
+  }
+
+  /**
+   * Paints the upper edge of the content border.
+   */
+  protected void paintContentBorderTopEdge(Graphics g, int tabPlacement,
+                                           int selectedIndex, int x, int y,
+                                           int w, int h)
+  {
+    // FIXME: Implement me.
+  }
+
+  /**
+   * Paints the lower edge of the content border.
+   */
+  protected void paintContentBorderBottomEdge(Graphics g, int tabPlacement,
+                                              int selectedIndex, int x, int y,
+                                              int w, int h)
+  {
+    // FIXME: Implement me.
+  }
+
+  /**
+   * Paints the left edge of the content border.
+   */
+  protected void paintContentBorderLeftEdge(Graphics g, int tabPlacement,
+                                            int selectedIndex, int x, int y,
+                                            int w, int h)
+  {
+    // FIXME: Implement me.
+  }
+
+  /**
+   * Paints the right edge of the content border.
+   */
+  protected void paintContentBorderRightEdge(Graphics g, int tabPlacement,
+                                             int selectedIndex, int x, int y,
+                                             int w, int h)
+  {
+    // FIXME: Implement me.
+  }
 }