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

Last change on this file since 2380 was 2305, checked in by kopal, 11 years ago

added new Open method using a WorkspaceModel

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