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

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

Wizard: plugin presentation height

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