source: trunk/CrypPlugins/WorkspaceManager/WorkspaceManager.cs @ 2679

Last change on this file since 2679 was 2679, checked in by Sven Rech, 11 years ago

Fixed WorkspaceManager model loading

File size: 30.3 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.Core;
23using Cryptool.PluginBase.Attributes;
24using Cryptool.PluginBase.Editor;
25using Cryptool.UiPluginBase;
26using Cryptool.PluginBase.IO;
27using Cryptool.PluginBase;
28
29using WorkspaceManager.Model;
30using WorkspaceManager.View;
31using WorkspaceManager.Execution;
32using WorkspaceManager.View.Container;
33using WorkspaceManager.View.Converter;
34using System.Windows;
35using System.Windows.Threading;
36using System.Threading;
37using System.Windows.Controls;
38using System.Windows.Media;
39using Cryptool.PluginBase.Miscellaneous;
40using WorkspaceManager.View.VisualComponents;
41using System.Windows.Media.Imaging;
42using System.Printing;
43using System.Windows.Documents;
44using System.Windows.Markup;
45using WorkspaceManager.Model.Tools;
46
47//Disable warnings for unused or unassigned fields and events:
48#pragma warning disable 0169, 0414, 0067
49
50namespace WorkspaceManager
51{
52    /// <summary>
53    /// Workspace Manager - PluginEditor based on MVC Pattern
54    /// </summary>
55    [TabColor("blue")]
56    [EditorInfo("cwm")]
57    [Author("Viktor Matkovic,Nils Kopal", "nils.kopal@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
58    [PluginInfo("WorkspaceManager.Resources.Attributes", false, "Workspace Manager", "Graphical plugin editor for the CrypTool workspace", "WorkspaceManager/DetailedDescription/Description.xaml", "WorkspaceManager/View/Image/WorkspaceManagerIcon.ico")]
59    public class WorkspaceManager : IEditor
60    {
61
62        /// <summary>
63        /// Create a new Instance of the Editor
64        /// </summary>
65        public WorkspaceManager()
66        {
67            Properties.Settings.Default.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(Default_PropertyChanged);
68            Settings = new WorkspaceManagerSettings(this);
69            WorkspaceModel = new WorkspaceModel();
70            WorkspaceModel.WorkspaceManagerEditor = this;
71            UndoRedoManager = new UndoRedoManager();
72            WorkspaceSpaceEditorView = new WorkSpaceEditorView(WorkspaceModel);
73            HasChanges = false;           
74        }
75
76        void Default_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
77        {
78            if(e.PropertyName == "EditScale")
79            {
80                if (OnZoomChanged != null)
81                    OnZoomChanged.Invoke(this, new ZoomChanged() { Value = Properties.Settings.Default.EditScale });
82            }
83        }
84
85        #region private Members
86
87        private WorkspaceModel WorkspaceModel = null;
88        private WorkSpaceEditorView WorkspaceSpaceEditorView = null;
89        private ExecutionEngine ExecutionEngine = null;
90        private volatile bool executing = false;
91        private volatile bool stopping = false;
92        private UndoRedoManager UndoRedoManager = null;
93
94        #endregion
95
96        /// <summary>
97        /// Is this Editor executing?
98        /// </summary>
99        public bool isExecuting(){
100            return executing;
101        }
102
103        #region IEditor Members
104
105        /// <summary>
106        ///
107        /// </summary>
108        public event SelectedPluginChangedHandler OnSelectedPluginChanged;
109
110        /// <summary>
111        ///
112        /// </summary>
113        public event ProjectTitleChangedHandler OnProjectTitleChanged;
114
115        /// <summary>
116        ///
117        /// </summary>
118        public event OpenProjectFileHandler OnOpenProjectFile;
119
120        /// <summary>
121        ///
122        /// </summary>
123        public event EditorSpecificPluginsChanged OnEditorSpecificPluginsChanged;
124
125        /// <summary>
126        /// Current filename
127        /// </summary>
128        public string CurrentFilename { private set; get; }
129
130        /// <summary>
131        /// Called by clicking on the new button of CrypTool
132        /// Creates a new Model
133        /// </summary>
134        public void New()
135        {
136            foreach (PluginModel pluginModel in new List<PluginModel>(WorkspaceModel.AllPluginModels))
137            {
138                WorkspaceModel.deletePluginModel(pluginModel);
139            }
140            this.HasChanges = false;
141            CurrentFilename = "unnamed project";
142            if (this.OnProjectTitleChanged != null)
143            {
144                this.OnProjectTitleChanged.BeginInvoke(this, "unnamed project", null, null);
145            }
146            UndoRedoManager.ClearStacks();
147            WorkspaceModel.UndoRedoManager = UndoRedoManager;
148            WorkspaceModel.UpdateableView = this.WorkspaceSpaceEditorView;
149        }
150
151        /// <summary>
152        /// Open the given model in the editor
153        /// </summary>
154        /// <param name="fileName"></param>
155        public void Open(WorkspaceModel model)
156        {
157            try
158            {
159                New();
160                WorkspaceModel = model;
161                WorkspaceSpaceEditorView.Load(WorkspaceModel);
162                WorkspaceModel.UndoRedoManager = UndoRedoManager;
163                WorkspaceModel.UpdateableView = this.WorkspaceSpaceEditorView;
164            }
165            catch (Exception ex)
166            {
167                GuiLogMessage("Could not open Model:" + ex.ToString(), NotificationLevel.Error);
168            }
169        }
170       
171        /// <summary>
172        /// Called by clicking on the open button of CrypTool
173        /// loads a serialized model
174        /// </summary>
175        /// <param name="fileName"></param>
176        public void Open(string fileName)
177        {
178            try
179            {
180                New();
181                GuiLogMessage("Loading Model: " + fileName, NotificationLevel.Info);               
182                WorkspaceModel = ModelPersistance.loadModel(fileName,this);               
183                WorkspaceSpaceEditorView.Load(WorkspaceModel);
184                WorkspaceModel.UndoRedoManager = UndoRedoManager;
185                WorkspaceModel.UpdateableView = this.WorkspaceSpaceEditorView;
186                HasChanges = false;
187                this.OnProjectTitleChanged.BeginInvoke(this, System.IO.Path.GetFileName(fileName), null, null);
188                CurrentFilename = fileName;
189            }
190            catch (Exception ex)
191            {
192                GuiLogMessage("Could not load Model:" + ex.ToString(), NotificationLevel.Error);
193            }
194        }
195
196        /// <summary>
197        /// Called by clicking on the save button of CrypTool
198        /// serializes the current model
199        /// </summary>
200        /// <param name="fileName"></param>
201        public void Save(string fileName)
202        {
203            try
204            {
205                GuiLogMessage("Saving Model: " + fileName, NotificationLevel.Info);
206                ModelPersistance.saveModel(this.WorkspaceModel, fileName);
207                HasChanges = false;
208                this.OnProjectTitleChanged.BeginInvoke(this, System.IO.Path.GetFileName(fileName), null, null);
209                CurrentFilename = fileName;
210            }
211            catch (Exception ex)
212            {
213                GuiLogMessage("Could not save Model:" + ex.ToString(), NotificationLevel.Error);               
214            }
215           
216        }
217
218        /// <summary>
219        /// Called by double clicking on a plugin symbol of CrypTool
220        /// Adds a new PluginModel wrapping an instance of the selected plugin
221        /// </summary>
222        /// <param name="type"></param>
223        public void Add(Type type)
224        {
225            /*if (!executing)
226            {
227                PluginModel newPluginModel = WorkspaceModel.newPluginModel(new Point(10, 10), 100, 100, type);
228                GuiLogMessage("Added by double click: " + newPluginModel.Name, NotificationLevel.Info);
229                HasChanges = true;
230            }*/
231        }
232
233        /// <summary>
234        ///
235        /// </summary>
236        /// <param name="espi"></param>
237        public void AddEditorSpecific(EditorSpecificPluginInfo espi)
238        {
239            //to be implemented
240        }
241
242        /// <summary>
243        ///
244        /// </summary>
245        /// <param name="espi"></param>
246        public void DeleteEditorSpecific(EditorSpecificPluginInfo espi)
247        {
248            //to be implemented   
249        }
250
251        /// <summary>
252        /// Undo changes
253        /// </summary>
254        public void Undo()
255        {
256            if (UndoRedoManager != null)
257            {
258                try
259                {
260                    UndoRedoManager.Undo();
261                }
262                catch (Exception ex)
263                {
264                    GuiLogMessage("Can not undo:" + ex.Message,NotificationLevel.Error);
265                }
266            }
267        }
268
269        /// <summary>
270        /// Redo changes
271        /// </summary>
272        public void Redo()
273        {
274            if (UndoRedoManager != null)
275            {
276                try
277                {
278                    UndoRedoManager.Redo();
279                }
280                catch (Exception ex)
281                {
282                    GuiLogMessage("Can not redo:" + ex.Message, NotificationLevel.Error);
283                }
284            }
285        }
286
287        public void Cut()
288        {
289           
290        }
291
292        public void Copy()
293        {
294           
295        }
296
297        public void Paste()
298        {
299           
300        }
301
302        public void Remove()
303        {
304           
305        }
306
307        public void Print()
308        {
309            try
310            {
311                Matrix m = PresentationSource.FromVisual(Application.Current.MainWindow).CompositionTarget.TransformToDevice;
312                double dx = m.M11 * 96;
313                double dy = m.M22 * 96;
314                this.GuiLogMessage("dx=" + dx + " dy=" + dy, NotificationLevel.Debug);
315                const int factor = 4;
316                ModifiedCanvas control = (ModifiedCanvas)((WorkSpaceEditorView)this.Presentation).scrollViewer.Content;
317                PrintDialog dialog = new PrintDialog();
318                dialog.PageRangeSelection = PageRangeSelection.AllPages;
319                dialog.UserPageRangeEnabled = true;
320
321                Nullable<Boolean> print = dialog.ShowDialog();
322                if (print == true)
323                {
324                    this.GuiLogMessage("Printing document \"" + this.CurrentFilename + "\" now", NotificationLevel.Info);
325                   
326                    PrintCapabilities capabilities = dialog.PrintQueue.GetPrintCapabilities(dialog.PrintTicket);
327                    System.Windows.Size pageSize = new System.Windows.Size(dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);
328                    System.Windows.Size visibleSize = new System.Windows.Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
329
330                    FixedDocument fixedDoc = new FixedDocument();
331                    control.Measure(new System.Windows.Size(double.PositiveInfinity, double.PositiveInfinity));
332                    control.Arrange(new Rect(new System.Windows.Point(0, 0), control.DesiredSize));
333                    System.Windows.Size size = control.DesiredSize;
334
335                    RenderTargetBitmap bmp = new RenderTargetBitmap((int)size.Width * factor, (int)size.Height * factor, dx * factor, dy * factor, PixelFormats.Pbgra32);
336                    bmp.Render(control);
337
338
339                    double xOffset = 0;
340                    double yOffset = 0;
341                    while (xOffset < size.Width)
342                    {
343                        yOffset = 0;
344                        while (yOffset < size.Height)
345                        {
346                            PageContent pageContent = new PageContent();
347                            FixedPage page = new FixedPage();
348                            ((IAddChild)pageContent).AddChild(page);
349                            fixedDoc.Pages.Add(pageContent);
350                            page.Width = pageSize.Width;
351                            page.Height = pageSize.Height;
352                            int width = (xOffset + visibleSize.Width) > size.Width ? (int)(size.Width - xOffset) : (int)visibleSize.Width;
353                            int height = (yOffset + visibleSize.Height) > size.Height ? (int)(size.Height - yOffset) : (int)visibleSize.Height;
354                            System.Windows.Controls.Image croppedImage = new System.Windows.Controls.Image();                           
355                            CroppedBitmap cb = new CroppedBitmap(bmp, new Int32Rect((int)xOffset * factor, (int)yOffset *factor, width * factor, height * factor));
356                            croppedImage.Source = cb;
357                            croppedImage.Width = width;
358                            croppedImage.Height = height;
359                            page.Children.Add(croppedImage);
360                            yOffset += visibleSize.Height;
361                        }
362                        xOffset += visibleSize.Width;
363                    }
364                    dialog.PrintDocument(fixedDoc.DocumentPaginator, "WorkspaceManager_" + this.CurrentFilename);
365                    this.GuiLogMessage("Printed \"" + fixedDoc.DocumentPaginator.PageCount + "\" pages of document \"" + this.CurrentFilename + "\"", NotificationLevel.Info);
366                }
367            }
368            catch (Exception ex)
369            {
370                this.GuiLogMessage("Exception while printing: " + ex.Message, NotificationLevel.Error);
371            }
372        }
373
374        /// <summary>
375        /// Show the Help site
376        /// </summary>
377        public void ShowHelp()
378        {
379            OnOpenTab(this.GetDescriptionDocument(), "WorkspaceManager Description", this);
380        }
381
382        /// <summary>
383        /// Show the Description of the selected plugin
384        /// </summary>
385        public void ShowSelectedPluginDescription()
386        {
387            //to be implemented properly
388            ShowHelp();
389        }
390
391        /// <summary>
392        /// Is Undo possible
393        /// </summary>
394        public bool CanUndo
395        {
396            get
397            {
398                if (UndoRedoManager != null)
399                {
400                    return !this.isExecuting() && UndoRedoManager.CanUndo();
401                }
402                else
403                {
404                    return false;
405                }
406            }
407        }
408
409        /// <summary>
410        /// Is Redo possible?
411        /// </summary>
412        public bool CanRedo
413        {
414            get
415            {
416                if (UndoRedoManager != null)
417                {
418                    return !this.isExecuting() && UndoRedoManager.CanRedo();
419                }
420                else
421                {
422                    return false;
423                }
424            }
425        }
426
427        public bool CanCut
428        {
429            get { return false; }
430        }
431
432        public bool CanCopy
433        {
434            get { return false; }
435        }
436
437        public bool CanPaste
438        {
439            get { return false; }
440        }
441
442        public bool CanRemove
443        {
444            get { return false; }
445        }
446
447        /// <summary>
448        /// Can the ExecutionEngine be started?
449        /// </summary>
450        public bool CanExecute
451        {
452            get{return !executing;}
453        }
454
455        /// <summary>
456        /// Can the ExecutionEngine be stopped?
457        /// </summary>
458        public bool CanStop
459        {
460            get { return executing; }
461        }
462
463        /// <summary>
464        /// Does this Editor has changes?
465        /// </summary>
466        public bool HasChanges
467        {
468            get;
469            set;
470        }
471
472        public bool CanPrint
473        {
474            get { return true; }
475        }
476
477        public string SamplesDir
478        {
479            set {  }
480        }
481
482        /// <summary>
483        ///
484        /// </summary>
485        public List<EditorSpecificPluginInfo> EditorSpecificPlugins
486        {
487            get;
488            set;
489        }
490
491        public bool ReadOnly { get; set; }
492
493        #endregion
494
495        #region IPlugin Members
496
497        /// <summary>
498        ///
499        /// </summary>
500        public event StatusChangedEventHandler OnPluginStatusChanged;
501
502        /// <summary>
503        ///
504        /// </summary>
505        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
506
507        /// <summary>
508        ///
509        /// </summary>
510        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
511
512        /// <summary>
513        /// Settings of this editor
514        /// </summary>
515        public ISettings Settings
516        {
517            get;
518            set;
519        }
520
521        /// <summary>
522        /// The Presentation of this editor
523        /// </summary>
524        public System.Windows.Controls.UserControl Presentation
525        {
526            get {return WorkspaceSpaceEditorView;}
527            set { WorkspaceSpaceEditorView = (WorkSpaceEditorView)value; }
528        }
529
530        /// <summary>
531        /// The QuickWatchPresentation of this editor
532        /// </summary>
533        public System.Windows.Controls.UserControl QuickWatchPresentation
534        {
535            get;
536            set;
537        }
538
539        /// <summary>
540        /// Called before execution
541        /// </summary>
542        public void PreExecution()
543        {
544            //to be implemented
545        }
546
547        /// <summary>
548        /// Starts the ExecutionEngine to execute the model
549        /// </summary>
550        public void Execute()
551        {
552            if (executing)
553            {
554                return;
555            }
556            EventsHelper.AsynchronousPropertyChanged = false;
557            try
558            {
559                GuiLogMessage("Execute Model now!", NotificationLevel.Info);
560                executing = true;
561
562                if (((WorkspaceManagerSettings)this.Settings).SynchronousEvents)
563                {
564                    EventsHelper.AsynchronousProgressChanged = false;
565                    EventsHelper.AsynchronousGuiLogMessage = false;
566                    EventsHelper.AsynchronousStatusChanged = false;
567                }
568
569                //Get the gui Thread
570                this.WorkspaceSpaceEditorView.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
571                {
572                    this.WorkspaceSpaceEditorView.ResetConnections();
573                    this.WorkspaceSpaceEditorView.State = EditorState.BUSY;                   
574                }
575                , null);
576
577                this.ExecutionEngine = new ExecutionEngine(this);
578
579                try
580                {
581                    ExecutionEngine.GuiUpdateInterval = int.Parse(((WorkspaceManagerSettings)this.Settings).GuiUpdateInterval);
582                    if (ExecutionEngine.GuiUpdateInterval <= 0)
583                    {
584                        GuiLogMessage("GuiUpdateInterval can not be <=0; Use GuiUpdateInterval = 1", NotificationLevel.Warning);
585                        ExecutionEngine.GuiUpdateInterval = 1;
586                    }
587                }
588                catch (Exception ex)
589                {
590                    GuiLogMessage("Could not set GuiUpdateInterval: " + ex.Message, NotificationLevel.Warning);
591                    ExecutionEngine.GuiUpdateInterval = 100;
592                }
593
594                try
595                {
596                    ExecutionEngine.SleepTime = int.Parse(((WorkspaceManagerSettings)this.Settings).SleepTime);
597                    if (ExecutionEngine.SleepTime < 0)
598                    {
599                        GuiLogMessage("SleepTime can not be <=0; Use GuiUpdateInterval = 0", NotificationLevel.Warning);
600                        ExecutionEngine.SleepTime = 0;
601                    }
602                }
603                catch (Exception ex)
604                {
605                    GuiLogMessage("Could not set SleepTime: " + ex.Message, NotificationLevel.Warning);
606                    ExecutionEngine.GuiUpdateInterval = 0;
607                }
608
609                int schedulers=0;
610                try
611                {
612                   schedulers = int.Parse(((WorkspaceManagerSettings)this.Settings).Threads);
613                    if (ExecutionEngine.SleepTime < 0)
614                    {
615                        GuiLogMessage("Schedulers can not be <=0; Use Schedulers = 1", NotificationLevel.Warning);
616                        schedulers = 1;
617                    }
618                }
619                catch (Exception ex)
620                {
621                    GuiLogMessage("Could not set Schedulers: " + ex.Message, NotificationLevel.Warning);
622                    schedulers = 1;
623                }
624
625                ExecutionEngine.BenchmarkPlugins = ((WorkspaceManagerSettings)this.Settings).BenchmarkPlugins;
626                ExecutionEngine.ThreadPriority = ((WorkspaceManagerSettings)this.Settings).ThreadPriority;
627
628                ExecutionEngine.Execute(WorkspaceModel, schedulers);               
629            }
630            catch (Exception ex)
631            {
632                GuiLogMessage("Exception during the execution: " + ex.Message, NotificationLevel.Error);
633                executing = false;
634                if (((WorkspaceManagerSettings)this.Settings).SynchronousEvents)
635                {
636                    EventsHelper.AsynchronousProgressChanged = true;
637                    EventsHelper.AsynchronousGuiLogMessage = true;
638                    EventsHelper.AsynchronousStatusChanged = true;
639                }
640            }
641        }
642
643        /// <summary>
644        /// Called after the execution
645        /// </summary>
646        public void PostExecution()
647        {
648            //to be implemented
649        }
650
651        /// <summary>
652        /// Pause the execution
653        /// </summary>
654        public void Pause()
655        {   
656            //to be implemented
657        }
658
659        /// <summary>
660        /// Stop the ExecutionEngine
661        /// </summary>
662        public void Stop()
663        {
664            if (!executing || stopping)
665            {
666                return;
667            }
668
669            stopping = true;
670
671            Thread stopThread = new Thread(new ThreadStart(waitingStop));
672            stopThread.Start(); 
673
674            EventsHelper.AsynchronousPropertyChanged = true;
675
676            if (((WorkspaceManagerSettings)this.Settings).SynchronousEvents)
677            {
678                EventsHelper.AsynchronousProgressChanged = true;
679                EventsHelper.AsynchronousGuiLogMessage = true;
680                EventsHelper.AsynchronousStatusChanged = true;
681            }
682
683                       
684        }
685
686        /// <summary>
687        /// Stops the execution engine and blocks until this work is done
688        /// </summary>
689        private void waitingStop()
690        {
691            try
692            {
693                GuiLogMessage("Executing stopped by User!", NotificationLevel.Info);
694                ExecutionEngine.Stop();
695                //Get the gui Thread
696                this.WorkspaceSpaceEditorView.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
697                {
698                    this.WorkspaceSpaceEditorView.ResetConnections();
699                    this.WorkspaceSpaceEditorView.State = EditorState.READY;
700                }
701                , null);
702            }
703            catch (Exception ex)
704            {
705                GuiLogMessage("Exception during the stopping of the execution: " + ex.Message, NotificationLevel.Error);
706            }
707            executing = false;
708            this.ExecutionEngine = null;
709            GC.Collect();
710            stopping = false;
711        }
712
713        /// <summary>
714        /// Called to initialize the editor
715        /// </summary>
716        public void Initialize()
717        {
718            //to be implemented
719        }
720
721        /// <summary>
722        /// Called when the editor is disposed
723        /// </summary>
724        public void Dispose()
725        {
726            if (ExecutionEngine != null && ExecutionEngine.IsRunning)
727            {
728                ExecutionEngine.Stop();
729            }
730            EventsHelper.AsynchronousPropertyChanged = true;
731        }
732
733        #endregion
734
735        #region INotifyPropertyChanged Members
736
737        /// <summary>
738        ///
739        /// </summary>
740        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
741
742        #endregion
743
744        #region IApplication Members
745
746        /// <summary>
747        ///
748        /// </summary>
749        private PluginManager pluginManager;
750        public PluginManager PluginManager
751        {
752            get { return pluginManager; }
753            set
754            {
755                pluginManager = value;
756                DragDropDataObjectToPluginConverter.PluginManager = value;
757            }         
758        }
759
760        #endregion
761
762        #region GuiLogMessage, Progress
763
764        /// <summary>
765        /// Loggs a message to the logging mechanism of CrypTool
766        /// </summary>
767        /// <param name="Message"></param>
768        /// <param name="notificationLevel"></param>
769        public void GuiLogMessage(string Message, NotificationLevel notificationLevel)
770        {
771            if (OnGuiLogNotificationOccured != null)
772            {
773                GuiLogEventArgs args = new GuiLogEventArgs(Message, this, notificationLevel);
774                args.Title = "-";
775                OnGuiLogNotificationOccured(this, args);
776            }
777        }
778
779        /// <summary>
780        /// GuiLogNotificationOccured
781        /// </summary>
782        /// <param name="sender"></param>
783        /// <param name="args"></param>
784        public void GuiLogNotificationOccured(IPlugin sender, GuiLogEventArgs args)
785        {
786            //Check if the logging event is Warning or Error and set the State of the PluginModel to
787            //the corresponding PluginModelState
788            if (args.NotificationLevel == NotificationLevel.Warning)
789            {               
790                foreach (PluginModel pluginModel in this.WorkspaceModel.AllPluginModels)
791                {
792                    if (pluginModel.Plugin == sender)
793                    {
794                        pluginModel.State = PluginModelState.Warning;
795                        pluginModel.GuiNeedsUpdate = true;
796                    }
797                }
798            }
799
800            if (args.NotificationLevel == NotificationLevel.Error)
801            {               
802                foreach (PluginModel pluginModel in this.WorkspaceModel.AllPluginModels)
803                {
804                    if (pluginModel.Plugin == sender)
805                    {
806                        pluginModel.State = PluginModelState.Error;
807                        pluginModel.GuiNeedsUpdate = true;
808                    }
809                }
810            }
811
812            if (OnGuiLogNotificationOccured != null)
813            {
814                switch (((WorkspaceManagerSettings)this.Settings).LogLevel)
815                {
816                    case 3://Error
817                        if (args.NotificationLevel == NotificationLevel.Debug ||
818                            args.NotificationLevel == NotificationLevel.Info ||
819                            args.NotificationLevel == NotificationLevel.Warning)
820                        {
821                            return;
822                        }
823                        break;
824
825                    case 2://Warning
826                        if (args.NotificationLevel == NotificationLevel.Debug ||
827                            args.NotificationLevel == NotificationLevel.Info)
828                        {
829                            return;
830                        }
831                        break;
832
833                    case 1://Info
834                        if (args.NotificationLevel == NotificationLevel.Debug)
835                        {
836                            return;
837                        }
838                        break;
839                }
840                OnGuiLogNotificationOccured(sender, args);
841            }
842               
843        }
844
845        /// <summary>
846        /// Progress of this editor
847        /// </summary>
848        /// <param name="Value"></param>
849        /// <param name="MaxValue"></param>
850        private void Progress(int Value, int MaxValue)
851        {
852            if (OnPluginProgressChanged != null)
853            {
854                OnPluginProgressChanged(this, new PluginProgressEventArgs(Value, MaxValue));
855            }
856        }
857        #endregion GuiLogMessage, Progress
858
859        /// <summary>
860        /// Selected Plugin changed by View
861        /// </summary>
862        /// <param name="args"></param>
863        public void onSelectedPluginChanged(PluginChangedEventArgs args)
864        {
865            this.OnSelectedPluginChanged(this, args);
866        }
867
868        #region IEditor Members
869
870
871        public void Active()
872        {
873            var b = true;
874        }
875
876        #endregion
877
878        #region IEditor Members
879
880
881        public event OpenTabHandler OnOpenTab;
882
883        #endregion
884
885
886        public double GetZoom()
887        {
888            return Properties.Settings.Default.EditScale;
889        }
890
891        public void Zoom(double value)
892        {
893            Properties.Settings.Default.EditScale = value;
894        }
895
896        public void FitToScreen()
897        {
898            this.WorkspaceSpaceEditorView.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
899            {
900                this.WorkspaceSpaceEditorView.FitToScreen();
901            }
902            , null);
903        }
904
905       
906
907        public event EventHandler<ZoomChanged> OnZoomChanged;
908    }
909}
910
911//Restore warnings for unused or unassigned fields and events:
912#pragma warning restore 0169, 0414, 0067
Note: See TracBrowser for help on using the repository browser.