source: trunk/CrypPlugins/WorkspaceManager/Model/PluginModel.cs @ 1551

Last change on this file since 1551 was 1502, checked in by kopal, 12 years ago

A PluginModel has now a state which represents its current ExecutionState. For example: EXECUTABLE, EXECUTING and so on

File size: 7.9 KB
Line 
1/*                             
2   Copyright 2010 Nils Kopal, Viktor M.
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17
18using System;
19using System.Collections.Generic;
20using System.Linq;
21using System.Text;
22using Cryptool.PluginBase;
23using System.Threading;
24
25namespace WorkspaceManager.Model
26{
27    /// <summary>
28    /// Class to represent and wrap a IPlugin in our model graph
29    /// </summary>
30    [Serializable]
31    public class PluginModel : VisualElementModel
32    {
33        [NonSerialized]
34        private Mutex mutex = new Mutex();
35
36        [NonSerialized]
37        private IPlugin plugin;
38
39        [NonSerialized]
40        private PluginModelState executionstate = PluginModelState.UNDEFINED;
41
42        /// <summary>
43        /// All ingoing connectors of this PluginModel
44        /// </summary>
45        public List<ConnectorModel> InputConnectors = null;
46
47        /// <summary>
48        /// All outgoing connectors of this PluginModel
49        /// </summary>
50        public List<ConnectorModel> OutputConnectors = null;
51
52        /// <summary>
53        /// The wrapped IPlugin of this PluginModel
54        /// </summary>
55        public IPlugin Plugin{
56            get { 
57                if(plugin==null && PluginType != null){
58                    plugin = PluginType.CreateObject();                   
59                }
60                return plugin;
61            }
62
63            private set
64            {
65                plugin = value;
66            }
67        } 
68
69        /// <summary>
70        /// The Type of the Wrapped IPlugin of this PluginModel
71        /// Depending on this the Plugin of this PluginModel will be instanciated
72        /// </summary>       
73        public Type PluginType = null;
74
75        /// <summary>
76        /// Stores if this Plugin is executable
77        /// </summary>
78        private bool executable = false;
79
80        /// <summary>
81        /// Is the Plugin actually minimized?
82        /// </summary>
83        public bool Minimized { get; set; }
84
85        /// <summary>
86        /// The execution state of the progress of the wrapped plugin
87        /// </summary>
88        public double PercentageFinished { get; set; }
89
90        /// <summary>
91        /// Create a new PluginModel
92        /// </summary>
93        public PluginModel()
94        {
95            this.InputConnectors = new List<ConnectorModel>();
96            this.OutputConnectors = new List<ConnectorModel>();
97        }
98
99        /// <summary>
100        /// The WorkspaceModel of this PluginModel
101        /// </summary>
102        public WorkspaceModel WorkspaceModel { get; set; }
103
104        /// <summary>
105        /// Generates all Connectors of this Plugin.
106        /// Warning: Before generation all "old" Connectors will be deleted
107        /// </summary>
108        public void generateConnectors(){
109           
110            if (Plugin != null)
111            {
112                this.InputConnectors.Clear();
113                this.OutputConnectors.Clear();
114
115                foreach (PropertyInfoAttribute propertyInfoAttribute in Plugin.GetProperties())
116                {                   
117                    if (propertyInfoAttribute.Direction.Equals(Direction.InputData))
118                    {
119                        ConnectorModel connectorModel = new ConnectorModel();
120                        connectorModel.ConnectorType = propertyInfoAttribute.PropertyInfo.DeclaringType;
121                        connectorModel.WorkspaceModel = WorkspaceModel;
122                        connectorModel.PluginModel = this;
123                        connectorModel.IsMandatory = propertyInfoAttribute.Mandatory;
124                        connectorModel.PropertyName = propertyInfoAttribute.PropertyName;
125                        InputConnectors.Add(connectorModel);
126                        WorkspaceModel.AllConnectorModels.Add(connectorModel);
127                    }
128                    else if (propertyInfoAttribute.Direction.Equals(Direction.OutputData))
129                    {
130                        ConnectorModel connectorModel = new ConnectorModel();
131                        connectorModel.ConnectorType = propertyInfoAttribute.PropertyInfo.DeclaringType;
132                        connectorModel.WorkspaceModel = WorkspaceModel;
133                        connectorModel.PluginModel = this;
134                        connectorModel.IsMandatory = propertyInfoAttribute.Mandatory;
135                        connectorModel.PropertyName = propertyInfoAttribute.PropertyName;
136                        connectorModel.Outgoing = true;
137                        Plugin.PropertyChanged += connectorModel.PropertyChangedOnPlugin;
138                        OutputConnectors.Add(connectorModel);
139                        WorkspaceModel.AllConnectorModels.Add(connectorModel);
140                    }
141                }
142            }     
143        }
144
145        /// <summary>
146        /// Returns the Presentation of the wrapped IPlugin
147        /// </summary>
148        public System.Windows.Controls.UserControl PluginPresentation
149        {
150            get
151            {
152                return this.Plugin.Presentation;
153            }
154        }
155             
156        /// <summary>
157        /// Should be called by the UI-Thread to paint changes of the PluginModel
158        /// </summary>
159        public void paint()
160        {
161            //Enter some Code which calls the paint method of the IPlugin
162        }
163
164        /// <summary>
165        /// The current ExecutionState of this PluginModel
166        /// </summary>
167        public PluginModelState ExecutionState{
168            get
169            {
170                return this.executionstate;
171            }
172            set
173            {
174                this.executionstate = value;
175            }
176        }
177
178        /// <summary>
179        /// Checks wether this PluginModel is executable or not and sets the isExecutable bool
180        /// </summary>
181        /// <returns></returns>
182        public void checkExecutable()
183        {
184            if(ExecutionState == PluginModelState.UNDEFINED){
185
186                mutex.WaitOne();
187                //First test if every mandatory Connector has Data
188                foreach (ConnectorModel connectorModel in this.InputConnectors)
189                {
190                    if (connectorModel.IsMandatory && !connectorModel.HasData)
191                    {
192                        mutex.ReleaseMutex();
193                        return;
194                    }
195
196                }
197
198                //Next test if every connceted Connection to each Connection is not active
199                foreach (ConnectorModel connectorModel in this.OutputConnectors)
200                {
201                    foreach (ConnectionModel connection in connectorModel.OutputConnections)
202                    {
203                        if (connection.Active)
204                        {                           
205                            mutex.ReleaseMutex();
206                            return;
207                        }                       
208                    }
209                }
210
211                ExecutionState = PluginModelState.EXECUTABLE;
212                mutex.ReleaseMutex();
213            }
214            return;
215        }
216    }
217
218    /// <summary>
219    /// Execution States of a PluginModel
220    /// </summary>
221    public enum PluginModelState
222    {
223        UNDEFINED,
224        EXECUTABLE,
225        PRE_EXECUTING,
226        EXECUTING,
227        POST_EXECUTING,
228        TERMINATED,
229        ERROR
230    }
231}
Note: See TracBrowser for help on using the repository browser.