public static async Task FindAllReferencesAsync(string documentIdString, Projects.Project hintProject = null)
{
if (hintProject == null)
{
hintProject = IdeApp.Workbench.ActiveDocument?.Project;
}
var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true);
try {
foreach (var provider in findReferencesProvider)
{
foreach (var result in await provider.FindAllReferences(documentIdString, hintProject, monitor.CancellationToken))
{
monitor.ReportResult(result);
}
}
} catch (OperationCanceledException) {
} catch (Exception ex) {
if (monitor != null)
{
monitor.ReportError("Error finding references", ex);
}
else
{
LoggingService.LogError("Error finding references", ex);
}
} finally {
if (monitor != null)
{
monitor.Dispose();
}
}
}
protected override void OnSetProject(Projects.Project project)
{
base.OnSetProject(project);
if (gproject != null && gproject.Project == project)
{
return;
}
if (designer != null)
{
designerStatus = designer.SaveStatus();
}
CloseDesigner();
CloseProject();
if (project != null)
{
GuiBuilderWindow w = GuiBuilderDisplayBinding.GetWindow(this.ContentName, project);
if (w != null)
{
AttachWindow(w);
if (designerStatus != null)
{
designer.LoadStatus(designerStatus);
}
designerStatus = null;
}
}
}
internal async void Load(FigmaBundle bundle, Projects.Project project)
{
this.mainBundle = bundle;
this.project = project;
bundlePopUp.RemoveAllItems();
bundlePopUp.AddItem(bundle.Manifest.DocumentTitle);
//loads current versions
versionPopUp.RemoveAllItems();
versionPopUp.AddItem("Latest");
ShowLoading(true);
EnableViews(false);
var versionTask = Task.Run(() => {
try {
var query = new FigmaFileVersionQuery(bundle.FileId);
var figmaFileVersions = FigmaSharp.AppContext.Api.GetFileVersions(query)
.versions;
var result = figmaFileVersions
.GroupByCreatedAt()
.ToArray();
return(result);
} catch (Exception ex) {
Console.WriteLine(ex);
return(null);
}
});
var figmaDirectory = Path.GetDirectoryName(bundle.DirectoryPath);
var currentProjectBundles = GetFromFigmaDirectory(figmaDirectory);
versions = await versionTask;
bundlePopUp.RemoveAllItems();
foreach (var figmaNode in currentProjectBundles)
{
bundlePopUp.AddItem(figmaNode.Manifest.DocumentTitle);
}
ShowLoading(false);
EnableViews(true);
if (versions != null && versions.Length > 0)
{
foreach (var version in versions)
{
versionMenu.AddItem(version);
}
}
versionMenu.Generate(versionPopUp.Menu);
//select current version
var menu = versionMenu.GetMenuItem(bundle.Version);
versionPopUp.SelectItem(menu);
}
public static async Task FindAllReferencesAsync(string documentIdString, Projects.Project hintProject = null)
{
if (hintProject == null)
{
hintProject = IdeApp.Workbench.ActiveDocument?.Project;
}
ITimeTracker timer = null;
var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true, true);
try {
var metadata = Counters.CreateFindReferencesMetadata();
timer = Counters.FindReferences.BeginTiming(metadata);
var tasks = new List <(Task task, FindReferencesProvider provider)> (findReferencesProvider.Count);
foreach (var provider in findReferencesProvider)
{
try {
tasks.Add((provider.FindAllReferences(documentIdString, hintProject, monitor), provider));
} catch (OperationCanceledException) {
Counters.SetUserCancel(metadata);
return;
} catch (Exception ex) {
Counters.SetFailure(metadata);
if (monitor != null)
{
monitor.ReportError("Error finding references", ex);
}
LoggingService.LogError("Error finding references", ex);
findReferencesProvider = findReferencesProvider.Remove(provider);
}
}
foreach (var task in tasks)
{
try {
await task.task;
} catch (OperationCanceledException) {
Counters.SetUserCancel(metadata);
return;
} catch (Exception ex) {
Counters.SetFailure(metadata);
if (monitor != null)
{
monitor.ReportError("Error finding references", ex);
}
LoggingService.LogError("Error finding references", ex);
findReferencesProvider = findReferencesProvider.Remove(task.provider);
}
}
} finally {
if (monitor != null)
{
monitor.Dispose();
}
if (timer != null)
{
timer.Dispose();
}
}
}
public Developer(int p1, string p2, string p3, Departments departments, int p4, Projects.Project project)
{
// TODO: Complete member initialization
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.departments = departments;
this.p4 = p4;
this.project = project;
}
// public static IUnresolvedMember AddCodeDomMember (MonoDevelop.Projects.Project project, IUnresolvedTypeDefinition type, CodeTypeMember newMember)
// {
// bool isOpen;
// var data = TextFileProvider.Instance.GetTextEditorData (type.Region.FileName, out isOpen);
// var parsedDocument = IdeApp.TypeSystemService.ParseFile (data.FileName, data.MimeType, data.Text);
//
// var insertionPoints = GetInsertionPoints (data, parsedDocument, type);
//
// var suitableInsertionPoint = GetSuitableInsertionPoint (insertionPoints, type, newMember);
//
// var dotNetProject = project as DotNetProject;
// if (dotNetProject == null) {
// LoggingService.LogError ("Only .NET projects are supported.");
// return null;
// }
//
// var generator = dotNetProject.LanguageBinding.GetCodeDomProvider ();
// StringWriter sw = new StringWriter ();
// var options = new CodeGeneratorOptions ();
// options.IndentString = data.GetLineIndent (type.Region.BeginLine) + "\t";
// if (newMember is CodeMemberMethod)
// options.BracingStyle = "C";
// generator.GenerateCodeFromMember (newMember, sw, options);
//
// var code = sw.ToString ();
// if (!string.IsNullOrEmpty (code))
// suitableInsertionPoint.Insert (data, code);
// if (!isOpen) {
// try {
// File.WriteAllText (type.Region.FileName, data.Text);
// } catch (Exception e) {
// LoggingService.LogError (string.Format ("Failed to write file '{0}'.", type.Region.FileName), e);
// MessageService.ShowError (GettextCatalog.GetString ("Failed to write file '{0}'.", type.Region.FileName));
// }
// }
// var newDocument = IdeApp.TypeSystemService.ParseFile (data.FileName, data.MimeType, data.Text);
// return newDocument.ParsedFile.GetMember (suitableInsertionPoint.Location.Line, int.MaxValue);
// }
public static async Task AddNewMember(Projects.Project project, ITypeSymbol type, Location part, SyntaxNode newMember, CancellationToken cancellationToken = default(CancellationToken))
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (newMember == null)
{
throw new ArgumentNullException(nameof(newMember));
}
if (!type.IsDefinedInSource())
{
throw new ArgumentException("The given type needs to be defined in source code.", nameof(type));
}
var ws = IdeApp.TypeSystemService.GetWorkspace(project.ParentSolution);
var projectId = ws.GetProjectId(project);
var docId = ws.GetDocumentId(projectId, part.SourceTree.FilePath);
var document = ws.GetDocument(docId, cancellationToken);
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var typeDecl = (ClassDeclarationSyntax)root.FindNode(part.SourceSpan);
// for some reason the reducer doesn't reduce this
var systemVoid = newMember.DescendantNodesAndSelf().OfType <QualifiedNameSyntax> ().FirstOrDefault(ma => ma.ToString() == "System.Void");
if (systemVoid != null)
{
newMember = newMember.ReplaceNode(systemVoid, SyntaxFactory.ParseTypeName("void"));
}
var newRoot = root.ReplaceNode(typeDecl, typeDecl.AddMembers((MemberDeclarationSyntax)newMember.WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation)));
document = document.WithSyntaxRoot(newRoot);
var projectOptions = await document.GetOptionsAsync(cancellationToken);
document = await Formatter.FormatAsync(document, Formatter.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
var newSolution = ws.CurrentSolution.WithDocumentText(docId, text);
await Runtime.RunInMainThread(() => {
ws.TryApplyChanges(newSolution);
});
}
private void menuProjectLanguage_Click(object sender, EventArgs e)
{
object[] properties = (object[])((ToolStripMenuItem)sender).Tag;
Projects.Project project = (Projects.Project)(properties[0]);
Projects.ProjectLanguage lang = (Projects.ProjectLanguage)(properties[1]);
Properties.Settings.Default.ProjectLanguage = lang.shortname;
Properties.Settings.Default.Project = project.shortname;
Properties.Settings.Default.Save();
loadSelectedProject();
}
public static async Task RoslynJumpToDeclaration(ISymbol symbol, Projects.Project hintProject = null, CancellationToken token = default(CancellationToken))
{
var result = await TryJumpToDeclarationAsync(symbol.GetDocumentationCommentId(), hintProject, token).ConfigureAwait(false);
if (!result)
{
await Runtime.RunInMainThread(delegate {
IdeApp.ProjectOperations.JumpToDeclaration(symbol, hintProject);
});
}
}
public static async Task RoslynJumpToDeclaration(ISymbol symbol, Projects.Project hintProject = null, CancellationToken token = default(CancellationToken))
{
if (symbol.Locations.Any(loc => loc.IsInSource)) // all locals are in source.
{
IdeApp.ProjectOperations.JumpToDeclaration(symbol);
return;
}
var result = await TryJumpToDeclarationAsync(symbol.GetDocumentationCommentId(), hintProject, token).ConfigureAwait(false);
if (!result)
{
IdeApp.ProjectOperations.JumpToDeclaration(symbol, hintProject);
}
}
public override void ModifyTags(
Projects.SolutionItem policyParent,
Projects.Project project,
string language,
string identifier,
string fileName,
ref Dictionary <string, string> tags)
{
base.ModifyTags(policyParent, project, language, identifier, fileName, ref tags);
if (tags != null)
{
tags["ModuleName"] = DModule.GetModuleName(project == null ? string.Empty : project.BaseDirectory.ToString(), fileName ?? identifier ?? string.Empty).Replace(' ', '_');
}
}
public Task CreateAsync(ProjectCreateParam projectDto)
{
Projects.Project project = ObjectMapper.Map <ProjectCreateParam, Projects.Project>(projectDto);
project.CreationTime = DateTime.Now;
project.CreatorId = CurrentUser.Id;
project.TenantId = CurrentTenant.Id;
project.IsDeleted = false;
var existed = ProjectRepository.FirstOrDefault(c => c.Name == project.Name);
if (existed != null)
{
throw new ArgumentException(L["ProjectError:NameDuplicate"]);
}
ProjectRepository.InsertAsync(project);
return(Task.CompletedTask);
}
public override void ModifyTags(
Projects.SolutionItem policyParent,
Projects.Project project,
string language,
string identifier,
string fileName,
ref Dictionary <string, string> tags)
{
base.ModifyTags(policyParent, project, language, identifier, fileName, ref tags);
tags["ModuleName"] =
Path.ChangeExtension(new FilePath(fileName ?? identifier)
.ToRelative(project.BaseDirectory), null)
.Replace(Path.DirectorySeparatorChar, '.')
.Replace(' ', '_');
}
public void Add([NotNull] Projects.Project project, [NotNull] string sourceFolder, [NotNull] string destinationFolder, FolderSynchronizationMode mode, string pattern)
{
Assert.ArgumentNotNull(project, nameof(project));
Assert.ArgumentNotNull(sourceFolder, nameof(sourceFolder));
Assert.ArgumentNotNull(destinationFolder, nameof(destinationFolder));
Assert.ArgumentNotNull(pattern, nameof(pattern));
var folder = new FolderSynchronizer(project, sourceFolder, destinationFolder, mode, pattern);
lock (syncObject)
{
Folders.Add(folder);
}
SaveProject(project);
}
public override string CreateContent(Projects.Project project, Dictionary <string, string> tags, string language)
{
var cc = base.CreateContent(project, tags, language);
if (addStdHeader)
{
StandardHeaderPolicy headerPolicy = project != null?project.Policies.Get <StandardHeaderPolicy>() : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <StandardHeaderPolicy>();
TextStylePolicy textPolicy = project != null?project.Policies.Get <TextStylePolicy>("text/plain") : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <TextStylePolicy>("text/plain");
DFormattingPolicy dPolicy = project != null?project.Policies.Get <DFormattingPolicy>("text/x-d") : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy <DFormattingPolicy>("text/x-d");
if (string.IsNullOrWhiteSpace(headerPolicy.Text) || !headerPolicy.IncludeInNewFiles)
{
return(cc);
}
var eol = TextStylePolicy.GetEolMarker(textPolicy.EolMarker);
var hdr = StringParserService.Parse(headerPolicy.Text, tags);
if (dPolicy.CommentOutStandardHeaders)
{
var headerLines = hdr.Split('\n');
if (headerLines.Length == 1)
{
return("/// " + headerLines[0].Trim() + eol + cc);
}
else
{
var ret = "/**" + eol;
for (int i = 0; i < headerLines.Length; i++)
{
ret += " * " + headerLines[i].Trim() + eol;
}
return(ret + " */" + eol + cc);
}
}
else
{
return(hdr + eol + cc);
}
}
return(cc);
}
private void LoadProject([NotNull] Projects.Project project, [NotNull] string projectFileName)
{
Debug.ArgumentNotNull(project, nameof(project));
Debug.ArgumentNotNull(projectFileName, nameof(projectFileName));
var fileName = GetConfigFileName(project);
if (!System.IO.File.Exists(fileName))
{
return;
}
var root = System.IO.File.ReadAllText(fileName).ToXElement();
if (root == null)
{
AppHost.Output.Log("Folder Sync: Project is not well-formed: " + fileName);
LogMessage(string.Format("Error: Load Project: {0} is not wellformed", fileName));
return;
}
var folderSyncElement = root.Element("FolderSync");
if (folderSyncElement == null)
{
AppHost.Output.Log("Folder Sync: Project root element is missing: " + fileName);
LogMessage("Error: Load Project: FolderSync element is missing");
return;
}
project.SynchronizeOutputFolderOnBuild = folderSyncElement.GetAttributeValue("SynchronizeProjectOutputFolderOnBuild") == "True";
foreach (var element in folderSyncElement.Elements("Folder"))
{
var sourceFolder = element.GetAttributeValue("SourceFolder");
var destinationFolder = element.GetAttributeValue("DestinationFolder");
var pattern = element.GetAttributeValue("Pattern");
var folder = new FolderSynchronizer(project, sourceFolder, destinationFolder, element.GetAttributeValue("Mode") == "Mirror" ? FolderSynchronizationMode.Mirror : FolderSynchronizationMode.Copy, pattern);
lock (syncObject)
{
Folders.Add(folder);
}
AppHost.Output.Log("Folder Sync: Monitoring : " + folder.AbsoluteSourceFolder + " => " + folder.AbsoluteDestinationFolder);
LogMessage(string.Format("Load Project: Monitoring {0}", folder.AbsoluteSourceFolder));
}
}
private void AddProject([NotNull] Projects.Project project)
{
Debug.ArgumentNotNull(project, nameof(project));
if (Folders.Any(f => f.Project == project))
{
return;
}
project.FileChanged += FileChanged;
project.FileCreated += FileChanged;
project.FileDeleted += FileDeleted;
project.FileRenamed += FileRenamed;
project.ProjectBuilt += ProjectBuilt;
LoadProject(project, project.FileName);
}
public const string Type = "Github"; //TODO: Convert to "github"
public Task <Document> Find(
Projects.Project project,
string documentName,
string version)
{
var rootUrl = project.GetGithubUrl()
.Replace("_version_/", version + "/")
.Replace("www.", ""); //TODO: Can be a problem?
var rawRootUrl = rootUrl
.Replace("github.com", "raw.githubusercontent.com")
.Replace("/tree/", "/"); //TODO: Replacing this can be a problem if I have a tree folder inside the repository
var rawUrl = rawRootUrl + documentName;
var editLink = rootUrl.Replace("/tree/", "/blob/") + documentName;
var localDirectory = "";
var fileName = documentName;
if (documentName.Contains("/"))
{
localDirectory = documentName.Substring(0, documentName.LastIndexOf('/'));
fileName = documentName.Substring(
documentName.LastIndexOf('/') + 1,
documentName.Length - documentName.LastIndexOf('/') - 1
);
}
var token = project.ExtraProperties["GithubAccessToken"]?.ToString(); //TODO: Define GetGithubAccessToken extension method
var document = new Document
{
Title = documentName,
EditLink = editLink,
RootUrl = rootUrl,
RawRootUrl = rawRootUrl,
Format = project.Format,
LocalDirectory = localDirectory,
FileName = fileName,
Version = version,
Content = DownloadWebContent(rawUrl, token)
};
return(Task.FromResult(document));
}
private void RemoveProject([NotNull] Projects.Project project)
{
Debug.ArgumentNotNull(project, nameof(project));
project.FileChanged -= FileChanged;
project.FileCreated -= FileChanged;
project.FileDeleted -= FileDeleted;
project.FileRenamed -= FileRenamed;
lock (syncObject)
{
for (var i = Folders.Count - 1; i >= 0; i--)
{
var folder = Folders[i];
if (folder.Project == project)
{
Folders.Remove(folder);
}
}
}
}
public override ParsedDocument Parse(bool storeAst, string fileName, System.IO.TextReader content, Projects.Project project = null)
{
currentDocument = openDocuments.FirstOrDefault(d => d != null && d.FileName == fileName);
// We need document and project to be loaded to correctly initialize Razor Host.
this.project = project as DotNetProject;
if (currentDocument == null && !TryAddDocument(fileName))
{
return(new RazorCSharpParsedDocument(fileName, new RazorCSharpPageInfo()));
}
this.aspProject = project as AspMvcProject;
EnsureParserInitializedFor(fileName);
var errors = new List <Error> ();
using (var source = new SeekableTextReader(content)) {
var textChange = CreateTextChange(source);
var parseResult = editorParser.CheckForStructureChanges(textChange);
if (parseResult == PartialParseResult.Rejected)
{
parseComplete.WaitOne();
if (!capturedArgs.GeneratorResults.Success)
{
GetRazorErrors(errors);
}
}
}
ParseHtmlDocument(errors);
CreateCSharpParsedDocument();
ClearLastChange();
RazorHostKind kind = RazorHostKind.WebPage;
if (editorParser.Host is WebCodeRazorHost)
{
kind = RazorHostKind.WebCode;
}
else if (editorParser.Host is MonoDevelop.RazorGenerator.RazorHost)
{
kind = RazorHostKind.Template;
}
var pageInfo = new RazorCSharpPageInfo()
{
HtmlRoot = htmlParsedDocument,
GeneratorResults = capturedArgs.GeneratorResults,
Spans = editorParser.CurrentParseTree.Flatten(),
CSharpParsedFile = parsedCodeFile,
CSharpCode = csharpCode,
Errors = errors,
FoldingRegions = GetFoldingRegions(),
Comments = comments,
Compilation = CreateCompilation(),
HostKind = kind,
};
return(new RazorCSharpParsedDocument(fileName, pageInfo));
}
public static async Task <bool> TryJumpToDeclarationAsync(string documentIdString, Projects.Project hintProject = null, CancellationToken token = default(CancellationToken))
{
try {
if (hintProject == null)
{
hintProject = IdeApp.Workbench.ActiveDocument?.Project;
}
foreach (var handler in jumpToDeclarationHandler)
{
if (await handler.TryJumpToDeclarationAsync(documentIdString, hintProject, token))
{
return(true);
}
}
} catch (OperationCanceledException) {
} catch (Exception ex) {
LoggingService.LogError("Error finding references", ex);
}
return(false);
}
public ProjectTVVM(Projects.Project project)
: base(null, true)
{
// TODO: Complete member initialization
this.project = project;
}
public static async Task InsertMemberWithCursor(string operation, Projects.Project project, ITypeSymbol type, Location part, SyntaxNode newMember, CancellationToken cancellationToken = default(CancellationToken))
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (newMember == null)
{
throw new ArgumentNullException(nameof(newMember));
}
var doc = await IdeApp.Workbench.OpenDocument(part.SourceTree.FilePath, project, true);
var textView = await doc.GetContentWhenAvailable <ITextView> (cancellationToken);
await doc.DocumentContext.UpdateParseDocument();
var document = doc.DocumentContext.AnalysisDocument;
if (document == null)
{
LoggingService.LogError("Can't find document to insert member (fileName:" + part.SourceTree.FilePath + ")");
return;
}
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var typeDecl = (ClassDeclarationSyntax)root.FindNode(part.SourceSpan);
// for some reason the reducer doesn't reduce this
var systemVoid = newMember.DescendantNodesAndSelf().OfType <QualifiedNameSyntax> ().FirstOrDefault(ma => ma.ToString() == "System.Void");
if (systemVoid != null)
{
newMember = newMember.ReplaceNode(systemVoid, SyntaxFactory.ParseTypeName("void"));
}
var newRoot = root.ReplaceNode(typeDecl, typeDecl.AddMembers((MemberDeclarationSyntax)newMember.WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation, insertedMemberAnnotation)));
var projectOptions = await document.GetOptionsAsync(cancellationToken);
document = document.WithSyntaxRoot(newRoot);
document = await Formatter.FormatAsync(document, Formatter.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var node = root.GetAnnotatedNodes(insertedMemberAnnotation).Single();
var model = await doc.DocumentContext.AnalysisDocument.GetSemanticModelAsync(cancellationToken);
Application.Invoke((o, args) => {
var editor = doc.Editor;
if (editor == null)
{
// bypass the insertion point selection UI for the new editor
document.Project.Solution.Workspace.TryApplyChanges(document.Project.Solution);
var editorOperationsFactoryService = CompositionManager.Instance.GetExportedValue <IEditorOperationsFactoryService> ();
var editorOperations = editorOperationsFactoryService.GetEditorOperations(textView);
var point = new Microsoft.VisualStudio.Text.VirtualSnapshotPoint(textView.TextSnapshot, node.SpanStart);
editorOperations.SelectAndMoveCaret(point, point, TextSelectionMode.Stream, EnsureSpanVisibleOptions.AlwaysCenter);
return;
}
var insertionPoints = InsertionPointService.GetInsertionPoints(
editor,
model,
type,
part.SourceSpan.Start
);
var options = new InsertionModeOptions(
operation,
insertionPoints,
point => {
if (!point.Success)
{
return;
}
var text = node.ToString();
point.InsertionPoint.Insert(editor, doc.DocumentContext, text);
}
);
editor.StartInsertionMode(options);
});
}
public async Task DeleteAsync(Guid projectID)
{
Projects.Project project = await ProjectRepository.FindAsync(c => c.Id == projectID);
await ProjectRepository.DeleteAsync(project);
}
public static async Task <bool> TryJumpToDeclarationAsync(string documentIdString, Projects.Project hintProject = null, CancellationToken token = default(CancellationToken))
{
if (hintProject == null)
{
hintProject = IdeApp.Workbench.ActiveDocument?.Project;
}
for (int i = 0; i < jumpToDeclarationHandler.Count; i++)
{
var handler = jumpToDeclarationHandler [i];
try {
if (await handler.TryJumpToDeclarationAsync(documentIdString, hintProject, token))
{
return(true);
}
} catch (OperationCanceledException) {
} catch (Exception ex) {
LoggingService.LogError("Error jumping to declaration", ex);
}
}
return(false);
}
public override void AttachToProject(Projects.Project project)
{
throw new NotImplementedException();
}
protected override void OnSetProject(Projects.Project project)
{
base.OnSetProject(project);
content.Project = project;
}
public async Task <ProjectDto> GetProjectAsync(Guid projectID)
{
Projects.Project project = await ProjectRepository.FindAsync(c => c.Id == projectID);
return(ObjectMapper.Map <Projects.Project, ProjectDto>(project));
}
public async Task <ProjectDto> UpdateAsync(ProjectUpdateParam projectDto)
{
Projects.Project project = await ProjectRepository.FindAsync(projectDto.ID);
if (project == null)
{
throw new ArgumentException(L["ProjectError:NameDuplicate"]);
}
if (!projectDto.Name.IsNullOrEmpty() && !projectDto.Name.Equals(project.Name))
{
project.Name = projectDto.Name;
}
if (!projectDto.Description.IsNullOrEmpty() && !projectDto.Description.Equals(project.Description))
{
project.Description = projectDto.Description;
}
if (!projectDto.StartDate.Equals(project.StartDate))
{
project.StartDate = projectDto.StartDate;
}
if (!projectDto.Address.IsNullOrEmpty() && !projectDto.Address.Equals(project.Address))
{
project.Address = projectDto.Address;
}
if (!projectDto.ProjectEstimate.Equals(project.ProjectEstimate))
{
project.ProjectEstimate = projectDto.ProjectEstimate;
}
if (!projectDto.ConstructionUnit.IsNullOrEmpty() && !projectDto.ConstructionUnit.Equals(project.ConstructionUnit))
{
project.ConstructionUnit = projectDto.ConstructionUnit;
}
if (!projectDto.MainContractor.IsNullOrEmpty() && !projectDto.MainContractor.Equals(project.MainContractor))
{
project.MainContractor = projectDto.MainContractor;
}
if (!projectDto.DesignOrganization.IsNullOrEmpty() && !projectDto.DesignOrganization.Equals(project.DesignOrganization))
{
project.DesignOrganization = projectDto.DesignOrganization;
}
if (!projectDto.SupervisingUnit.IsNullOrEmpty() && !projectDto.SupervisingUnit.Equals(project.SupervisingUnit))
{
project.SupervisingUnit = projectDto.SupervisingUnit;
}
if (!projectDto.ConsultingUnit.IsNullOrEmpty() && !projectDto.ConsultingUnit.Equals(project.ConsultingUnit))
{
project.ConsultingUnit = projectDto.ConsultingUnit;
}
if (!projectDto.Area.Equals(project.Area))
{
project.Area = projectDto.Area;
}
if (!projectDto.CompleteDate.Equals(project.CompleteDate))
{
project.CompleteDate = projectDto.CompleteDate;
}
if (!projectDto.Longitude.Equals(project.Longitude))
{
project.Longitude = projectDto.Longitude;
}
if (!projectDto.Latitude.Equals(project.Latitude))
{
project.Latitude = projectDto.Latitude;
}
if (!projectDto.Principal.Equals(project.Principal))
{
project.Principal = projectDto.Principal;
}
project.LastModificationTime = Clock.Now;
project.LastModifierId = this.CurrentUser.Id;
return(ObjectMapper.Map <Projects.Project, ProjectDto>(await ProjectRepository.UpdateAsync(project)));
}
public static async Task InsertMemberWithCursor(string operation, Projects.Project project, ITypeSymbol type, Location part, SyntaxNode newMember, CancellationToken cancellationToken = default(CancellationToken))
{
if (operation == null)
{
throw new ArgumentNullException(nameof(operation));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (newMember == null)
{
throw new ArgumentNullException(nameof(newMember));
}
var doc = await IdeApp.Workbench.OpenDocument(part.SourceTree.FilePath, project, true);
await doc.UpdateParseDocument();
var document = doc.AnalysisDocument;
if (document == null)
{
LoggingService.LogError("Can't find document to insert member (fileName:" + part.SourceTree.FilePath + ")");
return;
}
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var typeDecl = (ClassDeclarationSyntax)root.FindNode(part.SourceSpan);
// for some reason the reducer doesn't reduce this
var systemVoid = newMember.DescendantNodesAndSelf().OfType <QualifiedNameSyntax> ().FirstOrDefault(ma => ma.ToString() == "System.Void");
if (systemVoid != null)
{
newMember = newMember.ReplaceNode(systemVoid, SyntaxFactory.ParseTypeName("void"));
}
var newRoot = root.ReplaceNode(typeDecl, typeDecl.AddMembers((MemberDeclarationSyntax)newMember.WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation, insertedMemberAnnotation)));
var policy = project.Policies.Get <CSharpFormattingPolicy> ("text/x-csharp");
var textPolicy = project.Policies.Get <TextStylePolicy> ("text/x-csharp");
var projectOptions = policy.CreateOptions(textPolicy);
document = document.WithSyntaxRoot(newRoot);
document = await Formatter.FormatAsync(document, Formatter.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
document = await Simplifier.ReduceAsync(document, Simplifier.Annotation, projectOptions, cancellationToken).ConfigureAwait(false);
root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var node = root.GetAnnotatedNodes(insertedMemberAnnotation).Single();
Application.Invoke(async(o, args) => {
var insertionPoints = InsertionPointService.GetInsertionPoints(
doc.Editor,
await doc.UpdateParseDocument(),
type,
part.SourceSpan.Start
);
var options = new InsertionModeOptions(
operation,
insertionPoints,
point => {
if (!point.Success)
{
return;
}
var text = node.ToString();
point.InsertionPoint.Insert(doc.Editor, doc, text);
}
);
doc.Editor.StartInsertionMode(options);
});
}
void Update(Document document, int caretOffset)
{
CancelUpdatePath();
var cancellationToken = src.Token;
Task.Run(async() => {
var root = await document.GetSyntaxRootAsync(cancellationToken);
if (root == null || cancellationToken.IsCancellationRequested)
{
return;
}
amb = new AstAmbience(IdeServices.TypeSystemService.Workspace.Options);
SyntaxNode node;
try {
if (root.FullSpan.Length <= caretOffset)
{
var prevPath = CurrentPath;
CurrentPath = new PathEntry [] { new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = null
} };
isPathSet = false;
Runtime.RunInMainThread(delegate {
OnPathChanged(new DocumentPathChangedEventArgs(prevPath));
}).Ignore();
return;
}
node = root.FindNode(TextSpan.FromBounds(caretOffset, caretOffset));
if (node.SpanStart != caretOffset)
{
node = root.SyntaxTree.FindTokenOnLeftOfPosition(caretOffset, cancellationToken).Parent;
}
} catch (Exception ex) {
LoggingService.LogError("Error updating C# breadcrumbs", ex);
return;
}
var curMember = node?.AncestorsAndSelf().FirstOrDefault(m => m is VariableDeclaratorSyntax && m.Parent != null && !(m.Parent.Parent is LocalDeclarationStatementSyntax) || (m is MemberDeclarationSyntax && !(m is NamespaceDeclarationSyntax)));
var curType = node != null ? node.AncestorsAndSelf().FirstOrDefault(IsType) : null;
var curProject = ownerProjects != null && ownerProjects.Count > 1 ? ownerProjects [0] : null;
if (curType == curMember || curType is DelegateDeclarationSyntax)
{
curMember = null;
}
if (isPathSet && curType == lastType && curMember == lastMember && curProject == lastProject)
{
return;
}
var curTypeMakeup = GetEntityMarkup(curType);
var curMemberMarkup = GetEntityMarkup(curMember);
if (isPathSet && curType != null && lastType != null && curTypeMakeup == lastTypeMarkup &&
curMember != null && lastMember != null && curMemberMarkup == lastMemberMarkup && curProject == lastProject)
{
return;
}
// var regionEntry = await GetRegionEntry (DocumentContext.ParsedDocument, loc).ConfigureAwait (false);
await joinableTaskContext.Factory.SwitchToMainThreadAsync();
if (cancellationToken.IsCancellationRequested)
{
return;
}
var result = new List <PathEntry> ();
if (curProject != null)
{
// Current project if there is more than one
result.Add(new PathEntry(ImageService.GetIcon(curProject.StockIcon, Gtk.IconSize.Menu), GLib.Markup.EscapeText(curProject.Name))
{
Tag = curProject
});
}
if (curType == null)
{
var prevPath = CurrentPath;
result.Add(new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = root.SyntaxTree
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
CurrentPath = result.ToArray();
lastType = curType;
lastTypeMarkup = curTypeMakeup;
lastMember = curMember;
lastMemberMarkup = curMemberMarkup;
lastProject = curProject;
OnPathChanged(new DocumentPathChangedEventArgs(prevPath));
return;
}
if (curType != null)
{
var type = curType;
var pos = result.Count;
while (type != null)
{
if (!(type is BaseTypeDeclarationSyntax))
{
break;
}
var tag = (object)type.Ancestors().FirstOrDefault(IsType) ?? root;
result.Insert(pos, new PathEntry(ImageService.GetIcon(type.GetStockIcon(), Gtk.IconSize.Menu), GetEntityMarkup(type))
{
Tag = tag
});
type = type.Parent;
}
}
if (curMember != null)
{
result.Add(new PathEntry(ImageService.GetIcon(curMember.GetStockIcon(), Gtk.IconSize.Menu), curMemberMarkup)
{
Tag = curMember
});
if (curMember.Kind() == SyntaxKind.GetAccessorDeclaration ||
curMember.Kind() == SyntaxKind.SetAccessorDeclaration ||
curMember.Kind() == SyntaxKind.AddAccessorDeclaration ||
curMember.Kind() == SyntaxKind.RemoveAccessorDeclaration)
{
var parent = curMember.Parent;
if (parent != null)
{
result.Insert(result.Count - 1, new PathEntry(ImageService.GetIcon(parent.GetStockIcon(), Gtk.IconSize.Menu), GetEntityMarkup(parent))
{
Tag = parent
});
}
}
}
// if (regionEntry != null)
// result.Add(regionEntry);
PathEntry noSelection = null;
if (curType == null)
{
noSelection = new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = root
};
}
else if (curMember == null && !(curType is DelegateDeclarationSyntax))
{
noSelection = new PathEntry(GettextCatalog.GetString("No selection"))
{
Tag = curType
};
}
if (noSelection != null)
{
result.Add(noSelection);
}
var prev = CurrentPath;
if (prev != null && prev.Length == result.Count)
{
bool equals = true;
for (int i = 0; i < prev.Length; i++)
{
if (prev [i].Markup != result [i].Markup)
{
equals = false;
break;
}
}
if (equals)
{
return;
}
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
CurrentPath = result.ToArray();
lastType = curType;
lastTypeMarkup = curTypeMakeup;
lastMember = curMember;
lastMemberMarkup = curMemberMarkup;
lastProject = curProject;
OnPathChanged(new DocumentPathChangedEventArgs(prev));
}, cancellationToken).Ignore();
}
public abstract Task <bool> TryJumpToDeclarationAsync(string documentIdString, Projects.Project hintProject, CancellationToken token = default(CancellationToken));
private void loadSelectedProject()
{
#region search Project/Language
Projects.Project selectedProject = null;;
Projects.ProjectLanguage selectedLanguage = null;
foreach (Projects.Project p in Projects.projects)
{
if (p.shortname == Properties.Settings.Default.Project)
{
selectedProject = p;
if (p.languages.Count > 0)
{
foreach (Projects.ProjectLanguage lang in p.languages)
{
if (lang.shortname == Properties.Settings.Default.ProjectLanguage)
{
selectedLanguage = lang;
break;
}
}
}
break;
}
}
if ((selectedProject != null) && (selectedProject.languages.Count == 0))
{
selectedLanguage = null;
}
if (selectedProject == null)
{
selectedProject = Projects.projects[0]; // Wikipedia
}
if ((selectedProject.languages.Count > 0) && (selectedLanguage == null))
{
selectedLanguage = selectedProject.languages[0]; // some (random) standard!
// search for standard language
foreach (Projects.ProjectLanguage lang in selectedProject.languages)
{
if (lang.shortname == selectedProject.standardLanguage)
{
selectedLanguage = lang;
break;
}
}
// maybe the system is in another language
CultureInfo ci = Thread.CurrentThread.CurrentCulture;
string localLanguage = ci.TwoLetterISOLanguageName;
foreach (Projects.ProjectLanguage lang in selectedProject.languages)
{
if (lang.shortname == localLanguage)
{
selectedLanguage = lang;
break;
}
}
}
// save
Properties.Settings.Default.Project = selectedProject.shortname;
if (selectedLanguage != null)
{
Properties.Settings.Default.ProjectLanguage = selectedLanguage.shortname;
}
else
{
Properties.Settings.Default.ProjectLanguage = "";
}
Properties.Settings.Default.Save();
#endregion
// baseUrl
if (selectedProject.languages.Count == 0)
{
Projects.currentProjectBaseUrl = selectedProject.baseUrl;
}
else
{
Projects.currentProjectBaseUrl = selectedLanguage.baseUrl;
}
Projects.currentProjectBaseUrl += selectedProject.adding;//"/w/";
suggestionFetcher = new SuggestionFetcher(Projects.currentProjectBaseUrl, 30);
revisionsFetcher = new RevisionsFetcher(Projects.currentProjectBaseUrl);
// show name
Projects.currentProjectSaveName = "";
if (selectedLanguage != null)
{
Projects.currentProjectSaveName = selectedLanguage.shortname + ".";
}
Projects.currentProjectSaveName += selectedProject.shortname;
labelProject.Text = "Project: " + Projects.currentProjectSaveName;
#region show in menu
// remove all checked
foreach (ToolStripMenuItem m in menuProject.DropDownItems)
{
m.Checked = false;
foreach (ToolStripMenuItem m2 in m.DropDownItems)
{
m2.Checked = false;
}
}
// set checked
foreach (ToolStripMenuItem m in menuProject.DropDownItems)
{
Projects.Project project = ((Projects.Project)m.Tag);
if (project == selectedProject)
{
if (project.languages.Count == 0)
{
m.Checked = true;
}
else
{
foreach (ToolStripMenuItem m2 in m.DropDownItems)
{
object[] properties = (object[])m2.Tag;
Projects.ProjectLanguage lang = (Projects.ProjectLanguage)(properties[1]);
if (lang == selectedLanguage)
{
m2.Checked = true;
break;
}
}
}
break;
}
}
#endregion
}
