SelectionTool.java

package net.squiz.matrix.ui;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.tree.*;
import javax.swing.table.*;
import java.util.*;
import javax.swing.plaf.*;
import net.squiz.matrix.inspector.*;

public class SelectionTool extends MouseAdapter implements MouseMotionListener {

    private Component comp;
    private SelectionHandler selHandler;

    private Point initDragPoint = null;
    private int mouseX;
    private int mouseY;
    private Rectangle selectionBounds = new Rectangle(0, 0, 0, 0);
    private java.util.List currSelection = new ArrayList();

    /* TRUE if we are dragging the selection tool */
    private boolean dragging = false;
    /* a list of nodes to be removed from the selection */
    private java.util.List removeSelections = new ArrayList();
    /* a list of nodes to be added to the selection */
    private java.util.List addSelections = new ArrayList();

    public SelectionTool(JTree comp) {
        this.comp = comp;
        selHandler = new TreeSelection(comp);
    }

    public SelectionTool(JTable comp) {
        this.comp = comp;
        selHandler = new TableSelection(comp);
    }

    public SelectionTool(SelectionHandler handler, Component comp) {
        selHandler = handler;
        this.comp = comp;
    }

    public Point getInitialDragPoint() {
        return initDragPoint;
    }

    public boolean isDragging() {
        return dragging;
    }

    public void mouseMoved(MouseEvent evt) {}

    public void mouseReleased(MouseEvent evt) {
        dragging = false;
        initDragPoint = null;
        currSelection.clear();
        removeSelections.clear();
        addSelections.clear();
        comp.repaint();
    }

    public void mouseDragged(MouseEvent evt) {
        mouseX = evt.getX();
        mouseY = evt.getY();

        if (initDragPoint == null) {
            if (!selHandler.canSelect(evt.getPoint()))
                return;

            initDragPoint = evt.getPoint();
            dragging = true;
            // remove any nodes that are currently selected
            selHandler.clearSelection();
        }
        selHandler.updateSelection(evt.getPoint());
        comp.repaint();
    }

    public void paintSelectionTool(Graphics2D g2d) {

        if (initDragPoint == null)
            return;

        int x = 0, y = 0, width = 0, height = 0;

        // this is the best way to visualise this:
        // the slashes point up to the way the rectangle should be drawn
        // where the x and y co-ordinates are the first slashes origin
        // in each quadrant

        /* width -->  | width -->   |
        ----------------------------- -
        |          /  |         /   | ^
        |      /      |     /       | | height
        |  / x,y      | / x,y       |
        |---------------------------| * initDragPoint.y
        |         /   |        /    |
        |      /      |     /       | ^
        |  / x,y      | / x,y       | | height
        |---------------------------|
                      * initDragPoint.x
        */

        if (initDragPoint.x < mouseX) {
            x     = initDragPoint.x;
            width = mouseX - initDragPoint.x;
        } else {
            x     = mouseX;
            width = initDragPoint.x -mouseX;
        }

        if (initDragPoint.y > mouseY) {
            y      = mouseY;
            height = initDragPoint.y - mouseY;
        } else {
            y      = initDragPoint.y;
            height = mouseY - initDragPoint.y;
        }
        drawSelectionImage(g2d, x, y, width, height);
        selectionBounds.setBounds(x, y, width, height);
    }

    protected void drawSelectionImage(
        Graphics2D g2d,
        int x,
        int y,
        int width,
        int height) {
            g2d.setColor(UIManager.getColor("SelectionTool.background"));
            g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.3f));
            g2d.fillRect(x, y, width, height);
            g2d.setColor(UIManager.getColor("SelectionTool.bordercolor"));
            g2d.drawRect(x, y, width - 1, height - 1);
    }

    class TreeSelection implements SelectionHandler {

        private JTree tree;

        public TreeSelection(JTree tree) {
            this.tree = tree;
        }

        private TreePath[] pathsToArray(java.util.List paths) {
            return (TreePath[]) paths.toArray(new TreePath[paths.size()]);
        }

        public boolean canSelect(Point point) {
            // check to see if the point if within the bounds of a node.
            // if it is, we don't want to start a selection operation, because
            // we want to let the operation cascade down to the drag and drop
            // methods
            if (tree.getPathForLocation(point.x, point.y) != null)
                return false;
            return true;
        }

        public void clearSelection() {
            tree.clearSelection();
        }

        public void updateSelection(Point point) {
            TreePath mousePath = tree.getClosestPathForLocation(
            initDragPoint.x, initDragPoint.y);
            TreePath initPath = tree.getClosestPathForLocation(point.x, point.y);

            // get the rows between the initial drag point and the current mouse
            // point a check each of the tree path's bounds to see if it
            // intersects the rectangle drawing tool

            TreePath[] rows = getPathBetweenRows(
                tree.getRowForPath(mousePath), tree.getRowForPath(initPath));

            currSelection.clear();

            for (int i = 0; i < rows.length; i++) {
                if (rows[i] == null)
                    continue;

                    if (selectionBounds.intersects(tree.getPathBounds(rows[i]))) {
                        currSelection.add(rows[i]);
                    }
            }
            if (currSelection != null && !currSelection.isEmpty())
                intersectSelection(currSelection);
            // see the paintComponent method of this class to see how
            // the selection tool is drawn
        }

        private TreePath[] getPathBetweenRows(int index0, int index1) {
            int newMinIndex, newMaxIndex;
            TreeUI ui = tree.getUI();

            newMinIndex = Math.min(index0, index1);
            newMaxIndex = Math.max(index0, index1);

            if(tree != null) {
                TreePath[] selection = new TreePath[newMaxIndex - newMinIndex + 1];

                for (int counter = newMinIndex; counter <= newMaxIndex; counter++) {
                    selection[counter - newMinIndex] = ui.getPathForRow(tree, counter);
                }

                return selection;
            }

            return null;
        }

        protected void intersectSelection(java.util.List selPaths) {
            TreePath[] currSelPaths = tree.getSelectionPaths();

            // if there are currently no paths selected, then just selected
            // the specified selection paths
            if (currSelPaths == null) {
                tree.addSelectionPaths(pathsToArray(selPaths));
                return;
            }

            addSelections.clear();
            removeSelections.clear();
            boolean found = false;
            TreePath[] selPathsArr = pathsToArray(selPaths);

            for (int i = 0; i < selPathsArr.length; i++) {
                found = false;
                for (int j = 0; j < currSelPaths.length; j++) {
                    // check to see if new selection path is allready selection
                    if (selPathsArr[i] == currSelPaths[j]) {
                        found = true;
                        break;
                    }
                }
                if (!found)
                    addSelections.add(selPathsArr[i]);
            }
            for (int i = 0; i < currSelPaths.length; i++) {
                found = false;
                for (int j = 0; j < selPathsArr.length; j++) {
                    // check to see if old selection
                    // is not in the new selection
                    if (currSelPaths[i] == selPathsArr[j]) {
                        found = true;
                        break;
                    }
                }
                if (!found)
                    removeSelections.add(currSelPaths[i]);
            }
            // add any new selections that are not currently selected
            if (!addSelections.isEmpty())
                tree.addSelectionPaths(pathsToArray(addSelections));
            // remove any new selections that are current selected
            if (!removeSelections.isEmpty())
                tree.removeSelectionPaths(pathsToArray(removeSelections));
        }
    }

    class TableSelection implements SelectionHandler {

        private JTable table;

        public TableSelection(JTable table) {
            this.table = table;
        }

        public boolean canSelect(Point point) {
            if ( (table.rowAtPoint(point) == -1 ) || (table.columnAtPoint(point) == -1) )
                return true;
            if (table.getValueAt( table.rowAtPoint(point), table.columnAtPoint(point) ) == null)
                return true;

            // MM: need to move mouseInsideCellComponent into this
            // inner class
            InspectorGadget tempTable = (InspectorGadget) table;
            if (!tempTable.mouseInsideCellComponent(point))
                return true;
            return false;
        }

        public void updateSelection(Point point) {
            int currentRow = table.rowAtPoint(point);
            int currentColumn = table.columnAtPoint(point);
            int startRow = table.rowAtPoint(initDragPoint);
            int startColumn = table.columnAtPoint(initDragPoint);

            if (startRow == -1)
                startRow = table.getRowCount() - 1;

            table.changeSelection(currentRow,currentColumn,false,false);
            table.changeSelection(startRow,startColumn,false,true);
        }

        public void clearSelection() {
            table.clearSelection();
        }
    }
}