jdk-sandbox: comparison jdk/src/share/classes/javax/swing/plaf/synth/SynthTreeUI.java

equal deleted inserted replaced

-:4e81657271ba
+:92a8ec883f5d
 import javax.swing.tree.TreeCellEditor;
 import javax.swing.tree.TreeCellRenderer;
 import javax.swing.tree.TreeModel;
 import javax.swing.tree.TreePath;
 import sun.swing.plaf.synth.SynthIcon;
-import sun.swing.plaf.synth.SynthUI;
 /**
-* Skinnable TreeUI.
+* Provides the Synth L&F UI delegate for
+* {@link javax.swing.JTree}.
 *
 * @author Scott Violet
+* @since 1.7
 */
-class SynthTreeUI extends BasicTreeUI implements PropertyChangeListener,
+public class SynthTreeUI extends BasicTreeUI
-SynthUI {
+implements PropertyChangeListener, SynthUI {
 private SynthStyle style;
 private SynthStyle cellStyle;
 private SynthContext paintContext;
 private boolean drawHorizontalLines;
 private boolean drawVerticalLines;
 private Object linesStyle;
-private int leadRow;
 private int padding;
 private boolean useTreeColors;
-private Icon expandedIconWrapper;
+private Icon expandedIconWrapper = new ExpandedIconWrapper();
+/**
+* Creates a new UI object for the given component.
+*
+* @param x component to create UI object for
+* @return the UI object
+*/
 public static ComponentUI createUI(JComponent x) {
 return new SynthTreeUI();
 }
-SynthTreeUI() {
+/**
-expandedIconWrapper = new ExpandedIconWrapper();
+* @inheritDoc
-}
+*/
 @Override
 public Icon getExpandedIcon() {
 return expandedIconWrapper;
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void installDefaults() {
 updateStyle(tree);
 }
 context = getContext(tree, Region.TREE_CELL, ENABLED);
 cellStyle = SynthLookAndFeel.updateStyle(context, this);
 context.dispose();
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void installListeners() {
 super.installListeners();
 tree.addPropertyChangeListener(this);
 }
+/**
+* @inheritDoc
+*/
 @Override
 public SynthContext getContext(JComponent c) {
-return getContext(c, getComponentState(c));
+return getContext(c, SynthLookAndFeel.getComponentState(c));
 }
 private SynthContext getContext(JComponent c, int state) {
 return SynthContext.getContext(SynthContext.class, c,
 SynthLookAndFeel.getRegion(c), style, state);
-}
-private Region getRegion(JTree c) {
-return SynthLookAndFeel.getRegion(c);
-}
-private int getComponentState(JComponent c) {
-return SynthLookAndFeel.getComponentState(c);
 }
 private SynthContext getContext(JComponent c, Region region) {
 return getContext(c, region, getComponentState(c, region));
 }
 // Always treat the cell as selected, will be adjusted appropriately
 // when painted.
 return ENABLED | SELECTED;
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected TreeCellEditor createDefaultCellEditor() {
 TreeCellRenderer renderer = tree.getCellRenderer();
 DefaultTreeCellEditor editor;
 editor = new SynthTreeCellEditor(tree, null);
 }
 return editor;
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected TreeCellRenderer createDefaultCellRenderer() {
 return new SynthTreeCellRenderer();
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void uninstallDefaults() {
 SynthContext context = getContext(tree, ENABLED);
 style.uninstallDefaults(context);
 if (tree.getTransferHandler() instanceof UIResource) {
 tree.setTransferHandler(null);
 }
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void uninstallListeners() {
 super.uninstallListeners();
 tree.removePropertyChangeListener(this);
 }
+/**
+* @inheritDoc
+*/
 @Override
 public void update(Graphics g, JComponent c) {
 SynthContext context = getContext(c);
 SynthLookAndFeel.update(context, g);
 g, 0, 0, c.getWidth(), c.getHeight());
 paint(context, g);
 context.dispose();
 }
+/**
+* @inheritDoc
+*/
+@Override
 public void paintBorder(SynthContext context, Graphics g, int x,
 int y, int w, int h) {
 context.getPainter().paintTreeBorder(context, g, x, y, w, h);
 }
+/**
+* @inheritDoc
+*/
 @Override
 public void paint(Graphics g, JComponent c) {
 SynthContext context = getContext(c);
 paint(context, g);
 context.dispose();
 }
-private void updateLeadRow() {
+/**
-leadRow = getRowForPath(tree, tree.getLeadSelectionPath());
+* Paints the specified component.
-}
+*
+* @param context context for the component being painted
+* @param g {@code Graphics} object used for painting
+*/
 protected void paint(SynthContext context, Graphics g) {
 paintContext = context;
-updateLeadRow();
+updateLeadSelectionRow();
 Rectangle paintBounds = g.getClipBounds();
 Insets insets = tree.getInsets();
 TreePath initialPath = getClosestPathForLocation(tree, 0,
 paintBounds.y);
 boolean done = false;
 boolean isExpanded;
 boolean hasBeenExpanded;
 boolean isLeaf;
-Rectangle boundsBuffer = new Rectangle();
 Rectangle rowBounds = new Rectangle(0, 0, tree.getWidth(),0);
 Rectangle bounds;
 TreePath path;
 TreeCellRenderer renderer = tree.getCellRenderer();
 DefaultTreeCellRenderer dtcr = (renderer instanceof
 // Empty out the renderer pane, allowing renderers to be gc'ed.
 rendererPane.removeAll();
 }
-private boolean isDropLine(JTree.DropLocation loc) {
-return loc != null && loc.getPath() != null && loc.getChildIndex() != -1;
-}
-private void paintDropLine(Graphics g) {
-JTree.DropLocation loc = tree.getDropLocation();
-if (!isDropLine(loc)) {
-return;
-}
-Color c = (Color)style.get(paintContext, "Tree.dropLineColor");
-if (c != null) {
-g.setColor(c);
-Rectangle rect = getDropLineRect(loc);
-g.fillRect(rect.x, rect.y, rect.width, rect.height);
-}
-}
-private Rectangle getDropLineRect(JTree.DropLocation loc) {
-Rectangle rect;
-TreePath path = loc.getPath();
-int index = loc.getChildIndex();
-boolean ltr = tree.getComponentOrientation().isLeftToRight();
-Insets insets = tree.getInsets();
-if (tree.getRowCount() == 0) {
-rect = new Rectangle(insets.left,
-insets.top,
-tree.getWidth() - insets.left - insets.right,
-0);
-} else {
-int row = tree.getRowForPath(path);
-TreeModel model = getModel();
-Object root = model.getRoot();
-if (path.getLastPathComponent() == root
-&& index >= model.getChildCount(root)) {
-rect = tree.getRowBounds(tree.getRowCount() - 1);
-rect.y = rect.y + rect.height;
-Rectangle xRect;
-if (!tree.isRootVisible()) {
-xRect = tree.getRowBounds(0);
-} else if (model.getChildCount(root) == 0){
-xRect = tree.getRowBounds(0);
-xRect.x += totalChildIndent;
-xRect.width -= totalChildIndent + totalChildIndent;
-} else {
-TreePath lastChildPath = path.pathByAddingChild(
-model.getChild(root, model.getChildCount(root) - 1));
-xRect = tree.getPathBounds(lastChildPath);
-}
-rect.x = xRect.x;
-rect.width = xRect.width;
-} else {
-rect = tree.getPathBounds(path.pathByAddingChild(
-model.getChild(path.getLastPathComponent(), index)));
-}
-}
-if (rect.y != 0) {
-rect.y--;
-}
-if (!ltr) {
-rect.x = rect.x + rect.width - 100;
-}
-rect.width = 100;
-rect.height = 2;
-return rect;
-}
 private void configureRenderer(SynthContext context) {
 TreeCellRenderer renderer = tree.getCellRenderer();
 if (renderer instanceof DefaultTreeCellRenderer) {
 DefaultTreeCellRenderer r = (DefaultTreeCellRenderer)renderer;
 context, ColorType.TEXT_BACKGROUND));
 }
 }
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,
 Insets insets, Rectangle bounds,
 TreePath path, int row,
 boolean isExpanded,
 path, row, isExpanded,
 hasBeenExpanded, isLeaf);
 }
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void paintHorizontalLine(Graphics g, JComponent c, int y,
 int left, int right) {
 paintContext.getStyle().getGraphicsUtils(paintContext).drawLine(
 paintContext, "Tree.horizontalLine", g, left, y, right, y, linesStyle);
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void paintVerticalPartOfLeg(Graphics g,
 Rectangle clipBounds, Insets insets,
 TreePath path) {
 if (drawVerticalLines) {
 super.paintVerticalPartOfLeg(g, clipBounds, insets, path);
 }
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void paintVerticalLine(Graphics g, JComponent c, int x, int top,
 int bottom) {
 paintContext.getStyle().getGraphicsUtils(paintContext).drawLine(
 paintContext, "Tree.verticalLine", g, x, top, x, bottom, linesStyle);
 }
-protected void paintRow(TreeCellRenderer renderer,
+private 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) {
 int state = ENABLED;
 if (selected || isDrop) {
 state |= SELECTED;
 }
-if (tree.isFocusOwner() && row == leadRow) {
+if (tree.isFocusOwner() && row == getLeadSelectionRow()) {
 state |= FOCUSED;
 }
 cellContext.setComponentState(state);
 }
 int leadIndex;
 if (tree.hasFocus()) {
-leadIndex = leadRow;
+leadIndex = getLeadSelectionRow();
 }
 else {
 leadIndex = -1;
 }
 super.paintExpandControl(g, clipBounds, insets, bounds, path, row,
 isExpanded, hasBeenExpanded, isLeaf);
 paintContext.setComponentState(state);
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected void drawCentered(Component c, Graphics graphics, Icon icon,
 int x, int y) {
 int w = SynthIcon.getIconWidth(icon, paintContext);
 int h = SynthIcon.getIconHeight(icon, paintContext);
 SynthIcon.paintIcon(icon, paintContext, graphics,
 findCenteredX(x, w),
 y - h/2, w, h);
 }
+/**
+* @inheritDoc
+*/
+@Override
 public void propertyChange(PropertyChangeEvent event) {
 if (SynthLookAndFeel.shouldUpdateStyle(event)) {
 updateStyle((JTree)event.getSource());
 }
 if ("dropLocation" == event.getPropertyName()) {
 JTree.DropLocation oldValue = (JTree.DropLocation)event.getOldValue();
 repaintDropLocation(oldValue);
 repaintDropLocation(tree.getDropLocation());
+}
+}
+/**
+* @inheritDoc
+*/
+@Override
+protected void paintDropLine(Graphics g) {
+JTree.DropLocation loc = tree.getDropLocation();
+if (!isDropLine(loc)) {
+return;
+}
+Color c = (Color)style.get(paintContext, "Tree.dropLineColor");
+if (c != null) {
+g.setColor(c);
+Rectangle rect = getDropLineRect(loc);
+g.fillRect(rect.x, rect.y, rect.width, rect.height);
 }
 }
 private void repaintDropLocation(JTree.DropLocation loc) {
 if (loc == null) {
 if (r != null) {
 tree.repaint(r);
 }
 }
+/**
+* @inheritDoc
+*/
 @Override
 protected int getRowX(int row, int depth) {
 return super.getRowX(row, depth) + padding;
 }

changeset 4394	92a8ec883f5d
parent 2658	43e06bc950ec
child 4848	ffcc849b9351