TreeConnectorsView.java

package ini.trakem2.display;

import ini.trakem2.utils.Bureaucrat;
import ini.trakem2.utils.IJError;
import ini.trakem2.utils.Utils;
import ini.trakem2.utils.Worker;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;

/** List all connectors whose origins intersect with the given tree. */
public class TreeConnectorsView {

	static private Map<Tree<?>,TreeConnectorsView> open = Collections.synchronizedMap(new HashMap<Tree<?>,TreeConnectorsView>());
	
	private JFrame frame;
	private TargetsTableModel outgoing_model = new TargetsTableModel(),
				  incoming_model = new TargetsTableModel();
	private Tree<?> tree;

	public TreeConnectorsView(final Tree<?> tree) {
		this.tree = tree;
		update();
		createGUI();
		open.put(tree,this);
	}

	static public Bureaucrat create(final Tree<?> tree) {
		return Bureaucrat.createAndStart(new Worker.Task("Opening connectors table") {
			public void exec() {
				TreeConnectorsView tcv = open.get(tree);
				if (null != tcv) {
					tcv.update();
					tcv.frame.setVisible(true);
					tcv.frame.toFront();
				} else {
					// Create and store in the Map of 'open'
					new TreeConnectorsView(tree);
				}
			}
		}, tree.getProject());
	}

	static public void dispose(final Tree<?> tree) {
		TreeConnectorsView tcv = open.remove(tree);
		if (null == tcv) return;
		tcv.frame.dispose();
	}

	static private final Comparator<Displayable> IDSorter = new Comparator<Displayable>() {
		@Override
		public int compare(Displayable o1, Displayable o2) {
			if (o1.getId() < o1.getId()) return -1;
			return 1;
		}
	};
	
	private class Row {
		final Connector connector;
		final int i;
		final ArrayList<Displayable> origins, targets;
		String originids, targetids;
		Row(final Connector c, final int i, final ArrayList<Displayable> origins, final ArrayList<Displayable> targets) {
			this.connector = c;
			this.i = i;
			this.origins = origins;
			this.targets = targets;
			for (final Iterator<Displayable> it = this.targets.iterator(); it.hasNext(); ) {
				if (it.next().getClass() == Connector.class) {
					it.remove();
				}
			}
		}
		final Coordinate<Node<Float>> getCoordinate(int col) {
			switch (col) {
				case 0:
				case 1:
					return connector.getCoordinateAtOrigin();
				case 2:
					return connector.getCoordinate(i);
				default:
					Utils.log2("Can't deal with column " + col);
					return null;
			}
		}
		private final long getFirstId(final ArrayList<Displayable> c) {
			if (c.isEmpty())
					return 0;
			else
					return c.get(0).getId();
		}
		final long getColumn(final int col) {
			switch (col) {
				case 0:
					return connector.getId();
				case 1:
					return getFirstId(origins);
				case 2:
					return getFirstId(targets);
				default:
					Utils.log2("Don't know how to deal with column " + col);
					return 0;
			}
		}
		private final String getIds(String ids, final ArrayList<Displayable> ds) {
			if (null == ids) {
				switch (ds.size()) {
					case 0:
						ids = "";
						break;
					case 1:
						ids = ds.get(0).toString();
						break;
					default:
						final StringBuilder sb = new StringBuilder();
						for (final Displayable d : ds) {
							sb.append(d).append(',').append(' ');
						}
						sb.setLength(sb.length() -2);
						ids = sb.toString();
						break;
				}
			}
			return ids;
		}
		final String getTargetIds() {
			targetids = getIds(targetids, targets);
			return targetids;
		}
		final String getOriginIds() {
			originids = getIds(originids, origins);
			return originids;
		}
	}

	public void update() {
		// Find all Connector instances intersecting with the nodes of Tree
		try {
			final Collection<Connector>[] connectors = this.tree.findConnectors();
			outgoing_model.setData(connectors[0]);
			incoming_model.setData(connectors[1]);
		} catch (Exception e) {
			IJError.print(e);
		}
	}

	private void addTab(JTabbedPane tabs, String title, TargetsTableModel model) {
		JTable table = new Table();
		table.setModel(model);
		JScrollPane jsp = new JScrollPane(table);
		jsp.setPreferredSize(new Dimension(500, 500));
		tabs.addTab(title, jsp);
	}

	private void createGUI() {
		this.frame = new JFrame("Connectors for Tree #" + this.tree.getId());
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent we) {
				open.remove(tree);
			}
		});
		JTabbedPane tabs = new JTabbedPane();
		addTab(tabs, "Outgoing", outgoing_model);
		addTab(tabs, "Incoming", incoming_model);
		frame.getContentPane().add(tabs);
		frame.pack();
		frame.setVisible(true);
	}

	private class Table extends JTable {
		private static final long serialVersionUID = 1L;
		Table() {
			super();
			getTableHeader().addMouseListener(new MouseAdapter() {
				public void mouseClicked(MouseEvent me) {
					if (2 != me.getClickCount()) return;
					int viewColumn = getColumnModel().getColumnIndexAtX(me.getX());
					int column = convertColumnIndexToModel(viewColumn);
					if (-1 == column) return;
					((TargetsTableModel)getModel()).sortByColumn(column, me.isShiftDown());
				}
			});
			addMouseListener(new MouseAdapter() {
				public void mousePressed(MouseEvent me) {
					final int row = Table.this.rowAtPoint(me.getPoint());
					final int col = Table.this.columnAtPoint(me.getPoint());
					if (2 == me.getClickCount()) {
						go(col, row);
					} else if (Utils.isPopupTrigger(me)) {
						JPopupMenu popup = new JPopupMenu();
						final JMenuItem go = new JMenuItem("Go"); popup.add(go);
						final JMenuItem goandsel = new JMenuItem("Go and select"); popup.add(go);
						final JMenuItem update = new JMenuItem("Update"); popup.add(update);
						ActionListener listener = new ActionListener() {
							public void actionPerformed(ActionEvent ae) {
								final Object src = ae.getSource();
								if (src == go) go(col, row);
								else if (src == goandsel) {
									go(col, row);
									if (0 != (ae.getModifiers() ^ ActionEvent.SHIFT_MASK)) Display.getFront().getSelection().clear();
									TargetsTableModel ttm = (TargetsTableModel)getModel();
									Display.getFront().getSelection().add(ttm.rows.get(row).connector);
								} else if (src == update) {
									Bureaucrat.createAndStart(new Worker.Task("Updating...") {
										public void exec() {
											TreeConnectorsView.this.update();
										}
									}, TreeConnectorsView.this.tree.getProject());
								}
							}
						};
						go.addActionListener(listener);
						goandsel.addActionListener(listener);
						update.addActionListener(listener);
						popup.show(Table.this, me.getX(), me.getY());
					}
				}
			});
		}
		void go(int col, int row) {
			TargetsTableModel ttm = (TargetsTableModel)getModel();
			Display.centerAt(ttm.rows.get(row).getCoordinate(col));
		}
	}

	private class TargetsTableModel extends AbstractTableModel {
		private static final long serialVersionUID = 1L;
		List<Row> rows = null;

		synchronized public void setData(final Collection<Connector> connectors) {
			this.rows = new ArrayList<Row>(connectors.size());
			for (final Connector c : connectors) {
				int i = 0;
				final ArrayList<Displayable> origins = new ArrayList<Displayable>(c.getOrigins(VectorData.class, true));
				Collections.sort(origins, IDSorter);
				for (final Set<Displayable> targets : c.getTargets(VectorData.class, true)) {
					final ArrayList<Displayable> ts = new ArrayList<Displayable>(targets);
					Collections.sort(ts, IDSorter);
					this.rows.add(new Row(c, i++, origins, ts));
				}
			}
			SwingUtilities.invokeLater(new Runnable() {public void run() {
				fireTableDataChanged();
				fireTableStructureChanged();
			}});
		}

		public int getColumnCount() { return 3; }
		public String getColumnName(final int col) {
			switch (col) {
				case 0: return "Connector id";
				case 1: return "Origin id";
				case 2: return "Target id";
				default: return null;
			}
		}
		public int getRowCount() { return rows.size(); }
		public Object getValueAt(final int row, final int col) {
			switch (col) {
				case 0: return rows.get(row).connector.getId();
				case 1: return rows.get(row).getOriginIds();
				case 2: return rows.get(row).getTargetIds();
				default: return null;
			}
		}
		public boolean isCellEditable(int row, int col) { return false; }
		public void setValueAt(Object value, int row, int col) {}
		final void sortByColumn(final int col, final boolean descending) {
			final ArrayList<Row> rows = new ArrayList<Row>(this.rows);
			Collections.sort(rows, new Comparator<Row>() {
				public int compare(final Row r1, final Row r2) {
					final long op = r1.getColumn(col) - r2.getColumn(col);
					if (descending) {
						if (op > 0) return -1;
						if (op < 0) return 1;
						return 0;
					}
					if (op < 0) return -1;
					if (op > 0) return 1;
					return 0;
				}
			});
			this.rows = rows; // swap
			fireTableDataChanged();
			fireTableStructureChanged();
		}
	}

}