parallel/gui/ModelControlFrame_parallel.java

package appl.parallel.gui;

import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JPanel;

import schmitzm.lang.WorkingThread;
import schmitzm.lang.WorkingThreadAdapter;

import appl.parallel.client.RemoteExecutionController;
import appl.parallel.model.AbstractParallelStepModel;
import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.model.XuluModel;
import edu.bonn.xulu.plugin.gui.ModelControlContainer;
import edu.bonn.xulu.plugin.gui.ModelControlFrame_Basic;

/**
 * Introduces a new TAB into the {@link ModelControlFrame_Basic}
 * for controlling the parallel execution
 *
 * @author Dominik Appl
 */
public class ModelControlFrame_parallel extends ModelControlFrame_Tabbed {

        protected ParallelControlPanelEngine spcEngine;

        private boolean parallelPaneInitalized;

        /**
         * @param appl
         * @param model
         */
        public ModelControlFrame_parallel(XuluModellingPlatform appl,
                        XuluModel model) {
                super(appl, model);
                this.pack();
        }

        /**
         * does basically the same as
         * {@link ModelControlFrame_Basic#initControlContainer()}
         */
        protected void initControlContainer() {
                spcEngine = new ParallelControlPanelEngine(appl);
                // ####### Initialize controlcomponent #######
                controlContainer = new ModelControlContainer_parallel(model, spcEngine,
                                appl);

                // ******************** COPIED FROM SUPERCLASS
                // **************************

                // Bei Init-Aktion muessen zunaechst die Modell-Ressourcen mit den
                // ausgewaehlten
                // Datenpool-Objekten verknuepft werden; bevor das Modell initialisiert
                // wird
                controlContainer.addButtonActionListener(
                                ModelControlContainer.BUTTON_INIT, new ActionListener() {
                                        public void actionPerformed(ActionEvent e) {
                                                setModelResources();
                                        }
                                });
                // Waehrend das Modell laeuft, soll nichts an den Ressourcen veraendet
                // werden
                controlContainer.addThreadListener(new WorkingThreadAdapter() {
                        public void threadStarted(WorkingThread thread) {
                                contentContainer.setEnabled(false);
                                reloadButton.setEnabled(false);
                        }

                        public void threadStopped(WorkingThread thread) {
                                contentContainer.setEnabled(true);
                                reloadButton.setEnabled(true);
                        }
                });
                contentPane.add(controlContainer, new GridBagConstraints(0, 0, 1, 1,
                                1.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
                                new Insets(5, 5, 5, 5), 0, 0));
        }

        @Override
        protected void initContentPane() {
                super.initContentPane();
//              System.out.println(model.getClass().getName());
                if (model instanceof AbstractParallelStepModel) {
                        initializeParallelPane();
                } else
                        parallelPaneInitalized = false;
        }

        private boolean isParallelPaneInitalized() {
                return parallelPaneInitalized;
        }

        @Override
        protected ModelControlFrame_parallel newInstance(XuluModel newModel) {
                ModelControlFrame_parallel frame_parallel = new ModelControlFrame_parallel(
                                appl, newModel);
                // initialize the parallel pane if it was initialized before
                if (this.isParallelPaneInitalized()
                                && !frame_parallel.isParallelPaneInitalized()) {
                        if (newModel.getClass().getName()
                                        .equals(model.getClass().getName())) {
                                frame_parallel.initializeParallelPane();
                        }
                }
                return frame_parallel;
        }

        private void initializeParallelPane() {
                super.tabbedPane.addTab("Parallel Control", spcEngine.getPanel());
                // The boolean parallelPaneInitalized is required because after
                // reloading
                // with a custom classloader, like the preferred classloader, the
                // 'instanceof' will no longer work properly with the reloaded class.
                // (instanceof will return false)
                parallelPaneInitalized = true;
        }

}
1	mojays	2	package appl.parallel.gui;
2
3			import java.awt.Dimension;
4			import java.awt.GridBagConstraints;
5			import java.awt.Insets;
6			import java.awt.event.ActionEvent;
7			import java.awt.event.ActionListener;
8
9			import javax.swing.JPanel;
10
11			import schmitzm.lang.WorkingThread;
12			import schmitzm.lang.WorkingThreadAdapter;
13
14			import appl.parallel.client.RemoteExecutionController;
15			import appl.parallel.model.AbstractParallelStepModel;
16			import edu.bonn.xulu.XuluModellingPlatform;
17			import edu.bonn.xulu.model.XuluModel;
18			import edu.bonn.xulu.plugin.gui.ModelControlContainer;
19			import edu.bonn.xulu.plugin.gui.ModelControlFrame_Basic;
20
21			/**
22			* Introduces a new TAB into the {@link ModelControlFrame_Basic}
23			* for controlling the parallel execution
24			*
25			* @author Dominik Appl
26			*/
27			public class ModelControlFrame_parallel extends ModelControlFrame_Tabbed {
28
29			protected ParallelControlPanelEngine spcEngine;
30
31			private boolean parallelPaneInitalized;
32
33			/**
34			* @param appl
35			* @param model
36			*/
37			public ModelControlFrame_parallel(XuluModellingPlatform appl,
38			XuluModel model) {
39			super(appl, model);
40			this.pack();
41			}
42
43			/**
44			* does basically the same as
45			* {@link ModelControlFrame_Basic#initControlContainer()}
46			*/
47			protected void initControlContainer() {
48			spcEngine = new ParallelControlPanelEngine(appl);
49			// ####### Initialize controlcomponent #######
50			controlContainer = new ModelControlContainer_parallel(model, spcEngine,
51			appl);
52
53			// ******************** COPIED FROM SUPERCLASS
54			// **************************
55
56			// Bei Init-Aktion muessen zunaechst die Modell-Ressourcen mit den
57			// ausgewaehlten
58			// Datenpool-Objekten verknuepft werden; bevor das Modell initialisiert
59			// wird
60			controlContainer.addButtonActionListener(
61			ModelControlContainer.BUTTON_INIT, new ActionListener() {
62			public void actionPerformed(ActionEvent e) {
63			setModelResources();
64			}
65			});
66			// Waehrend das Modell laeuft, soll nichts an den Ressourcen veraendet
67			// werden
68			controlContainer.addThreadListener(new WorkingThreadAdapter() {
69			public void threadStarted(WorkingThread thread) {
70			contentContainer.setEnabled(false);
71			reloadButton.setEnabled(false);
72			}
73
74			public void threadStopped(WorkingThread thread) {
75			contentContainer.setEnabled(true);
76			reloadButton.setEnabled(true);
77			}
78			});
79			contentPane.add(controlContainer, new GridBagConstraints(0, 0, 1, 1,
80			1.0, 0.0, GridBagConstraints.CENTER, GridBagConstraints.BOTH,
81			new Insets(5, 5, 5, 5), 0, 0));
82			}
83
84			@Override
85			protected void initContentPane() {
86			super.initContentPane();
87			// System.out.println(model.getClass().getName());
88			if (model instanceof AbstractParallelStepModel) {
89			initializeParallelPane();
90			} else
91			parallelPaneInitalized = false;
92			}
93
94			private boolean isParallelPaneInitalized() {
95			return parallelPaneInitalized;
96			}
97
98			@Override
99			protected ModelControlFrame_parallel newInstance(XuluModel newModel) {
100			ModelControlFrame_parallel frame_parallel = new ModelControlFrame_parallel(
101			appl, newModel);
102			// initialize the parallel pane if it was initialized before
103			if (this.isParallelPaneInitalized()
104			&& !frame_parallel.isParallelPaneInitalized()) {
105			if (newModel.getClass().getName()
106			.equals(model.getClass().getName())) {
107			frame_parallel.initializeParallelPane();
108			}
109			}
110			return frame_parallel;
111			}
112
113			private void initializeParallelPane() {
114			super.tabbedPane.addTab("Parallel Control", spcEngine.getPanel());
115			// The boolean parallelPaneInitalized is required because after
116			// reloading
117			// with a custom classloader, like the preferred classloader, the
118			// 'instanceof' will no longer work properly with the reloaded class.
119			// (instanceof will return false)
120			parallelPaneInitalized = true;
121			}
122
123			}