plugin/multimodelcontrol/MultiModelControlHandler.java

package appl.plugin.multimodelcontrol;

import java.awt.Color;
import java.awt.PopupMenu;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

import appl.parallel.gui.ParallelControlPanelEngine;

import schmitzm.data.event.ObjectEvent;
import schmitzm.data.event.ObjectListener;
import schmitzm.lang.WorkingThread;
import schmitzm.lang.WorkingThreadAdapter;
import schmitzm.lang.WorkingThreadListener;
import schmitzm.swing.TextAreaPrintStream;
import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.appl.ModelControlManager;
import edu.bonn.xulu.gui.ModelControlFrame;
import edu.bonn.xulu.model.StepModel;
import edu.bonn.xulu.model.XuluModel;
import edu.bonn.xulu.model.event.ModelEvent;
import edu.bonn.xulu.model.event.ModelListener;
import edu.bonn.xulu.plugin.gui.ModelControlFrame_Basic;

/**
 * The class allows to control several models at once. At the moment it provides
 * a batch like execution functionality. It is still under development but
 * should basically work. It was developed in very short time and is therefore
 * not as well commented, as other classes.
 * 
 * @author Dominik Appl
 */
public class MultiModelControlHandler implements ListSelectionListener,
                ObjectListener, ActionListener {

        private MultiModelControlFrame frame;

        private final XuluModellingPlatform xulu;

        private DefaultListModel modelListModel;

        private ParallelControlPanelEngine parallelControlPanelEngine;

        private DefaultListModel commandListModel;

        private InterpretingThread interpretingThread;

        private TextAreaPrintStream consoleStream;

        private String string;

        public MultiModelControlHandler(XuluModellingPlatform xulu) {
                this.xulu = xulu;
                frame = new MultiModelControlFrame();
                initGUI();
                consoleStream = new TextAreaPrintStream(frame.console);
        }

        /**
         * 
         */
        private void initGUI() {
                // register as listener for changes in the ModelControlManager
                xulu.getModelControlManager().addObjectListener(this);
                // init model list
                initModelList();
                initCommandList();
                registerListeners();
        }

        /**
         * 
         */
        private void registerListeners() {
                frame.addStepCommand.addActionListener(this);
                frame.newOverAllStep.addActionListener(this);
                frame.clearModelSteps.addActionListener(this);
                frame.startButton.addActionListener(this);
                frame.stopButton.addActionListener(this);
                frame.stepButton.addActionListener(this);
                frame.modelList.addMouseListener(new java.awt.event.MouseAdapter() {
                        public void mouseClicked(java.awt.event.MouseEvent e) {
                                if (e.getClickCount() == 2) {
                                        handleModelListDoubleClick();
                                }
                        }
                });
        }

        /**
         * 
         */
        private void initCommandList() {
                commandListModel = new DefaultListModel();
                frame.syncCommandList.setModel(commandListModel);
                commandListModel.addElement(new StartCommand());
                commandListModel.addElement(new StopCommand());
                frame.syncCommandList
                                .setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                frame.syncCommandList.setSelectedIndex(0);
        }

        /**
         * inits the modelList
         */
        private void initModelList() {
                modelListModel = new DefaultListModel();
                frame.modelList.setModel(modelListModel);
                frame.modelList.addListSelectionListener(this);
                int modelCount = xulu.getModelControlManager().getCount();
                for (int i = 0; i < modelCount; i++) {
                        ModelControlFrame frame = xulu.getModelControlManager().getAll()[i];
                        this.addModelControlFrame(frame);
                }
                // frame.modelList.add(frame.modelPopupMenu);
        }

        public MultiModelControlFrame getFrame() {
                return frame;
        }

        /*
         * (non-Javadoc)
         * 
         * @see schmitzm.data.event.ObjectListener#performObjectEvent(schmitzm.data.event.ObjectEvent)
         */
        public void performObjectEvent(ObjectEvent e) {
                // only listen for ChangeEvents
                if (!(e instanceof ModelControlManager.ChangeEvent))
                        return;
                ModelControlManager.ChangeEvent event = (ModelControlManager.ChangeEvent) e;
                // if model was added:
                if (event.getOldValue() == null && event.getNewValue() != null
                                && event.getNewValue() instanceof ModelControlFrame)
                        addModelControlFrame((ModelControlFrame) event.getNewValue());
                // if model was removed
                if (event.getOldValue() != null && event.getNewValue() == null
                                && event.getOldValue() instanceof ModelControlFrame)
                        removeModelControlFrame((ModelControlFrame) event.getOldValue());
        }

        /**
         * @param model
         */
        private void addModelControlFrame(ModelControlFrame frame2) {
                modelListModel.addElement(new ModelListObject(frame2,
                                frame2.getModel(), frame2.getModel().getName()));

        }

        /**
         * Removes the model, which belongs to the specified ModelControlFrame from
         * the list in the MCC
         * 
         * @param frame2
         *            the ModelControlFrame from the removed model
         */
        private void removeModelControlFrame(ModelControlFrame frame2) {
                // find the index of the model in the vector
                for (int i = 0; i < modelListModel.size(); i++) {
                        ModelListObject m = (ModelListObject) modelListModel.get(i);
                        if (frame2.equals(m.getFrame()))
                                modelListModel.remove(i);
                }
        }

        /**
         * @return the actually selected ModelListObject from the model list
         */
        private ModelListObject getSelectedModelListObject() {
                return (ModelListObject) frame.modelList.getSelectedValue();

        }

        /*
         * (non-Javadoc)
         * 
         * @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
         */
        public void valueChanged(ListSelectionEvent e) {
                // TODO Auto-generated method stub
        }

        abstract class ModelCommand {
                protected boolean finished = false;

                public abstract String toString();

                public void execute() {
                        finished = true;
                }

                public void reset() {
                        finished = false;
                }

                // /**
                // * executed after all commands are executed
                // */
                // public void dispose()
                // {
                //                      
                // }

                /**
                 * @return true, if the execution is finished and no further execution
                 *         is required
                 */
                public boolean hasFinished() {
                        return finished;
                }

                /**
                 * tries to stop the execution of the command
                 */
                public void stop() {
                };

                /**
                 * @return Message to be displayed in the console
                 */
                public String startMessage() {
                        return null;
                }

                /**
                 * @return Message to be displayed
                 */
                public String finshedMessage() {
                        return null;
                }
        }

        class RepeatStartCommand extends ModelCommand {
                private final int execTimes;

                private int alreadyExec;

                /**
                 * @param execTimes
                 */
                public RepeatStartCommand(int execTimes) {
                        this.execTimes = execTimes;
                        alreadyExec = 0;
                        // TODO Auto-generated constructor stub
                }

                public String toString() {
                        return "Start Repeat (" + execTimes + " exec)";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
                 */
                @Override
                public String finshedMessage() {
                        return "Starting Repeat (" + (alreadyExec) + "/" + execTimes + ")";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
                 */
                @Override
                public String startMessage() {
                        return null;
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#execute()
                 */
                @Override
                public void execute() {
                        alreadyExec++;
                        finished = true;
                }

                public void reset() {
                        finished = false;
                        alreadyExec = 0;
                }
        }

        /**
         * The commands between start and stop are repeated
         * 
         * @author Dominik Appl
         */
        class RepeatStopCommand extends ModelCommand {
                private final int execTimes;

                private int alreadyExec;

                /**
                 * @param execTimes
                 */
                public RepeatStopCommand(int execTimes) {
                        this.execTimes = execTimes;
                        alreadyExec = 0;
                }

                public String toString() {
                        return "End Repeat (" + execTimes + " exec)";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
                 */
                @Override
                public String finshedMessage() {
                        return "Loop iteration finished.(" + alreadyExec + "/" + execTimes
                                        + ")";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
                 */
                @Override
                public String startMessage() {
                        return null;
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#execute()
                 */
                @Override
                public void execute() {
                        alreadyExec++;
                        if (alreadyExec == execTimes)
                                finished = true;
                }

                public void reset() {
                        finished = false;
                        alreadyExec = 0;
                }
        }

        class StartCommand extends ModelCommand {
                public String toString() {
                        return "------- START MODELLING -------";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
                 */
                @Override
                public String finshedMessage() {
                        return "Starting execution...";
                }

        }

        class StopCommand extends ModelCommand {
                public String toString() {
                        return "------- MODELLING FINISHED -------";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
                 */
                @Override
                public String finshedMessage() {
                        return "Finished execution";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
                 */
                @Override
                public String startMessage() {
                        return null;
                }
        }

        class ModelStepCommand extends ModelCommand {
                private ModelControlFrame_Basic controlFrame;

                private final Lock lock = new ReentrantLock();

                private final Condition threadStillRunning = lock.newCondition();

                private String name;

                private XuluModel model;

                private final int execTimes;

                private int finishedExecutions = 0;

                public void reset() {
                        finishedExecutions = 0;
                }

                /**
                 * 
                 */
                public ModelStepCommand(ModelListObject mlo, int execTimes) {
                        this.execTimes = execTimes;
                        if (!(mlo.getFrame() instanceof ModelControlFrame_Basic))
                                throw new UnsupportedOperationException(
                                                "The modelframe must be an instance of ModelControlFrame_Basic");
                        controlFrame = (ModelControlFrame_Basic) mlo.getFrame();
                        name = mlo.getName();
                        model = mlo.getModel();
                }

                public void execute() {
                        // check first if the model must be initialised
                        if (!model.isInitialised() && !model.isRunning()) {
                                controlFrame.setModelResources();
                                controlFrame.getControlContainer().init();
                        }
                        lock.lock();
                        try {
                                WorkingThreadAdapter adapter = new WorkingThreadAdapter() {
                                        /*
                                         * (non-Javadoc)
                                         * 
                                         * @see schmitzm.lang.WorkingThreadAdapter#threadPaused(schmitzm.lang.WorkingThread)
                                         */
                                        @Override
                                        public void threadPaused(WorkingThread thread) {
                                                try {
                                                        lock.lock();
                                                        // signal finished if the step is finished
                                                        threadStillRunning.signal();
                                                } finally {
                                                        lock.unlock();
                                                }
                                        }

                                        /*
                                         * (non-Javadoc)
                                         * 
                                         * @see schmitzm.lang.WorkingThreadAdapter#threadStopped(schmitzm.lang.WorkingThread)
                                         */
                                        @Override
                                        public void threadStopped(WorkingThread thread) {
                                                try {
                                                        lock.lock();
                                                        // signal finished if the step is finished
                                                        threadStillRunning.signal();
                                                } finally {
                                                        lock.unlock();
                                                }
                                        }
                                };
                                controlFrame.getControlContainer().getModelThread()
                                                .addThreadListener(adapter);
                                controlFrame.getControlContainer().step();
                                // wait for the model step to finish
                                threadStillRunning.await();
                                controlFrame.getControlContainer().getModelThread()
                                                .removeThreadListener(adapter);
                                finishedExecutions++;
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } finally {
                                lock.unlock();
                        }
                }

                public void stop() {
                        if (!model.isStopped())
                                controlFrame.getControlContainer().stop();
                        // try {
                        // controlFrame.getControlContainer().getModelThread().join();
                        // } catch (InterruptedException e) {
                        // // TODO Auto-generated catch block
                        // e.printStackTrace();
                        // }
                }

                @Override
                public boolean hasFinished() {
                        return finishedExecutions >= execTimes;
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#toString()
                 */
                @Override
                public String toString() {
                        return name + " (" + execTimes + " exec)";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
                 */
                @Override
                public String finshedMessage() {
                        return "...finished";
                }

                /*
                 * (non-Javadoc)
                 * 
                 * @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
                 */
                @Override
                public String startMessage() {
                        return "Executing step of " + name;
                }

        }

        /*
         * (non-Javadoc)
         * 
         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
         */
        public void actionPerformed(ActionEvent e) {
                if (e.getSource() == frame.addStepCommand) {
                        handleAddNewStep();
                }
                if (e.getSource() == frame.newOverAllStep) {
                        handleRepeatStep();
                }
                if (e.getSource() == frame.startButton) {
                        startInterpreting();
                }
                if (e.getSource() == frame.stopButton) {
                        if (interpretingThread != null) {
                                interpretingThread.stopThread();
                        }
                        // ToDO: dispose all models

                }
                if (e.getSource() == frame.clearModelSteps) {
                        int delIdx = frame.syncCommandList.getSelectedIndex();
                        // do not delete first or last entry
                        if (delIdx > 0 && delIdx < commandListModel.getSize() - 1)
                                commandListModel.remove(delIdx);
                        frame.syncCommandList.setSelectedIndex(delIdx);

                }
        }

        /**
         * 
         */
        private void handleAddNewStep() {
                if (checkInsertAllowed()) {
                        if (getSelectedModelListObject() == null) {
                                JOptionPane.showMessageDialog(null, "No model selected",
                                                "No model selected", JOptionPane.ERROR_MESSAGE);
                                return;
                        }
                        int selIdx = frame.syncCommandList.getSelectedIndex();
                        int execTimes = 1;
                        // get execution times from user
                        try {
                                string = JOptionPane.showInputDialog(frame,
                                                "How many steps do you want to execute for this enty?",
                                                1);
                                execTimes = Integer.valueOf(string);
                                if (execTimes <= 0)
                                        throw new UnsupportedOperationException(
                                                        "Only positive number allowed!");
                        } catch (Exception ex) {
                                JOptionPane.showMessageDialog(null,
                                                "Only positive number allowed", "Error",
                                                JOptionPane.ERROR_MESSAGE);
                                return;
                        }
                        commandListModel.add(selIdx + 1, new ModelStepCommand(
                                        getSelectedModelListObject(), execTimes));
                        // select new entry
                        frame.syncCommandList.setSelectedIndex(selIdx + 1);
                }
        }

        /**
         * 
         */
        protected void handleModelListDoubleClick() {
                ModelListObject selectedModelListObject = getSelectedModelListObject();
                if (selectedModelListObject != null) {
                        selectedModelListObject.getFrame().setVisible(true);
                        selectedModelListObject.getFrame().toFront();
                }

        }

        /**
         * 
         */
        private void handleRepeatStep() {
                if (checkInsertAllowed()) {
                        int selIdx = frame.syncCommandList.getSelectedIndex();
                        int execTimes = 1;
                        // get execution times from user
                        try {
                                string = JOptionPane.showInputDialog(frame,
                                                "How many steps do you want to execute for this enty?",
                                                1);
                                execTimes = Integer.valueOf(string);
                                if (execTimes <= 0)
                                        throw new UnsupportedOperationException(
                                                        "Only positive numbers allowed!");
                        } catch (Exception ex) {
                                JOptionPane.showMessageDialog(null,
                                                "Only positive numbers allowed", "Error",
                                                JOptionPane.ERROR_MESSAGE);
                                return;
                        }
                        commandListModel.add(selIdx + 1, new RepeatStartCommand(execTimes));
                        commandListModel.add(selIdx + 2, new RepeatStopCommand(execTimes));

                        // select new entry
                        frame.syncCommandList.setSelectedIndex(selIdx + 1);
                }
        }

        private void startInterpreting() {
                // clear console and start Thread
                frame.console.setText("");
                interpretingThread = new InterpretingThread();
                interpretingThread.start();

        }

        public void toggleGUI(boolean enabled) {
                frame.modelList.setEnabled(enabled);
                frame.addStepCommand.setEnabled(enabled);
                frame.newOverAllStep.setEnabled(enabled);
                frame.clearModelSteps.setEnabled(enabled);
                if (enabled)
                        frame.syncCommandList.setSelectionBackground(Color.LIGHT_GRAY);
                else
                        frame.syncCommandList.setSelectionBackground(Color.red);
        }

        /**
         * insert is allowed if its not the last position
         */
        private boolean checkInsertAllowed() {
                if (commandListModel.getSize() - 1 > frame.syncCommandList
                                .getSelectedIndex())
                        return true;
                JOptionPane.showMessageDialog(null,
                                "You can add nothing after the end command!", "Error",
                                JOptionPane.ERROR_MESSAGE);
                return false;
        }

        /**
         * Interprets the commandlist
         * 
         * @author Dominik Appl
         */
        class InterpretingThread extends Thread {

                private boolean exit;

                private ModelCommand currentCommand;

                /**
                 * Creates a new Thread
                 */
                public InterpretingThread() {
                        exit = false;
                }

                /**
                 * stops the Thread execution
                 */
                public void stopThread() {
                        exit = true;
                        if (currentCommand != null)
                                currentCommand.stop();
                }

                public void run() {
                        toggleGUI(false);
                        // reset all commands
                        for (int i = 0; i < frame.syncCommandList.getModel().getSize(); i++)
                                ((ModelCommand) frame.syncCommandList.getModel()
                                                .getElementAt(i)).reset();
                        // select first element
                        try {
                                frame.syncCommandList.setSelectedIndex(0);
                                int currentIdx = 0;
                                while (exit != true) {
                                        currentCommand = (ModelCommand) commandListModel
                                                        .getElementAt(currentIdx);
                                        // if the current command is an end of of a global loop
                                        // than go back in the list until the start of the loop is
                                        // found
                                        if (currentCommand instanceof RepeatStopCommand) {
                                                currentCommand.execute();
                                                // if the all steps are done, just go on
                                                if (currentCommand.hasFinished()) {
                                                        currentIdx++;
                                                        currentCommand = (ModelCommand) commandListModel
                                                                        .getElementAt(currentIdx);
                                                }
                                                // else do the repetition by decreasing the index
                                                // until the RepeatStartCommand is reached
                                                else {
                                                        while (!(currentCommand instanceof RepeatStartCommand)) {
                                                                currentIdx--;
                                                                // if some structure error occured:
                                                                if (currentIdx <= 0) {
                                                                        JOptionPane
                                                                                        .showMessageDialog(
                                                                                                        frame,
                                                                                                        "Something is wrong with the command structure. Do not use nested loops or other komplex structures!");
                                                                        exit = true;
                                                                        break;
                                                                }
                                                                currentCommand = (ModelCommand) commandListModel
                                                                                .getElementAt(currentIdx);
                                                        }
                                                }

                                        }
                                        if (currentCommand.startMessage() != null)
                                                consoleStream.print(currentCommand.startMessage());
                                        frame.syncCommandList.setSelectedIndex(currentIdx);
                                        currentCommand.execute();
                                        if (currentCommand.finshedMessage() != null)
                                                consoleStream.println(currentCommand.finshedMessage());
                                        // if the command has finished executing, get the next
                                        // command
                                        if (currentCommand.hasFinished())
                                                currentIdx++;
                                        if (currentIdx == commandListModel.getSize())
                                                exit = true;
                                }
                        } catch (Exception e) {
                                e.printStackTrace();
                        } finally {
                                toggleGUI(true);
                        }
                }
        }

}
1	mojays	2	package appl.plugin.multimodelcontrol;
2
3			import java.awt.Color;
4			import java.awt.PopupMenu;
5			import java.awt.event.ActionEvent;
6			import java.awt.event.ActionListener;
7			import java.util.Vector;
8			import java.util.concurrent.locks.Condition;
9			import java.util.concurrent.locks.Lock;
10			import java.util.concurrent.locks.ReentrantLock;
11
12			import javax.swing.DefaultListModel;
13			import javax.swing.JList;
14			import javax.swing.JOptionPane;
15			import javax.swing.ListSelectionModel;
16			import javax.swing.event.ListSelectionEvent;
17			import javax.swing.event.ListSelectionListener;
18
19			import appl.parallel.gui.ParallelControlPanelEngine;
20
21			import schmitzm.data.event.ObjectEvent;
22			import schmitzm.data.event.ObjectListener;
23			import schmitzm.lang.WorkingThread;
24			import schmitzm.lang.WorkingThreadAdapter;
25			import schmitzm.lang.WorkingThreadListener;
26			import schmitzm.swing.TextAreaPrintStream;
27			import edu.bonn.xulu.XuluModellingPlatform;
28			import edu.bonn.xulu.appl.ModelControlManager;
29			import edu.bonn.xulu.gui.ModelControlFrame;
30			import edu.bonn.xulu.model.StepModel;
31			import edu.bonn.xulu.model.XuluModel;
32			import edu.bonn.xulu.model.event.ModelEvent;
33			import edu.bonn.xulu.model.event.ModelListener;
34			import edu.bonn.xulu.plugin.gui.ModelControlFrame_Basic;
35
36			/**
37			* The class allows to control several models at once. At the moment it provides
38			* a batch like execution functionality. It is still under development but
39			* should basically work. It was developed in very short time and is therefore
40			* not as well commented, as other classes.
41			*
42			* @author Dominik Appl
43			*/
44			public class MultiModelControlHandler implements ListSelectionListener,
45			ObjectListener, ActionListener {
46
47			private MultiModelControlFrame frame;
48
49			private final XuluModellingPlatform xulu;
50
51			private DefaultListModel modelListModel;
52
53			private ParallelControlPanelEngine parallelControlPanelEngine;
54
55			private DefaultListModel commandListModel;
56
57			private InterpretingThread interpretingThread;
58
59			private TextAreaPrintStream consoleStream;
60
61			private String string;
62
63			public MultiModelControlHandler(XuluModellingPlatform xulu) {
64			this.xulu = xulu;
65			frame = new MultiModelControlFrame();
66			initGUI();
67			consoleStream = new TextAreaPrintStream(frame.console);
68			}
69
70			/**
71			*
72			*/
73			private void initGUI() {
74			// register as listener for changes in the ModelControlManager
75			xulu.getModelControlManager().addObjectListener(this);
76			// init model list
77			initModelList();
78			initCommandList();
79			registerListeners();
80			}
81
82			/**
83			*
84			*/
85			private void registerListeners() {
86			frame.addStepCommand.addActionListener(this);
87			frame.newOverAllStep.addActionListener(this);
88			frame.clearModelSteps.addActionListener(this);
89			frame.startButton.addActionListener(this);
90			frame.stopButton.addActionListener(this);
91			frame.stepButton.addActionListener(this);
92			frame.modelList.addMouseListener(new java.awt.event.MouseAdapter() {
93			public void mouseClicked(java.awt.event.MouseEvent e) {
94			if (e.getClickCount() == 2) {
95			handleModelListDoubleClick();
96			}
97			}
98			});
99			}
100
101			/**
102			*
103			*/
104			private void initCommandList() {
105			commandListModel = new DefaultListModel();
106			frame.syncCommandList.setModel(commandListModel);
107			commandListModel.addElement(new StartCommand());
108			commandListModel.addElement(new StopCommand());
109			frame.syncCommandList
110			.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
111			frame.syncCommandList.setSelectedIndex(0);
112			}
113
114			/**
115			* inits the modelList
116			*/
117			private void initModelList() {
118			modelListModel = new DefaultListModel();
119			frame.modelList.setModel(modelListModel);
120			frame.modelList.addListSelectionListener(this);
121			int modelCount = xulu.getModelControlManager().getCount();
122			for (int i = 0; i < modelCount; i++) {
123			ModelControlFrame frame = xulu.getModelControlManager().getAll()[i];
124			this.addModelControlFrame(frame);
125			}
126			// frame.modelList.add(frame.modelPopupMenu);
127			}
128
129			public MultiModelControlFrame getFrame() {
130			return frame;
131			}
132
133			/*
134			* (non-Javadoc)
135			*
136			* @see schmitzm.data.event.ObjectListener#performObjectEvent(schmitzm.data.event.ObjectEvent)
137			*/
138			public void performObjectEvent(ObjectEvent e) {
139			// only listen for ChangeEvents
140			if (!(e instanceof ModelControlManager.ChangeEvent))
141			return;
142			ModelControlManager.ChangeEvent event = (ModelControlManager.ChangeEvent) e;
143			// if model was added:
144			if (event.getOldValue() == null && event.getNewValue() != null
145			&& event.getNewValue() instanceof ModelControlFrame)
146			addModelControlFrame((ModelControlFrame) event.getNewValue());
147			// if model was removed
148			if (event.getOldValue() != null && event.getNewValue() == null
149			&& event.getOldValue() instanceof ModelControlFrame)
150			removeModelControlFrame((ModelControlFrame) event.getOldValue());
151			}
152
153			/**
154			* @param model
155			*/
156			private void addModelControlFrame(ModelControlFrame frame2) {
157			modelListModel.addElement(new ModelListObject(frame2,
158			frame2.getModel(), frame2.getModel().getName()));
159
160			}
161
162			/**
163			* Removes the model, which belongs to the specified ModelControlFrame from
164			* the list in the MCC
165			*
166			* @param frame2
167			* the ModelControlFrame from the removed model
168			*/
169			private void removeModelControlFrame(ModelControlFrame frame2) {
170			// find the index of the model in the vector
171			for (int i = 0; i < modelListModel.size(); i++) {
172			ModelListObject m = (ModelListObject) modelListModel.get(i);
173			if (frame2.equals(m.getFrame()))
174			modelListModel.remove(i);
175			}
176			}
177
178			/**
179	alfonx	33	* @return the actually selected ModelListObject from the model list
180	mojays	2	*/
181			private ModelListObject getSelectedModelListObject() {
182			return (ModelListObject) frame.modelList.getSelectedValue();
183
184			}
185
186			/*
187			* (non-Javadoc)
188			*
189			* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
190			*/
191			public void valueChanged(ListSelectionEvent e) {
192			// TODO Auto-generated method stub
193			}
194
195			abstract class ModelCommand {
196			protected boolean finished = false;
197
198			public abstract String toString();
199
200			public void execute() {
201			finished = true;
202			}
203
204			public void reset() {
205			finished = false;
206			}
207
208			// /**
209			// * executed after all commands are executed
210			// */
211			// public void dispose()
212			// {
213			//
214			// }
215
216			/**
217			* @return true, if the execution is finished and no further execution
218			* is required
219			*/
220			public boolean hasFinished() {
221			return finished;
222			}
223
224			/**
225			* tries to stop the execution of the command
226			*/
227			public void stop() {
228			};
229
230			/**
231			* @return Message to be displayed in the console
232			*/
233			public String startMessage() {
234			return null;
235			}
236
237			/**
238			* @return Message to be displayed
239			*/
240			public String finshedMessage() {
241			return null;
242			}
243			}
244
245			class RepeatStartCommand extends ModelCommand {
246			private final int execTimes;
247
248			private int alreadyExec;
249
250			/**
251			* @param execTimes
252			*/
253			public RepeatStartCommand(int execTimes) {
254			this.execTimes = execTimes;
255			alreadyExec = 0;
256			// TODO Auto-generated constructor stub
257			}
258
259			public String toString() {
260			return "Start Repeat (" + execTimes + " exec)";
261			}
262
263			/*
264			* (non-Javadoc)
265			*
266			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
267			*/
268			@Override
269			public String finshedMessage() {
270			return "Starting Repeat (" + (alreadyExec) + "/" + execTimes + ")";
271			}
272
273			/*
274			* (non-Javadoc)
275			*
276			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
277			*/
278			@Override
279			public String startMessage() {
280			return null;
281			}
282
283			/*
284			* (non-Javadoc)
285			*
286			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#execute()
287			*/
288			@Override
289			public void execute() {
290			alreadyExec++;
291			finished = true;
292			}
293
294			public void reset() {
295			finished = false;
296			alreadyExec = 0;
297			}
298			}
299
300			/**
301			* The commands between start and stop are repeated
302			*
303			* @author Dominik Appl
304			*/
305			class RepeatStopCommand extends ModelCommand {
306			private final int execTimes;
307
308			private int alreadyExec;
309
310			/**
311			* @param execTimes
312			*/
313			public RepeatStopCommand(int execTimes) {
314			this.execTimes = execTimes;
315			alreadyExec = 0;
316			}
317
318			public String toString() {
319			return "End Repeat (" + execTimes + " exec)";
320			}
321
322			/*
323			* (non-Javadoc)
324			*
325			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
326			*/
327			@Override
328			public String finshedMessage() {
329			return "Loop iteration finished.(" + alreadyExec + "/" + execTimes
330			+ ")";
331			}
332
333			/*
334			* (non-Javadoc)
335			*
336			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
337			*/
338			@Override
339			public String startMessage() {
340			return null;
341			}
342
343			/*
344			* (non-Javadoc)
345			*
346			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#execute()
347			*/
348			@Override
349			public void execute() {
350			alreadyExec++;
351			if (alreadyExec == execTimes)
352			finished = true;
353			}
354
355			public void reset() {
356			finished = false;
357			alreadyExec = 0;
358			}
359			}
360
361			class StartCommand extends ModelCommand {
362			public String toString() {
363			return "------- START MODELLING -------";
364			}
365
366			/*
367			* (non-Javadoc)
368			*
369			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
370			*/
371			@Override
372			public String finshedMessage() {
373			return "Starting execution...";
374			}
375
376			}
377
378			class StopCommand extends ModelCommand {
379			public String toString() {
380			return "------- MODELLING FINISHED -------";
381			}
382
383			/*
384			* (non-Javadoc)
385			*
386			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
387			*/
388			@Override
389			public String finshedMessage() {
390			return "Finished execution";
391			}
392
393			/*
394			* (non-Javadoc)
395			*
396			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
397			*/
398			@Override
399			public String startMessage() {
400			return null;
401			}
402			}
403
404			class ModelStepCommand extends ModelCommand {
405			private ModelControlFrame_Basic controlFrame;
406
407			private final Lock lock = new ReentrantLock();
408
409			private final Condition threadStillRunning = lock.newCondition();
410
411			private String name;
412
413			private XuluModel model;
414
415			private final int execTimes;
416
417			private int finishedExecutions = 0;
418
419			public void reset() {
420			finishedExecutions = 0;
421			}
422
423			/**
424			*
425			*/
426			public ModelStepCommand(ModelListObject mlo, int execTimes) {
427			this.execTimes = execTimes;
428			if (!(mlo.getFrame() instanceof ModelControlFrame_Basic))
429			throw new UnsupportedOperationException(
430			"The modelframe must be an instance of ModelControlFrame_Basic");
431			controlFrame = (ModelControlFrame_Basic) mlo.getFrame();
432			name = mlo.getName();
433			model = mlo.getModel();
434			}
435
436			public void execute() {
437			// check first if the model must be initialised
438			if (!model.isInitialised() && !model.isRunning()) {
439			controlFrame.setModelResources();
440			controlFrame.getControlContainer().init();
441			}
442			lock.lock();
443			try {
444			WorkingThreadAdapter adapter = new WorkingThreadAdapter() {
445			/*
446			* (non-Javadoc)
447			*
448			* @see schmitzm.lang.WorkingThreadAdapter#threadPaused(schmitzm.lang.WorkingThread)
449			*/
450			@Override
451			public void threadPaused(WorkingThread thread) {
452			try {
453			lock.lock();
454			// signal finished if the step is finished
455			threadStillRunning.signal();
456			} finally {
457			lock.unlock();
458			}
459			}
460
461			/*
462			* (non-Javadoc)
463			*
464			* @see schmitzm.lang.WorkingThreadAdapter#threadStopped(schmitzm.lang.WorkingThread)
465			*/
466			@Override
467			public void threadStopped(WorkingThread thread) {
468			try {
469			lock.lock();
470			// signal finished if the step is finished
471			threadStillRunning.signal();
472			} finally {
473			lock.unlock();
474			}
475			}
476			};
477			controlFrame.getControlContainer().getModelThread()
478			.addThreadListener(adapter);
479			controlFrame.getControlContainer().step();
480			// wait for the model step to finish
481			threadStillRunning.await();
482			controlFrame.getControlContainer().getModelThread()
483			.removeThreadListener(adapter);
484			finishedExecutions++;
485			} catch (InterruptedException e) {
486			// TODO Auto-generated catch block
487			e.printStackTrace();
488			} finally {
489			lock.unlock();
490			}
491			}
492
493			public void stop() {
494			if (!model.isStopped())
495			controlFrame.getControlContainer().stop();
496			// try {
497			// controlFrame.getControlContainer().getModelThread().join();
498			// } catch (InterruptedException e) {
499			// // TODO Auto-generated catch block
500			// e.printStackTrace();
501			// }
502			}
503
504			@Override
505			public boolean hasFinished() {
506			return finishedExecutions >= execTimes;
507			}
508
509			/*
510			* (non-Javadoc)
511			*
512			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#toString()
513			*/
514			@Override
515			public String toString() {
516			return name + " (" + execTimes + " exec)";
517			}
518
519			/*
520			* (non-Javadoc)
521			*
522			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#finshedMessage()
523			*/
524			@Override
525			public String finshedMessage() {
526			return "...finished";
527			}
528
529			/*
530			* (non-Javadoc)
531			*
532			* @see appl.plugin.multimodelcontrol.MultiModelControlHandler.ModelCommand#startMessage()
533			*/
534			@Override
535			public String startMessage() {
536			return "Executing step of " + name;
537			}
538
539			}
540
541			/*
542			* (non-Javadoc)
543			*
544			* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
545			*/
546			public void actionPerformed(ActionEvent e) {
547			if (e.getSource() == frame.addStepCommand) {
548			handleAddNewStep();
549			}
550			if (e.getSource() == frame.newOverAllStep) {
551			handleRepeatStep();
552			}
553			if (e.getSource() == frame.startButton) {
554			startInterpreting();
555			}
556			if (e.getSource() == frame.stopButton) {
557			if (interpretingThread != null) {
558			interpretingThread.stopThread();
559			}
560			// ToDO: dispose all models
561
562			}
563			if (e.getSource() == frame.clearModelSteps) {
564			int delIdx = frame.syncCommandList.getSelectedIndex();
565			// do not delete first or last entry
566			if (delIdx > 0 && delIdx < commandListModel.getSize() - 1)
567			commandListModel.remove(delIdx);
568			frame.syncCommandList.setSelectedIndex(delIdx);
569
570			}
571			}
572
573			/**
574			*
575			*/
576			private void handleAddNewStep() {
577			if (checkInsertAllowed()) {
578			if (getSelectedModelListObject() == null) {
579			JOptionPane.showMessageDialog(null, "No model selected",
580			"No model selected", JOptionPane.ERROR_MESSAGE);
581			return;
582			}
583			int selIdx = frame.syncCommandList.getSelectedIndex();
584			int execTimes = 1;
585			// get execution times from user
586			try {
587			string = JOptionPane.showInputDialog(frame,
588			"How many steps do you want to execute for this enty?",
589			1);
590			execTimes = Integer.valueOf(string);
591			if (execTimes <= 0)
592			throw new UnsupportedOperationException(
593			"Only positive number allowed!");
594			} catch (Exception ex) {
595			JOptionPane.showMessageDialog(null,
596			"Only positive number allowed", "Error",
597			JOptionPane.ERROR_MESSAGE);
598			return;
599			}
600			commandListModel.add(selIdx + 1, new ModelStepCommand(
601			getSelectedModelListObject(), execTimes));
602			// select new entry
603			frame.syncCommandList.setSelectedIndex(selIdx + 1);
604			}
605			}
606
607			/**
608			*
609			*/
610			protected void handleModelListDoubleClick() {
611			ModelListObject selectedModelListObject = getSelectedModelListObject();
612			if (selectedModelListObject != null) {
613			selectedModelListObject.getFrame().setVisible(true);
614			selectedModelListObject.getFrame().toFront();
615			}
616
617			}
618
619			/**
620			*
621			*/
622			private void handleRepeatStep() {
623			if (checkInsertAllowed()) {
624			int selIdx = frame.syncCommandList.getSelectedIndex();
625			int execTimes = 1;
626			// get execution times from user
627			try {
628			string = JOptionPane.showInputDialog(frame,
629			"How many steps do you want to execute for this enty?",
630			1);
631			execTimes = Integer.valueOf(string);
632			if (execTimes <= 0)
633			throw new UnsupportedOperationException(
634			"Only positive numbers allowed!");
635			} catch (Exception ex) {
636			JOptionPane.showMessageDialog(null,
637			"Only positive numbers allowed", "Error",
638			JOptionPane.ERROR_MESSAGE);
639			return;
640			}
641			commandListModel.add(selIdx + 1, new RepeatStartCommand(execTimes));
642			commandListModel.add(selIdx + 2, new RepeatStopCommand(execTimes));
643
644			// select new entry
645			frame.syncCommandList.setSelectedIndex(selIdx + 1);
646			}
647			}
648
649			private void startInterpreting() {
650			// clear console and start Thread
651			frame.console.setText("");
652			interpretingThread = new InterpretingThread();
653			interpretingThread.start();
654
655			}
656
657			public void toggleGUI(boolean enabled) {
658			frame.modelList.setEnabled(enabled);
659			frame.addStepCommand.setEnabled(enabled);
660			frame.newOverAllStep.setEnabled(enabled);
661			frame.clearModelSteps.setEnabled(enabled);
662			if (enabled)
663			frame.syncCommandList.setSelectionBackground(Color.LIGHT_GRAY);
664			else
665			frame.syncCommandList.setSelectionBackground(Color.red);
666			}
667
668			/**
669			* insert is allowed if its not the last position
670			*/
671			private boolean checkInsertAllowed() {
672			if (commandListModel.getSize() - 1 > frame.syncCommandList
673			.getSelectedIndex())
674			return true;
675			JOptionPane.showMessageDialog(null,
676			"You can add nothing after the end command!", "Error",
677			JOptionPane.ERROR_MESSAGE);
678			return false;
679			}
680
681			/**
682			* Interprets the commandlist
683			*
684			* @author Dominik Appl
685			*/
686			class InterpretingThread extends Thread {
687
688			private boolean exit;
689
690			private ModelCommand currentCommand;
691
692			/**
693			* Creates a new Thread
694			*/
695			public InterpretingThread() {
696			exit = false;
697			}
698
699			/**
700			* stops the Thread execution
701			*/
702			public void stopThread() {
703			exit = true;
704			if (currentCommand != null)
705			currentCommand.stop();
706			}
707
708			public void run() {
709			toggleGUI(false);
710			// reset all commands
711			for (int i = 0; i < frame.syncCommandList.getModel().getSize(); i++)
712			((ModelCommand) frame.syncCommandList.getModel()
713			.getElementAt(i)).reset();
714			// select first element
715			try {
716			frame.syncCommandList.setSelectedIndex(0);
717			int currentIdx = 0;
718			while (exit != true) {
719			currentCommand = (ModelCommand) commandListModel
720			.getElementAt(currentIdx);
721			// if the current command is an end of of a global loop
722			// than go back in the list until the start of the loop is
723			// found
724			if (currentCommand instanceof RepeatStopCommand) {
725			currentCommand.execute();
726			// if the all steps are done, just go on
727			if (currentCommand.hasFinished()) {
728			currentIdx++;
729			currentCommand = (ModelCommand) commandListModel
730			.getElementAt(currentIdx);
731			}
732			// else do the repetition by decreasing the index
733			// until the RepeatStartCommand is reached
734			else {
735			while (!(currentCommand instanceof RepeatStartCommand)) {
736			currentIdx--;
737			// if some structure error occured:
738			if (currentIdx <= 0) {
739			JOptionPane
740			.showMessageDialog(
741			frame,
742			"Something is wrong with the command structure. Do not use nested loops or other komplex structures!");
743			exit = true;
744			break;
745			}
746			currentCommand = (ModelCommand) commandListModel
747			.getElementAt(currentIdx);
748			}
749			}
750
751			}
752			if (currentCommand.startMessage() != null)
753			consoleStream.print(currentCommand.startMessage());
754			frame.syncCommandList.setSelectedIndex(currentIdx);
755			currentCommand.execute();
756			if (currentCommand.finshedMessage() != null)
757			consoleStream.println(currentCommand.finshedMessage());
758			// if the command has finished executing, get the next
759			// command
760			if (currentCommand.hasFinished())
761			currentIdx++;
762			if (currentIdx == commandListModel.getSize())
763			exit = true;
764			}
765			} catch (Exception e) {
766			e.printStackTrace();
767			} finally {
768			toggleGUI(true);
769			}
770			}
771			}
772
773			}