org.coode.matrix.ui.component.MatrixTreeTable Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.coode.matrix Show documentation
A Swing Component that combines a JTree and a JTable.
The newest version!
/*
* Copyright (C) 2007, University of Manchester
*/
package org.coode.matrix.ui.component;

import java.awt.Color;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetDragEvent;
import java.awt.dnd.DropTargetEvent;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.tree.TreeSelectionModel;

import org.coode.matrix.model.api.MatrixModel;
import org.coode.matrix.ui.renderer.MatrixHeaderCellRenderer;
import org.protege.editor.owl.model.OWLModelManager;
import org.protege.editor.owl.model.event.EventType;
import org.protege.editor.owl.model.event.OWLModelManagerChangeEvent;
import org.protege.editor.owl.model.event.OWLModelManagerListener;
import org.protege.editor.owl.ui.renderer.LinkedObjectComponent;
import org.protege.editor.owl.ui.renderer.OWLRendererPreferences;
import org.protege.editor.owl.ui.table.OWLObjectDropTargetListener;
import org.protege.editor.owl.ui.transfer.OWLObjectDropTarget;
import org.protege.editor.owl.ui.tree.OWLObjectTree;
import org.semanticweb.owlapi.model.OWLEntity;
import org.semanticweb.owlapi.model.OWLObject;
import org.semanticweb.owlapi.model.OWLOntologyChange;

import uk.ac.manchester.cs.bhig.jtreetable.JTreeTable;

/**
 * Author: Nick Drummond

 * http://www.cs.man.ac.uk/~drummond/


 * 
 * The University Of Manchester

 * Bio Health Informatics Group

 * Date: Jan 3, 2008


 */
public class MatrixTreeTable extends JTreeTable
        implements OWLObjectDropTarget, LinkedObjectComponent {
    private static final long serialVersionUID = 1L;

    private OWLModelManager mngr;

    protected MatrixModel model;

    protected Cursor defaultCursor;

    private TableCellRenderer headerRenderer;

    private OWLModelManagerListener l = new OWLModelManagerListener(){

        public void handleChange(OWLModelManagerChangeEvent event) {
            if (event.getType().equals(EventType.ENTITY_RENDERER_CHANGED)){
                handleRendererChanged();
            }
        }
    };

    public MatrixTreeTable(OWLObjectTree tree, MatrixModel model, OWLModelManager mngr) {
        // constructor ensures createColsFromModel disabled otherwise JTable redraws all columns
        // on a tableChanged() losing any width info columns are added manually in tableChanged()
        super(tree, model);

        this.model = model;

        this.mngr = mngr;

        headerRenderer = new MatrixHeaderCellRenderer();

        defaultCursor = getCursor();

        handleRendererChanged();

        mngr.addListener(l);

        getTable().setGridColor(Color.LIGHT_GRAY);

        setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);

        // allow drop on both the table and the scrollpane
        final Container clientPane = getTable().getParent();
        DropTarget dt = new DropTarget(clientPane, new MatrixDropTargetListener(this));
        clientPane.setDropTarget(dt);
        dt = new DropTarget(getTable(), new MatrixDropTargetListener(this));
        getTable().setDropTarget(dt);

        setupColumns();
    }

    public void dispose(){
        model.dispose();
        mngr.removeListener(l);
    }


    @Override
    protected String getTreeTitle() {
        return getModel().getTreeColumnLabel();
    }


    private void setupColumns(){
        final TableColumnModel cm = getTable().getColumnModel();
        for (int i=0; i getTree() {
        return (OWLObjectTree)super.getTree();
    }


    @Override
    public MatrixModel getModel(){
        return (MatrixModel)super.getModel();
    }


    public R getSelectedOWLObject() {
        if (getTable().getSelectedRow() >= 0) {
            return (R) model.getValueAt(getTable().getSelectedRow(), 0);
        }
        else {
            return null;
        }
    }


    public boolean dropOWLObjects(List owlObjects, Point pt, int type) {
        boolean result = false;
        int dropRow = getTable().rowAtPoint(pt);
        int dropColumn = getTable().columnAtPoint(pt);
        for (OWLObject obj : owlObjects) {
            // if any of the objects are dropped successfully, return true
            // this behaviour may need revising depending on expectations
            if (dropOWLObject(obj, dropColumn, dropRow)) {
                result = true;
            }
        }
        if (result){
            getTable().repaint();
        }
        return result;
    }


    protected boolean dropOWLObject(OWLObject dropObject, int dropColumn, int dropRow) {

        boolean result = false;

        int modelColumn = getTable().convertColumnIndexToModel(dropColumn);

        if (dropRow >= 0 && model.isSuitableCellValue(dropObject, dropRow, modelColumn)) {

            // droppedInSelection is true when more than one row is selected and one of the selected rows is dropped on
            boolean droppedInSelection = false;
            int[] selectedRows = getTable().getSelectedRows();
            if (selectedRows.length > 1) {
                for (int selectedRow : selectedRows) {
                    if (selectedRow == dropRow) {
                        droppedInSelection = true;
                        break;
                    }
                }
            }

            if (droppedInSelection) {
                for (int selectedRow : selectedRows) {
                    if (addValue(dropObject, selectedRow, modelColumn)){
                        result = true;
                    }
                }
            }
            else {
                result = addValue(dropObject, dropRow, modelColumn);
            }

            if (result){
                repaint(getTable().getCellRect(dropRow, modelColumn, true));
            }
        }
        else{
            Object colObj = model.getSuitableColumnObject(dropObject);
            if (colObj != null) {
                result = addColumn(colObj);
        }
        }
        return result;
    }


    public boolean addColumn(Object object) {
        return addColumn(object, getTable().getColumnCount());
    }


    public boolean addColumn(Object object, int index) {
        boolean success = model.addColumn(object);

        if (success){
            TableColumn c = getTable().getColumnModel().getColumn(index);
            c.setHeaderRenderer(headerRenderer);
        }

        return success;
    }

    
    public boolean removeColumn(Object object){
        model.removeColumn(object);
        return true;
    }


    private boolean addValue(OWLObject value, int row, int col) {
        boolean success = false;
        if (model.isCellEditable(row, col)) {
            R rowObj = model.getNodeForRow(row);
            Object colObj = model.getColumnObjectAtModelIndex(col);
            List changes = model.addMatrixValue(rowObj, colObj, value);
            if (!changes.isEmpty()){
                mngr.applyChanges(changes);
                success = true;
            }
        }
        return success;
    }


    protected void handleRendererChanged() {
        final int rowHeight = getFontMetrics(OWLRendererPreferences.getInstance().getFont()).getHeight();
        getTree().setRowHeight(rowHeight);
        getTable().validate();
    }


////////////////////////////////////////// implementation of LinkedObjectComponent


    private OWLEntity linkedObject;


    public Point getMouseCellLocation() {
        Point mousePos = getMousePosition();
        if (mousePos == null) {
            return new Point();
        }
        Rectangle cellRect = getMouseCellRect();
        return new Point(mousePos.x - cellRect.x, mousePos.y - cellRect.y);
    }


    public Rectangle getMouseCellRect() {
        Point mousePos = getMousePosition();
        if(mousePos != null) {
            return getTable().getCellRect(getTable().rowAtPoint(mousePos),
                                          getTable().columnAtPoint(mousePos), true);
        }
        else {
            return null;
        }

    }

    //
    //    public Object getCellObject() {
    //        Point mousePosition = getMousePosition();
    //        if (mousePosition == null) {
    //            return null;
    //        }
    //        int row = getTable().rowAtPoint(mousePosition);
    //        int col = getTable().columnAtPoint(mousePosition);
    //        return getTable().getValueAt(row, col);
    //    }


    public void setLinkedObject(OWLObject object) {
        if (object instanceof OWLEntity) {
            linkedObject = (OWLEntity) object;
            setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        }
        else {
            linkedObject = null;
            setCursor(defaultCursor);
        }
    }


    public OWLObject getLinkedObject() {
        return linkedObject;
    }


    public JComponent getComponent() {
        return this;
    }


    /**
     * The DnD behaviour for the matrix tree table
     */
    class MatrixDropTargetListener extends OWLObjectDropTargetListener {

        public MatrixDropTargetListener(MatrixTreeTable component) {
            super(component);
        }

        @Override
        public void dragOver(DropTargetDragEvent dtde) {
            super.dragOver(dtde);

            Transferable t = dtde.getTransferable();
            if (isAcceptableTransferable(t)) {
                if (getTable().getSelectedRows().length < 2) {
                    Point pt = dtde.getLocation();
                    int row = getTable().rowAtPoint(pt);
                    int col = getTable().columnAtPoint(pt);

                    if (row != -1) {
                        OWLObject obj = getDropObjects(t).iterator().next();
                        if (model.isSuitableCellValue(obj, row, col)) {
                            // Provide a bit of feedback by selecting the table row
                            getTable().getSelectionModel().setSelectionInterval(row, row);

                            setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
                        }
                        else{
                            setCursor(defaultCursor);
                        }
                    }
                }
            }
        }


        @Override
        public void dragExit(DropTargetEvent dte) {
            super.dragExit(dte);
            setCursor(defaultCursor);
        }
    }
}