source: trunk/CrypPlugins/Wizard/WizardControl.xaml.cs

Last change on this file was 8983, checked in by kopal, 8 months ago

Complete CrypTool 2 project

  • renamed "Cryptool" namespace to "CrypTool" namespace
File size: 86.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Collections.ObjectModel;
4using System.ComponentModel;
5using System.Linq;
6using System.Net;
7using System.Text.RegularExpressions;
8using System.Windows;
9using System.Windows.Controls;
10using System.Windows.Data;
11using System.Windows.Documents;
12using System.Windows.Input;
13using System.Windows.Media;
14using System.Windows.Media.Animation;
15using System.Windows.Shapes;
16using System.Xml;
17using System.Xml.Linq;
18using System.Reflection;
19using System.Windows.Threading;
20using System.Threading;
21using System.Globalization;
22using System.Xml.Schema;
23using CrypTool.Core;
24using CrypTool.PluginBase;
25using CrypTool.PluginBase.Editor;
26using CrypTool.PluginBase.Miscellaneous;
27using KeyTextBox;
28using WorkspaceManager.Model;
29using Path = System.IO.Path;
30using ValidationType = System.Xml.ValidationType;
31
32namespace Wizard
33{
34    /// <summary>
35    /// Interaction logic for WizardControl.xaml
36    /// </summary>
37    [CrypTool.PluginBase.Attributes.Localization("Wizard.Properties.Resources")]
38    public partial class WizardControl : UserControl
39    {
40        private class PageInfo
41        {
42            public string name;
43            public string description;
44            public string image;
45            public XElement tag;
46            public string headline;
47        }
48
49        private class ConditionalTextSetter
50        {
51            public Action<XElement> TextSetter { get; set; }
52            public XElement XElement { get; set; }
53        }
54
55        ObservableCollection<PageInfo> currentHistory = new ObservableCollection<PageInfo>();
56        private readonly RecentFileList _recentFileList = RecentFileList.GetSingleton();
57        private List<ConditionalTextSetter> conditionalTextSetters;
58        private Dictionary<string, bool> selectedCategories = new Dictionary<string, bool>();
59        private SolidColorBrush selectionBrush = new SolidColorBrush();
60        private const string configXMLPath = "Wizard.Config.wizard.config.start.xml";
61        private const string defaultLang = "en";
62        private XElement wizardConfigXML;
63        private Dictionary<string, List<PluginPropertyValue>> propertyValueDict = new Dictionary<string, List<PluginPropertyValue>>();
64        private HashSet<TextBox> boxesWithWrongContent = new HashSet<TextBox>();
65        private HistoryTranslateTransformConverter historyTranslateTransformConverter = new HistoryTranslateTransformConverter();
66        private List<TextBox> currentOutputBoxes = new List<TextBox>();
67        private List<ProgressBar> currentProgressBars = new List<ProgressBar>();
68        private List<TextBox> currentInputBoxes = new List<TextBox>();
69        private List<ContentControl> currentPresentations = new List<ContentControl>();
70        private WorkspaceManager.WorkspaceManagerClass currentManager = null;
71        private bool canStopOrExecute = false;
72        private string _title;
73
74        internal event OpenEditorHandler OnOpenEditor;
75        internal event OpenTabHandler OnOpenTab;
76        internal event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
77
78        internal string SamplesDir { set; private get; }
79       
80        public WizardControl()
81        {
82            InitializeComponent();
83            OuterScrollViewer.Focus();
84            Loaded += delegate { Keyboard.Focus(this); };
85        }
86
87        public void Initialize()
88        {
89            try
90            {
91                // DEBUG HELP string[] names = this.GetType().Assembly.GetManifestResourceNames();
92
93                XElement xml = GetXml(configXMLPath);
94                GenerateXML(xml);
95               
96                currentHistory.CollectionChanged += delegate
97                {
98                    CreateHistory();
99                };
100
101                selectionBrush.Color = Color.FromArgb(255, 200, 220, 245);
102                SetupPage(wizardConfigXML);
103                AddToHistory(wizardConfigXML);
104            }
105            catch (Exception ex)
106            {
107                GuiLogMessage(string.Format("Couldn't create wizard: {0}", ex.Message), NotificationLevel.Error);
108            }
109        }
110
111        public XElement WizardConfigXML
112        {
113            get { return wizardConfigXML; }
114        }
115
116        private XElement GetXml(string xmlPath)
117        {
118            XmlReaderSettings settings = new XmlReaderSettings();
119            settings.DtdProcessing = DtdProcessing.Parse;
120            settings.ValidationType = ValidationType.DTD;
121            settings.ValidationEventHandler += delegate(object sender, ValidationEventArgs e)
122                                                   {
123                                                       GuiLogMessage(string.Format("Error validating wizard XML file {0}: {1}", xmlPath, e.Message), NotificationLevel.Error);
124                                                   };
125            settings.XmlResolver = new ResourceDTDResolver();
126
127            return LoadXMLFromAssembly(xmlPath, settings);
128        }
129
130        public static XElement LoadXMLFromAssembly(string xmlPath, XmlReaderSettings settings)
131        {
132            XmlReader xmlReader = XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream(xmlPath), settings);
133            return XElement.Load(xmlReader);
134        }
135
136        internal class ResourceDTDResolver : XmlResolver
137        {
138            public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
139            {
140                if (Path.GetFileName(absoluteUri.LocalPath) == "wizard.dtd")
141                    return Assembly.GetExecutingAssembly().GetManifestResourceStream("Wizard.Config.wizard.dtd");
142                return null;
143            }
144
145            public override ICredentials Credentials
146            {
147                set { }
148            }
149        }
150
151        // generate the full XML tree for the wizard (recursive)
152        private void GenerateXML(XElement xml)
153        {
154            try
155            {
156                IEnumerable<XElement> allFiles = xml.Elements("file");
157                foreach(var ele in allFiles)
158                {
159                    XAttribute att = ele.Attribute("resource");
160                    if (att != null)
161                    {
162                        string path = att.Value;
163                        XElement sub = GetXml(path);
164                        ele.AddAfterSelf(sub);
165                    }
166                }
167
168                IEnumerable<XElement> allElements = xml.Elements();
169                if (allElements.Any())
170                {
171                    foreach (XElement ele in allElements)
172                    {
173                        if (ele.Name != "file")
174                        {
175                            GenerateXML(ele);
176                        }
177                    }
178                }
179
180                wizardConfigXML = xml;
181
182            }
183            catch (Exception ex)
184            {
185                GuiLogMessage(string.Format("Could not GenerateXML: {0}", ex.Message), NotificationLevel.Error);
186            }
187        }
188
189        #region WidthConverter
190
191        [ValueConversion(typeof(Double), typeof(Double))]
192        private class WidthConverter : IValueConverter
193        {
194            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
195            {
196                return (double)value * (double)parameter;
197            }
198
199            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
200            {
201                throw new NotImplementedException();
202            }
203        }
204
205        private WidthConverter widthConverter = new WidthConverter();
206
207        #endregion
208
209        #region HistoryTranslateTransformConverter
210
211        [ValueConversion(typeof(double), typeof(double))]
212        class HistoryTranslateTransformConverter : IValueConverter
213        {
214            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
215            {
216                return (double)value - 2;
217            }
218
219            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
220            {
221                throw new NotImplementedException();
222            }
223        }
224
225        #endregion
226
227        private void SetupPage(XElement element)
228        {
229            StopCurrentWorkspaceManager();
230            nextButton.IsEnabled = true;
231            CreateProjectButton.Visibility = Visibility.Hidden;
232            HideErrorLabel();
233
234            currentOutputBoxes.Clear();
235            currentProgressBars.Clear();
236            currentInputBoxes.Clear();
237            currentPresentations.Clear();
238            boxesWithWrongContent.Clear();
239            conditionalTextSetters = new List<ConditionalTextSetter>();
240            SaveContent();
241
242            if ((element.Name == "loadSample") && (element.Attribute("file") != null) && (element.Attribute("title") != null))
243            {
244                if (!LoadSample(element.Attribute("file").Value, element.Attribute("title").Value, true, element))
245                {
246                    ErrorLabel.Visibility = Visibility.Visible;
247                }
248                abortButton_Click(null, null);
249                return;
250            }
251
252            XElement parent = element.Parent;
253            if (parent == null)
254            {
255                backButton.IsEnabled = false;
256                abortButton.IsEnabled = false;
257            }
258            else
259            {
260                backButton.IsEnabled = true;
261                abortButton.IsEnabled = true;
262            }
263
264            //nextButton.IsEnabled = false;
265
266            //set headline
267            XElement headline = FindElementsInElement(element, "headline").First();
268            if (headline != null)
269            {
270                SetTextFromXElement(headline, delegate(XElement el) { taskHeader.Content = el.Value.Trim().ToUpper(); });
271            }
272
273            //set task description label
274            XElement task = FindElementsInElement(element, "task").First();
275            if (task != null)
276            {
277                SetTextFromXElement(task, delegate(XElement el) { descHeader.Text = el.Value.Trim(); });
278            }
279
280
281            if (element.Name == "input" || element.Name == "sampleViewer")
282            {
283                categoryGrid.Visibility = Visibility.Hidden;
284                inputPanel.Visibility = Visibility.Visible;
285               
286                var inputs = from el in element.Elements()
287                             where el.Name == "inputBox" || el.Name == "comboBox" || el.Name == "checkBox" || el.Name == "outputBox" 
288                             || el.Name == "keyTextBox" || el.Name == "progressBar" || el.Name == "label" || el.Name == "presentation" 
289                             || el.Name == "pluginSetter"
290                             select el;
291
292                inputStack.Children.Clear();
293               
294                var allNexts = (from el in element.Elements()
295                                 where el.Name == "input" || el.Name == "category" || el.Name == "loadSample" || el.Name == "sampleViewer"
296                                 select el);
297                if (allNexts.Count() > 0)
298                {
299                    inputPanel.Tag = allNexts.First();
300                    if (allNexts.First().Name == "loadSample")
301                        SwitchNextButtonContent();
302                }
303                else
304                {
305                    var dummy = new XElement("loadSample");
306                    element.Add(dummy);
307                    inputPanel.Tag = dummy;
308                    SwitchNextButtonContent();
309                }
310
311                FillInputStack(inputs, element.Name.ToString(), (element.Name == "input"));
312
313                if (element.Name == "sampleViewer" && (element.Attribute("file") != null))
314                {
315                    nextButton.IsEnabled = false;
316                    if (element.Attribute("showCreateButton") == null || element.Attribute("showCreateButton").Value.ToLower() != "false")
317                    {
318                        CreateProjectButton.Visibility = Visibility.Visible;
319                    }
320                   
321                    if (!LoadSample(element.Attribute("file").Value, null, false, element))
322                    {
323                        ErrorLabel.Visibility = Visibility.Visible;
324                    }
325                }
326
327                string id = GetElementID((XElement)inputPanel.Tag);
328
329            }
330            else if (element.Name == "category")
331            {
332                categoryGrid.Visibility = Visibility.Visible;
333                inputPanel.Visibility = Visibility.Hidden;
334               
335                radioButtonStackPanel.Children.Clear();
336
337                //generate radio buttons
338                var options = from el in element.Elements()
339                              where el.Name == "category" || el.Name == "input" || el.Name == "loadSample" || el.Name == "sampleViewer"
340                              select el;
341
342                if (options.Any())
343                {
344                    bool isSelected = false;
345
346                    foreach (XElement ele in options)
347                    {
348                        Border border = new Border();
349                        Label l = new Label();
350                        Image i = new Image();
351                        StackPanel sp = new StackPanel();
352
353                        border.Child = sp;
354                        border.VerticalAlignment = VerticalAlignment.Stretch;
355                        border.CornerRadius = new CornerRadius(5, 0, 0, 5);
356                        border.BorderBrush = Brushes.LightSeaGreen;
357
358                        l.Height = 35;
359                        l.HorizontalAlignment = HorizontalAlignment.Stretch;
360                        XElement label = FindElementsInElement(ele, "name").First();
361                        if (label != null)
362                        {
363                            SetTextFromXElement(label, delegate(XElement el) { l.Content = el.Value.Trim(); });
364                        }
365
366                        i.Width = 26;
367                        string image = ele.Attribute("image").Value;
368                        if (image != null)
369                        {
370                            ImageSource ims = (ImageSource) TryFindResource(image);
371                            if (ims != null)
372                            {
373                                i.Source = ims;
374                                sp.Children.Add(i);
375                            }
376                            else
377                                GuiLogMessage(string.Format("Could not find ressource image {0}!",image), NotificationLevel.Warning);
378                        }
379
380                        sp.VerticalAlignment = VerticalAlignment.Stretch;
381                        sp.HorizontalAlignment = HorizontalAlignment.Stretch;
382                        sp.Orientation = Orientation.Horizontal;
383                        sp.Children.Add(l);
384
385                        RadioButton rb = new RadioButton();
386                        rb.Focusable = false;
387                        string id = GetElementID(ele);
388                        rb.Checked += rb_Checked;
389                        rb.MouseDoubleClick += rb_MouseDoubleClick;
390                        rb.HorizontalAlignment = HorizontalAlignment.Stretch;
391                        rb.VerticalAlignment = VerticalAlignment.Stretch;
392                        rb.VerticalContentAlignment = VerticalAlignment.Center;
393                        rb.HorizontalContentAlignment = HorizontalAlignment.Stretch;
394                        rb.Content = border;
395                        rb.Tag = ele;
396                        if (ele.Name == "loadSample")
397                        {
398                            RoutedEventHandler rbEvent = delegate
399                                              {
400                                                  SwitchNextButtonContent();
401                                              };
402                            rb.Checked += rbEvent;
403                            rb.Unchecked += rbEvent;
404                        }
405
406                        radioButtonStackPanel.Children.Add(rb);
407                        bool wasSelected = false;
408                        selectedCategories.TryGetValue(GetElementID(ele), out wasSelected);
409                        if (wasSelected)
410                        {
411                            rb.IsChecked = true;
412                            isSelected = true;
413                        }
414                    }
415
416                    if (!isSelected)
417                    {
418                        RadioButton b = (RadioButton)radioButtonStackPanel.Children[0];
419                        b.IsChecked = true;
420                        selectedCategories.Remove(GetElementID((XElement)b.Tag));
421                        selectedCategories.Add(GetElementID((XElement)b.Tag), true);
422                    }
423
424                }
425            }
426        }
427
428        private void HideErrorLabel()
429        {
430            if ((ErrorLabel.Tag != null) && ((bool)(ErrorLabel.Tag) == true))
431            {
432                ErrorLabel.Visibility = Visibility.Collapsed;
433                ErrorLabel.Tag = false;
434            }
435            else
436            {
437                ErrorLabel.Tag = true;
438            }
439        }
440
441        void rb_MouseDoubleClick(object sender, MouseButtonEventArgs e)
442        {
443            nextButton_Click(sender, e);
444        }
445
446        private void FillInputStack(IEnumerable<XElement> inputs, string type, bool isInput)
447        {
448            var inputFieldStyle = (Style)FindResource("InputFieldStyle");
449
450            var groups = from input in inputs where input.Attribute("group") != null select input.Attribute("group").Value;
451            groups = groups.Distinct();
452
453            var inputGroups = new List<StackPanel>();
454            var otherInputs = new List<StackPanel>();
455
456            foreach (var group in groups)
457            {
458                var sp = new StackPanel();
459                sp.Orientation = Orientation.Horizontal;
460                sp.Tag = group;
461                inputGroups.Add(sp);
462            }
463
464            foreach (var input in inputs)
465            {
466                try
467                {
468                    var stack = new StackPanel();
469
470                    var descriptionTextBlock = new TextBlock() { FontWeight = FontWeights.Normal };
471                    var description = new Label() { Content = descriptionTextBlock };
472                    var descEle = FindElementsInElement(input, "description");
473                    if (descEle != null && descEle.Any())
474                    {
475                        SetTextFromXElement(descEle.First(), el =>
476                                                                 {
477                                                                     descriptionTextBlock.Inlines.Clear();
478                                                                     var inline = TrimInline(XMLHelper.ConvertFormattedXElement(el));
479                                                                     if (inline != null)
480                                                                     {
481                                                                         descriptionTextBlock.Inlines.Add(inline);
482                                                                     }
483                                                                 });
484                    }
485                    description.HorizontalAlignment = HorizontalAlignment.Left;
486                    description.FontWeight = FontWeights.Bold;
487                    stack.Children.Add(description);
488
489                    if (input.Name != "label")
490                    {
491                        Control inputElement = CreateInputElement(input, inputFieldStyle, isInput);
492
493                        //TODO add controls to same "level" if they have the same group
494
495                        //Set width:
496                        if (inputElement != null && input.Attribute("width") != null)
497                        {
498                            string width = input.Attribute("width").Value.Trim();
499                            if (width.EndsWith("%"))
500                            {
501                                double percentage;
502                                if (Double.TryParse(width.Substring(0, width.Length - 1), out percentage))
503                                {
504                                    percentage /= 100;
505                                    Binding binding = new Binding("ActualWidth");
506                                    binding.Source = inputStack;
507                                    binding.Converter = widthConverter;
508                                    binding.ConverterParameter = percentage;
509                                    inputElement.SetBinding(FrameworkElement.WidthProperty, binding);
510                                }
511                            }
512                            else
513                            {
514                                double widthValue;
515                                if (Double.TryParse(width, out widthValue))
516                                {
517                                    inputElement.Width = widthValue;
518                                }
519                            }
520                        }
521
522                        //Set alignment
523                        if (inputElement != null && input.Attribute("alignment") != null)
524                        {
525                            switch (input.Attribute("alignment").Value.Trim().ToLower())
526                            {
527                                case "right":
528                                    inputElement.HorizontalAlignment = HorizontalAlignment.Right;
529                                    break;
530                                case "left":
531                                    inputElement.HorizontalAlignment = HorizontalAlignment.Left;
532                                    break;
533                                case "center":
534                                    inputElement.HorizontalAlignment = HorizontalAlignment.Center;
535                                    break;
536                                case "stretch":
537                                    inputElement.HorizontalAlignment = HorizontalAlignment.Stretch;
538                                    break;
539                            }
540                        }
541
542                        stack.Children.Add(inputElement);
543                    }
544
545                    if (input.Attribute("group") != null && inputGroups.Any())
546                    {
547                        var sp = from g in inputGroups where (string)g.Tag == input.Attribute("group").Value select g;
548                        if (sp.Any())
549                        {
550                            var group = sp.First();
551                            group.Children.Add(stack);
552                        }
553                    }
554                    else
555                    {
556                        stack.Tag = input;
557                        otherInputs.Add(stack);
558                    }
559                }
560                catch (Exception e)
561                {
562                    GuiLogMessage(string.Format("Error while creating wizard element {0}: {1}", input, e.Message), NotificationLevel.Error);
563                }
564            }
565
566            foreach (var input in inputs)
567            {
568                if (input.Attribute("group") != null && inputGroups.Any())
569                {
570                    var sp = from g in inputGroups where (string)g.Tag == input.Attribute("group").Value select g;
571                    if (sp.Any())
572                    {
573                        var group = sp.First();
574                        if (!inputStack.Children.Contains(group))
575                            inputStack.Children.Add(group);
576                    }
577                }
578                else
579                {
580                    var p = from g in otherInputs where (XElement)g.Tag == input select g;
581                    if (p.Any())
582                    {
583                        var put = p.First();
584                        inputStack.Children.Add(put);
585                    }
586                }
587            }
588
589        }
590
591        private Inline TrimInline(Inline inline, bool left = true, bool right = true)
592        {
593            if (inline is Run)
594            {
595                if (left)
596                {
597                    ((Run) inline).Text = ((Run) inline).Text.TrimStart();
598                }
599                if (right)
600                {
601                    ((Run) inline).Text = ((Run) inline).Text.TrimEnd();
602                }
603            }
604            else if (inline is Span)
605            {
606                var inlines = ((Span) inline).Inlines;
607                TrimInline(inlines.First(), true, false);
608                TrimInline(inlines.Last(), false, true);
609            }
610            return inline;
611        }
612
613        private Control CreateInputElement(XElement input, Style inputFieldStyle, bool isInput)
614        {
615            Control element = null;
616
617            string key = null;
618            if (input.Name != "presentation" && input.Name != "progressBar")
619                key = GetElementPluginPropertyKey(input);
620
621            var pluginPropertyValue = GetPropertyValue(key, input.Parent);
622
623            XElement xel;
624            switch (input.Name.ToString())
625            {
626                case "pluginSetter":
627                    var pluginInputBox = new TextBox();
628                    pluginInputBox.Visibility = Visibility.Collapsed;
629                    pluginInputBox.Tag = input;
630                    pluginInputBox.Text = input.Value;
631                    element = pluginInputBox;
632                    break;
633
634                case "inputBox":
635                    var inputBox = new TextBox();
636                    inputBox.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
637                    inputBox.Tag = input;
638                    inputBox.AcceptsReturn = true;
639                    inputBox.TextWrapping = TextWrapping.Wrap;
640                    if (input.Attribute("visibleLines") != null)
641                    {
642                        int visibleLines;
643                        if (Int32.TryParse(input.Attribute("visibleLines").Value.Trim(), out visibleLines))
644                        {
645                            inputBox.MinLines = visibleLines;
646                            inputBox.MaxLines = visibleLines;
647                        }
648                    }
649                    inputBox.Style = inputFieldStyle;
650
651                    if (input.Attribute("regex") != null)
652                    {
653                        var regex = new Regex(input.Attribute("regex").Value, RegexOptions.Compiled);
654
655                        inputBox.TextChanged += delegate
656                        {
657                            CheckRegex(inputBox, regex);
658                        };
659                    }
660
661                    if (key != null && pluginPropertyValue != null)
662                        inputBox.Text = (string) pluginPropertyValue.Value;
663                    else
664                    {
665                        var defaultvalues = FindElementsInElement(input, "defaultvalue");
666                        SetTextFromXElement(defaultvalues.First(), delegate(XElement el)
667                                                                       {
668                                                                           if (!string.IsNullOrEmpty(el.Value))
669                                                                               inputBox.Text = el.Value.Trim();
670                                                                       });
671                    }
672
673                    if (!isInput)
674                        currentInputBoxes.Add(inputBox);
675
676                    xel = input.Element("storage");
677                    if (xel != null)
678                    {
679                        var storageContainer = new StorageContainer(ShowStorageOverlay);
680                        bool showStorageButton;
681                        bool showLoadAddButtons;
682                        GetStorageAttributes(xel, out showStorageButton, out showLoadAddButtons);
683                        storageContainer.AddContent(inputBox, xel.Attribute("key").Value, showStorageButton, showLoadAddButtons, showLoadAddButtons);
684                        storageContainer.SetValueMethod(delegate(string s) { inputBox.Text = s; });
685                        storageContainer.GetValueMethod(() => inputBox.Text);
686                        element = storageContainer;
687                    }
688                    else
689                    {
690                        element = inputBox;
691                    }
692                    break;
693
694                case "comboBox":
695                    var comboBox = new ComboBox();
696                    comboBox.Style = inputFieldStyle;
697                    comboBox.Tag = input;
698                    comboBox.SelectionChanged += InputComboBoxSelectionChanged;
699
700                    var items = FindElementsInElement(input, "item");
701                    foreach (var item in items)
702                    {
703                        var cbi = new ComboBoxItem();
704                        if (item.Attribute("content") != null)
705                        {
706                            cbi.Content = item.Attribute("content").Value;
707                        }
708                        comboBox.Items.Add(cbi);
709                    }
710
711                    if (key != null && pluginPropertyValue != null)
712                    {
713                        if (pluginPropertyValue.Value is int)
714                        {
715                            var cbi = (ComboBoxItem) comboBox.Items.GetItemAt((int)pluginPropertyValue.Value);
716                            cbi.IsSelected = true;
717                        }
718                    }
719                    else if (input.Attribute("defaultValue") != null)
720                    {
721                        int i;
722                        if (Int32.TryParse(input.Attribute("defaultValue").Value.Trim(), out i))
723                        {
724                            var cbi = (ComboBoxItem) comboBox.Items.GetItemAt(i);
725                            cbi.IsSelected = true;
726                        }
727                    }
728                    else
729                    {
730                        ((ComboBoxItem) comboBox.Items.GetItemAt(0)).IsSelected = true;
731                    }
732
733                    element = comboBox;
734                    break;
735
736                case "checkBox":
737                    CheckBox checkBox = new CheckBox();
738                    checkBox.Tag = input;
739                    checkBox.Style = inputFieldStyle;
740
741                    var contents = FindElementsInElement(input, "content");
742                    SetTextFromXElement(contents.First(), delegate(XElement el)
743                                                   {
744                                                       if (!string.IsNullOrEmpty(el.Value))
745                                                           checkBox.Content = el.Value.Trim();
746                                                   });
747
748                    if (key != null && pluginPropertyValue != null)
749                    {
750                        string value = (string)pluginPropertyValue.Value;
751                        if (value.ToLower() == "true")
752                            checkBox.IsChecked = true;
753                        else
754                            checkBox.IsChecked = false;
755                    }
756                    else if (input.Attribute("defaultValue") != null)
757                    {
758                        string value = input.Attribute("defaultValue").Value;
759                        if (value.ToLower() == "true")
760                            checkBox.IsChecked = true;
761                        else
762                            checkBox.IsChecked = false;
763                    }
764
765                    element = checkBox;
766                    break;
767
768                case "outputBox":
769                    if (isInput)
770                        break;
771
772                    var outputBox = new TextBox();
773                    outputBox.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
774                    outputBox.Tag = input;
775                    outputBox.AcceptsReturn = true;
776                    outputBox.TextWrapping = TextWrapping.Wrap;
777                    if (input.Attribute("visibleLines") != null)
778                    {
779                        int visibleLines;
780                        if (Int32.TryParse(input.Attribute("visibleLines").Value.Trim(), out visibleLines))
781                        {
782                            outputBox.MinLines = visibleLines;
783                            outputBox.MaxLines = visibleLines;
784                        }
785                    }
786                    outputBox.Style = inputFieldStyle;
787
788                    if (input.Attribute("regex") != null)
789                    {
790                        var regex = new Regex(input.Attribute("regex").Value, RegexOptions.Compiled);
791
792                        outputBox.TextChanged += delegate
793                        {
794                            CheckRegex(outputBox, regex);
795                        };
796                    }
797                   
798                    outputBox.IsReadOnly = true;
799                    currentOutputBoxes.Add(outputBox);
800
801                    xel = input.Element("storage");
802                    if (xel != null)
803                    {
804                        var storageContainer = new StorageContainer(ShowStorageOverlay);
805                        bool showLoadAddButtons;
806                        bool showStorageButton;
807                        GetStorageAttributes(xel, out showStorageButton, out showLoadAddButtons);
808                        storageContainer.AddContent(outputBox, xel.Attribute("key").Value, showStorageButton, false, showLoadAddButtons);
809                        storageContainer.SetValueMethod(null);
810                        storageContainer.GetValueMethod(() => outputBox.Text);
811                        element = storageContainer;
812                    }
813                    else
814                    {
815                        element = outputBox;
816                    }
817                    break;
818
819                case "progressBar":
820                    if (isInput)
821                        break;
822
823                    var progressBar = new ProgressBar();
824                    progressBar.Tag = input;
825                    progressBar.Style = inputFieldStyle;
826                    progressBar.Height = 30;
827                    currentProgressBars.Add(progressBar);
828                    element = progressBar;
829                    break;
830
831                case "keyTextBox":
832                    var keyTextBox = new KeyTextBox.KeyTextBox();
833                    var keyManager = new SimpleKeyManager(input.Attribute("format").Value);
834                    keyTextBox.KeyManager = keyManager;
835                    if (key != null && pluginPropertyValue != null)
836                    {
837                        keyManager.SetKey((string) pluginPropertyValue.Value);
838                    }
839                    else if (input.Attribute("defaultkey") != null)
840                    {
841                        keyManager.SetKey(input.Attribute("defaultkey").Value);
842                    }
843                    keyTextBox.Tag = input;
844                    keyTextBox.Style = inputFieldStyle;
845
846                    xel = input.Element("storage");
847                    if (xel != null)
848                    {
849                        var storageContainer = new StorageContainer(ShowStorageOverlay);
850                        bool showLoadAddButtons;
851                        bool showStorageButton;
852                        GetStorageAttributes(xel, out showStorageButton, out showLoadAddButtons);
853                        storageContainer.AddContent(keyTextBox, xel.Attribute("key").Value, showStorageButton, showLoadAddButtons, showLoadAddButtons);
854                        storageContainer.SetValueMethod(delegate(string s) { keyTextBox.CurrentKey = s; });
855                        storageContainer.GetValueMethod(() => keyTextBox.CurrentKey);
856                        element = storageContainer;
857                    }
858                    else
859                    {
860                        element = keyTextBox;
861                    }
862                    break;
863
864                case "presentation":
865                    if (isInput)
866                        break;
867
868                    var cc = new ContentControl();
869
870                    //Set height:
871                    if (input.Attribute("height") != null)
872                    {
873                        string height = input.Attribute("height").Value.Trim();
874                        if (height.EndsWith("%"))
875                        {
876                            double percentage;
877                            if (Double.TryParse(height.Substring(0, height.Length - 1), out percentage))
878                            {
879                                percentage /= 100;
880                                Binding binding = new Binding("ActualHeight");
881                                binding.Source = inputStack;
882                                binding.Converter = widthConverter;
883                                binding.ConverterParameter = percentage;
884                                cc.SetBinding(FrameworkElement.HeightProperty, binding);
885                            }
886                        }
887                        else
888                        {
889                            double heightValue;
890                            if (Double.TryParse(height, out heightValue))
891                            {
892                                cc.Height = heightValue;
893                            }
894                        }
895                    }
896
897                    cc.Style = inputFieldStyle;
898                    cc.Tag = input;
899
900                    currentPresentations.Add(cc);
901                    element = cc;
902                    break;
903            }
904
905            return element;
906        }
907
908        private static void GetStorageAttributes(XElement xel, out bool showStorageButton, out bool showLoadAddButtons)
909        {
910            showStorageButton = false;
911            if (xel.Attribute("showStorageButton") != null)
912            {
913                showStorageButton = xel.Attribute("showStorageButton").Value == "true";
914            }
915            showLoadAddButtons = false;
916            if (xel.Attribute("showLoadAddButtons") != null)
917            {
918                showLoadAddButtons = xel.Attribute("showLoadAddButtons").Value == "true";
919            }
920        }
921
922        private void ShowStorageOverlay(StorageControl control)
923        {
924            control.CloseEvent += delegate { Overlay.Visibility = Visibility.Collapsed; };
925            StorageGrid.Children.Clear();
926            StorageGrid.Children.Add(control);
927            Overlay.Visibility = Visibility.Visible;
928        }
929
930        /// <summary>
931        /// If a combobox on an input page is changed, this method checks if some conditional texts on the same page have to be changed.
932        /// </summary>
933        private void InputComboBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
934        {
935            var comboBox = (ComboBox) sender;
936            var ele = (XElement) comboBox.Tag;
937
938            var pluginSetters = (from i in ele.Elements("item")
939                                 group i by i.Attribute("lang").Value
940                                 into ig
941                                 select ig.ElementAt(comboBox.SelectedIndex)).SelectMany(x => x.Elements("pluginSetter")).ToList();
942
943            string pluginName = null;
944            string propertyName = null;
945            if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
946            {
947                pluginName = ele.Attribute("plugin").Value;
948                propertyName = ele.Attribute("property").Value;
949            }
950
951            foreach (var conditionalTextSetter in conditionalTextSetters)
952            {
953                foreach (var condition in conditionalTextSetter.XElement.Elements("condition"))
954                {
955                    var condPlugin = condition.Attribute("plugin").Value;
956                    var condProperty = condition.Attribute("property").Value;
957                    int condValue;
958                    if (!int.TryParse(condition.Attribute("value").Value, out condValue))
959                    {
960                        continue;
961                    }
962
963                    if (!string.IsNullOrEmpty(pluginName) && !string.IsNullOrEmpty(propertyName))
964                    {
965                        if (condPlugin == pluginName && condProperty == propertyName)
966                        {
967                            if (condValue == comboBox.SelectedIndex)
968                            {
969                                conditionalTextSetter.TextSetter(condition);
970                            }
971                        }
972                    }
973
974                    foreach (var pluginSetter in pluginSetters)
975                    {
976                        if (condPlugin == pluginSetter.Attribute("plugin").Value && condProperty == pluginSetter.Attribute("property").Value)
977                        {
978                            int setterValue;
979                            if (int.TryParse(pluginSetter.Value, out setterValue))
980                            {
981                                if (condValue == setterValue)
982                                {
983                                    conditionalTextSetter.TextSetter(condition);
984                                }
985                            }
986                        }
987                    }
988                }
989            }
990        }
991
992        private PluginPropertyValue GetPropertyValue(string key, XElement path)
993        {
994            if (key != null && propertyValueDict.ContainsKey(key))
995            {
996                foreach (var pv in propertyValueDict[key])
997                {
998                    if (IsSamePath(pv.Path, path))
999                    {
1000                        return pv;
1001                    }
1002                }
1003            }
1004            return null;
1005        }
1006
1007        private bool IsSamePath(XElement path, XElement path2)
1008        {
1009            if (path == path2 || path.Descendants().Contains(path2) || path2.Descendants().Contains(path))
1010            {
1011                return true;
1012            }
1013            return false;
1014        }
1015
1016        private string GetElementPluginPropertyKey(XElement element)
1017        {
1018            string key = null;
1019            if (element.Attribute("plugin") != null && element.Attribute("property") != null)
1020            {
1021                var plugin = element.Attribute("plugin").Value;
1022                var property = element.Attribute("property").Value;
1023                key = string.Format("{0}.{1}", plugin, property);
1024            }
1025            return key;
1026        }
1027
1028        private void CreateHistory()
1029        {
1030            StackPanel historyStack = new StackPanel();
1031            historyStack.Orientation = Orientation.Horizontal;
1032
1033            foreach (var page in currentHistory)
1034            {
1035                var p = new ContentControl();
1036                p.Focusable = false;
1037                var bg = selectionBrush.Clone();
1038                bg.Opacity = 1 - (historyStack.Children.Count / (double)currentHistory.Count);
1039                var sp = new StackPanel { Orientation = Orientation.Horizontal, Background = bg };
1040                p.Content = sp;
1041                p.Tag = page.tag;
1042                p.MouseDoubleClick += new MouseButtonEventHandler(page_MouseDoubleClick);
1043
1044                Polygon triangle = new Polygon();
1045                triangle.Points = new PointCollection();
1046                triangle.Points.Add(new Point(0, 0));
1047                triangle.Points.Add(new Point(0, 10));
1048                triangle.Points.Add(new Point(10, 5));
1049                triangle.Fill = bg;
1050                triangle.Stretch = Stretch.Uniform;
1051                triangle.Width = 32;
1052                sp.Children.Add(triangle); 
1053                if (page.image != null && FindResource(page.image) != null)
1054                {
1055                    var im = new Image { Source = (ImageSource)FindResource(page.image), Width = 32 };
1056                    sp.Children.Add(im);
1057                }
1058                var nameLabel = new Label { Content = page.name };
1059                sp.Children.Add(nameLabel);
1060                p.ToolTip = page.headline;
1061                var translateTranform = new TranslateTransform();
1062                triangle.RenderTransform = translateTranform;
1063                Binding binding = new Binding("ActualWidth");
1064                binding.Source = p;
1065                binding.Converter = historyTranslateTransformConverter;
1066                BindingOperations.SetBinding(translateTranform, TranslateTransform.XProperty, binding);
1067
1068                historyStack.Children.Add(p);
1069            }
1070
1071            history.Content = historyStack;
1072            history.ScrollToRightEnd();
1073        }
1074
1075        void page_MouseDoubleClick(object sender, MouseButtonEventArgs e)
1076        {
1077            SwitchButtonWhenNecessary();
1078            canStopOrExecute = false;
1079
1080            var cc = (ContentControl)sender;
1081            var hs = (StackPanel)history.Content;
1082            int i = hs.Children.IndexOf(cc);
1083            history.Content = null;
1084
1085            while (currentHistory.Count > i+1)
1086            {
1087                currentHistory.RemoveAt(currentHistory.Count - 1);
1088            }
1089
1090            CreateHistory();
1091
1092            XElement parent = (XElement)cc.Tag;
1093
1094            if (parent == null)
1095                parent = wizardConfigXML;
1096
1097            SetupPage(parent);
1098        }
1099
1100        private void CheckRegex(TextBox textBox, Regex regex)
1101        {
1102            var match = regex.Match(textBox.Text);
1103            if (!match.Success || match.Index != 0 || match.Length != textBox.Text.Length)
1104            {
1105                textBox.Style = (Style) FindResource("TextInputInvalid");
1106                GuiLogMessage(string.Format("Content of textbox does not fit regular expression {0}.", regex.ToString()), NotificationLevel.Error);
1107                boxesWithWrongContent.Add(textBox);
1108                nextButton.IsEnabled = false;
1109            }
1110            else
1111            {
1112                textBox.Style = null;
1113                boxesWithWrongContent.Remove(textBox);
1114                if (boxesWithWrongContent.Count == 0)
1115                    nextButton.IsEnabled = true;
1116            }
1117        }
1118
1119        private string GetElementID(XElement element)
1120        {
1121            if (element != null && element.Parent != null)
1122            {
1123                return GetElementID(element.Parent) + "[" + element.Parent.Nodes().ToList().IndexOf(element) + "]." + element.Name;
1124            }
1125            else
1126                return "";
1127        }
1128
1129        private bool LoadSample(string file, string title, bool openTab, XElement element)
1130        {
1131            try
1132            {
1133                _title = title;
1134                file = Path.Combine(SamplesDir, file);
1135
1136                var persistance = new ModelPersistance();
1137                persistance.OnGuiLogNotificationOccured += delegate(IPlugin sender, GuiLogEventArgs args)
1138                                                        {
1139                                                            OnGuiLogNotificationOccured(sender, args);
1140                                                        };
1141                var model = persistance.loadModel(file,false);
1142                model.OnGuiLogNotificationOccured += delegate(IPlugin sender, GuiLogEventArgs args)
1143                                                         {
1144                                                             OnGuiLogNotificationOccured(sender, args);
1145                                                         };
1146
1147                foreach (PluginModel pluginModel in model.GetAllPluginModels())
1148                {
1149                    pluginModel.Plugin.Initialize();
1150                }
1151
1152                if (!openTab)
1153                {
1154                    CreateProjectButton.Tag = element;
1155                    RegisterEventsForLoadedSample(model);
1156                }
1157
1158                FillDataToModel(model, element);
1159
1160                //load sample:
1161                if (openTab)
1162                {
1163                    ImageSource ims = null;
1164                    currentManager = (WorkspaceManager.WorkspaceManagerClass) OnOpenEditor(typeof (WorkspaceManager.WorkspaceManagerClass), null);
1165                    currentManager.Open(model);
1166                    persistance.HandleTemplateReplacement(file, model);
1167                    if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_RunTemplate)
1168                    {
1169                        currentManager.OnFileLoaded += NewEditorOnFileLoaded;
1170                    }
1171                   
1172                    if (element.Attribute("image") != null)
1173                    {
1174                        ims = (ImageSource)TryFindResource(element.Attribute("image").Value);
1175                    }
1176                    currentManager.Presentation.ToolTip = _title;
1177                    var tooltip = new Span();
1178                    tooltip.Inlines.Add(new Run(_title));
1179                    OnOpenTab(currentManager, new TabInfo() { Title = _title,  Tooltip = tooltip, Icon = ims }, null);
1180                }
1181                else
1182                {
1183                    currentManager = new WorkspaceManager.WorkspaceManagerClass();
1184                    currentManager.Open(model);
1185                    canStopOrExecute = true;
1186                    currentManager.OnFileLoaded += OnFileLoaded;
1187                }
1188
1189                _recentFileList.AddRecentFile(file);
1190            }
1191            catch(Exception ex)
1192            {
1193                GuiLogMessage(string.Format("Error loading sample {0}: {1}", file,ex.Message),NotificationLevel.Error);
1194                return false;
1195            }
1196            return true;
1197        }
1198
1199        private void NewEditorOnFileLoaded(IEditor editor, string filename)
1200        {
1201            if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_RunTemplate && currentManager.CanExecute)
1202                currentManager.Execute();
1203            currentManager.OnFileLoaded -= NewEditorOnFileLoaded;
1204            OnOpenTab(currentManager, new TabInfo() { Title = _title }, null);
1205        }
1206
1207        private void OnFileLoaded(IEditor editor, string filename)
1208        {
1209            currentManager.Execute();
1210            currentManager.OnFileLoaded -= OnFileLoaded;
1211        }
1212
1213        private void FillDataToModel(WorkspaceModel model, XElement element)
1214        {
1215            //Fill in all data from wizard to sample:
1216            foreach (var c in propertyValueDict)
1217            {
1218                foreach (var ppv in c.Value)
1219                {
1220                    if (IsSamePath(element, ppv.Path))
1221                    {
1222                        try
1223                        {
1224                            var plugins = ppv.PluginName.Split(';');
1225                            foreach (var plugin in model.GetAllPluginModels().Where(x => plugins.Contains(x.GetName())))
1226                            {
1227                                if (SetPluginProperty(ppv, plugin))   
1228                                    plugin.Plugin.Initialize();
1229                                else
1230                                    GuiLogMessage(string.Format("Failed settings plugin property {0}.{1} to \"{2}\"!", plugin.GetName(), ppv.PropertyName, ppv.Value), NotificationLevel.Error);
1231                            }
1232                        }
1233                        catch (Exception)
1234                        {
1235                            GuiLogMessage(string.Format("Failed settings plugin property {0}.{1} to \"{2}\"!", ppv.PluginName, ppv.PropertyName, ppv.Value), NotificationLevel.Error);
1236                        }
1237                    }
1238                }
1239            }
1240        }
1241
1242        internal static bool SetPluginProperty(PluginPropertyValue ppv, PluginModel plugin)
1243        {
1244            var settings = plugin.Plugin.Settings;
1245
1246            object propertyObject = null;
1247            PropertyInfo property;
1248            if (!ppv.PropertyName.StartsWith(".") && plugin.Plugin.GetType().GetProperty(ppv.PropertyName) != null)
1249            {
1250                property = plugin.Plugin.GetType().GetProperty(ppv.PropertyName);
1251                propertyObject = plugin.Plugin;
1252            }
1253            else
1254            {
1255                if (ppv.PropertyName.StartsWith("."))
1256                {
1257                    property = settings.GetType().GetProperty(ppv.PropertyName.Substring(1, ppv.PropertyName.Length - 1));
1258                    propertyObject = settings;
1259                }
1260                else
1261                {
1262                    property = settings.GetType().GetProperty(ppv.PropertyName);
1263                    propertyObject = settings;
1264                }
1265            }
1266           
1267            if (property != null)
1268            {
1269                if (ppv.Value is string)
1270                    SetPropertyToString(ppv, propertyObject, property);
1271                else if (ppv.Value is int)
1272                    property.SetValue(propertyObject, (int)ppv.Value, null);
1273                else if (ppv.Value is bool)
1274                    property.SetValue(propertyObject, (bool)ppv.Value, null);
1275                return true;
1276            }
1277            else
1278            {
1279                //if (ppv.Value is object)
1280                //{
1281                //    return true;
1282                //}
1283                return false;
1284            }
1285        }
1286
1287        private static void SetPropertyToString(PluginPropertyValue ppv, object settings, PropertyInfo property)
1288        {
1289            if (property.PropertyType == typeof(string))
1290            {
1291                property.SetValue(settings, (string) ppv.Value, null);
1292            }
1293            else if (property.PropertyType == typeof(int))
1294            {
1295                property.SetValue(settings, Int32.Parse((string)ppv.Value), null);
1296            }
1297            else if (property.PropertyType == typeof(double))
1298            {
1299                property.SetValue(settings, Double.Parse((string)ppv.Value), null);
1300            }
1301        }
1302
1303        private void RegisterEventsForLoadedSample(WorkspaceModel model)
1304        {
1305            //check if the addressed plugins are present in the template
1306            var referencedPlugins = currentInputBoxes.Cast<Control>().Concat<Control>(currentOutputBoxes).Concat<Control>(currentPresentations).Concat<Control>(currentProgressBars);
1307            foreach (var plugin in referencedPlugins)
1308            {
1309                XElement ele = (XElement)plugin.Tag;
1310                var pluginName = ele.Attribute("plugin").Value;
1311                if (pluginName != null)
1312                {
1313                    int n = model.GetAllPluginModels().Where(x => x.GetName() == pluginName).Count();
1314                    if (n == 0)
1315                    {
1316                        GuiLogMessage("Could not find plugin '"+pluginName+"'.", NotificationLevel.Warning);
1317                    }
1318                    else if (n > 1)
1319                    {
1320                        GuiLogMessage("Found more than one plugin '" + pluginName + "'.", NotificationLevel.Warning);
1321                    }
1322                }
1323            }
1324
1325            //Register events for output boxes:
1326            foreach (var outputBox in currentOutputBoxes)
1327            {
1328                XElement ele = (XElement)outputBox.Tag;
1329                var pluginName = ele.Attribute("plugin").Value;
1330                var propertyName = ele.Attribute("property").Value;
1331                if (pluginName != null && propertyName != null)
1332                {
1333                    var plugin = model.GetAllPluginModels().Where(x => x.GetName() == pluginName).First().Plugin;
1334                    var settings = plugin.Settings;
1335                    object theObject = null;
1336
1337                    var property = plugin.GetType().GetProperty(propertyName);
1338                    EventInfo propertyChangedEvent = null;
1339                    if (property != null)
1340                    {
1341                        propertyChangedEvent = plugin.GetType().GetEvent("PropertyChanged");
1342                        theObject = plugin;
1343                    }
1344                    else    //Use property from settings
1345                    {
1346                        property = settings.GetType().GetProperty(propertyName);
1347                        propertyChangedEvent = settings.GetType().GetEvent("PropertyChanged");
1348                        theObject = settings;
1349                    }
1350
1351                    if (property != null && propertyChangedEvent != null)
1352                    {
1353                        TextBox box = outputBox;
1354                        propertyChangedEvent.AddEventHandler(theObject, (PropertyChangedEventHandler)delegate(Object sender, PropertyChangedEventArgs e)
1355                                                                                                         {
1356                                                                                                             if (e.PropertyName == propertyName)
1357                                                                                                             {
1358                                                                                                                 UpdateOutputBox(box, property, theObject);
1359                                                                                                             }
1360                                                                                                         });
1361                    }
1362                }
1363            }
1364
1365            //Register events for progress bars:
1366            foreach (var progressBar in currentProgressBars)
1367            {
1368                XElement ele = (XElement) progressBar.Tag;
1369                var pluginName = ele.Attribute("plugin").Value;
1370                var plugin = model.GetAllPluginModels().Where(x => x.GetName() == pluginName).First().Plugin;
1371                ProgressBar bar = progressBar;
1372                plugin.OnPluginProgressChanged += delegate(IPlugin sender, PluginProgressEventArgs args)
1373                                                      {
1374                                                          Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1375                                                          {
1376                                                              bar.Maximum = args.Max;
1377                                                              bar.Value = args.Value;
1378                                                          }, null);
1379                                                      };
1380
1381            }
1382
1383            //fill presentations
1384            foreach (var presentation in currentPresentations)
1385            {
1386                var ele = (XElement)presentation.Tag;
1387                var pluginName = ele.Attribute("plugin").Value;
1388                if (!string.IsNullOrEmpty(pluginName))
1389                {
1390                    var plugin = model.GetAllPluginModels().Where(x => x.GetName() == pluginName).First().Plugin;
1391                    if (presentation.Content == null)
1392                    {
1393                        presentation.Content = plugin.Presentation;
1394                        if (presentation.Content.GetType().GetProperty("Text") != null)
1395                        {
1396                            var defaultvalues = FindElementsInElement(ele, "defaultvalue");
1397                            ContentControl presentation1 = presentation;
1398                            SetTextFromXElement(defaultvalues.First(), delegate(XElement el)
1399                                                                           {
1400                                                                               if (!string.IsNullOrEmpty(el.Value))
1401                                                                               {
1402                                                                                   presentation1.Content.GetType().GetProperty("Text").SetValue(presentation1.Content, el.Value.Trim(), null);
1403                                                                               }
1404                                                                           });
1405                        }
1406                    }
1407                }
1408            }
1409
1410            //Register events for input boxes:
1411            foreach (var inputBox in currentInputBoxes)
1412            {
1413                XElement ele = (XElement)inputBox.Tag;
1414                var pluginName = ele.Attribute("plugin").Value;
1415                var propertyName = ele.Attribute("property").Value;
1416                if (pluginName != null && propertyName != null)
1417                {
1418                    var pluginNames = pluginName.Split(';');
1419                    foreach (var plugin in model.GetAllPluginModels().Where(x => pluginNames.Contains(x.GetName())))
1420                    {
1421                        var settings = plugin.Plugin.Settings;
1422                        object theObject = null;
1423
1424                        var property = plugin.Plugin.GetType().GetProperty(propertyName);
1425                        //we check, if the property name starts with a "."; thus, we assume we want to target the settings of a component
1426                        if (!propertyName.StartsWith(".") && property != null)
1427                        {
1428                            theObject = plugin.Plugin;
1429                        }
1430                        else    //Use property from settings
1431                        {
1432                            if (propertyName.StartsWith("."))
1433                            {
1434                                property = settings.GetType().GetProperty(propertyName.Substring(1, propertyName.Length - 1));
1435                                theObject = settings;
1436                            }
1437                            else
1438                            {
1439                                property = settings.GetType().GetProperty(propertyName);
1440                                theObject = settings;
1441                            }                           
1442                        }
1443
1444                        if (property != null)
1445                        {
1446                            TextBox box = inputBox;
1447                            PluginModel plugin1 = plugin;
1448                            inputBox.TextChanged += delegate
1449                                                        {
1450                                                            property.SetValue(settings, box.Text, null);
1451                                                            plugin1.Plugin.Initialize();
1452                                                        };
1453                        }
1454                    }
1455                }
1456            }
1457        }
1458
1459        private void UpdateOutputBox(TextBox box, PropertyInfo property, object theObject)
1460        {
1461            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1462                                                             {
1463                                                                 box.Text = (string) property.GetValue(theObject, null);
1464                                                             }, null);
1465        }
1466
1467        void rb_Checked(object sender, RoutedEventArgs e)
1468        {
1469            ResetSelectionDependencies();
1470            RadioButton b = (RadioButton)sender;
1471            b.Background = Brushes.LightSeaGreen;
1472            Border c = (Border)b.Content;
1473            c.BorderThickness = new Thickness(1, 1, 0, 1);
1474            c.Background = selectionBrush;
1475            XElement ele = (XElement)b.Tag;
1476            selectedCategories.Remove(GetElementID(ele));
1477            selectedCategories.Add(GetElementID(ele), true);
1478            XElement desc = FindElementsInElement(ele, "description").First();
1479            if (desc != null)
1480            {
1481                SetTextFromXElement(desc, el =>
1482                                              {
1483                                                  CategoryDescription.Inlines.Clear();
1484                                                  var inline = TrimInline(XMLHelper.ConvertFormattedXElement(el));
1485                                                  if (inline != null)
1486                                                  {
1487                                                      CategoryDescription.Inlines.Add(inline);
1488                                                  }
1489                                              });
1490            }
1491            nextButton.IsEnabled = true;
1492        }
1493
1494        /// <summary>
1495        /// Gets the elements text with respect to possible condition statements and calls the setter action delegate.
1496        /// </summary>
1497        private void SetTextFromXElement(XElement element, Action<XElement> textSetter)
1498        {
1499            if (element.Element("condition") != null)
1500            {
1501                conditionalTextSetters.Add(new ConditionalTextSetter() {TextSetter = textSetter, XElement = element});
1502                foreach (var condition in element.Elements("condition"))
1503                {
1504                    var key = GetElementPluginPropertyKey(condition);
1505                    if (propertyValueDict.ContainsKey(key))
1506                    {
1507                        foreach (var pair in propertyValueDict[key])
1508                        {
1509                            if (IsSamePath(pair.Path, element))
1510                            {
1511                                if (condition.Attribute("value").Value == pair.Value.ToString())
1512                                {
1513                                    textSetter(condition);
1514                                    return;
1515                                }
1516                            }
1517                        }
1518                    }
1519                }
1520                //if no condition holds, just set the content of the first one:
1521                textSetter(element.Element("condition"));
1522            }
1523            else
1524            {
1525                textSetter(element);
1526            }
1527        }
1528
1529        private void ResetSelectionDependencies()
1530        {
1531            for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
1532            {
1533                RadioButton b = (RadioButton)radioButtonStackPanel.Children[i];
1534                XElement ele = (XElement)b.Tag;
1535                selectedCategories.Remove(GetElementID(ele));
1536                selectedCategories.Add(GetElementID(ele), false);
1537                b.Background = Brushes.Transparent;
1538                Border c = (Border)b.Content;
1539                c.BorderThickness = new Thickness(0);
1540                c.Background = Brushes.Transparent;
1541            }
1542        }
1543
1544        //finds elements according to the current language
1545        private IEnumerable<XElement> FindElementsInElement(XElement element, string xname)
1546        {
1547            CultureInfo currentLang = CultureInfo.CurrentUICulture;
1548
1549            IEnumerable<XElement> allElements = element.Elements(xname);
1550            IEnumerable<XElement> foundElements = null;
1551
1552            if (allElements.Any())
1553            {
1554                foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TextInfo.CultureName select descln;
1555                if (!foundElements.Any())
1556                {
1557                    foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TwoLetterISOLanguageName select descln;
1558                    if (!foundElements.Any())
1559                        foundElements = from descln in allElements where descln.Attribute("lang").Value == defaultLang select descln;
1560                }
1561            }
1562
1563            if (foundElements == null || !foundElements.Any() || !allElements.Any())
1564            {
1565                if (!allElements.Any())
1566                {
1567                    List<XElement> fe = new List<XElement>();
1568                    fe.Add(new XElement("dummy"));
1569                    return fe;
1570                }
1571                else
1572                    return allElements;
1573            }
1574
1575            return foundElements;
1576        }
1577
1578        private void nextButton_Click(object sender, RoutedEventArgs e)
1579        {
1580            if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_ShowAnimations)
1581            {
1582                Storyboard mainGridStoryboardLeft = (Storyboard) FindResource("MainGridStoryboardNext1");
1583                mainGridStoryboardLeft.Begin();
1584            }
1585            else
1586            {
1587                SetNextContent(sender, e);
1588            }
1589        }
1590
1591        private void backButton_Click(object sender, RoutedEventArgs e)
1592        {
1593            canStopOrExecute = false;
1594            if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_ShowAnimations)
1595            {
1596                Storyboard mainGridStoryboardLeft = (Storyboard) FindResource("MainGridStoryboardBack1");
1597                mainGridStoryboardLeft.Begin();
1598            }
1599            else
1600            {
1601                SetLastContent(sender, e);
1602            }
1603        }
1604
1605        private void abortButton_Click(object sender, RoutedEventArgs e)
1606        {
1607            SwitchButtonWhenNecessary();
1608            canStopOrExecute = false;
1609
1610            foreach (RadioButton rb in radioButtonStackPanel.Children)
1611            {
1612                if (rb.IsChecked != null && (bool)rb.IsChecked)
1613                    rb.IsChecked = false;
1614            }
1615
1616            history.Content = null;
1617            currentHistory.Clear();
1618            AddToHistory(wizardConfigXML);
1619            propertyValueDict.Clear();
1620            ResetSelectionDependencies();
1621            radioButtonStackPanel.Children.Clear();
1622            selectedCategories.Clear();
1623            CategoryDescription.Text = "";
1624            SetupPage(wizardConfigXML);
1625        }
1626
1627        internal void StopCurrentWorkspaceManager()
1628        {
1629            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
1630            {
1631                if (currentManager != null && currentManager.CanStop)
1632                    currentManager.Stop();
1633            }, null);
1634        }
1635
1636        internal void ExecuteCurrentWorkspaceManager()
1637        {
1638            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1639            {
1640                if (currentManager != null && currentManager.CanExecute)
1641                    currentManager.Execute();
1642            }, null);
1643        }
1644
1645        internal bool WizardCanStop()
1646        {
1647            if (!canStopOrExecute || currentManager == null)
1648                return false;
1649            else
1650                return currentManager.CanStop;
1651        }
1652
1653        internal bool WizardCanExecute()
1654        {
1655            if (!canStopOrExecute || currentManager == null)
1656                return false;
1657            else
1658                return currentManager.CanExecute;
1659        }
1660
1661        private void SwitchButtonWhenNecessary()
1662        {
1663            if (inputPanel.Visibility == Visibility.Visible)
1664            {
1665                if (inputPanel.Tag != null && ((XElement)inputPanel.Tag).Name == "loadSample")
1666                    SwitchNextButtonContent();
1667            }
1668        }
1669
1670        private void SetNextContent(object sender, EventArgs e)
1671        {
1672            if (categoryGrid.Visibility == Visibility.Visible)
1673            {
1674                for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
1675                {
1676                    RadioButton b = (RadioButton) radioButtonStackPanel.Children[i];
1677                    if (b.IsChecked != null && (bool) b.IsChecked)
1678                    {
1679                        var ele = (XElement) b.Tag;
1680                        AddToHistory(ele);
1681                        SetupPage(ele);
1682                        break;
1683                    }
1684                }
1685            }
1686            else if (inputPanel.Visibility == Visibility.Visible)
1687            {
1688                var nextElement = (XElement) inputPanel.Tag;
1689                AddToHistory(nextElement);
1690                SetupPage(nextElement);
1691            }
1692
1693            if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_ShowAnimations)
1694            {
1695                Storyboard mainGridStoryboardLeft = (Storyboard) FindResource("MainGridStoryboardNext2");
1696                mainGridStoryboardLeft.Begin();
1697            }
1698        }
1699
1700        private void SaveContent()
1701        {
1702            if (inputPanel.Visibility == Visibility.Visible)
1703            {
1704                foreach (var child in inputStack.Children)
1705                {
1706                    SaveControlContent(child);
1707                }
1708            }
1709        }
1710
1711        private void AddToHistory(XElement ele)
1712        {
1713            try
1714            {
1715                var page = new PageInfo() { tag = ele };
1716                SetTextFromXElement(FindElementsInElement(ele, "name").First(), delegate(XElement el) { page.name = el.Value.Trim(); });
1717                SetTextFromXElement(FindElementsInElement(ele, "description").First(), delegate(XElement el) { page.description = el.Value.Trim(); });
1718                SetTextFromXElement(FindElementsInElement(ele, "headline").First(), delegate(XElement el) { page.headline = el.Value.Trim(); });
1719
1720                if (ele.Attribute("image") != null)
1721                {
1722                    page.image = ele.Attribute("image").Value;
1723                }
1724
1725                currentHistory.Add(page);
1726            }
1727            catch (Exception)
1728            {
1729                GuiLogMessage("Error adding page to history", NotificationLevel.Error);
1730            }
1731        }
1732
1733        private void SaveControlContent(object o)
1734        {
1735            var sp = (StackPanel)o;
1736
1737            foreach (var inp in sp.Children)
1738            {
1739                var input = inp;
1740                if (input is StorageContainer)
1741                {
1742                    input = ((StorageContainer)input).GetContent();
1743                }
1744
1745                if (input is TextBox || input is ComboBox || input is CheckBox || input is KeyTextBox.KeyTextBox)
1746                {
1747                    Control c = (Control)input;
1748                    XElement ele = (XElement)c.Tag;
1749                    if (ele.Name == "outputBox")
1750                        continue;
1751
1752                    var key = GetElementPluginPropertyKey(ele);
1753                    PluginPropertyValue newEntry = null;
1754                   
1755                    if (input is TextBox)
1756                    {
1757                        if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
1758                        {
1759                            TextBox textBox = (TextBox) input;
1760                            newEntry = new PluginPropertyValue()
1761                                           {
1762                                               PluginName = ele.Attribute("plugin").Value,
1763                                               PropertyName = ele.Attribute("property").Value,
1764                                               Value = textBox.Text,
1765                                               Path = ele.Parent
1766                                           };
1767                        }
1768                    }
1769                    else if (input is KeyTextBox.KeyTextBox)
1770                    {
1771                        if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
1772                        {
1773                            var keyTextBox = (KeyTextBox.KeyTextBox) input;
1774                            newEntry = new PluginPropertyValue()
1775                                           {
1776                                               PluginName = ele.Attribute("plugin").Value,
1777                                               PropertyName = ele.Attribute("property").Value,
1778                                               Value = keyTextBox.CurrentKey,
1779                                               Path = ele.Parent
1780                                           };
1781                        }
1782                    }
1783                    else if (input is ComboBox)
1784                    {
1785                        var comboBox = (ComboBox)input;
1786                        var pluginSetters = (from i in ele.Elements("item")
1787                                             group i by i.Attribute("lang").Value into ig
1788                                             select ig.ElementAt(comboBox.SelectedIndex)).SelectMany(x => x.Elements("pluginSetter"));
1789
1790                        foreach (var pluginSetter in pluginSetters)
1791                        {
1792                            int setterValue;
1793                            if (int.TryParse(pluginSetter.Value, out setterValue))
1794                            {
1795                                var pluginSetterKey = GetElementPluginPropertyKey(pluginSetter);
1796                                AddPluginPropertyEntry(new PluginPropertyValue()
1797                                                            {
1798                                                                PluginName = pluginSetter.Attribute("plugin").Value,
1799                                                                PropertyName = pluginSetter.Attribute("property").Value,
1800                                                                Value = setterValue,
1801                                                                Path = ele.Parent
1802                                                            }, pluginSetterKey, ele);
1803                            }
1804                        }
1805
1806                        if (key != null)
1807                        {
1808                            newEntry = new PluginPropertyValue()
1809                                            {
1810                                                PluginName = ele.Attribute("plugin").Value,
1811                                                PropertyName = ele.Attribute("property").Value,
1812                                                Value = comboBox.SelectedIndex,
1813                                                Path = ele.Parent
1814                                            };
1815                        }
1816                    }
1817                    else if (input is CheckBox)
1818                    {
1819                        if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
1820                        {
1821                            CheckBox checkBox = (CheckBox) input;
1822                            if (checkBox.IsChecked != null)
1823                            {
1824                                newEntry = new PluginPropertyValue()
1825                                               {
1826                                                   PluginName = ele.Attribute("plugin").Value,
1827                                                   PropertyName = ele.Attribute("property").Value,
1828                                                   Value = (bool) checkBox.IsChecked,
1829                                                   Path = ele.Parent
1830                                               };
1831                            }
1832                        }
1833                    }
1834
1835                    if (newEntry != null)
1836                    {
1837                        AddPluginPropertyEntry(newEntry, key, ele);
1838                    }
1839                }
1840                else if (input is StackPanel)
1841                {
1842                    SaveControlContent(input);
1843                }
1844            }
1845        }
1846
1847        private void AddPluginPropertyEntry(PluginPropertyValue newEntry, string key, XElement ele)
1848        {
1849            if (newEntry != null && key != null)
1850            {
1851                var pluginPropertyValue = GetPropertyValue(key, ele.Parent);
1852                if (pluginPropertyValue != null)
1853                {
1854                    pluginPropertyValue.Value = newEntry.Value;
1855                }
1856                else
1857                {
1858                    if (propertyValueDict.ContainsKey(key))
1859                    {
1860                        propertyValueDict[key].Add(newEntry);
1861                    }
1862                    else
1863                    {
1864                        propertyValueDict.Add(key, new List<PluginPropertyValue>() {newEntry});
1865                    }
1866                }
1867            }
1868        }
1869
1870        private void SetLastContent(object sender, EventArgs e)
1871        {
1872            canStopOrExecute = false;
1873
1874            XElement ele = null;
1875            if (categoryGrid.Visibility == Visibility.Visible && radioButtonStackPanel.Children.Count > 0)
1876            {
1877                RadioButton b = (RadioButton) radioButtonStackPanel.Children[0];
1878                ele = (XElement) b.Tag;
1879
1880                foreach (RadioButton rb in radioButtonStackPanel.Children)
1881                {
1882                    if (rb.IsChecked != null && (bool)rb.IsChecked)
1883                        rb.IsChecked = false;
1884                }
1885
1886            }
1887            else if (inputPanel.Visibility == Visibility.Visible)
1888            {
1889                ele = (XElement) inputPanel.Tag;
1890                if (ele != null && ((XElement)inputPanel.Tag).Name == "loadSample")
1891                    SwitchNextButtonContent();
1892            }
1893
1894            if (ele != null)
1895            {
1896                XElement grandParent = ele.Parent.Parent;
1897                if (grandParent == null)
1898                    grandParent = wizardConfigXML;
1899
1900                if (currentHistory.Count > 0)
1901                    currentHistory.RemoveAt(currentHistory.Count - 1);
1902
1903                SetupPage(grandParent);
1904            }
1905
1906            if (CrypTool.PluginBase.Properties.Settings.Default.Wizard_ShowAnimations)
1907            {
1908                Storyboard mainGridStoryboardLeft = (Storyboard) FindResource("MainGridStoryboardBack2");
1909                mainGridStoryboardLeft.Begin();
1910            }
1911        }
1912
1913        private void GuiLogMessage(string message, NotificationLevel loglevel)
1914        {
1915            if (OnGuiLogNotificationOccured != null)
1916                OnGuiLogNotificationOccured(null, new GuiLogEventArgs(message, null, loglevel));
1917        }
1918
1919        private void SwitchNextButtonContent()
1920        {
1921            var tmp = nextButton.Content;
1922            nextButton.Content = nextButton.Tag;
1923            nextButton.Tag = tmp;
1924        }
1925
1926        private void history_MouseMove(object sender, MouseEventArgs e)
1927        {
1928            if (e.LeftButton == MouseButtonState.Pressed)
1929            {
1930                Point dir = e.GetPosition(history);
1931                if (dir.X < history.ActualWidth / 2)
1932                    history.LineRight();
1933                else if (dir.X > history.ActualWidth / 2)
1934                    history.LineLeft();
1935            }
1936        }
1937
1938        private void KeyPressedDown(Key key)
1939        {
1940            switch (key)
1941            {
1942                case Key.Up:
1943                case Key.Down:
1944                    if (categoryGrid.Visibility == Visibility.Visible)
1945                    {
1946                        if (radioButtonStackPanel.Children.Count != 0)
1947                        {
1948                            int i = 0;
1949                            while (((RadioButton)radioButtonStackPanel.Children[i]).IsChecked == false)
1950                                i++;
1951                            ((RadioButton)radioButtonStackPanel.Children[i]).IsChecked = false;
1952
1953                            if (key == Key.Down)
1954                            {
1955                                if (radioButtonStackPanel.Children.Count > i + 1)
1956                                    ((RadioButton)radioButtonStackPanel.Children[i + 1]).IsChecked = true;
1957                                else
1958                                    ((RadioButton)radioButtonStackPanel.Children[0]).IsChecked = true;
1959                            }
1960                            else   //Up
1961                            {
1962                                if (i - 1 >= 0)
1963                                    ((RadioButton)radioButtonStackPanel.Children[i - 1]).IsChecked = true;
1964                                else
1965                                    ((RadioButton)radioButtonStackPanel.Children[radioButtonStackPanel.Children.Count - 1]).IsChecked = true;
1966                            }
1967                        }
1968                    }
1969                    break;
1970
1971                case Key.Left:
1972                    if (backButton.IsEnabled)
1973                        backButton_Click(null, null);
1974                    break;
1975
1976                case Key.Right:
1977                    if (nextButton.IsEnabled)
1978                        nextButton_Click(null, null);
1979                    break;
1980            }
1981        }
1982
1983        private void ScrollViewer_PreviewKeyDown(object sender, KeyEventArgs e)
1984        {
1985            if (OuterScrollViewer.IsKeyboardFocused || descScroll.IsKeyboardFocused || inputPanel.IsKeyboardFocused || history.IsKeyboardFocused)
1986            {
1987                KeyPressedDown(e.Key);
1988                e.Handled = true;
1989            }
1990        }
1991
1992        private void CreateProjectButton_Click(object sender, RoutedEventArgs e)
1993        {
1994            SaveControlContent(inputStack);
1995            var element = (XElement)CreateProjectButton.Tag;
1996            if ((element == null) || !LoadSample(element.Attribute("file").Value, Properties.Resources.LoadedSampleTitle, true, element))
1997            {
1998                ErrorLabel.Visibility = Visibility.Visible;
1999            }
2000        }
2001
2002        private void CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
2003        {
2004            if (CategoryDescription.Text != null)
2005                Clipboard.SetText(CategoryDescription.Text);
2006        }
2007
2008        private void CommandBinding_CanExecute(object sender, CanExecuteRoutedEventArgs e)
2009        {
2010            e.CanExecute = true;
2011        }
2012
2013        private void EventSetter_OnHandler(object sender, RoutedEventArgs e)
2014        {
2015            if (e.Source is RadioButton)
2016            {
2017                RadioButton rb = (RadioButton) e.Source;
2018                if (rb.IsChecked.HasValue && rb.IsChecked.Value)
2019                {
2020                    Storyboard sb = (Storyboard) Resources["NextButtonAttentionAnimation"];
2021                    sb.Begin();
2022                }
2023            }
2024        }
2025
2026        private void nextButton_IsEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
2027        {
2028            if (e.NewValue != e.OldValue)
2029            {
2030                SwitchNextButtonContent();
2031            }
2032        }
2033    }
2034
2035    internal class PluginPropertyValue
2036    {
2037        public string PluginName;
2038        public string PropertyName;
2039        public object Value;
2040        public XElement Path;
2041    }
2042}
Note: See TracBrowser for help on using the repository browser.