package omaTabbed;

import java.awt.*;
import java.awt.event.*;
import java.util.*;

// Referenced classes of package com.objectplanet.gui:
//            TabbedEvent, TabbedListener

public class TabbedPanel extends Panel
    implements WindowListener
{

    public static final int TOP = 0;
    public static final int BOTTOM = 1;
    public static final int LEFT = 2;
    public static final int RIGHT = 3;
    private int orientation;
    private Hashtable components;
    private Vector tabs;
    private int tabPosition[];
    private BitSet tabEnabled;
    private boolean detachable;
    private String title;
    private Font titleFont;
    private Color tabColor;
    private Hashtable tabColors;
    private Color tabLabelColor;
    private Hashtable tabLabelColors;
    private Font tabFont;
    private Vector listeners;
    private Image offscreen;
    private int tabOffset;
    private String currentTab;
    private boolean leftButtonPushed;
    private boolean rightButtonPushed;
    private Rectangle leftButtonBounds;
    private Rectangle rightButtonBounds;
    private Hashtable detachedFrames;
    private static final int BORDER = 5;
    private static final int TAB_SPACE = 12;
    private static final int TAB_V_SPACE = 9;
    private static final int ARROW_WIDTH = 10;
    private static final int ARROW_HEIGHT = 14;
    private static final int ARROW_SKIP = 20;

    public Insets getInsets()
    {
        FontMetrics fontmetrics = getFontMetrics(titleFont);
        FontMetrics fontmetrics1;
        fontmetrics1 = fontmetrics1 = getFontMetrics(tabFont);
        byte byte0 = ((byte)(TabbedEvent.evaluation ? 10 : 0));
        Insets insets = new Insets(5, 5, 5, 5);
        int i = fontmetrics1.getHeight() + 4;
        switch(orientation)
        {
        case 0: // '\0'
        default:
            if(title != null && title.trim().length() > 0)
                insets.top += Math.max(i, fontmetrics.getHeight());
            else
                insets.top += i;
            insets.bottom += byte0;
            break;

        case 1: // '\001'
            if(title != null && title.trim().length() > 0)
                insets.bottom += Math.max(i, fontmetrics.getHeight());
            else
                insets.bottom += i;
            insets.top += byte0;
            break;

        case 2: // '\002'
            if(title != null && title.length() > 0)
                insets.left += Math.max(getWidestTabWidth() + 10, fontmetrics.stringWidth(title) + 7);
            else
                insets.left += getWidestTabWidth() + 10;
            insets.bottom += byte0;
            break;

        case 3: // '\003'
            if(title != null && title.length() > 0)
                insets.right += Math.max(getWidestTabWidth() + 10, fontmetrics.stringWidth(title) + 7);
            else
                insets.right += getWidestTabWidth() + 10;
            insets.bottom += byte0;
            break;
        }
        return insets;
    }

    public boolean isDetached(String s)
    {
        if(s != null)
            return detachedFrames.containsKey(s);
        else
            return false;
    }

    public static void main(String args[])
    {
        TabbedPanel tabbedpanel = new TabbedPanel();
        tabbedpanel.add("Version", new TextArea("ObjectPlanet's TabbedPanel 1.01"));
        Frame frame = new Frame();
        frame.add("Center", tabbedpanel);
        frame.setSize(300, 200);
        frame.show();
    }

    public void windowOpened(WindowEvent windowevent)
    {
    }

    public void windowDeiconified(WindowEvent windowevent)
    {
    }

    public void windowActivated(WindowEvent windowevent)
    {
    }

    public void setTabLabelColor(Color color)
    {
        tabLabelColor = color;
        repaint();
    }

    public Color getTabLabelColor()
    {
        return tabLabelColor;
    }

    public void setTabLabelColor(String s, Color color)
    {
        if(contains(s))
            if(color != null)
                tabLabelColors.put(s, color);
            else
                tabLabelColors.remove(s);
        repaint();
    }

    public Color getTabLabelColor(String s)
    {
        if(s != null)
        {
            Color color = (Color)tabLabelColors.get(s);
            if(color != null)
                return color;
            else
                return tabLabelColor;
        } else
        {
            return getTabLabelColor();
        }
    }

    private void paintLeftTab(Graphics g, int i, int j, String s)
    {
        String s1 = s == null ? "" : s;
        Insets insets = getInsets();
        FontMetrics fontmetrics = g.getFontMetrics();
        int k = (fontmetrics.getHeight() + 9) - 1;
        int l = j + 5 + 1;
        int i1 = insets.left - j - 5 - 6;
        boolean flag = currentTab.equals(s1);
        if(flag)
        {
            i1 -= 4;
            i -= 2;
            l += 5;
            k += 4;
        }
        Color color = getTabColor(s1);
        g.setColor(color);
        g.fillRect(i1 + 1, i, l - 1, k);
        g.setColor(color.brighter());
        g.drawLine(i1 + 2, i, (i1 + l) - 1, i);
        g.drawLine(i1 + 2, i, i1, i + 2);
        g.drawLine(i1, i + 2, i1, (i + k) - 2);
        g.setColor(Color.black);
        g.drawLine(i1 + 1, (i + k) - 1, i1 + 2, i + k);
        g.drawLine(i1 + 2, i + k, (i1 + l) - 1, i + k);
        g.setColor(color.darker());
        g.drawLine(i1 + 2, (i + k) - 1, (i1 + l) - 1, (i + k) - 1);
        int j1 = (i1 + l / 2) - fontmetrics.stringWidth(s) / 2;
        int k1 = ((i + k / 2 + fontmetrics.getHeight() / 2) - fontmetrics.getDescent()) + 1;
        Color color1 = getTabLabelColor(s1);
        if(isEnabled(s1))
        {
            g.setColor(color1);
            g.drawString(s1, j1, k1);
        } else
        {
            g.setColor(color.brighter());
            g.drawString(s1, j1 + 1, k1 + 1);
            g.setColor(color.darker());
            g.drawString(s1, j1, k1);
        }
    }

    private void paintRightTab(Graphics g, int i, int j, String s)
    {
        String s1 = s == null ? "" : s;
        FontMetrics fontmetrics = g.getFontMetrics();
        Insets insets = getInsets();
        Dimension dimension = getSize();
        int k = (fontmetrics.getHeight() + 9) - 1;
        int l = j + 5 + 2;
        int i1 = ((dimension.width - insets.right) + 5) - 1;
        boolean flag = currentTab.equals(s1);
        if(flag)
        {
            i1 -= 2;
            i -= 2;
            l += 5;
            k += 4;
        }
        Color color = getTabColor(s1);
        g.setColor(color);
        g.fillRect(i1 + 1, i, l - 1, k);
        g.setColor(color.brighter());
        g.drawLine(i1 + 1, i, (i1 + l) - 2, i);
        g.setColor(Color.black);
        g.drawLine((i1 + l) - 1, i + 1, i1 + l, i + 2);
        g.drawLine(i1 + l, i + 2, i1 + l, (i + k) - 2);
        g.drawLine(i1 + l, (i + k) - 2, (i1 + l) - 2, i + k);
        g.drawLine((i1 + l) - 2, i + k, i1 + 1, i + k);
        g.setColor(color.darker());
        g.drawLine((i1 + l) - 1, i + 2, (i1 + l) - 1, (i + k) - 2);
        g.drawLine((i1 + l) - 2, (i + k) - 1, i1 + 1, (i + k) - 1);
        int j1 = (i1 + l / 2) - fontmetrics.stringWidth(s1) / 2;
        int k1 = ((i + k / 2 + fontmetrics.getHeight() / 2) - fontmetrics.getDescent()) + 1;
        if(flag)
            j1++;
        Color color1 = getTabLabelColor(s1);
        if(isEnabled(s1))
        {
            g.setColor(color1);
            g.drawString(s1, j1, k1);
        } else
        {
            g.setColor(color.brighter());
            g.drawString(s1, j1 + 1, k1 + 1);
            g.setColor(color.darker());
            g.drawString(s1, j1, k1);
        }
    }

    private String getFirstEnabledTab()
    {
        int i = tabs.size();
        for(int j = 0; j < i; j++)
        {
            String s = (String)tabs.elementAt(j);
            if(isEnabled(s))
                return s;
        }

        if(tabs.size() > 0)
        {
            return (String)tabs.elementAt(0);
        } else
        {
            currentTab = null;
            return null;
        }
    }

    public void doLayout()
    {
        Dimension dimension = getSize();
        Insets insets = getInsets();
        for(Enumeration enumeration = components.elements(); enumeration.hasMoreElements();)
        {
            Component component = (Component)enumeration.nextElement();
            if(component != null)
                if(component.getName().equals(currentTab))
                {
                    int i = dimension.width - insets.left - insets.right;
                    int j = dimension.height - insets.top - insets.bottom;
                    component.setLocation(insets.left, insets.top);
                    component.setSize(i, j);
                    component.validate();
                } else
                {
                    component.setSize(0, 0);
                }
        }

        repaint();
    }

    public Component remove(String s)
    {
        if(s == null)
            return null;
        if(isDetached(s))
            retach(s);
        Component component = (Component)components.remove(s);
        if(component != null)
        {
            super.remove(component);
            int i = tabs.indexOf(s);
            if(i >= 0)
            {
                tabs.removeElementAt(i);
                int j = tabEnabled.size();
                for(int k = i; k < j - 1; k++)
                    if(tabEnabled.get(k + 1))
                        tabEnabled.set(k);
                    else
                        tabEnabled.clear(k);

                tabEnabled.clear(j - 1);
            }
            notifyListeners(new TabbedEvent(5, this, s, component));
            if(currentTab.equals(s))
                show(getFirstEnabledTab());
        }
        repaint();
        return component;
    }

    public void retach(String s)
    {
        if(s == null)
            return;
        Frame frame = (Frame)detachedFrames.get(s);
        if(frame == null)
            return;
        Component component = null;
        try
        {
            component = frame.getComponent(0);
            if(component == null)
                return;
        }
        catch(ArrayIndexOutOfBoundsException _ex)
        {
            return;
        }
        frame.setVisible(false);
        frame.dispose();
        detachedFrames.remove(s);
        super.add(s, component);
        components.put(s, component);
        setEnabled(s, true);
        notifyListeners(new TabbedEvent(3, this, s, component));
        show(s);
    }

    public boolean isEnabled(String s)
    {
        int i = tabs.indexOf(s);
        if(i >= 0)
            return tabEnabled.get(i);
        else
            return false;
    }

    public boolean isShowing(String s)
    {
        return s != null && s.equals(currentTab);
    }

    public void setTabFont(Font font)
    {
        if(font != null)
            tabFont = font;
        else
            tabFont = getFont();
        doLayout();
    }

    public Font getTabFont()
    {
        return tabFont;
    }

    public boolean contains(String s)
    {
        return components.containsKey(s);
    }

    public String getTabName(int i)
    {
        try
        {
            return (String)tabs.elementAt(i);
        }
        catch(IndexOutOfBoundsException _ex)
        {
            return null;
        }
    }

    public void setTitleFont(Font font)
    {
        if(font != null)
            titleFont = font;
        else
            titleFont = getFont();
        doLayout();
    }

    public void windowClosed(WindowEvent windowevent)
    {
    }

    public Font getTitleFont()
    {
        return titleFont;
    }

    private void processMousePressed(MouseEvent mouseevent)
    {
        Point point = new Point(mouseevent.getX(), mouseevent.getY());
        if(leftButtonBounds.contains(point))
        {
            leftButtonPushed = true;
            repaint();
        } else
        if(rightButtonBounds.contains(point))
        {
            rightButtonPushed = true;
            repaint();
        } else
        if(checkSelection(point) != null)
        {
            String s = checkSelection(point);
            boolean flag = currentTab != null && currentTab.equals(s) && mouseevent.isMetaDown();
            if(flag && detachable)
                detach(s);
            else
                show(s);
        }
    }

    public void removeTabbedListener(TabbedListener tabbedlistener)
    {
        listeners.removeElement(tabbedlistener);
    }

    public void render(Graphics g)
    {
        Dimension dimension = getSize();
        g.setColor(getBackground());
        g.fillRect(0, 0, dimension.width, dimension.height);
        paintPanelBorder(g, dimension);
        paintTitle(g, dimension);
        paintTabs(g, dimension);
        paintArrowButtons(g, dimension);
    }

    private void paintPanelBorder(Graphics g, Dimension dimension)
    {
        Insets insets = getInsets();
        Color color = getTabColor(currentTab);
        g.setColor(color);
        switch(orientation)
        {
        case 0: // '\0'
        default:
            g.fillRect(0, insets.top - 5, dimension.width - 1, (dimension.height - 1 - insets.top) + 5);
            paintRect(g, 0, insets.top - 5, dimension.width - 1, (dimension.height - 1 - insets.top) + 5);
            break;

        case 1: // '\001'
            g.fillRect(0, 0, dimension.width - 1, (dimension.height - 1 - insets.bottom) + 5);
            paintRect(g, 0, 0, dimension.width - 1, (dimension.height - 1 - insets.bottom) + 5);
            break;

        case 2: // '\002'
            g.fillRect(insets.left - 5, 0, (dimension.width - 1 - insets.left) + 5, dimension.height - 1);
            paintRect(g, insets.left - 5, 0, (dimension.width - 1 - insets.left) + 5, dimension.height - 1);
            break;

        case 3: // '\003'
            g.fillRect(0, 0, (dimension.width - 1 - insets.right) + 5, dimension.height - 1);
            paintRect(g, 0, 0, (dimension.width - 1 - insets.right) + 5, dimension.height - 1);
            break;
        }
    }

    public void windowIconified(WindowEvent windowevent)
    {
    }

    private void paintBottomTab(Graphics g, int i, String s)
    {
        String s1 = s == null ? "" : s;
        FontMetrics fontmetrics = g.getFontMetrics();
        Dimension dimension = getSize();
        Insets insets = getInsets();
        int j = (fontmetrics.stringWidth(s1) + 12) - 1;
        int k = fontmetrics.getHeight();
        int l = k - 1;
        int i1 = (dimension.height - insets.bottom) + 5;
        boolean flag = currentTab.equals(s1);
        if(flag)
        {
            i1 -= 2;
            i -= 2;
            l += 4;
            j += 4;
        }
        Color color = getTabColor(s1);
        g.setColor(color);
        g.fillRect(i, i1, j, l + 1);
        int j1 = (i + j / 2) - fontmetrics.stringWidth(s1) / 2;
        int k1 = (((dimension.height - insets.bottom) + fontmetrics.getHeight()) - fontmetrics.getDescent()) + 5;
        if(flag)
            k1 += 2;
        Color color1 = getTabLabelColor(s1);
        if(isEnabled(s1))
        {
            g.setColor(color1);
            g.drawString(s1, j1, k1);
        } else
        {
            g.setColor(color.brighter());
            g.drawString(s1, j1 + 1, k1 + 1);
            g.setColor(color.darker());
            g.drawString(s1, j1, k1);
        }
        g.setColor(Color.black);
        g.drawLine(i + 2, i1 + l + 2, (i + j) - 2, i1 + l + 2);
        g.drawLine((i + j) - 1, i1 + l + 2, i + j, i1 + l + 1);
        if(flag)
            g.drawLine(i + j, i1 + l, i + j, i1 + 2);
        else
            g.drawLine(i + j, i1 + l, i + j, i1);
        g.setColor(color.darker());
        g.drawLine(i + 1, i1 + l + 1, (i + j) - 1, i1 + l + 1);
        if(flag)
            g.drawLine((i + j) - 1, i1 + l, (i + j) - 1, i1 + 1);
        else
            g.drawLine((i + j) - 1, i1 + l, (i + j) - 1, i1);
        boolean flag1 = needArrowButtons() && i + j > leftButtonBounds.x;
        if(flag1)
        {
            g.setColor(getBackground());
            g.fillRect(dimension.width - 20 - 6, i1, 26, l + 4);
            g.setColor(color);
            g.fillRect(dimension.width - 20 - 8, i1 + 3, 2, l - 2);
            int l1 = leftButtonBounds.x - 3;
            g.setColor(color.darker());
            g.drawLine(l1, i1, l1 - 1, i1 + (int)((double)l * 0.29999999999999999D));
            g.drawLine(l1 - 1, i1 + (int)((double)l * 0.29999999999999999D), l1, i1 + (int)((double)l * 0.59999999999999998D));
            g.drawLine(l1, i1 + (int)((double)l * 0.59999999999999998D), l1 - 1, i1 + l + 1);
            g.setColor(Color.black);
            g.drawLine(l1 + 1, i1, l1, i1 + (int)((double)l * 0.29999999999999999D));
            g.drawLine(l1, i1 + (int)((double)l * 0.29999999999999999D), l1 + 1, i1 + (int)((double)l * 0.59999999999999998D));
            g.drawLine(l1 + 1, i1 + (int)((double)l * 0.59999999999999998D), l1 - 1, i1 + l + 1);
            if(flag)
            {
                g.setColor(color.darker());
                g.drawLine(l1 + 1, i1, dimension.width - 1, i1);
                g.setColor(Color.black);
                g.drawLine(l1 + 1, i1 + 1, dimension.width - 1, i1 + 1);
            }
        }
        if(i >= 0)
        {
            g.setColor(color.brighter());
            g.drawLine(i, i1, i, i1 + l);
            g.drawLine(i, i1 + l, i + 1, i1 + l + 2);
        } else
        if(i >= -j && i < 0)
        {
            int i2 = l / 3;
            g.setColor(getBackground());
            g.fillRect(0, i1 + 2, 2, l + 2);
            g.fillRect(0, i1 + l + 2, 3, 2);
            g.setColor(color);
            g.fillRect(2, i1 + 2, 3, l - 2);
            g.setColor(color.darker());
            g.drawLine(0, i1, 2, i1 + i2);
            g.drawLine(2, i1 + i2, 0, i1 + i2 * 2);
            g.drawLine(0, i1 + i2 * 2, 3, i1 + l + 2);
            g.setColor(color.brighter());
            g.drawLine(1, i1, 3, i1 + i2);
            g.drawLine(3, i1 + i2, 1, i1 + i2 * 2);
            g.drawLine(1, i1 + i2 * 2, 4, i1 + l + 1);
        }
    }

    public Color getTabColor(String s)
    {
        if(s != null)
        {
            Color color = (Color)tabColors.get(s);
            if(color != null)
                return color;
            else
                return tabColor;
        } else
        {
            return getTabColor();
        }
    }

    public void setTabColor(Color color)
    {
        tabColor = color;
        repaint();
    }

    public Color getTabColor()
    {
        return tabColor;
    }

    public void setTabColor(String s, Color color)
    {
        if(contains(s))
            if(color != null)
                tabColors.put(s, color);
            else
                tabColors.remove(s);
        repaint();
    }

    public void setOrientation(int i)
    {
        orientation = i;
        validate();
        doLayout();
        repaint();
    }

    private void paintLeftButton(Graphics g, Rectangle rectangle)
    {
        g.setColor(getBackground());
        g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
        g.draw3DRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height, !leftButtonPushed);
        g.setColor(Color.black);
        Point point = new Point(rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2);
        point.x += leftButtonPushed ? 1 : 0;
        point.y += leftButtonPushed ? 1 : 0;
        g.drawLine(point.x + 1, point.y - 3, point.x + 1, point.y + 3);
        g.drawLine(point.x, point.y - 2, point.x, point.y + 2);
        g.drawLine(point.x - 1, point.y - 1, point.x - 1, point.y + 1);
        g.drawLine(point.x - 2, point.y, point.x - 2, point.y);
    }

    private void paintRightButton(Graphics g, Rectangle rectangle)
    {
        g.setColor(getBackground());
        g.fillRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
        g.draw3DRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height, !rightButtonPushed);
        g.setColor(Color.black);
        Point point = new Point(rectangle.x + rectangle.width / 2, rectangle.y + rectangle.height / 2);
        point.x += rightButtonPushed ? 1 : 0;
        point.y += rightButtonPushed ? 1 : 0;
        g.drawLine(point.x - 1, point.y - 3, point.x - 1, point.y + 3);
        g.drawLine(point.x, point.y - 2, point.x, point.y + 2);
        g.drawLine(point.x + 1, point.y - 1, point.x + 1, point.y + 1);
        g.drawLine(point.x + 2, point.y, point.x + 2, point.y);
    }

    public void setDetachable(boolean flag)
    {
        detachable = flag;
    }

    public int getOrientation()
    {
        return orientation;
    }

    protected void processEvent(AWTEvent awtevent)
    {
        if(awtevent instanceof MouseEvent)
            switch(awtevent.getID())
            {
            case 501:
                processMousePressed((MouseEvent)awtevent);
                break;

            case 502:
                processMouseReleased((MouseEvent)awtevent);
                break;
            }
        super.processEvent(awtevent);
    }

    private void paintTopTab(Graphics g, int i, String s)
    {
        String s1 = s == null ? "" : s;
        FontMetrics fontmetrics = g.getFontMetrics();
        Insets insets = getInsets();
        int j = (fontmetrics.stringWidth(s1) + 12) - 1;
        int k = fontmetrics.getHeight();
        int l = k + 4;
        int i1 = insets.top - 5;
        getSize();
        boolean flag = currentTab != null && currentTab.equals(s1);
        if(flag)
        {
            l += 2;
            i -= 2;
            j += 4;
        }
        Color color = getTabColor(s1);
        g.setColor(color);
        if(flag)
            g.fillRect(i + 1, (i1 - l) + 3, j - 2, l - 2);
        else
            g.fillRect(i + 1, (i1 - l) + 3, j - 2, l - 3);
        int k1 = (i + j / 2) - fontmetrics.stringWidth(s1) / 2;
        int l1 = i1 - fontmetrics.getDescent();
        if(flag)
            l1 -= 2;
        Color color1 = getTabLabelColor(s1);
        if(isEnabled(s1))
        {
            g.setColor(color1);
            g.drawString(s1, k1, l1);
        } else
        {
            g.setColor(color.brighter());
            g.drawString(s1, k1 + 1, l1 + 1);
            g.setColor(color.darker());
            g.drawString(s1, k1, l1);
        }
        g.setColor(color.brighter());
        g.drawLine(i + 2, (i1 - l) + 2, (i + j) - 2, (i1 - l) + 2);
        if(i >= 0)
        {
            g.drawLine(i, i1, i, (i1 - l) + 4);
            g.drawLine(i, (i1 - l) + 4, i + 2, (i1 - l) + 2);
        } else
        if(i > -j && i < 0)
        {
            int i2 = (insets.top - 5 - l) + 2;
            g.setColor(getBackground());
            g.fillRect(0, i2, 3, l - 2);
            g.fillRect(0, i2 + 1, 5, l - 4);
            g.setColor(color);
            g.fillRect(2, i2 + 1, 3, l - 4);
            g.setColor(color.darker());
            g.drawLine(2, i2 + 1, 0, i2 + (int)((double)l * 0.25D));
            g.drawLine(0, i2 + (int)((double)l * 0.25D), 2, i2 + (int)((double)l * 0.5D));
            g.drawLine(2, i2 + (int)((double)l * 0.5D), 0, i2 + (int)((double)l * 0.75D));
            g.setColor(color.brighter());
            g.drawLine(0, i2 + (int)((double)l * 0.75D), 0, i2 + l + 1);
            g.drawLine(4, i2, 1, i2 + (int)((double)l * 0.25D));
            g.drawLine(1, i2 + (int)((double)l * 0.25D), 3, i2 + (int)((double)l * 0.5D));
            g.drawLine(3, i2 + (int)((double)l * 0.5D), 1, i2 + (int)((double)l * 0.75D));
        }
        boolean flag1 = needArrowButtons() && i + j > leftButtonBounds.x;
        if(!flag1)
        {
            g.setColor(Color.black);
            g.drawLine((i + j) - 1, (i1 - l) + 3, i + j, (i1 - l) + 4);
            g.drawLine(i + j, (i1 - l) + 4, i + j, i1 - 1);
            g.setColor(color.darker());
            g.drawLine((i + j) - 1, (i1 - l) + 3, (i + j) - 1, i1 - 1);
        } else
        {
            i = leftButtonBounds.x - 5;
            int j1 = (insets.top - 5 - l) + 2;
            g.setColor(getBackground());
            g.fillRect(i, j1, j, l - 2);
            g.setColor(color.darker());
            g.drawLine(i, j1, i + 1, j1 + (int)((double)l * 0.25D));
            g.drawLine(i + 1, j1 + (int)((double)l * 0.25D), i, j1 + (int)((double)l * 0.5D));
            g.drawLine(i, j1 + (int)((double)l * 0.5D), i + 1, j1 + (int)((double)l * 0.75D));
            g.drawLine(i + 1, j1 + (int)((double)l * 0.75D), i, (j1 + l) - 3);
            g.setColor(Color.black);
            g.drawLine(i + 1, j1 + 1, i + 2, j1 + (int)((double)l * 0.25D));
            g.drawLine(i + 2, j1 + (int)((double)l * 0.25D), i + 1, j1 + (int)((double)l * 0.5D));
            g.drawLine(i + 1, j1 + (int)((double)l * 0.5D), i + 2, j1 + (int)((double)l * 0.75D));
            g.drawLine(i + 2, j1 + (int)((double)l * 0.75D), i + 1, (j1 + l) - 3);
        }
    }

    public Component add(String s, Component component)
    {
        if(s == null || component == null)
            return null;
        component.setName(s);
        if(isDetached(s))
        {
            Frame frame = (Frame)detachedFrames.get(s);
            if(frame != null)
            {
                frame.removeAll();
                frame.add("Center", component);
                frame.doLayout();
            }
        } else
        {
            if(components.containsKey(s))
            {
                Component component1 = (Component)components.get(s);
                remove(component1);
                int i = tabs.indexOf(s);
                if(i > 0)
                {
                    tabs.removeElementAt(i);
                    tabs.insertElementAt(s, i);
                }
            } else
            {
                tabs.addElement(s);
            }
            add(component);
            components.put(s, component);
            tabEnabled.set(tabs.indexOf(s));
            if(currentTab == null)
                currentTab = s;
            doLayout();
            repaint();
        }
        notifyListeners(new TabbedEvent(4, this, s, component));
        return component;
    }

    public void windowClosing(WindowEvent windowevent)
    {
        if(windowevent.getID() == 201)
        {
            Window window = windowevent.getWindow();
            if(window instanceof Frame)
                retach(((Frame)window).getTitle());
        }
    }

    private boolean needArrowButtons()
    {
        int i = tabs.size();
        return i > 0 && tabPosition[i - 1] > getSize().width - 2 || tabOffset > 0;
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    public void setTitle(String s)
    {
        title = s;
        doLayout();
    }

    public String getTitle()
    {
        return title;
    }

    public void addTabbedListener(TabbedListener tabbedlistener)
    {
        listeners.addElement(tabbedlistener);
    }

    private void processMouseReleased(MouseEvent mouseevent)
    {
        Point point = new Point(mouseevent.getX(), mouseevent.getY());
        if(leftButtonBounds.contains(point))
        {
            tabOffset -= 20;
            tabOffset = Math.max(tabOffset, 0);
            leftButtonPushed = false;
        } else
        if(rightButtonBounds.contains(point))
        {
            int i = components.size();
            if(i > 0 && tabPosition[i - 1] > leftButtonBounds.x)
                tabOffset += 20;
            rightButtonPushed = false;
        }
        repaint();
    }

    private int getWidestTabWidth()
    {
        int i = 0;
        FontMetrics fontmetrics = getFontMetrics(tabFont);
        if(fontmetrics != null)
        {
            for(Enumeration enumeration = tabs.elements(); enumeration.hasMoreElements();)
            {
                String s = (String)enumeration.nextElement();
                i = Math.max(i, fontmetrics.stringWidth(s));
            }

        }
        return i;
    }

    private void paintTabs(Graphics g, Dimension dimension)
    {
        if(tabs.size() == 0)
            return;
        getInsets();
        int i = 2 - tabOffset;
        int j = 2;
        int k = 12;
        FontMetrics fontmetrics = getFontMetrics(tabFont);
        if(fontmetrics != null)
            k = fontmetrics.getHeight();
        int l = 0;
        int i1 = getWidestTabWidth();
        g.setFont(tabFont);
        for(Enumeration enumeration = tabs.elements(); enumeration.hasMoreElements();)
        {
            String s = (String)enumeration.nextElement();
            switch(orientation)
            {
            case 0: // '\0'
            default:
                paintTopTab(g, i, s);
                i += fontmetrics.stringWidth(s) + 12;
                tabPosition[l] = i;
                break;

            case 1: // '\001'
                paintBottomTab(g, i, s);
                i += fontmetrics.stringWidth(s) + 12;
                tabPosition[l] = i;
                break;

            case 2: // '\002'
                paintLeftTab(g, j, i1, s);
                j += fontmetrics.getHeight() + 9;
                tabPosition[l] = j;
                break;

            case 3: // '\003'
                paintRightTab(g, j, i1, s);
                j += fontmetrics.getHeight() + 9;
                tabPosition[l] = j;
                break;
            }
            l++;
        }

        int j1 = tabs.indexOf(currentTab);
        i = 2 - tabOffset;
        j = 2;
        for(int k1 = 0; k1 < j1; k1++)
            if(orientation == 0 || orientation == 1)
                i += fontmetrics.stringWidth((String)tabs.elementAt(k1)) + 12;
            else
                j += fontmetrics.getHeight() + 9;

        switch(orientation)
        {
        case 0: // '\0'
        default:
            paintTopTab(g, i, currentTab);
            break;

        case 1: // '\001'
            paintBottomTab(g, i, currentTab);
            break;

        case 2: // '\002'
            paintLeftTab(g, j, i1, currentTab);
            break;

        case 3: // '\003'
            paintRightTab(g, j, i1, currentTab);
            break;
        }
    }

    private void paintTitle(Graphics g, Dimension dimension)
    {
        g.setFont(titleFont);
        if(title != null && title.trim().length() > 0)
        {
            Insets insets = getInsets();
            FontMetrics fontmetrics = g.getFontMetrics();
            g.setColor(getForeground());
            switch(orientation)
            {
            case 0: // '\0'
                int i = dimension.width - fontmetrics.stringWidth(title) - 5;
                g.drawString(title, i, insets.top - 5 - fontmetrics.getDescent());
                break;

            case 1: // '\001'
                int j = dimension.width - fontmetrics.stringWidth(title) - 5;
                g.drawString(title, j, ((dimension.height - insets.bottom) + 5 + fontmetrics.getHeight()) - fontmetrics.getDescent());
                break;

            case 2: // '\002'
                int k = insets.left - 5 - fontmetrics.stringWidth(title) - 5;
                g.drawString(title, k, dimension.height - fontmetrics.getDescent());
                break;

            case 3: // '\003'
                int l = (dimension.width - insets.right) + 5 + 5;
                g.drawString(title, l, dimension.height - fontmetrics.getDescent());
                break;
            }
        }
    }

    public boolean isDetachable()
    {
        return detachable;
    }

    private void paintRect(Graphics g, int i, int j, int k, int l)
    {
        Color color = getTabColor(currentTab);
        g.setColor(color.brighter());
        g.drawLine(i, j, i, j + l);
        g.drawLine(i, j, i + k, j);
        g.setColor(Color.black);
        g.drawLine(i, j + l, i + k, j + l);
        g.drawLine(i + k, j, i + k, j + l);
        g.setColor(color.darker());
        g.drawLine(i + 1, (j + l) - 1, (i + k) - 1, (j + l) - 1);
        g.drawLine((i + k) - 1, j + 1, (i + k) - 1, (j + l) - 1);
    }

    private String checkSelection(Point point)
    {
        String s = null;
        Dimension dimension = getSize();
        int i = Math.min(tabs.size(), tabPosition.length);
        int j = 0;
        Insets insets = getInsets();
        int i1 = 12;
        FontMetrics fontmetrics = getFontMetrics(tabFont);
        if(fontmetrics != null)
            i1 = fontmetrics.getHeight();
        int k;
        int l;
        switch(orientation)
        {
        case 0: // '\0'
        default:
            l = insets.top - 5;
            k = l - i1 - 5;
            break;

        case 1: // '\001'
            k = (dimension.height - insets.bottom) + 5;
            l = k + i1 + 5;
            break;

        case 2: // '\002'
            l = insets.left - 5;
            k = l - getWidestTabWidth() - 7;
            break;

        case 3: // '\003'
            k = (dimension.width - insets.right) + 5;
            l = k + getWidestTabWidth() + 7;
            break;
        }
        for(int j1 = 0; j1 < i; j1++)
        {
            if(orientation == 0 || orientation == 1)
            {
                if(point.x < j || point.x >= tabPosition[j1] || point.y <= k || point.y >= l)
                    continue;
                s = (String)tabs.elementAt(j1);
                break;
            }
            if(point.y < j || point.y >= tabPosition[j1] || point.x <= k || point.x >= l)
                continue;
            s = (String)tabs.elementAt(j1);
            break;
        }

        if(s != null && !isEnabled(s))
            s = null;
        return s;
    }

    public Component get(String s)
    {
        return (Component)components.get(s);
    }

    public TabbedPanel()
    {
        this(0);
    }

    public void windowDeactivated(WindowEvent windowevent)
    {
    }

    public TabbedPanel(int i)
    {
        setBackground(Color.lightGray);
        setLayout(null);
        orientation = i;
        tabColor = getBackground();
        tabColors = new Hashtable();
        tabLabelColor = Color.black;
        tabLabelColors = new Hashtable();
        detachable = true;
        titleFont = getFont();
        if(titleFont == null)
            titleFont = new Font("Dialog", 0, 12);
        tabFont = titleFont;
        components = new Hashtable();
        tabs = new Vector();
        tabPosition = new int[100];
        tabEnabled = new BitSet();
        leftButtonBounds = new Rectangle();
        rightButtonBounds = new Rectangle();
        listeners = new Vector();
        detachedFrames = new Hashtable();
        enableEvents(16L);
    }

    public int getComponentCount()
    {
        return tabs.size();
    }

    public final void paint(Graphics g)
    {
        Dimension dimension = getSize();
        if(offscreen == null || offscreen.getWidth(this) < dimension.width || offscreen.getHeight(this) < dimension.height)
            offscreen = createImage(dimension.width, dimension.height);
        Graphics g1 = g;
        if(offscreen != null)
            g1 = offscreen.getGraphics();
        render(g1);
        if(g1 != g)
        {
            g.drawImage(offscreen, 0, 0, this);
            g1.dispose();
        }
        if(TabbedEvent.evaluation)
            TabbedEvent.paintEvaluation(g, dimension, orientation, getInsets());
        super.paint(g);
    }

    public Component show(String s)
    {
        if(s == null || !isEnabled(s))
            return null;
        String s1 = currentTab;
        currentTab = s;
        doLayout();
        if(!s.equals(s1))
        {
            notifyListeners(new TabbedEvent(1, this, s1, get(s1)));
            notifyListeners(new TabbedEvent(0, this, s, get(s)));
        }
        return get(s);
    }

    private void paintArrowButtons(Graphics g, Dimension dimension)
    {
        int i = 0;
        int j = 0;
        Insets insets = getInsets();
        switch(orientation)
        {
        case 0: // '\0'
            i = dimension.width - 20 - 2;
            j = insets.top - 14 - 5 - 1;
            break;

        case 1: // '\001'
            i = dimension.width - 20 - 2;
            j = (dimension.height - insets.bottom) + 5;
            break;
        }
        leftButtonBounds.setBounds(i, j, 10, 14);
        rightButtonBounds.setBounds(i + 10 + 1, j, 10, 14);
        if(needArrowButtons())
        {
            paintLeftButton(g, leftButtonBounds);
            paintRightButton(g, rightButtonBounds);
        }
    }

    public void detach(String s)
    {
        if(s == null || !contains(s) || isDetached(s) || !detachable)
        {
            return;
        } else
        {
            setEnabled(s, false);
            show(getFirstEnabledTab());
            Component component = (Component)components.remove(s);
            Frame frame = new Frame(s);
            frame.setLayout(new BorderLayout());
            frame.addNotify();
            frame.add("Center", component);
            detachedFrames.put(s, frame);
            Dimension dimension = getSize();
            Insets insets = getInsets();
            Insets insets1 = frame.getInsets();
            int i = (dimension.width - insets.left - insets.right) + insets1.left + insets1.right;
            int j = (dimension.height - insets.top - insets.bottom) + insets1.top + insets1.bottom;
            frame.setSize(i, j);
            Point point = getLocationOnScreen();
            frame.setLocation(point.x + 20, point.y + 20);
            frame.setVisible(true);
            component.setVisible(true);
            notifyListeners(new TabbedEvent(2, this, s, component));
            frame.addWindowListener(this);
            return;
        }
    }

    private void notifyListeners(TabbedEvent tabbedevent)
    {
        for(Enumeration enumeration = listeners.elements(); enumeration.hasMoreElements(); ((TabbedListener)enumeration.nextElement()).tabEvent(tabbedevent));
    }

    public void setEnabled(String s, boolean flag)
    {
        int i = tabs.indexOf(s);
        if(flag && i >= 0)
            tabEnabled.set(i);
        else
        if(i >= 0)
            tabEnabled.clear(i);
        repaint();
    }
}