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

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

Wizard: category selection memory change

File size: 33.5 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.Text.RegularExpressions;
6using System.Windows;
7using System.Windows.Controls;
8using System.Windows.Data;
9using System.Windows.Documents;
10using System.Windows.Input;
11using System.Windows.Media;
12using System.Windows.Media.Animation;
13using System.Windows.Media.Imaging;
14using System.Windows.Navigation;
15using System.Windows.Shapes;
16using System.Xml.Linq;
17using System.IO;
18using System.Reflection;
19using System.Windows.Threading;
20using System.Threading;
21using System.Collections;
22using System.Globalization;
23using Cryptool.PluginBase;
24using WorkspaceManager.Model;
25
26namespace Wizard
27{
28    /// <summary>
29    /// Interaction logic for WizardControl.xaml
30    /// </summary>
31    [Cryptool.PluginBase.Attributes.Localization("Wizard.Properties.Resources")]
32    public partial class WizardControl : UserControl
33    {
34
35        private Dictionary<string, bool> selectedCategories = new Dictionary<string, bool>();
36        private SolidColorBrush selectionBrush = new SolidColorBrush();
37        private const string configXMLPath = "Wizard.Config.wizard.config.start.xml";
38        private const string defaultLang = "en";
39        private XElement wizardConfigXML;
40        private Dictionary<string, PluginPropertyValue> propertyValueDict = new Dictionary<string, PluginPropertyValue>();
41        private HashSet<TextBox> boxesWithWrongContent = new HashSet<TextBox>();
42
43        internal event OpenTabHandler OnOpenTab;
44        internal event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
45
46        internal string SamplesDir { set; private get; }
47
48        public WizardControl()
49        {
50            try
51            {
52                // DEBUG HELP string[] names = this.GetType().Assembly.GetManifestResourceNames();
53
54                Stream fileStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(configXMLPath);
55                XElement xml = XElement.Load(fileStream);
56                GenerateXML(xml);
57            }
58            catch (Exception)
59            {
60               
61            }
62
63            InitializeComponent();
64
65            selectionBrush.Color = Color.FromArgb(255, 200, 220, 245);
66            SetupPage(wizardConfigXML);
67        }
68
69        // generate the full XML tree for the wizard (recursive)
70        private void GenerateXML(XElement xml)
71        {
72            try
73            {
74                //find all nested subcategories and add them to the tree
75                IEnumerable<XElement> categories = xml.Elements("category");
76                if (categories.Any())
77                {
78                    foreach (XElement cat in categories)
79                    {
80                        IEnumerable<XElement> files = cat.Elements("file");
81                        if (files.Any())
82                        {
83                            foreach (XElement element in files)
84                            {
85                                XAttribute att = element.Attribute("resource");
86                                if (att != null)
87                                {
88                                    string path = att.Value;
89                                    Stream fileStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path);
90                                    XElement sub = XElement.Load(fileStream);
91                                    GenerateXML(sub);
92                                    IEnumerable<XElement> elems = sub.Elements();
93                                    if (elems.Any())
94                                    {
95                                        foreach (XElement ele in elems)
96                                        {
97                                            cat.Add(ele);
98                                        }
99                                    }
100                                }
101                            }
102                        }
103                    }
104                }
105
106                wizardConfigXML = xml;
107
108            }
109            catch (Exception)
110            {
111               
112            }
113        }
114
115        #region WidthConverter
116
117        [ValueConversion(typeof(Double), typeof(Double))]
118        private class WidthConverter : IValueConverter
119        {
120            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
121            {
122                return (double)value * (double)parameter;
123            }
124
125            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
126            {
127                throw new NotImplementedException();
128            }
129        }
130
131        private WidthConverter widthConverter = new WidthConverter();
132
133        #endregion
134
135        private void SetupPage(XElement element)
136        {
137            if ((element.Name == "loadSample") && (element.Attribute("file") != null) && (element.Attribute("title") != null))
138            {
139                LoadSample(element.Attribute("file").Value, element.Attribute("title").Value);
140                abortButton_Click(null, null);
141            }
142
143            XElement parent = element.Parent;
144            if (parent == null)
145            {
146                backButton.IsEnabled = false;
147                abortButton.IsEnabled = false;
148            }
149            else
150            {
151                backButton.IsEnabled = true;
152                abortButton.IsEnabled = true;
153            }
154
155            //nextButton.IsEnabled = false;
156
157            //set headline
158            XElement headline = FindElementsInElement(element, "headline").First();
159            if (headline != null)
160                taskHeader.Content = headline.Value;
161
162            //set description label
163            XElement desc = FindElementsInElement(element, "desc").First();
164            if (desc != null)
165                descHeader.Content = desc.Value;
166
167
168            if (element.Name == "input" || element.Name == "output")
169            {
170                categoryGrid.Visibility = Visibility.Hidden;
171                inputPanel.Visibility = Visibility.Visible;
172
173                var inputs = element.Elements("inputBox");
174                inputs = inputs.Union(element.Elements("comboBox"));
175                inputs = inputs.Union(element.Elements("checkBox"));
176                inputStack.Children.Clear();
177
178                inputPanel.Tag = element.Element("input");
179                if (inputPanel.Tag == null)
180                    inputPanel.Tag = element.Element("category");
181                if (inputPanel.Tag == null)
182                {
183                    inputPanel.Tag = element.Element("loadSample");
184                    if (inputPanel.Tag != null)
185                        SwitchNextButtonContent();
186                }
187                if (inputPanel.Tag == null)
188                    inputPanel.Tag = element.Element("output");
189
190                //if (inputPanel.Tag != null)
191                //    nextButton.IsEnabled = true;
192
193                FillInputStack(inputs, element.Name.ToString());
194
195                string id = GetElementID((XElement)inputPanel.Tag);
196
197            }
198            else if (element.Name == "category")
199            {
200                categoryGrid.Visibility = Visibility.Visible;
201                inputPanel.Visibility = Visibility.Hidden;
202               
203                radioButtonStackPanel.Children.Clear();
204                //ResetBackground();
205
206                //generate radio buttons
207                var options = element.Elements("category");
208                var inputs = element.Elements("input");
209                var loadSamples = element.Elements("loadSample");
210                var outputs = element.Elements("output");
211
212                if (inputs.Any())
213                    options = options.Union(inputs);
214                if (loadSamples.Any())
215                    options = options.Union(loadSamples);
216                if (outputs.Any())
217                    options = options.Union(outputs);
218
219                if (options.Any())
220                {
221                    bool isSelected = false;
222
223                    foreach (XElement ele in options)
224                    {
225                        Border border = new Border();
226                        Label l = new Label();
227                        Image i = new Image();
228                        StackPanel sp = new StackPanel();
229
230                        border.Child = sp;
231                        border.VerticalAlignment = VerticalAlignment.Stretch;
232                        border.CornerRadius = new CornerRadius(5, 0, 0, 5);
233                        border.BorderBrush = Brushes.LightSeaGreen;
234
235                        l.Height = 30;
236                        l.HorizontalAlignment = HorizontalAlignment.Stretch;
237                        XElement label = FindElementsInElement(ele, "name").First();
238                        if (label != null)
239                            l.Content = label.Value;
240
241                        i.Width = 26;
242                        string image = ele.Attribute("image").Value;
243                        if (image != null)
244                        {
245                            ImageSource ims = (ImageSource) TryFindResource(image);
246                            if (ims != null)
247                            {
248                                i.Source = ims;
249                                sp.Children.Add(i);
250                            }
251                        }
252
253                        sp.VerticalAlignment = VerticalAlignment.Stretch;
254                        sp.HorizontalAlignment = HorizontalAlignment.Stretch;
255                        sp.Orientation = Orientation.Horizontal;
256                        sp.Children.Add(l);
257
258                        RadioButton rb = new RadioButton();
259                        string id = GetElementID(ele);
260                        rb.Checked += rb_Checked;
261                        rb.HorizontalAlignment = HorizontalAlignment.Stretch;
262                        rb.VerticalAlignment = VerticalAlignment.Stretch;
263                        rb.HorizontalContentAlignment = HorizontalAlignment.Stretch;
264                        rb.Content = border;
265                        rb.Tag = ele;
266                        if (ele.Name == "loadSample")
267                        {
268                            RoutedEventHandler rbEvent = delegate
269                                              {
270                                                  SwitchNextButtonContent();
271                                              };
272                            rb.Checked += rbEvent;
273                            rb.Unchecked += rbEvent;
274                        }
275
276                        radioButtonStackPanel.Children.Add(rb);
277                        bool wasSelected;
278                        selectedCategories.TryGetValue(GetElementID(ele), out wasSelected);
279                        if (wasSelected != null && wasSelected)
280                        {
281                            rb.IsChecked = true;
282                            isSelected = true;
283                            //nextButton.IsEnabled = true;
284                        }
285                    }
286
287                    if (!isSelected)
288                    {
289                        RadioButton b = (RadioButton)radioButtonStackPanel.Children[0];
290                        b.IsChecked = true;
291                        selectedCategories.Remove(GetElementID((XElement)b.Tag));
292                        selectedCategories.Add(GetElementID((XElement)b.Tag), true);
293                    }
294
295                }
296            }
297
298        }
299
300        private void FillInputStack(IEnumerable<XElement> inputs, string type)
301        {
302            var inputFieldStyle = (Style)FindResource("InputFieldStyle");
303
304            foreach (var input in inputs)
305            {
306                try
307                {
308                    var description = new Label();
309                    description.Content = FindElementsInElement(input, "description").First().Value.Trim();
310                    description.HorizontalAlignment = HorizontalAlignment.Left;
311                    description.FontWeight = FontWeights.Bold;
312                    inputStack.Children.Add(description);
313
314                    bool isInput = (type == "input");
315
316                    Control inputElement = CreateInputElement(input, inputFieldStyle, isInput);
317
318                    //Set width:
319                    if (inputElement != null && input.Attribute("width") != null)
320                    {
321                        string width = input.Attribute("width").Value.Trim();
322                        if (width.EndsWith("%"))
323                        {
324                            double percentage;
325                            if (Double.TryParse(width.Substring(0, width.Length - 1), out percentage))
326                            {
327                                percentage /= 100;
328                                Binding binding = new Binding("ActualWidth");
329                                binding.Source = inputStack;
330                                binding.Converter = widthConverter;
331                                binding.ConverterParameter = percentage;
332                                inputElement.SetBinding(FrameworkElement.WidthProperty, binding);
333                            }
334                        }
335                        else
336                        {
337                            double widthValue;
338                            if (Double.TryParse(width, out widthValue))
339                            {
340                                inputElement.Width = widthValue;
341                            }
342                        }
343                    }
344
345                    //Set alignment
346                    if (inputElement != null && input.Attribute("alignment") != null)
347                    {
348                        switch (input.Attribute("alignment").Value.Trim().ToLower())
349                        {
350                            case "right":
351                                inputElement.HorizontalAlignment = HorizontalAlignment.Right;
352                                break;
353                            case "left":
354                                inputElement.HorizontalAlignment = HorizontalAlignment.Left;
355                                break;
356                            case "center":
357                                inputElement.HorizontalAlignment = HorizontalAlignment.Center;
358                                break;
359                            case "stretch":
360                                inputElement.HorizontalAlignment = HorizontalAlignment.Stretch;
361                                break;
362                        }
363                    }
364                }
365                catch (Exception e)
366                {
367                    GuiLogMessage(string.Format("Error while creating wizard element {0}: {1}", input, e.Message), NotificationLevel.Error);
368                }
369
370            }
371        }
372
373        private Control CreateInputElement(XElement input, Style inputFieldStyle, bool isInput)
374        {
375            Control element = null;
376
377            if (input.Name == "inputBox")
378            {
379                var textBox = new TextBox();
380                textBox.Tag = input;
381                textBox.AcceptsReturn = true;
382                if (input.Attribute("visibleLines") != null)
383                {
384                    int visibleLines;
385                    if (Int32.TryParse(input.Attribute("visibleLines").Value.Trim(), out visibleLines))
386                    {
387                        textBox.MinLines = visibleLines;
388                        textBox.MaxLines = visibleLines;
389                    }
390                }
391                textBox.Style = inputFieldStyle;
392                inputStack.Children.Add(textBox);
393
394                if (isInput)
395                {
396                    if (input.Attribute("regex") != null)
397                    {
398                        var regex = new Regex(input.Attribute("regex").Value, RegexOptions.Compiled);
399
400                        textBox.TextChanged += delegate
401                        {
402                            CheckRegex(textBox, regex);
403                        };
404                    }
405
406                    if (propertyValueDict.ContainsKey(GetElementID(input)))
407                        textBox.Text = (string) propertyValueDict[GetElementID(input)].Value;
408                    else if (input.Attribute("defaultValue") != null)
409                        textBox.Text = input.Attribute("defaultValue").Value.Trim();
410                }
411                else
412                {
413                    if (input.Attribute("plugin") != null && input.Attribute("property") != null)
414                    {
415                        var plugin = input.Attribute("plugin").Value;
416                        var property = input.Attribute("property").Value;
417                        foreach (var e in propertyValueDict.Values)
418                        {
419                            if (e.PluginName == plugin && e.PropertyName == property)
420                                textBox.Text = (String)e.Value;
421                        }
422                    }
423                }
424
425                element = textBox;
426            }
427            else if (input.Name == "comboBox")
428            {
429                ComboBox cb = new ComboBox();
430                cb.Style = inputFieldStyle;
431                cb.Tag = input;
432
433                var items = FindElementsInElement(input, "item");
434                foreach (var item in items)
435                {
436                    ComboBoxItem cbi = new ComboBoxItem();
437                    if (item.Attribute("content") != null)
438                        cbi.Content = item.Attribute("content").Value;
439                    cb.Items.Add(cbi);
440                }
441
442                if (isInput)
443                {
444                    if (propertyValueDict.ContainsKey(GetElementID(input)))
445                    {
446                        if (propertyValueDict[GetElementID(input)].Value is int)
447                        {
448                            ComboBoxItem cbi =
449                                (ComboBoxItem) cb.Items.GetItemAt((int) propertyValueDict[GetElementID(input)].Value);
450                            cbi.IsSelected = true;
451                        }
452                    }
453                    else if (input.Attribute("defaultValue") != null)
454                    {
455                        int i = 0;
456                        if (Int32.TryParse(input.Attribute("defaultValue").Value.Trim(), out i))
457                        {
458                            ComboBoxItem cbi = (ComboBoxItem) cb.Items.GetItemAt(i);
459                            cbi.IsSelected = true;
460                        }
461                    }
462                }
463                else
464                {
465                    if (input.Attribute("plugin") != null && input.Attribute("property") != null)
466                    {
467                        var plugin = input.Attribute("plugin").Value;
468                        var property = input.Attribute("property").Value;
469                        foreach (var e in propertyValueDict.Values)
470                        {
471                            if (e.PluginName == plugin && e.PropertyName == property)
472                                cb.SelectedIndex = (int) e.Value;
473                        }
474                    }
475                }
476
477                inputStack.Children.Add(cb);
478                element = cb;
479            }
480            else if (input.Name == "checkBox")
481            {
482                CheckBox cb = new CheckBox();
483                cb.Tag = input;
484                cb.Style = inputFieldStyle;
485
486                if (input.Attribute("content") != null)
487                    cb.Content = input.Attribute("content").Value;
488
489                if (isInput)
490                {
491                    if (propertyValueDict.ContainsKey(GetElementID(input)))
492                    {
493                        string value = (string) propertyValueDict[GetElementID(input)].Value;
494                        if (value.ToLower() == "true")
495                            cb.IsChecked = true;
496                        else
497                            cb.IsChecked = false;
498                    }
499                    else if (input.Attribute("defaultValue") != null)
500                    {
501                        string value = input.Attribute("defaultValue").Value;
502                        if (value.ToLower() == "true")
503                            cb.IsChecked = true;
504                        else
505                            cb.IsChecked = false;
506                    }
507                }
508                else
509                {
510                    if (input.Attribute("plugin") != null && input.Attribute("property") != null)
511                    {
512                        var plugin = input.Attribute("plugin").Value;
513                        var property = input.Attribute("property").Value;
514                        foreach (var e in propertyValueDict.Values)
515                        {
516                            if (e.PluginName == plugin && e.PropertyName == property)
517                                cb.IsChecked = (bool)e.Value;
518                        }
519                    }
520                }
521
522                inputStack.Children.Add(cb);
523                element = cb;
524            }
525
526            if (!isInput)
527                element.IsEnabled = false;
528
529            return element;
530        }
531
532        private void CheckRegex(TextBox textBox, Regex regex)
533        {
534            var match = regex.Match(textBox.Text);
535            if (!match.Success || match.Index != 0 || match.Length != textBox.Text.Length)
536            {
537                textBox.Style = (Style) FindResource("TextInputInvalid");
538                GuiLogMessage(string.Format("Content of textbox does not fit regular expression {0}.", regex.ToString()), NotificationLevel.Error);
539                boxesWithWrongContent.Add(textBox);
540                nextButton.IsEnabled = false;
541            }
542            else
543            {
544                textBox.Style = null;
545                boxesWithWrongContent.Remove(textBox);
546                if (boxesWithWrongContent.Count == 0)
547                    nextButton.IsEnabled = true;
548            }
549        }
550
551        private string GetElementID(XElement element)
552        {
553            if (element != null && element.Parent != null)
554            {
555                return GetElementID(element.Parent) + "[" + element.Parent.Nodes().ToList().IndexOf(element) + "]." + element.Name;
556            }
557            else
558                return "";
559        }
560
561        private void LoadSample(string file, string title)
562        {
563            file = SamplesDir + "\\" + file;
564
565            var newEditor = new WorkspaceManager.WorkspaceManager();
566            var model = ModelPersistance.loadModel(file, newEditor);
567            foreach (var c in propertyValueDict)
568            {
569                var ppv = c.Value;
570                try
571                {
572                    var plugin = model.AllPluginModels.Where(x => x.Name == ppv.PluginName).First().Plugin;
573                    var settings = plugin.Settings;
574                    var property = settings.GetType().GetProperty(ppv.PropertyName);
575                    if (ppv.Value is string)
576                        property.SetValue(settings, (string)ppv.Value, null);
577                    else if (ppv.Value is int)
578                        property.SetValue(settings, (int)ppv.Value, null);
579                    else if (ppv.Value is bool)
580                        property.SetValue(settings, (bool)ppv.Value, null);
581                }
582                catch (Exception)
583                {
584                    GuiLogMessage(string.Format("Failed settings plugin property {0}.{1} to \"{2}\"!", ppv.PluginName, ppv.PropertyName, ppv.Value), NotificationLevel.Error);
585                    return;
586                }
587            }
588
589            OnOpenTab(newEditor, title, null);
590            foreach (PluginModel pluginModel in model.AllPluginModels)
591            {
592                pluginModel.Plugin.Initialize();
593            }
594            newEditor.Open(model);                   
595        }
596
597        void rb_Checked(object sender, RoutedEventArgs e)
598        {
599            ResetSelectionDependencies();
600            RadioButton b = (RadioButton)sender;
601            b.Background = Brushes.LightSeaGreen;
602            Border c = (Border)b.Content;
603            c.BorderThickness = new Thickness(1, 1, 0, 1);
604            c.Background = selectionBrush;
605            XElement ele = (XElement)b.Tag;
606            selectedCategories.Remove(GetElementID(ele));
607            selectedCategories.Add(GetElementID(ele), true);
608            XElement desc = FindElementsInElement(ele, "description").First();
609            if (desc != null)
610                description.Text = desc.Value;
611            nextButton.IsEnabled = true;
612        }
613
614        private void ResetSelectionDependencies()
615        {
616            for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
617            {
618                RadioButton b = (RadioButton)radioButtonStackPanel.Children[i];
619                XElement ele = (XElement)b.Tag;
620                selectedCategories.Remove(GetElementID(ele));
621                selectedCategories.Add(GetElementID(ele), false);
622                b.Background = Brushes.Transparent;
623                Border c = (Border)b.Content;
624                c.BorderThickness = new Thickness(0);
625                c.Background = Brushes.Transparent;
626            }
627        }
628
629        //finds elements according to the current language
630        private IEnumerable<XElement> FindElementsInElement(XElement element, string xname)
631        {
632            CultureInfo currentLang = System.Globalization.CultureInfo.CurrentCulture;
633
634            IEnumerable<XElement> allElements = element.Elements(xname);
635            IEnumerable<XElement> foundElements = null;
636
637            if (allElements.Any())
638            {
639                foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TextInfo.CultureName select descln;
640                if (!foundElements.Any())
641                {
642                    foundElements = from descln in allElements where descln.Attribute("lang").Value == currentLang.TwoLetterISOLanguageName select descln;
643                    if (!foundElements.Any())
644                        foundElements = from descln in allElements where descln.Attribute("lang").Value == defaultLang select descln;
645                }
646            }
647
648            if (foundElements == null || !foundElements.Any() || !allElements.Any())
649            {
650                List<XElement> fe = new List<XElement>();
651                fe.Add(new XElement("dummy"));
652                return fe;
653            }
654
655            return foundElements;
656        }
657
658        private void nextButton_Click(object sender, RoutedEventArgs e)
659        {
660            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardNext1");
661            mainGridStoryboardLeft.Begin();
662        }
663
664        private void backButton_Click(object sender, RoutedEventArgs e)
665        {
666            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardBack1");
667            mainGridStoryboardLeft.Begin();
668        }
669
670        private void abortButton_Click(object sender, RoutedEventArgs e)
671        {
672            if (inputPanel.Visibility == Visibility.Visible)
673            {
674                if (((XElement)inputPanel.Tag).Name == "loadSample")
675                    SwitchNextButtonContent();
676            }
677
678            propertyValueDict.Clear();
679            ResetSelectionDependencies();
680            radioButtonStackPanel.Children.Clear();
681            selectedCategories.Clear();
682            description.Text = "";
683            SetupPage(wizardConfigXML);
684        }
685
686        private void SetNextContent(object sender, EventArgs e)
687        {
688            if (categoryGrid.Visibility == Visibility.Visible)
689            {
690                for (int i = 0; i < radioButtonStackPanel.Children.Count; i++)
691                {
692                    RadioButton b = (RadioButton) radioButtonStackPanel.Children[i];
693                    if (b.IsChecked != null && (bool) b.IsChecked)
694                    {
695                        SetupPage((XElement) b.Tag);
696                        break;
697                    }
698                }
699            }
700            else if (inputPanel.Visibility == Visibility.Visible)
701            {
702                foreach (var child in inputStack.Children)
703                {
704                    SaveControlContent(child);
705                }
706                var nextElement = (XElement) inputPanel.Tag;
707                SetupPage(nextElement);
708            }
709
710            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardNext2");
711            mainGridStoryboardLeft.Begin();
712        }
713
714        private void SaveControlContent(object o)
715        {
716            if (o is TextBox || o is ComboBox || o is CheckBox)
717            {
718                Control c = (Control)o;
719                XElement ele = (XElement)c.Tag;
720                var id = GetElementID(ele);
721                PluginPropertyValue newEntry = new PluginPropertyValue();
722                if (ele.Attribute("plugin") != null && ele.Attribute("property") != null)
723                {
724                    if (o is TextBox)
725                    {
726                        TextBox textBox = (TextBox)o;
727                        newEntry = new PluginPropertyValue()
728                                   {
729                                       PluginName = ele.Attribute("plugin").Value,
730                                       PropertyName = ele.Attribute("property").Value,
731                                       Value = textBox.Text
732                                   };
733                    }
734                    else if (o is ComboBox)
735                    {
736                        ComboBox comboBox = (ComboBox)o;
737                        newEntry = new PluginPropertyValue()
738                        {
739                            PluginName = ele.Attribute("plugin").Value,
740                            PropertyName = ele.Attribute("property").Value,
741                            Value = comboBox.SelectedIndex
742                        };
743                    }
744                    else if (o is CheckBox)
745                    {
746                        CheckBox checkBox = (CheckBox)o;
747                        if (checkBox.IsChecked != null)
748                        {
749                            newEntry = new PluginPropertyValue()
750                            {
751                                PluginName = ele.Attribute("plugin").Value,
752                                PropertyName = ele.Attribute("property").Value,
753                                Value = (bool)checkBox.IsChecked
754                            };
755                        }
756                    }
757
758                    if (!propertyValueDict.ContainsKey(id))
759                        propertyValueDict.Add(id, newEntry);
760                    else
761                        propertyValueDict[id] = newEntry;
762                } 
763            }
764        }
765
766        private void DeleteControlContent(object o)
767        {
768            if (o is TextBox || o is ComboBox || o is CheckBox)
769            {
770                Control control = (Control)o;
771                XElement ele = (XElement)control.Tag;
772                var id = GetElementID(ele);
773
774                if (propertyValueDict.ContainsKey(id))
775                    propertyValueDict.Remove(id);
776            }
777        }
778
779
780        private void SetLastContent(object sender, EventArgs e)
781        {
782            XElement ele = null;
783            if (categoryGrid.Visibility == Visibility.Visible && radioButtonStackPanel.Children.Count > 0)
784            {
785                RadioButton b = (RadioButton) radioButtonStackPanel.Children[0];
786                ele = (XElement) b.Tag;
787
788                foreach (RadioButton rb in radioButtonStackPanel.Children)
789                {
790                    if (rb.IsChecked != null && (bool)rb.IsChecked)
791                        rb.IsChecked = false;
792                }
793            }
794            else if (inputPanel.Visibility == Visibility.Visible)
795            {
796                //foreach (var child in inputStack.Children)
797                //{
798                //    DeleteControlContent(child);
799                //}
800                boxesWithWrongContent.Clear();
801
802                ele = (XElement) inputPanel.Tag;
803                if (((XElement)inputPanel.Tag).Name == "loadSample")
804                    SwitchNextButtonContent();
805            }
806
807            if (ele != null)
808            {
809                XElement grandParent = ele.Parent.Parent;
810                if (grandParent != null)
811                    SetupPage(grandParent);
812                else
813                    SetupPage(wizardConfigXML);
814            }
815
816            Storyboard mainGridStoryboardLeft = (Storyboard)FindResource("MainGridStoryboardBack2");
817            mainGridStoryboardLeft.Begin();
818        }
819
820        private void GuiLogMessage(string message, NotificationLevel loglevel)
821        {
822            if (OnGuiLogNotificationOccured != null)
823                OnGuiLogNotificationOccured(null, new GuiLogEventArgs(message, null, loglevel));
824        }
825
826        private void SwitchNextButtonContent()
827        {
828            var tmp = nextButton.Content;
829            nextButton.Content = nextButton.Tag;
830            nextButton.Tag = tmp;
831        }
832    }
833
834    internal struct PluginPropertyValue
835    {
836        public string PluginName;
837        public string PropertyName;
838        public object Value;
839    }
840}
Note: See TracBrowser for help on using the repository browser.