AbstractElementList.java

Go to the documentation of this file.

package com.arcle.rmt.j2se.swing.vc;

import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;

import java.awt.event.MouseListener;
import java.awt.event.KeyListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
import java.awt.event.KeyEvent;
import java.awt.BorderLayout;

import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Observable;
import java.util.Observer;
import java.util.Vector;
import java.util.List;
import java.util.Map;
import java.util.ArrayList;
import java.util.Collection;

import com.arcle.rmt.rqml.Description;
import com.arcle.rmt.rqml.RQMLFirstClass;
import com.arcle.rmt.j2se.swing.ui.ComponentView;
import com.arcle.rmt.j2se.swing.ui.Controller;
import com.arcle.rmt.j2se.swing.ui.ExceptionSafeActionWrapper;
import com.arcle.rmt.j2se.framework.Document;
import com.arcle.rmt.j2se.model.RQMLDocument;
import com.arcle.rmt.j2se.model.RQMLDocumentUpdateEvent;
import com.arcle.rmt.j2se.model.RQMLFirstClassFactory;
import com.arcle.rmt.j2se.util.GenericClassMap;
import com.arcle.rmt.j2se.util.ClassMapVisitor;
import com.arcle.rmt.j2se.util.MoreCollections;
import com.arcle.rmt.j2se.util.CollectionVisitor;
import com.arcle.rmt.xplat.util.MutableBoolean;


public abstract class AbstractElementList extends ComponentView {

    protected AbstractElementList(ElementEditFactory f) {
        _editFactory = f;
    }

    //-----------------------------------------------------------------------
    // Strategy Methods

    protected void doEditElement(RQMLFirstClass elem) {
        if (shouldOpenElementEditors) {
            // the editor window will be automatically displayed.
            ElementEdit ee = getElementEditFactory().createElementEdit(elem);
            ee.setDocument(getDocument());
        }
    }

    protected void initChildren() { }

    protected void layoutChildren() {
        setLayout(new BorderLayout());
        JSplitPane sp1;

        // left panel
        sp1 = createSplitPane(JSplitPane.VERTICAL_SPLIT);
        sp1.add(createScrollPane(getTree()), JSplitPane.TOP);
        sp1.add(createScrollPane(getCurrentDescription()), JSplitPane.BOTTOM);
        sp1.setOneTouchExpandable(true);
        sp1.setResizeWeight(PANE_WEIGHT);
        add(sp1, BorderLayout.CENTER);
    }


    //-----------------------------------------------------------------------
    // View implementations


    public void update(Observable o, Object param) {
        if(o != null && o == getDocument()) {
            if (param instanceof RQMLDocumentUpdateEvent) {
                RQMLDocumentUpdateEvent evt = (RQMLDocumentUpdateEvent) param;
                RQMLFirstClass elem = (RQMLFirstClass) evt.getElement();
                switch (evt.getEventType()) {
                case RQMLDocumentUpdateEvent.ET_NEW_ELEMENT:
                    handleNewElement(elem);
                    break;
                case RQMLDocumentUpdateEvent.ET_DELETING_ELEMENT:
                    handleDeleteElement(elem);
                    break;
                }
            }
        } else {
            super.update(o, param);
        }
    }

    public void setDocument(Document doc) {
        super.setDocument(doc);
        boolean hasDocument = doc != null;
        if (hasDocument) {
            loadData();
        }
        getTree().setEnabled(hasDocument);
        getCurrentDescription().setEnabled(hasDocument);
    }


    public Controller getController() {
        if (_controller == null) {
            _controller = createController();
        }
        return _controller;
    }

    protected ElementTypeNodeFacade getElementTypeNodeFacade() {
        if (_nodeFacade == null) {
            _nodeFacade = createElementTypeNodeFacade();
        }
        return _nodeFacade;
    }


    //-----------------------------------------------------------------------
    // Own implementations

    protected void handleNewElement(RQMLFirstClass elem) {
        createChild(elem);
    }

    protected void handleDeleteElement(RQMLFirstClass elem) {
        deleteChild(elem);
    }

    protected void createChild(final RQMLFirstClass elem) {
        ElementTypeNode node = (ElementTypeNode)
            getElementTypeNodeFacade().findFirstInstance(elem);
        if (node != null) {
            // ask the node to create a child
            node.createChild(elem);
        } else {
            throw new UnsupportedOperationException(
                "Cannot create child for element: " + elem);
        }
    }

    protected void deleteChild(final RQMLFirstClass elem) {
        ElementTypeNode node = (ElementTypeNode)
            getElementTypeNodeFacade().findFirstInstance(elem);
        if (node != null) {
            // ask the node to create a child
            node.deleteChild(elem);
        } else {
            throw new UnsupportedOperationException(
                "Cannot delete child for element: " + elem);
        }
    }


    protected void loadData() {
        RQMLDocument doc = getRQMLDocument();
        if (doc == null) {
            throw new IllegalStateException(
                "Must set document before calling loadData()");
        }
        clearTypeNodes();
        // don't open editors while we're loading document.
        shouldOpenElementEditors = false;
        try {
            Iterator elems = doc.getElements();
            while (elems.hasNext()) {
                Object elem = elems.next();
                createChild((RQMLFirstClass) elem);
            }
            TreeModelAdapter tm = (TreeModelAdapter) getTreeModel();
            tm.reload();
        } finally {
            shouldOpenElementEditors = true;
        }
    }

    protected void clearTypeNodes() {
        ClassMapVisitor visitor = new ClassMapVisitor() {
            public boolean visitClassMap(Class cls, Object obj) {
                ElementTypeNode node = (ElementTypeNode) obj;
                node.clear();
                return true;
            }
        };
        getElementTypeNodeFacade().visitClasses(visitor);
    }


    //-----------------------------------------------------------------------
    // Factory Methods

    protected JTree createTree() {
        JTree tree = new JTree();
        tree.setModel(getTreeModel());
        tree.getSelectionModel().setSelectionMode(
            TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setEnabled(false); // initially disabled
        //tree.putClientProperty("JTree.lineStyle", "Horizontal");
        TreeController ctrl = createTreeController();
        tree.addTreeSelectionListener(ctrl);
        tree.addMouseListener(ctrl);
        tree.addKeyListener(ctrl);
        return tree;
    }

    protected TreeController createTreeController() {
        return new TreeController();
    }

    protected DescriptionText createCurrentDescription() {
        DescriptionText dt = new DescriptionText();
        dt.setEnabled(false); // initially disabled
        dt.setLineWrap(true);
        dt.setWrapStyleWord(true);
        return dt;
    }

    protected JScrollPane createScrollPane(JComponent c) {
        return new JScrollPane(c);
    }

    protected JSplitPane createSplitPane(int splitMode) {
        return new JSplitPane(splitMode);
    }

    protected RootNode createRootNode() {
        return new RootNode();
    }

    protected TreeModelAdapter createTreeModel() {
        return new TreeModelAdapter(createRootNode());
    }


    protected Controller createController() {
        return new ElementListController();
    }


    protected abstract ElementTypeNodeFacade createElementTypeNodeFacade();


    //-----------------------------------------------------------------------
    // accessor methods

    protected JTree getTree() {
        if (_tree == null) {
            _tree = createTree();
        }
        return _tree;
    }

    protected DescriptionText getCurrentDescription() {
        if (_currentDescription == null) {
            _currentDescription = createCurrentDescription();
        }
        return _currentDescription;
    }

    protected RQMLDocument getRQMLDocument() {
        return (RQMLDocument) getDocument();
    }


    protected TreeModelAdapter getTreeModel() {
        if (_treeModel == null) {
            _treeModel = createTreeModel();
        }
        return _treeModel;
    }

    protected RootNode getRootNode() {
        return (RootNode) getTreeModel().getRoot();
    }

    protected ElementEditFactory getElementEditFactory() {
        return _editFactory;
    }


    //-----------------------------------------------------------------------

    protected boolean shouldOpenElementEditors = true;

    private JTree _tree = null;

    private DescriptionText _currentDescription = null;


    private Controller _controller;

    private TreeModelAdapter _treeModel = null;

    private ElementEditFactory _editFactory;


    private ElementTypeNodeFacade _nodeFacade = null;

    private static final float PANE_WEIGHT = 0.8f;

    //-----------------------------------------------------------------------
    // Controller classes

    protected class TreeController implements TreeSelectionListener,
            MouseListener, KeyListener {

        //-------------------------------------------------------------------
        // TreeSelectionListener implementations

        public void valueChanged(TreeSelectionEvent e) {
            JTree tree = getTree();
            if (e.getSource() != tree || !tree.isEnabled()) {
                // this isn't the tree we're supposed to control
                // or the tree is disabled.
                return;
            }
            DescriptionText desc = getCurrentDescription();

            Object path = tree.getLastSelectedPathComponent();
            if (path instanceof ElementTypeNode) {
                ElementTypeNode node = (ElementTypeNode) path;
                desc.setDescription(null);
            } else if (path instanceof ElementNode) {
                ElementNode node = (ElementNode) path;
                RQMLFirstClass elem = node.getElement();
                desc.setDescription(elem.getDescription());
            }
        }

        //-------------------------------------------------------------------
        // MouseListener implementations

        public void mouseClicked(MouseEvent e) { }

        public void mouseEntered(MouseEvent e)  { }

        public void mouseExited(MouseEvent e) { }

        public void mousePressed(MouseEvent e) {
            JTree tree = getTree();
            if (e.getSource() != tree || !tree.isEnabled()) {
                // this isn't the tree we're supposed to control
                // or the tree is disabled.
                return;
            }

            int selRow = tree.getRowForLocation(e.getX(), e.getY());
            TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
            if (selRow != -1) {
                if(e.getClickCount() == 2) {
                    Object clicked = selPath.getLastPathComponent();
                    if (clicked instanceof Node) {
                        doEditNode((Node) clicked);
                    }
                }
            }
        }

        public void mouseReleased(MouseEvent e) { }

        //-------------------------------------------------------------------
        // KeyListener implementations

        public void keyPressed(KeyEvent e) {
            JTree tree = getTree();
            if (e.getSource() != tree || !tree.isEnabled()) {
                // this isn't the tree we're supposed to control
                // or the tree is disabled
                return;
            }

            Object selected = tree.getLastSelectedPathComponent();
            if (selected instanceof Node) {
                switch (e.getKeyCode()) {
                case KeyEvent.VK_ENTER:
                    doEditNode((Node) selected);
                    break;
                }
            }
        }

        public void keyReleased(KeyEvent e) { }

        public void keyTyped(KeyEvent e) { }

        //-------------------------------------------------------------------
        // strategy methods

        protected void doEditNode(Node node) {
            if (node instanceof ElementTypeNode) {
                ElementTypeNode etn = (ElementTypeNode) node;
                etn.cmNewElement();
            } else if (node instanceof ElementNode) {
                ElementNode en = (ElementNode) node;
                en.cmEditElement();
            } else {
                // System.out.println(node);
            }
        }
    }

    protected class ElementListController implements Controller {
        public List getActions() {
            ElementTypeNodeFacade facade
                = (ElementTypeNodeFacade) getElementTypeNodeFacade();
            Collection nodes = facade.getNodes();
            final List actions = new ArrayList(nodes.size());

            CollectionVisitor visitor = new CollectionVisitor() {
                public boolean visitCollection(Object element) {
                    ElementTypeNode node = (ElementTypeNode) element;
                    actions.add(createActionWrapper(node.getNewElementAction()));
                    return true;
                }
            };

            MoreCollections.visitCollection(nodes, visitor);
            return actions;
        }

        protected Action createActionWrapper(Action wrapped) {
            return new ExceptionSafeActionWrapper(AbstractElementList.this,
                wrapped);
        }
    }

    //-----------------------------------------------------------------------
    // Custom Components

    protected class DescriptionText extends JTextArea implements Observer {
        public DescriptionText() {
            setEditable(false);
        }

        public void update(Observable source, Object param) {
            if (desc != null && (source == desc || param == desc) ) {
                setText(desc.getString());
            }
        }

        public void setDescription(Description d) {
            if (d == desc) {
                return;
            }
            Description old = desc;
            if (desc != null && isEditable()) {
                desc.setString(getText());
                if (desc instanceof Observable) {
                    ((Observable) desc).deleteObserver(this);
                }
            }
            desc = d;
            if (desc instanceof Observable) {
                ((Observable) desc).addObserver(this);
            }
            if (desc != null) {
                setText(desc.getString());
            }
            //setEditable(desc != null);
            this.firePropertyChange("description", old, desc);
        }

        protected Description desc = null;
    }

    //-----------------------------------------------------------------------
    // Model Adapters

    protected class TreeModelAdapter extends DefaultTreeModel {
        public TreeModelAdapter(RootNode root) {
            super(root, true);
        }

        //-------------------------------------------------------------------
    }

    protected abstract class Node implements TreeNode {
        public Node(Node p) {
            parent = p;
        }

        public TreeNode getChildAt(int childIndex) {
            return (TreeNode) getChildren().get(childIndex);
        }

        public int getChildCount() {
            return getChildren().size();
        }

        public TreeNode getParent() {
            return parent;
        }

        public int getIndex(TreeNode node) {
            return getChildren().indexOf(node);
        }

        public boolean getAllowsChildren() {
            return true;
        }

        public boolean isLeaf() {
            return false;
        }

        public Enumeration children() {
            return Collections.enumeration(getChildren());
        }

        protected List getChildren() {
            if (children == null) {
                children = createChildren();
            }
            return children;
        }

        protected abstract List createChildren();

        private List children = null;

        private Node parent;
    }


    protected class ElementTypeNode extends Node {
        public ElementTypeNode(RootNode p, String t, NewElementAction f) {
            super(p);
            title = t;
            elementFactory = f;
        }

        public boolean getAllowsChildren() {
            return true;
        }

        public String toString() {
            return title;
        }

        public boolean isLeaf() {
            return false;
        }

        protected List createChildren() {
            return new Vector();
        }


        public void clear() {
            getChildren().clear();
        }

        //-------------------------------------------------------------------
        // Own implementation methods

        public void cmNewElement() {
            // the element will be created in the document and the
            // editor window will be automatically displayed.
            elementFactory.createRQMLFirstClass();
        }

        public void createChild(RQMLFirstClass elem) {
            ElementNode child = new ElementNode(this, elem);
            List children = getChildren();
            children.add(child);
            doEditElement(elem);
            getTreeModel().nodesWereInserted(this, new int[]{children.size()-1});
        }

        public void deleteChild(RQMLFirstClass elem) {
            Iterator iter = getChildren().iterator();
            while (iter.hasNext()) {
                ElementNode cur = (ElementNode) iter.next();
                if (cur.getElement() == elem) {
                    cur.notifyRemoved();
                    iter.remove();
                }
            }
            getTreeModel().nodeStructureChanged(this);
        }


        public Action getNewElementAction() {
            return elementFactory;
        }

        //-------------------------------------------------------------------
        // Member variables

        protected String title;

        protected NewElementAction elementFactory;
    }

    protected class ElementNode extends Node implements Observer {
        public ElementNode(ElementTypeNode p, RQMLFirstClass elem) {
            super(p);
            _element = elem;
            addObservable(elem);
        }

        public String toString() {
            RQMLFirstClass e = getElement();
            String id = e.getID();
            String name = e.getName().getString();
            return (id != null ? id : "") + " " + (name != null ? name : "");
        }

        public boolean isLeaf() {
            return true;
        }

        public boolean getAllowsChildren() {
            return false;
        }

        protected List createChildren() {
            return null;
        }

        //-------------------------------------------------------------------
        // Observable implementation

        public void update(Observable source, Object param) {
            getTreeModel().nodeChanged(this);
        }

        //-------------------------------------------------------------------
        // Own implementation

        public RQMLFirstClass getElement() {
            return _element;
        }


        public void cmEditElement() {
            doEditElement(getElement());
            getTreeModel().nodeChanged(this);
        }

        public void notifyRemoved() {
            deleteObservable(getElement());
        }

        protected boolean addObservable(Object observable) {
            if (observable instanceof Observable) {
                Observable obs = (Observable) observable;
                obs.addObserver(this);
                return true;
            }
            return false;
        }

        protected boolean deleteObservable(Object observable) {
            if (observable instanceof Observable) {
                Observable obs = (Observable) observable;
                obs.deleteObserver(this);
                return true;
            }
            return false;
        }

        //-------------------------------------------------------------------
        // Member Variables

        private RQMLFirstClass _element;
    }

    protected class RootNode extends Node {
        public RootNode() {
            super(null);
        }

        public String toString() {
            return "RQML";
        }

        protected List createChildren() {
            return new ArrayList(getElementTypeNodeFacade().getNodes());
        }

    }

    //-----------------------------------------------------------------------
    // ElementTypeNodeFacade

    protected abstract class ElementTypeNodeFacade extends GenericClassMap {

        public ElementTypeNode getElementTypeNode(Class interfaceClass) {
            return (ElementTypeNode) getMappings().get(interfaceClass);
        }

        public Collection getNodes() {
            return getMappings().values();
        }

        protected abstract Map createMappings();
    }

    //-----------------------------------------------------------------------
    // Action classes

    protected abstract class NewElementAction extends AbstractAction
            implements RQMLFirstClassFactory, PropertyChangeListener {

        public NewElementAction(String name) {
            super(name);
            AbstractElementList.this.addPropertyChangeListener(this);
            checkEnabled();
        }

        //-------------------------------------------------------------------
        // RQMLFirstClassFactory methods

        public abstract RQMLFirstClass createRQMLFirstClass();

        //-------------------------------------------------------------------
        // AbstractAction implementations

        public void actionPerformed(ActionEvent e) {
            // the element will be created in the document and the
            // editor window will be automatically displayed.
            createRQMLFirstClass();
        }

        //-------------------------------------------------------------------
        // PropertyChangeListener implementations

        public void propertyChange(PropertyChangeEvent evt) {
            if (evt.getSource() == AbstractElementList.this) {
                if ("document".equals(evt.getPropertyName())) {
                    checkEnabled();
                }
            }
        }

        //-------------------------------------------------------------------
        // Own implementations

        protected void checkEnabled() {
            setEnabled(getDocument() != null);
        }
    }
}

---