/*
 * Copyright (c) 2012 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2015-08-24 22:44:14 +0000 (Mon, 24 Aug 2015) $' 
 * '$Revision: 33630 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */

package org.kepler.gui.frame;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.KeyStroke;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import org.kepler.gui.KeplerGraphFrame;
import org.kepler.gui.ModelToFrameManager;
import org.kepler.gui.TabManager;
import org.kepler.gui.TabPane;
import org.kepler.gui.TabbedCompositeTabComponent;
import org.kepler.gui.WorkflowOutlineTabPane;
import org.kepler.gui.state.StateChangeMonitor;
import org.kepler.moml.NamedObjIdChangeRequest;
import org.kepler.objectmanager.ObjectManager;

import diva.canvas.event.LayerAdapter;
import diva.canvas.event.LayerEvent;
import diva.graph.GraphModel;
import diva.graph.GraphPane;
import diva.graph.JGraph;
import ptolemy.actor.CompositeActor;
import ptolemy.actor.gui.Configuration;
import ptolemy.actor.gui.SizeAttribute;
import ptolemy.actor.gui.Tableau;
import ptolemy.actor.lib.hoc.MultiCompositeActor;
import ptolemy.kernel.CompositeEntity;
import ptolemy.kernel.util.ChangeRequest;
import ptolemy.kernel.util.IllegalActionException;
import ptolemy.kernel.util.NameDuplicationException;
import ptolemy.kernel.util.NamedObj;
import ptolemy.moml.LibraryAttribute;
import ptolemy.moml.MoMLChangeRequest;
import ptolemy.util.MessageHandler;
import ptolemy.vergil.actor.ActorEditorGraphController;
import ptolemy.vergil.actor.ActorGraphModel;
import ptolemy.vergil.basic.AbstractBasicGraphModel;
import ptolemy.vergil.basic.EditorDropTarget;

/** This is a graph editor frame that uses a tabbed pane to display
    multiple composite actors.  
  
 TODO:

    go to actor in exception dialog does not switch tabs
    fix NamedObjId errors when closing (KGF calls dispose() twice, second time getModel() returns null)
    
 DONE:
    zoom and window position not saved in composite tabs
        fix: override of updateWindowAttributes() along with refactoring methods
        in BasicGraphFrame for getting the center, etc.
    support nested tabs for case/execution choice actors
    double-click on tab to make separate window
    frame close button closes tab instead of frame
        fix: remove _close() override
    add non-composites to tab: atomic actor source code
        difficult since not opened in graph frame
    does not save window size? see bug http://bugzilla.ecoinformatics.org/show_bug.cgi?id=5637
    do not place in tabbed pane when no other composites open
    canvas scroll bars missing
        fix: update scrollbars to use selected sub-workflow in stateChanged()
    update outline tree when selected tab changes
        fix: refresh outline pane in stateChanged()
    change color of X for closing tab on rollover
    new in/out port buttons on toolbar place ports in top level instead of subwf
        fix: uncomment TabbedKeplerController.getGraphModel(), see next fix.
    one actor in composites rendered wrong when opened the first time
        fix: in _createGraphPane
    resize tab component on renames
        fix: call invalidate() in TabbedCompositeTabComponent.refreshName()
    cmd-l on composite not already opened should open in new window, not tab
        fix: added LookInsideTabbedComposite.actionIsRunning()
    rename tabs when composite names are changed
    rename tabs when parent composite is renamed
    delete tabs when composite is deleted
    delete tabs when composite parent is deleted
    ports are displayed wrong (probably controller)
        fix: updated ActorEditorGraphController to add port layout listener when using alternative actor controllers
    when tab changes, panner is repainted, but panner does not show actor highlight changes
        (same behavior in ptolemy; no fix)
    file->close / cmd-w should close selected tab
    open composite on one already opened set selected tab
    add X button to tabs to close
    close tab via button, then can't open again (need to close tableau?)
    frame title is wrong: seems to be set to last opened composite
    focus stops working (fix: use MultiCompositeController from CaseGraphFrame?)
    cmd-l on already opened composite should switch to tab
    clean up LookInsideAction, controller stuff

    @author Daniel Crawl
    @version $Id: TabbedKeplerGraphFrame.java 33630 2015-08-24 22:44:14Z crawl $

*/
public class TabbedKeplerGraphFrame extends KeplerGraphFrame implements ChangeListener {
    /** Construct a frame associated with the specified composite actor.
     *  After constructing this, it is necessary
     *  to call setVisible(true) to make the frame appear.
     *  This is typically done by calling show() on the controlling tableau.
     *  This constructor results in a graph frame that obtains its library
     *  either from the model (if it has one) or the default library defined
     *  in the configuration.
     *  @see Tableau#show()
     *  @param entity The model to put in this frame.
     *  @param tableau The tableau responsible for this frame.
     */
    public TabbedKeplerGraphFrame(CompositeActor entity, Tableau tableau) {
        this(entity, tableau, null);
    }

    /** Construct a frame associated with the specified composite actor.
     *  After constructing this, it is necessary
     *  to call setVisible(true) to make the frame appear.
     *  This is typically done by calling show() on the controlling tableau.
     *  This constructor results in a graph frame that obtains its library
     *  either from the model (if it has one), or the <i>defaultLibrary</i>
     *  argument (if it is non-null), or the default library defined
     *  in the configuration.
     *  @see Tableau#show()
     *  @param entity The model to put in this frame.
     *  @param tableau The tableau responsible for this frame.
     *  @param defaultLibrary An attribute specifying the default library
     *   to use if the model does not have a library.
     */
    public TabbedKeplerGraphFrame(CompositeActor entity, Tableau tableau,
            LibraryAttribute defaultLibrary) {
        super(entity, tableau, defaultLibrary);        
     }

    ///////////////////////////////////////////////////////////////////
    ////                         public methods                    ////
    
    /** Add a new tab for a model. */
    public void addComposite(CompositeEntity model,
            TabbedKeplerGraphTableau keplerGraphMultiCompositeTableau,
            LibraryAttribute defaultLibrary) {

        Component component = _addCompositeToPane(model, keplerGraphMultiCompositeTableau);
        if(component instanceof JGraph) {
                ((TabbedKeplerController) _controller)._addHotKeys((JGraph)component);
        }
        
        try {
            if(component instanceof JGraph) {
                _setJGraphSize((JGraph) component, model);
                _initBasicGraphFrameSetZoomAndPane(model, (JGraph) component);
            } else if(component instanceof JTabbedPane) {
                for (Component subComponent : ((JTabbedPane)component).getComponents()) {
                    if (subComponent instanceof JGraph) {
                        JGraph subGraph = (JGraph) subComponent;
                        NamedObj subModel = ((AbstractBasicGraphModel) subGraph.getGraphPane().getGraphModel()).getPtolemyModel();
                        _setJGraphSize(subGraph, subModel);
                        _initBasicGraphFrameSetZoomAndPane(subModel, subGraph);
                    }
                }
            }
        } catch (IllegalActionException e) {
            MessageHandler.error("Error setting zoom and pane.", e);
        }
        
    }    
    
    /** Add a menu to the menu bar. */
    public void addMenu(JMenu menu) {
        _menubar.add(menu);
        setJMenuBar(_menubar);
    }
        
    /** Create a new tab displaying the contents of a composite actor
     *  inside of an existing tab for a MultiCompositeActor.
     */
    public void addSubComposite(CompositeEntity composite) {
        
        final CompositeEntity container = (CompositeEntity) composite.getContainer();
        
        // find the tab belonging to the container
        Component containerComponent = _findComponentForModel(container);
        if(containerComponent == null) {
            MessageHandler.error("ERROR: could not find container component for " + container.getFullName());
            return;
        }
        
        if(!(containerComponent instanceof JTabbedPane)) {
            MessageHandler.error("ERROR: container component for "  + container.getFullName() +
                    " is not a tabbed pane.");
            return;
        }
        
        JTabbedPane tabbedPane = (JTabbedPane)containerComponent;
        Component compositeComponent = _createComponentForComposite(composite);
        tabbedPane.add(compositeComponent);
        _modelManager.add(composite, this);
        
    }
    
    /** Listen for name changes in the model. */
    @Override
    public void changeExecuted(ChangeRequest change) {
        
        //System.out.println(change);
        
        if(_tabbedPane != null && (change instanceof MoMLChangeRequest) &&
            !(change instanceof NamedObjIdChangeRequest)) {
            //System.out.println("source = " + change.getSource());
            //System.out.println("context = " + ((MoMLChangeRequest)change).getContext());
            //System.out.println("description = " + change.getDescription());
            
            final NamedObj context = ((MoMLChangeRequest)change).getContext();
            final String description = change.getDescription();
            
            // see if something was renamed
            Matcher matcher = _MOML_RENAME_PATTERN.matcher(description);            
            if(matcher.find()) {
                //System.out.println("g1 = " + matcher.group(1) + " g2 = " + matcher.group(2));
                // get the previous name
                final String oldName = matcher.group(1);
                
                // construct the full name
                final String oldRenamedFullName = context.getFullName() + "." + oldName;
                // find the tab (if one exists) for the renamed composite.
                for(int i = 0; i < _tabbedPane.getTabCount(); i++) {
                    final TabbedCompositeTabComponent component = 
                        (TabbedCompositeTabComponent) _tabbedPane.getTabComponentAt(i);
                    final String componentFullName = component.getModelFullName();
                    if(componentFullName.startsWith(oldRenamedFullName)) {
                        component.refreshName();
                    }
                }              
            } else {
                // see if something was deleted
                matcher = _MOML_DELETE_PATTERN.matcher(description);
                if(matcher.find()) {
                    // get the item that was deleted
                    final String deletedName = matcher.group(1);

                    // construct the full name of the item deleted
                    final String deleteFullName = context.getFullName() + "." + deletedName;
                    final Set<Component> tabsToDelete = new HashSet<Component>();
                    for(int i = 0; i < _tabbedPane.getTabCount(); i++) {
                        final TabbedCompositeTabComponent tabComponent = 
                            (TabbedCompositeTabComponent) _tabbedPane.getTabComponentAt(i);
                        final String componentFullName = tabComponent.getModelFullName();
                        // find the tab (if one exists) for the deleted composite.
                        // also find any tabs that are models contained in the delete composite.
                        if(componentFullName.startsWith(deleteFullName)) {
                            tabsToDelete.add(_tabbedPane.getComponentAt(i));
                        }
                    }
                        
                    // remove the tabs
                    for(Component component : tabsToDelete) {
                        _removeTab(component);
                    }                    
                }
            }
        }
        
        // tell the parent class about the change
        // NOTE: this is necessary since KeplerGraphFrame.changeExecuted()
        // sets the frame as modified and repaints the jgraph and panner
        super.changeExecuted(change);
    }

    /** Free resources when closing. */
    @Override
    public void dispose() {
        
        // remove the sub-workflows in tabs from the object manager and
        // model to frame manager.
        if(_tabbedPane != null) {
            for(Component component : _tabbedPane.getComponents()) {
                _disposeComponent(component);
            }
            _tabbedPane.removeAll();
        }
        
        super.dispose();
    }
    
    /** Get the controller for a model contained in this frame. */
    /* FIXME: add support for tab containing a tabbed pane.
    public GraphController getControllerForModel(NamedObj model) {
        int tabCount = _tabbedPane.getTabCount();
        for(int i = 0; i < tabCount; i++) {
            GraphPane pane = ((JGraph) _tabbedPane.getComponentAt(i)).getGraphPane();
            if(((AbstractBasicGraphModel)pane.getGraphModel()).getPtolemyModel() == model) {
                return pane.getGraphController();
            }
        }
        return null;
    }
    */
    
    /** Return the JGraph instance that this view uses to represent the
     *  ptolemy model.
     *  @return the JGraph.
     *  @see #setJGraph(JGraph)
     */
    @Override
    public JGraph getJGraph() {
        if(_tabbedPane == null) {
            return super.getJGraph();
        } else {
            Component selectedTab = _tabbedPane.getSelectedComponent();
            // see if nothing is selected, which means the window is closing.
            if(selectedTab == null) {
                return super.getJGraph();
            } else if(selectedTab instanceof JGraph) {
                return (JGraph) selectedTab;
            } else if(selectedTab instanceof JTabbedPane) {
                Component selectedSubTab = ((JTabbedPane)selectedTab).getSelectedComponent();
                if(selectedSubTab instanceof JGraph) {
                    return (JGraph) selectedSubTab;
                }
            }
        }
        System.err.println("WARNING: getJGraph() could not find JGraph.");
        return null;
    }

    /** Return the model associated with the selected tab. If no tab
     *  is selected, returns the root model associated with this frame.
     */
    public NamedObj getSelectedModel() {
        if (_tabbedPane == null) {
            return getModel();
        } else {
            Component tab = _tabbedPane.getSelectedComponent();
            if (tab instanceof JGraph) {
                GraphPane pane = ((JGraph) tab).getGraphPane();
                return ((AbstractBasicGraphModel)pane.getGraphModel()).getPtolemyModel();
            } else if(tab instanceof JTabbedPane) {
                Component subTab = ((JTabbedPane)tab).getSelectedComponent();
                if(subTab instanceof JGraph) {
                    GraphPane pane = ((JGraph) subTab).getGraphPane();
                    return ((AbstractBasicGraphModel)pane.getGraphModel()).getPtolemyModel();                    
                }
            }
        }
        return null;
    }
    
    /** Remove a workflow from the frame. */
    public void removeComposite(NamedObj model) {
        Component component = _findComponentForModel(model);
        if(component != null) {
            _removeTab(component);
        }
    }
    
    /** Remove a menu from the menu bar. */
    public void removeMenu(JMenu menu) {
        _menubar.remove(menu);
        setJMenuBar(_menubar);
    }

    /** Set the selected tab to the tab containing a specific model. */
    public void setSelectedTab(NamedObj model) {
        Component component = _findComponentForModel(model);
        if(component != null) {
            _tabbedPane.setSelectedComponent(component);
        }
    }
    
    /** React to a change in the state of the tabbed pane.
     *  @param event The event.
     */
    @Override
    public void stateChanged(ChangeEvent event) {
        final Object source = event.getSource();
        
        if (source instanceof JTabbedPane) {            
            final Component selected = ((JTabbedPane) source).getSelectedComponent();
            
            JGraph selectedJGraph = null;
            NamedObj modelInTab = null;

            if (selected instanceof JGraph) {

                selectedJGraph = (JGraph) selected;
                modelInTab = ((AbstractBasicGraphModel)selectedJGraph.getGraphPane().
                        getGraphModel()).getPtolemyModel();

            } else if(selected instanceof JTabbedPane) {

                JTabbedPane selectedTabbedPane = (JTabbedPane)selected;
                Component subSelected = selectedTabbedPane.getSelectedComponent();
                
                if(subSelected instanceof JGraph) {
                    selectedJGraph = (JGraph) subSelected;
                    modelInTab = ((AbstractBasicGraphModel)selectedJGraph.getGraphPane().
                            getGraphModel()).getPtolemyModel().getContainer();
                }
                
            }
            
            if(selectedJGraph != null) {
                
                setJGraph(selectedJGraph);
                selected.requestFocus();        
                //System.out.println("changed focus");
                
                //notify any listeners that we've changed selected components
                StateChangeMonitor.getInstance().notifyStateChange(
                        new TabbedKeplerGraphFrameEvent(
                                (JTabbedPane) source, this, modelInTab));

                if (_graphPanner != null) {
                    _graphPanner.setCanvas(selectedJGraph);
                    _graphPanner.repaint();
                    //System.out.println("repainted panner");
                }
                
                // update the outline tab, if present, to be rooted at the
                // selected sub-workflow
                TabManager manager = TabManager.getInstance();
                TabPane outlinePane = manager.getTab(this, WorkflowOutlineTabPane.class);
                if(outlinePane != null) {
                    ((WorkflowOutlineTabPane)outlinePane).setWorkflow((CompositeEntity) modelInTab);
                }
                
                // update the scrollbars to use the selected sub-workflow
                if(_horizontalScrollBar != null) {
                    _horizontalScrollBar.setModel(getJGraph().getGraphPane().getCanvas()
                        .getHorizontalRangeModel());
                }
                if(_verticalScrollBar != null) {
                    _verticalScrollBar.setModel(getJGraph().getGraphPane().getCanvas()
                        .getVerticalRangeModel());
                }

            }
        }
    }
    
    /** Update the nested tabs displayed for a composite actor. This method
     *  removes tabs for sub-composites that no longer exist, and renames
     *  the tab titles to match the names of the sub-composites.
     */
    public void updateTabsForComposite(CompositeEntity composite) {
        
        if(composite instanceof MultiCompositeActor) {
            Component component = _findComponentForModel(composite);
            if(component == null) {
                System.err.println("ERROR: could not find component for " + composite.getFullName());
                return;
            }
            if(!(component instanceof JTabbedPane)) {
                System.err.println("ERROR: component for " + composite.getFullName() +
                        "is not a tabbed pane.");
                return;
            }
            
            JTabbedPane tabbedPane = (JTabbedPane)component;

            Set<Component> subComponentsToBeRemoved = new HashSet<Component>();
            for(Component subComponent : tabbedPane.getComponents()) {
                if(subComponent instanceof JGraph) {
                    
                    final int index = tabbedPane.indexOfComponent(subComponent);
                    
                    final NamedObj modelInTab = ((AbstractBasicGraphModel)((JGraph) subComponent).
                            getGraphPane().getGraphModel()).getPtolemyModel();
                    String name = modelInTab.getName();
                    if(composite.getEntity(name) == null) {
                        //System.out.println("going to remove " + name);
                        subComponentsToBeRemoved.add(subComponent);
                    } else if(!tabbedPane.getTitleAt(index).equals(name)) {
                        tabbedPane.setTitleAt(index, name);
                        //System.out.println("renaming to " + name);
                    }
                }
            }
            
            for(Component subComponent : subComponentsToBeRemoved) {
                tabbedPane.remove(subComponent);
                
                final NamedObj modelInTab = ((AbstractBasicGraphModel)((JGraph) subComponent).
                        getGraphPane().getGraphModel()).getPtolemyModel();
                _modelManager.removeModel(modelInTab);
            }
        }
    }
       
    /** Update the size, zoom and position of all the open tabs.
     *  This method is typically called when closing the window
     *  or writing the moml file out.
     *  @exception IllegalActionException If there is a problem
     *  getting a parameter.
     *  @exception NameDuplicationException If there is a problem
     *  creating a parameter.
     */
    @Override
    public void updateWindowAttributes() throws IllegalActionException,
        NameDuplicationException {

        if (_tabbedPane == null) {
            super.updateWindowAttributes();
        } else {
            _updateWindowAttributesForTabs(_tabbedPane);
        }
    }
    
    ///////////////////////////////////////////////////////////////////
    ////                         protected methods                 ////

    /** Create a new graph pane. Note that this method is called in
     *  constructor of the base class, so it must be careful to not reference
     *  local variables that may not have yet been created.
     *  This overrides the base class to create a specialized
     *  graph controller (an inner class).
     *  @param entity The object to be displayed in the pane.
     *  @return The pane that is created.
     */
    @Override
    protected GraphPane _createGraphPane(NamedObj entity) {

        
        ActorEditorGraphController controller;

        // the first time this is called, set the _controller.
        // otherwise, use an ActorEditorGraphController for the controller.
        // NOTE: if the controller is always set to a TabbedKeplerController,
        // it causes one actor to always be rendered twice on the canvas the
        // first time the tab is opened.
        
        if(_controller == null) {
            _controller = new TabbedKeplerController();
            controller = _controller;
        } else {
            controller = new ActorEditorGraphController();
        }
        
        controller.setConfiguration(getConfiguration());
        controller.setFrame(this);
        
        final ActorGraphModel graphModel = new ActorGraphModel(entity);
        return new GraphPane(controller, graphModel);
    }

    /** Create the component that goes to the right of the library.
     *  NOTE: This is called in the base class constructor, before
     *  things have been initialized. Hence, it cannot reference
     *  local variables.
     *  @param entity The entity to display in the component.
     *  @return The component that goes to the right of the library.
     */
    @Override
    protected JComponent _createRightComponent(NamedObj entity) {
        if (!(entity instanceof CompositeActor)) {
            return super._createRightComponent(entity);
        }

        _panel = new JPanel(new BorderLayout());
        
        final Component component = 
            _addCompositeToPane((CompositeEntity) entity, (TabbedKeplerGraphTableau) getTableau());
                    
        if(component instanceof JGraph) {
                setJGraph((JGraph) component);
        } else {
                throw new RuntimeException("Did not get JGraph for composite actor.");
        }
            
        // listen for changes so that we can change titles when the 
        // composite name changes, or close tabs when composites are
        // deleted from the model.
        entity.addChangeListener(this);

        return _panel;        
    }
        
    ///////////////////////////////////////////////////////////////////
    ////                         private methods                   ////

    /** Add a tabbed pane for the specified composite.
     *  @param composite The composite.
     *  @param newPane True to add the pane prior to the last pane.
     *  @return The pane.
     */
    private Component _addCompositeToPane(CompositeEntity composite,
            TabbedKeplerGraphTableau tableau) {

        final Component component = _createComponentForComposite(composite);
        
        // see if this is the first composite to be added
        if(_panel.getComponentCount() == 0) {
            _panel.add(component, BorderLayout.CENTER);
            _rootComposite = composite;
            _rootTableau = tableau;
        } else {
            
            if(_tabbedPane == null) {
                
                _tabbedPane = _createJTabbedPane();
                
                // remove the first workflow from the pane and put in the tab
                final JGraph firstJgraph = (JGraph) _panel.getComponent(0);
                _panel.remove(firstJgraph);
                _tabbedPane.add(firstJgraph, BorderLayout.CENTER);
                int index = _tabbedPane.indexOfComponent(firstJgraph);
                TabbedCompositeTabComponent tabComponent =
                    new TabbedCompositeTabComponent(_rootComposite, _rootTableau);
                _tabbedPane.setTabComponentAt(index, tabComponent);
                _tabbedPane.setSelectedIndex(index);
                _panel.add(_tabbedPane, BorderLayout.CENTER);
            }
            
            // add the new workflow
            _tabbedPane.add(component, BorderLayout.CENTER);
            int index = _tabbedPane.indexOfComponent(component);
            TabbedCompositeTabComponent tabComponent =
                new TabbedCompositeTabComponent(composite, tableau);
            _tabbedPane.setTabComponentAt(index, tabComponent);
            _tabbedPane.setSelectedIndex(index);
        }
                
        if(_modelManager == null) {
            _modelManager = ModelToFrameManager.getInstance();
        }
        _modelManager.add(composite, this);
        
        return component;
    }
    
    /** Create a Component displaying the composite actor. If the composite
     *  actor is a MultiCompositeActor containing multiple Refinements,
     *  this returns a JTabbedPane containing a tab with a JGraph for each
     *  of the Refinements. Otherwise, this returns a JGraph displaying
     *  the contents of the composite.
     */
    private Component _createComponentForComposite(CompositeEntity composite) {
    
        Component component = null;
        
        if(composite instanceof MultiCompositeActor) {
                
                JTabbedPane tabbedPane = _createJTabbedPane();
                
            List<CompositeEntity> containedComposites = composite.entityList(CompositeEntity.class);
            for(CompositeEntity containedComposite : containedComposites) {             
                Component subComponent = _createComponentForComposite(containedComposite);
                tabbedPane.add(subComponent);//, BorderLayout.CENTER);
                _modelManager.add(containedComposite, this);
            }
            
                component = tabbedPane;
        
        } else {
                
                GraphPane pane = _createGraphPane(composite);
                pane.getForegroundLayer().setPickHalo(2);
                pane.getForegroundEventLayer().setConsuming(false);
                pane.getForegroundEventLayer().setEnabled(true);
                pane.getForegroundEventLayer().addLayerListener(new LayerAdapter() {
                    /** Invoked when the mouse is pressed on a layer
                     * or figure.
                     */
                    @Override
                    public void mousePressed(LayerEvent event) {
                        Component eventComponent = event.getComponent();
        
                        if (!eventComponent.hasFocus()) {
                            eventComponent.requestFocus();
                            //System.out.println("set focus to " + component);
                        }
                    }
                });
                component = new JGraph(pane);
                
            component.setBackground(BACKGROUND_COLOR);
            // Create a drop target for the jgraph.
            // FIXME: Should override _setDropIntoEnabled to modify all the drop targets created.
            new EditorDropTarget((JGraph) component);

        }

        String name = composite.getName();
        // if the composite does not have a name, use the effigy's name
        if(name.isEmpty()) {
            name = _getName();
        }
        component.setName(name);

        return component;
    
    }
        
    /** Do not override _close() since we want to close the frame if the frame's
     *  close button is pushed instead of closing the tab.
     */
    /*
    @Override
    protected boolean _close() {
        
        if(_tabbedPane == null) {
            return super._close();
        } else {
            // remove the selected tab
            _removeTab(_tabbedPane.getSelectedComponent());
            return true;
        }
    }
    */
    
    /** Remove the tab for a component. */
    private void _removeTab(Component component) {

        /*
        if(component instanceof JGraph) {
            //final JGraph jgraph = (JGraph) component;
            //final NamedObj modelInTab = 
                //((AbstractBasicGraphModel)jgraph.getGraphPane().getGraphModel()).getPtolemyModel();
            //modelInTab.removeChangeListener(this);
        */

        final int index = _tabbedPane.indexOfComponent(component);
        final TabbedCompositeTabComponent tabComponent =
            (TabbedCompositeTabComponent) _tabbedPane.getTabComponentAt(index);
        final Tableau tableau = tabComponent.getTableau();
        try {
            tableau.setContainer(null);
        } catch (Exception e) {
            MessageHandler.error("Error closing tableau.", e);
        }
                 
        if(component instanceof JGraph) {
            final NamedObj modelInTab = 
                ((AbstractBasicGraphModel)((JGraph) component).getGraphPane().getGraphModel()).getPtolemyModel();
            _modelManager.removeModel(modelInTab);
        } else if(component instanceof JTabbedPane) {
            JTabbedPane subPane = (JTabbedPane)component;
            NamedObj container = null;
            for(Component subComponent : subPane.getComponents()) {
                if(subComponent instanceof JGraph) {
                    final NamedObj modelInTab = 
                            ((AbstractBasicGraphModel)((JGraph) subComponent).getGraphPane().getGraphModel()).getPtolemyModel();
                    _modelManager.removeModel(modelInTab);
                    container = modelInTab.getContainer();
                }
            }
            subPane.removeChangeListener(this);
            subPane.removeAll();
                _modelManager.removeModel(container);
        }
        
        _tabbedPane.remove(component);
        

        // if only one tab left, move back to panel
        if(_tabbedPane.getTabCount() == 1) {
            final Component firstComponent = _tabbedPane.getComponentAt(0);
            _panel.remove(_tabbedPane);
            _tabbedPane.removeChangeListener(this);
            _tabbedPane = null;
            _panel.add(firstComponent, BorderLayout.CENTER);
        }
    }
    
    /** Create a tabbed pane for the composite models. */
    private JTabbedPane _createJTabbedPane() {
        
        JTabbedPane tabbedPane = new JTabbedPane(JTabbedPane.TOP, JTabbedPane.WRAP_TAB_LAYOUT);
        tabbedPane.addChangeListener(this);
        //_tabbedPane.setTabLayoutPolicy(JTabbedPane.WRAP_TAB_LAYOUT);

        // register keyboard shortcut to scroll tabs left
        final ActionListener actionSelectLeft = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent event) {
                final JTabbedPane pane = (JTabbedPane)event.getSource();
                final int newIndex = pane.getSelectedIndex() - 1;
                pane.setSelectedIndex(newIndex < 0 ? pane.getTabCount() - 1 : newIndex);
            }
        };

        tabbedPane.registerKeyboardAction(actionSelectLeft, 
                KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, InputEvent.META_DOWN_MASK),
                JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        // register keyboard shortcut to scroll tabs right
        final ActionListener actionSelectRight = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent event) {
                final JTabbedPane pane = (JTabbedPane)event.getSource();
                final int newIndex = (pane.getSelectedIndex() + 1) % pane.getTabCount();
                pane.setSelectedIndex(newIndex);
            }
        };
        
        tabbedPane.registerKeyboardAction(actionSelectRight,
                KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, InputEvent.META_DOWN_MASK),
                JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        /*
        TabbedPaneUI foo = _tabbedPane.getUI();
        _tabbedPane.setUI(new BasicTabbedPaneUI() {  
            @Override  
            protected int calculateTabAreaHeight(int tabPlacement, int horizRunCount, int maxTabHeight) {  
                if (_tabbedPane.getTabCount() > 1) {  
                    return super.calculateTabAreaHeight(tabPlacement, horizRunCount, maxTabHeight);  
                } else {  
                    return 0;  
                }  
            }
            @Override  
            protected void paintTab(Graphics g, int tabPlacement, Rectangle[] rects, int tabIndex, Rectangle iconRect, Rectangle textRect) {  
                if (_tabbedPane.getTabCount() > 1) {  
                    super.paintTab(g, tabPlacement, rects, tabIndex, iconRect, textRect);  
                }  
            }  
        });  
        
        */
        
        // add a MouseListener that handles double-clicks on the tabs.
        // when a tab is double-clicked, open the sub-workflow in a separate
        // frame and remove from the tabbed pane.
        tabbedPane.addMouseListener(new MouseListener() {

            @Override
            public void mouseClicked(MouseEvent event) {
                
                if(event.getClickCount() == 2) {
                    final Object source = event.getSource();
                    if (source instanceof JTabbedPane) {            
                        final Component selected = ((JTabbedPane) source).getSelectedComponent();
                        if (selected instanceof JGraph) {
                            final JGraph jgraph = (JGraph) selected;
                            GraphModel graphModel = jgraph.getGraphPane().getGraphModel();
                            if(graphModel instanceof ActorGraphModel) {
                                NamedObj model = ((ActorGraphModel)graphModel).getPtolemyModel();

                                // make sure it's not the top level workflow
                                if(model.toplevel() != model) {
                                    TabbedKeplerGraphFrame frame =
                                            (TabbedKeplerGraphFrame) _modelManager.getFrame(model);
                                    if(frame != null) {
                                        frame.removeComposite(model);
                                    }
                                    Configuration configuration = (Configuration) Configuration
                                            .configurations().get(0);
                                    try {
                                        configuration.openModel(model);
                                    } catch (IllegalActionException | NameDuplicationException e) {
                                        MessageHandler.error("Error opening sub-workflow in separate window.", e);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            @Override
            public void mousePressed(MouseEvent e) {
            }

            @Override
            public void mouseReleased(MouseEvent e) {
            }

            @Override
            public void mouseEntered(MouseEvent e) {
            }

            @Override
            public void mouseExited(MouseEvent e) {
            }
        });
        
        return tabbedPane;
    }

    /** Dispose of a Component in a tabbed pane. If the Component is a JGraph,
     *  this method removes the references in the ObjectManager and ModelToFrameManager.
     *  If the Component is a JTabbedPane, this method recursively removes the 
     *  Components in each tab, and then disposes of the JTabbedPane.
     */
    private void _disposeComponent(Component component) {
        
        final ObjectManager objectManager = ObjectManager.getInstance();

        if(component instanceof JGraph) {
            final JGraph jgraph = (JGraph) component;
            final NamedObj modelInTab = ((AbstractBasicGraphModel)jgraph.getGraphPane().
                    getGraphModel()).getPtolemyModel();
            // make sure it's not the top-level workflow, which is
            // removed by KeplerGraphFrame
            if(modelInTab.getContainer() != null) {
                objectManager.removeNamedObjs(modelInTab);
                _modelManager.removeModel(modelInTab);                    
            }
        } else if(component instanceof JTabbedPane) {
            
            JTabbedPane subTabbedPane = (JTabbedPane)component;
            NamedObj container = null;
            while(subTabbedPane.getTabCount() > 0) {
                Component subComponent = subTabbedPane.getComponentAt(0);
                if(subComponent instanceof JGraph) {
                    final NamedObj modelInTab = ((AbstractBasicGraphModel)((JGraph) subComponent).
                            getGraphPane().getGraphModel()).getPtolemyModel();
                    container = modelInTab.getContainer();
                }
                _disposeComponent(subComponent);
                subTabbedPane.remove(0);
            }
            if(container != null) {
                objectManager.removeNamedObjs(container);
                _modelManager.removeModel(container);
            }
        }
    }

    /** Find the component for a NamedObj; returns null if not found. */
    private Component _findComponentForModel(NamedObj model) {
        // look through all the tabs
        if(_tabbedPane != null) {
            for(Component component : _tabbedPane.getComponents()) {
                if(component instanceof JGraph) {
                    final JGraph jgraph = (JGraph) component;
                    final NamedObj modelInTab = 
                        ((AbstractBasicGraphModel)jgraph.getGraphPane().getGraphModel()).getPtolemyModel();
                    // see if this tab's model matches
                    if(modelInTab == model) {
                        return component;
                    }
                } else if(component instanceof JTabbedPane) {
                        // the component is a tabbed pane containing one or more composites,
                        // e.g., refinements in a Case or ExecutionChoice actor.
                        if(((JTabbedPane)component).getComponentCount() > 0) {
                            Component subComponent = ((JTabbedPane)component).getComponentAt(0);
                        if(subComponent != null && (subComponent instanceof JGraph)) {
                            final NamedObj subModelInTab = 
                                    ((AbstractBasicGraphModel)((JGraph) subComponent).getGraphPane().getGraphModel()).getPtolemyModel();
                            // see if the contained of the submodel matches the model
                            if(subModelInTab.getContainer() == model) {
                                return component;
                            }
                        }
                        }
                }
            }
        }
        return null;
    }

    /** Set the size for a JGraph, from a SizeAttribute in the model.
     */
    private void _setJGraphSize(JGraph jgraph, NamedObj model) {
                
        if(jgraph != null) {
            try {
                // The SizeAttribute property is used to specify the size
                // of the JGraph component. Unfortunately, with Swing's
                // mysterious and undocumented handling of component sizes,
                // there appears to be no way to control the size of the
                // JGraph from the size of the Frame, which is specified
                // by the WindowPropertiesAttribute.
                SizeAttribute size = (SizeAttribute) model.getAttribute(
                        "_vergilSize", SizeAttribute.class);
                if (size != null) {
                    size.setSize(jgraph);
                } else {
                    // Set the default size.
                    // Note that the location is of the frame, while the size
                    // is of the scrollpane.
                    jgraph.setPreferredSize(new Dimension(600, 400));
                }
            } catch (Exception ex) {
                // Ignore problems here. Errors simply result in a default
                // size and location.
            }
        }
    }
    
    /** Update the size, zoom, and position of all the open graphs
     *  for a tabbed pane.
     *  @param tabbedPane The tabbed pane.
     */
    private void _updateWindowAttributesForTabs(JTabbedPane tabbedPane) throws IllegalActionException, NameDuplicationException {
        for (Component component : tabbedPane.getComponents()) {
            if (component instanceof JGraph) {
                GraphPane pane = ((JGraph) component).getGraphPane();
                _updateWindowAttributes(this, ((AbstractBasicGraphModel) pane.getGraphModel()).getPtolemyModel(),
                        (JGraph) component);
            } else if (component instanceof JTabbedPane) {
                _updateWindowAttributesForTabs((JTabbedPane) component);
            }
        }
    }

    ///////////////////////////////////////////////////////////////////
    ////                         private variables                 ////

    /** The root panel. This contains either a single JGraph if no
     *  composite actors have been opened, or _tabbedPane, which
     *  contains a tab for each open composite actor.
     *  
     *  NOTE: do not assign it null here since the assignment happens
     *  after the constructor which creates it in _createRightComponent().
     */
    private JPanel _panel; 

    /** The tabbed pane for composites. This is null if no
     *  composite actors have been opened.
     */
    private JTabbedPane _tabbedPane;
    
    /** The composite actor for which this frame was opened. */
    private CompositeEntity _rootComposite;    

    /** The tableau for which this frame was opened. */
    private TabbedKeplerGraphTableau _rootTableau;
    
    /** A regex for MoML change requests that rename actors. */
    private static final Pattern _MOML_RENAME_PATTERN = 
        Pattern.compile("entity name=\"(\\w+)\"><(?:rename|display) name=\"(\\w+)\"");

    /** A regex for MoML change requests that delete actors. */
    private static final Pattern _MOML_DELETE_PATTERN = Pattern.compile("deleteEntity name=\"(\\w+)\"");

    /** Model to frame mapping. */
    private ModelToFrameManager _modelManager;
    
    ///////////////////////////////////////////////////////////////////
    ////                     public inner classes                  ////

    /** Specialized graph controller that handles multiple graph models. */
    public class TabbedKeplerController extends ActorEditorGraphController {
        /** Override the base class to select the graph model associated
         *  with the selected pane.
         */
        @Override
        public GraphModel getGraphModel() {
           
            if(_panel != null) {
                if(_tabbedPane != null) {
                    //System.out.println("selected tab: " + _tabbedPane.getSelectedIndex());
                    Component tab = _tabbedPane.getSelectedComponent();
                    if (tab instanceof JGraph) {
                        GraphPane pane = ((JGraph) tab).getGraphPane();
                        return pane.getGraphModel();
                    } else if(tab instanceof JTabbedPane) {
                        Component subTab = ((JTabbedPane)tab).getSelectedComponent();
                        if(subTab instanceof JGraph) {
                            GraphPane pane = ((JGraph) subTab).getGraphPane();
                            return pane.getGraphModel();
                        }
                    }
                } else if(_panel.getComponentCount() > 0) {
                    JGraph jgraph = (JGraph) _panel.getComponent(0);
                    return jgraph.getGraphPane().getGraphModel();
                }
            }
            
            // Fallback position.
            //System.out.println(System.nanoTime() + " MultiCompositeController.getGraphModel could not find JGraph");
            return super.getGraphModel();            
        }
        

        /** Add hot keys to the actions in the given JGraph.
         *  This method is overridden so that we can call it in
         *  addComposite().
         *  @param jgraph The JGraph to which hot keys are to be added.
         */
        @Override
        protected void _addHotKeys(JGraph jgraph) {
            super._addHotKeys(jgraph);
        }
    }
}