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

Last change on this file since 2638 was 2638, checked in by sauer, 11 years ago

Wizard:

  • result output
  • history bug fixes
File size: 46.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Collections.ObjectModel;
4using System.Collections.Specialized;
5using System.ComponentModel;
6using System.Linq;
7using System.Text;
8using System.Text.RegularExpressions;
9using System.Windows;
10using System.Windows.Controls;
11using System.Windows.Data;
12using System.Windows.Documents;
13using System.Windows.Input;
14using System.Windows.Media;
15using System.Windows.Media.Animation;
16using System.Windows.Media.Imaging;
17using System.Windows.Navigation;
18using System.Windows.Shapes;
19using System.Xml.Linq;
20using System.IO;
21using System.Reflection;
22using System.Windows.Threading;
23using System.Threading;
24using System.Collections;
25using System.Globalization;
26using Cryptool.PluginBase;
27using WorkspaceManager.Model;
28
29namespace Wizard
30{
31    /// <summary>
32    /// Interaction logic for WizardControl.xaml
33    /// </summary>
34    [Cryptool.PluginBase.Attributes.Localization("Wizard.Properties.Resources")]
35    public partial class WizardControl : UserControl
36    {
37        private class PageInfo
38        {
39            public string name;
40            public string description;
41            public string image;
42            public XElement tag;
43        }
44
45        ObservableCollection<PageInfo> currentHistory = new ObservableCollection<PageInfo>();
46        private Dictionary<string, bool> selectedCategories = new Dictionary<string, bool>();
47        private SolidColorBrush selectionBrush = new SolidColorBrush();
48        private const string configXMLPath = "Wizard.Config.wizard.config.start.xml";
49        private const string defaultLang = "en";
50        private XElement wizardConfigXML;
51        private Dictionary<string, PluginPropertyValue> propertyValueDict = new Dictionary<string, PluginPropertyValue>();
52        private HashSet<TextBox> boxesWithWrongContent = new HashSet<TextBox>();
53        private HistoryTranslateTransformConverter historyTranslateTransformConverter = new HistoryTranslateTransformConverter();
54        private List<TextBox> currentOutputBoxes = new List<TextBox>();
55        private List<TextBox> currentInputBoxes = new List<TextBox>();
56
57        internal event OpenTabHandler OnOpenTab;
58        internal event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
59
60        internal string SamplesDir { set; private get; }
61
62        public WizardControl()
63        {
64            try
65            {
66                // DEBUG HELP string[] names = this.GetType().Assembly.GetManifestResourceNames();
67
68                Stream fileStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(configXMLPath);
69                XElement xml = XElement.Load(fileStream);
70                GenerateXML(xml);
71            }
72            catch (Exception)
73            {
74               
75            }
76
77            InitializeComponent();
78
79            currentHistory.CollectionChanged += delegate
80                                                    {
81                                                        CreateHistory();
82                                                    };
83
84            selectionBrush.Color = Color.FromArgb(255, 200, 220, 245);
85            SetupPage(wizardConfigXML);
86            AddToHistory(wizardConfigXML);
87        }
88
89        // generate the full XML tree for the wizard (recursive)
90        private void GenerateXML(XElement xml)
91        {
92            try
93            {
94                //find all nested subcategories and add them to the tree
95                IEnumerable<XElement> categories = xml.Elements("category");
96                if (categories.Any())
97                {
98                    foreach (XElement cat in categories)
99                    {
100                        IEnumerable<XElement> files = cat.Elements("file");
101                        if (files.Any())
102                        {
103                            foreach (XElement element in files)
104                            {
105                                XAttribute att = element.Attribute("resource");
106                                if (att != null)
107                                {
108                                    string path = att.Value;
109                                    Stream fileStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path);
110                                    XElement sub = XElement.Load(fileStream);
111                                    GenerateXML(sub);
112                                    IEnumerable<XElement> elems = sub.Elements();
113                                    if (elems.Any())
114                                    {
115                                        foreach (XElement ele in elems)
116                                        {
117                                            cat.Add(ele);
118                                        }
119                                    }
120                                }
121                            }
122                        }
123                    }
124                }
125
126                wizardConfigXML = xml;
127
128            }
129            catch (Exception)
130            {
131               
132            }
133        }
134
135        #region WidthConverter
136
137        [ValueConversion(typeof(Double), typeof(Double))]
138        private class WidthConverter : IValueConverter
139        {
140            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
141            {
142                return (double)value * (double)parameter;
143            }
144
145            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
146            {
147                throw new NotImplementedException();
148            }
149        }
150
151        private WidthConverter widthConverter = new WidthConverter();
152
153        #endregion
154
155        #region HistoryTranslateTransformConverter
156
157        [ValueConversion(typeof(double), typeof(double))]
158        class HistoryTranslateTransformConverter : IValueConverter
159        {
160            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
161            {
162                return (double)value - 2;
163            }
164
165            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
166            {
167                throw new NotImplementedException();
168            }
169        }
170
171        #endregion
172
173        private void SetupPage(XElement element)
174        {
175            nextButton.IsEnabled = true;
176
177            currentOutputBoxes.Clear();
178            currentInputBoxes.Clear();
179            SaveContent();
180            boxesWithWrongContent.Clear();
181
182            if ((element.Name == "loadSample") && (element.Attribute("file") != null) && (element.Attribute("title") != null))
183            {
184                LoadSample(element.Attribute("file").Value, element.Attribute("title").Value, true);
185                abortButton_Click(null, null);
186                return;
187            }
188
189            XElement parent = element.Parent;
190            if (parent == null)
191            {
192                backButton.IsEnabled = false;
193                abortButton.IsEnabled = false;
194            }
195            else
196            {
197                backButton.IsEnabled = true;
198                abortButton.IsEnabled = true;
199            }
200
201            //nextButton.IsEnabled = false;
202
203            //set headline
204            XElement headline = FindElementsInElement(element, "headline").First();
205            if (headline != null)
206                taskHeader.Content = headline.Value;
207
208            //set description label
209            XElement desc = FindElementsInElement(element, "desc").First();
210            if (desc != null)
211                descHeader.Content = desc.Value;
212
213
214            if (element.Name == "input" || element.Name == "sampleViewer")
215            {
216                categoryGrid.Visibility = Visibility.Hidden;
217                inputPanel.Visibility = Visibility.Visible;
218
219                var inputs = from el in element.Elements()
220                             where el.Name == "inputBox" || el.Name == "comboBox" || el.Name == "checkBox" || el.Name == "outputBox"
221                             select el;
222
223                inputStack.Children.Clear();
224               
225                var allNexts = (from el in element.Elements()
226                                 where el.Name == "input" || el.Name == "category" || el.Name == "loadSample" || el.Name == "sampleViewer"
227                                 select el);
228                if (allNexts.Count() > 0)
229                {
230                    inputPanel.Tag = allNexts.First();
231                    if (allNexts.First().Name == "loadSample")
232                        SwitchNextButtonContent();
233                }
234                else
235                {
236                    var dummy = new XElement("loadSample");
237                    element.Add(dummy);
238                    inputPanel.Tag = dummy;
239                    SwitchNextButtonContent();
240                }
241
242                FillInputStack(inputs, element.Name.ToString(), (element.Name == "input"));
243
244                if (element.Name == "sampleViewer" && (element.Attribute("file") != null) && (element.Attribute("title") != null))
245                {
246                    nextButton.IsEnabled = false;
247                    LoadSample(element.Attribute("file").Value, element.Attribute("title").Value, false);
248                }
249
250                string id = GetElementID((XElement)inputPanel.Tag);
251
252            }
253            else if (element.Name == "category")
254            {
255                categoryGrid.Visibility = Visibility.Visible;
256                inputPanel.Visibility = Visibility.Hidden;
257               
258                radioButtonStackPanel.Children.Clear();
259
260                //generate radio buttons
261                var options = from el in element.Elements()
262                              where el.Name == "category" || el.Name == "input" || el.Name == "loadSample"
263                              select el;
264
265                if (options.Any())
266                {
267                    bool isSelected = false;
268
269                    foreach (XElement ele in options)
270                    {
271                        Border border = new Border();
272                        Label l = new Label();
273                        Image i = new Image();
274                        StackPanel sp = new StackPanel();
275
276                        border.Child = sp;
277                        border.VerticalAlignment = VerticalAlignment.Stretch;
278                        border.CornerRadius = new CornerRadius(5, 0, 0, 5);
279                        border.BorderBrush = Brushes.LightSeaGreen;
280
281                        l.Height = 30;
282                        l.HorizontalAlignment = HorizontalAlignment.Stretch;
283                        XElement label = FindElementsInElement(ele, "name").First();
284                        if (label != null)
285                            l.Content = label.Value;
286
287                        i.Width = 26;
288                        string image = ele.Attribute("image").Value;
289                        if (image != null)
290                        {
291                            ImageSource ims = (ImageSource) TryFindResource(image);
292                            if (ims != null)
293                            {
294                                i.Source = ims;
295                                sp.Children.Add(i);
296                            }
297                        }
298
299                        sp.VerticalAlignment = VerticalAlignment.Stretch;
300                        sp.HorizontalAlignment = HorizontalAlignment.Stretch;
301                        sp.Orientation = Orientation.Horizontal;
302                        sp.Children.Add(l);
303
304                        RadioButton rb = new RadioButton();
305                        string id = GetElementID(ele);
306                        rb.Checked += rb_Checked;
307                        rb.HorizontalAlignment = HorizontalAlignment.Stretch;
308                        rb.VerticalAlignment = VerticalAlignment.Stretch;
309                        rb.HorizontalContentAlignment = HorizontalAlignment.Stretch;
310                        rb.Content = border;
311                        rb.Tag = ele;
312                        if (ele.Name == "loadSample")
313                        {
314                            RoutedEventHandler rbEvent = delegate
315                                              {
316                                                  SwitchNextButtonContent();
317                                              };
318                            rb.Checked += rbEvent;
319                            rb.Unchecked += rbEvent;
320                        }
321
322                        radioButtonStackPanel.Children.Add(rb);
323                        bool wasSelected = false;
324                        selectedCategories.TryGetValue(GetElementID(ele), out wasSelected);
325                        if (wasSelected)
326                        {
327                            rb.IsChecked = true;
328                            isSelected = true;
329                        }
330                    }
331
332                    if (!isSelected)
333                    {
334                        RadioButton b = (RadioButton)radioButtonStackPanel.Children[0];
335                        b.IsChecked = true;
336                        selectedCategories.Remove(GetElementID((XElement)b.Tag));
337                        selectedCategories.Add(GetElementID((XElement)b.Tag), true);
338                    }
339
340                }
341            }
342        }
343
344        private void FillInputStack(IEnumerable<XElement> inputs, string type, bool isInput)
345        {
346            var inputFieldStyle = (Style)FindResource("InputFieldStyle");
347
348            foreach (var input in inputs)
349            {
350                try
351                {
352                    var description = new Label();
353                    description.Content = FindElementsInElement(input, "description").First().Value.Trim();
354                    description.HorizontalAlignment = HorizontalAlignment.Left;
355                    description.FontWeight = FontWeights.Bold;
356                    inputStack.Children.Add(description);
357
358                    Control inputElement = CreateInputElement(input, inputFieldStyle, isInput);
359
360                    //Set width:
361                    if (inputElement != null && input.Attribute("width") != null)
362                    {
363                        string width = input.Attribute("width").Value.Trim();
364                        if (width.EndsWith("%"))
365                        {
366                            double percentage;
367                            if (Double.TryParse(width.Substring(0, width.Length - 1), out percentage))
368                            {
369                                percentage /= 100;
370                                Binding binding = new Binding("ActualWidth");
371                                binding.Source = inputStack;
372                                binding.Converter = widthConverter;
373                                binding.ConverterParameter = percentage;
374                                inputElement.SetBinding(FrameworkElement.WidthProperty, binding);
375                            }
376                        }
377                        else
378                        {
379                            double widthValue;
380                            if (Double.TryParse(width, out widthValue))
381                            {
382                                inputElement.Width = widthValue;
383                            }
384                        }
385                    }
386
387                    //Set alignment
388                    if (inputElement != null && input.Attribute("alignment") != null)
389                    {
390                        switch (input.Attribute("alignment").Value.Trim().ToLower())
391                        {
392                            case "right":
393                                inputElement.HorizontalAlignment = HorizontalAlignment.Right;
394                                break;
395                            case "left":
396                                inputElement.HorizontalAlignment = HorizontalAlignment.Left;
397                                break;
398                            case "center":
399                                inputElement.HorizontalAlignment = HorizontalAlignment.Center;
400                                break;
401                            case "stretch":
402                                inputElement.HorizontalAlignment = HorizontalAlignment.Stretch;
403                                break;
404                        }
405                    }
406                }
407                catch (Exception e)
408                {
409                    GuiLogMessage(string.Format("Error while creating wizard element {0}: {1}", input, e.Message), NotificationLevel.Error);
410                }
411
412            }
413        }
414
415        private Control CreateInputElement(XElement input, Style inputFieldStyle, bool isInput)
416        {
417            Control element = null;
418
419            string key = GetElementPluginPropertyKey(input);
420
421            switch (input.Name.ToString())
422            {
423                case "inputBox":
424                    var inputBox = new TextBox();
425                    inputBox.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
426                    inputBox.Tag = input;
427                    inputBox.AcceptsReturn = true;
428                    if (input.Attribute("visibleLines") != null)
429                    {
430                        int visibleLines;
431                        if (Int32.TryParse(input.Attribute("visibleLines").Value.Trim(), out visibleLines))
432                        {
433                            inputBox.MinLines = visibleLines;
434                            inputBox.MaxLines = visibleLines;
435                        }
436                    }
437                    inputBox.Style = inputFieldStyle;
438                    inputStack.Children.Add(inputBox);
439
440                    if (input.Attribute("regex") != null)
441                    {
442                        var regex = new Regex(input.Attribute("regex").Value, RegexOptions.Compiled);
443
444                        inputBox.TextChanged += delegate
445                        {
446                            CheckRegex(inputBox, regex);
447                        };
448                    }
449
450                    if (key != null && propertyValueDict.ContainsKey(key))
451                        inputBox.Text = (string)propertyValueDict[key].Value;
452                    else if (input.Attribute("defaultValue") != null)
453                        inputBox.Text = input.Attribute("defaultValue").Value.Trim();
454
455                    if (!isInput)
456                        currentInputBoxes.Add(inputBox);
457
458                    element = inputBox;
459                    break;
460
461                case "comboBox":
462                    ComboBox comboBox = new ComboBox();
463                    comboBox.Style = inputFieldStyle;
464                    comboBox.Tag = input;
465
466                    var items = FindElementsInElement(input, "item");
467                    foreach (var item in items)
468                    {
469                        ComboBoxItem cbi = new ComboBoxItem();
470                        if (item.Attribute("content") != null)
471                            cbi.Content = item.Attribute("content").Value;
472                        comboBox.Items.Add(cbi);
473                    }
474
475
476                    if (key != null && propertyValueDict.ContainsKey(key))
477                    {
478                        if (propertyValueDict[key].Value is int)
479                        {
480                            ComboBoxItem cbi =
481                                (ComboBoxItem)comboBox.Items.GetItemAt((int)propertyValueDict[key].Value);
482                            cbi.IsSelected = true;
483                        }
484                    }
485                    else if (input.Attribute("defaultValue") != null)
486                    {
487                        int i = 0;
488                        if (Int32.TryParse(input.Attribute("defaultValue").Value.Trim(), out i))
489                        {
490                            ComboBoxItem cbi = (ComboBoxItem)comboBox.Items.GetItemAt(i);
491                            cbi.IsSelected = true;
492                        }
493                    }
494
495
496                    inputStack.Children.Add(comboBox);
497                    element = comboBox;
498                    break;
499
500                case "checkBox":
501                    CheckBox checkBox = new CheckBox();
502                    checkBox.Tag = input;
503                    checkBox.Style = inputFieldStyle;
504
505                    if (input.Attribute("content") != null)
506                        checkBox.Content = input.Attribute("content").Value;
507
508
509                    if (key != null && propertyValueDict.ContainsKey(key))
510                    {
511                        string value = (string)propertyValueDict[key].Value;
512                        if (value.ToLower() == "true")
513                            checkBox.IsChecked = true;
514                        else
515                            checkBox.IsChecked = false;
516                    }
517                    else if (input.Attribute("defaultValue") != null)
518                    {
519                        string value = input.Attribute("defaultValue").Value;
520                        if (value.ToLower() == "true")
521                            checkBox.IsChecked = true;
522                        else
523                            checkBox.IsChecked = false;
524                    }
525
526                    inputStack.Children.Add(checkBox);
527                    element = checkBox;
528                    break;
529
530                case "outputBox":
531                    if (isInput)
532                        break;
533
534                    var outputBox = new TextBox();
535                    outputBox.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
536                    outputBox.Tag = input;
537                    outputBox.AcceptsReturn = true;
538                    if (input.Attribute("visibleLines") != null)
539                    {
540                        int visibleLines;
541                        if (Int32.TryParse(input.Attribute("visibleLines").Value.Trim(), out visibleLines))
542                        {
543                            outputBox.MinLines = visibleLines;
544                            outputBox.MaxLines = visibleLines;
545                        }
546                    }
547                    outputBox.Style = inputFieldStyle;
548                    inputStack.Children.Add(outputBox);
549
550                    if (input.Attribute("regex") != null)
551                    {
552                        var regex = new Regex(input.Attribute("regex").Value, RegexOptions.Compiled);
553
554                        outputBox.TextChanged += delegate
555                        {
556                            CheckRegex(outputBox, regex);
557                        };
558                    }
559                   
560                    outputBox.IsEnabled = false;
561
562                    currentOutputBoxes.Add(outputBox);
563                    element = outputBox;
564                    break;
565            }
566
567            return element;
568        }
569
570        private string GetElementPluginPropertyKey(XElement element)
571        {
572            var plugin = element.Attribute("plugin").Value;
573            var property = element.Attribute("property").Value;
574            string key = null;
575            if (plugin != null && property != null)
576                key = string.Format("{0}.{1}", plugin, property);
577            return key;
578        }
579
580        private void CreateHistory()
581        {
582            StackPanel historyStack = new StackPanel();
583            historyStack.Orientation = Orientation.Horizontal;
584
585            foreach (var page in currentHistory)
586            {
587                var p = new ContentControl();
588                var bg = selectionBrush.Clone();
589                bg.Opacity = 1 - (historyStack.Children.Count / (double)currentHistory.Count);
590                var sp = new StackPanel { Orientation = Orientation.Horizontal, Background = bg };
591                p.Content = sp;
592                p.Tag = page.tag;
593                p.MouseDoubleClick += new MouseButtonEventHandler(page_MouseDoubleClick);
594
595                Polygon triangle = new Polygon();
596                triangle.Points = new PointCollection();
597                triangle.Points.Add(new Point(0, 0));
598                triangle.Points.Add(new Point(0, 10));
599                triangle.Points.Add(new Point(10, 5));
600                triangle.Fill = bg;
601                triangle.Stretch = Stretch.Uniform;
602                triangle.Width = 32;
603                sp.Children.Add(triangle);
604
605                if (page.image != null && FindResource(page.image) != null)
606                {
607                    var im = new Image { Source = (ImageSource)FindResource(page.image), Width = 32 };
608                    sp.Children.Add(im);
609                }
610                var nameLabel = new Label { Content = page.name };
611                sp.Children.Add(nameLabel);
612                p.ToolTip = page.description;
613                var translateTranform = new TranslateTransform();
614                triangle.RenderTransform = translateTranform;
615                Binding binding = new Binding("ActualWidth");
616                binding.Source = p;
617                binding.Converter = historyTranslateTransformConverter;
618                BindingOperations.SetBinding(translateTranform, TranslateTransform.XProperty, binding);
619
620                historyStack.Children.Add(p);
621            }
622
623            history.Content = historyStack;
624            history.ScrollToRightEnd();
625        }
626
627        void page_MouseDoubleClick(object sender, MouseButtonEventArgs e)
628        {
629            SwitchButtonWhenNecessary();
630
631            var cc = (ContentControl)sender;
632            var hs = (StackPanel)history.Content;
633            int i = hs.Children.IndexOf(cc);
634            history.Content = null;
635
636            while (currentHistory.Count > i+1)
637            {
638                currentHistory.RemoveAt(currentHistory.Count - 1);
639            }
640
641            CreateHistory();
642
643            XElement parent = (XElement)cc.Tag;
644
645            if (parent == null)
646                parent = wizardConfigXML;
647
648            SetupPage(parent);
649        }
650
651        private void CheckRegex(TextBox textBox, Regex regex)
652        {
653            var match = regex.Match(textBox.Text);
654            if (!match.Success || match.Index != 0 || match.Length != textBox.Text.Length)
655            {
656                textBox.Style = (Style) FindResource("TextInputInvalid");
657                GuiLogMessage(string.Format("Content of textbox does not fit regular expression {0}.", regex.ToString()), NotificationLevel.Error);
658                boxesWithWrongContent.Add(textBox);
659                nextButton.IsEnabled = false;
660            }
661            else
662            {
663                textBox.Style = null;
664                boxesWithWrongContent.Remove(textBox);
665                if (boxesWithWrongContent.Count == 0)
666                    nextButton.IsEnabled = true;
667            }
668        }
669
670        private string GetElementID(XElement element)
671        {
672            if (element != null && element.Parent != null)
673            {
674                return GetElementID(element.Parent) + "[" + element.Parent.Nodes().ToList().IndexOf(element) + "]." + element.Name;
675            }
676            else
677                return "";
678        }
679
680        private void LoadSample(string file, string title, bool openTab)
681        {
682            file = SamplesDir + "\\" + file;
683
684            var newEditor = new WorkspaceManager.WorkspaceManager();
685            var model = ModelPersistance.loadModel(file, newEditor);
686
687            //Fill in all data from wizard to sample:
688            foreach (var c in propertyValueDict)
689            {
690                var ppv = c.Value;
691                try
692                {
693                    var plugin = model.AllPluginModels.Where(x => x.Name == ppv.PluginName).First().Plugin;
694                    var settings = plugin.Settings;
695
696                    var property = plugin.GetType().GetProperty(ppv.PropertyName) ?? settings.GetType().GetProperty(ppv.PropertyName);
697
698                    if (property != null)
699                    {
700                        if (ppv.Value is string)
701                            property.SetValue(settings, (string) ppv.Value, null);
702                        else if (ppv.Value is int)
703                            property.SetValue(settings, (int) ppv.Value, null);
704                        else if (ppv.Value is bool)
705                            property.SetValue(settings, (bool) ppv.Value, null);
706                    }
707                }
708                catch (Exception)
709                {
710                    GuiLogMessage(string.Format("Failed settings plugin property {0}.{1} to \"{2}\"!", ppv.PluginName, ppv.PropertyName, ppv.Value), NotificationLevel.Error);
711                }
712            }
713
714            //Register events for output boxes:
715            foreach (var outputBox in currentOutputBoxes)
716            {
717                XElement ele = (XElement) outputBox.Tag;
718                var pluginName = ele.Attribute("plugin").Value;
719                var propertyName = ele.Attribute("property").Value;
720                if (pluginName != null && propertyName != null)
721                {
722                    var plugin = model.AllPluginModels.Where(x => x.Name == pluginName).First().Plugin;
723                    var settings = plugin.Settings;
724                    object theObject = null;
725
726                    var property = plugin.GetType().GetProperty(propertyName);
727                    EventInfo propertyChangedEvent = null;
728                    if (property != null)
729                    {
730                        propertyChangedEvent = plugin.GetType().GetEvent("PropertyChanged");
731                        theObject = plugin;
732                    }
733                    else    //Use property from settings
734                    {
735                        property = settings.GetType().GetProperty(propertyName);
736                        propertyChangedEvent = settings.GetType().GetEvent("PropertyChanged");
737                        theObject = settings;
738                    }
739
740                    if (property != null && propertyChangedEvent != null)
741                    {
742                        TextBox box = outputBox;
743                        propertyChangedEvent.AddEventHandler(theObject, (PropertyChangedEventHandler)delegate(Object sender, PropertyChangedEventArgs e)
744                                                                                                    {
745                                                                                                        if (e.PropertyName == propertyName)
746                                                                                                        {
747                                                                                                            UpdateOutputBox(box, property, theObject);
748                                                                                                        }
749                                                                                                    });
750                    }
751                }
752            }
753
754            //Register events for input boxes:
755            foreach (var inputBox in currentInputBoxes)
756            {
757                XElement ele = (XElement)inputBox.Tag;
758                var pluginName = ele.Attribute("plugin").Value;
759                var propertyName = ele.Attribute("property").Value;
760                if (pluginName != null && propertyName != null)
761                {
762                    var plugin = model.AllPluginModels.Where(x => x.Name == pluginName).First().Plugin;
763                    var settings = plugin.Settings;
764                    object theObject = null;
765
766                    var property = plugin.GetType().GetProperty(propertyName);
767                    if (property != null)
768                    {
769                        theObject = plugin;
770                    }
771                    else    //Use property from settings
772                    {
773                        property = settings.GetType().GetProperty(propertyName);
774                        theObject = settings;
775                    }
776
777                    if (property != null)
778                    {
779                        inputBox.TextChanged += delegate
780                                                    {
781                                                        property.SetValue(settings, (string) inputBox.Text, null);
782                                                        plugin.Initialize();
783                                                    };
784                    }
785                }
786            }
787
788            //load sample:
789            foreach (PluginModel pluginModel in model.AllPluginModels)
790            {
791                pluginModel.Plugin.Initialize();
792            }
793            newEditor.Open(model);
794
795            if (openTab)
796                OnOpenTab(newEditor, title, null);
797            else
798                newEditor.Execute();
799        }
800
801        private void UpdateOutputBox(TextBox box, PropertyInfo property, object theObject)
802        {
803            Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
804                                                             {
805                                                                 box.Text = (string) property.GetValue(theObject, null);
806                                                             }, null);
807        }
808
809        void rb_Checked(object sender, RoutedEventArgs e)
810        {
811            ResetSelectionDependencies();
812            RadioButton b = (RadioButton)sender;
813            b.Background = Brushes.LightSeaGreen;
814            Border c = (Border)b.Content;
815            c.BorderThickness = new Thickness(1, 1, 0, 1);
816            c.Background = selectionBrush;
817            XElement ele = (XElement)b.Tag;
818            selectedCategories.Remove(GetElementID(ele));
819            selectedCategories.Add(GetElementID(ele), true);
820            XElement desc = FindElementsInElement(ele, "description").First();
821            if (desc != null)
822                description.Text = desc.Value;
823            nextButton.IsEnabled = true;
824        }
825
826        private void ResetSelectionDependencies()
827        {
828            for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
829            {
830                RadioButton b = (RadioButton)radioButtonStackPanel.Children[i];
831                XElement ele = (XElement)b.Tag;
832                selectedCategories.Remove(GetElementID(ele));
833                selectedCategories.Add(GetElementID(ele), false);
834                b.Background = Brushes.Transparent;
835                Border c = (Border)b.Content;
836                c.BorderThickness = new Thickness(0);
837                c.Background = Brushes.Transparent;
838            }
839        }
840
841        //finds elements according to the current language
842        private IEnumerable<XElement> FindElementsInElement(XElement element, string xname)
843        {
844            CultureInfo currentLang = System.Globalization.CultureInfo.CurrentCulture;
845
846            IEnumerable<XElement> allElements = element.Elements(xname);
847            IEnumerable<XElement> foundElements = null;
848
849            if (allElements.Any())
850            {
851                foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TextInfo.CultureName select descln;
852                if (!foundElements.Any())
853                {
854                    foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TwoLetterISOLanguageName select descln;
855                    if (!foundElements.Any())
856                        foundElements = from descln in allElements where descln.Attribute("lang").Value == defaultLang select descln;
857                }
858            }
859
860            if (foundElements == null || !foundElements.Any() || !allElements.Any())
861            {
862                List<XElement> fe = new List<XElement>();
863                fe.Add(new XElement("dummy"));
864                return fe;
865            }
866
867            return foundElements;
868        }
869
870        private void nextButton_Click(object sender, RoutedEventArgs e)
871        {
872            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardNext1");
873            mainGridStoryboardLeft.Begin();
874        }
875
876        private void backButton_Click(object sender, RoutedEventArgs e)
877        {
878            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardBack1");
879            mainGridStoryboardLeft.Begin();
880        }
881
882        private void abortButton_Click(object sender, RoutedEventArgs e)
883        {
884            SwitchButtonWhenNecessary();
885
886            foreach (RadioButton rb in radioButtonStackPanel.Children)
887            {
888                if (rb.IsChecked != null && (bool)rb.IsChecked)
889                    rb.IsChecked = false;
890            }
891
892            history.Content = null;
893            currentHistory.Clear();
894            AddToHistory(wizardConfigXML);
895            propertyValueDict.Clear();
896            ResetSelectionDependencies();
897            radioButtonStackPanel.Children.Clear();
898            selectedCategories.Clear();
899            description.Text = "";
900            SetupPage(wizardConfigXML);
901        }
902
903        private void SwitchButtonWhenNecessary()
904        {
905            if (inputPanel.Visibility == Visibility.Visible)
906            {
907                if (inputPanel.Tag != null && ((XElement)inputPanel.Tag).Name == "loadSample")
908                    SwitchNextButtonContent();
909            }
910        }
911
912        private void SetNextContent(object sender, EventArgs e)
913        {
914            if (categoryGrid.Visibility == Visibility.Visible)
915            {
916                for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
917                {
918                    RadioButton b = (RadioButton) radioButtonStackPanel.Children[i];
919                    if (b.IsChecked != null && (bool) b.IsChecked)
920                    {
921                        var ele = (XElement) b.Tag;
922                        AddToHistory(ele);
923                        SetupPage(ele);
924                        break;
925                    }
926                }
927            }
928            else if (inputPanel.Visibility == Visibility.Visible)
929            {
930                var nextElement = (XElement) inputPanel.Tag;
931                AddToHistory(nextElement);
932                SetupPage(nextElement);
933            }
934
935            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardNext2");
936            mainGridStoryboardLeft.Begin();
937        }
938
939        private void SaveContent()
940        {
941            if (inputPanel.Visibility == Visibility.Visible)
942            {
943                foreach (var child in inputStack.Children)
944                {
945                    SaveControlContent(child);
946                }
947            }
948        }
949
950        private void AddToHistory(XElement ele)
951        {
952            try
953            {
954                var page = new PageInfo()
955                                   {
956                                       name = FindElementsInElement(ele, "name").First().Value,
957                                       description = FindElementsInElement(ele, "description").First().Value,
958                                       tag = ele
959                                   };
960
961                if (ele.Attribute("image") != null)
962                {
963                    page.image = ele.Attribute("image").Value;
964                }
965
966                currentHistory.Add(page);
967            }
968            catch (Exception)
969            {
970                GuiLogMessage("Error adding page to history", NotificationLevel.Error);
971            }
972        }
973
974        private void SaveControlContent(object o)
975        {
976            if (o is TextBox || o is ComboBox || o is CheckBox)
977            {
978                Control c = (Control)o;
979                XElement ele = (XElement)c.Tag;
980               
981                PluginPropertyValue newEntry = new PluginPropertyValue();
982                if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
983                {
984                    if (o is TextBox)
985                    {
986                        TextBox textBox = (TextBox)o;
987                        newEntry = new PluginPropertyValue()
988                                   {
989                                       PluginName = ele.Attribute("plugin").Value,
990                                       PropertyName = ele.Attribute("property").Value,
991                                       Value = textBox.Text
992                                   };
993                    }
994                    else if (o is ComboBox)
995                    {
996                        ComboBox comboBox = (ComboBox)o;
997                        newEntry = new PluginPropertyValue()
998                        {
999                            PluginName = ele.Attribute("plugin").Value,
1000                            PropertyName = ele.Attribute("property").Value,
1001                            Value = comboBox.SelectedIndex
1002                        };
1003                    }
1004                    else if (o is CheckBox)
1005                    {
1006                        CheckBox checkBox = (CheckBox)o;
1007                        if (checkBox.IsChecked != null)
1008                        {
1009                            newEntry = new PluginPropertyValue()
1010                            {
1011                                PluginName = ele.Attribute("plugin").Value,
1012                                PropertyName = ele.Attribute("property").Value,
1013                                Value = (bool)checkBox.IsChecked
1014                            };
1015                        }
1016                    }
1017
1018                    var key = GetElementPluginPropertyKey(ele);
1019                    if (key != null)
1020                    {
1021                        if (!propertyValueDict.ContainsKey(key))
1022                            propertyValueDict.Add(key, newEntry);
1023                        else
1024                            propertyValueDict[key] = newEntry;
1025                    }
1026                } 
1027            }
1028        }
1029
1030        private void DeleteControlContent(object o)
1031        {
1032            if (o is TextBox || o is ComboBox || o is CheckBox)
1033            {
1034                Control control = (Control)o;
1035                XElement ele = (XElement)control.Tag;
1036
1037                var key = GetElementPluginPropertyKey(ele);
1038                if (key != null && propertyValueDict.ContainsKey(key))
1039                    propertyValueDict.Remove(key);
1040            }
1041        }
1042
1043
1044        private void SetLastContent(object sender, EventArgs e)
1045        {
1046            XElement ele = null;
1047            if (categoryGrid.Visibility == Visibility.Visible && radioButtonStackPanel.Children.Count > 0)
1048            {
1049                RadioButton b = (RadioButton) radioButtonStackPanel.Children[0];
1050                ele = (XElement) b.Tag;
1051
1052                foreach (RadioButton rb in radioButtonStackPanel.Children)
1053                {
1054                    if (rb.IsChecked != null && (bool)rb.IsChecked)
1055                        rb.IsChecked = false;
1056                }
1057
1058            }
1059            else if (inputPanel.Visibility == Visibility.Visible)
1060            {
1061                ele = (XElement) inputPanel.Tag;
1062                if (ele != null && ((XElement)inputPanel.Tag).Name == "loadSample")
1063                    SwitchNextButtonContent();
1064            }
1065
1066            if (ele != null)
1067            {
1068                XElement grandParent = ele.Parent.Parent;
1069                if (grandParent == null)
1070                    grandParent = wizardConfigXML;
1071
1072                if (currentHistory.Count > 0)
1073                    currentHistory.RemoveAt(currentHistory.Count - 1);
1074
1075                SetupPage(grandParent);
1076            }
1077
1078            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardBack2");
1079            mainGridStoryboardLeft.Begin();
1080        }
1081
1082        private void GuiLogMessage(string message, NotificationLevel loglevel)
1083        {
1084            if (OnGuiLogNotificationOccured != null)
1085                OnGuiLogNotificationOccured(null, new GuiLogEventArgs(message, null, loglevel));
1086        }
1087
1088        private void SwitchNextButtonContent()
1089        {
1090            var tmp = nextButton.Content;
1091            nextButton.Content = nextButton.Tag;
1092            nextButton.Tag = tmp;
1093        }
1094
1095        private void history_MouseMove(object sender, MouseEventArgs e)
1096        {
1097            if (e.LeftButton == MouseButtonState.Pressed)
1098            {
1099                Point dir = e.GetPosition(history);
1100                if (dir.X < history.ActualWidth / 2)
1101                    history.LineRight();
1102                else if (dir.X > history.ActualWidth / 2)
1103                    history.LineLeft();
1104            }
1105        }
1106
1107        protected override void OnKeyDown(KeyEventArgs e)
1108        {
1109            switch (e.Key)
1110            {
1111                case Key.Up:
1112                case Key.Down:
1113                    if (categoryGrid.Visibility == Visibility.Visible)
1114                    {
1115                        if (radioButtonStackPanel.Children.Count != 0)
1116                        {
1117                            int i = 0;
1118                            while (((RadioButton)radioButtonStackPanel.Children[i]).IsChecked == false)
1119                                i++;
1120                            ((RadioButton)radioButtonStackPanel.Children[i]).IsChecked = false;
1121
1122                            if (e.Key == Key.Down)
1123                            {
1124                                if (radioButtonStackPanel.Children.Count > i + 1)
1125                                    ((RadioButton)radioButtonStackPanel.Children[i + 1]).IsChecked = true;
1126                                else
1127                                    ((RadioButton)radioButtonStackPanel.Children[0]).IsChecked = true;
1128                            }
1129                            else   //Up
1130                            {
1131                                if (i - 1 >= 0)
1132                                    ((RadioButton)radioButtonStackPanel.Children[i - 1]).IsChecked = true;
1133                                else
1134                                    ((RadioButton)radioButtonStackPanel.Children[radioButtonStackPanel.Children.Count - 1]).IsChecked = true;
1135                            }
1136                        }
1137                    }
1138                    break;
1139
1140                case Key.Left:
1141                    break;
1142
1143                case Key.Right:
1144                    break;
1145            }
1146        }
1147
1148    }
1149
1150    internal struct PluginPropertyValue
1151    {
1152        public string PluginName;
1153        public string PropertyName;
1154        public object Value;
1155    }
1156}
Note: See TracBrowser for help on using the repository browser.