feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/javax/swing/plaf/metal/MetalTreeUI.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package javax.swing.plaf.metal;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.beans.*;
+import java.io.*;
+import java.util.*;
+import javax.swing.plaf.*;
+import javax.swing.tree.*;
+
+import javax.swing.plaf.basic.*;
+
+/**
+ * The metal look and feel implementation of <code>TreeUI</code>.
+ * <p>
+ * <code>MetalTreeUI</code> allows for configuring how to
+ * visually render the spacing and delineation between nodes. The following
+ * hints are supported:
+ *
+ * <table summary="Descriptions of supported hints: Angled, Horizontal, and None">
+ *  <tr>
+ *    <th><p style="text-align:left">Angled</p></th>
+ *    <td>A line is drawn connecting the child to the parent. For handling
+ *          of the root node refer to
+ *          {@link javax.swing.JTree#setRootVisible} and
+ *          {@link javax.swing.JTree#setShowsRootHandles}.
+ *    </td>
+ *  </tr>
+ *  <tr>
+ *     <th><p style="text-align:left">Horizontal</p></th>
+ *     <td>A horizontal line is drawn dividing the children of the root node.</td>
+ *  </tr>
+ *  <tr>
+ *      <th><p style="text-align:left">None</p></th>
+ *      <td>Do not draw any visual indication between nodes.</td>
+ *  </tr>
+ * </table>
+ *
+ * <p>
+ * As it is typically impractical to obtain the <code>TreeUI</code> from
+ * the <code>JTree</code> and cast to an instance of <code>MetalTreeUI</code>
+ * you enable this property via the client property
+ * <code>JTree.lineStyle</code>. For example, to switch to
+ * <code>Horizontal</code> style you would do:
+ * <code>tree.putClientProperty("JTree.lineStyle", "Horizontal");</code>
+ * <p>
+ * The default is <code>Angled</code>.
+ *
+ * @author Tom Santos
+ * @author Steve Wilson (value add stuff)
+ */
+public class MetalTreeUI extends BasicTreeUI {
+
+    private static Color lineColor;
+
+    private static final String LINE_STYLE = "JTree.lineStyle";
+
+    private static final String LEG_LINE_STYLE_STRING = "Angled";
+    private static final String HORIZ_STYLE_STRING = "Horizontal";
+    private static final String NO_STYLE_STRING = "None";
+
+    private static final int LEG_LINE_STYLE = 2;
+    private static final int HORIZ_LINE_STYLE = 1;
+    private static final int NO_LINE_STYLE = 0;
+
+    private int lineStyle = LEG_LINE_STYLE;
+    private PropertyChangeListener lineStyleListener = new LineListener();
+
+    // Boilerplate
+    public static ComponentUI createUI(JComponent x) {
+        return new MetalTreeUI();
+    }
+
+    public MetalTreeUI()
+    {
+        super();
+    }
+
+    protected int getHorizontalLegBuffer()
+      {
+          return 3;
+      }
+
+    public void installUI( JComponent c ) {
+        super.installUI( c );
+        lineColor = UIManager.getColor( "Tree.line" );
+
+        Object lineStyleFlag = c.getClientProperty( LINE_STYLE );
+        decodeLineStyle(lineStyleFlag);
+        c.addPropertyChangeListener(lineStyleListener);
+
+    }
+
+    public void uninstallUI( JComponent c) {
+         c.removePropertyChangeListener(lineStyleListener);
+         super.uninstallUI(c);
+    }
+
+    /** this function converts between the string passed into the client property
+      * and the internal representation (currently and int)
+      *
+      */
+    protected void decodeLineStyle(Object lineStyleFlag) {
+      if ( lineStyleFlag == null ||
+                    lineStyleFlag.equals(LEG_LINE_STYLE_STRING)){
+        lineStyle = LEG_LINE_STYLE; // default case
+      } else {
+          if ( lineStyleFlag.equals(NO_STYLE_STRING) ) {
+              lineStyle = NO_LINE_STYLE;
+          } else if ( lineStyleFlag.equals(HORIZ_STYLE_STRING) ) {
+              lineStyle = HORIZ_LINE_STYLE;
+          }
+      }
+
+    }
+
+    protected boolean isLocationInExpandControl(int row, int rowLevel,
+                                                int mouseX, int mouseY) {
+        if(tree != null && !isLeaf(row)) {
+            int                     boxWidth;
+
+            if(getExpandedIcon() != null)
+                boxWidth = getExpandedIcon().getIconWidth() + 6;
+            else
+                boxWidth = 8;
+
+            Insets i = tree.getInsets();
+            int    boxLeftX = (i != null) ? i.left : 0;
+
+
+            boxLeftX += (((rowLevel + depthOffset - 1) * totalChildIndent) +
+                        getLeftChildIndent()) - boxWidth/2;
+
+            int boxRightX = boxLeftX + boxWidth;
+
+            return mouseX >= boxLeftX && mouseX <= boxRightX;
+        }
+        return false;
+    }
+
+    public void paint(Graphics g, JComponent c) {
+        super.paint( g, c );
+
+
+        // Paint the lines
+        if (lineStyle == HORIZ_LINE_STYLE && !largeModel) {
+            paintHorizontalSeparators(g,c);
+        }
+    }
+
+    protected void paintHorizontalSeparators(Graphics g, JComponent c) {
+        g.setColor( lineColor );
+
+        Rectangle clipBounds = g.getClipBounds();
+
+        int beginRow = getRowForPath(tree, getClosestPathForLocation
+                                     (tree, 0, clipBounds.y));
+        int endRow = getRowForPath(tree, getClosestPathForLocation
+                             (tree, 0, clipBounds.y + clipBounds.height - 1));
+
+        if ( beginRow <= -1 || endRow <= -1 ) {
+            return;
+        }
+
+        for ( int i = beginRow; i <= endRow; ++i ) {
+            TreePath        path = getPathForRow(tree, i);
+
+            if(path != null && path.getPathCount() == 2) {
+                Rectangle       rowBounds = getPathBounds(tree,getPathForRow
+                                                          (tree, i));
+
+                // Draw a line at the top
+                if(rowBounds != null)
+                    g.drawLine(clipBounds.x, rowBounds.y,
+                               clipBounds.x + clipBounds.width, rowBounds.y);
+            }
+        }
+
+    }
+
+    protected void paintVerticalPartOfLeg(Graphics g, Rectangle clipBounds,
+                                          Insets insets, TreePath path) {
+        if (lineStyle == LEG_LINE_STYLE) {
+            super.paintVerticalPartOfLeg(g, clipBounds, insets, path);
+        }
+    }
+
+    protected void paintHorizontalPartOfLeg(Graphics g, Rectangle clipBounds,
+                                            Insets insets, Rectangle bounds,
+                                            TreePath path, int row,
+                                            boolean isExpanded,
+                                            boolean hasBeenExpanded, boolean
+                                            isLeaf) {
+        if (lineStyle == LEG_LINE_STYLE) {
+            super.paintHorizontalPartOfLeg(g, clipBounds, insets, bounds,
+                                           path, row, isExpanded,
+                                           hasBeenExpanded, isLeaf);
+        }
+    }
+
+    /** This class listens for changes in line style */
+    class LineListener implements PropertyChangeListener {
+        public void propertyChange(PropertyChangeEvent e) {
+            String name = e.getPropertyName();
+            if ( name.equals( LINE_STYLE ) ) {
+                decodeLineStyle(e.getNewValue());
+            }
+        }
+    } // end class PaletteListener
+
+}