/****************************************************************************
|
**
|
** Copyright (C) 2020 The Qt Company Ltd.
|
** Contact: https://www.qt.io/licensing/
|
**
|
** This file is part of the Qt VS Tools.
|
**
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
** Commercial License Usage
|
** Licensees holding valid commercial Qt licenses may use this file in
|
** accordance with the commercial license agreement provided with the
|
** Software or, alternatively, in accordance with the terms contained in
|
** a written agreement between you and The Qt Company. For licensing terms
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
** information use the contact form at https://www.qt.io/contact-us.
|
**
|
** GNU General Public License Usage
|
** Alternatively, this file may be used under the terms of the GNU
|
** General Public License version 3 as published by the Free Software
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
** included in the packaging of this file. Please review the following
|
** information to ensure the GNU General Public License requirements will
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
**
|
** $QT_END_LICENSE$
|
**
|
****************************************************************************/
|
|
using System;
|
using System.Collections.Generic;
|
using System.Drawing;
|
using System.IO;
|
using System.Linq;
|
using System.Windows;
|
using System.Windows.Controls;
|
using System.Windows.Interop;
|
using System.Windows.Media;
|
using System.Windows.Media.Imaging;
|
using Microsoft.Win32;
|
using QtVsTools.Common;
|
|
namespace QtVsTools.Wizards.ProjectWizard
|
{
|
using QtVsTools.Core;
|
|
public partial class ConfigPage : WizardPage
|
{
|
interface ICloneable<T> where T : ICloneable<T>
|
{
|
T Clone();
|
}
|
|
class Module : ICloneable<Module>
|
{
|
public string Name { get; set; }
|
public string Id { get; set; }
|
public bool IsSelected { get; set; }
|
public bool IsReadOnly { get; set; }
|
public bool IsEnabled => !IsReadOnly;
|
|
public Module Clone()
|
{
|
return new Module
|
{
|
Name = Name,
|
Id = Id,
|
IsSelected = IsSelected,
|
IsReadOnly = IsReadOnly
|
};
|
}
|
}
|
|
class Config : ICloneable<Config>, IWizardConfiguration
|
{
|
public string Name { get; set; }
|
public VersionInformation QtVersion { get; set; }
|
public string QtVersionName { get; set; }
|
public string QtVersionPath { get; set; }
|
public string Target { get; set; }
|
public string Platform { get; set; }
|
public bool IsDebug { get; set; }
|
|
public Dictionary<string, Module> Modules { get; set; }
|
|
public IEnumerable<Module> AllModules
|
=> Modules.Values;
|
public IEnumerable<Module> SelectedModules
|
=> Modules.Values.Where((Module m) => m.IsSelected);
|
|
IEnumerable<string> IWizardConfiguration.Modules
|
=> SelectedModules.SelectMany((Module m) => m.Id.Split(' '));
|
|
public Config Clone()
|
{
|
return new Config
|
{
|
Name = Name,
|
QtVersion = QtVersion,
|
QtVersionName = QtVersionName,
|
Target = Target,
|
Platform = Platform,
|
IsDebug = IsDebug,
|
Modules = AllModules
|
.Select((Module m) => m.Clone())
|
.ToDictionary((Module m) => m.Name)
|
};
|
}
|
}
|
|
class CloneableList<T> : List<T> where T : ICloneable<T>
|
{
|
public CloneableList() : base()
|
{ }
|
|
public CloneableList(IEnumerable<T> collection) : base(collection)
|
{ }
|
|
public CloneableList<T> Clone()
|
{
|
return new CloneableList<T>(this.Select(x => x.Clone()));
|
}
|
}
|
|
const string QT_VERSION_DEFAULT = "<Default>";
|
const string QT_VERSION_BROWSE = "<Browse...>";
|
|
IEnumerable<string> qtVersionList = new[] { QT_VERSION_DEFAULT, QT_VERSION_BROWSE }
|
.Union(QtVersionManager.The().GetVersions());
|
|
QtVersionManager qtVersionManager = QtVersionManager.The();
|
VersionInformation defaultQtVersionInfo;
|
|
CloneableList<Config> defaultConfigs;
|
List<Config> currentConfigs;
|
bool initialNextButtonIsEnabled;
|
bool initialFinishButtonIsEnabled;
|
|
public ConfigPage()
|
{
|
InitializeComponent();
|
|
string defaultQtVersionName = qtVersionManager.GetDefaultVersion();
|
defaultQtVersionInfo = qtVersionManager.GetVersionInfo(defaultQtVersionName);
|
|
ErrorIcon.Source = Imaging.CreateBitmapSourceFromHIcon(
|
SystemIcons.Exclamation.Handle, Int32Rect.Empty,
|
BitmapSizeOptions.FromEmptyOptions());
|
|
DataContext = this;
|
Loaded += OnLoaded;
|
}
|
|
void OnLoaded(object sender, RoutedEventArgs e)
|
{
|
Loaded -= OnLoaded;
|
|
var qtModules = QtModules.Instance.GetAvailableModules()
|
.Where((QtModule mi) => mi.Selectable)
|
.Select((QtModule mi) => new Module()
|
{
|
Name = mi.Name,
|
Id = mi.proVarQT,
|
IsSelected = Data.DefaultModules.Contains(mi.LibraryPrefix),
|
IsReadOnly = Data.DefaultModules.Contains(mi.LibraryPrefix),
|
});
|
|
qtVersionList = new[] { QT_VERSION_DEFAULT, QT_VERSION_BROWSE }
|
.Union(QtVersionManager.The().GetVersions());
|
|
if (defaultQtVersionInfo == null) {
|
Validate();
|
return;
|
}
|
|
defaultConfigs = new CloneableList<Config> {
|
new Config {
|
Name = "Debug",
|
IsDebug = true,
|
QtVersion = defaultQtVersionInfo,
|
QtVersionName = defaultQtVersionInfo.name,
|
Target = defaultQtVersionInfo.isWinRT()
|
? ProjectTargets.WindowsStore.Cast<string>()
|
: ProjectTargets.Windows.Cast<string>(),
|
Platform = defaultQtVersionInfo.is64Bit()
|
? ProjectPlatforms.X64.Cast<string>()
|
: ProjectPlatforms.Win32.Cast<string>(),
|
Modules = qtModules.ToDictionary((Module m) => m.Name),
|
},
|
new Config {
|
Name = "Release",
|
IsDebug = false,
|
QtVersion = defaultQtVersionInfo,
|
QtVersionName = defaultQtVersionInfo.name,
|
Target = defaultQtVersionInfo.isWinRT()
|
? ProjectTargets.WindowsStore.Cast<string>()
|
: ProjectTargets.Windows.Cast<string>(),
|
Platform = defaultQtVersionInfo.is64Bit()
|
? ProjectPlatforms.X64.Cast<string>()
|
: ProjectPlatforms.Win32.Cast<string>(),
|
Modules = qtModules.ToDictionary((Module m) => m.Name),
|
}
|
};
|
currentConfigs = defaultConfigs.Clone();
|
ConfigTable.ItemsSource = currentConfigs;
|
|
initialNextButtonIsEnabled = NextButton.IsEnabled;
|
initialFinishButtonIsEnabled = FinishButton.IsEnabled;
|
|
Validate();
|
}
|
|
/// <summary>
|
/// Callback to validate selected configurations.
|
/// Must return an error message in case of failed validation.
|
/// Otherwise, return empty string or null.
|
/// </summary>
|
public Func<IEnumerable<IWizardConfiguration>, string> ValidateConfigs { get; set; }
|
|
void Validate()
|
{
|
if (currentConfigs == null) {
|
ErrorMsg.Content = "Register at least one Qt version using \"Qt VS Tools\"" +
|
" -> \"Qt Options\".";
|
ErrorPanel.Visibility = Visibility.Visible;
|
NextButton.IsEnabled = false;
|
FinishButton.IsEnabled = false;
|
} else if (currentConfigs // "$(Configuration)|$(Platform)" must be unique
|
.GroupBy((Config c) => string.Format("{0}|{1}", c.Name, c.Platform))
|
.Where((IGrouping<string, Config> g) => g.Count() > 1)
|
.Any()) {
|
ErrorMsg.Content = "(Configuration, Platform) must be unique";
|
ErrorPanel.Visibility = Visibility.Visible;
|
NextButton.IsEnabled = false;
|
FinishButton.IsEnabled = false;
|
} else if (ValidateConfigs != null
|
&& ValidateConfigs(currentConfigs) is string errorMsg
|
&& !string.IsNullOrEmpty(errorMsg)) {
|
ErrorMsg.Content = errorMsg;
|
ErrorPanel.Visibility = Visibility.Visible;
|
NextButton.IsEnabled = false;
|
FinishButton.IsEnabled = false;
|
} else {
|
ErrorMsg.Content = string.Empty;
|
ErrorPanel.Visibility = Visibility.Hidden;
|
NextButton.IsEnabled = initialNextButtonIsEnabled;
|
FinishButton.IsEnabled = initialFinishButtonIsEnabled;
|
}
|
}
|
|
void RemoveConfig_Click(object sender, RoutedEventArgs e)
|
{
|
if (sender is Button buttonRemove
|
&& GetBinding(buttonRemove) is Config config) {
|
currentConfigs.Remove(config);
|
if (!currentConfigs.Any()) {
|
currentConfigs = defaultConfigs.Clone();
|
ConfigTable.ItemsSource = currentConfigs;
|
}
|
ConfigTable.Items.Refresh();
|
Validate();
|
}
|
}
|
|
void DuplicateConfig_Click(object sender, RoutedEventArgs e)
|
{
|
if (sender is Button buttonDuplicate
|
&& GetBinding(buttonDuplicate) is Config config) {
|
currentConfigs.Add(config.Clone());
|
ConfigTable.Items.Refresh();
|
Validate();
|
}
|
}
|
|
void Name_TextChanged(object sender, TextChangedEventArgs e)
|
{
|
if (sender is TextBox txt && GetBinding(txt) is Config cfg)
|
cfg.Name = txt.Text;
|
Validate();
|
}
|
|
void QtVersion_ComboBox_Loaded(object sender, RoutedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxQtVersion
|
&& GetBinding(comboBoxQtVersion) is Config config) {
|
comboBoxQtVersion.IsEnabled = false;
|
comboBoxQtVersion.ItemsSource = qtVersionList;
|
comboBoxQtVersion.Text = config.QtVersionName;
|
comboBoxQtVersion.IsEnabled = true;
|
}
|
}
|
|
void QtVersion_TextChanged(object sender, TextChangedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxQtVersion
|
&& comboBoxQtVersion.IsEnabled
|
&& GetBinding(comboBoxQtVersion) is Config config
|
&& config.QtVersionName != comboBoxQtVersion.Text) {
|
var oldQtVersion = config.QtVersion;
|
if (comboBoxQtVersion.Text == QT_VERSION_DEFAULT) {
|
config.QtVersion = defaultQtVersionInfo;
|
config.QtVersionName = defaultQtVersionInfo.name;
|
config.QtVersionPath = defaultQtVersionInfo.qtDir;
|
comboBoxQtVersion.Text = defaultQtVersionInfo.name;
|
} else if (comboBoxQtVersion.Text == QT_VERSION_BROWSE) {
|
var openFileDialog = new OpenFileDialog
|
{
|
Filter = "qmake (qmake.exe)|qmake.exe"
|
};
|
if (openFileDialog.ShowDialog() == true) {
|
IEnumerable<string> binPath = Path.GetDirectoryName(openFileDialog.FileName)
|
.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
|
string lastDirName = binPath.LastOrDefault();
|
if ("bin".Equals(lastDirName, StringComparison.InvariantCultureIgnoreCase))
|
binPath = binPath.Take(binPath.Count() - 1);
|
|
var qtVersion = string.Join(
|
Path.DirectorySeparatorChar.ToString(), binPath);
|
var versionInfo = VersionInformation.Get(qtVersion);
|
if (versionInfo != null) {
|
versionInfo.name = qtVersion;
|
config.QtVersion = versionInfo;
|
config.QtVersionName = versionInfo.name;
|
config.QtVersionPath = config.QtVersion.qtDir;
|
}
|
}
|
comboBoxQtVersion.Text = config.QtVersionName;
|
} else if (qtVersionManager.GetVersions().Contains(comboBoxQtVersion.Text)) {
|
config.QtVersion = qtVersionManager.GetVersionInfo(comboBoxQtVersion.Text);
|
config.QtVersionName = comboBoxQtVersion.Text;
|
config.QtVersionPath = qtVersionManager.GetInstallPath(comboBoxQtVersion.Text);
|
} else {
|
config.QtVersion = null;
|
config.QtVersionName = config.QtVersionPath = comboBoxQtVersion.Text;
|
}
|
|
if (oldQtVersion != config.QtVersion) {
|
if (config.QtVersion != null) {
|
config.Target = config.QtVersion.isWinRT()
|
? ProjectTargets.WindowsStore.Cast<string>()
|
: ProjectTargets.Windows.Cast<string>();
|
config.Platform = config.QtVersion.is64Bit()
|
? ProjectPlatforms.X64.Cast<string>()
|
: ProjectPlatforms.Win32.Cast<string>();
|
} else if (config.QtVersionPath.StartsWith("SSH:")) {
|
config.Target = ProjectTargets.LinuxSSH.Cast<string>();
|
} else if (config.QtVersionPath.StartsWith("WSL:")) {
|
config.Target = ProjectTargets.LinuxWSL.Cast<string>();
|
}
|
ConfigTable.Items.Refresh();
|
}
|
Validate();
|
}
|
}
|
|
void Target_ComboBox_Loaded(object sender, RoutedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxTarget
|
&& GetBinding(comboBoxTarget) is Config config) {
|
comboBoxTarget.IsEnabled = false;
|
comboBoxTarget.ItemsSource = EnumExt.GetValues<string>(typeof(ProjectTargets));
|
comboBoxTarget.Text = config.Target;
|
comboBoxTarget.IsEnabled = true;
|
}
|
}
|
|
void Target_TextChanged(object sender, TextChangedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxTarget
|
&& comboBoxTarget.IsEnabled
|
&& GetBinding(comboBoxTarget) is Config config
|
&& config.Target != comboBoxTarget.Text) {
|
config.Target = comboBoxTarget.Text;
|
ConfigTable.Items.Refresh();
|
Validate();
|
}
|
}
|
|
void Platform_ComboBox_Loaded(object sender, RoutedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxPlatform
|
&& GetBinding(comboBoxPlatform) is Config config) {
|
comboBoxPlatform.IsEnabled = false;
|
comboBoxPlatform.ItemsSource = EnumExt.GetValues<string>(typeof(ProjectPlatforms));
|
comboBoxPlatform.Text = config.Platform;
|
comboBoxPlatform.IsEnabled = true;
|
}
|
}
|
|
void Platform_TextChanged(object sender, TextChangedEventArgs e)
|
{
|
if (sender is ComboBox comboBoxPlatform
|
&& comboBoxPlatform.IsEnabled
|
&& GetBinding(comboBoxPlatform) is Config config
|
&& config.Platform != comboBoxPlatform.Text) {
|
config.Platform = comboBoxPlatform.Text;
|
ConfigTable.Items.Refresh();
|
Validate();
|
}
|
}
|
|
void Debug_Click(object sender, RoutedEventArgs e)
|
{
|
if (sender is CheckBox checkBox && GetBinding(checkBox) is Config config) {
|
config.IsDebug = checkBox.IsChecked ?? false;
|
if (config.IsDebug && config.Name.EndsWith("Release")) {
|
config.Name = string.Format("{0}Debug",
|
config.Name.Substring(0, config.Name.Length - "Release".Length));
|
ConfigTable.Items.Refresh();
|
} else if (!config.IsDebug && config.Name.EndsWith("Debug")) {
|
config.Name = string.Format("{0}Release",
|
config.Name.Substring(0, config.Name.Length - "Debug".Length));
|
ConfigTable.Items.Refresh();
|
}
|
Validate();
|
}
|
}
|
|
void Module_Click(object sender, RoutedEventArgs e)
|
{
|
if (sender is CheckBox checkBoxModule
|
&& (checkBoxModule.TemplatedParent as ContentPresenter)?.Content is Module module
|
&& GetBinding(checkBoxModule) is Config config
|
&& FindAncestor(checkBoxModule, "Modules") is ComboBox comboBoxModules
|
&& FindDescendant(comboBoxModules, "SelectedModules") is ListView selectedModules) {
|
selectedModules.ItemsSource = config.SelectedModules;
|
Validate();
|
}
|
}
|
|
protected override void OnNextButtonClick(object sender, RoutedEventArgs e)
|
{
|
Data.Configs = currentConfigs.Cast<IWizardConfiguration>();
|
base.OnNextButtonClick(sender, e);
|
}
|
|
protected override void OnFinishButtonClick(object sender, RoutedEventArgs e)
|
{
|
Data.Configs = currentConfigs.Cast<IWizardConfiguration>();
|
base.OnFinishButtonClick(sender, e);
|
}
|
|
static object GetBinding(FrameworkElement control)
|
{
|
if (control.BindingGroup == null
|
|| control.BindingGroup.Items == null
|
|| control.BindingGroup.Items.Count == 0) {
|
return null;
|
}
|
return control.BindingGroup.Items[0];
|
}
|
|
static FrameworkElement FindAncestor(FrameworkElement control, string name)
|
{
|
while (control != null && control.Name != name) {
|
object parent = control.Parent
|
?? control.TemplatedParent
|
?? VisualTreeHelper.GetParent(control);
|
control = parent as FrameworkElement;
|
}
|
return control;
|
}
|
|
static FrameworkElement FindDescendant(FrameworkElement control, string name)
|
{
|
var stack = new Stack<FrameworkElement>(new[] { control });
|
while (stack.Any()) {
|
control = stack.Pop();
|
if (control?.Name == name && control is FrameworkElement result)
|
return result;
|
for (int i = 0; i < VisualTreeHelper.GetChildrenCount(control); ++i) {
|
if (VisualTreeHelper.GetChild(control, i) is FrameworkElement child)
|
stack.Push(child);
|
}
|
}
|
return null;
|
}
|
}
|
}
|
