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

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

Wizard: plugin presentation

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