Exemple #1
0
        public override void DoGlobalOperationOn(IEntity entity, Action <RefactoringContext, Script, AstNode> callback, string operationName = null)
        {
            using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(operationName ?? GettextCatalog.GetString("Performing refactoring task..."), null)) {
                var col = ReferenceFinder.FindReferences(entity, true, monitor);

                string oldFileName          = null;
                MDRefactoringContext ctx    = null;
                MDRefactoringScript  script = null;
                TextEditorData       data   = null;
                bool hadBom = false;
                System.Text.Encoding encoding = null;
                bool isOpen = true;

                foreach (var r in col)
                {
                    var memberRef = r as CSharpReferenceFinder.CSharpMemberReference;
                    if (memberRef == null)
                    {
                        continue;
                    }

                    if (oldFileName != memberRef.FileName)
                    {
                        if (oldFileName != null && !isOpen)
                        {
                            script.Dispose();
                            Mono.TextEditor.Utils.TextFileUtility.WriteText(oldFileName, data.Text, encoding, hadBom);
                        }

                        data = TextFileProvider.Instance.GetTextEditorData(memberRef.FileName, out hadBom, out encoding, out isOpen);
                        var project = memberRef.Project;

                        ParsedDocument parsedDocument;
                        using (var reader = new StreamReader(data.OpenStream()))
                            parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser().Parse(true, memberRef.FileName, reader, project);
                        var resolver = new CSharpAstResolver(TypeSystemService.GetCompilation(project), memberRef.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile);

                        ctx         = new MDRefactoringContext(project as DotNetProject, data, parsedDocument, resolver, memberRef.AstNode.StartLocation, this.context.CancellationToken);
                        script      = new MDRefactoringScript(ctx, FormattingOptions);
                        oldFileName = memberRef.FileName;
                    }

                    callback(ctx, script, memberRef.AstNode);
                }

                if (oldFileName != null && !isOpen)
                {
                    script.Dispose();
                    Mono.TextEditor.Utils.TextFileUtility.WriteText(oldFileName, data.Text, encoding, hadBom);
                }
            }
        }
Exemple #2
0
        public override void DoGlobalOperationOn(IEnumerable <IEntity> entities, Action <RefactoringContext, Script, IEnumerable <AstNode> > callback, string operationName = null)
        {
            using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(operationName ?? GettextCatalog.GetString("Performing refactoring task..."), null)) {
                var col = entities.SelectMany(entity => ReferenceFinder.FindReferences(entity, true, monitor)).OfType <CSharpReferenceFinder.CSharpMemberReference> ().GroupBy(reference => reference.FileName);

                foreach (var r in col)
                {
                    string filename = r.Key;

                    bool isOpen;
                    System.Text.Encoding encoding;
                    bool hadBom;

                    var data = TextFileProvider.Instance.GetTextEditorData(filename, out hadBom, out encoding, out isOpen);

                    var firstReference = r.First();

                    var project = firstReference.Project;

                    ParsedDocument parsedDocument;
                    using (var reader = new StreamReader(data.OpenStream()))
                        parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser().Parse(true, filename, reader, project);

                    var resolver = new CSharpAstResolver(TypeSystemService.GetCompilation(project), firstReference.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile);

                    var ctx    = new MDRefactoringContext(project as DotNetProject, data, parsedDocument, resolver, firstReference.AstNode.StartLocation, this.context.CancellationToken);
                    var script = new MDRefactoringScript(ctx, FormattingOptions);

                    callback(ctx, script, r.Select(reference => reference.AstNode));

                    if (!isOpen)
                    {
                        script.Dispose();
                        Mono.TextEditor.Utils.TextFileUtility.WriteText(filename, data.Text, encoding, hadBom);
                    }
                }
            }
        }
		public override void DoGlobalOperationOn (IEntity entity, Action<RefactoringContext, Script, AstNode> callback, string operationName = null)
		{
			using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor (operationName ?? GettextCatalog.GetString ("Performing refactoring task..."), null)) {
				var col = ReferenceFinder.FindReferences (entity, true, monitor);

				string oldFileName = null;
				MDRefactoringContext ctx = null;
				MDRefactoringScript script = null;
				TextEditorData data = null;
				bool hadBom = false;
				System.Text.Encoding encoding = null;
				bool isOpen = true;

				foreach (var r in col) {
					var memberRef = r as CSharpReferenceFinder.CSharpMemberReference;
					if (memberRef == null)
						continue;

					if (oldFileName != memberRef.FileName) {
						if (oldFileName != null && !isOpen) {
							script.Dispose ();
							Mono.TextEditor.Utils.TextFileUtility.WriteText (oldFileName, data.Text, encoding, hadBom);
						}

						data = TextFileProvider.Instance.GetTextEditorData (memberRef.FileName, out hadBom, out encoding, out isOpen);
						var project = memberRef.Project;

						ParsedDocument parsedDocument;
						using (var reader = new StreamReader (data.OpenStream ()))
							parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser ().Parse (true, memberRef.FileName, reader, project);
						var resolver = new CSharpAstResolver (TypeSystemService.GetCompilation (project), memberRef.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile);

						ctx = new MDRefactoringContext (project as DotNetProject, data, parsedDocument, resolver, memberRef.AstNode.StartLocation, this.context.CancellationToken);
						script = new MDRefactoringScript (ctx, FormattingOptions);
						oldFileName = memberRef.FileName;
					}

					callback (ctx, script, memberRef.AstNode);
				}

				if (oldFileName != null && !isOpen) {
					script.Dispose ();
					Mono.TextEditor.Utils.TextFileUtility.WriteText (oldFileName, data.Text, encoding, hadBom);
				}
			}
		}
Exemple #4
0
        public override Task <Script> InsertWithCursor(string operation, ITypeDefinition parentType, Func <Script, RefactoringContext, IEnumerable <AstNode> > nodeCallback)
        {
            var tcs = new TaskCompletionSource <Script>();

            if (parentType == null)
            {
                return(tcs.Task);
            }
            var part = parentType.Parts.FirstOrDefault();

            if (part == null)
            {
                return(tcs.Task);
            }

            var loadedDocument = Ide.IdeApp.Workbench.OpenDocument(part.Region.FileName);

            loadedDocument.RunWhenLoaded(delegate {
                var editor         = loadedDocument.Editor;
                var loc            = part.Region.Begin;
                var parsedDocument = loadedDocument.UpdateParseDocument();
                var declaringType  = parsedDocument.GetInnermostTypeDefinition(loc);
                MDRefactoringScript script;

                if (loadedDocument.Editor != this.context.TextEditor)
                {
                    script = new MDRefactoringScript(new MDRefactoringContext(loadedDocument, loc, context.CancellationToken), FormattingOptions);
                    startedScripts.Add(script);
                }
                else
                {
                    script = this;
                }
                var nodes = nodeCallback(script, script.context);
                var mode  = new InsertionCursorEditMode(
                    editor.Parent,
                    CodeGenerationService.GetInsertionPoints(loadedDocument, declaringType));
                if (mode.InsertionPoints.Count == 0)
                {
                    MessageService.ShowError(
                        GettextCatalog.GetString("No valid insertion point can be found in type '{0}'.", declaringType.Name)
                        );
                    return;
                }
                if (declaringType.Kind == TypeKind.Enum)
                {
                    foreach (var node in nodes.Reverse())
                    {
                        var output = OutputNode(CodeGenerationService.CalculateBodyIndentLevel(declaringType), node);
                        var point  = mode.InsertionPoints.First();
                        var offset = loadedDocument.Editor.LocationToOffset(point.Location);
                        var text   = output.Text + ",";
                        var delta  = point.Insert(editor, text);
                        output.RegisterTrackedSegments(script, delta + offset);
                    }
                    tcs.SetResult(script);
                    return;
                }

                var helpWindow       = new Mono.TextEditor.PopupWindow.InsertionCursorLayoutModeHelpWindow();
                helpWindow.TitleText = operation;
                mode.HelpWindow      = helpWindow;

                mode.CurIndex = 0;
                operationsRunning++;
                mode.StartMode();
                mode.Exited += delegate(object s, InsertionCursorEventArgs iCArgs) {
                    if (iCArgs.Success)
                    {
                        if (iCArgs.InsertionPoint.LineAfter == NewLineInsertion.None &&
                            iCArgs.InsertionPoint.LineBefore == NewLineInsertion.None && nodes.Count() > 1)
                        {
                            iCArgs.InsertionPoint.LineAfter = NewLineInsertion.BlankLine;
                        }
                        foreach (var node in nodes.Reverse())
                        {
                            var output = OutputNode(CodeGenerationService.CalculateBodyIndentLevel(declaringType), node);
                            var offset = loadedDocument.Editor.LocationToOffset(iCArgs.InsertionPoint.Location);
                            var text   = output.Text;
                            var delta  = iCArgs.InsertionPoint.Insert(editor, text);
                            output.RegisterTrackedSegments(script, delta + offset);
                        }
                        tcs.SetResult(script);
                    }
                    else
                    {
                        Rollback();
                    }
                    DisposeOnClose();
                };
            });

            return(tcs.Task);
        }
		public override void DoGlobalOperationOn (IEnumerable<IEntity> entities, Action<RefactoringContext, Script, IEnumerable<AstNode>> callback, string operationName = null)
		{
			using (var monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor (operationName ?? GettextCatalog.GetString ("Performing refactoring task..."), null)) {
				var col = entities.SelectMany (entity => ReferenceFinder.FindReferences (entity, true, monitor)).OfType<CSharpReferenceFinder.CSharpMemberReference> ().GroupBy(reference => reference.FileName);

				foreach (var r in col) {
					string filename = r.Key;

					bool isOpen;
					System.Text.Encoding encoding;
					bool hadBom;

					var data = TextFileProvider.Instance.GetTextEditorData (filename, out hadBom, out encoding, out isOpen);

					var firstReference = r.First ();

					var project = firstReference.Project;

					ParsedDocument parsedDocument;
					using (var reader = new StreamReader (data.OpenStream ()))
						parsedDocument = new MonoDevelop.CSharp.Parser.TypeSystemParser ().Parse (true, filename, reader, project);

					var resolver = new CSharpAstResolver (TypeSystemService.GetCompilation (project), firstReference.SyntaxTree, parsedDocument.ParsedFile as CSharpUnresolvedFile);

					var ctx = new MDRefactoringContext (project as DotNetProject, data, parsedDocument, resolver, firstReference.AstNode.StartLocation, this.context.CancellationToken);
					var script = new MDRefactoringScript (ctx, FormattingOptions);

					callback (ctx, script, r.Select (reference => reference.AstNode));

					if (!isOpen) {
						script.Dispose ();
						Mono.TextEditor.Utils.TextFileUtility.WriteText (filename, data.Text, encoding, hadBom);
					}
				}
			}
		}
		public override Task<Script> InsertWithCursor (string operation, ITypeDefinition parentType, Func<Script, RefactoringContext, IList<AstNode>> nodeCallback)
		{
			var tcs = new TaskCompletionSource<Script>();
			if (parentType == null)
				return tcs.Task;
			var part = parentType.Parts.FirstOrDefault ();
			if (part == null)
				return tcs.Task;

			var loadedDocument = IdeApp.Workbench.OpenDocument (new FileOpenInformation (part.Region.FileName, null));
			loadedDocument.RunWhenLoaded (delegate {
				var editor = loadedDocument.Editor;
				var loc = part.Region.Begin;
				var parsedDocument = loadedDocument.UpdateParseDocument ();
				var declaringType = parsedDocument.GetInnermostTypeDefinition (loc);
				MDRefactoringScript script;

				if (loadedDocument.Editor != context.TextEditor) {
					script = new MDRefactoringScript (MDRefactoringContext.Create (loadedDocument, loc, context.CancellationToken).Result, FormattingOptions);
					startedScripts.Add (script);
				} else {
					script = this;
				}
				var nodes = nodeCallback (script, script.context);
				var mode = new InsertionCursorEditMode (
					editor.Parent,
					MonoDevelop.Ide.TypeSystem.CodeGenerationService.GetInsertionPoints (loadedDocument, declaringType));
				if (mode.InsertionPoints.Count == 0) {
					MessageService.ShowError (
						GettextCatalog.GetString ("No valid insertion point can be found in type '{0}'.", declaringType.Name)
					);
					return;
				}
				if (declaringType.Kind == TypeKind.Enum) {
					foreach (var node in nodes.Reverse ()) {
						var output = OutputNode (MonoDevelop.Ide.TypeSystem.CodeGenerationService.CalculateBodyIndentLevel (declaringType), node);
						var point = mode.InsertionPoints.First ();
						var offset = loadedDocument.Editor.LocationToOffset (point.Location);
						var text = output.Text + ",";
						var delta = point.Insert (editor, text);
						output.RegisterTrackedSegments (script, delta + offset);
					}
					tcs.SetResult (script);
					return;
				}

				var helpWindow = new Mono.TextEditor.PopupWindow.InsertionCursorLayoutModeHelpWindow ();
				helpWindow.TitleText = operation;
				mode.HelpWindow = helpWindow;
				
				mode.CurIndex = 0;
				operationsRunning++;
				mode.StartMode ();
				mode.Exited += delegate(object s, InsertionCursorEventArgs iCArgs) {
					if (iCArgs.Success) {
						if (iCArgs.InsertionPoint.LineAfter == NewLineInsertion.None && 
						    iCArgs.InsertionPoint.LineBefore == NewLineInsertion.None && nodes.Count > 1) {
							iCArgs.InsertionPoint.LineAfter = NewLineInsertion.BlankLine;
						}
						foreach (var node in nodes.Reverse ()) {
							var output = OutputNode (MonoDevelop.Ide.TypeSystem.CodeGenerationService.CalculateBodyIndentLevel (declaringType), node);
							var offset = loadedDocument.Editor.LocationToOffset (iCArgs.InsertionPoint.Location);
							var text = output.Text;
							var delta = iCArgs.InsertionPoint.Insert (editor, text);
							output.RegisterTrackedSegments (script, delta + offset);
						}
						tcs.SetResult (script);
					} else {
						Rollback ();
					}
					DisposeOnClose (); 
				};
			});
		
			return tcs.Task;
		}