private void LoadTable()
{
var imageCount = Data.Database.Main.Table<ProjectImage>().Count();
var allPatternsButton = new StyledElement("All UI Images", imageCount.ToString(), UITableViewCellStyle.Value1);
if (imageCount > 0)
{
allPatternsButton.Accessory = UITableViewCellAccessory.DisclosureIndicator;
allPatternsButton.Tapped += () => NavigationController.PushViewController(new LocalViewPatternsViewController() { Title = "All" }, true);
}
var section = new Section("Albums");
var projects = Data.Database.Main.Table<Project>();
foreach (var p in projects)
{
var project = p;
var element = new ProjectElement(project);
if (Data.Database.Main.Table<ProjectImage>().Where(a => a.ProjectId == project.Id).Count() > 0)
{
element.Accessory = UITableViewCellAccessory.DisclosureIndicator;
element.Tapped += () => {
NavigationController.PushViewController(new LocalViewPatternsViewController(project.Id) { Title = project.Name }, true);
};
}
section.Add(element);
}
var root = new RootElement(Title) { new Section() { allPatternsButton }, section };
Root = root;
}
private void OnBindToElement(object sender, BindToElementEventArgs e)
{
if (e.Element == null || !(e.Element is ProjectElement)) return;
Element = e.Element as ProjectElement;
this.DataContext = Element;
}
private string ExpectedNamespace(ProjectElement project, string documentPath)
{
var projectpath = Path.GetDirectoryName(project.FilePath);
var filepath = Path.GetDirectoryName(documentPath);
var namespaceSuffix = projectpath.Length < filepath.Length ? filepath.Substring(projectpath.Length).Replace("\\", ".") : String.Empty;
return GetDefaultNamespace(project) + namespaceSuffix;
}
public MVSSolutionFile(StreamReader data)
{
data.ReadLine();
var Header = data.ReadLine();
var Project = data.ReadLine();
while (Project != null)
{
if (Project.StartsWith("Project"))
{
var r = ToValueReader(Project);
var p = new ProjectElement
{
Kind = r(0),
Name = r(1),
ProjectFile = r(2),
Identifier = r(3),
};
this.Projects.Add(p);
}
Project = data.ReadLine();
}
}
/// <summary>
/// Create dependent file node based on an msbuild item
/// </summary>
/// <param name="item">msbuild item</param>
/// <returns>dependent file node</returns>
public virtual FileNode CreateDependentFileNode(ProjectElement item)
{
// заменил возвращаемый тип с DependentFileNode на FileNode
// для поддержки наследования NemerleDependentFileNode -> NemerleFileNode
return new DependentFileNode(this, item);
}
/// <summary>
/// Initializes a new instance of the <see cref="SourceModelProxy"/> class.
/// </summary>
/// <param name="source">The source.</param>
public SourceModelProxy(SourceModelServices source)
{
if (source == null)
{
throw new ArgumentNullException("source", "source is null.");
}
Contract.EndContractBlock();
this.activeProject = GetNonNull(source.ActiveProject, "source.ActiveProject");
this.activeSourceFile = GetNonNull(source.ActiveSourceFile, "source.ActiveSourceFile");
}
protected virtual void LoadImportedNamespaces(ProjectElement project, XmlDocument doc, string projectDir, string projectLangTag)
{
string lImportsQuery = String.Format(STR_ImportsQueryFormat, projectLangTag);
XmlNodeList lImports = doc.SelectNodes(lImportsQuery);
int lCount = lImports.Count;
for (int i = 0; i < lCount; i++)
{
System.Xml.XmlNode lImportNode = lImports[i];
System.Xml.XmlNode lNamespace = lImportNode.Attributes.GetNamedItem(STR_Namespace);
string lNamespaceStr = lNamespace.Value;
project.AddImportedNamespace(lNamespaceStr);
}
}
protected virtual void LoadReferences(ProjectElement project, Hashtable projects, XmlDocument doc, string projectDir, string projectLangTag)
{
string lReferencesQuery = String.Format(STR_ReferencesQueryFormat, projectLangTag);
XmlNodeList lReferences = doc.SelectNodes(lReferencesQuery);
int lCount = lReferences.Count;
for (int i = 0; i < lCount; i++)
{
System.Xml.XmlNode lReferenceNode = lReferences[i];
System.Xml.XmlNode lName = lReferenceNode.Attributes.GetNamedItem(STR_Name);
System.Xml.XmlNode lAssemblyName = lReferenceNode.Attributes.GetNamedItem(STR_AssemblyName);
if (lAssemblyName != null)
{
string lAssemblyNameStr = lAssemblyName.Value;
string lPath = FrameworkHelper.GetAssemblyPath(lAssemblyNameStr);
if (lPath == null || lPath.Length == 0)
{
System.Xml.XmlNode lHintPath = lReferenceNode.Attributes.GetNamedItem("HintPath");
lPath = lHintPath.Value;
lPath = PathUtilities.GetPath(projectDir, lPath);
if (File.Exists(lPath))
{
AssemblyReference lRef = new AssemblyReference(lPath);
project.AddReference(lRef);
}
}
else
project.AddReferenceByName(lAssemblyNameStr);
}
else
{
System.Xml.XmlNode lProjectRef = lReferenceNode.Attributes.GetNamedItem(STR_Project);
string lGuid = lProjectRef.Value;
ProjectInfo lInfo = projects[lGuid] as ProjectInfo;
if (lInfo != null)
{
AssemblyReference lRef = new AssemblyReference(String.Empty);
lRef.SetSourceProjectFullName(lInfo.FilePath);
project.AddReference(lRef);
}
}
}
}
/// <summary>
/// Adds non member file items to the hierarcy.
/// </summary>
/// <param name="project">The project to modify.</param>
/// <param name="fileList">Files containing the information about the non member file items.</param>
protected virtual void AddNonmemberFileItems(IList<string> fileList)
{
if (fileList == null)
throw new ArgumentNullException("fileList");
foreach (string fileKey in fileList)
{
HierarchyNode parentNode = this;
FolderNode topFolderNode = null;
string canonicalName = fileKey;
if (!Path.IsPathRooted(canonicalName))
canonicalName = Path.Combine(ProjectManager.BaseUri.AbsoluteUrl, fileKey);
if (fileKey.IndexOfAny(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }) < 0)
{
// the parent is the project node, just make sure this isn't the project file itself
if (NativeMethods.IsSamePath(ProjectFile, canonicalName))
continue;
}
else
{
string directoryCanonicalName = Path.GetDirectoryName(canonicalName) + '\\';
ReadOnlyCollection<HierarchyNode> parentFolderNodes = itemIdMap.GetNodesByName(directoryCanonicalName);
if (parentFolderNodes.Count == 1)
{
parentNode = parentFolderNodes[0];
for (HierarchyNode parentChain = parentNode; parentChain != null; parentChain = parentChain.Parent)
{
FolderNode folderNode = parentChain as FolderNode;
if (folderNode != null)
topFolderNode = folderNode;
}
if (topFolderNode != null && !topFolderNode.IsNonmemberItem && topFolderNode.IsExpanded)
topFolderNode = null;
}
}
ProjectElement element = new ProjectElement(this, null, true);
element.Rename(canonicalName);
element.SetMetadata(ProjectFileConstants.Name, canonicalName);
HierarchyNode childNode = this.CreateFileNode(element);
parentNode.AddChild(childNode);
if (topFolderNode != null)
{
topFolderNode.CollapseFolder();
}
}
}
internal void AddAllProjectIssues()
{
if (CodeRush.Source.ActiveProject == null)
{
Error(null, new ErrorArgs(new Exception("You must have a file open in the project you wish to scan.")));
}
else
{
try
{
runType = RunType.Project;
processedFiles = 0;
CodeIssues.Clear();
activeProject = CodeRush.Source.ActiveProject;
totalFiles = CodeRush.Source.ActiveProject.AllFiles.Count;
foreach (SourceFile file in CodeRush.Source.ActiveProject.AllFiles)
CheckIssues(file);
}
catch (Exception err)
{
Debug.Assert(false, "Error Scanning Project", err.Message);
}
}
}
private void Delete(ProjectElement element)
{
element.Project.Remove();
//Shoudl always be true
if (element.Parent is Section)
((Section)element.Parent).Remove(element);
//_parent.CreateMenu();
if (_allProjects != null)
{
var imageCount = Data.Database.Main.Table<ProjectImage>().Count();
_allProjects.Value = imageCount.ToString();
_allProjects.GetImmediateRootElement().Reload(_allProjects, UITableViewRowAnimation.None);
}
}
protected virtual FolderNode VerifySubFolderExists(string path, HierarchyNode parent)
{
FolderNode folderNode = null;
uint uiItemId;
Url url = new Url(this.BaseURI, path);
string strFullPath = url.AbsoluteUrl;
// Folders end in our storage with a backslash, so add one...
this.ParseCanonicalName(strFullPath, out uiItemId);
if (uiItemId != (uint)VSConstants.VSITEMID.Nil)
{
Debug.Assert(this.NodeFromItemId(uiItemId) is FolderNode, "Not a FolderNode");
folderNode = (FolderNode)this.NodeFromItemId(uiItemId);
}
if (folderNode == null && path != null && parent != null)
{
// folder does not exist yet...
// We could be in the process of loading so see if msbuild knows about it
ProjectElement item = null;
foreach (MSBuild.ProjectItem folder in buildProject.GetItems(ProjectFileConstants.Folder))
{
if (String.Compare(folder.EvaluatedInclude.TrimEnd('\\'), path.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase) == 0)
{
item = new ProjectElement(this, folder, false);
break;
}
}
// If MSBuild did not know about it, create a new one
if (item == null)
item = this.AddFolderToMsBuild(path);
folderNode = this.CreateFolderNode(path, item);
parent.AddChild(folderNode);
}
return folderNode;
}
private string GetDefaultNamespace(ProjectElement project)
{
return project.DefaultNamespace ?? project.RootNamespace;
}
protected virtual void LoadCompileUnits(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
}
protected virtual void LoadRootFiles(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
string query = "VisualStudioProject/Files/File";
XmlNodeList files = lDoc.SelectNodes(query);
int count = files.Count;
for (int i = 0; i < count; i++)
{
System.Xml.XmlNode fileNode = files[i];
System.Xml.XmlNode relPath = fileNode.Attributes.GetNamedItem("RelativePath");
string lFilePath = Path.Combine(lProjectDir, relPath.Value);
project.AddDiskFile(lFilePath);
}
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixExtensionReferenceNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixExtensionReferenceNode(WixProjectNode root, ProjectElement element)
: base(root, element)
{
this.InitializeFileChangeEvents();
}
protected internal override FolderNode CreateFolderNode(ProjectElement element)
{
return(new NodejsFolderNode(this, element));
}
public XSharpComReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
BindReferenceData();
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root project node</param>
/// <param name="element">The project element</param>
/// <overloads>There are two overloads for the constructor</overloads>
public SandcastleBuilderProjectReferenceNode(ProjectNode root, ProjectElement element) :
base(root, element)
{
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixLibraryReferenceNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixLibraryReferenceNode(WixProjectNode root, ProjectElement element)
: base(root, element)
{
}
protected override ComReferenceNode CreateComReferenceNode(ProjectElement reference)
{
return(new XSharpComReferenceNode(this.ProjectMgr, reference));
}
/// <summary>
/// Initializes a new instance of the <see cref="MyCustomProjectFileNode"/> class.
/// </summary>
/// <param name="root">The project node.</param>
/// <param name="e">The project element node.</param>
internal MyCustomProjectFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
}
protected internal override FolderNode CreateFolderNode(string path, ProjectElement element)
{
FolderNode folderNode = new MultiverseInterfaceFolderNode(this, path, element);
return(folderNode);
}
/// <summary>
/// Initializes a new instance of the <see cref="IronRacketProjectFileNode"/> class.
/// </summary>
/// <param name="root">The project node.</param>
/// <param name="e">The project element node.</param>
internal IronRacketProjectFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
}
protected override void LoadImportedNamespaces(ProjectElement project, XmlDocument doc, string projectDir, string projectLangTag)
{
base.LoadImportedNamespaces(project, doc, projectDir, projectLangTag);
}
private ProjectItemInstance prjitem; // the project item that contains the properties from resolvedProperties
internal XSharpAssemblyReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
//Binding reference data at startup will cause a 'project has changed' method
//BindReferenceData();
}
public ProjectLocation(ProjectElement projectElement)
: this(projectElement.Location.Line, projectElement.Location.Column)
{
}
bool BuildElement(DocumentInfo Doc, string ConfigSetting, string AdditionalPredefines, bool OutputMessages, out Types.BuildInfo BuildInfo, out Types.ASM.FileInfo FileInfo)
{
BuildInfo = new C64Studio.Types.BuildInfo();
BuildInfo.TargetFile = "";
BuildInfo.TargetType = Types.CompileTargetType.NONE;
FileInfo = null;
Types.ASM.FileInfo combinedFileInfo = null;
try
{
if (Doc.Element != null)
{
Doc.Element.CompileTarget = Types.CompileTargetType.NONE;
Doc.Element.CompileTargetFile = null;
// check dependencies
foreach (var dependency in Doc.Element.ForcedDependency.DependentOnFile)
{
var project = Core.MainForm.m_Solution.GetProjectByName(dependency.Project);
if (project == null)
{
Core.AddToOutput("Could not find project \"" + dependency.Project + "\" for dependency \"" + dependency.Filename + "\" for \"" + Doc.DocumentFilename + "\"" + System.Environment.NewLine);
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
}
ProjectElement elementDependency = project.GetElementByFilename(dependency.Filename);
if (elementDependency == null)
{
Core.AddToOutput("Could not find dependency \"" + dependency.Filename + "\" in project \"" + dependency.Project + "\" for \"" + Doc.DocumentFilename + "\"" + System.Environment.NewLine);
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
Types.ASM.FileInfo dependencyFileInfo = null;
// skip building if not required
if (!Core.Compiling.NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting))
{
Core.AddToOutput("Dependency " + dependency.Filename + " is current for config " + ConfigSetting + System.Environment.NewLine);
if ((Doc.Type == ProjectElement.ElementType.ASM_SOURCE) ||
(Doc.Type == ProjectElement.ElementType.BASIC_SOURCE))
{
dependencyFileInfo = elementDependency.DocumentInfo.ASMFileInfo;
//Debug.Log( "Doc " + Doc.Text + " receives " + dependencyFileInfo.Labels.Count + " dependency labels from dependency " + dependency.Filename );
}
}
else
{
Types.BuildInfo tempInfo = new C64Studio.Types.BuildInfo();
if (!BuildElement(elementDependency.DocumentInfo, ConfigSetting, null, false, out tempInfo, out dependencyFileInfo))
{
return(false);
}
}
// include symbols from dependency
if (dependency.IncludeSymbols)
{
if (combinedFileInfo == null)
{
combinedFileInfo = new C64Studio.Types.ASM.FileInfo();
}
// merge label info
if (dependencyFileInfo != null)
{
foreach (var entry in dependencyFileInfo.Labels)
{
if (!combinedFileInfo.Labels.ContainsKey(entry.Key))
{
combinedFileInfo.Labels.Add(entry.Key, entry.Value);
}
}
//Debug.Log( "Doc " + Doc.Text + " receives " + dependencyFileInfo.Labels.Count + " dependency labels from dependency " + dependency.Filename );
}
}
}
}
if (!Doc.Compilable)
{
// not buildable
// TODO - Autoexport?
return(true);
}
ToolInfo tool = Core.DetermineTool(Doc, false);
ProjectElement.PerConfigSettings configSetting = null;
Parser.ParserBase parser = Core.DetermineParser(Doc);
if (Doc.Element != null)
{
if (!Doc.Element.Settings.ContainsKey(ConfigSetting))
{
Doc.Element.Settings.Add(ConfigSetting, new ProjectElement.PerConfigSettings());
}
configSetting = Doc.Element.Settings[ConfigSetting];
if (!string.IsNullOrEmpty(configSetting.PreBuild))
{
Core.AddToOutput("Running pre build step on " + Doc.Element.Name + System.Environment.NewLine);
if (!Core.Executing.RunCommand(Doc, "pre build", configSetting.PreBuild))
{
return(false);
}
}
if (configSetting.PreBuildChain.Active)
{
if (!BuildChain(configSetting.PreBuildChain, "pre build chain", OutputMessages))
{
return(false);
}
}
Core.AddToOutput("Running build on " + Doc.Element.Name + " with configuration " + ConfigSetting + System.Environment.NewLine);
}
else
{
Core.AddToOutput("Running build on " + Doc.DocumentFilename + System.Environment.NewLine);
}
// include previous symbols
string additionalPredefines = null;
if (parser is Parser.ASMFileParser)
{
((Parser.ASMFileParser)parser).InitialFileInfo = combinedFileInfo;
if (combinedFileInfo != null)
{
//Debug.Log( "Doc " + Doc.Text + " receives " + combinedFileInfo.Labels.Count + " initial labels" );
}
additionalPredefines = AdditionalPredefines;
}
else if (parser is Parser.BasicFileParser)
{
// BASIC may receive symbols from assembly
((Parser.BasicFileParser)parser).InitialFileInfo = combinedFileInfo;
((Parser.BasicFileParser)parser).SetBasicVersion(((Parser.BasicFileParser)parser).Settings.Version);
((Parser.BasicFileParser)parser).Settings.UpperCaseMode = !((SourceBasicEx)Doc.BaseDoc).m_LowerCaseMode;
if (combinedFileInfo != null)
{
//Debug.Log( "Doc " + Doc.Text + " receives " + combinedFileInfo.Labels.Count + " initial labels" );
}
Doc.ASMFileInfo = combinedFileInfo;
}
parser.AssembledOutput = null;
if ((configSetting != null) &&
(!string.IsNullOrEmpty(configSetting.CustomBuild)))
{
Core.AddToOutput("Running custom build step on " + Doc.Element.Name + " with configuration " + ConfigSetting + System.Environment.NewLine);
if (!Core.Executing.RunCommand(Doc, "custom build", configSetting.CustomBuild))
{
return(false);
}
BuildInfo.TargetFile = Doc.Element.TargetFilename;
BuildInfo.TargetType = Doc.Element.TargetType;
}
else
{
ProjectConfig config = null;
if (Doc.Project != null)
{
config = Doc.Project.Settings.Configuration(ConfigSetting);
}
int startAddress = -1;
if ((Doc.Type == ProjectElement.ElementType.BASIC_SOURCE) &&
(Doc.BaseDoc != null))
{
// BASIC files bring a start address
startAddress = ((SourceBasicEx)Doc.BaseDoc).StartAddress;
((Parser.BasicFileParser)parser).SetBasicVersion(((SourceBasicEx)Doc.BaseDoc).BASICVersion);
}
if ((!Core.MainForm.ParseFile(parser, Doc, config, additionalPredefines, OutputMessages, CreatePreProcessedFile)) ||
(!parser.Assemble(new C64Studio.Parser.CompileConfig()
{
TargetType = Core.DetermineTargetType(Doc, parser),
OutputFile = Core.DetermineTargetFilename(Doc, parser),
AutoTruncateLiteralValues = Core.Settings.ASMAutoTruncateLiteralValues,
StartAddress = startAddress,
EnabledHacks = Core.Settings.EnabledC64StudioHacks
})) ||
(parser.Errors > 0))
{
Core.MainForm.AddOutputMessages(parser);
Core.AddToOutput("Build failed, " + parser.Warnings.ToString() + " warnings, " + parser.Errors.ToString() + " errors encountered" + System.Environment.NewLine);
// always show messages if we fail!
//if ( OutputMessages )
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
Core.MainForm.AddOutputMessages(parser);
var compileTarget = Core.DetermineTargetType(Doc, parser);
string compileTargetFile = Core.DetermineTargetFilename(Doc, parser);
if (Doc.Element != null)
{
Doc.Element.CompileTargetFile = compileTargetFile;
}
if (compileTargetFile == null)
{
if (parser is Parser.ASMFileParser)
{
parser.AddError(-1, Types.ErrorCode.E0001_NO_OUTPUT_FILENAME, "No output filename was given, missing element setting or !to <Filename>,<FileType> macro?");
}
else
{
parser.AddError(-1, Types.ErrorCode.E0001_NO_OUTPUT_FILENAME, "No output filename was given, missing element setting");
}
if (OutputMessages)
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
BuildInfo.TargetFile = compileTargetFile;
BuildInfo.TargetType = compileTarget;
if (parser.Warnings > 0)
{
if (OutputMessages)
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
}
}
if (string.IsNullOrEmpty(BuildInfo.TargetFile))
{
Core.AddToOutput("No target file name specified" + System.Environment.NewLine);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
// write output if applicable
if ((parser.AssembledOutput != null) &&
(parser.AssembledOutput.Assembly != null))
{
try
{
System.IO.File.WriteAllBytes(BuildInfo.TargetFile, parser.AssembledOutput.Assembly.Data());
}
catch (System.Exception ex)
{
Core.AddToOutput("Build failed, Could not create output file " + parser.CompileTargetFile + System.Environment.NewLine);
Core.AddToOutput(ex.ToString() + System.Environment.NewLine);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
Core.AddToOutput("Build successful, " + parser.Warnings.ToString() + " warnings, 0 errors encountered" + System.Environment.NewLine);
Core.AddToOutput("Start address $" + parser.AssembledOutput.OriginalAssemblyStartAddress.ToString("X4")
+ " to $" + (parser.AssembledOutput.OriginalAssemblyStartAddress + parser.AssembledOutput.OriginalAssemblySize - 1).ToString("X4")
+ ", size " + parser.AssembledOutput.OriginalAssemblySize + " bytes" + System.Environment.NewLine);
Core.AddToOutput("Compiled to file " + BuildInfo.TargetFile + ", " + parser.AssembledOutput.Assembly.Length + " bytes" + System.Environment.NewLine);
//Debug.Log( "File " + Doc.DocumentFilename + " was rebuilt for config " + ConfigSetting + " this round" );
}
if ((configSetting != null) &&
(configSetting.PostBuildChain.Active))
{
if (!BuildChain(configSetting.PostBuildChain, "post build chain", OutputMessages))
{
return(false);
}
}
if ((configSetting != null) &&
(!string.IsNullOrEmpty(configSetting.PostBuild)))
{
Core.ShowDocument(Core.MainForm.m_Output);
Core.AddToOutput("Running post build step on " + Doc.Element.Name + System.Environment.NewLine);
if (!Core.Executing.RunCommand(Doc, "post build", configSetting.PostBuild))
{
return(false);
}
}
Doc.HasBeenSuccessfullyBuilt = true;
if (parser is Parser.ASMFileParser)
{
FileInfo = ((Parser.ASMFileParser)parser).ASMFileInfo;
// update symbols in main asm file
Doc.SetASMFileInfo(FileInfo, parser.KnownTokens(), parser.KnownTokenInfo());
//Debug.Log( "Doc " + Doc.Text + " gets " + ( (SourceASM)Doc ).ASMFileInfo.Labels.Count + " labels" );
}
if (FileInfo != null)
{
if (!string.IsNullOrEmpty(FileInfo.LabelDumpFile))
{
Core.MainForm.DumpLabelFile(FileInfo);
}
}
Core.Compiling.m_RebuiltFiles.Add(Doc.DocumentFilename);
return(true);
}
catch (Exception ex)
{
Core.AddToOutput("An error occurred during building an element\r\n" + ex.ToString());
return(false);
}
}
public CommonReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
}
public LinkFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
}
public static bool ConditionChainsAreEquivalent(this ProjectElement projectElement, ProjectElement otherProjectElement)
{
return(projectElement.ConditionChain().SetEquals(otherProjectElement.ConditionChain()));
}
internal protected override FolderNode CreateFolderNode(string path, ProjectElement item)
{
return(new ConfigurationFolderNode(this, path, item));
}
/// <summary>
/// Invoked when it comes time to set the root
/// </summary>
private void CreateMenu()
{
var root = new RootElement(Title);
root.Add(new Section() {
new MenuElement("Add Pattern", () => OpenAddPatternView(), Images.Menu.Plus)
});
var browseSection = new Section() { HeaderView = new MenuSectionView("Browse") };
root.Add(browseSection);
browseSection.Add(new MenuElement("Recently Added", () => {
var c = new RecentPatternsViewController();
NavigationController.PushViewController(c, true);
}, Images.Menu.Recent));
browseSection.Add(new MenuElement("UI Patterns", () => {
var c = new PatternCategoriesViewController();
NavigationController.PushViewController(c, true);
}, Images.Menu.UIPatterns));
browseSection.Add(new MenuElement("Icons", () => {
var c = new IconBrowserController();
NavigationController.PushViewController(c, true);
}, Images.Menu.Icons));
var albumSection = new Section() { HeaderView = new MenuSectionView("Albums") };
root.Add(albumSection);
var imageCount = Data.Database.Main.Table<ProjectImage>().Count();
_allProjects = new MenuElement("All Albums", imageCount.ToString(), UITableViewCellStyle.Value1) { Image = Images.Menu.AllAlbums };
_allProjects.Tapped += () => {
if (Data.Database.Main.Table<ProjectImage>().Count() > 0)
NavigationController.PushViewController(new LocalViewPatternsViewController() { Title = "All" }, true);
else
{
}
};
albumSection.Add(_allProjects);
var projects = Data.Database.Main.Table<Project>();
foreach (var p in projects)
{
var project = p;
var element = new ProjectElement(project, this) { Image = Images.Menu.Album };
albumSection.Add(element);
}
// albumSection.Add(new MenuElement("Add Album", () => {
// PresentViewController(new UINavigationController(new NewAlbumViewController((r) => {
// DismissViewController(true, null);
// })), true, null);
// }, null));
//
var moreSection = new Section() { HeaderView = new MenuSectionView("Info") };
root.Add(moreSection);
moreSection.Add(new MenuElement("About", () => NavigationController.PushViewController(new AboutController(), true), Images.Menu.Info));
moreSection.Add(new MenuElement("Feedback & Support", () => {
var config = UserVoice.UVConfig.Create("appreciateui.uservoice.com", "y2jtRDr35UyLi2fjSv16bA", "x9U5XhzGUPdsghNbzNq3UHxtGDeuETsuwT4ufmV2Q");
UserVoice.UserVoice.PresentUserVoiceInterface(this, config);
}, Images.Menu.Feedback));
Root = root;
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixFileNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixFileNode(WixProjectNode root, ProjectElement element)
: this(root, element, false)
{
}
/// <summary>
/// To support virtual folders, override this method to return your own folder nodes
/// </summary>
/// <param name="path">Path to store for this folder</param>
/// <param name="element">Element corresponding to the folder</param>
/// <returns>A FolderNode that can then be added to the hierarchy</returns>
public virtual FolderNode CreateFolderNode(string path, ProjectElement element)
{
if (element == null)
throw new ArgumentNullException("element");
FolderNode folderNode = new FolderNode(this, path, element);
return folderNode;
}
public IDisposable TrackElement(ProjectElement element)
{
return(_shouldTrackElements ? new EvaluationFrame(this, CurrentLocation.WithFileLineAndElement(element.Location.File, element.Location.Line, element)) : null);
}
/// <summary>
/// Adds non member folder items to the hierarcy.
/// </summary>
/// <param name="project">The project to modify.</param>
/// <param name="folderList">Folders list containing the folder names.</param>
protected virtual void AddNonmemberFolderItems(IList<string> folderList)
{
if (folderList == null)
{
throw new ArgumentNullException("folderList");
}
foreach (string folderKey in folderList)
{
HierarchyNode parentNode = this;
string[] folders = folderKey.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
FolderNode topFolderNode = null;
foreach (string folder in folders)
{
string childNodeId = Path.Combine(parentNode.VirtualNodeName, folder);
HierarchyNode childNode = parentNode.FindChild(childNodeId, false);
if (childNode == null)
{
if (topFolderNode == null)
{
topFolderNode = parentNode as FolderNode;
if (topFolderNode != null && (!topFolderNode.IsNonmemberItem) && topFolderNode.IsExpanded)
{
topFolderNode = null;
}
}
ProjectElement element = new ProjectElement(this, null, true);
FolderNode folderNode = this.CreateFolderNode(childNodeId, element);
childNode = folderNode;
parentNode.AddChild(childNode);
}
parentNode = childNode;
}
if (topFolderNode != null)
{
topFolderNode.CollapseFolder();
}
}
}
protected virtual void LoadRootNamespace(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
string lSettingsQuery = String.Format(STR_SettingsQueryFormat, lProjectLangTag);
XmlNodeList lSettings = lDoc.SelectNodes(lSettingsQuery);
int lCount = lSettings.Count;
if (lCount > 0)
{
System.Xml.XmlNode lSettingsNode = lSettings[0];
System.Xml.XmlNode lRootNamespace = lSettingsNode.Attributes.GetNamedItem(STR_RootNamespace);
if (lRootNamespace != null)
project.SetRootNamespace(lRootNamespace.Value);
}
}
public WixFileNode(WixProjectNode root, ProjectElement element, bool isNonMemberItem)
: base(root, element)
{
this.isNonMemberItem = isNonMemberItem;
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
protected override ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return(new NemerleProjectReferenceNode(this.ProjectMgr, element));
}
protected virtual void LoadFiles(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
string lFilesQuery = GetFilesQuery(lProjectLangTag);
XmlNodeList lFiles = lDoc.SelectNodes(lFilesQuery);
int lCount = lFiles.Count;
for (int i = 0; i < lCount; i++)
{
System.Xml.XmlNode lFileNode = lFiles[i];
System.Xml.XmlNode lRelPath = lFileNode.Attributes.GetNamedItem(STR_RelPath);
string lFilePath = Path.Combine(lProjectDir, lRelPath.Value);
SourceFile proxy = project.AddDiskFile(lFilePath);
proxy.BuildProjectSymbols();
}
}
public NodejsFolderNode(CommonProjectNode root, ProjectElement element) : base(root, element)
{
_project = root;
}
protected override void LoadReferences(ProjectElement project, Hashtable projects, XmlDocument doc, string projectDir, string projectLangTag)
{
// Vs2002 VC doesn't stores assembly references, instead #using <dll> directive is used.
}
/// <summary>
/// Constructor for the NemerleDependentFileNode
/// </summary>
/// <param name="root">Root of the hierarchy</param>
/// <param name="e">Associated project element</param>
public NemerleDependentFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
HasParentNodeNameRelation = false;
}
protected override void LoadFiles(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
LoadRootFiles(project, lDoc, lProjectDir, lProjectLangTag);
LoadFilterFiles(project, lDoc, lProjectDir, lProjectLangTag);
}
protected virtual ReferenceNode CreateJarReferenceNode(ProjectElement element)
{
return(new JarReferenceNode(ProjectManager, element));
}
protected override void LoadRootNamespace(ProjectElement project, XmlDocument lDoc, string lProjectDir, string lProjectLangTag)
{
base.LoadRootNamespace(project, lDoc, lProjectDir, lProjectLangTag);
}
protected virtual ReferenceNode CreateMavenReferenceNode(ProjectElement element)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a COM reference node from the project element.
/// </summary>
/// <returns>A COM reference node</returns>
protected override ComReferenceNode CreateComReferenceNode(ProjectElement reference)
{
return(new SandcastleBuilderComReferenceNode(this.ProjectManager, reference));
}
private string ExpectedNamespace(ProjectElement project, string documentPath, LanguageElement element)
{
string fullExpectedNamespace = ExpectedNamespace(project, documentPath);
string parentNamespace = CurrentNamespace(element.Parent);
return fullExpectedNamespace.StartsWith(String.Format("{0}.", parentNamespace)) ? fullExpectedNamespace.Substring(parentNamespace.Length + 1) : fullExpectedNamespace;
}
/// <summary>
/// Creates the file node.
/// </summary>
/// <param name="item">The project element item.</param>
/// <returns></returns>
public override FileNode CreateFileNode(ProjectElement item)
{
MyCustomProjectFileNode node = new MyCustomProjectFileNode(this, item);
node.OleServiceProvider.AddService(typeof(EnvDTE.Project), new OleServiceProvider.ServiceCreatorCallback(this.CreateServices), false);
node.OleServiceProvider.AddService(typeof(ProjectItem), node.ServiceCreator, false);
node.OleServiceProvider.AddService(typeof(VSProject), new OleServiceProvider.ServiceCreatorCallback(this.CreateServices), false);
return node;
}
/// <summary>
/// Create a file node based on an msbuild item.
/// </summary>
/// <param name="item">msbuild item</param>
/// <returns>FileNode added</returns>
public virtual FileNode CreateFileNode(ProjectElement item)
{
return new FileNode(this, item);
}
//=====================================================================
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
protected override ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return(new SandcastleBuilderProjectReferenceNode(this.ProjectManager, element));
}
public static IEnumerable <string> AllConditions(this ProjectElement projectElement)
{
return(new string[] { projectElement.Condition }.Concat(projectElement.AllParents.Select(p => p.Condition)));
}
/// <summary>
/// Create dependent file node based on an msbuild item
/// </summary>
/// <param name="item">msbuild item</param>
/// <returns>dependent file node</returns>
public virtual DependentFileNode CreateDependentFileNode(ProjectElement item)
{
return new DependentFileNode(this, item);
}
public PythonProjectReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
}
/// <summary>
/// To support virtual folders, override this method to return your own folder nodes
/// </summary>
/// <param name="path">Path to store for this folder</param>
/// <param name="element">Element corresponding to the folder</param>
/// <returns>A FolderNode that can then be added to the hierarchy</returns>
protected internal virtual FolderNode CreateFolderNode(string path, ProjectElement element)
{
FolderNode folderNode = new FolderNode(this, path, element);
return folderNode;
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
/// <param name="element">MSBuild properties for the project.</param>
/// <returns>A <see cref="WixProjectReferenceNode"/> instance.</returns>
protected override ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return(new WixProjectReferenceNode(this.ProjectMgr as WixProjectNode, element));
}
public PythonFolderNode(CommonProjectNode root, string path, ProjectElement element)
: base(root, path, element)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="XSharpFileNode"/> class.
/// </summary>
/// <param name="root">The project node.</param>
/// <param name="e">The project element node.</param>
internal XSharpFileNode(XSharpProjectNode root, ProjectElement element)
: this(root, element, false)
{
}
