synthtreeui.java

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

	    lineX = tree.getWidth() - offset - insets.right;
	}
	int clipLeft = clipBounds.x;
	int clipRight = clipBounds.x + (clipBounds.width - 1);

	if (lineX >= clipLeft && lineX <= clipRight) {
	    int clipTop = clipBounds.y;
	    int clipBottom = clipBounds.y + clipBounds.height;
	    Rectangle parentBounds = getPathBounds(tree, path);
	    Rectangle lastChildBounds = getPathBounds(tree,
						     getLastChildPath(path));
	    int       top;

	    if (parentBounds == null) {
		top = Math.max(insets.top, clipTop);
	    }
	    else {
		top = Math.max(parentBounds.y + parentBounds.height, clipTop);
            }
	    if (depth == 0 && !tree.isRootVisible()) {
		TreeModel     model = tree.getModel();
                Object        root = model.getRoot();

                if (model.getChildCount(root) > 0) {
                    parentBounds = getPathBounds(tree, path.
				  pathByAddingChild(model.getChild(root, 0)));
                    if (parentBounds != null) {
                        top = Math.max(insets.top, parentBounds.y +
                                       parentBounds.height / 2);
                    }
		}
	    }

	    int bottom = Math.min(lastChildBounds.y +
				  (lastChildBounds.height / 2), clipBottom);

            if (top < bottom) {
                SynthGraphics engine = context.getStyle().
                                               getSynthGraphics(context);

                g.setColor(context.getStyle().getColor(context,
                                                       ColorType.FOREGROUND));
                engine.drawLine(context, "Tree.verticalLine", g, lineX, top,
                                lineX, bottom);
            }
	}
    }

    /**
     * Paints the expand (toggle) part of a row. The receiver should
     * NOT modify <code>clipBounds</code>, or <code>insets</code>.
     */
    protected void paintExpandControl(SynthContext context, Graphics g,
                                    Rectangle clipBounds, Insets insets,
                                    Rectangle bounds, TreePath path,
                                    int row, boolean isExpanded,
                                    boolean hasBeenExpanded,
                                    boolean isLeaf) {
	Object       value = path.getLastPathComponent();

	// Draw icons if not a leaf and either hasn't been loaded,
	// or the model child count is > 0.
	if (!isLeaf && (!hasBeenExpanded ||
			tree.getModel().getChildCount(value) > 0)) {
	    int middleXOfKnob;

	    if (leftToRight) {
	        middleXOfKnob = bounds.x - getTrailingControlOffset() + 1;
	    }
	    else {
	        middleXOfKnob = bounds.x + bounds.width +
                                         getTrailingControlOffset() - 1;
	    }
	    int middleYOfKnob = bounds.y + (bounds.height / 2);

	    if (isExpanded) {
		Icon expandedIcon = getExpandedIcon();

		if (expandedIcon != null) {
                    paintIconCenteredAt(context, tree, g, expandedIcon,
                                        middleXOfKnob, middleYOfKnob);
                }
	    }
	    else {
		Icon collapsedIcon = getCollapsedIcon();

		if (collapsedIcon != null) {
                    paintIconCenteredAt(context, tree, g, collapsedIcon,
                                        middleXOfKnob, middleYOfKnob);
                }
	    }
	}
    }

    /**
     * Paints the renderer part of a row. The receiver should
     * NOT modify <code>clipBounds</code>, or <code>insets</code>.
     */
    protected void paintRow(TreeCellRenderer renderer,
               DefaultTreeCellRenderer dtcr, SynthContext treeContext,
               SynthContext cellContext, Graphics g, Rectangle clipBounds,
               Insets insets, Rectangle bounds, Rectangle rowBounds,
               TreePath path, int row, boolean isExpanded,
               boolean hasBeenExpanded, boolean isLeaf) {
	// Don't paint the renderer if editing this row.
        boolean selected = tree.isRowSelected(row);

        if (selected) {
            cellContext.setComponentState(ENABLED | SELECTED);
        }
        else {
            cellContext.setComponentState(ENABLED);
        }
        if (dtcr != null && (dtcr.getBorderSelectionColor() instanceof
                             UIResource)) {
            dtcr.setBorderSelectionColor(style.getColor(
                                             cellContext, ColorType.FOCUS));
        }
        SynthLookAndFeel.updateSubregion(cellContext, g, rowBounds);
	if (getEditingRow() == row) {
	    return;
        }

	int leadIndex;

	if (tree.hasFocus()) {
	    leadIndex = getLeadSelectionRow();
	}
	else {
	    leadIndex = -1;
        }

	Component component = renderer.getTreeCellRendererComponent(
                         tree, path.getLastPathComponent(),
                         selected, isExpanded, isLeaf, row,
                         (leadIndex == row));
	
	rendererPane.paintComponent(g, component, tree, bounds.x, bounds.y,
				    bounds.width, bounds.height, true);	
    }

    /**
     * Returns true if the expand (toggle) control should be drawn for
     * the specified row.
     */
    private boolean shouldPaintExpandControl(TreePath path, int row,
                                             boolean isExpanded,
                                             boolean hasBeenExpanded,
                                             boolean isLeaf) {
	if (isLeaf) {
	    return false;
        }

	int              depth = path.getPathCount() - 1;

	if ((depth == 0 || (depth == 1 && !tree.isRootVisible())) &&
                           !tree.getShowsRootHandles()) {
	    return false;
        }
	return true;
    }

    //
    // Generic painting methods
    //

    /**
     * Paints the Icon centered at the specified location.
     */
    private void paintIconCenteredAt(SynthContext context, Component c,
                                     Graphics graphics, Icon icon,
                                     int x, int y) {
        int w = SynthIcon.getIconWidth(icon, context);
        int h = SynthIcon.getIconHeight(icon, context);
	SynthIcon.paintIcon(icon, context, graphics, x - w/2, y - h/2, w, h);
    }

    //
    // Various local methods
    //

    /**
     * Resets the selection model. The appropriate listener are installed
     * on the model.
     */
    private void selectionModelChanged(TreeSelectionModel oldModel,
                                    TreeSelectionModel newModel) {
	completeEditing();
        if (newModel != null) {
            if (treeSelectionListener != null) {
                newModel.removeTreeSelectionListener
		               (treeSelectionListener);
            }
        }
	if (newModel != null) {
	    if (treeSelectionListener != null) {
		newModel.addTreeSelectionListener
		                   (treeSelectionListener);
            }
	    if (treeState != null) {
		treeState.setSelectionModel(newModel);
            }
	}
	else if (treeState != null) {
	    treeState.setSelectionModel(null);
        }
	if (tree != null) {
	    tree.repaint();
        }
    }

    public void propertyChange(PropertyChangeEvent event) {
        if (event.getSource() == tree) {
            String              changeName = event.getPropertyName();

            if (SynthLookAndFeel.shouldUpdateStyle(event)) {
                fetchStyle((JTree)event.getSource());
            }
            if (JTree.LEAD_SELECTION_PATH_PROPERTY.equals(changeName)) {
                updateLeadRow();
                repaintPath((TreePath)event.getOldValue());
                repaintPath((TreePath)event.getNewValue());
            }
            else if (JTree.ANCHOR_SELECTION_PATH_PROPERTY.equals(changeName)) {
                repaintPath((TreePath)event.getOldValue());
                repaintPath((TreePath)event.getNewValue());
            }
            else if (JTree.CELL_RENDERER_PROPERTY.equals(changeName)) {
                completeEditing();
                updateRenderer();
                invalidateStateAndSize();
            }
            else if (JTree.TREE_MODEL_PROPERTY.equals(changeName)) {
                TreeModel oldModel = (TreeModel)event.getOldValue();

                completeEditing();
                if (oldModel != null && treeModelListener != null) {
                    oldModel.removeTreeModelListener(treeModelListener);
                }
                TreeModel newModel = (TreeModel)event.getNewValue();
                if (newModel != null && treeModelListener != null) {
                    newModel.addTreeModelListener(treeModelListener);
                }
                if (treeState != null) {
                    treeState.setModel(newModel);
                    updateLayoutCacheExpandedNodes();
                    invalidateSize();
                }
            }
            else if (JTree.ROOT_VISIBLE_PROPERTY.equals(changeName)) {
                completeEditing();
                updateRootOffset();
                if (treeState != null) {
                    treeState.setRootVisible(((Boolean)event.getNewValue()).
                                             booleanValue());
                    invalidateStateAndSize();
                }
            }
            else if (JTree.SHOWS_ROOT_HANDLES_PROPERTY.equals(changeName)) {
                completeEditing();
                updateRootOffset();
                invalidateStateAndSize();
            }
            else if (JTree.ROW_HEIGHT_PROPERTY.equals(changeName)) {
                completeEditing();
                if (treeState != null) {
                    updateLargeModel();
                    treeState.setRowHeight(tree.getRowHeight());
                    invalidateSize();
                }
            }
            else if (JTree.CELL_EDITOR_PROPERTY.equals(changeName)) {
                completeEditing();
                TreeCellEditor oldEditor = (TreeCellEditor)event.getOldValue();

                if (oldEditor != null && cellEditorListener != null) {
                    oldEditor.removeCellEditorListener(cellEditorListener);
                }

                TreeCellEditor newEditor = (TreeCellEditor)event.getNewValue();
                if (newEditor != null) {
                    if (cellEditorListener == null) {
                        cellEditorListener = createCellEditorListener();
                    }
                    if (cellEditorListener != null) {
                        newEditor.addCellEditorListener(cellEditorListener);
                    }
                }
            }
            else if (JTree.EDITABLE_PROPERTY.equals(changeName)) {
                completeEditing();

                TreeCellEditor editor = tree.getCellEditor();

                if (tree.isEditable()) {
                    if (editor == null) {
                        editor = createCellEditor();
                        if (editor != null) {
                            tree.setCellEditor(editor);
                        }
                    }
                    else {
                        if (cellEditorListener == null) {
                            cellEditorListener = createCellEditorListener();
                        }
                        if (cellEditorListener != null) {
                            editor.addCellEditorListener(cellEditorListener);
                        }
                    }
                }
                else if (editor instanceof UIResource) {
                    tree.setCellEditor(null);
                }
            }
            else if (JTree.LARGE_MODEL_PROPERTY.equals(changeName)) {
                updateLargeModel();
            }
            else if(JTree.SELECTION_MODEL_PROPERTY.equals(changeName)) {
                selectionModelChanged((TreeSelectionModel)event.
                                      getOldValue(), tree.getSelectionModel());
            }
            else if("font".equals(changeName)) {
                completeEditing();
                invalidateStateAndSize();
            }
            else if ("componentOrientation".equals(changeName)) {
                leftToRight = tree.getComponentOrientation().isLeftToRight();
                invalidateStateAndSize();

                InputMap km = getInputMap(JComponent.WHEN_FOCUSED);
                SwingUtilities.replaceUIInputMap(tree,
						JComponent.WHEN_FOCUSED, km);
            } else if ("transferHandler".equals(changeName)) {
                DropTarget dropTarget = tree.getDropTarget();
                if (dropTarget instanceof UIResource) {
                    if (defaultDropTargetListener == null) {
                        defaultDropTargetListener = new TreeDropTargetListener();
                    }
                    try {
                        dropTarget.addDropTargetListener(defaultDropTargetListener);
                    } catch (TooManyListenersException tmle) {
                        // should not happen... swing drop target is multicast
                    }
                }
            }
	}
    }


    private int getTrailingControlOffset() {
	return trailingControlOffset;
    }

    private int getIndent() {
        return indent;
    }

    /**
     * Returns the icon to draw when the node is expanded.
     */
    private Icon getExpandedIcon() {
	return expandedIcon;
    }

    /**
     * Returns the Icon to draw when the node is collapsed.
     */
    private Icon getCollapsedIcon() {
	return collapsedIcon;
    }

    /**
     * Updates the necessary state in response to the large model, or rowHeight
     * property changing.
     */
    private void updateLargeModel() {
        boolean largeModel = tree.isLargeModel();

	if (tree.getRowHeight() < 1) {
	    largeModel = false;
        }
	if (this.largeModel != largeModel) {
	    completeEditing();
	    this.largeModel = largeModel;
	    treeState = createLayoutCache();
	    configureLayoutCache();
	    invalidateSize();
	}
    }

    /**
     * Returns true if operating in large model mode.
     */
    private boolean isLargeModel() {
	return largeModel;