internal void SaveSolutionProj(MFSolution solution)
{
if (!string.IsNullOrEmpty(solution.ProjectPath))
{
try
{
//if(File.Exists(solution.ProjectPath)
string fullpath = ExpandEnvVars(solution.ProjectPath, "");
Project proj = LoadProject(fullpath);
proj.ProjectCollection.UnloadProject(proj);
proj = new Project();
proj.Xml.DefaultTargets = "Build";
string dir = Path.GetDirectoryName(fullpath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
ProjectPropertyGroupElement mainGrp = proj.Xml.AddPropertyGroup();
mainGrp.AddProperty("Author", solution.Author);
mainGrp.AddProperty("Description", solution.Description);
mainGrp.AddProperty("Documentation", solution.Documentation);
mainGrp.AddProperty("PlatformGuid", solution.Guid);
if (solution.DefaultISA != null && solution.DefaultISA.Name != null)
{
ProjectPropertyElement bp = mainGrp.AddProperty("INSTRUCTION_SET", solution.DefaultISA.Name);
bp.Condition = solution.DefaultISA.Conditional;
}
mainGrp.AddProperty("TARGETPLATFORM", solution.Name);
mainGrp.AddProperty("PLATFORM", solution.Name);
mainGrp.AddProperty("IsSolutionWizardVisible", solution.IsSolutionWizardVisible.ToString());
mainGrp.AddProperty("ENDIANNESS", solution.ENDIANNESS.ToString());
Dictionary<string,object> nameLookup = new Dictionary<string,object>();
foreach (MFProperty prop in solution.Properties)
{
switch (prop.Name.ToLower())
{
case "author":
case "description":
case "documentation":
case "platformguid":
case "targetplatform":
case "platform":
case "issolutionwizardvisible":
case "endianness":
case "tcp_ip_stack":
case "instruction_set":
// these properties are reset in this method - this prevents duplication
break;
default:
string key = prop.Name.ToLower();
if(!nameLookup.ContainsKey(key))
{
ProjectPropertyElement bp = mainGrp.AddProperty(prop.Name, prop.Value);
bp.Condition = prop.Condition;
nameLookup[key] = bp;
}
break;
}
}
MFProject defProj = null;
foreach (MFProject prj in solution.Projects)
{
if (prj.IsClrProject)
{
defProj = prj;
break;
}
}
if (defProj != null)
{
///
/// If we have the LWIP feature project then we need to add the following property to the
/// solutions settings file
///
bool AddLWIP = false;
foreach (MFComponent f in defProj.Features)
{
if (f.Name.Equals("Network (RTIP)", StringComparison.InvariantCultureIgnoreCase))
{
AddLWIP = false;
break;
}
else if (f.Name.Equals("Network (LWIP)", StringComparison.InvariantCultureIgnoreCase))
{
AddLWIP = true;
}
}
if (AddLWIP)
{
mainGrp.AddProperty("TCP_IP_STACK", "LWIP");
}
}
ProjectItemGroupElement big = proj.Xml.AddItemGroup();
string solPath = RemoveSpoClient(Path.GetDirectoryName(solution.ProjectPath));
bool fFoundSolPath = false;
foreach (MFBuildFile item in solution.Items)
{
if (string.Equals(item.ItemName, "IncludePaths", StringComparison.InvariantCultureIgnoreCase) &&
string.Equals(item.File, solPath, StringComparison.InvariantCultureIgnoreCase))
{
fFoundSolPath = true;
}
ProjectItemElement bi = big.AddItem(item.ItemName, item.File);
bi.Condition = item.Condition;
}
if (!fFoundSolPath)
{
big.AddItem("IncludePaths", solPath);
}
Processor prc = null;
if (!string.IsNullOrEmpty(solution.Processor.Guid))
{
prc = m_helper.FindProcessor(solution.Processor.Guid);
}
else
{
prc = m_helper.FindProcessorByName(solution.Processor.Name);
if (prc != null)
{
solution.Processor.Guid = prc.Guid;
solution.Processor.Name = prc.Name;
solution.Processor.ProjectPath = prc.ProjectPath;
}
}
if (prc != null)
{
proj.Xml.AddImport(prc.ProjectPath);
}
proj.Save(fullpath);
if (solution.m_cloneSolution != null)
{
string cloneRoot = Path.GetDirectoryName(ExpandEnvVars(solution.m_cloneSolution.ProjectPath, "")) + "\\";
string newRoot = Path.GetDirectoryName(ExpandEnvVars(solution.ProjectPath, "")) + "\\";
CopyClonedFile(cloneRoot + "platform_selector.h", newRoot + "platform_selector.h", solution.m_cloneSolution.Name, solution.Name);
///
/// Copy the LWIP_selector file for the cloned solution
///
if (File.Exists(cloneRoot + "lwip_selector.h"))
{
CopyClonedFile(cloneRoot + "lwip_selector.h", newRoot + "lwip_selector.h", solution.m_cloneSolution.Name, solution.Name);
}
//CopyClonedFile(cloneRoot + "dotnetmf.proj", newRoot + "dotnetmf.proj", solution.m_cloneSolution.Name, solution.Name);
//CopyClonedFiles(cloneRoot + "DeviceCode\\", newRoot + "DeviceCode\\", solution.m_cloneSolution.Name, solution.Name);
}
///
/// copy the generic lwip_selector file in the case the cloned solution doesn't have one or we are creating a
/// new solution with LWIP
///
if (!File.Exists(Path.Combine(dir, "lwip_selector.h")))
{
string lwipSel = ExpandEnvVars("$(SPOCLIENT)\\DeviceCode\\PAL\\LWIP\\Config\\lwip_selector.h", "");
if (File.Exists(lwipSel) && defProj != null)
{
foreach (MFComponent f in defProj.Features)
{
if (f.Name.Equals("Network (LWIP)", StringComparison.InvariantCultureIgnoreCase))
{
CopyClonedFile(lwipSel, Path.Combine(dir, "lwip_selector.h"), "<TEMPLATE>", solution.Name);
break;
}
}
}
}
string platSelectorFile = Path.Combine(dir, "platform_selector.h");
bool fNewSelector = false;
if (!File.Exists(platSelectorFile))
{
Processor proc = m_helper.FindProcessor(solution.Processor.Guid);
if(proc != null)
{
string template = Path.GetDirectoryName(ExpandEnvVars(proc.ProjectPath, "")) + "\\" + proc.Name + "_template_selector.h";
string newRoot = Path.GetDirectoryName(ExpandEnvVars(solution.ProjectPath, "")) + "\\";
if (File.Exists(template))
{
CopyClonedFile(template, newRoot + "platform_selector.h", "<TEMPLATE>", solution.Name);
fNewSelector = true;
}
}
}
// only modify if we are cloning or creating a new solution
if (File.Exists(platSelectorFile))
{
if (fNewSelector || (solution.m_cloneSolution != null))
{
FileAttributes attribs = File.GetAttributes(platSelectorFile);
if (0 != (attribs & FileAttributes.ReadOnly))
{
throw new Exception("File Access Exception: File " + platSelectorFile + " is not accessible");
}
string tmpFile = Path.GetTempFileName();
using (TextWriter tw = File.CreateText(tmpFile))
{
using (TextReader tr = File.OpenText(platSelectorFile))
{
string data = tr.ReadToEnd();
Regex rx = new Regex("#define\\s+SYSTEM_CLOCK_HZ\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define SYSTEM_CLOCK_HZ " + solution.SystemClockSpeed.ToString());
rx = new Regex("#define\\s+SLOW_CLOCKS_PER_SECOND\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define SLOW_CLOCKS_PER_SECOND " + solution.SlowClockSpeed.ToString());
rx = new Regex("#define\\s+SRAM1_MEMORY_Base\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define SRAM1_MEMORY_Base 0x" + solution.RamBase.ToString("X08"));
rx = new Regex("#define\\s+SRAM1_MEMORY_Size\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define SRAM1_MEMORY_Size 0x" + solution.RamLength.ToString("X08"));
rx = new Regex("#define\\s+FLASH_MEMORY_Base\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define FLASH_MEMORY_Base 0x" + solution.FlashBase.ToString("X08"));
rx = new Regex("#define\\s+FLASH_MEMORY_Size\\s+[^\\r^\\n]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define FLASH_MEMORY_Size 0x" + solution.FlashLength.ToString("X08"));
rx = new Regex("#define\\s+DEBUG_TEXT_PORT\\s+[^\\s]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define DEBUG_TEXT_PORT " + solution.DebuggerPort);
rx = new Regex("#define\\s+STDIO\\s+[\\w\\d_]+");
data = rx.Replace(data, "#define STDIO " + solution.DebuggerPort);
rx = new Regex("#define\\s+DEBUGGER_PORT\\s+[^\\s]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define DEBUGGER_PORT " + solution.DebuggerPort);
rx = new Regex("#define\\s+MESSAGING_PORT\\s+[^\\s]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define MESSAGING_PORT " + solution.DebuggerPort);
rx = new Regex("#define\\s+RUNTIME_MEMORY_PROFILE__[\\w]+", RegexOptions.Singleline);
data = rx.Replace(data, "#define RUNTIME_MEMORY_PROFILE__" + solution.MemoryProfile);
tw.Write(data);
}
}
File.Delete(platSelectorFile);
File.Move(tmpFile, platSelectorFile);
}
}
else
{
using (TextWriter tw = File.CreateText(platSelectorFile))
{
tw.WriteLine(string.Format("#ifndef _PLATFORM_{0}_SELECTOR_H_\r\n#define _PLATFORM_{0}_SELECTOR_H_ 1", solution.Name));
tw.WriteLine(string.Format("#define HAL_SYSTEM_NAME \"{0}\"", solution.Name));
tw.WriteLine(string.Format("#define PLATFORM_{0} ", prc.Name.ToUpper()));
tw.WriteLine(string.Format("#define PLATFORM_{0}_{1}", prc.PlatformFamily.ToUpper(), prc.Name.ToUpper()));
tw.WriteLine(string.Format("#define PLATFORM_{0}_{1}", prc.PlatformFamily.ToUpper(), solution.Name.ToUpper()));
if (0 == string.Compare(prc.Name, "MC9328", true))
{
tw.WriteLine("#define PLATFORM_ARM_MC9328MXL");
}
tw.WriteLine("#define PLATFORM_SUPPORTS_SOFT_REBOOT TRUE");
tw.WriteLine(string.Format("#define SYSTEM_CLOCK_HZ {0}", solution.SystemClockSpeed));
tw.WriteLine(string.Format("#define SLOW_CLOCKS_PER_SECOND {0}", solution.SlowClockSpeed));
tw.WriteLine("#define CLOCK_COMMON_FACTOR 1");
tw.WriteLine("#define SLOW_CLOCKS_TEN_MHZ_GCD 1");
tw.WriteLine("#define SLOW_CLOCKS_MILLISECOND_GCD 1");
tw.WriteLine(string.Format("#define SRAM1_MEMORY_Base 0x{0:X08}", solution.RamBase));
tw.WriteLine(string.Format("#define SRAM1_MEMORY_Size 0x{0:X08}", solution.RamLength));
tw.WriteLine(string.Format("#define FLASH_MEMORY_Base 0x{0:X08}", solution.FlashBase));
tw.WriteLine(string.Format("#define FLASH_MEMORY_Size 0x{0:X08}", solution.FlashLength));
tw.WriteLine(@"
#define TXPROTECTRESISTOR RESISTOR_DISABLED
#define RXPROTECTRESISTOR RESISTOR_DISABLED
#define CTSPROTECTRESISTOR RESISTOR_DISABLED
#define RTSPROTECTRESISTOR RESISTOR_DISABLED
");
tw.WriteLine(@"
#define GLOBAL_LOCK(x) SmartPtr_IRQ x
#define DISABLE_INTERRUPTS() SmartPtr_IRQ::ForceDisabled()
#define ENABLE_INTERRUPTS() SmartPtr_IRQ::ForceEnabled()
#define INTERRUPTS_ENABLED_STATE() SmartPtr_IRQ::GetState()
#define GLOBAL_LOCK_SOCKETS(x) SmartPtr_IRQ x
#if defined(_DEBUG)
#define ASSERT_IRQ_MUST_BE_OFF() ASSERT(!SmartPtr_IRQ::GetState())
#define ASSERT_IRQ_MUST_BE_ON() ASSERT( SmartPtr_IRQ::GetState())
#else
#define ASSERT_IRQ_MUST_BE_OFF()
#define ASSERT_IRQ_MUST_BE_ON()
#endif
#define TOTAL_USART_PORT 1
#define COM1 ConvertCOM_ComHandle(0)
#define COM2 ConvertCOM_ComHandle(1)
#define TOTAL_USB_CONTROLLER 1
#define USB1 ConvertCOM_UsbHandle(0)
#define TOTAL_SOCK_PORT 0
#define TOTAL_DEBUG_PORT 1
#define COM_DEBUG ConvertCOM_DebugHandle(0)
#define COM_MESSAGING ConvertCOM_MessagingHandle(0)
#define USART_TX_IRQ_INDEX(x) ( (x) ? 0 : 0 ) // TODO set right indexes
#define USART_DEFAULT_PORT COM1
#define USART_DEFAULT_BAUDRATE 115200
#define USB_IRQ_INDEX 0 // TODO set right index
#define PLATFORM_DEPENDENT_TX_USART_BUFFER_SIZE 512 // there is one TX for each usart port
#define PLATFORM_DEPENDENT_RX_USART_BUFFER_SIZE 512 // there is one RX for each usart port
#define PLATFORM_DEPENDENT_USB_QUEUE_PACKET_COUNT 32 // there is one queue for each pipe of each endpoint and the size of a single packet is sizeof(USB_PACKET64) == 68 bytes
");
tw.WriteLine(string.Format("#define DEBUG_TEXT_PORT {0}", solution.DebuggerPort));
tw.WriteLine(string.Format("#define STDIO {0}", solution.DebuggerPort));
tw.WriteLine(string.Format("#define DEBUGGER_PORT {0}", solution.DebuggerPort));
tw.WriteLine(string.Format("#define MESSAGING_PORT {0}", solution.DebuggerPort));
tw.WriteLine(string.Format("#define RUNTIME_MEMORY_PROFILE__{0} 1", solution.MemoryProfile));
tw.WriteLine("#include <processor_selector.h>");
tw.WriteLine(string.Format("#endif // _PLATFORM_{0}_SELECTOR_H_ 1", solution.Name));
}
}
//foreach (MFProject prj in solution.Projects)
//{
// SaveProjectProj(prj);
//}
}
catch
{
Console.WriteLine("Error: Unable to save solution file " + solution.ProjectPath);
}
}
}
public List<MFComponentDescriptor> GetAvailableSolutions(string spoClientRoot)
{
List<MFComponentDescriptor> list = new List<MFComponentDescriptor>();
string fullpath = ExpandEnvVars(Path.Combine(spoClientRoot, "Solutions"), "");
foreach (string subdir in Directory.GetDirectories(fullpath))
{
foreach (string solution in Directory.GetFiles(subdir, "*.settings"))
{
try
{
Project proj = LoadProject(solution);
Processor proc = null;
MFSolution sol = new MFSolution();
Dictionary<string, string> tbl = new Dictionary<string, string>();
tbl["PLATFORM"] = "Name";
tbl["PlatformGuid"] = "Guid";
LoadStringProps(proj, sol, tbl);
foreach (ProjectImportElement imp in proj.Xml.Imports)
{
if (imp.Project.ToLower().Contains(@"\devicecode\targets\"))
{
proc = LoadProcessorProj(imp.Project, "");
}
}
if (sol.IsSolutionWizardVisible)
{
list.Add(new MFComponentDescriptor(new MFComponent(MFComponentType.MFSolution, sol.Name, sol.Guid, solution), sol.Description, sol.Documentation, proj.FullPath, proc));
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: loading solution file: " + solution + "\r\n", e.Message);
}
}
}
return list;
}
public MFSolution CloneSolution(MFSolution solution, string name)
{
MFSolution solNew = new MFSolution();
solution.CopyTo(solNew, name);
return solNew;
}
public Library[] GetLibrariesOfType(LibraryCategory LibraryCategory, MFProject proj, MFSolution solution)
{
List<Library> ret = new List<Library>();
foreach (Inventory inv in m_invs)
{
foreach (Library lib in inv.Libraries)
{
if (lib.LibraryCategory != null)
{
if (string.IsNullOrEmpty(lib.LibraryCategory.Guid)) continue;
if (0 == string.Compare(lib.LibraryCategory.Guid, LibraryCategory.Guid, true))
{
ret.Add(lib);
}
}
}
}
return ret.ToArray();
}
private void addPlatformToolStripMenuItem_Click(object sender, EventArgs e)
{
TreeNode parent = treeViewInventory.Nodes[0].Nodes["Solutions"];
MFSolution newPlat = new MFSolution();
newPlat.Guid = Guid.NewGuid().ToString("B").ToUpper();
TreeNode newNode = AddTreeElement(parent, "<New Solution>", newPlat, true, DefaultInventory.Solutions, c_defaultInventoryKey);
DefaultInventory.Solutions.Add(newPlat);
treeViewInventory.SelectedNode = newNode;
newNode.BeginEdit();
}
public void AnalyzeLibraries(InventoryHelper helper, MFSolution solution, List<LibraryCategory> unresolved, List<LibraryCategory> removed)
{
Dictionary<string, MFComponent> reqLibList = new Dictionary<string, MFComponent>();
Dictionary<string, MFComponent> unresolvedTypes = new Dictionary<string, MFComponent>();
List<MFComponent> features = new List<MFComponent>();
Dictionary<string, MFComponent> preferredLibrary = new Dictionary<string, MFComponent>();
Processor proc = helper.FindProcessor(solution.Processor.Guid);
libraryCategoriesField.Clear();
///
/// First add all the features and there dependencies
///
if (this.IsClrProject)
{
foreach (MFComponent cmpFeat in featuresField)
{
RecurseFeatureDeps(cmpFeat, features, helper);
}
///
/// get debug transport
///
if (solution.TransportType != null)
{
string key = solution.TransportType.Guid.ToLower();
foreach (MFComponent transportFeat in solution.TransportType.FeatureAssociations)
{
if (!features.Contains(transportFeat))
{
features.Add(transportFeat);
}
}
}
}
this.featuresField.Clear();
foreach (MFComponent cmpFeat in features)
{
Feature feat = helper.FindFeature(cmpFeat.Guid);
this.featuresField.Add(cmpFeat);
foreach (MFComponent cmp in feat.ComponentDependencies)
{
string key = cmp.Guid.ToLower();
if (cmp.ComponentType == MFComponentType.LibraryCategory)
{
if (!unresolvedTypes.ContainsKey(key))
{
unresolvedTypes[key] = cmp;
}
}
else if (cmp.ComponentType == MFComponentType.Library)
{
reqLibList[key] = cmp;
RecurseLibCatDeps(cmp, unresolvedTypes, helper, false);
}
}
}
///
/// Add any required libraries before analyzing all project libraries
///
foreach (Library lib in helper.GetRequiredLibraries())
{
// Only add CLR libraries to CLR projects
if (lib.Level == LibraryLevel.CLR && !this.IsClrProject)
continue;
string key = lib.Guid.ToLower();
if (!reqLibList.ContainsKey(key))
{
MFComponent cmpNew = new MFComponent(MFComponentType.Library, lib.Name, lib.Guid, lib.ProjectPath);
reqLibList[key] = cmpNew;
RecurseLibCatDeps(cmpNew, unresolvedTypes, helper, false);
}
}
///
/// Now add all required library categories
///
foreach (LibraryCategory lc in helper.GetRequiredLibraryCategories())
{
if (lc.Level == LibraryLevel.CLR && !this.isClrProjectField) continue;
string key = lc.Guid.ToLower();
if (!unresolvedTypes.ContainsKey(key))
{
MFComponent cmp = new MFComponent(MFComponentType.LibraryCategory, lc.Name, lc.Guid, lc.ProjectPath);
unresolvedTypes[lc.Guid.ToLower()] = cmp;
}
}
///
/// Add cloned solution's solution-dependent projects
///
if (solution.m_cloneSolution != null && m_cloneProj != null)
{
foreach (MFComponent lib in m_cloneProj.librariesField)
{
// If we have already added a library for the current solution, then just add a new component to the project
if (solution.m_clonedLibraryMap.ContainsKey(lib.Guid.ToUpper()))
{
Library newLib = solution.m_clonedLibraryMap[lib.Guid.ToUpper()];
librariesField.Add(new MFComponent(lib.ComponentType, newLib.Name, newLib.Guid, newLib.ProjectPath, lib.Conditional));
}
// otherwise, create a new library based on the cloned solution's library
else if (lib.ProjectPath.ToUpper().Contains("\\SOLUTIONS\\" + solution.m_cloneSolution.Name.ToUpper() + "\\"))
{
string name = CopyHelper.ReplaceText(lib.Name, solution.m_cloneSolution.Name, solution.Name);
string path = CopyHelper.ReplaceText(lib.ProjectPath, solution.m_cloneSolution.Name, solution.Name);
string guid = System.Guid.NewGuid().ToString("B").ToUpper();
// find cloned solution's library in the intventory
Library l = helper.FindLibrary(lib);
if (l != null)
{
Library l2 = new Library();
// copy and rename
l.CopyTo(l2);
CopyHelper.Rename(l2, solution.m_cloneSolution.Name, solution.Name);
l2.Name = name;
l2.Guid = guid;
l2.ProjectPath = path;
// add library to inventory
helper.AddLibraryToInventory(l2, false, helper.DefaultInventory);
// hash to used so that we don't add multiple libraries for each project
solution.m_clonedLibraryMap[lib.Guid.ToUpper()] = l2;
// Add the component to this projects library list
MFComponent newCmp = new MFComponent(lib.ComponentType, name, guid, path, lib.Conditional);
librariesField.Add(newCmp);
if (l.HasLibraryCategory)
{
preferredLibrary[l.LibraryCategory.Guid.ToLower()] = newCmp;
}
}
}
}
}
///
/// HACK - fix this to make it data driven (add a field on library categories that allows them to be required by a solution)
///
if (this.isClrProjectField)
{
LibraryCategory lc = helper.FindLibraryCategoryByName("WearLeveling_HAL");
if (lc != null)
{
string key = lc.Guid.ToLower();
if (unresolvedTypes.ContainsKey(key))
{
solution.m_solRequiredLibCats[key] = unresolvedTypes[key];
}
}
}
else if(solution.m_solRequiredLibCats != null)
{
foreach (MFComponent cmp in solution.m_solRequiredLibCats.Values)
{
string key = cmp.Guid.ToLower();
if (!unresolvedTypes.ContainsKey(key))
{
unresolvedTypes[key] = cmp;
}
}
}
///
/// Use a copy of the libraries, because the libraryField may be updated inside the loop
///
MFComponent[] __libs = new MFComponent[librariesField.Count];
librariesField.CopyTo(__libs);
List<MFComponent> libs = new List<MFComponent>(__libs);
Dictionary<string, MFComponent> resolvedTypes = new Dictionary<string, MFComponent>();
List<string> duplicateLibList = new List<string>();
while (true)
{
List<MFComponent> remList = new List<MFComponent>();
Dictionary<string, MFComponent> newUnresolvedTypes = new Dictionary<string, MFComponent>();
foreach (MFComponent cmpLib in libs)
{
Library lib = helper.FindLibrary(cmpLib);
bool fKeepingLib = false;
if (duplicateLibList.Contains(cmpLib.Guid.ToLower()) || lib == null || !ValidateLibrary(lib, solution, proc, helper))
{
librariesField.Remove(cmpLib);
remList.Add(cmpLib);
continue;
}
if (lib.HasLibraryCategory)
{
if (preferredLibrary.ContainsKey(lib.LibraryCategory.Guid.ToLower()) &&
string.Compare(cmpLib.Guid, preferredLibrary[lib.LibraryCategory.Guid.ToLower()].Guid, true) != 0)
{
fKeepingLib = true;
}
///
/// Make sure the library selection matches the feature selection
///
else if (this.isClrProjectField)
{
LibraryCategory lc = helper.FindLibraryCategory(lib.LibraryCategory.Guid);
if (lc != null)
{
if (lc.FeatureAssociations.Count > 0)
{
bool fFeatureSelected = false;
foreach (MFComponent feat in lc.FeatureAssociations)
{
if (features.Contains(feat))
{
fFeatureSelected = true;
break;
}
}
if (((!fFeatureSelected && !lib.IsStub) || (fFeatureSelected && lib.IsStub)) &&
string.IsNullOrEmpty(cmpLib.Conditional))
{
librariesField.Remove(cmpLib);
remList.Add(cmpLib);
continue;
}
}
}
}
if (!fKeepingLib)
{
string key = lib.LibraryCategory.Guid.ToLower();
if (unresolvedTypes.ContainsKey(key) || (!string.IsNullOrEmpty(cmpLib.Conditional) && resolvedTypes.ContainsKey(key)))
{
unresolvedTypes.Remove(key);
resolvedTypes[key] = lib.LibraryCategory;
fKeepingLib = true;
RecurseLibCatDeps(cmpLib, newUnresolvedTypes, helper, true);
}
}
}
else
{
fKeepingLib = true;
}
if (fKeepingLib)
{
remList.Add(cmpLib);
duplicateLibList.Add(cmpLib.Guid.ToLower());
foreach (MFComponent dep in lib.Dependencies)
{
if (dep.ComponentType == MFComponentType.Library)
{
if (duplicateLibList.Contains(dep.Guid.ToLower()) || librariesField.Contains(dep))
{
continue;
}
Library libDep = helper.FindLibrary(dep);
if (libDep != null && libDep.HasLibraryCategory)
{
string key = libDep.LibraryCategory.Guid.ToLower();
if(!unresolvedTypes.ContainsKey(key) && !resolvedTypes.ContainsKey(key) && !newUnresolvedTypes.ContainsKey(key))
{
newUnresolvedTypes[key] = libDep.LibraryCategory;
}
}
else
{
remList.Add(dep);
librariesField.Add(dep);
}
}
}
}
}
foreach (MFComponent cmp in remList)
{
if (libs.Contains(cmp))
{
libs.Remove(cmp);
}
}
if (newUnresolvedTypes.Count == 0) break;
foreach (string key in newUnresolvedTypes.Keys)
{
if (!unresolvedTypes.ContainsKey(key) && !resolvedTypes.ContainsKey(key))
{
unresolvedTypes[key] = newUnresolvedTypes[key];
}
}
}
foreach (MFComponent cmp in resolvedTypes.Values)
{
libraryCategoriesField.Add(cmp);
}
foreach (MFComponent cmp in libs)
{
librariesField.Remove(cmp);
}
foreach (MFComponent cmp in reqLibList.Values)
{
if (!librariesField.Contains(cmp))
{
Library lib = helper.FindLibrary(cmp);
if (lib != null && ValidateLibrary(lib, solution, proc, helper))
{
librariesField.Add(cmp);
}
}
}
foreach (MFComponent cmp in unresolvedTypes.Values)
{
LibraryCategory lc = helper.FindLibraryCategory(cmp.Guid);
unresolved.Add(lc);
}
}
public void CopyTo(MFSolution dest, string newName)
{
Dictionary<string, string> hash = new Dictionary<string, string>();
dest.m_cloneSolution = this;
hash[this.nameField] = newName;
hash[@"\$\(PLATFORM\)"] = newName;
hash[@"\$\(TARGETPLATFORM\)"] = newName;
CopyHelper.CopyTo(this, dest, hash);
}
internal void CopyProjFilesFromClone(MFProject proj, MFSolution solution)
{
if (proj.m_cloneProj != null)
{
string dirSource = MsBuildWrapper.ExpandEnvVars(Path.GetDirectoryName(proj.m_cloneProj.ProjectPath), "");
string dirTarg = MsBuildWrapper.ExpandEnvVars(Path.GetDirectoryName(proj.ProjectPath), "");
string dirSourceRoot = Path.GetDirectoryName(dirSource);
string dirTargRoot = Path.GetDirectoryName(dirTarg);
try
{
CopyClonedFiles(dirSourceRoot, dirTargRoot, solution.m_cloneSolution == null ? "$(PLATFORM)" : solution.m_cloneSolution.Name, solution.Name, false);
CopyClonedFiles(dirSource, dirTarg, solution.m_cloneSolution == null ? "$(PLATFORM)" : solution.m_cloneSolution.Name, solution.Name, true);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: Copying clone files\r\n\tsrc:" + dirSource + "\r\n\tdst:" + dirTarg + "\r\n", e.Message);
}
}
}
private void wpCreatePlatform_CloseFromNext(object sender, Gui.Wizard.PageEventArgs e)
{
MFSolution sol = null;
Regex expUnsupportedChars = new Regex("[^\\w\\d_]+");
if (expUnsupportedChars.IsMatch(tb_PlatformName.Text))
{
MessageBox.Show(this, Properties.Resources.InvalidSolutionName, Properties.Resources.SolutionWizard, MessageBoxButtons.OK, MessageBoxIcon.Error);
e.Page = wpCreatePlatform;
return;
}
if (m_IsSolutionCloned && (m_solution == null || m_solution.m_cloneSolution == null))
{
sol = new MFSolution();
m_solution.CopyTo(sol, tb_PlatformName.Text);
}
else if (m_solution != null)
{
sol = m_solution;
}
else
{
sol = new MFSolution();
}
sol.Name = tb_PlatformName.Text;
sol.Description = tb_PlatformDescription.Text;
sol.Author = tb_SolutionAuthor.Text;
m_solution = sol;
if (m_selectedSolution != null && IsWindowsSolution(m_solution))
{
Processor proc = m_bw.LoadProcessorProj(m_spoClientPath + "\\devicecode\\Targets\\OS\\Windows\\Windows.settings", "");
if(proc != null)
{
m_solution.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid, proc.ProjectPath);
}
m_solution.Projects[0].Name = m_solution.Name;
e.Page = wpChooseFeatures;
}
Wiz.NextEnabled = true;
}
public MFSolution()
{
this.m_cloneSolution = null;
this.m_solRequiredLibCats = new Dictionary<string,MFComponent>();
this.m_clonedLibraryMap = new Dictionary<string, Library>();
this.descriptionField = "";
this.documentationField = "";
this.guidField = System.Guid.NewGuid().ToString("B");
this.nameField = "";
this.projectsField = new System.Collections.Generic.List<MFProject>();
this.versionField = new Version();
this.propertiesField = new System.Collections.Generic.List<MFProperty>();
this.isSolutionWizardVisibleField = true;
this.authorField = "";
this.itemsField = new List<MFBuildFile>();
this.customFilterField = "";
this.m_transportType = null;
this.ENDIANNESS = "le";
}
private bool IsWindowsSolution(MFSolution solution)
{
return (0 == string.Compare(solution.Processor.Name, "windows", true));
}
void m_worker_DoWork(object sender, DoWorkEventArgs e)
{
lock (m_bw)
{
switch((BackgroundWorkerType)e.Argument)
{
case BackgroundWorkerType.LoadFeatures:
if (m_solution == null && m_selectedSolution != null)
{
m_solution = m_bw.LoadSolutionProj(m_selectedSolution.Component.ProjectPath, "");
}
if (IsWindowsSolution(m_solution))
{
m_bw.LoadDefaultLibraries(m_spoClientPath);
m_bw.LoadDefaultLibraryCategories(m_spoClientPath);
//m_bw.LoadDefaultManifestFiles(m_spoClientPath);
}
m_bw.LoadDefaultFeatures(m_spoClientPath);
break;
case BackgroundWorkerType.LoadSolution:
m_solution = m_bw.LoadSolutionProj(m_selectedSolution.Component.ProjectPath, "");
m_bw.LoadLibraries( m_solution.ProjectPath);
m_bw.LoadDefaultLibraryCategories(m_spoClientPath);
break;
case BackgroundWorkerType.LoadProjects:
if (m_inv.ProjectTemplates.Count == 0)
{
m_bw.LoadTemplateProjects(m_spoClientPath + "\\ProjectTemplates");
}
break;
case BackgroundWorkerType.LoadSolutions:
m_solutionRefs = m_bw.GetAvailableSolutions(m_spoClientPath);
break;
case BackgroundWorkerType.LoadLibraries:
m_bw.LoadDefaultLibraries(m_spoClientPath);
//m_bw.LoadDefaultManifestFiles(m_spoClientPath);
m_bw.LoadDefaultLibraryCategories(m_spoClientPath);
m_bw.LoadDefaultFeatures(m_spoClientPath);
break;
case BackgroundWorkerType.LoadProcessors:
m_bw.LoadProcessors(m_spoClientPath + "\\DeviceCode\\Targets\\Native");
m_bw.LoadProcessors(m_spoClientPath + "\\DeviceCode\\Targets\\OS");
break;
}
}
e.Result = e.Argument;
}
private void cloneSolutionToolStripMenuItem_Click_1(object sender, EventArgs e)
{
TreeNode tn = treeViewInventory.SelectedNode;
if(tn == null) return;
TreeNodeData tnd = (tn.Tag as TreeNodeData);
if (tnd != null)
{
MFSolution sol = tnd.Data as MFSolution;
if (sol != null)
{
MFSolution solNew = new MFSolution();
sol.CopyTo(solNew, "<Cloned " + sol.Name + " Solution>");
this.DefaultInventory.Solutions.Add(solNew);
RefreshTree();
}
}
}
internal MFSolution LoadSolutionProj(string solutionProjFile, string path)
{
MFSolution sol = new MFSolution();
Project proj;
string fullpath = ExpandEnvVars(solutionProjFile, path);
string codebase = "";
string codebasetype = "";
string processor = "";
try
{
proj = LoadProject(fullpath);
path = Path.GetDirectoryName(fullpath);
// load solution libraries
LoadLibraries(Path.Combine(path, "DeviceCode"));
Dictionary<string, string> tbl = new Dictionary<string, string>();
tbl["PLATFORM"] = "Name";
tbl["PlatformGuid"] = "Guid";
LoadStringProps(proj, sol, tbl);
foreach (ProjectItemGroupElement big in proj.Xml.ItemGroups)
{
foreach (ProjectItemElement bi in big.Items)
{
MFBuildFile bf = new MFBuildFile();
bf.File = bi.Include;
bf.ItemName = bi.ItemType;
bf.Condition = bi.Condition;
sol.Items.Add(bf);
}
}
foreach (ResolvedImport imp in proj.Imports)
{
if (imp.ImportedProject.FullPath.ToLower().Contains("\\devicecode\\targets\\"))
{
Processor proc = LoadProcessorProj(imp.ImportedProject.FullPath, "");
if (proc != null)
{
sol.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid, proc.ProjectPath);
}
}
}
if (sol.Processor == null || string.IsNullOrEmpty(sol.Processor.Name))
{
foreach (ProjectProperty prop in proj.Properties)
{
if (prop.IsImported)
{
if (prop.Name == "TARGETPROCESSOR")
{
Processor proc = m_helper.FindProcessorByName(prop.EvaluatedValue);
if (proc != null)
{
sol.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid);
}
else
{
foreach (ProjectImportElement imp in proj.Xml.Imports)
{
if (imp.Project.ToUpper().Contains("\\DEVICECODE\\TARGETS\\"))
{
proc = LoadProcessorProj(imp.Project, "");
break;
}
}
}
if (proc == null)
{
sol.Processor = new MFComponent(MFComponentType.Processor, prop.EvaluatedValue);
sol.Processor.Guid = "";
}
else
{
sol.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid, proc.ProjectPath);
}
}
}
}
}
foreach (ProjectPropertyGroupElement pg in proj.Xml.PropertyGroups)
{
foreach (ProjectPropertyElement bp in pg.Properties)
{
string cond = CombineConditionals(pg.Condition, bp.Condition);
switch (bp.Name)
{
case "Description":
sol.Description = bp.Value;
break;
case "Documentation":
sol.Documentation = bp.Value;
break;
case "INSTRUCTION_SET":
ISA isa = m_helper.FindISAByName(bp.Value);
if (isa == null)
{
sol.DefaultISA = new MFComponent(MFComponentType.ISA, bp.Value);
}
else
{
sol.DefaultISA = new MFComponent(MFComponentType.ISA, isa.Name, isa.Guid);
}
break;
case "PLATFORM":
case "TARGETPLATFORM":
sol.Name = bp.Value;
break;
case "PlatformGuid":
sol.Guid = bp.Value;
break;
case "TARGETPROCESSOR":
Processor proc = m_helper.FindProcessorByName(bp.Value);
if (proc != null)
{
sol.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid);
}
else
{
processor = bp.Value;
}
break;
//obsolete props (moved to processor settings)
case "PLATFORM_FAMILY":
case "ARM_TYPE":
case "MDK_DEVICE_TYPE":
case "CPUName":
break;
case "TARGETCODEBASE":
codebase = bp.Value;
break;
case "TARGETCODEBASETYPE":
codebasetype = bp.Value;
break;
default:
MFProperty prop = new MFProperty();
prop.Name = bp.Name;
prop.Value = bp.Value;
prop.Condition = cond;
sol.Properties.Add(prop);
break;
}
}
}
// for legacy settings files
if (sol.Processor == null)
{
string procFile = Path.Combine(Environment.GetEnvironmentVariable("SPOCLIENT"), "DeviceCode\\Targets\\" + codebasetype + "\\" + codebase + "\\" + processor + ".settings");
if (File.Exists(procFile))
{
Processor proc = LoadProcessorProj(procFile, "");
sol.Processor = new MFComponent(MFComponentType.Processor, proc.Name, proc.Guid);
}
else // delay load
{
sol.Processor = new MFComponent(MFComponentType.Processor, processor);
sol.Processor.Guid = "";
}
}
if (string.IsNullOrEmpty(sol.Name)) sol.Name = Path.GetFileNameWithoutExtension(solutionProjFile);
if (string.IsNullOrEmpty(sol.Guid)) sol.Guid = System.Guid.NewGuid().ToString("B");
sol.ProjectPath = ConvertPathToEnv(solutionProjFile);
foreach (string subdir in Directory.GetDirectories(Path.GetDirectoryName(fullpath)))
{
if (subdir.TrimEnd().ToUpper().EndsWith("DEVICECODE")) continue;
foreach (string projFile in Directory.GetFiles(subdir, "*.proj"))
{
MFProject mfproj = LoadProjectProj(projFile, Path.GetDirectoryName(projFile));
if (mfproj != null) sol.Projects.Add(mfproj);
}
}
// load platform selector file for memory data
string platSelectorFile = Path.Combine(path, "platform_selector.h");
if (File.Exists(platSelectorFile))
{
string data = "";
using (TextReader tr = File.OpenText(platSelectorFile))
{
data = tr.ReadToEnd();
}
sol.SystemClockSpeed = ParseHexInt(data, "SYSTEM_CLOCK_HZ");
sol.SlowClockSpeed = ParseHexInt(data, "SLOW_CLOCKS_PER_SECOND");
Regex rx = null;
Match m = null;
if (sol.SlowClockSpeed == -1)
{
rx = new Regex("\\sSLOW_CLOCKS_PER_SECOND\\s+SYSTEM_CLOCK_HZ");
if (rx.IsMatch(data))
{
sol.SlowClockSpeed = sol.SystemClockSpeed;
}
}
sol.RamBase = ParseHexInt(data, "SRAM1_MEMORY_Base");
sol.RamLength = ParseHexInt(data, "SRAM1_MEMORY_Size");
sol.FlashBase = ParseHexInt(data, "FLASH_MEMORY_Base");
sol.FlashLength = ParseHexInt(data, "FLASH_MEMORY_Size");
rx = new Regex("#define\\s+DEBUGGER_PORT\\s+([\\w\\d_]+)", RegexOptions.IgnoreCase);
m = rx.Match(data);
if (m.Success)
{
sol.DebuggerPort = m.Groups[1].Value;
}
else
{
sol.DebuggerPort = "COM1";
}
rx = new Regex("\\sRUNTIME_MEMORY_PROFILE__([\\w]+)");
m = rx.Match(data);
if (m.Success)
{
sol.MemoryProfile = m.Groups[1].Value;
}
else
{
sol.MemoryProfile = "medium";
}
}
MFSolution dbSol = m_helper.FindSolutionByName(sol.Name);
if (null == dbSol)
{
m_helper.DefaultInventory.Solutions.Add(sol);
}
else
{
sol = dbSol;
}
}
catch(Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: Exception in load solution " + e.Message);
sol = null;
}
return sol;
}
public void Rename(string newName)
{
if (m_cloneSolution == null)
{
MFSolution sol = new MFSolution();
CopyHelper.CopyTo(this, sol);
m_cloneSolution = sol;
}
CopyHelper.Rename(this, this.nameField, newName);
}
internal void CreateSolutionDirProj(MFSolution solution)
{
string solutionDir = @"$(SPOCLIENT)\Solutions\" + solution.Name;
string fullpath = ExpandEnvVars(Path.Combine(solutionDir, "dotnetmf.proj"), "");
Project proj = LoadProject(fullpath);
proj.ProjectCollection.UnloadProject(proj);
proj = new Project();
proj.Xml.DefaultTargets = "Build";
try
{
ProjectPropertyGroupElement bpg = proj.Xml.AddPropertyGroup();
bpg.AddProperty("Directory", RemoveSpoClient(solutionDir));
bpg.AddProperty("MFSettingsFile", Path.Combine(solutionDir, solution.Name + ".settings"));
ProjectItemGroupElement big = proj.Xml.AddItemGroup();
foreach (MFProject mfproj in solution.Projects)
{
if (!string.IsNullOrEmpty(mfproj.Directory) && !string.IsNullOrEmpty(mfproj.ProjectPath))
{
ProjectItemElement bi = big.AddItem("RequiredProjects", Path.Combine(Path.GetFileName(mfproj.Directory), Path.GetFileName(mfproj.ProjectPath)));
}
}
proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Settings");
proj.Xml.AddImport(@"$(SPOCLIENT)\tools\targets\Microsoft.SPOT.System.Targets");
proj.Save(fullpath);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Error: loading LibCat file: " + fullpath + "\r\n", e.Message);
}
}
public bool ValidateLibrary(Library lib, MFSolution solution, Processor proc, InventoryHelper helper)
{
try
{
if (!lib.IsSolutionWizardVisible)
{
return false;
}
// don't show processor specific libraries
if ((lib.ProcessorSpecific != null) && !string.IsNullOrEmpty(lib.ProcessorSpecific.Guid) &&
(0 != string.Compare(lib.ProcessorSpecific.Guid, solution.Processor.Guid, true)))
{
return false;
}
if (!string.IsNullOrEmpty(lib.CustomFilter))
{
bool OK = false;
// don't show custom specific libraries
foreach (string libFilter in lib.CustomFilter.Split(';'))
{
string[] customAttribs = proc.CustomFilter.Split(';');
foreach (string attrib in customAttribs)
{
if (string.Compare(attrib, libFilter, true) == 0)
{
OK = true;
break;
}
}
if (!OK)
{
foreach (string attrib in solution.CustomFilter.Split(';'))
{
if (0 == string.Compare(attrib, libFilter, true))
{
OK = true;
break;
}
}
}
///
/// Now lets check to see if one of the selected features contains this filter.
/// This is used for Network (LWIP) to enable the libraries to be auto selected
/// based on which Network feature was choosen
///
if (!OK)
{
MFProject defProj = null;
foreach(MFProject proj in solution.Projects)
{
if(proj.IsClrProject)
{
defProj = proj;
break;
}
}
foreach (MFComponent feat in defProj.Features)
{
Feature f = helper.FindFeature(feat.Guid);
if (f != null && 0 == string.Compare(f.Filter, libFilter, true))
{
OK = true;
break;
}
}
}
if (!OK)
{
OK = (0 == string.Compare(lib.CustomFilter, solution.Name, true));
}
if (OK) break;
}
if (!OK) return false;
}
if (!IsBootloaderProject() && lib.IsBootloaderLibrary())
{
return false;
}
// only add CLR libraries to a CLR project
if (lib.Level == LibraryLevel.CLR && !this.IsClrProject)
{
return false;
}
string projPath = lib.ProjectPath.ToLower();
if (projPath.Contains(@"\devicecode\drivers\sample\"))
{
return false;
}
if (projPath.Contains("\\solutions\\") && !projPath.Contains("\\solutions\\" + solution.Name.ToLower() + "\\"))
{
return false;
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception validating solution libraries: " + e.ToString());
return false;
}
return true;
}
internal void CopyTemplateFiles(LibraryCategory libType, MFSolution solution, MFComponent compLibTemplate)
{
const string c_FastCompile = @"fastcompile.cpp";
const string c_FastCompileTag = @"FastCompileCPPFile";
string dstPath = Path.Combine(ExpandEnvVars(Path.GetDirectoryName(solution.ProjectPath), ""), "DeviceCode\\");
List<string> reloadProjs = new List<string>();
//Regex expRelPath = new Regex("([\\w\\W]*\\\\)([^\\\\]+\\\\[^\\\\]+)");
//Regex expRemoveDeviceCode = new Regex("\\\\DeviceCode\\\\", RegexOptions.IgnoreCase);
//Regex expRemoveStubDir = new Regex("\\\\stub[s]?\\\\", RegexOptions.IgnoreCase);
Regex expStubReplace = new Regex("(?<!Is)(stub[s]?)", RegexOptions.IgnoreCase);
//string relPath = "";
foreach (ApiTemplate api in libType.Templates)
{
string src = ExpandEnvVars( api.FilePath, Environment.GetEnvironmentVariable("SPOCLIENT") );
//
// Make relative path based on path after \DeviceCode\ if it exists, otherwise up to two directories deep
//
//relPath = Path.GetDirectoryName(src);
//string devCode = "\\devicecode\\";
/*
int idx = relPath.ToLower().IndexOf(devCode);
if (idx != -1)
{
idx += devCode.Length;
relPath = relPath.Substring(idx, relPath.Length - idx);
}
else
{
Match m = expRelPath.Match(Path.GetDirectoryName(api.FilePath));
relPath = m.Groups[1].Value.ToLower();
}
*/
string dst = dstPath + libType.Name + "\\" + Path.GetFileName(api.FilePath);
bool isProcFile = src.ToLower().Contains("\\processor\\");
try
{
// ignore fast compiles
if (-1 != dst.IndexOf(c_FastCompile, StringComparison.OrdinalIgnoreCase))
{
continue;
}
//dst = expRemoveStubDir.Replace(dst, "\\");
if (isProcFile)
{
dst = expStubReplace.Replace(dst, solution.Processor.Name);
}
else
{
dst = expStubReplace.Replace(dst, solution.Name);
}
if (!Directory.Exists(Path.GetDirectoryName(dst)))
{
Directory.CreateDirectory(Path.GetDirectoryName(dst));
}
if (File.Exists(dst))
{
continue;
}
//
// The source file may refer to "stubs" for function names or includes, we need to replace this
// with the solution (or processor) name
//
TextWriter tw = File.CreateText(dst);
TextReader tr = File.OpenText(src);
try
{
string txt = tr.ReadToEnd();
if (isProcFile)
{
txt = expStubReplace.Replace(txt, solution.Processor.Name);
}
else
{
txt = expStubReplace.Replace(txt, solution.Name);
}
Regex exp = new Regex("<IsStub>([\\w\\W]+)</IsStub>", RegexOptions.IgnoreCase);
txt = exp.Replace(txt, "<IsStub>false</IsStub>");
tw.Write(txt);
}
finally
{
tr.Close();
tw.Close();
}
File.SetAttributes(dst, FileAttributes.Normal);
if (0 == string.Compare(".proj", Path.GetExtension(dst), true))
{
Project p = LoadProject(dst);
p.Xml.DefaultTargets = "Build";
compLibTemplate.ProjectPath = ConvertPathToEnv(dst);
foreach (ProjectPropertyGroupElement pg in p.Xml.PropertyGroups)
{
foreach (ProjectPropertyElement bp in pg.Properties)
{
switch (bp.Name.ToLower())
{
case "directory":
bp.Value = RemoveSpoClient(Path.GetDirectoryName(dst));
break;
case "assemblyname":
bp.Value = compLibTemplate.Name;
break;
case "projectpath":
bp.Value = ConvertPathToEnv(dst);
break;
case "projectguid":
bp.Value = compLibTemplate.Guid;
break;
case "libraryfile":
bp.Value = compLibTemplate.Name + ".$(LIB_EXT)";
break;
case "manifestfile":
bp.Value = compLibTemplate.Name + ".$(LIB_EXT).manifest";
break;
}
}
}
foreach (ProjectItemGroupElement ig in p.Xml.ItemGroups)
{
ArrayList remove_list = new ArrayList();
foreach (ProjectItemElement bi in ig.Items)
{
if (bi.ItemType == c_FastCompileTag)
{
remove_list.Add(bi);
continue;
}
//dst = expRemoveStubDir.Replace(dst, "\\");
if (-1 != src.IndexOf("\\processor\\", StringComparison.CurrentCultureIgnoreCase))
{
bi.Include = expStubReplace.Replace(bi.Include, solution.Processor.Name);
}
else
{
bi.Include = expStubReplace.Replace(bi.Include, solution.Name);
}
}
foreach (ProjectItemElement bi in remove_list)
{
ig.RemoveChild(bi);
}
}
p.Save(dst);
reloadProjs.Add(dst);
}
}
catch(Exception e)
{
System.Diagnostics.Debug.Print(e.ToString());
System.Diagnostics.Debug.Print("Unable to copy file: " + src + " to " + dst );
}
}
foreach (string prj in reloadProjs)
{
LoadLibraryProj(prj, "", true);
}
}
public SolutionWrapper CreateSolution(string Name, string Description, string Author, bool IsSolutionWizardVisible)
{
MFSolution solution = new MFSolution();
solution.Name = Name;
solution.Description = Description;
solution.Author = Author;
solution.IsSolutionWizardVisible = IsSolutionWizardVisible;
return SolutionWrapper.Wrap<SolutionWrapper>(solution);
}
