← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/Main/Base/Project/Src/Project/Converter/UpgradeView.xaml.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Main/Base/Project/Src/Project/Converter/UpgradeView.xaml.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using System.ComponentModel;
 
7
using System.Linq;
 
8
using System.Windows;
 
9
using System.Windows.Controls;
 
10
 
 
11
using ICSharpCode.Core.Presentation;
 
12
 
 
13
namespace ICSharpCode.SharpDevelop.Project.Converter
 
14
{
 
15
        /// <summary>
 
16
        /// Interaction logic for UpgradeView.xaml
 
17
        /// </summary>
 
18
        internal partial class UpgradeView : UserControl
 
19
        {
 
20
                readonly Solution solution;
 
21
                readonly List<Entry> entries;
 
22
                
 
23
                public UpgradeView(Solution solution)
 
24
                {
 
25
                        if (solution == null)
 
26
                                throw new ArgumentNullException("solution");
 
27
                        this.solution = solution;
 
28
                        InitializeComponent();
 
29
                        
 
30
                        this.entries = solution.Projects.OfType<IUpgradableProject>().Select(p => new Entry(p)).ToList();
 
31
                        listView.ItemsSource = entries;
 
32
                        SortableGridViewColumn.SetCurrentSortColumn(listView, nameColumn);
 
33
                        SortableGridViewColumn.SetSortDirection(listView, ColumnSortDirection.Ascending);
 
34
                        ListView_SelectionChanged(null, null);
 
35
                }
 
36
                
 
37
                public bool UpgradeViewOpenedAutomatically {
 
38
                        get { return upgradeDescription.Visibility == Visibility.Visible; }
 
39
                        set { upgradeDescription.Visibility = value ? Visibility.Visible : Visibility.Collapsed; }
 
40
                }
 
41
                
 
42
                public Solution Solution {
 
43
                        get { return solution; }
 
44
                }
 
45
                
 
46
                public void Select(IUpgradableProject project)
 
47
                {
 
48
                        foreach (Entry entry in entries) {
 
49
                                if (entry.Project == project)
 
50
                                        listView.SelectedItem = entry;
 
51
                        }
 
52
                }
 
53
                
 
54
                void SelectAllCheckBox_Checked(object sender, RoutedEventArgs e)
 
55
                {
 
56
                        listView.SelectAll();
 
57
                }
 
58
                
 
59
                void SelectAllCheckBox_Unchecked(object sender, RoutedEventArgs e)
 
60
                {
 
61
                        listView.SelectedItems.Clear();
 
62
                }
 
63
                
 
64
                void ListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
 
65
                {
 
66
                        if (listView.SelectedItems.Count == listView.ItemsSource.Cast<Entry>().Count())
 
67
                                selectAllCheckBox.IsChecked = true;
 
68
                        else if (listView.SelectedItems.Count == 0)
 
69
                                selectAllCheckBox.IsChecked = false;
 
70
                        else
 
71
                                selectAllCheckBox.IsChecked = null;
 
72
                        
 
73
                        conversionGroupBox.IsEnabled = listView.SelectedItems.Count > 0;
 
74
                        UpdateCompilerComboBox();
 
75
                }
 
76
                
 
77
                void UpdateCompilerComboBox()
 
78
                {
 
79
                        if (listView.SelectedItems.Count > 0) {
 
80
                                // Fetch list of available compiler versions
 
81
                                HashSet<CompilerVersion> availableVersionsSet = new HashSet<CompilerVersion>();
 
82
                                HashSet<CompilerVersion> currentVersions = new HashSet<CompilerVersion>();
 
83
                                foreach (Entry entry in listView.SelectedItems) {
 
84
                                        if (entry.CompilerVersion != null)
 
85
                                                currentVersions.Add(entry.CompilerVersion);
 
86
                                        availableVersionsSet.AddRange(entry.Project.GetAvailableCompilerVersions());
 
87
                                }
 
88
                                List<CompilerVersion> availableVersions = availableVersionsSet.OrderBy(n => n.MSBuildVersion).ThenBy(n => n.DisplayName).ToList();
 
89
                                if (currentVersions.Count != 1) {
 
90
                                        availableVersions.Insert(0, new UnchangedCompilerVersion());
 
91
                                }
 
92
                                // Assign available versions to newVersionComboBox
 
93
                                // Unless the user has already chosen a version, automatically set the selection to the
 
94
                                // current version of the chosen projects, or to 'do not change' if there are different
 
95
                                // current versions.
 
96
                                newCompilerSelectionChangingByCode = true;
 
97
                                newVersionComboBox.ItemsSource = availableVersions;
 
98
                                
 
99
                                CompilerVersion oldSelectedVersion = newVersionComboBox.SelectedValue as CompilerVersion;
 
100
                                if (!newCompilerSelectionSetByUser || oldSelectedVersion == null) {
 
101
                                        newCompilerSelectionSetByUser = false;
 
102
                                        if (currentVersions.Count == 1)
 
103
                                                newVersionComboBox.SelectedValue = currentVersions.Single();
 
104
                                        else
 
105
                                                newVersionComboBox.SelectedValue = new UnchangedCompilerVersion();
 
106
                                }
 
107
                                newCompilerSelectionChangingByCode = false;
 
108
                                UpdateTargetFrameworkComboBox();
 
109
                        }
 
110
                }
 
111
                
 
112
                bool newCompilerSelectionChangingByCode;
 
113
                bool newCompilerSelectionSetByUser;
 
114
                
 
115
                void newVersionComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
 
116
                {
 
117
                        if (!newCompilerSelectionChangingByCode)
 
118
                                newCompilerSelectionSetByUser = true;
 
119
                        UpdateTargetFrameworkComboBox();
 
120
                }
 
121
                
 
122
                void UpdateTargetFrameworkComboBox()
 
123
                {
 
124
                        // Determine the available target frameworks
 
125
                        List<TargetFramework> availableFrameworks;
 
126
                        bool doNotChangeAllowed;
 
127
                        CompilerVersion selectedCompiler = newVersionComboBox.SelectedValue as CompilerVersion;
 
128
                        if (selectedCompiler == null || selectedCompiler is UnchangedCompilerVersion) {
 
129
                                // no entries or "Do not change" selected
 
130
                                // -> available target frameworks is the intersection of all compiler's target framework,
 
131
                                // and "Do not change" is always available
 
132
                                
 
133
                                var supportedTargetFrameworks =
 
134
                                        from Entry entry in listView.SelectedItems
 
135
                                        where entry.CompilerVersion != null
 
136
                                        select entry.CompilerVersion.GetSupportedTargetFrameworks();
 
137
                                
 
138
                                if (supportedTargetFrameworks.Any()) {
 
139
                                        availableFrameworks = supportedTargetFrameworks.Aggregate((a, b) => a.Intersect(b)).ToList();
 
140
                                } else {
 
141
                                        availableFrameworks = new List<TargetFramework>();
 
142
                                }
 
143
                                doNotChangeAllowed = true;
 
144
                        } else {
 
145
                                // Specific compiler version is selected
 
146
                                // Show that compiler's target frameworks
 
147
                                availableFrameworks = selectedCompiler.GetSupportedTargetFrameworks().ToList();
 
148
                                // Allow do not change on target framework if all current frameworks are supported
 
149
                                // by the new compiler.
 
150
                                doNotChangeAllowed = true;
 
151
                                foreach (Entry entry in listView.SelectedItems) {
 
152
                                        doNotChangeAllowed &= availableFrameworks.Contains(entry.TargetFramework);
 
153
                                }
 
154
                        }
 
155
                        
 
156
                        availableFrameworks.Sort((a, b) => a.DisplayName.CompareTo(b.DisplayName));
 
157
                        if (doNotChangeAllowed) {
 
158
                                availableFrameworks.Insert(0, new UnchangedTargetFramework());
 
159
                        }
 
160
                        
 
161
                        // detect whether all projects use a single framework
 
162
                        TargetFramework frameworkUsedByAllProjects = null;
 
163
                        bool frameworkUsedByAllProjectsInitialized = false;
 
164
                        foreach (Entry entry in listView.SelectedItems) {
 
165
                                if (!frameworkUsedByAllProjectsInitialized) {
 
166
                                        frameworkUsedByAllProjects = entry.TargetFramework;
 
167
                                        frameworkUsedByAllProjectsInitialized = true;
 
168
                                } else {
 
169
                                        if (!object.Equals(frameworkUsedByAllProjects, entry.TargetFramework))
 
170
                                                frameworkUsedByAllProjects = null;
 
171
                                }
 
172
                        }
 
173
                        
 
174
                        // if projects use different frameworks, preselect "<do not change>", if possible
 
175
                        if (frameworkUsedByAllProjects == null && doNotChangeAllowed)
 
176
                                frameworkUsedByAllProjects = availableFrameworks[0];
 
177
                        
 
178
                        newFrameworkSelectionChangingByCode = true;
 
179
                        newFrameworkComboBox.ItemsSource = availableFrameworks;
 
180
                        
 
181
                        TargetFramework oldSelectedFramework = newFrameworkComboBox.SelectedValue as TargetFramework;
 
182
                        if (!newFrameworkSelectionSetByUser || oldSelectedFramework == null) {
 
183
                                newFrameworkSelectionSetByUser = false;
 
184
                                newFrameworkComboBox.SelectedValue = frameworkUsedByAllProjects;
 
185
                        }
 
186
                        newFrameworkSelectionChangingByCode = false;
 
187
                        UpdateConvertButtonEnabled();
 
188
                }
 
189
                
 
190
                bool newFrameworkSelectionChangingByCode;
 
191
                bool newFrameworkSelectionSetByUser;
 
192
                
 
193
                void newFrameworkComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
 
194
                {
 
195
                        if (!newFrameworkSelectionChangingByCode)
 
196
                                newFrameworkSelectionSetByUser = true;
 
197
                        UpdateConvertButtonEnabled();
 
198
                }
 
199
                
 
200
                void UpdateConvertButtonEnabled()
 
201
                {
 
202
                        CompilerVersion selectedCompiler = newVersionComboBox.SelectedValue as CompilerVersion;
 
203
                        TargetFramework selectedFramework = newFrameworkComboBox.SelectedValue as TargetFramework;
 
204
                        
 
205
                        bool changingCompiler = false;
 
206
                        bool changingFramework = false;
 
207
                        if (!(selectedCompiler is UnchangedCompilerVersion)) {
 
208
                                foreach (Entry entry in listView.SelectedItems) {
 
209
                                        if (!object.Equals(entry.CompilerVersion, selectedCompiler))
 
210
                                                changingCompiler = true;
 
211
                                }
 
212
                        }
 
213
                        if (!(selectedFramework is UnchangedTargetFramework)) {
 
214
                                foreach (Entry entry in listView.SelectedItems) {
 
215
                                        if (!object.Equals(entry.TargetFramework, selectedFramework))
 
216
                                                changingFramework = true;
 
217
                                }
 
218
                        }
 
219
                        
 
220
                        convertButton.IsEnabled = selectedCompiler != null && selectedFramework != null && (changingCompiler || changingFramework);
 
221
                }
 
222
                
 
223
                void convertButton_Click(object sender, RoutedEventArgs e)
 
224
                {
 
225
                        Core.AnalyticsMonitorService.TrackFeature(GetType(), "convertButton_Click");
 
226
                        
 
227
                        CompilerVersion selectedCompiler = newVersionComboBox.SelectedValue as CompilerVersion;
 
228
                        TargetFramework selectedFramework = newFrameworkComboBox.SelectedValue as TargetFramework;
 
229
                        if (selectedCompiler is UnchangedCompilerVersion)
 
230
                                selectedCompiler = null;
 
231
                        if (selectedFramework is UnchangedTargetFramework)
 
232
                                selectedFramework = null;
 
233
                        
 
234
                        
 
235
                        foreach (Entry entry in listView.SelectedItems) {
 
236
                                entry.UpgradeProject(selectedCompiler, selectedFramework);
 
237
                        }
 
238
                        solution.Save();
 
239
                        UpdateCompilerComboBox();
 
240
                }
 
241
                
 
242
                sealed class UnchangedCompilerVersion : CompilerVersion
 
243
                {
 
244
                        public UnchangedCompilerVersion() : base(new Version(0, 0), Core.StringParser.Parse("${res:ICSharpCode.SharpDevelop.Project.UpgradeView.DoNotChange}"))
 
245
                        {
 
246
                        }
 
247
                        
 
248
                        public override bool Equals(object obj)
 
249
                        {
 
250
                                return obj is UnchangedCompilerVersion;
 
251
                        }
 
252
                        
 
253
                        public override int GetHashCode()
 
254
                        {
 
255
                                return 0;
 
256
                        }
 
257
                }
 
258
                
 
259
                sealed class UnchangedTargetFramework : TargetFramework
 
260
                {
 
261
                        public UnchangedTargetFramework() : base(string.Empty, Core.StringParser.Parse("${res:ICSharpCode.SharpDevelop.Project.UpgradeView.DoNotChange}"))
 
262
                        {
 
263
                        }
 
264
                        
 
265
                        public override bool Equals(object obj)
 
266
                        {
 
267
                                return obj is UnchangedTargetFramework;
 
268
                        }
 
269
                        
 
270
                        public override int GetHashCode()
 
271
                        {
 
272
                                return 0;
 
273
                        }
 
274
                }
 
275
                
 
276
                internal sealed class Entry : INotifyPropertyChanged
 
277
                {
 
278
                        public readonly IUpgradableProject Project;
 
279
                        
 
280
                        public Entry(IUpgradableProject project)
 
281
                        {
 
282
                                this.Project = project;
 
283
                                
 
284
                                this.CompilerVersion = project.CurrentCompilerVersion;
 
285
                                this.TargetFramework = project.CurrentTargetFramework;
 
286
                        }
 
287
                        
 
288
                        public string Name {
 
289
                                get { return this.Project.Name; }
 
290
                        }
 
291
                        
 
292
                        public override string ToString()
 
293
                        {
 
294
                                return this.Name;
 
295
                        }
 
296
                        
 
297
                        public CompilerVersion CompilerVersion;
 
298
                        public TargetFramework TargetFramework;
 
299
                        
 
300
                        public string CompilerVersionName {
 
301
                                get { return CompilerVersion != null ? CompilerVersion.DisplayName : null; }
 
302
                        }
 
303
                        
 
304
                        public string TargetFrameworkName {
 
305
                                get { return TargetFramework != null ? TargetFramework.DisplayName : null; }
 
306
                        }
 
307
                        
 
308
                        public void UpgradeProject(CompilerVersion newVersion, TargetFramework newFramework)
 
309
                        {
 
310
                                this.Project.UpgradeProject(newVersion, newFramework);
 
311
                                
 
312
                                this.CompilerVersion = this.Project.CurrentCompilerVersion;
 
313
                                this.TargetFramework = this.Project.CurrentTargetFramework;
 
314
                                OnPropertyChanged("CompilerVersionName");
 
315
                                OnPropertyChanged("TargetFrameworkName");
 
316
                        }
 
317
                        
 
318
                        public event PropertyChangedEventHandler PropertyChanged;
 
319
                        
 
320
                        void OnPropertyChanged(string propertyName)
 
321
                        {
 
322
                                if (PropertyChanged != null) {
 
323
                                        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
 
324
                                }
 
325
                        }
 
326
                }
 
327
        }
 
328
}