*   Licensed to the Apache Software Foundation (ASF) under one

*  or more contributor license agreements.  See the NOTICE file

*  distributed with this work for additional information

*  regarding copyright ownership.  The ASF licenses this file

*  to you under the Apache License, Version 2.0 (the

*  "License"); you may not use this file except in compliance

*  with the License.  You may obtain a copy of the License at

*

*    http://www.apache.org/licenses/LICENSE-2.0

*

*  Unless required by applicable law or agreed to in writing,

*  software distributed under the License is distributed on an

*  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

*  KIND, either express or implied.  See the License for the

*  specific language governing permissions and limitations

*  under the License.

****************************************************************/

* A controller that works with the project tree, tracking selection and

* dispatching project events.

*/

    /*

     * A snapshot of the current state of the project controller. This was added

     * so that we could support history of recent objects.

     */

        private boolean isRefiring;

        private DisplayEvent event;

        private DataChannelDescriptor domain;

        private DataNodeDescriptor node;

        private DataMap map;

        private ObjEntity objEntity;

        private DbEntity dbEntity;

        private Embeddable embeddable;

        private EmbeddableAttribute[] embAttrs;

        private ObjAttribute[] objAttrs;

        private DbAttribute[] dbAttrs;

        private ObjRelationship[] objRels;

        private DbRelationship[] dbRels;

        private Procedure procedure;

        private ProcedureParameter[] procedureParameters;

        private Query query;

        /**

         * Paths of multiple selection

         */

        private Object[] paths;

        /**

         * currently selecte entity listener class

         */

        private String listenerClass;

        /**

         * currently selected callback type

         */

        private CallbackType callbackType;

        /**

         * currently selected callback methods

         */

        private String[] callbackMethods;

        public ControllerState() {

            // life is much easier if these guys are never null

            embAttrs = new EmbeddableAttribute[0];

            dbAttrs = new DbAttribute[0];

            dbRels = new DbRelationship[0];

            procedureParameters = new ProcedureParameter[0];

            objAttrs = new ObjAttribute[0];

            objRels = new ObjRelationship[0];

            callbackMethods = new String[0];

        }

        /*

         * Used to determine if the val ControllerState is equivalent, which

         * means if the event is refired again, will it end up in the same place

         * on the screen. This get's a bit messy at the end, because of

         * inheritance heirarchy issues.

         */

        public boolean isEquivalent(ControllerState val) {

            if (val == null)

                return false;

            if (event instanceof EntityDisplayEvent && val.event instanceof EntityDisplayEvent) {

                if (((EntityDisplayEvent) val.event).getEntity() instanceof ObjEntity) {

                    return objEntity == val.objEntity;

                } else {

                    return dbEntity == val.dbEntity;

                }

            } else if (event instanceof ProcedureDisplayEvent && val.event instanceof ProcedureDisplayEvent) {

                return procedure == val.procedure;

            } else if (event instanceof QueryDisplayEvent && val.event instanceof QueryDisplayEvent) {

                return query == val.query;

            } else if (event instanceof EmbeddableDisplayEvent && val.event instanceof EmbeddableDisplayEvent) {

                return embeddable == val.embeddable;

            } else if (event.getClass() == DataMapDisplayEvent.class && event.getClass() == val.event.getClass()) {

                return map == val.map;

            } else if (event.getClass() == DataNodeDisplayEvent.class && event.getClass() == val.event.getClass()) {

                return node == val.node;

            } else if (event.getClass() == DomainDisplayEvent.class && event.getClass() == val.event.getClass()) {

                return domain == val.domain;

            }

            return false;

        }

    }

    protected EventListenerList listenerList;

    protected boolean dirty;

    protected int entityTabSelection;

    protected Project project;

    protected Preferences projectControllerPreferences;

    protected ControllerState currentState;

    protected CircularArray controllerStateHistory;

    protected int maxHistorySize = 20;

    private EntityResolver entityResolver;

    /**

     * Project files watcher. When project file is changed, user will be asked

     * to confirm loading the changes

     */

    ProjectWatchdog watchdog;

    public ProjectController(CayenneModelerController parent) {

        super(parent);

        this.listenerList = new EventListenerList();

        controllerStateHistory = new CircularArray(maxHistorySize);

        currentState = new ControllerState();

    }

    @Override

    public Component getView() {

        return parent.getView();

    }

    public Project getProject() {

        return project;

    }

    public EntityResolver getEntityResolver() {

        return entityResolver;

    }

    public void setProject(Project currentProject) {

        if (this.project != currentProject) {

            this.project = currentProject;

            this.projectControllerPreferences = null;

            if (project == null) {

                this.entityResolver = null;

                if (watchdog != null) {

                    watchdog.interrupt();

                    watchdog = null;

                }

            } else {

                if (watchdog == null) {

                    watchdog = new ProjectWatchdog(this);

                    watchdog.start();

                }

                watchdog.reconfigure();

                entityResolver = new EntityResolver(

                        ((DataChannelDescriptor) currentProject.getRootNode()).getDataMaps());

                updateEntityResolver();

            }

        }

    }

    public void updateEntityResolver() {

        Collection<DataMap> dataMaps = ((DataChannelDescriptor) project.getRootNode()).getDataMaps();

        entityResolver.setDataMaps(dataMaps);

        for (DataMap dataMap : dataMaps) {

            dataMap.setNamespace(entityResolver);

        }

    }

    public Preferences getPreferenceForProject() {

        if (getProject() == null) {

            throw new CayenneRuntimeException("No Project selected");

        }

        if (projectControllerPreferences == null) {

            updateProjectControllerPreferences();

        }

        return projectControllerPreferences;

    }

    /**

     * Returns top preferences for the current project, throwing an exception if

     * no project is selected.

     */

    public Preferences getPreferenceForDataDomain() {

        DataChannelDescriptor dataDomain = (DataChannelDescriptor) getProject().getRootNode();

        if (dataDomain == null) {

            throw new CayenneRuntimeException("No DataDomain selected");

        }

        return getPreferenceForProject().node(dataDomain.getName());

    }

    /**

     * Returns preferences object for the current DataMap. If no preferences

     * exist for the current DataMap, a new Preferences object is created. If no

     * DataMap is currently selected, an exception is thrown. An optional

     * nameSuffix allows to address more than one defaults instance for a single

     * DataMap.

     */

    public DataMapDefaults getDataMapPreferences(String nameSuffix) {

        DataMap map = getCurrentDataMap();

        if (map == null) {

            throw new CayenneRuntimeException("No DataMap selected");

        }

        Preferences pref;

        if (nameSuffix == null || nameSuffix.length() == 0) {

            pref = getPreferenceForDataDomain().node("DataMap").node(map.getName());

        } else {

            pref = getPreferenceForDataDomain().node("DataMap").node(map.getName()).node(nameSuffix);

        }

        return (DataMapDefaults) application.getCayenneProjectPreferences().getProjectDetailObject(

                DataMapDefaults.class, pref);

    }

    /**

     * Returns preferences object for the current DataMap, throwing an exception

     * if no DataMap is selected.

     */

    public DataNodeDefaults getDataNodePreferences() {

        DataNodeDescriptor node = getCurrentDataNode();

        if (node == null) {

            throw new CayenneRuntimeException("No DataNode selected");

        }

        return (DataNodeDefaults) application.getCayenneProjectPreferences().getProjectDetailObject(

                DataNodeDefaults.class, getPreferenceForDataDomain().node("DataNode").node(node.getName()));

    }

    public void projectOpened() {

        CayenneModelerFrame frame = (CayenneModelerFrame) getView();

        addDataNodeDisplayListener(frame);

        addDataMapDisplayListener(frame);

        addObjEntityDisplayListener(frame);

        addDbEntityDisplayListener(frame);

        addQueryDisplayListener(frame);

        addProcedureDisplayListener(frame);

        addMultipleObjectsDisplayListener(frame);

        addEmbeddableDisplayListener(frame);

    }

    public void reset() {

        clearState();

        setDirty(false);

        setEntityTabSelection(0);

        listenerList = new EventListenerList();

        controllerStateHistory.clear();

    }

    /*

     * Allow the user to change the default history size. TODO When a user

     * changes their preferences it should call this method. I don't know how

     * the preferences work, so I will leave this to someone else to do. Garry

     */

    public void setHistorySize(int newSize) {

        controllerStateHistory.resize(newSize);

    }

    public boolean isDirty() {

        return dirty;

    }

    /** Resets all current models to null. */

    private void clearState() {

        // don't clear if we are refiring events for history navigation

        if (currentState.isRefiring)

            return;

        currentState = new ControllerState();

    }

    private void saveState(DisplayEvent e) {

        if (!controllerStateHistory.contains(currentState)) {

            currentState.event = e;

            controllerStateHistory.add(currentState);

        }

    }

    private void removeFromHistory(EventObject e) {

        synchronized (controllerStateHistory) {

            int count = controllerStateHistory.size();

            List<Object> removeList = new ArrayList<Object>();

            for (int i = 0; i < count; i++) {

                ControllerState cs = (ControllerState) controllerStateHistory.get(i);

                EventObject csEvent = cs.event;

                if (csEvent == null) {

                    continue;

                }

                if (e instanceof EntityEvent && csEvent instanceof EntityDisplayEvent) {

                    if (((EntityEvent) e).getEntity() == ((EntityDisplayEvent) csEvent).getEntity()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof EmbeddableEvent && csEvent instanceof EmbeddableDisplayEvent) {

                    if (((EmbeddableEvent) e).getEmbeddable() == ((EmbeddableDisplayEvent) csEvent).getEmbeddable()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof ProcedureEvent && csEvent instanceof ProcedureDisplayEvent) {

                    if (((ProcedureEvent) e).getProcedure() == ((ProcedureDisplayEvent) csEvent).getProcedure()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof QueryEvent && csEvent instanceof QueryDisplayEvent) {

                    if (((QueryEvent) e).getQuery() == ((QueryDisplayEvent) csEvent).getQuery()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof DataMapEvent && csEvent instanceof DataMapDisplayEvent) {

                    if (((DataMapEvent) e).getDataMap() == ((DataMapDisplayEvent) csEvent).getDataMap()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof DataNodeEvent && csEvent instanceof DataNodeDisplayEvent) {

                    if (((DataNodeEvent) e).getDataNode() == ((DataNodeDisplayEvent) csEvent).getDataNode()) {

                        removeList.add(cs);

                    }

                } else if (e instanceof DomainEvent && csEvent instanceof DomainDisplayEvent) {

                    if (((DomainEvent) e).getDomain() == ((DomainDisplayEvent) csEvent).getDomain()) {

                        removeList.add(cs);

                    }

                }

            }

            Iterator it = removeList.iterator();

            while (it.hasNext()) {

                controllerStateHistory.remove(it.next());

            }

        }

    }

    public DataNodeDescriptor getCurrentDataNode() {

        return currentState.node;

    }

    public DataMap getCurrentDataMap() {

        return currentState.map;

    }

    public ObjEntity getCurrentObjEntity() {

        return currentState.objEntity;

    }

    public Embeddable getCurrentEmbeddable() {

        return currentState.embeddable;

    }

    public DbEntity getCurrentDbEntity() {

        return currentState.dbEntity;

    }

    /**

     * @return Array of selected ObjAttributes

     */

    public ObjAttribute[] getCurrentObjAttributes() {

        return currentState.objAttrs;

    }

    /**

     * @return Array of selected DbAttributes

     */

    public DbAttribute[] getCurrentDbAttributes() {

        return currentState.dbAttrs;

    }

    /**

     * @return Array of selected EmbeddableAttribute

     */

    public EmbeddableAttribute[] getCurrentEmbAttrs() {

        return currentState.embAttrs;

    }

    /**

     * @return Array of selected ObjRelationships

     */

    public ObjRelationship[] getCurrentObjRelationships() {

        return currentState.objRels;

    }

    /**

     * @return Array of selected DbRelationships

     */

    public DbRelationship[] getCurrentDbRelationships() {

        return currentState.dbRels;

    }

    public Query getCurrentQuery() {

        return currentState.query;

    }

    public Procedure getCurrentProcedure() {

        return currentState.procedure;

    }

    public ProcedureParameter[] getCurrentProcedureParameters() {

        return currentState.procedureParameters;

    }

    public Object[] getCurrentPaths() {

        return currentState.paths;

    }

    public void addDomainDisplayListener(DomainDisplayListener listener) {

        listenerList.add(DomainDisplayListener.class, listener);

    }

    public void addDomainListener(DomainListener listener) {

        listenerList.add(DomainListener.class, listener);

    }

    public void removeDomainListener(DomainListener listener) {

        listenerList.remove(DomainListener.class, listener);

    }

    public void addDataNodeDisplayListener(DataNodeDisplayListener listener) {

        listenerList.add(DataNodeDisplayListener.class, listener);

    }

    public void addDataNodeListener(DataNodeListener listener) {

        listenerList.add(DataNodeListener.class, listener);

    }

    public void addDataMapDisplayListener(DataMapDisplayListener listener) {

        listenerList.add(DataMapDisplayListener.class, listener);

    }

    public void addDataMapListener(DataMapListener listener) {

        listenerList.add(DataMapListener.class, listener);

    }

    public void removeDataMapListener(DataMapListener listener) {

        listenerList.remove(DataMapListener.class, listener);

    }

    public void addDbEntityListener(DbEntityListener listener) {

        listenerList.add(DbEntityListener.class, listener);

    }

    public void removeDbEntityListener(DbEntityListener listener) {

        listenerList.remove(DbEntityListener.class, listener);

    }

    public void addObjEntityListener(ObjEntityListener listener) {

        listenerList.add(ObjEntityListener.class, listener);

    }

    public void removeObjEntityListener(ObjEntityListener listener) {

        listenerList.remove(ObjEntityListener.class, listener);

    }

    public void addDbEntityDisplayListener(DbEntityDisplayListener listener) {

        listenerList.add(DbEntityDisplayListener.class, listener);

    }

    public void addObjEntityDisplayListener(ObjEntityDisplayListener listener) {

        listenerList.add(ObjEntityDisplayListener.class, listener);

    }

    public void addEmbeddableDisplayListener(EmbeddableDisplayListener listener) {

        listenerList.add(EmbeddableDisplayListener.class, listener);

    }

    public void addEmbeddableAttributeDisplayListener(EmbeddableAttributeDisplayListener listener) {

        listenerList.add(EmbeddableAttributeDisplayListener.class, listener);

    }

    public void addDbAttributeListener(DbAttributeListener listener) {

        listenerList.add(DbAttributeListener.class, listener);

    }

    public void removeDbAttributeListener(DbAttributeListener listener) {

        listenerList.remove(DbAttributeListener.class, listener);

    }

    public void addDbAttributeDisplayListener(DbAttributeDisplayListener listener) {

        listenerList.add(DbAttributeDisplayListener.class, listener);

    }

    public void addObjAttributeListener(ObjAttributeListener listener) {

        listenerList.add(ObjAttributeListener.class, listener);

    }

    public void removeObjAttributeListener(ObjAttributeListener listener) {

        listenerList.remove(ObjAttributeListener.class, listener);

    }

    public void addObjAttributeDisplayListener(ObjAttributeDisplayListener listener) {

        listenerList.add(ObjAttributeDisplayListener.class, listener);

    }

    public void addDbRelationshipListener(DbRelationshipListener listener) {

        listenerList.add(DbRelationshipListener.class, listener);

    }

    public void removeDbRelationshipListener(DbRelationshipListener listener) {

        listenerList.add(DbRelationshipListener.class, listener);

    }

    public void addDbRelationshipDisplayListener(DbRelationshipDisplayListener listener) {

        listenerList.add(DbRelationshipDisplayListener.class, listener);

    }

    public void addObjRelationshipListener(ObjRelationshipListener listener) {

        listenerList.add(ObjRelationshipListener.class, listener);

    }

    public void removeObjRelationshipListener(ObjRelationshipListener listener) {

        listenerList.remove(ObjRelationshipListener.class, listener);

    }

    public void addObjRelationshipDisplayListener(ObjRelationshipDisplayListener listener) {

        listenerList.add(ObjRelationshipDisplayListener.class, listener);

    }

    public void addQueryDisplayListener(QueryDisplayListener listener) {

        listenerList.add(QueryDisplayListener.class, listener);

    }

    public void addQueryListener(QueryListener listener) {

        listenerList.add(QueryListener.class, listener);

    }

    public void addProcedureDisplayListener(ProcedureDisplayListener listener) {

        listenerList.add(ProcedureDisplayListener.class, listener);

    }

    public void addProcedureListener(ProcedureListener listener) {

        listenerList.add(ProcedureListener.class, listener);

    }

    public void addProcedureParameterListener(ProcedureParameterListener listener) {

        listenerList.add(ProcedureParameterListener.class, listener);

    }

    public void addProcedureParameterDisplayListener(ProcedureParameterDisplayListener listener) {

        listenerList.add(ProcedureParameterDisplayListener.class, listener);

    }

    public void addMultipleObjectsDisplayListener(MultipleObjectsDisplayListener listener) {

        listenerList.add(MultipleObjectsDisplayListener.class, listener);

    }

    public void fireDomainDisplayEvent(DomainDisplayEvent e) {

        boolean changed = e.getDomain() != currentState.domain;

        if (!changed) {

            changed = currentState.node != null || currentState.map != null || currentState.dbEntity != null

                    || currentState.objEntity != null || currentState.procedure != null || currentState.query != null

                    || currentState.embeddable != null;

        }

        if (!e.isRefired()) {

            e.setDomainChanged(changed);

            if (changed) {

                clearState();

                currentState.domain = e.getDomain();

            }

        }

        if (changed) {

            saveState(e);

        }

        for (EventListener listener : listenerList.getListeners(DomainDisplayListener.class)) {

            DomainDisplayListener temp = (DomainDisplayListener) listener;

            temp.currentDomainChanged(e);

        }

        // call different methods depending on whether domain was opened or

        // closed

        if (e.getDomain() == null) {

            getApplication().getActionManager().projectOpened();

        } else {

            getApplication().getActionManager().domainSelected();

        }

    }

    /**

     * Informs all listeners of the DomainEvent. Does not send the event to its

     * originator.

     */

    public void fireDomainEvent(DomainEvent e) {

        setDirty(true);

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener listener : listenerList.getListeners(DomainListener.class)) {

            DomainListener temp = (DomainListener) listener;

            switch (e.getId()) {

            case MapEvent.CHANGE:

                temp.domainChanged(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid DomainEvent type: " + e.getId());

            }

        }

    }

    public void fireDataNodeDisplayEvent(DataNodeDisplayEvent e) {

        boolean changed = e.getDataNode() != currentState.node;

        if (!changed) {

            changed = currentState.map != null || currentState.dbEntity != null || currentState.objEntity != null

                    || currentState.procedure != null || currentState.query != null || currentState.embeddable != null;

        }

        if (!e.isRefired()) {

            e.setDataNodeChanged(changed);

            if (changed) {

                clearState();

                currentState.domain = e.getDomain();

                currentState.node = e.getDataNode();

            }

        }

        if (changed) {

            saveState(e);

        }

        EventListener[] list = listenerList.getListeners(DataNodeDisplayListener.class);

        for (EventListener listener : list) {

            ((DataNodeDisplayListener) listener).currentDataNodeChanged(e);

        }

    }

    /**

     * Informs all listeners of the DataNodeEvent. Does not send the event to

     * its originator.

     */

    public void fireDataNodeEvent(DataNodeEvent e) {

        setDirty(true);

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener listener : listenerList.getListeners(DataNodeListener.class)) {

            DataNodeListener temp = (DataNodeListener) listener;

            switch (e.getId()) {

            case MapEvent.ADD:

                temp.dataNodeAdded(e);

                break;

            case MapEvent.CHANGE:

                temp.dataNodeChanged(e);

                break;

            case MapEvent.REMOVE:

                temp.dataNodeRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid DataNodeEvent type: " + e.getId());

            }

        }

    }

    public void fireDataMapDisplayEvent(DataMapDisplayEvent e) {

        boolean changed = e.getDataMap() != currentState.map;

        if (!changed) {

            changed = currentState.dbEntity != null || currentState.objEntity != null || currentState.procedure != null

                    || currentState.query != null || currentState.embeddable != null;

        }

        if (!e.isRefired()) {

            e.setDataMapChanged(changed);

            if (changed) {

                clearState();

                currentState.domain = e.getDomain();

                currentState.node = e.getDataNode();

                currentState.map = e.getDataMap();

            }

        }

        if (changed) {

            saveState(e);

        }

        EventListener[] list = listenerList.getListeners(DataMapDisplayListener.class);

        for (EventListener listener : list) {

            DataMapDisplayListener temp = (DataMapDisplayListener) listener;

            temp.currentDataMapChanged(e);

        }

    }

    /**

     * Informs all listeners of the DataMapEvent. Does not send the event to its

     * originator.

     */

    public void fireDataMapEvent(DataMapEvent e) {

        setDirty(true);

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener eventListener : listenerList.getListeners(DataMapListener.class)) {

            DataMapListener listener = (DataMapListener) eventListener;

            switch (e.getId()) {

            case MapEvent.ADD:

                listener.dataMapAdded(e);

                break;

            case MapEvent.CHANGE:

                listener.dataMapChanged(e);

                break;

            case MapEvent.REMOVE:

                listener.dataMapRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid DataMapEvent type: " + e.getId());

            }

        }

    }

    /**

     * Informs all listeners of the EntityEvent. Does not send the event to its

     * originator.

     */

    public void fireObjEntityEvent(EntityEvent e) {

        setDirty(true);

        if (e.getEntity().getDataMap() != null && e.getId() == MapEvent.CHANGE) {

            e.getEntity().getDataMap().objEntityChanged(e);

        }

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener listener : listenerList.getListeners(ObjEntityListener.class)) {

            ObjEntityListener temp = (ObjEntityListener) listener;

            switch (e.getId()) {

            case MapEvent.ADD:

                temp.objEntityAdded(e);

                break;

            case MapEvent.CHANGE:

                temp.objEntityChanged(e);

                break;

            case MapEvent.REMOVE:

                temp.objEntityRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid EntityEvent type: " + e.getId());

            }

        }

    }

    /**

     * Informs all listeners of the EntityEvent. Does not send the event to its

     * originator.

     */

    public void fireDbEntityEvent(EntityEvent e) {

        setDirty(true);

        if (e.getEntity().getDataMap() != null && e.getId() == MapEvent.CHANGE) {

            e.getEntity().getDataMap().dbEntityChanged(e);

        }

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener listener : listenerList.getListeners(DbEntityListener.class)) {

            DbEntityListener temp = (DbEntityListener) listener;

            switch (e.getId()) {

            case MapEvent.ADD:

                temp.dbEntityAdded(e);

                break;

            case MapEvent.CHANGE:

                temp.dbEntityChanged(e);

                break;

            case MapEvent.REMOVE:

                temp.dbEntityRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid EntityEvent type: " + e.getId());

            }

        }

    }

    /**

     * Informs all listeners of the ProcedureEvent. Does not send the event to

     * its originator.

     */

    public void fireQueryEvent(QueryEvent e) {

        setDirty(true);

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener eventListener : listenerList.getListeners(QueryListener.class)) {

            QueryListener listener = (QueryListener) eventListener;

            switch (e.getId()) {

            case MapEvent.ADD:

                listener.queryAdded(e);

                break;

            case MapEvent.CHANGE:

                listener.queryChanged(e);

                break;

            case MapEvent.REMOVE:

                listener.queryRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid ProcedureEvent type: " + e.getId());

            }

        }

    }

    /**

     * Informs all listeners of the ProcedureEvent. Does not send the event to

     * its originator.

     */

    public void fireProcedureEvent(ProcedureEvent e) {

        setDirty(true);

        if (e.getId() == MapEvent.REMOVE) {

            removeFromHistory(e);

        }

        for (EventListener eventListener : listenerList.getListeners(ProcedureListener.class)) {

            ProcedureListener listener = (ProcedureListener) eventListener;

            switch (e.getId()) {

            case MapEvent.ADD:

                listener.procedureAdded(e);

                break;

            case MapEvent.CHANGE:

                listener.procedureChanged(e);

                break;

            case MapEvent.REMOVE:

                listener.procedureRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid ProcedureEvent type: " + e.getId());

            }

        }

    }

    /**

     * Informs all listeners of the ProcedureEvent. Does not send the event to

     * its originator.

     */

    public void fireProcedureParameterEvent(ProcedureParameterEvent e) {

        setDirty(true);

        EventListener[] list = listenerList.getListeners(ProcedureParameterListener.class);

        for (EventListener eventListener : list) {

            ProcedureParameterListener listener = (ProcedureParameterListener) eventListener;

            switch (e.getId()) {

            case MapEvent.ADD:

                listener.procedureParameterAdded(e);

                break;

            case MapEvent.CHANGE:

                listener.procedureParameterChanged(e);

                break;

            case MapEvent.REMOVE:

                listener.procedureParameterRemoved(e);

                break;

            default:

                throw new IllegalArgumentException("Invalid ProcedureParameterEvent type: " + e.getId());

            }

        }

    }

    public void fireNavigationEvent(EventObject e) {

        Object source = e.getSource();

        if (source == null)

            return;

        int size = controllerStateHistory.size();

        if (size == 0)

            return;

        int i = controllerStateHistory.indexOf(currentState);

        ControllerState cs = null;

        if (size == 1) {

            cs = (ControllerState) controllerStateHistory.get(0);

        } else if (source instanceof NavigateForwardAction) {

            int counter = 0;

            while (true) {

                if (i < 0) {

                    // a new state got created without it being saved.

                    // just move to the beginning of the list

                    cs = (ControllerState) controllerStateHistory.get(0);

                } else if (i + 1 < size) {

                    // move forward

                    cs = (ControllerState) controllerStateHistory.get(i + 1);

                } else {

                    // wrap around

                    cs = (ControllerState) controllerStateHistory.get(0);

                }

                if (!cs.isEquivalent(currentState)) {

                    break;

                }

                // if it doesn't find it within 5 tries it is probably stuck in

                // a loop

                if (++counter > 5) {

                    break;

                }

                i++;

            }

        } else if (source instanceof NavigateBackwardAction) {

            int counter = 0;

            while (true) {

                if (i < 0) {

                    // a new state got created without it being saved.

                    try {

                        cs = (ControllerState) controllerStateHistory.get(size - 2);

                    } catch (ArrayIndexOutOfBoundsException ex) {

                        cs = (ControllerState) controllerStateHistory.get(size - 1);

                    }

                } else if (i - 1 >= 0) {

                    // move to the previous one

                    cs = (ControllerState) controllerStateHistory.get(i - 1);

                } else {

                    // wrap around

                    cs = (ControllerState) controllerStateHistory.get(size - 1);

                }

                if (!cs.isEquivalent(currentState)) {

                    break;

                }

                // if it doesn't find it within 5 tries it is probably stuck in

                // a loop

                if (++counter > 5) {

                    break;

                }

                i--;

            }

        }

        // reset the current state to the one we just navigated to

        currentState = cs;

        DisplayEvent de = cs.event;

        if (de == null)

            return;

        // make sure that isRefiring is turned off prior to exiting this routine

        // this flag is used to tell the controller to not create new states

        // when we are refiring the event that we saved earlier

        currentState.isRefiring = true;

        // the order of the following is checked in most specific to generic

        // because

        // of the inheritance heirarchy

        de.setRefired(true);

        if (de instanceof EntityDisplayEvent) {

            EntityDisplayEvent ede = (EntityDisplayEvent) de;

            ede.setEntityChanged(true);

            if (ede.getEntity() instanceof ObjEntity) {

                fireObjEntityDisplayEvent(ede);

            } else if (ede.getEntity() instanceof DbEntity) {

                fireDbEntityDisplayEvent(ede);

            }

        } else if (de instanceof EmbeddableDisplayEvent) {

            EmbeddableDisplayEvent ede = (EmbeddableDisplayEvent) de;

            ede.setEmbeddableChanged(true);

            fireEmbeddableDisplayEvent(ede);

        } else if (de instanceof ProcedureDisplayEvent) {

            ProcedureDisplayEvent pde = (ProcedureDisplayEvent) de;

            pde.setProcedureChanged(true);

            fireProcedureDisplayEvent(pde);

        } else if (de instanceof QueryDisplayEvent) {

            QueryDisplayEvent qde = (QueryDisplayEvent) de;

            qde.setQueryChanged(true);

            fireQueryDisplayEvent(qde);

        } else if (de instanceof DataMapDisplayEvent) {

            DataMapDisplayEvent dmde = (DataMapDisplayEvent) de;

            dmde.setDataMapChanged(true);

            fireDataMapDisplayEvent(dmde);

        } else if (de instanceof DataNodeDisplayEvent) {

            DataNodeDisplayEvent dnde = (DataNodeDisplayEvent) de;

            dnde.setDataNodeChanged(true);

            fireDataNodeDisplayEvent(dnde);

        } else if (de instanceof DomainDisplayEvent) {

            DomainDisplayEvent dde = (DomainDisplayEvent) de;

            dde.setDomainChanged(true);

            fireDomainDisplayEvent(dde);

        }

        // turn off refiring

        currentState.isRefiring = false;

    }

    public void fireObjEntityDisplayEvent(EntityDisplayEvent e) {

        boolean changed = e.getEntity() != currentState.objEntity;

        if (!e.isRefired()) {

            e.setEntityChanged(changed);

            if (changed) {

                clearState();

                currentState.domain = e.getDomain();

                currentState.node = e.getDataNode();

                currentState.map = e.getDataMap();

                currentState.objEntity = (ObjEntity) e.getEntity();

            }

        }

        if (changed) {

            saveState(e);

        }

        for (EventListener listener : listenerList.getListeners(ObjEntityDisplayListener.class)) {

            ObjEntityDisplayListener temp = (ObjEntityDisplayListener) listener;

            temp.currentObjEntityChanged(e);

        }

    }

    public void fireEmbeddableDisplayEvent(EmbeddableDisplayEvent e) {

        boolean changed = e.getEmbeddable() != currentState.embeddable;

        if (!e.isRefired()) {

            e.setEmbeddableChanged(changed);

            if (changed) {

                clearState();

                currentState.domain = e.getDomain();

                currentState.node = e.getDataNode();

                currentState.map = e.getDataMap();

                currentState.embeddable = e.getEmbeddable();

            }

        }

        if (changed) {

            saveState(e);