paneui.java

修正了jdk1.6中对托盘事件产生异常的bug.

        initPaintableTabLocations(pane);

        Insets aInsets = getTabAreaInsets(tabData.getAreaOrientation());

        Point l = getLocationInTabbedPanel(lastTab, tabData.getTabbedPanel());

        if (tabData.isHorizontalLayout()) {
          int w = aInsets.left + aInsets.right + Math.max(0, tabData.getTabAreaWidth() - l.x - lastVisibleRect.width) + EXTRA_SIZE;

          for (int i = 0; i < tabData.getTabList().size(); i++)
            w += ((Tab) tabData.getTabList().get(i)).getWidth();

          pane.setSize(w, getTabbedPanelExtraSize());
        }
        else {
          int h = aInsets.top + aInsets.bottom + Math.max(0,
                                                          tabData.getTabAreaHeight() - l.y - lastVisibleRect.height) + EXTRA_SIZE;

          for (int i = 0; i < tabData.getTabList().size(); i++)
            h += ((Tab) tabData.getTabList().get(i)).getHeight();

          pane.setSize(getTabbedPanelExtraSize(), h);
        }

        pane.doValidation();

        int index = tabData.getPreTab() == null ? 0 : tabData.getTabCount() > 1 ? 1 : 0;

        Shape originalClip = g.getClip();

        int tx = -x - (tabData.getAreaOrientation() == Direction.RIGHT ?
                       -tabData.getTabbedPanelWidth() + getTabbedPanelExtraSize() : 0);
        int ty = -y - (tabData.getAreaOrientation() == Direction.DOWN ?
                       -tabData.getTabbedPanelHeight() + getTabbedPanelExtraSize() : 0);

        Rectangle visibleRect = (Rectangle) tabData.getVisibleTabRects().get(index);
        Tab tab = (Tab) tabData.getTabList().get(index);

        if (tabData.isHorizontalLayout()) {
          tx -= (tabData.getPreTab() != null ? tab.getX() - tabData.getPreTab().getX() + visibleRect.x : visibleRect.x);
          g.clipRect(aInsets.left, 0, tabData.getTabAreaWidth(), height);
        }
        else {
          ty -= (tabData.getPreTab() != null ? tab.getY() - tabData.getPreTab().getY() + visibleRect.y : visibleRect.y);
          g.clipRect(0, aInsets.top, width, tabData.getTabAreaHeight());
        }

        applyFocusAndHover(pane, true);
        pane.paint(g, tx, ty);
        applyFocusAndHover(pane, false);

        g.setClip(originalClip);
      }
    }
  }

  private int getTabbedPanelExtraSize() {
    Insets insets = getContentInsets(tabData.getAreaOrientation(), tabData.getTabbedPanel().isTabAreaVisible());

    if (tabData.isHorizontalLayout())
      return tabData.getTabAreaHeight() + insets.top + insets.bottom + EXTRA_SIZE;
    else
      return tabData.getTabAreaWidth() + insets.left + insets.right + EXTRA_SIZE;
  }

  public void paintContentArea(TabbedPanelContentPanel p, Graphics g, int x, int y, int width, int height) {
    if (enabled) {
      if (PAINT_CONTENT_AREA) {
        tabData.initialize(p.getTabbedPanel());
        PanePainter pane = paneHandler.getPainter(tabData.getAreaOrientation());

        initTabLocations(pane);

        int tx = 0;
        int ty = 0;

        if (tabData.getTabbedPanel().hasContentArea()) {
          Point l = getLocationInTabbedPanel(p, tabData.getTabbedPanel());

          int yComp = 0;
          int xComp = 0;

          if (/* !tabData.getTabbedPanel().hasContentArea() || */(pane.getTabCount() == 0 && tabData.getTabCount() > 0)) {
            if (tabData.getAreaOrientation() == Direction.UP) {
              yComp = tabData.getTabAreaHeight();
            }
            else if (tabData.getAreaOrientation() == Direction.DOWN) {
              yComp = -tabData.getTabAreaHeight();
            }
            else if (tabData.getAreaOrientation() == Direction.LEFT) {
              xComp = tabData.getTabAreaWidth();
            }
            else {
              xComp = -tabData.getTabAreaWidth();
            }
          }

          tx = -l.x + (xComp > 0 ? xComp : 0);
          ty = -l.y + (yComp > 0 ? yComp : 0);

          int extraWidth = 0;
          int extraHeight = 0;

          if (tabAreaNotVisibleFix && !tabData.getTabbedPanel().isTabAreaVisible()) {
            extraWidth = !tabData.isHorizontalLayout() ? tabMinimumSizes[getDirectionIndex(
                tabData.getAreaOrientation())].width
                                                         - raiseds[getDirectionIndex(tabData.getAreaOrientation())]
                                                         + (tabData.getAreaOrientation() == Direction.LEFT ? areaInsets[getDirectionIndex(
                                                             Direction.LEFT)].left
                                                            : areaInsets[getDirectionIndex(Direction.RIGHT)].right) : 0;
            extraHeight = tabData.isHorizontalLayout() ? tabMinimumSizes[getDirectionIndex(
                tabData.getAreaOrientation())].height
                                                         - raiseds[getDirectionIndex(tabData.getAreaOrientation())]
                                                         + (tabData.getAreaOrientation() == Direction.UP ? areaInsets[getDirectionIndex(
                                                             Direction.UP)].top
                                                            : areaInsets[getDirectionIndex(Direction.DOWN)].bottom) : 0;
          }

          tx -= tabData.getAreaOrientation() == Direction.LEFT ? extraWidth : 0;
          ty -= tabData.getAreaOrientation() == Direction.UP ? extraHeight : 0;

          pane.setSize(tabData.getTabbedPanelSize().width - Math.abs(xComp) + extraWidth, tabData.getTabbedPanelSize()
                                                                                          .height
                                                                                          - Math.abs(yComp) + extraHeight);

          pane.doValidation();
        }
        else {
          if (tabData.isHorizontalLayout()) {
            pane.setSize(p.getWidth(), p.getHeight() + tabData.getTabAreaHeight());
          }
          else {
            pane.setSize(p.getWidth() + tabData.getTabAreaWidth(), p.getHeight());
          }

          pane.doValidation();

          if (tabData.getAreaOrientation() == Direction.UP)
            ty -= tabData.getTabAreaHeight();
          else if (tabData.getAreaOrientation() == Direction.LEFT)
            tx -= tabData.getTabAreaWidth();
        }

        pane.paint(g, tx, ty);

        tabData.reset();

        reset(pane);
      }
    }
  }

  private Component getComponent() {
    return componentCache.getComponent();
  }

  private void reset(PanePainter pane) {
    pane.removeAllTabs();
    componentCache.reset();
  }

  private Point getLocationInTabbedPanel(Component c, TabbedPanel tp) {
    Point l = SwingUtilities.convertPoint(c.getParent(), c.getLocation(), tp);
    Insets tpInsets = tp.getInsets();
    l.x -= tpInsets.left;
    l.y -= tpInsets.top;

    return l;
  }

  private void initPaintableTabLocations(PanePainter pane) {
    reset(pane);

    if (tabData.getPreTab() != null) {
      tabData.getTabList().add(0, tabData.getPreTab());
      tabData.getVisibleTabRects().add(0, new Rectangle(0, 0, 0, 0));
    }

    if (tabData.getPostTab() != null) {
      tabData.getTabList().add(tabData.getPostTab());
      tabData.getVisibleTabRects().add(new Rectangle(0, 0, 0, 0));
    }

    int size = 0;
    int selectedIndex = -1;

    for (int i = 0; i < tabData.getTabCount(); i++) {
      final Tab tab = (Tab) tabData.getTabList().get(i);

      SizeIcon icon = new SizeIcon(getInternalTabWidth(tab) - getWidthCompensate(tabData.getAreaOrientation()), getInternalTabHeight(
          tab)
                                                                                                                - getHeightCompensate(
                                                                                                                    tabData.getAreaOrientation()), isSwapWidthHeight(
                                                                                                                        tabData.getAreaOrientation()));

      pane.addTab(EMPTY_STRING, icon, getComponent());

      if (tab.isHighlighted())
        selectedIndex = pane.getTabCount() - 1;

      if (!tab.isEnabled()) {
        pane.setEnabledAt(i, false);
        pane.setDisabledIconAt(i, icon);
      }

      size += tabData.isHorizontalLayout() ? tab.getWidth() : tab.getHeight();
    }

    pane.setSelectedIndex(selectedIndex);
    pane.doValidation();
  }

  private void applyFocusAndHover(PanePainter pane, boolean active) {
    if (active) {
      for (int i = 0; i < tabData.getTabCount(); i++) {
        Tab tab = (Tab) tabData.getTabList().get(i);

        if (tab.getFocusableComponent() != null && tab.getFocusableComponent().hasFocus()) {
          pane.setMouseEntered(true);
          pane.setFocusActive(true);
          break;
        }
      }

      if (hoveredTab != null) {
        for (int i = 0; i < tabData.getTabCount(); i++) {
          Tab tab = (Tab) tabData.getTabList().get(i);

          if (tab == hoveredTab) {
            pane.setMouseEntered(true);
            pane.setHoveredTab(i);
            break;
          }
        }
      }
    }
    else {
      pane.setFocusActive(false);
      pane.setMouseEntered(false);
    }
  }

  private int getInternalTabWidth(Tab tab) {
    Direction areaOrientation = tab.getTabbedPanel().getProperties().getTabAreaOrientation();
    Insets insets = tab.isHighlighted() ? getSelectedInsets(areaOrientation) : getNormalInsets(areaOrientation);
    int width = tab.getWidth();

    width -= insets.left + insets.right;

    if (areaOrientation == Direction.LEFT || areaOrientation == Direction.RIGHT)
      width -= getSelectedRaised(areaOrientation);

    return width;
  }

  private int getInternalTabHeight(Tab tab) {
    Direction areaOrientation = tab.getTabbedPanel().getProperties().getTabAreaOrientation();
    Insets insets = tab.isHighlighted() ? getSelectedInsets(areaOrientation) : getNormalInsets(areaOrientation);
    int height = tab.getHeight();

    height -= insets.top + insets.bottom;

    if (areaOrientation == Direction.UP || areaOrientation == Direction.DOWN)
      height -= getSelectedRaised(areaOrientation);

    return height;
  }

  private void initTabLocations(PanePainter pane) {
    findPaintableTabs();

    Dimension minSize = getTabExternalMinSize(tabData.getAreaOrientation());
    Insets aInsets = getTabAreaInsets(tabData.getAreaOrientation());

    int selectedIndex = -1;

    if (tabData.getTabbedPanel().isTabAreaVisible()) {
      for (int i = 0; i < tabData.getTabCount(); i++) {
        final Tab tab = (Tab) tabData.getTabList().get(i);
        final Rectangle visibleRect = (Rectangle) tabData.getVisibleTabRects().get(i);
        Insets insets = getTabInsets(tabData.getAreaOrientation());
        int iconWidth = Math.max(-insets.left - insets.right,
                                 getInternalTabWidth(tab) - (tab.getWidth() - visibleRect.width));
        int iconHeight = Math.max(-insets.top - insets.bottom,
                                  getInternalTabHeight(tab) - (tab.getHeight() - visibleRect.height));

        Point l = getLocationInTabbedPanel(tab, tabData.getTabbedPanel());

        if ((tabData.isHorizontalLayout() && (visibleRect.width >= minSize.width || minSize.width < tabData.getTabbedPanelWidth() - l.x
                                                                                                    - aInsets.right))
            || (!tabData.isHorizontalLayout() && (visibleRect.height >= minSize.height || minSize.height < tabData.getTabbedPanelHeight()
                                                                                                           - l.y - aInsets.bottom))) {
          final int iWidth = iconWidth;
          final int iHeight = iconHeight;

          SizeIcon icon = new SizeIcon(iWidth - getWidthCompensate(tabData.getAreaOrientation()), iHeight
                                                                                                  - getHeightCompensate(
                                                                                                      tabData.getAreaOrientation()), isSwapWidthHeight(
                                                                                                          tabData.getAreaOrientation()));
          pane.addTab(EMPTY_STRING, icon, getComponent());

          if (i == tabData.getSelectedTabPainterIndex()) {
            selectedIndex = i;
          }

          if (!tab.isEnabled()) {
            pane.setEnabledAt(i, false);
            pane.setDisabledIconAt(i, icon);
          }
        }
      }
    }
    else if (tabAreaNotVisibleFix) {
      pane.addTab(EMPTY_STRING, componentCache.getComponent());
    }

    if (pane.getTabCount() > 0)
      pane.setSelectedIndex(selectedIndex);
    pane.doValidation();
  }

  private void findPaintableTabs() {
    Tab firstTab = null;
    Rectangle firstVisibleRect = null;
    Tab previousTab = null;

    int i = 0;
    boolean tabsFound = false;

    if (tabData.getTabbedPanel().isTabAreaVisible()) {
      while (i < tabData.getTabbedPanel().getTabCount()) {
        Tab tab = tabData.getTabbedPanel().getTabAt(i);
        Rectangle r = tab.getVisibleRect();

        if (i == 0) {
          firstTab = tab;
          firstVisibleRect = r;
        }

        i++;

        if (r.width > 0 && r.height > 0) {
          tabsFound = true;
          tabData.getTabList().add(tab);
          tabData.getVisibleTabRects().add(r);

          if (tabData.getTabCount() == 1)
            tabData.setPreTab(previousTab);

          if (tab.isHighlighted()) {
            tabData.setSelectedTabPainterIndex(tabData.getTabCount() - 1);
          }
        }
        else if (tabData.getTabList().size() > 0 && (r.width == 0 || r.height == 0))
          tabData.setPostTab(tab);

        if (tabsFound
            && r.x == 0
            && r.y == 0
            && ((tabData.isHorizontalLayout() && r.width < tab.getWidth()) || (!tabData.isHorizontalLayout() && r.height < tab.getHeight()))) {
          break;
        }

        previousTab = tab;
      }

      if (firstTab != null) {
        // TODO: Ugly!
        Component box = findDraggableComponentBox(firstTab);

        if (box != null) {
          if (tabData.isHorizontalLayout()) {
            tabData.setTabAreaWidth(box.getWidth());
            tabData.setTabAreaHeight(box.getParent().getHeight());
          }
          else {
            tabData.setTabAreaWidth(box.getParent().getWidth());
            tabData.setTabAreaHeight(box.getHeight());
          }
        }

        if (tabData.getTabCount() == 0) {
          tabData.getTabList().add(firstTab);
          tabData.getVisibleTabRects().add(firstVisibleRect);
        }
      }
    }
  }

  private Component findDraggableComponentBox(Component c) {
    if (c == null || c instanceof DraggableComponentBox)
      return c;

    return findDraggableComponentBox(c.getParent());
  }
}