synthtabbedpaneui.java

来自「java jdk 1.4的源码」· Java 代码 · 共 1,888 行 · 第 1/5 页

              targetInsets.left = topInsets.bottom;
              targetInsets.bottom = topInsets.right;
              targetInsets.right = topInsets.top;
              break;
          case TOP:
          default:
              targetInsets.top = topInsets.top;
              targetInsets.left = topInsets.left;
              targetInsets.bottom = topInsets.bottom;
              targetInsets.right = topInsets.right;              
        }
    }  

   // REMIND(aim,7/29/98): This method should be made
   // protected in the next release where
   // API changes are allowed
   //
   boolean requestFocusForVisibleComponent() {
        Component visibleComponent = getVisibleComponent();
        if (visibleComponent.isFocusTraversable()) {
             visibleComponent.requestFocus();
             return true;
        } else if (visibleComponent instanceof JComponent) {
             if (((JComponent)visibleComponent).requestDefaultFocus()) {
                 return true;
             }
        }
        return false;
    }
  


    private static class RightAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(EAST);
        }
    };
    
    private static class LeftAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(WEST);
        }
    };

    private static class UpAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(NORTH);
        }
    };

    private static class DownAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(SOUTH);
        }
    };

    private static class NextAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(NEXT);
        }
    };

    private static class PreviousAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.navigateSelectedTab(PREVIOUS);
        }
    };

    private static class PageUpAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
	    int tabPlacement = pane.getTabPlacement();
	    if (tabPlacement == TOP|| tabPlacement == BOTTOM) {
		ui.navigateSelectedTab(WEST); 
	    } else {
		ui.navigateSelectedTab(NORTH);
	    }
        }
    };

    private static class PageDownAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
	    int tabPlacement = pane.getTabPlacement();
	    if (tabPlacement == TOP || tabPlacement == BOTTOM) {
		ui.navigateSelectedTab(EAST); 
	    } else {
		ui.navigateSelectedTab(SOUTH);
	    }
        }
    };

    private static class RequestFocusAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
            pane.requestFocus();
        }
    };

    private static class RequestFocusForVisibleAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = (JTabbedPane)e.getSource();
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            ui.requestFocusForVisibleComponent();
        }
    };


    /**
     * Selects a tab in the JTabbedPane based on the String of the
     * action command. The tab selected is based on the first tab that
     * has a mnemonic matching the first character of the action command.
     */
    private static class SetSelectedIndexAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
            JTabbedPane pane = (JTabbedPane)e.getSource();

            if (pane != null && (pane.getUI() instanceof SynthTabbedPaneUI)) {
                SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
                String command = e.getActionCommand();

                if (command != null && command.length() > 0) {
                    int mnemonic = (int)e.getActionCommand().charAt(0);
                    if (mnemonic >= 'a' && mnemonic <='z') {
                        mnemonic  -= ('a' - 'A');
                    }
                    Integer index = (Integer)ui.mnemonicToIndexMap.
                                 get(new Integer(mnemonic));
                    if (index != null && pane.isEnabledAt(index.intValue())) {
                        pane.setSelectedIndex(index.intValue());
                    }
                }
	    }
        }
    };

    private static class SelectFocusIndexAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
            JTabbedPane pane = (JTabbedPane)e.getSource();
            SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();
            int focusIndex = ui.getFocusIndex();
            if (focusIndex != -1) {
                pane.setSelectedIndex(focusIndex);
	    }
	}
    };

    private static class ScrollTabsForwardAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = null;
	    Object src = e.getSource();
	    if (src instanceof JTabbedPane) {
		pane = (JTabbedPane)src;
	    } else if (src instanceof ScrollableTabButton) {
	        pane = (JTabbedPane)((ScrollableTabButton)src).getParent();
	    } else {
		return; // shouldn't happen
	    }
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();		

	    if (ui.scrollableTabLayoutEnabled()) {
		ui.tabScroller.scrollForward(pane.getTabPlacement());
	    }
        }
    }

    private static class ScrollTabsBackwardAction extends AbstractAction {
        public void actionPerformed(ActionEvent e) {
	    JTabbedPane pane = null;
	    Object src = e.getSource();
	    if (src instanceof JTabbedPane) {
		pane = (JTabbedPane)src;
	    } else if (src instanceof ScrollableTabButton) {
	        pane = (JTabbedPane)((ScrollableTabButton)src).getParent();
	    } else {
		return; // shouldn't happen
	    }
	    SynthTabbedPaneUI ui = (SynthTabbedPaneUI)pane.getUI();		

	    if (ui.scrollableTabLayoutEnabled()) {
                ui.tabScroller.scrollBackward(pane.getTabPlacement());
	    }
        }
    }

    /**
     * This inner class is marked &quot;public&quot; due to a compiler bug.
     * This class should be treated as a &quot;protected&quot; inner class.
     * Instantiate it only within subclasses of SynthTabbedPaneUI.
     */  
    class TabbedPaneLayout implements LayoutManager {

        public void addLayoutComponent(String name, Component comp) {}
    
        public void removeLayoutComponent(Component comp) {}
    
        public Dimension preferredLayoutSize(Container parent) {
            return calculateSize(false);
        }

        public Dimension minimumLayoutSize(Container parent) {
            return calculateSize(true);
        }

        protected Dimension calculateSize(boolean minimum) {
            int tabPlacement = tabPane.getTabPlacement();
            Insets insets = tabPane.getInsets();
            Insets contentInsets = getContentBorderInsets(tabPlacement);
	    Insets tabAreaInsets = getTabAreaInsets(tabPlacement);

            Dimension zeroSize = new Dimension(0,0);
            int height = contentInsets.top + contentInsets.bottom; 
            int width = contentInsets.left + contentInsets.right;
            int cWidth = 0;
            int cHeight = 0;

	    // Determine minimum size required to display largest
	    // child in each dimension
	    //
            for (int i = 0; i < tabPane.getTabCount(); i++) {
                Component component = tabPane.getComponentAt(i);
		if (component != null) {
                    Dimension size = zeroSize;
                    size = minimum? component.getMinimumSize() : 
                                component.getPreferredSize();
                      
                    if (size != null) {
                        cHeight = Math.max(size.height, cHeight);
                        cWidth = Math.max(size.width, cWidth);
                    }
		}
            }
	    // Add content border insets to minimum size
            width += cWidth;
            height += cHeight;
            int tabExtent = 0;

	    // Calculate how much space the tabs will need, based on the
	    // minimum size required to display largest child + content border
	    //
            switch(tabPlacement) {
              case LEFT:
              case RIGHT:
	          height = Math.max(height, calculateMaxTabHeight(tabPlacement) + 
				             tabAreaInsets.top + tabAreaInsets.bottom);
                  tabExtent = preferredTabAreaWidth(tabPlacement, height);
                  width += tabExtent;
                  break;
              case TOP:
              case BOTTOM:
              default:
	          width = Math.max(width, calculateMaxTabWidth(tabPlacement) +
				             tabAreaInsets.left + tabAreaInsets.right);
                  tabExtent = preferredTabAreaHeight(tabPlacement, width);
                  height += tabExtent;
            }
            return new Dimension(width + insets.left + insets.right, 
                             height + insets.bottom + insets.top);

        }

        protected int preferredTabAreaHeight(int tabPlacement, int width) {
            FontMetrics metrics = getFontMetrics();
            int tabCount = tabPane.getTabCount();
            int total = 0;
            if (tabCount > 0) {
                int rows = 1;
                int x = 0;

                int maxTabHeight = calculateMaxTabHeight(tabPlacement);
        
                for (int i = 0; i < tabCount; i++) {
                    int tabWidth = calculateTabWidth(tabPlacement, i, metrics);

                    if (x != 0 && x + tabWidth > width) {
                        rows++;
                        x = 0;
                    } 
                    x += tabWidth;
                }
                total = calculateTabAreaHeight(tabPlacement, rows, maxTabHeight);
            }
            return total;
        }

        protected int preferredTabAreaWidth(int tabPlacement, int height) {
            FontMetrics metrics = getFontMetrics();
            int tabCount = tabPane.getTabCount();
            int total = 0;
            if (tabCount > 0) {
                int columns = 1;
                int y = 0;
                int fontHeight = metrics.getHeight();

                maxTabWidth = calculateMaxTabWidth(tabPlacement);
        
                for (int i = 0; i < tabCount; i++) {
                    int tabHeight = calculateTabHeight(tabPlacement, i, fontHeight);

                    if (y != 0 && y + tabHeight > height) { 
                        columns++;
                        y = 0;
                    }
                    y += tabHeight;
                }                    
                total = calculateTabAreaWidth(tabPlacement, columns, maxTabWidth);
            }
            return total;
        }

        public void layoutContainer(Container parent) {
            setMouseOverTab(-1);

            int tabPlacement = tabPane.getTabPlacement();
            Insets insets = tabPane.getInsets();
            int selectedIndex = tabPane.getSelectedIndex();
            Component visibleComponent = getVisibleComponent();

            calculateLayoutInfo();

            if (selectedIndex < 0) {
                if (visibleComponent != null) {
                    // The last tab was removed, so remove the component
                    setVisibleComponent(null);
                }
            } else {
                int cx, cy, cw, ch;
                int totalTabWidth = 0;
                int totalTabHeight = 0;
                Insets contentInsets = getContentBorderInsets(tabPlacement);

                Component selectedComponent = tabPane.getComponentAt(selectedIndex);
                boolean shouldChangeFocus = false;

                // In order to allow programs to use a single component
                // as the display for multiple tabs, we will not change
                // the visible compnent if the currently selected tab
                // has a null component.  This is a bit dicey, as we don't
                // explicitly state we support this in the spec, but since
                // programs are now depending on this, we're making it work.
                //
                if (selectedComponent != null) {
                    if (selectedComponent != visibleComponent &&
                            visibleComponent != null) {
                        if (SwingUtilities.findFocusOwner(visibleComponent) != null) {
                           shouldChangeFocus = true;
                        }
                    }                   
                    setVisibleComponent(selectedComponent);
                }

                Rectangle bounds = tabPane.getBounds();
                int numChildren = tabPane.getComponentCount();

                if (numChildren > 0) {

                    switch(tabPlacement) {
                      case LEFT:
                        totalTabWidth = calculateTabAreaWidth(tabPlacement, runCount, maxTabWidth);
                        cx = insets.left + totalTabWidth + contentInsets.left;
                        cy = insets.top + contentInsets.top;