dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-05-19 12:30:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
Cosmos/source/Archive/Cosmos.VS.ProjectSystem/PropertyPages/CosmosPage.cs

954 lines
33 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using Cosmos.Build.Common;
using Cosmos.VS.Package;
using Microsoft.VisualBasic;
using DebugMode = Cosmos.Build.Common.DebugMode;
namespace Cosmos.VS.ProjectSystem.PropertyPages
{
// We put all items on ONE form because VS is such a C++ developers wet dream to manage mulitple pages
// and add new ones.
// We use our own profiles instead of Project Configrations because:
// -Couldnt find a proper way to tell VS there are no configuration independent pages. The MPF way (as well as
// 0 sized array) both don't work.
// -When we assign our own project configuration types and the solution configurations refer to now non existent
// project configurations, there are errors.
//
// BOTH of the above probably could be solved with some digging. BUT in the end we learned that project configs
// really wont do what we want. For the user to change the active config for a *single* project they would need
// to change it manually in the solution config, or maintain on solution config for every project config type.
// Maintaining so many solution configs is not only impractical but causes a whole bunch of other issues.
//
// So instead we keep our own list of profiles, and when the user selects them we write out a copy of its values
// to the active configuration (all since we are not configuration dependent) for MSBuild and other code to use.
[Guid(Guids.guidCosmosPropertyPageString)]
public partial class CosmosPage : CustomPropertyPage
{
protected class ProfileItem
{
public string Prefix;
public string Name;
public bool IsPreset;
public override string ToString()
{
return Name;
}
}
protected ProfilePresets mPresets = new ProfilePresets();
protected int mVMwareAndBochsDebugPipe;
protected int mHyperVDebugPipe;
protected bool mShowTabBochs;
protected bool mShowTabDebug;
protected bool mShowTabDeployment;
protected bool mShowTabLaunch;
protected bool mShowTabVMware;
protected bool mShowTabHyperV;
protected bool mShowTabPXE;
protected bool mShowTabUSB;
protected bool mShowTabISO;
protected bool mShowTabSlave;
protected bool FreezeEvents;
public CosmosPage()
{
InitializeComponent();
# region Profile
butnProfileClone.Click += new EventHandler(butnProfileClone_Click);
butnProfileDelete.Click += new EventHandler(butnProfileDelete_Click);
butnProfileRename.Click += new EventHandler(butnProfileRename_Click);
lboxProfile.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
var xProfile = (ProfileItem)lboxProfile.SelectedItem;
if (xProfile.Prefix != mProps.Profile)
{
// Save existing profile
mProps.SaveProfile(mProps.Profile);
// Load newly selected profile
mProps.LoadProfile(xProfile.Prefix);
mProps.Profile = xProfile.Prefix;
IsDirty = true;
UpdateUI();
}
};
#endregion
# region Deploy
lboxDeployment.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
var xValue = (DeploymentType)((EnumValue)lboxDeployment.SelectedItem).Value;
if (xValue != mProps.Deployment)
{
mProps.Deployment = xValue;
IsDirty = true;
}
};
#endregion
# region Launch
lboxLaunch.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
var xValue = (LaunchType)((EnumValue)lboxLaunch.SelectedItem).Value;
if (xValue != mProps.Launch)
{
mProps.Launch = xValue;
IsDirty = true;
// Bochs requires an ISO. Force Deployment property.
if (LaunchType.Bochs == xValue)
{
if (DeploymentType.ISO != mProps.Deployment)
{
foreach (EnumValue scannedValue in lboxDeployment.Items)
{
if (DeploymentType.ISO == (DeploymentType)scannedValue.Value)
{
lboxDeployment.SelectedItem = scannedValue;
break;
}
}
}
}
}
};
#endregion
#region Compile
comboFramework.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var value = (Framework)((EnumValue)comboFramework.SelectedItem).Value;
if (value != mProps.Framework)
{
mProps.Framework = value;
IsDirty = true;
}
};
comboBinFormat.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var value = (BinFormat)((EnumValue)comboBinFormat.SelectedItem).Value;
if (value != mProps.BinFormat)
{
mProps.BinFormat = value;
IsDirty = true;
}
};
textOutputPath.TextChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
string value = textOutputPath.Text;
if (!string.Equals(value, mProps.OutputPath, StringComparison.InvariantCultureIgnoreCase))
{
mProps.OutputPath = textOutputPath.Text;
IsDirty = true;
}
};
#endregion
#region Assembler
checkUseInternalAssembler.CheckedChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
bool value = checkUseInternalAssembler.Checked;
if (value != mProps.UseInternalAssembler)
{
mProps.UseInternalAssembler = value;
IsDirty = true;
}
};
#endregion
#region VMware
cmboVMwareEdition.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (VMwareEdition)((EnumValue)cmboVMwareEdition.SelectedItem).Value;
if (x != mProps.VMwareEdition)
{
mProps.VMwareEdition = x;
IsDirty = true;
}
};
#endregion
#region PXE
comboPxeInterface.TextChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = comboPxeInterface.Text.Trim();
if (x != mProps.PxeInterface)
{
mProps.PxeInterface = x;
IsDirty = true;
}
};
cmboSlavePort.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (string)cmboSlavePort.SelectedItem;
if (x != mProps.SlavePort)
{
mProps.SlavePort = x;
IsDirty = true;
}
};
butnPxeRefresh.Click += new EventHandler(butnPxeRefresh_Click);
#endregion
#region Debug
comboDebugMode.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (Cosmos.Build.Common.DebugMode)((EnumValue)comboDebugMode.SelectedItem).Value;
if (x != mProps.DebugMode)
{
mProps.DebugMode = x;
IsDirty = true;
}
};
chckEnableDebugStub.CheckedChanged += delegate (object aSender, EventArgs e)
{
if (FreezeEvents) return;
panlDebugSettings.Enabled = chckEnableDebugStub.Checked;
mProps.DebugEnabled = chckEnableDebugStub.Checked;
IsDirty = true;
};
comboTraceMode.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (TraceAssemblies)((EnumValue)comboTraceMode.SelectedItem).Value;
if (x != mProps.TraceAssemblies)
{
mProps.TraceAssemblies = x;
IsDirty = true;
}
};
checkIgnoreDebugStubAttribute.CheckedChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
bool x = checkIgnoreDebugStubAttribute.Checked;
if (x != mProps.IgnoreDebugStubAttribute)
{
mProps.IgnoreDebugStubAttribute = x;
IsDirty = true;
}
};
cmboCosmosDebugPort.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (string)cmboCosmosDebugPort.SelectedItem;
if (x != mProps.CosmosDebugPort)
{
mProps.CosmosDebugPort = x;
IsDirty = true;
}
};
cmboVisualStudioDebugPort.SelectedIndexChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
var x = (string)cmboVisualStudioDebugPort.SelectedItem;
if (x != mProps.VisualStudioDebugPort)
{
mProps.VisualStudioDebugPort = x;
IsDirty = true;
}
};
checkEnableGDB.CheckedChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
bool x = checkEnableGDB.Checked;
if (x != mProps.EnableGDB)
{
mProps.EnableGDB = x;
IsDirty = true;
}
checkStartCosmosGDB.Enabled = x;
checkStartCosmosGDB.Checked = x;
};
checkStartCosmosGDB.CheckedChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
bool x = checkStartCosmosGDB.Checked;
if (x != mProps.StartCosmosGDB)
{
mProps.StartCosmosGDB = x;
IsDirty = true;
}
};
checkEnableBochsDebug.CheckedChanged += delegate (Object sender, EventArgs e)
{
if (FreezeEvents) return;
bool x = checkEnableBochsDebug.Checked;
if (x != mProps.EnableBochsDebug)
{
mProps.EnableBochsDebug = x;
IsDirty = true;
}
checkStartBochsDebugGui.Enabled = x;
if (x == false)
{
checkStartBochsDebugGui.Checked = x;
}
};
checkStartBochsDebugGui.CheckedChanged += delegate (object sender, EventArgs e)
{
if (FreezeEvents) return;
bool x = checkStartBochsDebugGui.Checked;
if (x != mProps.StartBochsDebugGui)
{
mProps.StartBochsDebugGui = x;
IsDirty = true;
}
};
#endregion
}
public override void ApplyChanges()
{
// Save now, because when we reload this form it will
// reload out of the saved profile and trash any changes
// in the active area.
mProps.SaveProfile(mProps.Profile);
base.ApplyChanges();
}
protected void RemoveTab(TabPage aTab)
{
if (TabControl1.TabPages.Contains(aTab))
{
TabControl1.TabPages.Remove(aTab);
}
}
protected void UpdateTabs()
{
var xTab = TabControl1.SelectedTab;
RemoveTab(tabDebug);
RemoveTab(tabDeployment);
RemoveTab(tabLaunch);
RemoveTab(tabVMware);
RemoveTab(tabHyperV);
RemoveTab(tabPXE);
RemoveTab(tabUSB);
RemoveTab(tabISO);
RemoveTab(tabSlave);
RemoveTab(tabBochs);
if (mShowTabDebug)
{
TabControl1.TabPages.Add(tabDebug);
}
if (mShowTabDeployment)
{
TabControl1.TabPages.Add(tabDeployment);
}
if (mShowTabPXE)
{
TabControl1.TabPages.Add(tabPXE);
}
if (mShowTabUSB)
{
TabControl1.TabPages.Add(tabUSB);
}
if (mShowTabISO)
{
TabControl1.TabPages.Add(tabISO);
}
if (mShowTabLaunch)
{
TabControl1.TabPages.Add(tabLaunch);
}
if (mShowTabVMware)
{
TabControl1.TabPages.Add(tabVMware);
}
if (mShowTabHyperV)
{
TabControl1.TabPages.Add(tabHyperV);
}
if (mShowTabSlave)
{
TabControl1.TabPages.Add(tabSlave);
}
if (mShowTabBochs)
{
TabControl1.TabPages.Add(tabBochs);
}
if (TabControl1.TabPages.Contains(xTab))
{
TabControl1.SelectedTab = xTab;
}
else
{
TabControl1.SelectedTab = tabProfile;
}
}
protected void UpdatePresetsUI()
{
FreezeEvents = true;
mShowTabDebug = true;
cmboCosmosDebugPort.Enabled = true;
cmboVisualStudioDebugPort.Enabled = true;
if (mProps.Profile == "ISO")
{
mShowTabDebug = false;
}
else if (mProps.Profile == "USB")
{
mShowTabDebug = false;
mShowTabUSB = true;
}
else if (mProps.Profile == "VMware")
{
mShowTabVMware = true;
chckEnableDebugStub.Checked = true;
chkEnableStackCorruptionDetection.Checked = true;
cmboCosmosDebugPort.Enabled = false;
cmboVisualStudioDebugPort.Enabled = false;
cmboVisualStudioDebugPort.SelectedIndex = mVMwareAndBochsDebugPipe;
}
else if (mProps.Profile == "HyperV")
{
mShowTabHyperV = true;
chckEnableDebugStub.Checked = true;
chkEnableStackCorruptionDetection.Checked = true;
cmboCosmosDebugPort.Enabled = false;
cmboVisualStudioDebugPort.Enabled = false;
cmboVisualStudioDebugPort.SelectedIndex = mHyperVDebugPipe;
}
else if (mProps.Profile == "PXE")
{
chckEnableDebugStub.Checked = false;
}
else if (mProps.Profile == "Bochs")
{
mShowTabBochs = true;
chckEnableDebugStub.Checked = true;
chkEnableStackCorruptionDetection.Checked = true;
cmboCosmosDebugPort.Enabled = false;
cmboVisualStudioDebugPort.Enabled = false;
cmboVisualStudioDebugPort.SelectedIndex = mVMwareAndBochsDebugPipe;
}
else if (mProps.Profile == "IntelEdison")
{
mShowTabBochs = false;
mShowTabVMware = false;
cmboVisualStudioDebugPort.Enabled = false;
}
FreezeEvents = false;
}
protected void UpdateUI()
{
UpdatePresetsUI();
var xProfile = (ProfileItem)lboxProfile.SelectedItem;
if (xProfile == null)
{
return;
}
if (mShowTabDebug == false)
{
chckEnableDebugStub.Checked = false;
}
lablCurrentProfile.Text = xProfile.Name;
lablDeployText.Text = mProps.Description;
lboxDeployment.SelectedItem = mProps.Deployment;
// Launch
lboxLaunch.SelectedItem = mProps.Launch;
lablBuildOnly.Visible = mProps.Launch == LaunchType.None;
lboxDeployment.SelectedItem = EnumValue.Find(lboxDeployment.Items, mProps.Deployment);
lboxLaunch.SelectedItem = EnumValue.Find(lboxLaunch.Items, mProps.Launch);
cmboVMwareEdition.SelectedItem = EnumValue.Find(cmboVMwareEdition.Items, mProps.VMwareEdition);
chckEnableDebugStub.Checked = mProps.DebugEnabled;
chkEnableStackCorruptionDetection.Checked = mProps.StackCorruptionDetectionEnabled;
comboStackCorruptionDetectionLevel.SelectedItem = EnumValue.Find(comboStackCorruptionDetectionLevel.Items, mProps.StackCorruptionDetectionLevel);
panlDebugSettings.Enabled = mProps.DebugEnabled;
cmboCosmosDebugPort.SelectedIndex = cmboCosmosDebugPort.Items.IndexOf(mProps.CosmosDebugPort);
if (!String.IsNullOrWhiteSpace(mProps.VisualStudioDebugPort))
{
cmboVisualStudioDebugPort.SelectedIndex =
cmboVisualStudioDebugPort.Items.IndexOf(mProps.VisualStudioDebugPort);
}
textOutputPath.Text = mProps.OutputPath;
comboFramework.SelectedItem = EnumValue.Find(comboFramework.Items, mProps.Framework);
comboBinFormat.SelectedItem = EnumValue.Find(comboBinFormat.Items, mProps.BinFormat);
checkUseInternalAssembler.Checked = mProps.UseInternalAssembler;
checkEnableGDB.Checked = mProps.EnableGDB;
checkStartCosmosGDB.Checked = mProps.StartCosmosGDB;
checkEnableBochsDebug.Checked = mProps.EnableBochsDebug;
checkStartBochsDebugGui.Checked = mProps.StartBochsDebugGui;
// Locked to COM1 for now.
//cmboCosmosDebugPort.SelectedIndex = 0;
#region Slave
cmboSlavePort.SelectedIndex = cmboSlavePort.Items.IndexOf(mProps.SlavePort);
#endregion
checkIgnoreDebugStubAttribute.Checked = mProps.IgnoreDebugStubAttribute;
comboDebugMode.SelectedItem = EnumValue.Find(comboDebugMode.Items, mProps.DebugMode);
comboTraceMode.SelectedItem = EnumValue.Find(comboTraceMode.Items, mProps.TraceAssemblies);
lablPreset.Visible = xProfile.IsPreset;
mShowTabDeployment = !xProfile.IsPreset;
mShowTabLaunch = !xProfile.IsPreset;
//
mShowTabISO = mProps.Deployment == DeploymentType.ISO;
mShowTabUSB = mProps.Deployment == DeploymentType.USB;
mShowTabPXE = mProps.Deployment == DeploymentType.PXE;
//
mShowTabVMware = mProps.Launch == LaunchType.VMware;
mShowTabHyperV = mProps.Launch == LaunchType.HyperV;
mShowTabSlave = mProps.Launch == LaunchType.Slave;
mShowTabBochs = (LaunchType.Bochs == mProps.Launch);
//
UpdateTabs();
}
protected int FillProfile(string aPrefix, string aName)
{
var xProfile = new ProfileItem { Prefix = aPrefix, Name = aName, IsPreset = true };
return lboxProfile.Items.Add(xProfile);
}
protected int FillProfile(int aID)
{
var xProfile = new ProfileItem { Prefix = "User" + aID.ToString("000"), IsPreset = false };
xProfile.Name = mProps.GetProperty(xProfile.Prefix + "_Name");
return lboxProfile.Items.Add(xProfile);
}
protected void FillProfiles()
{
lboxProfile.Items.Clear();
foreach (var xPreset in mPresets)
{
FillProfile(xPreset.Key, xPreset.Value);
}
for (int i = 1; i < 100; i++)
{
if (!string.IsNullOrEmpty(mProps.GetProperty("User" + i.ToString("000") + "_Name")))
{
FillProfile(i);
}
}
}
void butnProfileRename_Click(object sender, EventArgs e)
{
var xItem = (ProfileItem)lboxProfile.SelectedItem;
if (xItem == null)
{
// This should be impossible, but we check for it anwyays.
}
else if (xItem.IsPreset)
{
MessageBox.Show("Preset profiles cannot be renamed.");
}
else
{
string xName = Interaction.InputBox("Profile Name", "Rename Profile", mProps.Name);
if (xName != "")
{
IsDirty = true;
mProps.Name = xName;
xItem.Name = xName;
typeof(ListBox).InvokeMember(
"RefreshItems",
BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod,
null,
lboxProfile,
new object[] { });
}
}
}
void butnProfileDelete_Click(object sender, EventArgs e)
{
var xItem = (ProfileItem)lboxProfile.SelectedItem;
if (xItem == null)
{
// This should be impossible, but we check for it anwyays.
}
else if (xItem.IsPreset)
{
MessageBox.Show("Preset profiles cannot be deleted.");
}
else if (MessageBox.Show("Delete profile '" + xItem.Name + "'?", "", MessageBoxButtons.YesNo)
== DialogResult.Yes)
{
IsDirty = true;
// Select a new profile first, so the selectchange logic wont barf
lboxProfile.SelectedIndex = 0;
lboxProfile.Items.Remove(xItem);
mProps.DeleteProfile(xItem.Prefix);
}
}
void butnProfileClone_Click(object sender, EventArgs e)
{
var xItem = (ProfileItem)lboxProfile.SelectedItem;
if (xItem == null)
{
// This should be impossible, but we check for it anwyays.
return;
}
int xID;
string xPrefix = null;
for (xID = 1; xID < 100; xID++)
{
xPrefix = "User" + xID.ToString("000");
if (mProps.GetProperty(xPrefix + "_Name") == "")
{
break;
}
}
if (xID == 100)
{
MessageBox.Show("No more profile space is available.");
return;
}
IsDirty = true;
mProps.Name = xItem.Prefix + " User " + xID.ToString("000");
mProps.Description = "";
mProps.SaveProfile(xPrefix);
lboxProfile.SelectedIndex = FillProfile(xID);
}
void butnPxeRefresh_Click(object sender, EventArgs e)
{
FillNetworkInterfaces();
}
protected BuildProperties mProps = new BuildProperties();
public override PropertiesBase Properties
{
get
{
return mProps;
}
}
/// <summary>
/// Load project independent properties.
/// </summary>
protected void LoadProjectProps()
{
foreach (var propertyName in mProps.ProjectIndependentProperties)
{
var propertyValue = ProjectMgr.GetProjectProperty(propertyName);
mProps.SetProperty(propertyName, propertyValue);
}
}
/// <summary>
/// Load properties for the given profile.
/// </summary>
/// <param name="aPrefix">Name of the profile for which load properties.</param>
protected void LoadProfileProps(string aPrefix)
{
string xPrefix = aPrefix + (aPrefix == "" ? "" : "_");
foreach (var xName in BuildProperties.PropNames)
{
if (!mProps.ProjectIndependentProperties.Contains(xName))
{
string xValue = ProjectConfigs[0].GetConfigurationProperty(xPrefix + xName, false);
// This is important that we dont copy empty values, so instead the defaults will be used.
if (!string.IsNullOrWhiteSpace(xValue))
{
mProps.SetProperty(xPrefix + xName, xValue);
}
}
}
}
protected void LoadProps()
{
// Load mProps from project config file.
// The reason for loading into mProps seems to be so we can track changes, and cancel if necessary.
mProps.Reset();
// Reset cache only on first one
// Get selected profile
mProps.SetProperty(
BuildPropertyNames.ProfileString,
ProjectConfigs[0].GetConfigurationProperty(BuildPropertyNames.ProfileString, true));
LoadProjectProps();
// Load selected profile props
LoadProfileProps("");
foreach (var xPreset in mPresets)
{
LoadProfileProps(xPreset.Key);
}
for (int i = 1; i < 100; i++)
{
string xPrefix = "User" + i.ToString("000");
if (!string.IsNullOrWhiteSpace(ProjectConfigs[0].GetConfigurationProperty(xPrefix + "_Name", false)))
{
LoadProfileProps(xPrefix);
}
}
}
protected override void FillProperties()
{
base.FillProperties();
LoadProps();
FillProfiles();
foreach (ProfileItem xItem in lboxProfile.Items)
{
if (xItem.Prefix == mProps.Profile)
{
lboxProfile.SelectedItem = xItem;
break;
}
}
lboxDeployment.Items.AddRange(EnumValue.GetEnumValues(typeof(DeploymentType), true));
comboFramework.Items.AddRange(EnumValue.GetEnumValues(typeof(Framework), true));
comboBinFormat.Items.AddRange(EnumValue.GetEnumValues(typeof(BinFormat), true));
lboxLaunch.Items.AddRange(EnumValue.GetEnumValues(typeof(LaunchType), true));
#region VMware
cmboVMwareEdition.Items.AddRange(EnumValue.GetEnumValues(typeof(VMwareEdition), true));
#endregion
#region Debug
cmboCosmosDebugPort.Items.Clear();
FillComPorts(cmboCosmosDebugPort.Items);
cmboVisualStudioDebugPort.Items.Clear();
FillComPorts(cmboVisualStudioDebugPort.Items);
mVMwareAndBochsDebugPipe = cmboVisualStudioDebugPort.Items.Add(@"Pipe: Cosmos\Serial");
mHyperVDebugPipe = cmboVisualStudioDebugPort.Items.Add(@"Pipe: CosmosSerial");
comboDebugMode.Items.AddRange(EnumValue.GetEnumValues(typeof(DebugMode), false));
comboTraceMode.Items.AddRange(EnumValue.GetEnumValues(typeof(TraceAssemblies), false));
comboStackCorruptionDetectionLevel.Items.AddRange(EnumValue.GetEnumValues(typeof(StackCorruptionDetectionLevel), true));
#endregion
#region PXE
FillNetworkInterfaces();
cmboSlavePort.Items.Clear();
cmboSlavePort.Items.Add("None");
FillComPorts(cmboSlavePort.Items);
#endregion
UpdateUI();
}
protected void FillComPorts(System.Collections.IList aList)
{
//TODO http://stackoverflow.com/questions/2937585/how-to-open-a-serial-port-by-friendly-name
foreach (string xPort in SerialPort.GetPortNames())
{
aList.Add("Serial: " + xPort);
}
}
protected void FillNetworkInterfaces()
{
comboPxeInterface.Items.Clear();
comboPxeInterface.Items.AddRange(GetNetworkInterfaces().ToArray());
if (mProps.PxeInterface == String.Empty)
{
if (comboPxeInterface.Items.Count > 0)
{
comboPxeInterface.Text = comboPxeInterface.Items[0].ToString();
}
else
{
comboPxeInterface.Text = "192.168.42.1";
}
}
else
{
comboPxeInterface.Text = mProps.PxeInterface;
}
}
protected List<string> GetNetworkInterfaces()
{
NetworkInterface[] nInterfaces = NetworkInterface.GetAllNetworkInterfaces();
List<string> interfaces_list = new List<string>();
foreach (NetworkInterface nInterface in nInterfaces)
{
if (nInterface.OperationalStatus == OperationalStatus.Up)
{
IPInterfaceProperties ipProperties = nInterface.GetIPProperties();
foreach (var ip in ipProperties.UnicastAddresses)
{
if (ip.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
interfaces_list.Add(ip.Address.ToString());
}
}
}
}
return interfaces_list;
}
private void OutputBrowse_Click(object sender, EventArgs e)
{
string folderPath = String.Empty;
var dialog = new FolderBrowserDialog();
dialog.ShowNewFolderButton = true;
folderPath = textOutputPath.Text;
if ((String.IsNullOrEmpty(folderPath) == false)
&& (folderPath.IndexOfAny(System.IO.Path.GetInvalidPathChars()) == -1))
{
if (System.IO.Path.IsPathRooted(folderPath) == false)
{
folderPath = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(Project.FullName), folderPath);
}
while ((System.IO.Directory.Exists(folderPath) == false) && (String.IsNullOrEmpty(folderPath) == false))
{
int index = -1;
index =
folderPath.IndexOfAny(
new Char[] { System.IO.Path.PathSeparator, System.IO.Path.AltDirectorySeparatorChar });
if (index > -1)
{
folderPath = folderPath.Substring(0, index - 1);
}
else
{
folderPath = String.Empty;
}
}
if (String.IsNullOrEmpty(folderPath) == true)
{
folderPath = System.IO.Path.GetDirectoryName(Project.FullName);
}
}
else
{
folderPath = System.IO.Path.GetDirectoryName(Project.FullName);
}
dialog.SelectedPath = folderPath;
dialog.Description = "Select build output path";
if (dialog.ShowDialog() == DialogResult.OK)
{
textOutputPath.Text = dialog.SelectedPath;
}
}
private void chkEnableStacckCorruptionDetection_CheckedChanged(object sender, EventArgs e)
{
if (!FreezeEvents)
{
IsDirty = true;
mProps.StackCorruptionDetectionEnabled = chkEnableStackCorruptionDetection.Checked;
comboStackCorruptionDetectionLevel.Enabled = mProps.StackCorruptionDetectionEnabled;
}
}
private void stackCorruptionDetectionLevelComboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (!FreezeEvents)
{
var x = (StackCorruptionDetectionLevel)((EnumValue) comboStackCorruptionDetectionLevel.SelectedItem).Value;
if (x != mProps.StackCorruptionDetectionLevel)
{
mProps.StackCorruptionDetectionLevel = x;
IsDirty = true;
}
}
}
}
}
Reference in a new issue View git blame Copy permalink