private async Task LoadDetailByIdAsync(int id)
{
if (id == 0)
{
SelectedProject = new ProjectWrapper(CreateNewDetail());
}
else
{
var lookup = await _projectRepository.GetByIdAsync(id);
SelectedProject = new ProjectWrapper(lookup);
SelectedProject.PropertyChanged += (s, e) =>
{
if (!HasChanges)
{
HasChanges = _projectRepository.HasChanges();
}
if (e.PropertyName == nameof(SelectedProject.HasErrors))
{
SaveDetailCommand.RaiseCanExecuteChanged();
}
};
}
IntialiseProjectSubtasks(SelectedProject.Model.ProjectSubtasks);
SaveDetailCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Constructs a local (task-specific) script task.
/// </summary>
public ScriptTask(Script script,
ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper, ScriptProject referencedGlobalScriptProject)
{
bool hasReference = script.ScriptProjectReference != null;
ScriptTaskWrapper = new ScriptTaskWrapper(containerWrapper, hasReference ? script.ScriptProjectReference.ScriptProjectName : script.ScriptProject.Name, hasReference, ScriptTaskScope.Package)
{
Name = script.Name,
DelayValidation = script.DelayValidation,
ForceExecutionResult = script.ForceExecutionResult.ToString()
};
AddExpressions(ScriptTaskWrapper, script.PropertyExpressions);
if (hasReference)
{
ScriptTaskWrapper.ReadOnlyVariables = GetVariableNames(referencedGlobalScriptProject.ReadOnlyVariables, ScriptTaskScope.Package, projectWrapper, packageWrapper, containerWrapper);
ScriptTaskWrapper.ReadWriteVariables = GetVariableNames(referencedGlobalScriptProject.ReadWriteVariables, ScriptTaskScope.Package, projectWrapper, packageWrapper, containerWrapper);
}
else
{
ScriptTaskWrapper.ReadOnlyVariables = GetVariableNames(script.ScriptProject.ReadOnlyVariables, ScriptTaskScope.Package, projectWrapper, packageWrapper, containerWrapper);
ScriptTaskWrapper.ReadWriteVariables = GetVariableNames(script.ScriptProject.ReadWriteVariables, ScriptTaskScope.Package, projectWrapper, packageWrapper, containerWrapper);
AddAssemblyReferences(script.ScriptProject.AssemblyReferences, projectWrapper.Version);
AddSourceFiles(script.ScriptProject.Files);
}
CheckForBuildErrors(projectWrapper.StopBuildOnScriptErrors);
ScriptTaskWrapper.PropagateErrors(script.PropagateErrors);
}
public static void CreateTask(ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper,
IonStructure.Task task, List <ScriptProject> globalScriptProjects, ScriptProject referencedGlobalScriptProject = null)
{
try
{
ExecutableWrapper executableWrapper = null;
switch (task)
{
case DataFlow dataFlow:
DataFlowTask dataFlowTask = new DataFlowTask(dataFlow, projectWrapper, packageWrapper, containerWrapper);
executableWrapper = dataFlowTask.DataFlowTaskWrapper;
break;
case ExecuteSql executeSql:
ExecuteSqlTask executeSqlTask = new ExecuteSqlTask(executeSql, containerWrapper);
executableWrapper = executeSqlTask.ExecuteSqlTaskWrapper;
break;
case ExecuteProcess executeProcess:
executableWrapper = ExecuteProcessTask.CreateTask(executeProcess, containerWrapper);
break;
case Expression expression:
executableWrapper = ExpressionTask.CreateTask(expression, containerWrapper);
break;
case Script script:
ScriptTask scriptTask = new ScriptTask(script, projectWrapper, packageWrapper, containerWrapper, referencedGlobalScriptProject);
executableWrapper = scriptTask.ScriptTaskWrapper;
break;
case ForLoopContainer forLoopContainer:
executableWrapper = ContainerExecutable.CreateForLoopContainer(forLoopContainer, projectWrapper, packageWrapper, containerWrapper, globalScriptProjects);
break;
case ForEachFromVariableLoopContainer forEachFromVarLoopContainer:
executableWrapper = ContainerExecutable.CreateForEachFromVariableLoopContainer(forEachFromVarLoopContainer, projectWrapper, packageWrapper, containerWrapper, globalScriptProjects);
break;
case SequenceContainer sequenceContainer:
executableWrapper = ContainerExecutable.CreateSequenceContainer(sequenceContainer, projectWrapper, packageWrapper, containerWrapper, globalScriptProjects);
break;
}
AddPrecedenceConstraints(containerWrapper, executableWrapper, task.PrecedenceConstraints);
}
catch (Exception e)
{
if (e.Data[Constants.ExceptionTaskKey] == null)
{
e.Data[Constants.ExceptionTaskKey] = task.Name;
}
else
{
e.Data[Constants.ExceptionTaskKey] = task.Name + "/" + e.Data[Constants.ExceptionTaskKey]; // If task is not null then the task being created is a container, and an exception has been thrown in one of its underlying tasks.
}
throw;
}
}
public override void BeforeCloseOnNext()
{
Params.Solution.Projects.Clear();
foreach (BaseNode BN in _treeView.AllNodes)
{
ComponentNode CN = BN as ComponentNode;
if (CN == null)
{
continue;
}
if (!CN.Checked)
{
continue;
}
else
{
string str = @"$(SPOCLIENT)\Solutions\" + Params.Solution.Name + @"\";
ProjectWrapper Template = FindProjectTemplate(CN.TypedContent);
MFProject tmpProj = new MFProject();
Template.InnerObject.CopyTo(tmpProj, Params.Solution.Name);
if (tmpProj != null)
{
tmpProj.ProjectPath = str + Path.GetFileName(tmpProj.Directory) + @"\" + Path.GetFileName(tmpProj.ProjectPath);
tmpProj.SettingsFile = str + Params.Solution.Name + ".settings";
Params.Solution.Projects.Add(ProjectWrapper.Wrap <ProjectWrapper>(tmpProj));
}
}
}
this.OnShowNextBtn(true);
}
/// <summary>
/// Метод конвертации коллекции в строку формата JSON
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="project"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static string ConvertToString <T>(this Project <T> project, EventLogger <IEmployee <IComputer> > logger = null) where T : IEmployee <IComputer>
{
var wrapper = new ProjectWrapper <T>(project);
logger.Log("Converted to string");
return(JsonConvert.SerializeObject(wrapper, Formatting.Indented));
}
private void InitializeProject(Project project)
{
Project = new ProjectWrapper(project);
Project.PropertyChanged += (s, e) =>
{
if (!HasChanges)
{
HasChanges = _projectRepository.HasChanges();
}
if (e.PropertyName == nameof(Project.HasErrors))
{
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
}
if (e.PropertyName == nameof(Project.ProjectName))
{
SetTitle();
}
};
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
if (Project.Id == 0)
{
//Trick to trigger the validation
Project.ProjectName = "";
}
SetTitle();
}
private void projectsGridView_MouseMove(object sender, MouseEventArgs e)
{
Point pt = new Point(e.X, e.Y);
GridHitInfo ghi = projectsGridView.CalcHitInfo(pt);
if (ghi.InRowCell)
{
int dsRowIndex = projectsGridView.GetDataSourceRowIndex(ghi.RowHandle);
if (lastHoveredDSRowIndex != dsRowIndex)
{
ProjectWrapper project = projectsDataSource[dsRowIndex];
string message = JenkinsTrayResources.ResourceManager
.GetString("BuildStatus_" + project.Project.Status.Key);
if (project.Project.Status.IsStuck && project.Project.Queue.InQueue)
{
message += string.Format(JenkinsTrayResources.BuildDetails_InQueue_Since, project.Project.Queue.InQueueSince);
}
toolTip.SetToolTip(projectsGridControl, message);
}
lastHoveredDSRowIndex = dsRowIndex;
}
else
{
lastHoveredDSRowIndex = -1;
}
}
void ReBuildItem_Click(object sender, EventArgs e)
{
ProjectWrapper proj = (ProjectWrapper)((ToolStripMenuItem)sender).Tag;
Debug.Assert(proj != null);
this.Build(proj, "Rebuild");
}
public NewProjectWizard(SolutionWrapper Solution)
{
InitializeComponent();
Param.Solution = Solution;
Param.OldProject = null;
MFProject tmpProj = new MFProject();
Param.NewProject = ProjectWrapper.Wrap <ProjectWrapper>(tmpProj);
mPDP = new ProjectDescriptionPage(Param);
mPDP.IsCLREvent += new EventHandler <IsCLREventArgs>(mPDP_IsCLREvent);
mMFP = new ManageFeaturesPage(Param);
mPageList.Add(new ProjectTemplatePage(Param));
mPageList.Add(mPDP);
mPageList.Add(mMFP);
mPageList.Add(new ManageLibrariesPage(Param));
foreach (BasePage bp in mPageList)
{
bp.ShowBackBtnEvent += new EventHandler <ShowBtnEventArgs>(bp_ShowBackBtnEvent);
bp.ShowNextBtnEvent += new EventHandler <ShowBtnEventArgs>(bp_ShowNextBtnEvent);
}
this.Initialize();
}
public Output(ProjectWrapper projectWrapper)
{
Name = projectWrapper.Name;
DtProjFilePath = Path.Combine(Properties.Instance.OutputDirectory, projectWrapper.Name, projectWrapper.Name + ".dtproj");
IspacFilePath = Path.ChangeExtension(DtProjFilePath, ".ispac");
ProjectWrapper = projectWrapper;
SqlServerVersion = projectWrapper.Version;
}
public bool ContainsProject(ProjectWrapper proj)
{
foreach (ConvertableMFProject cp in mProjectList)
{
if (cp.Project == proj) return true;
}
return false;
}
private void ShowDescription(ProjectWrapper project)
{
DescriptionTB.Clear();
DescriptionTB.AppendText("Name: " + project.Name + "\r\n\r\n");
DescriptionTB.AppendText("Project Path:\r\n");
DescriptionTB.AppendText(project.ProjectPath + "\r\n\r\n");
DescriptionTB.AppendText("Description:\r\n");
DescriptionTB.AppendText(project.Description + "\r\n\r\n");
}
public static void ConstructTask(ProjectWrapper project, PackageWrapper package, ContainerWrapper taskContainer, Task task, ScriptProject innerTask = null)
{
try
{
ExecutableWrapper executableTask = null;
switch (task)
{
case DataFlow dataflowTask:
executableTask = DataFlowTask.ConstructTask(dataflowTask, project, package, taskContainer);
break;
case ExecuteSql executeSqlTask:
executableTask = ConstructExecuteSqlTask(executeSqlTask, taskContainer);
break;
case ExecuteProcess executeProcessTask:
executableTask = ConstructExecuteProcessTask(executeProcessTask, taskContainer);
break;
case Expression expressionTask:
executableTask = ConstructExpressionTask(expressionTask, taskContainer);
break;
case Script scriptTask:
executableTask = ConstructScriptTask(scriptTask, project, package, taskContainer, innerTask);
break;
case ForLoopContainer forLoopContainer:
executableTask = ContainerExecutable.ConstructForLoopContainer(forLoopContainer, project, package, taskContainer);
break;
case ForEachFromVariableLoopContainer forEachFromVarLoopContainer:
executableTask = ContainerExecutable.ConstructForEachFromVariableLoopContainer(forEachFromVarLoopContainer, project, package, taskContainer);
break;
case SequenceContainer sequenceContainer:
executableTask = ContainerExecutable.ConstructSequenceContainer(sequenceContainer, project, package, taskContainer);
break;
}
AddPrecedenceConstraints(taskContainer, executableTask, task.PrecedenceConstraints);
}
catch (Exception e)
{
if (e.Data[Constants.ExceptionTaskKey] == null)
{
e.Data[Constants.ExceptionTaskKey] = task.Name;
}
else
{
e.Data[Constants.ExceptionTaskKey] = task.Name + "/" + e.Data[Constants.ExceptionTaskKey]; // If task is not null then the task being constructed is a container and an exception has been thrown in one of the underlying tasks.
}
throw;
}
}
public async override Task LoadAsync(int?projectId)
{
var project = projectId.HasValue
? await _projectRepository.GetByIdAsync(projectId.Value)
: throw new NullReferenceException();
Id = project.Id;
Project = new ProjectWrapper(project);
SetTitle();
}
public bool ContainsProject(ProjectWrapper proj)
{
foreach (ConvertableMFProject cp in mProjectList)
{
if (cp.Project == proj)
{
return(true);
}
}
return(false);
}
public SolutionWrapper(EnvDTE.Solution solution)
{
Solution = solution;
var projects = new ProjectWrapper[solution.Projects.Count];
var i = 0;
foreach (Project p in solution.Projects)
{
projects[i++] = new ProjectWrapper(p);
}
Projects = projects;
}
private void _treeView_SelectionChangedEvent(object sender, Forms.BaseForms.ObjectEventArgs e)
{
ProjectWrapper PW = e.Object as ProjectWrapper;
if (PW != null)
{
ShowDescription(PW);
selectedProject = PW;
this.OnShowNextBtn(true);
}
}
private void projectsGridView_CustomUnboundColumnData(object sender, CustomColumnDataEventArgs e)
{
if (e.IsGetData)
{
if (e.Column == statusGridColumn)
{
ProjectWrapper projectWrapper = (ProjectWrapper)projectsDataSource[e.ListSourceRowIndex];
byte[] imgBytes = iconsByKey[projectWrapper.Project.Status.Key];
e.Value = imgBytes;
}
}
}
public void LoadData(int projectId)
{
try
{
Project = _CatalogueDb.Projects.FirstOrDefault(p => p.Id == projectId)?.ToProjectWrapper()
?? new ProjectWrapper(new Project(""));
}
catch (Exception e)
{
Debug.WriteLine($"Error loading project: {e.Message}");
}
}
public void RemoveProject(ProjectWrapper proj)
{
ConvertableMFProject tmp = null;
foreach (ConvertableMFProject cp in mProjectList)
{
if (cp.Project == proj) tmp = cp;
}
if (tmp != null)
{
mProjectList.Remove(tmp);
}
}
private Project GetSelectedProject()
{
int[] rowHandles = projectsGridView.GetSelectedRows();
if (rowHandles.Length != 1)
{
return(null);
}
int rowHandle = rowHandles[0];
int dsRowIndex = projectsGridView.GetDataSourceRowIndex(rowHandle);
ProjectWrapper projectWrapper = projectsDataSource[dsRowIndex];
return(projectWrapper.Project);
}
/// <summary>
/// Constructs a "global" script task.
/// </summary>
public ScriptTask(ScriptProject scriptProject, ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper)
{
ScriptTaskWrapper = new ScriptTaskWrapper(containerWrapper, scriptProject.Name, false, ScriptTaskScope.Project)
{
Name = scriptProject.Name
};
ScriptTaskWrapper.ReadOnlyVariables = GetVariableNames(scriptProject.ReadOnlyVariables, ScriptTaskScope.Project, projectWrapper, packageWrapper, containerWrapper);
ScriptTaskWrapper.ReadWriteVariables = GetVariableNames(scriptProject.ReadWriteVariables, ScriptTaskScope.Project, projectWrapper, packageWrapper, containerWrapper);
AddAssemblyReferences(scriptProject.AssemblyReferences, projectWrapper.Version);
AddSourceFiles(scriptProject.Files);
}
public async Task DeleteProject(ProjectWrapper project)
{
try
{
_CatalogueDb.Projects.Remove(project.Project);
await _CatalogueDb.SaveChangesAsync();
Projects.Remove(project);
}
catch (Exception e)
{
Debug.WriteLine($"Error deleting project: {e.Message}");
}
}
internal static ProjectWrapper GetInstance()
{
Project real = default(Project);
RealInstanceFactory(ref real);
var instance = (ProjectWrapper)ProjectWrapper.GetWrapper(real);
InstanceFactory(ref instance);
if (instance == null)
{
Assert.Inconclusive("Could not Create Test Instance");
}
return(instance);
}
private BuildDetails GetBuildDetails(GridColumn column, int listSourceRowIndex)
{
ProjectWrapper projectWrapper = (ProjectWrapper)projectsDataSource[listSourceRowIndex];
if (column == lastSuccessGridColumn)
{
return(projectWrapper.LastSuccessBuild);
}
if (column == lastFailureGridColumn)
{
return(projectWrapper.LastFailureBuild);
}
throw new Exception("Column not supported: " + column.Caption);
}
/// <summary>
/// Updates the selected project
/// </summary>
/// <param name="projectWrapper"></param>
/// <returns></returns>
public async Task <Project> Update(Project project)
{
var wrapper = new ProjectWrapper()
{
project = project
};
this.SetHeaders();
var response = await Client.PutAsJsonAsync($"projects/{project.Id}", wrapper);
HandleResponse(response);
var result = await response.Content.ReadAsAsync <Project>();
return(result);
}
public Package(IonStructure.Package package, ProjectWrapper projectWrapper, List <ScriptProject> globalScriptProjects)
{
PackageWrapper = new PackageWrapper()
{
Name = package.Name,
DelayValidation = package.DelayValidation,
LocaleId = package.LocaleId,
};
SetParameters(package.Parameters);
SetVariables(package.Variables);
ConnectionManagerFactory.CreateConnectionManagers(PackageWrapper, package.Connections);
CreateTasks(projectWrapper, package.Tasks, globalScriptProjects);
SetPackageLocaleId(projectWrapper, package);
}
public DataFlowTask(DataFlow dataFlow, ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper)
{
DataFlowTaskWrapper = new DataFlowTaskWrapper(containerWrapper)
{
Name = dataFlow.Name,
DelayValidation = dataFlow.DelayValidation,
ForceExecutionResult = dataFlow.ForceExecutionResult.ToString(),
AutoAdjustBufferSize = dataFlow.AutoAdjustBufferSize,
DefaultBufferMaxRows = int.Parse(dataFlow.DefaultBufferMaxRows, CultureInfo.InvariantCulture),
DefaultBufferSize = int.Parse(dataFlow.DefaultBufferSize, CultureInfo.InvariantCulture)
};
DataFlowTaskWrapper.PropagateErrors(dataFlow.PropagateErrors);
AddComponents(dataFlow.Components, packageWrapper, projectWrapper);
}
public static SequenceContainerWrapper CreateSequenceContainer(SequenceContainer sequenceContainer,
ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper, List <ScriptProject> globalScriptProjects)
{
SequenceContainerWrapper sequenceContainerWrapper = new SequenceContainerWrapper(containerWrapper)
{
Name = sequenceContainer.Name,
DelayValidation = sequenceContainer.DelayValidation,
ForceExecutionResult = sequenceContainer.ForceExecutionResult.ToString()
};
AddExpressions(sequenceContainerWrapper, sequenceContainer.PropertyExpressions);
CreateTasks(projectWrapper, packageWrapper, sequenceContainerWrapper, sequenceContainer.Tasks, globalScriptProjects);
return(sequenceContainerWrapper);
}
public void LoadData(int projectId)
{
try
{
Data.Project p = _CatalogueDb.Projects.Find(projectId);
var items = _CatalogueDb.ProjectItems.ToList();
Project = _CatalogueDb.Projects.Include(p => p.Items).FirstOrDefault(p => p.Id == projectId)?.ToProjectWrapper()
?? new ProjectWrapper(new Data.Project(""));
}
catch (Exception e)
{
Debug.WriteLine($"Error loading project: {e.Message}");
}
}
private static string GetVariableNames(List <ScriptVariable> scriptVariables, ScriptTaskScope scope,
ProjectWrapper projectWrapper, PackageWrapper packageWrapper, ContainerWrapper containerWrapper)
{
if (scriptVariables == null)
{
return(string.Empty); // Return early if there are no variables configured for the script.
}
List <string> qualifiedVariableNames = new List <string>();
foreach (ScriptVariable scriptVariable in scriptVariables)
{
string qualifiedScriptVariableName = GetQualifiedVariableName(scriptVariable);
switch (scriptVariable.Namespace)
{
case "$Package":
if (scope == ScriptTaskScope.Package)
{
if (!packageWrapper.ContainsParameter(scriptVariable.VariableName))
{
throw new InvalidOperationException($"Could find referenced package parameter {scriptVariable.VariableName}!");
}
}
break;
case "$Project":
if (!projectWrapper.ContainsParameter(scriptVariable.VariableName))
{
throw new InvalidOperationException($"Could find referenced project parameter {scriptVariable.VariableName}!");
}
break;
default:
if (scope == ScriptTaskScope.Package)
{
if (!containerWrapper.ContainsVariable(qualifiedScriptVariableName) && !packageWrapper.ContainsVariable(qualifiedScriptVariableName))
{
throw new InvalidOperationException($"Couldn't find referenced variable {qualifiedScriptVariableName}!");
}
}
break;
}
qualifiedVariableNames.Add(qualifiedScriptVariableName);
}
return(string.Join(",", qualifiedVariableNames));
}
public Project(SsisProject ssisProject)
{
ProjectWrapper = new ProjectWrapper()
{
Name = ssisProject.Name,
LocaleId = ssisProject.LocaleId,
StopBuildOnScriptErrors = Convert.ToBoolean(Properties.Instance.OtherProperties["StopBuildOnScriptErrors"], CultureInfo.InvariantCulture),
Version = (SqlServerVersion)ssisProject.TargetSqlServerVersion
};
SetProtectionLevel(ssisProject.ProtectionLevel, ssisProject.Password);
SetParameters(ssisProject.Parameters);
ConnectionManagerFactory.CreateConnectionManagers(ProjectWrapper, ssisProject.Connections);
CreateScriptProjects(ssisProject.ScriptProjects);
CreatePackages(ssisProject.Packages);
}
private void CreateNewDetail()
{
Project myProject = new Project
{
Id = 0,
ProjectName = "<New Project 1>",
SystemId = 0,
Priority = 0,
Deadline = System.DateTime.Now,
StatusId = 0,
Complete = false,
Comment = ""
};
SelectedProject = new ProjectWrapper(myProject);
}
public void SetProject(SolutionWrapper Solution, ProjectWrapper Project)
{
MFProject tmpProj = new MFProject();
Project.InnerObject.CopyTo(tmpProj, Solution.Name);
Param.NewProject = ProjectWrapper.Wrap<ProjectWrapper>(tmpProj);
Param.OldProject = Project;
Param.Solution = Solution;
if (Project.IsClrProject)
mPageList.Add(new ManageFeaturesPage(Param));
mPageList.Add(new ManageLibrariesPage(Param));
//mPageList.Add(new ManageLibrariesPageTest(Solution, Project, NewProject));
this.Initialize();
}
private void Build(ProjectWrapper project, string target)
{
this.Build(PK.Wrapper.ExpandEnvVars(project.ProjectPath, ""), target);
}
public void SaveProjectProj(ProjectWrapper mfproj)
{
this.m_bw.SaveProjectProj(mfproj.InnerObject);
}
private void LoadProjects()
{
projectsDataSource = new BindingList<ProjectWrapper>();
foreach (Server server in ConfigurationService.Servers)
{
foreach (Project project in server.Projects)
{
ProjectWrapper wrapper = new ProjectWrapper(project);
projectsDataSource.Add(wrapper);
}
}
projectsGridControl.DataSource = projectsDataSource;
projectsGridView.BestFitColumns();
UpdateStatusBar();
}
public ManageFeaturesPage(WizardParams Params, ProjectWrapper project)
: base(Params)
{
InitializeComponent();
this.project = project;
}
public MFProjectTreeNode(ProjectWrapper project)
: base(project.Name, ImageKeysEnum.Project)
{
this.Project = project;
this.Tag = project;
#region Features
MFTreeNodeBase FeaturesNode = new MFComponentsTreeNode("Features");//this.NewNode("Features", MFTreeNodeBase.TreeNodeType.Components, null, MFTreeNodeBase.ImageKeysEnum.Components);
this.Nodes.Add(FeaturesNode);
foreach (ComponentWrapper feat in this.Project.Features)
{
//FeatureWrapper f = PK.Wrapper.FindFeature(feat.Guid);
MFTreeNodeBase FeatNode = new MFFeatureTreeNode(PK.Wrapper.FindFeature(feat.Guid));//this.NewNode(f.Name, MFTreeNodeBase.TreeNodeType.Feature, f, MFTreeNodeBase.ImageKeysEnum.Feature);
FeaturesNode.Nodes.Add(FeatNode);
}
#endregion
#region Library Categories
MFTreeNodeBase LibraryCategoriesNode = new MFComponentsTreeNode("Library Categories");//this.NewNode("Library Categories", MFTreeNodeBase.TreeNodeType.Components, null, MFTreeNodeBase.ImageKeysEnum.Components);
this.Nodes.Add(LibraryCategoriesNode);
foreach (ComponentWrapper LibCat in this.Project.LibraryCategories)
{
MFTreeNodeBase LibCatNode = new MFLibCatTreeNode(PK.Wrapper.FindLibraryCategory(LibCat.Guid));//this.NewNode(lc.Name, MFTreeNodeBase.TreeNodeType.LibCat, lc, MFTreeNodeBase.ImageKeysEnum.LibraryCategory);
LibraryCategoriesNode.Nodes.Add(LibCatNode);
}
#endregion
#region Libraries
MFTreeNodeBase LibraryesNode = new MFComponentsTreeNode("Libraries");//this.NewNode("Libraries", MFTreeNodeBase.TreeNodeType.Components, null, MFTreeNodeBase.ImageKeysEnum.Components);
this.Nodes.Add(LibraryesNode);
//Groups Libraries Dictionary
SortedDictionary<string, TreeNode> LibGroupsDict = new SortedDictionary<string, TreeNode>();
SortedList<string, TreeNode> LibVoidGroupsList = new SortedList<string, TreeNode>();
foreach (ComponentWrapper l in this.Project.Libraries)
{
LibraryWrapper lib = PK.Wrapper.FindLibrary(l);
if (lib != null)
{
//MFTreeNodeBase LibNode = new MFLibraryTreeNode(lib, ref LibGroupsDict, ref LibVoidGroupsList);//this.NewNode(lib.Name, MFTreeNodeBase.TreeNodeType.Lib, lib, MFTreeNodeBase.ImageKeysEnum.Library);
}
}
foreach (TreeNode tn in LibVoidGroupsList.Values)
{
LibraryesNode.Nodes.Add(tn);
}
foreach (TreeNode tn in LibGroupsDict.Values)
{
LibraryesNode.Nodes.Add(tn);
}
List<BuildFileWrapper> source_files = new List<BuildFileWrapper>(Project.SourceFiles);
source_files.AddRange(Project.HeaderFiles);
source_files.AddRange(Project.OtherFiles);
source_files.Add(Project.ScatterFile);
AddFileList(new CollectionWrapper<BuildFileWrapper, MFBuildFile>(source_files), this.Project.ProjectPath);
#endregion
}
public void CopyProjFilesFromClone(ProjectWrapper proj, SolutionWrapper solution)
{
this.m_bw.CopyProjFilesFromClone(proj.InnerObject, solution.InnerObject);
}
private void _treeView_SelectionChangedEvent(object sender, Forms.BaseForms.ObjectEventArgs e)
{
ProjectWrapper PW = e.Object as ProjectWrapper;
if (PW != null)
{
ShowDescription(PW);
selectedProject = PW;
this.OnShowNextBtn(true);
}
}
private void ShowDescription(ProjectWrapper project)
{
DescriptionTB.Clear();
DescriptionTB.AppendText("Name: " + project.Name + "\r\n\r\n");
DescriptionTB.AppendText("Project Path:\r\n");
DescriptionTB.AppendText(project.ProjectPath + "\r\n\r\n");
DescriptionTB.AppendText("Description:\r\n");
DescriptionTB.AppendText(project.Description + "\r\n\r\n");
}
public ConvertableMFProject(ProjectWrapper proj, string BuildType, string MediaType)
{
_Project = proj;
_BuildType = BuildType;
_MediaType = MediaType;
}
