Task/MainWindowViewModel.cs at master · dimOk00/Task · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;

namespace TreeViewMVVMBinding
{
    public class MainWindowViewModel : ViewModelBase
    {
        static int controlINdex = 1;

        ObservableCollection<Group> groups;

        public MainWindowViewModel()
        {
            Groups = new ObservableCollection<Group>()
            {
                new Group("Group 1", new ObservableCollection<MyControl>
                {
                    new MyControl("Control 1", "Role 1", "Value 1")
                })
            };
        }

        public ObservableCollection<Group> Groups
        {
            get
            {
                return groups;
            }
            set
            {
                groups = value;
                OnPropertyChanged("Groups");
            }
        }

        private RelayCommand addGroupCommand;
        public RelayCommand AddGroupCommand
        {
            get
            {
                return addGroupCommand ??
                    (addGroupCommand = new RelayCommand(obj =>
                    {
                        int groupsCount = Groups.Count;
                        Group group = new Group($"Group {++groupsCount}");
                        Groups.Add(group);
                    }));
            }
        }

        private RelayCommand addControlCommand;
        public RelayCommand AddControlCommand
        {
            get
            {
                return addControlCommand ??
                    (addControlCommand = new RelayCommand(obj =>
                    {
                        Group selectedGroup = obj as Group;
                        if (selectedGroup != null)
                        {
                            if(selectedGroup.MyControls == null)
                            {
                                selectedGroup.MyControls = new ObservableCollection<MyControl>();
                            }
                            selectedGroup.MyControls.Add(new MyControl($"Control {++controlINdex}", $"Role  {controlINdex}", $"Value  {controlINdex}"));
                        }
                    }));
            }
        }

        private RelayCommand removeGroupControl;
        public RelayCommand RemoveGroupControl
        {
            get
            {
                return removeGroupControl ??
                    (removeGroupControl = new RelayCommand(obj =>
                    {
                        if (obj is Group)
                        {
                            groups.Remove(obj as Group);
                        }
                        else if (obj is MyControl)
                        {
                            MyControl control = obj as MyControl;
                            foreach (var group in Groups)
                            {
                                if (group.MyControls.Contains(control))
                                {
                                    group.MyControls.Remove(control);
                                    return;
                                }

                            }
                        }
                    }));
            }
        }

        private RelayCommand highlight;
        public RelayCommand Highlight
        {
            get
            {
                return highlight ??
                    (highlight = new RelayCommand(obj =>
                    {


                    }));
            }
        }
    }
}