/* (swing1.1.1beta2) */
//package jp.gr.java_conf.tame.swing.examples;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import jp.gr.java_conf.tame.swing.panel.*;
/**
* @version 1.0 07/09/99
*/
public class SingleRowTabbedPaneExample4 extends JPanel {
public SingleRowTabbedPaneExample4() {
setLayout(new BorderLayout());
SingleRowTabbedPane tabbedPane = new SingleRowTabbedPane(
SingleRowTabbedPane.FOUR_BUTTONS, SwingConstants.LEFT);
tabbedPane.setTabPlacement(JTabbedPane.BOTTOM);
String tabs[] = {"One", "Two", "Three", "Four", "Five",
"Six", "Seven","Eight","Nine", "Ten" };
for (int i=0;i<tabs.length;i++) {
tabbedPane.addTab(tabs[i], createPane(tabs[i]));
}
tabbedPane.setSelectedIndex(0);
add(tabbedPane, BorderLayout.CENTER);
}
private JPanel createPane(String s) {
JPanel p = new JPanel();
p.add(new JLabel(s));
return p;
}
public static void main(String[] args) {
JFrame frame = new JFrame("Four buttons Example");
frame.addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent e ) {
System.exit(0);
}
});
frame.getContentPane().add( new SingleRowTabbedPaneExample4() );
frame.setSize( 250, 100 );
frame.setVisible(true);
}
}
==============================================================
/* (swing1.1.1beta2) */
package jp.gr.java_conf.tame.swing.panel;
import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.basic.*;
import jp.gr.java_conf.tame.swing.button.StopArrowButton;
/**
* @version 1.0 07/09/99
*/
public class SingleRowTabbedPane extends JTabbedPane {
public static final String ROTATE = "Rotate";
public static final String PREVIOUS = "Previous";
public static final String NEXT = "Next";
public static final String FIRST = "First";
public static final String LEFT_SHIFT = "Left";
public static final String RIGHT_SHIFT = "Right";
public static final String LAST = "Last";
public static final int ONE_BUTTON = 1; // ROTATE ;
public static final int TWO_BUTTONS = 2; // PREVIOUS | NEXT ;
public static final int FOUR_BUTTONS = 4; // FIRST | LEFT_SHIFT | RIGHT_SHIFT | LAST ;
protected int buttonPlacement;
protected int buttonCount;
protected JButton[] tabPaneButtons;
protected Dimension buttonSize;
protected int visibleCount;
protected int visibleStartIndex;
private final int BUTTON_WIDTH = 16;
private final int BUTTON_HEIGHT = 17;
public SingleRowTabbedPane() {
this(TWO_BUTTONS, RIGHT);
//this(ONE_BUTTON, RIGHT);
//this(FOUR_BUTTONS, LEFT);
}
public SingleRowTabbedPane(int buttonCount, int buttonPlacement) {
setButtonPreferredSize(new Dimension(BUTTON_WIDTH, BUTTON_HEIGHT));
tabPaneButtons = createButtons(buttonCount);
this.buttonPlacement = buttonPlacement;
visibleStartIndex=0;
setUI(new SingleRowTabbedPaneUI());
}
public void setTabPlacement(int tabPlacement) {
if (tabPlacement == LEFT || tabPlacement == RIGHT) {
throw new IllegalArgumentException("not suported: LEFT and RIGHT");
}
super.setTabPlacement(tabPlacement);
}
public int getButtonPlacement() {
return buttonPlacement;
}
public void setButtonPreferredSize(Dimension d) {
if (d != null) {
buttonSize = d;
}
}
public Dimension getButtonPreferredSize() {
return buttonSize;
}
public JButton[] getButtons() {
return tabPaneButtons;
}
public int getButtonCount() {
return buttonCount;
}
public void insertTab(String title, Icon icon,
Component component, String tip, int index) {
if (component instanceof TabbedPaneButton) {
if (component != null) {
component.setVisible(true);
addImpl(component, null, -1);
}
return;
}
super.insertTab(title, icon, component, tip, index);
}
public boolean isVisibleTab(int index) {
if ((visibleStartIndex <= index) &&
(index < visibleStartIndex + visibleCount)) {
return true;
} else {
return false;
}
}
public int getVisibleCount() {
return visibleCount;
}
public void setVisibleCount(int visibleCount) {
if (visibleCount < 0) {
return;
}
this.visibleCount = visibleCount;
}
public int getVisibleStartIndex() {
return visibleStartIndex;
}
public void setVisibleStartIndex(int visibleStartIndex) {
if (visibleStartIndex < 0 ||
getTabCount() <= visibleStartIndex) {
return;
}
this.visibleStartIndex = visibleStartIndex;
}
protected JButton[] createButtons(int buttonCount) {
JButton[] tabPaneButtons = null;
switch (buttonCount) {
case ONE_BUTTON:
this.buttonCount = buttonCount;
tabPaneButtons = new JButton[buttonCount];
tabPaneButtons[0] = new PrevOrNextButton(EAST);
tabPaneButtons[0].setActionCommand(ROTATE);
break;
case TWO_BUTTONS:
this.buttonCount = buttonCount;
tabPaneButtons = new JButton[buttonCount];
tabPaneButtons[0] = new PrevOrNextButton(WEST);
tabPaneButtons[0].setActionCommand(PREVIOUS);
tabPaneButtons[1] = new PrevOrNextButton(EAST);
tabPaneButtons[1].setActionCommand(NEXT);
break;
case FOUR_BUTTONS:
this.buttonCount = buttonCount;
tabPaneButtons = new JButton[buttonCount];
tabPaneButtons[0] = new FirstOrLastButton(WEST);
tabPaneButtons[0].setActionCommand(FIRST);
tabPaneButtons[1] = new PrevOrNextButton(WEST);
tabPaneButtons[1].setActionCommand(LEFT_SHIFT);
tabPaneButtons[2] = new PrevOrNextButton(EAST);
tabPaneButtons[2].setActionCommand(RIGHT_SHIFT);
tabPaneButtons[3] = new FirstOrLastButton(EAST);
tabPaneButtons[3].setActionCommand(LAST);
break;
default:
}
return tabPaneButtons;
}
class PrevOrNextButton extends BasicArrowButton implements TabbedPaneButton {
public PrevOrNextButton(int direction) {
super(direction);
}
}
class FirstOrLastButton extends StopArrowButton implements TabbedPaneButton {
public FirstOrLastButton(int direction) {
super(direction);
}
}
}
============================================================
/* (swing1.1.1beta2) */
package jp.gr.java_conf.tame.swing.panel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.plaf.basic.BasicTabbedPaneUI;
import javax.swing.plaf.metal.MetalTabbedPaneUI;
/**
* @version 1.0 07/09/99
*/
public class SingleRowTabbedPaneUI extends MetalTabbedPaneUI {
protected ActionListener[] buttonListeners;
public void installUI(JComponent c) {
this.tabPane = (JTabbedPane)c;
c.setLayout(createLayoutManager());
installDefaults();
installComponents();
installListeners();
installKeyboardActions();
runCount = 1;
selectedRun = 0;
}
public void uninstallUI(JComponent c) {
uninstallComponents();
super.uninstallUI(c);
}
protected LayoutManager createLayoutManager() {
return new SingleRowTabbedLayout(tabPane);
}
protected void installComponents() {
JButton[] buttons = ((SingleRowTabbedPane)tabPane).getButtons();
for (int i=0;i<buttons.length;i++) {
tabPane.add(buttons[i]);
}
}
protected void uninstallComponents() {
JButton[] buttons = ((SingleRowTabbedPane)tabPane).getButtons();
for (int i=0;i<buttons.length;i++) {
tabPane.remove(buttons[i]);
}
}
protected void installListeners() {
super.installListeners();
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
JButton[] buttons = stabPane.getButtons();
int n = buttons.length;
buttonListeners = new ActionListener[n];
for (int i=0;i<n;i++) {
buttonListeners[i] = null;
String str = buttons[i].getActionCommand();
if (str.equals(SingleRowTabbedPane.ROTATE)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
int index = sPane.getVisibleStartIndex() + sPane.getVisibleCount();
return (index < sPane.getTabCount())? index: 0;
}
};
}
else if (str.equals(SingleRowTabbedPane.PREVIOUS)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
return getStartIndex(sPane.getVisibleStartIndex() - 1);
}
};
}
else if (str.equals(SingleRowTabbedPane.NEXT)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
return sPane.getVisibleStartIndex() + sPane.getVisibleCount();
}
};
}
else if (str.equals(SingleRowTabbedPane.FIRST)) {
buttonListeners[i] = new ShiftTabs();
}
else if (str.equals(SingleRowTabbedPane.LEFT_SHIFT)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
return sPane.getVisibleStartIndex() - 1;
}
};
}
else if (str.equals(SingleRowTabbedPane.RIGHT_SHIFT)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
return sPane.getVisibleStartIndex() + 1;
}
};
}
else if (str.equals(SingleRowTabbedPane.LAST)) {
buttonListeners[i] = new ShiftTabs() {
protected int getStartIndex() {
return getStartIndex(sPane.getTabCount() - 1);
}
};
}
buttons[i].addActionListener(buttonListeners[i]);
}
}
protected void uninstallListeners() {
super.uninstallListeners();
JButton[] buttons = ((SingleRowTabbedPane)tabPane).getButtons();
for (int i=0;i<buttons.length;i++) {
buttons[i].removeActionListener(buttonListeners[i]);
}
}
public int tabForCoordinate(JTabbedPane pane, int x, int y) {
int tabCount = tabPane.getTabCount();
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
int visibleCount = stabPane.getVisibleCount();
int visibleStartIndex = stabPane.getVisibleStartIndex();
for (int i=0,index = visibleStartIndex; i < visibleCount; i++,index++) {
if (rects[index].contains(x, y)) {
return index;
}
}
return -1;
}
public void paint(Graphics g, JComponent c) {
int selectedIndex = tabPane.getSelectedIndex();
int tabPlacement = tabPane.getTabPlacement();
int tabCount = tabPane.getTabCount();
ensureCurrentLayout();
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
int visibleCount = stabPane.getVisibleCount();
int visibleStartIndex = stabPane.getVisibleStartIndex();
Rectangle iconRect = new Rectangle(),
textRect = new Rectangle();
Rectangle clipRect = g.getClipBounds();
Insets insets = tabPane.getInsets();
tabRuns[0] = visibleStartIndex;
for (int i=0,index=visibleStartIndex; i<visibleCount; i++,index++) {
if (rects[index].intersects(clipRect)) {
paintTab(g, tabPlacement, rects, index, iconRect, textRect);
}
}
if (stabPane.isVisibleTab(selectedIndex)) {
if (rects[selectedIndex].intersects(clipRect)) {
paintTab(g, tabPlacement, rects, selectedIndex, iconRect, textRect);
}
}
paintContentBorder(g, tabPlacement, selectedIndex);
}
protected void paintContentBorderTopEdge( Graphics g,
int tabPlacement, int selectedIndex, int x, int y, int w, int h ) {
g.setColor(selectHighlight);
if (tabPlacement != TOP || selectedIndex < 0 ||
(rects[selectedIndex].y + rects[selectedIndex].height + 1 < y) ||
!((SingleRowTabbedPane)tabPane).isVisibleTab(selectedIndex) ) {
g.drawLine(x, y, x+w-2, y);
} else {
Rectangle selRect = rects[selectedIndex];
g.drawLine(x, y, selRect.x + 1, y);
if (selRect.x + selRect.width < x + w - 2) {
g.drawLine(selRect.x + selRect.width, y, x+w-2, y);
} else {
g.setColor(shadow);
g.drawLine(x+w-2, y, x+w-2, y);
}
}
}
protected void paintContentBorderBottomEdge(Graphics g,
int tabPlacement, int selectedIndex, int x, int y, int w, int h) {
g.setColor(darkShadow);
if (tabPlacement != BOTTOM || selectedIndex < 0 ||
(rects[selectedIndex].y - 1 > h) ||
!((SingleRowTabbedPane)tabPane).isVisibleTab(selectedIndex) ) {
g.drawLine(x, y+h-1, x+w-1, y+h-1);
} else {
Rectangle selRect = rects[selectedIndex];
g.drawLine(x, y+h-1, selRect.x, y+h-1);
if (selRect.x + selRect.width < x + w - 2) {
g.drawLine(selRect.x + selRect.width, y+h-1, x+w-1, y+h-1);
}
}
}
protected Insets getTabAreaInsets(int tabPlacement) {
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
Dimension d = stabPane.getButtonPreferredSize();
int n = stabPane.getButtonCount();
int buttonPlacement = stabPane.getButtonPlacement();
Insets currentInsets = new Insets(0,0,0,0);
if (tabPlacement == TOP) {
currentInsets.top = tabAreaInsets.top;
currentInsets.bottom = tabAreaInsets.bottom;
} else {
currentInsets.top = tabAreaInsets.bottom;
currentInsets.bottom = tabAreaInsets.top;
}
if (buttonPlacement == RIGHT) {
currentInsets.left = tabAreaInsets.left;
currentInsets.right = tabAreaInsets.right + n * d.width;
} else {
currentInsets.left = tabAreaInsets.left + n * d.width;
currentInsets.right = tabAreaInsets.right;
}
return currentInsets;
}
protected int lastTabInRun(int tabCount, int run) {
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
return stabPane.getVisibleStartIndex() + stabPane.getVisibleCount() -1;
}
protected void ensureCurrentLayout() {
SingleRowTabbedLayout layout = (SingleRowTabbedLayout)tabPane.getLayout();
layout.calculateLayoutInfo();
setButtonsEnabled();
}
protected void setButtonsEnabled() {
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
int visibleCount = stabPane.getVisibleCount();
int visibleStartIndex = stabPane.getVisibleStartIndex();
JButton[] buttons = stabPane.getButtons();
boolean lEnable = 0 < visibleStartIndex;
boolean rEnable = visibleStartIndex + visibleCount < tabPane.getTabCount();
for (int i=0;i<buttons.length;i++) {
boolean enable = false;
String str = buttons[i].getActionCommand();
if (str.equals(SingleRowTabbedPane.ROTATE)) {
enable = lEnable || rEnable;
}
else if (str.equals(SingleRowTabbedPane.PREVIOUS)) {
enable = lEnable;
}
else if (str.equals(SingleRowTabbedPane.NEXT)) {
enable = rEnable;
}
else if (str.equals(SingleRowTabbedPane.FIRST)) {
enable = lEnable;
}
else if (str.equals(SingleRowTabbedPane.LEFT_SHIFT)) {
enable = lEnable;
}
else if (str.equals(SingleRowTabbedPane.RIGHT_SHIFT)) {
enable = rEnable;
}
else if (str.equals(SingleRowTabbedPane.LAST)) {
enable = rEnable;
}
buttons[i].setEnabled(enable);
}
}
//
// Tab Navigation by Key
// (Not yet done)
//
protected void ensureVisibleTabAt(int index) {
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
int visibleCount = stabPane.getVisibleCount();
int visibleStartIndex = stabPane.getVisibleStartIndex();
int visibleEndIndex = visibleStartIndex + visibleCount -1;
if (visibleStartIndex < index &&
index < visibleEndIndex) {
return;
}
int selectedIndex = tabPane.getSelectedIndex();
boolean directionIsRight = (0 < index - selectedIndex)? true: false;
//if (directionIsRight) {
if (index <= visibleStartIndex) {
//System.out.println("dec");
if (visibleStartIndex == 0) return;
stabPane.setVisibleStartIndex( --visibleStartIndex );
((SingleRowTabbedLayout)tabPane.getLayout()).calculateLayoutInfo();
int count = stabPane.getVisibleCount();
int startIndex = stabPane.getVisibleStartIndex();
if (startIndex <= index &&
index <= startIndex + count-1) {
} else {
stabPane.setVisibleStartIndex( ++visibleStartIndex );
}
}
//} else {
if (visibleEndIndex <= index) {
//System.out.println("inc");
if (visibleStartIndex == visibleCount+1) return;
stabPane.setVisibleStartIndex( ++visibleStartIndex );
((SingleRowTabbedLayout)tabPane.getLayout()).calculateLayoutInfo();
int count = stabPane.getVisibleCount();
int startIndex = stabPane.getVisibleStartIndex();
if (startIndex <= index &&
index <= startIndex + count-1) {
} else {
stabPane.setVisibleStartIndex( --visibleStartIndex );
}
}
//}
int c = stabPane.getVisibleCount();
int s = stabPane.getVisibleStartIndex();
}
protected void selectNextTab(int current) {
for (int i=current+1;i<tabPane.getTabCount();i++) {
if (tabPane.isEnabledAt(i)) {
ensureVisibleTabAt(i);
tabPane.setSelectedIndex(i);
break;
}
}
}
protected void selectPreviousTab(int current) {
for (int i=current-1;0<=i;i--) {
if (tabPane.isEnabledAt(i)) {
ensureVisibleTabAt(i);
tabPane.setSelectedIndex(i);
break;
}
}
}
/* not used
protected int getPreviousTabIndex(int base) {
int tabIndex = base - 1;
return (tabIndex < 0? 0: tabIndex);
}
protected int getNextTabIndex(int base) {
int tabIndex = base + 1;
return (tabPane.getTabCount() <= tabIndex? tabIndex-1: tabIndex);
}
*/
//
// these methods exist for innerclass
//
void setMaxTabHeight(int maxTabHeight) {
this.maxTabHeight = maxTabHeight;
}
int getMaxTabHeight() {
return maxTabHeight;
}
Rectangle[] getRects() {
return rects;
}
SingleRowTabbedPane getTabbedPane() {
return (SingleRowTabbedPane)tabPane;
}
protected FontMetrics getFontMetrics() {
Font font = tabPane.getFont();
return Toolkit.getDefaultToolkit().getFontMetrics(font);
}
protected int calculateMaxTabHeight(int tabPlacement) {
return super.calculateMaxTabHeight(tabPlacement);
}
protected int calculateTabWidth(int tabPlacement, int tabIndex, FontMetrics metrics) {
return super.calculateTabWidth(tabPlacement, tabIndex, metrics);
}
protected void assureRectsCreated(int tabCount) {
super.assureRectsCreated(tabCount);
}
//
// Layout
//
class SingleRowTabbedLayout extends BasicTabbedPaneUI.TabbedPaneLayout {
JTabbedPane tabPane;
SingleRowTabbedLayout(JTabbedPane tabPane) {
this.tabPane = tabPane;
}
public void layoutContainer(Container parent) {
super.layoutContainer(parent);
if (tabPane.getComponentCount() < 1) {
return;
}
int tabPlacement = tabPane.getTabPlacement();
int maxTabHeight = calculateMaxTabHeight(tabPlacement);
Insets tabAreaInsets = getTabAreaInsets(tabPlacement);
Insets insets = tabPane.getInsets();
Rectangle bounds = tabPane.getBounds();
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
Dimension d = stabPane.getButtonPreferredSize();
JButton[] buttons = stabPane.getButtons();
int buttonPlacement = stabPane.getButtonPlacement();
int x,y;
if (tabPlacement == TOP) { // TOP
y = bounds.y + insets.top + tabAreaInsets.top;
} else { // BOTTOM
y = bounds.y + bounds.height - insets.bottom
- tabAreaInsets.bottom - maxTabHeight;
}
if (buttonPlacement == RIGHT) { // RIGHT
x = bounds.x + bounds.width - insets.right;
for (int i=buttons.length-1;0<=i;i--) {
x -= d.width;
buttons[i].setBounds(x, y, d.width, d.height);
}
} else { // LEFT
x = bounds.x + insets.left;
for (int i=0;i<buttons.length;i++) {
buttons[i].setBounds(x, y, d.width, d.height);
x += d.width;
}
}
}
public void calculateLayoutInfo() {
int tabCount = tabPane.getTabCount();
assureRectsCreated(tabCount);
calculateTabWidths(tabPane.getTabPlacement(), tabCount);
calculateTabRects(tabPane.getTabPlacement(), tabCount);
}
protected void calculateTabWidths(int tabPlacement, int tabCount) {
if (tabCount == 0) {
return;
}
FontMetrics metrics = getFontMetrics();
int fontHeight = metrics.getHeight();
int maxTabHeight = calculateMaxTabHeight(tabPlacement);
setMaxTabHeight(maxTabHeight);
Rectangle[] rects = getRects();
for (int i = 0; i < tabCount; i++) {
rects[i].width = calculateTabWidth(tabPlacement, i, metrics);
rects[i].height = maxTabHeight;
}
}
protected void calculateTabRects(int tabPlacement, int tabCount) {
if (tabCount == 0) {
return;
}
SingleRowTabbedPane stabPane = (SingleRowTabbedPane)tabPane;
Dimension size = tabPane.getSize();
Insets insets = tabPane.getInsets();
Insets tabAreaInsets = getTabAreaInsets(tabPlacement);
int selectedIndex = tabPane.getSelectedIndex();
int maxTabHeight = getMaxTabHeight();
int x = insets.left + tabAreaInsets.left;
int y;
if (tabPlacement == TOP) {
y = insets.top + tabAreaInsets.top;
} else { // BOTTOM
y = size.height - insets.bottom - tabAreaInsets.bottom - maxTabHeight;
}
int returnAt = size.width - (insets.right + tabAreaInsets.right);
Rectangle[] rects = getRects();
int visibleStartIndex = stabPane.getVisibleStartIndex();
int visibleCount = 0;
for (int i = visibleStartIndex; i < tabCount; i++) {
Rectangle rect = rects[i];
if (visibleStartIndex < i) {
rect.x = rects[i-1].x + rects[i-1].width;
} else {
rect.x = x;
}
if (rect.x + rect.width > returnAt) {
break;
} else {
visibleCount++;
rect.y = y;
}
}
stabPane.setVisibleCount(visibleCount);
stabPane.setVisibleStartIndex(visibleStartIndex);
}
}
//
// Listener
//
protected class ShiftTabs implements ActionListener {
SingleRowTabbedPane sPane;
public void actionPerformed(ActionEvent e) {
sPane = getTabbedPane();
int index = getStartIndex();
sPane.setVisibleStartIndex(index);
sPane.repaint();
}
//public abstract int getStartIndex();
protected int getStartIndex() {
return 0; // first tab
}
protected int getStartIndex(int lastIndex) {
Insets insets = sPane.getInsets();
Insets tabAreaInsets = getTabAreaInsets(sPane.getTabPlacement());
int width = sPane.getSize().width
- (insets.left + insets.right)
- (tabAreaInsets.left + tabAreaInsets.right);
int index;
Rectangle[] rects = getRects();
for (index=lastIndex;0<=index;index--) {
width -= rects[index].width;
if (width < 0) {
break;
}
}
return ++index;
}
}
}
=======================================================
/* (swing1.1.1beta2) */
package jp.gr.java_conf.tame.swing.panel;
/**
* @version 1.0 07/07/99
*/
public interface TabbedPaneButton {
}
=============================
/* (swing1.1.1beta2) */
package jp.gr.java_conf.tame.swing.button;
import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.basic.*;
/**
* @version 1.0 07/07/99
*/
public class StopArrowButton extends BasicArrowButton {
public StopArrowButton(int direction) {
super(direction);
}
public void paintTriangle(Graphics g, int x, int y, int size,
int direction, boolean isEnabled) {
super.paintTriangle(g, x, y, size, direction, isEnabled);
Color c = g.getColor();
if (isEnabled) {
g.setColor(UIManager.getColor("controlDkShadow"));
} else {
g.setColor(UIManager.getColor("controlShadow"));
}
g.translate(x, y);
size = Math.max(size, 2);
int mid = size / 2;
int h = size-1;
if (direction == WEST) {
g.drawLine(-1, mid-h, -1, mid+h);
if (!isEnabled) {
g.setColor(UIManager.getColor("controlLtHighlight"));
g.drawLine(0, mid-h+1, 0, mid-1);
g.drawLine(0, mid+2, 0, mid+h+1);
}
} else { // EAST
g.drawLine(size, mid-h, size, mid+h);
if (!isEnabled) {
g.setColor(UIManager.getColor("controlLtHighlight"));
g.drawLine(size+1, mid-h+1, size+1, mid+h+1);
}
}
g.setColor(c);
}
}