closetabbedpaneui.java

eq跨平台查询工具源码 eq跨平台查询工具源码

    private Rectangle getCloseIconRectangle(Rectangle tabRect) {
        int iconWidth = closeIcon.getIconWidth();
        int iconHeight = closeIcon.getIconHeight();
        
        int y = tabRect.y + ((tabRect.height - iconHeight) / 2);
        int x = tabRect.x + ((int)(tabRect.width - iconWidth - 6));
        
        return new Rectangle(x, y, iconWidth, iconHeight);
    }
    
    /* This method will create and return a polygon shape for the given tab rectangle
     * which has been cropped at the specified cropline with a torn edge visual.
     * e.g. A "File" tab which has cropped been cropped just after the "i":
     *             -------------
     *             |  .....     |
     *             |  .          |
     *             |  ...  .    |
     *             |  .    .   |
     *             |  .    .    |
     *             |  .    .     |
     *             --------------
     *
     * The x, y arrays below define the pattern used to create a "torn" edge
     * segment which is repeated to fill the edge of the tab.
     * For tabs placed on TOP and BOTTOM, this righthand torn edge is created by
     * line segments which are defined by coordinates obtained by
     * subtracting xCropLen[i] from (tab.x + tab.width) and adding yCroplen[i]
     * to (tab.y).
     * For tabs placed on LEFT or RIGHT, the bottom torn edge is created by
     * subtracting xCropLen[i] from (tab.y + tab.height) and adding yCropLen[i]
     * to (tab.x).
     */
    private int xCropLen[] = {1,1,0,0,1,1,2,2};
    private int yCropLen[] = {0,3,3,6,6,9,9,12};
    private static final int CROP_SEGMENT = 12;
    
    private Polygon createCroppedTabClip(int tabPlacement, Rectangle tabRect, int cropline) {
        int rlen = 0;
        int start = 0;
        int end = 0;
        int ostart = 0;
        
        switch(tabPlacement) {
            case LEFT:
            case RIGHT:
                rlen = tabRect.width;
                start = tabRect.x;
                end = tabRect.x + tabRect.width;
                ostart = tabRect.y;
                break;
            case TOP:
            case BOTTOM:
            default:
                rlen = tabRect.height;
                start = tabRect.y;
                end = tabRect.y + tabRect.height + 1;
                ostart = tabRect.x;
        }
        
        int rcnt = rlen/CROP_SEGMENT;
        
        if (rlen%CROP_SEGMENT > 0) {
            rcnt++;
        }
        
        int npts = 2 + (rcnt*8);
        int xp[] = new int[npts];
        int yp[] = new int[npts];
        int pcnt = 0;
        
        xp[pcnt] = ostart;
        yp[pcnt++] = end;
        xp[pcnt] = ostart;
        yp[pcnt++] = start;
        for(int i = 0; i < rcnt; i++) {
            for(int j = 0; j < xCropLen.length; j++) {
                xp[pcnt] = cropline - xCropLen[j];
                yp[pcnt] = start + (i*CROP_SEGMENT) + yCropLen[j];
                if (yp[pcnt] >= end) {
                    yp[pcnt] = end;
                    pcnt++;
                    break;
                }
                pcnt++;
            }
        }
        if (tabPlacement == JTabbedPane.TOP || tabPlacement == JTabbedPane.BOTTOM) {
            return new Polygon(xp, yp, pcnt);
            
        } else { // LEFT or RIGHT
            return new Polygon(yp, xp, pcnt);
        }
    }
    
    /* If tabLayoutPolicy == SCROLL_TAB_LAYOUT, this method will paint an edge
     * indicating the tab is cropped in the viewport display
     */
    private void paintCroppedTabEdge(Graphics g, int tabPlacement, int tabIndex,
            boolean isSelected, int x, int y) {
        
        switch(tabPlacement) {
            
            case LEFT:
            case RIGHT:
                int xx = x;
                g.setColor(shadow);
                
                while(xx <= x+rects[tabIndex].width) {
                    
                    for (int i=0; i < xCropLen.length; i+=2) {
                        g.drawLine(xx+yCropLen[i], y-xCropLen[i],
                                xx+yCropLen[i+1]-1, y-xCropLen[i+1]);
                    }
                    
                    xx+=CROP_SEGMENT;
                    
                }
                
                break;
                
            case TOP:
            case BOTTOM:
            default:
                int yy = y;
                g.setColor(controlShadow);
                
                while(yy <= y+rects[tabIndex].height) {
                    
                    for (int i=0; i < xCropLen.length; i+=2) {
                        g.drawLine(x-xCropLen[i], yy+yCropLen[i],
                                x-xCropLen[i+1], yy+yCropLen[i+1]-1);
                    }
                    
                    yy+=CROP_SEGMENT;
                    
                }
                
        }
        
    }
    
    protected void layoutLabel(int tabPlacement,
            FontMetrics metrics, int tabIndex,
            String title, Icon icon,
            Rectangle tabRect, Rectangle iconRect,
            Rectangle textRect, boolean isSelected ) {
        
        textRect.x = textRect.y = iconRect.x = iconRect.y = 0;
        
        View v = getTextViewForTab(tabIndex);
        
        if (v != null) {
            tabPane.putClientProperty("html", v);
        }
        
        SwingUtilities.layoutCompoundLabel((JComponent) tabPane,
                metrics, title, icon,
                SwingUtilities.CENTER,
                SwingUtilities.LEFT,
                SwingUtilities.CENTER,
                SwingUtilities.TRAILING,
                tabRect,
                iconRect,
                textRect,
                textIconGap);
        
        tabPane.putClientProperty("html", null);
        
        int xNudge = getTabLabelShiftX(tabPlacement, tabIndex, isSelected);
        int yNudge = getTabLabelShiftY(tabPlacement, tabIndex, isSelected);
        iconRect.x += xNudge + 5;
        iconRect.y += yNudge;
        textRect.x += xNudge + 6;
        textRect.y += yNudge;
        
    }
   

    protected void paintIcon(Graphics g, int tabPlacement,
            int tabIndex, Icon icon, Rectangle iconRect,
            boolean isSelected ) {
        if (icon != null) {
            
            int y = iconRect.y - 1;
            
            if (!isSelected)
                y += 2;
            
            icon.paintIcon(tabPane, g, iconRect.x, y);
            
        }
        
    }
    
    protected void paintText(Graphics g, int tabPlacement,
            Font font, FontMetrics metrics, int tabIndex,
            String title, Rectangle textRect,
            boolean isSelected) {
        
        g.setFont(font);
        
        View v = getTextViewForTab(tabIndex);
        
        if (v != null) {
            v.paint(g, textRect); // html
        }
        
        else {  // plain text
            int mnemIndex = tabPane.getDisplayedMnemonicIndexAt(tabIndex);
            
            if (tabPane.isEnabled() && tabPane.isEnabledAt(tabIndex)) {
                g.setColor(tabPane.getForegroundAt(tabIndex));
                int y = textRect.y + metrics.getAscent()-1;
                
                if (!isSelected)
                    y+=2;
                
                BasicGraphicsUtils.drawStringUnderlineCharAt(g,
                        title, mnemIndex,
                        textRect.x, y);
                
            }
            
            else { // tab disabled
                g.setColor(tabPane.getBackgroundAt(tabIndex).brighter());
                BasicGraphicsUtils.drawStringUnderlineCharAt(g,
                        title, mnemIndex,
                        textRect.x, textRect.y + metrics.getAscent() - 1);
                g.setColor(tabPane.getBackgroundAt(tabIndex).darker());
                BasicGraphicsUtils.drawStringUnderlineCharAt(g, title, mnemIndex,
                        textRect.x - 1,
                        textRect.y + metrics.getAscent() - 1);
            }
            
        }
        
    }
    
    
    protected int getTabLabelShiftX(int tabPlacement, int tabIndex, boolean isSelected) {
        Rectangle tabRect = rects[tabIndex];
        int nudge = 0;
        switch(tabPlacement) {
            case LEFT:
                nudge = isSelected? -1 : 1;
                break;
            case RIGHT:
                nudge = isSelected? 1 : -1;
                break;
            case BOTTOM:
            case TOP:
            default:
                nudge = tabRect.width % 2;
        }
        return nudge;
    }
    
    protected int getTabLabelShiftY(int tabPlacement, int tabIndex, boolean isSelected) {
        Rectangle tabRect = rects[tabIndex];
        int nudge = 0;
        switch(tabPlacement) {
            case TOP:
            case BOTTOM:
                nudge = isSelected? 1 : -1;
                break;
            case LEFT:
            case RIGHT:
                nudge = tabRect.height % 2;
                break;
            default:
                nudge = isSelected? -1 : 1;
        }
        return nudge;
    }
    
    protected void paintFocusIndicator(Graphics g, int tabPlacement,
            Rectangle[] rects, int tabIndex,
            Rectangle iconRect, Rectangle textRect,
            boolean isSelected) {
        
        Rectangle tabRect = rects[tabIndex];
        if (tabPane.hasFocus() && isSelected) {
            int x, y, w, h;
            g.setColor(focus);
            switch(tabPlacement) {
                case LEFT:
                    x = tabRect.x + 3;
                    y = tabRect.y + 3;
                    w = tabRect.width - 5;
                    h = tabRect.height - 6;
                    break;
                case RIGHT:
                    x = tabRect.x + 2;
                    y = tabRect.y + 3;
                    w = tabRect.width - 5;
                    h = tabRect.height - 6;
                    break;
                case BOTTOM:
                    x = tabRect.x + 3;
                    y = tabRect.y + 2;
                    w = tabRect.width - 6;
                    h = tabRect.height - 5;
                    break;
                case TOP:
                default:
                    x = tabRect.x + 3;
                    y = tabRect.y + 3;
                    w = tabRect.width - 6;
                    h = tabRect.height - 5;
            }
            BasicGraphicsUtils.drawDashedRect(g, x, y, w, h);
        }
    }
    
    /**
     * this function draws the border around each tab
     * note that this function does now draw the background of the tab.
     * that is done elsewhere
     */
    protected void paintTabBorder(Graphics g, int tabPlacement,
            int tabIndex,
            int x, int y, int w, int h,
            boolean isSelected ) {

        g.setColor(lightHighlight);
        
        switch (tabPlacement) {
            case LEFT:
                g.drawLine(x+1, y+h-2, x+1, y+h-2); // bottom-left highlight
                g.drawLine(x, y+2, x, y+h-3); // left highlight
                g.drawLine(x+1, y+1, x+1, y+1); // top-left highlight
                g.drawLine(x+2, y, x+w-1, y); // top highlight
                
                g.setColor(shadow);
                g.drawLine(x+2, y+h-2, x+w-1, y+h-2); // bottom shadow
                
                g.setColor(darkShadow);
                g.drawLine(x+2, y+h-1, x+w-1, y+h-1); // bottom dark shadow
                break;
            case RIGHT:
                g.drawLine(x, y, x+w-3, y); // top highlight
                
                g.setColor(shadow);
                g.drawLine(x, y+h-2, x+w-3, y+h-2); // bottom shadow
                g.drawLine(x+w-2, y+2, x+w-2, y+h-3); // right shadow
                
                g.setColor(darkShadow);
                g.drawLine(x+w-2, y+1, x+w-2, y+1); // top-right dark shadow
                g.drawLine(x+w-2, y+h-2, x+w-2, y+h-2); // bottom-right dark shadow
                g.drawLine(x+w-1, y+2, x+w-1, y+h-3); // right dark shadow
                g.drawLine(x, y+h-1, x+w-3, y+h-1); // bottom dark shadow
                break;
            case BOTTOM:                
                g.setColor(darkShadow);
                g.drawLine(x, y, x, y+h-3); // left highlight
                g.drawLine(x+1, y+h-2, x+1, y+h-2); // bottom-left highlight
                
                g.drawLine(x+2, y+h-1, x+w-3, y+h-1); // bottom dark shadow
                g.drawLine(x+w-2, y+h-2, x+w-2, y+h-2); // bottom-right dark shadow
                g.drawLine(x+w-1, y, x+w-1, y+h-3); // right dark shadow
                break;
            case TOP:
            default:
                g.setColor(darkShadow);
                g.drawLine(x, y+2, x, y+h-2); // left side
                g.drawLine(x+1, y+1, x+1, y+1); // top-left side

                g.drawLine(x+2, y, x+w-3, y); // top side
                
                g.drawLine(x+w-2, y+1, x+w-2, y+1); // top-right side
                g.drawLine(x+w-1, y+2, x+w-1, y+h+3); // right side
        }
        
    }
    
    protected void paintTabBackground(Graphics g, int tabPlacement,
            int tabIndex,
            int x, int y, int w, int h,
            boolean isSelected ) {