public static void Left (TextEditorData data)
		{
			if (Platform.IsMac && data.IsSomethingSelected && !data.Caret.PreserveSelection) {
				data.Caret.Offset = System.Math.Min (data.SelectionAnchor, data.Caret.Offset);
				data.ClearSelection ();
				return;
			}
			
			if (data.Caret.Column > DocumentLocation.MinColumn) {
				DocumentLine line = data.Document.GetLine (data.Caret.Line);
				if (data.Caret.Column > line.Length + 1) {
					if (data.Caret.AllowCaretBehindLineEnd) {
						data.Caret.Column--;
					} else {
						data.Caret.Column = line.Length + 1;
					}
				} else {
					int offset = data.Caret.Offset - 1;
					foreach (var folding in data.Document.GetFoldingsFromOffset (offset).Where (f => f.IsFolded && f.Offset < offset)) {
						offset = System.Math.Min (offset, folding.Offset);
					}
					data.Caret.Offset = offset;
				}
			} else if (data.Caret.Line > DocumentLocation.MinLine) {
				DocumentLine prevLine = data.Document.GetLine (data.Caret.Line - 1);
				var nextLocation = new DocumentLocation (data.Caret.Line - 1, prevLine.Length + 1);
				if (data.HasIndentationTracker && data.Options.IndentStyle == IndentStyle.Virtual && nextLocation.Column == DocumentLocation.MinColumn)
					nextLocation = new DocumentLocation (data.Caret.Line - 1, data.GetVirtualIndentationColumn (nextLocation));
				data.Caret.Location = nextLocation;
			}
		}

		void TestCreateMethod (string input, string outputString, bool returnWholeFile)
		{
			var generator = new CSharpCodeGeneratorNode ();
			MonoDevelop.Projects.CodeGeneration.CodeGenerator.AddGenerator (generator);
			var refactoring = new CreateMethodCodeGenerator ();
			RefactoringOptions options = ExtractMethodTests.CreateRefactoringOptions (input);
			Assert.IsTrue (refactoring.IsValid (options));
			if (returnWholeFile) {
				refactoring.SetInsertionPoint (CodeGenerationService.GetInsertionPoints (options.Document, refactoring.DeclaringType).First ());
			} else {
				DocumentLocation loc = new DocumentLocation (1, 1);
				refactoring.SetInsertionPoint (new InsertionPoint (loc, NewLineInsertion.Eol, NewLineInsertion.Eol));
			}
			List<Change> changes = refactoring.PerformChanges (options, null);
//			changes.ForEach (c => Console.WriteLine (c));
			// get just the generated method.
			string output = ExtractMethodTests.GetOutput (options, changes);
			if (returnWholeFile) {
				Assert.IsTrue (ExtractMethodTests.CompareSource (output, outputString), "Expected:" + Environment.NewLine + outputString + Environment.NewLine + "was:" + Environment.NewLine + output);
				return;
			}
			output = output.Substring (0, output.IndexOf ('}') + 1).Trim ();
			// crop 1 level of indent
			Document doc = new Document (output);
			foreach (LineSegment line in doc.Lines) {
				if (doc.GetCharAt (line.Offset) == '\t')
					((IBuffer)doc).Remove (line.Offset, 1);
			}
			output = doc.Text;
			
			Assert.IsTrue (ExtractMethodTests.CompareSource (output, outputString), "Expected:" + Environment.NewLine + outputString + Environment.NewLine + "was:" + Environment.NewLine + output);
			MonoDevelop.Projects.CodeGeneration.CodeGenerator.RemoveGenerator (generator);
		}

        protected override void Update(CommandInfo info)
        {
            Document doc = IdeApp.Workbench.ActiveDocument;
            var editor = doc.GetContent<ITextEditorDataProvider> ();
            info.Enabled = false;
            if (doc != null
                && editor != null
                && doc.Project is MonoDroidProject)
            {
                var data = editor.GetTextEditorData ();

                var loc = new DocumentLocation (data.Caret.Line, data.Caret.Column);

                ResolveResult result;
                AstNode node;
                if (!doc.TryResolveAt (loc, out result, out node)) {
                    return;
                }

                var memberResolve = result as MemberResolveResult;
                if (memberResolve == null) {
                    return;
                }

                info.Enabled = ResourceHelper.IsResourcesMemberField(memberResolve);
            }
        }

		public static void FormatStatmentAt (MonoDevelop.Ide.Gui.Document data, DocumentLocation location)
		{
			var offset = data.Editor.LocationToOffset (location);
			var policyParent = data.Project != null ? data.Project.Policies : PolicyService.DefaultPolicies;
			var mimeTypeChain = DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
			Format (policyParent, mimeTypeChain, data, offset, offset, false, true);
		}		

        public static bool TryResolveAt(this Document doc, DocumentLocation loc, out ResolveResult result, out AstNode node)
        {
            if(doc == null)
                throw new ArgumentNullException("doc");

            result = null;
            node = null;
            var parsed_doc = doc.ParsedDocument;
            if(parsed_doc == null)
                return false;

            var unit = parsed_doc.GetAst<SyntaxTree>();
            var parsed_file = parsed_doc.ParsedFile as BVE5UnresolvedFile;

            if(unit == null || parsed_file == null)
                return false;

            try{
                result = ResolveAtLocation.Resolve(new Lazy<ICompilation>(() => doc.Compilation), parsed_file, unit, loc, out node);
                if(result == null || node is Statement)
                    return false;
            }catch(Exception e){
                Console.WriteLine("Got resolver exception:" + e);
                return false;
            }
            return true;
        }

		public Selection (DocumentLocation anchor, DocumentLocation lead, SelectionMode selectionMode = SelectionMode.Normal)
		{
			if (anchor.Line < DocumentLocation.MinLine || anchor.Column < DocumentLocation.MinColumn)
				throw new ArgumentOutOfRangeException ("anchor", anchor + " is out of range.");
			if (lead.Line < DocumentLocation.MinLine || lead.Column < DocumentLocation.MinColumn)
				throw new ArgumentOutOfRangeException ("lead", lead + " is out of range.");
			this.Anchor        = anchor;
			this.Lead          = lead;
			this.SelectionMode = selectionMode;
		}

		public Selection (DocumentLocation anchor, DocumentLocation lead, SelectionMode selectionMode)
		{
			if (anchor.Line < DocumentLocation.MinLine || anchor.Column < DocumentLocation.MinColumn)
				throw new ArgumentException ("anchor");
			if (lead.Line < DocumentLocation.MinLine || lead.Column < DocumentLocation.MinColumn)
				throw new ArgumentException ("lead");
			this.Anchor        = anchor;
			this.Lead          = lead;
			this.SelectionMode = selectionMode;
		}

		string GetIndentationString (DocumentLocation loc)
		{
			var line = data.Document.GetLine (loc.Line);
			if (line == null)
				return "";
			// Get context to the end of the line w/o changing the main engine's state
			var offset = line.Offset;
			string curIndent = line.GetIndentation (data.Document);
			try {
				stateTracker.Update (Math.Min (data.Length, offset + Math.Min (line.Length, loc.Column - 1)));
				int nlwsp = curIndent.Length;
				if (!stateTracker.LineBeganInsideMultiLineComment || (nlwsp < line.LengthIncludingDelimiter && data.Document.GetCharAt (offset + nlwsp) == '*'))
					return stateTracker.ThisLineIndent;
			} catch (Exception e) {
				LoggingService.LogError ("Error while indenting at "+ loc, e); 
			}
			return curIndent;
		}

        protected override void Run()
        {
            Document doc = IdeApp.Workbench.ActiveDocument;
            var editor = doc.GetContent<ITextEditorDataProvider> ();
            if (doc != null
                && editor != null
                && doc.Project is MonoDroidProject)
            {
                var data = editor.GetTextEditorData ();
                var offset = data.Caret.Offset;

                var loc = new DocumentLocation (data.Caret.Line, data.Caret.Column);

                ResolveResult result;
                AstNode node;
                if (!doc.TryResolveAt (loc, out result, out node)) {
                    return;
                }

                var memberResolve = result as MemberResolveResult;
                if (memberResolve == null) {
                    return;
                }

                if (ResourceHelper.IsResourcesMemberField(memberResolve)) {

                    MonoDevelop.Projects.Project project;
                    if (memberResolve.Type.TryGetSourceProject (out project))
                    {
                        var androidProject = project as MonoDroidProject;
                        var fileNames = ResourceHelper.ResolveToFilenames (memberResolve, androidProject, ResourceFolders.LAYOUT);

                        if (fileNames.Count == 1) {
                            IdeApp.Workbench.OpenDocument(new FileOpenInformation(fileNames[0], project));
                        } else if (fileNames.Count > 1) {
                            OpenAutoOpenWindow (doc, data, project, fileNames);
                        } else {
                            Console.WriteLine ("Failed to resolve the layout");
                        }
                    }
                }
            }
        }

		string GetIndentationString (int offset, DocumentLocation loc)
		{
			stateTracker.UpdateEngine (Math.Min (data.Length, offset + 1));
			LineSegment line = data.Document.GetLine (loc.Line);

			// Get context to the end of the line w/o changing the main engine's state
			var ctx = (CSharpIndentEngine)stateTracker.Engine.Clone ();
			for (int max = offset; max < line.Offset + line.Length; max++) {
				ctx.Push (data.Document.GetCharAt (max));
			}
//			int pos = line.Offset;
			string curIndent = line.GetIndentation (data.Document);
			int nlwsp = curIndent.Length;
//			int o = offset > pos + nlwsp ? offset - (pos + nlwsp) : 0;
			if (!stateTracker.Engine.LineBeganInsideMultiLineComment || (nlwsp < line.LengthIncludingDelimiter && data.Document.GetCharAt (line.Offset + nlwsp) == '*')) {
				return ctx.ThisLineIndent;
			}
			return curIndent;
		}

		public Cairo.Point LocationToPoint (DocumentLocation loc, bool useAbsoluteCoordinates)
		{
			DocumentLine line = Document.GetLine (loc.Line);
			if (line == null)
				return new Cairo.Point (-1, -1);
			int x = (int)(ColumnToX (line, loc.Column) + this.XOffset + this.TextStartPosition);
			int y = (int)LineToY (loc.Line);
			return useAbsoluteCoordinates ? new Cairo.Point (x, y) : new Cairo.Point (x - (int)this.textEditor.HAdjustment.Value, y - (int)this.textEditor.VAdjustment.Value);
		}

		internal bool CalculateClickLocation (double x, double y, out DocumentLocation clickLocation)
		{
			VisualLocationTranslator trans = new VisualLocationTranslator (this);

			clickLocation = trans.PointToLocation (x, y);
			if (clickLocation.Line < DocumentLocation.MinLine || clickLocation.Column < DocumentLocation.MinColumn)
				return false;
			DocumentLine line = Document.GetLine (clickLocation.Line);
			if (line != null && clickLocation.Column >= line.Length + 1 && GetWidth (Document.GetTextAt (line.SegmentIncludingDelimiter) + "-") < x) {
				clickLocation = new DocumentLocation (clickLocation.Line, line.Length + 1);
				if (textEditor.GetTextEditorData ().HasIndentationTracker && textEditor.Options.IndentStyle == IndentStyle.Virtual && clickLocation.Column == 1) {
					int indentationColumn = this.textEditor.GetTextEditorData ().GetVirtualIndentationColumn (clickLocation);
					if (indentationColumn > clickLocation.Column)
						clickLocation = new DocumentLocation (clickLocation.Line, indentationColumn);
				}
			}
			return true;
		}

		bool IsInsideSelection (DocumentLocation clickLocation)
		{
			var selection = textEditor.MainSelection;
			if (selection.SelectionMode == SelectionMode.Block) {
				int minColumn = System.Math.Min (selection.Anchor.Column, selection.Lead.Column);
				int maxColumn = System.Math.Max (selection.Anchor.Column, selection.Lead.Column);

				return selection.MinLine <= clickLocation.Line && clickLocation.Line <= selection.MaxLine &&
					minColumn <= clickLocation.Column && clickLocation.Column <= maxColumn;
			}
			return selection.Start <= clickLocation && clickLocation < selection.End;
		}

		LayoutWrapper GetVirtualSpaceLayout (DocumentLine line, DocumentLocation location)
		{
			string virtualSpace = "";
			var data = textEditor.GetTextEditorData ();
			if (data.HasIndentationTracker && line.Length == 0) {
				virtualSpace = this.textEditor.GetTextEditorData ().GetIndentationString (location);
			}
			if (location.Column > line.Length + 1 + virtualSpace.Length)
				virtualSpace += new string (' ', location.Column - line.Length - 1 - virtualSpace.Length);
			// predit layout already contains virtual space.
			if (!string.IsNullOrEmpty (textEditor.preeditString))
				virtualSpace = "";
			LayoutWrapper wrapper = new LayoutWrapper (textEditor.LayoutCache.RequestLayout ());
			wrapper.LineChars = virtualSpace.ToCharArray ();
			wrapper.Layout.SetText (virtualSpace);
			wrapper.Layout.Tabs = tabArray;
			wrapper.Layout.FontDescription = textEditor.Options.Font;
			int vy, vx;
			wrapper.Layout.GetSize (out vx, out vy);
			wrapper.Width = wrapper.LastLineWidth = vx / Pango.Scale.PangoScale;
			return wrapper;
		}

		static ResolveResult GetHeuristicResult (Document doc, DocumentLocation location, ref AstNode node)
		{
			int offset = doc.Editor.Caret.Offset;
			bool wasLetter = false, wasWhitespaceAfterLetter = false;
			while (offset < doc.Editor.Length) {
				char ch = doc.Editor.GetCharAt (offset);
				bool isLetter = char.IsLetterOrDigit (ch) || ch == '_';
				bool isWhiteSpace = char.IsWhiteSpace (ch);
				bool isValidPunc = ch == '.' || ch == '<' || ch == '>';

				if (!(wasLetter && wasWhitespaceAfterLetter) && (isLetter || isWhiteSpace || isValidPunc)) {
					if (isValidPunc) {
						wasWhitespaceAfterLetter = false;
						wasLetter = false;
					}
					offset++;
				} else {
					offset--;
					while (offset > 1) {
						ch = doc.Editor.GetCharAt (offset - 1);
						if (!(ch == '.' || char.IsWhiteSpace (ch)))
							break;
						offset--;
					}
					break;
				}

				wasLetter |= isLetter;
				if (wasLetter)
					wasWhitespaceAfterLetter |= isWhiteSpace;
			}

			var unit = SyntaxTree.Parse (CreateStub (doc, offset), doc.FileName);

			return ResolveAtLocation.Resolve (
				doc.Compilation, 
				doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile,
				unit,
				location, 
				out node);
		}

		public Gdk.Point DocumentToScreenLocation (DocumentLocation location)
		{
			var p = widget.TextEditor.LocationToPoint (location);
			int tx, ty;
			widget.Vbox.ParentWindow.GetOrigin (out tx, out ty);
			tx += widget.TextEditorContainer.Allocation.X + p.X;
			ty += widget.TextEditorContainer.Allocation.Y + p.Y + (int)TextEditor.LineHeight;
			return new Gdk.Point (tx, ty);
		}

		public override TooltipItem GetItem (Mono.TextEditor.TextEditor editor, int offset)
		{
			if (offset >= editor.Document.TextLength)
				return null;
			
			if (!DebuggingService.IsDebugging || DebuggingService.IsRunning)
				return null;
				
			StackFrame frame = DebuggingService.CurrentFrame;
			if (frame == null)
				return null;
			
			var ed = (ExtensibleTextEditor)editor;
			
			string expression = null;
			int startOffset = 0, length = 0;
			if (ed.IsSomethingSelected && offset >= ed.SelectionRange.Offset && offset <= ed.SelectionRange.EndOffset) {
				expression = ed.SelectedText;
				startOffset = ed.SelectionRange.Offset;
				length = ed.SelectionRange.Length;
			} else {
				ICSharpCode.NRefactory.TypeSystem.DomRegion expressionRegion;
				ResolveResult res = ed.GetLanguageItem (offset, out expressionRegion);
				
				if (res == null || res.IsError || res.GetType () == typeof (ResolveResult))
					return null;
				
				//Console.WriteLine ("res is a {0}", res.GetType ().Name);
				
				if (expressionRegion.IsEmpty)
					return null;

				if (res is NamespaceResolveResult ||
				    res is ConversionResolveResult ||
				    res is ForEachResolveResult ||
				    res is TypeIsResolveResult ||
				    res is TypeOfResolveResult ||
				    res is ErrorResolveResult)
					return null;
				
				var start = new DocumentLocation (expressionRegion.BeginLine, expressionRegion.BeginColumn);
				var end   = new DocumentLocation (expressionRegion.EndLine, expressionRegion.EndColumn);
				
				startOffset = editor.Document.LocationToOffset (start);
				int endOffset = editor.Document.LocationToOffset (end);
				length = endOffset - startOffset;
				
				if (res is LocalResolveResult) {
					var lr = (LocalResolveResult) res;
					
					// Capture only the local variable portion of the expression...
					expression = lr.Variable.Name;
					length = expression.Length;
					
					// Calculate start offset based on the variable region because we don't want to include the type information.
					// Note: We might not actually need to do this anymore?
					if (lr.Variable.Region.BeginLine != start.Line || lr.Variable.Region.BeginColumn != start.Column) {
						start = new DocumentLocation (lr.Variable.Region.BeginLine, lr.Variable.Region.BeginColumn);
						startOffset = editor.Document.LocationToOffset (start);
					}
				} else if (res is InvocationResolveResult) {
					var ir = (InvocationResolveResult) res;
					
					if (ir.Member.Name != ".ctor")
						return null;
					
					expression = ir.Member.DeclaringType.FullName;
				} else if (res is MemberResolveResult) {
					var mr = (MemberResolveResult) res;
					
					if (mr.TargetResult == null) {
						// User is hovering over a member definition...
						
						if (mr.Member is IProperty) {
							// Visual Studio will evaluate Properties if you hover over their definitions...
							var prop = (IProperty) mr.Member;
							
							if (prop.CanGet) {
								if (prop.IsStatic)
									expression = prop.FullName;
								else
									expression = prop.Name;
							} else {
								return null;
							}
						} else if (mr.Member is IField) {
							var field = (IField) mr.Member;
							
							if (field.IsStatic)
								expression = field.FullName;
							else
								expression = field.Name;
						} else {
							return null;
						}
					}
					
					// If the TargetResult is not null, then treat it like any other ResolveResult.
				} else if (res is ConstantResolveResult) {
					// Fall through...
//.........这里部分代码省略.........

		public bool Contains (DocumentLocation loc)
		{
			return anchor <= loc && loc <= lead || lead <= loc && loc <= anchor;
		}

		public void SetToOffsetWithDesiredColumn (int desiredOffset)
		{
			DocumentLocation old = Location;
			
			int line   = TextEditorData.Document.OffsetToLineNumber (desiredOffset);
			int column = desiredOffset - TextEditorData.Document.GetLine (line).Offset + 1;
			location = new DocumentLocation (line, column);
			SetColumn ();
			OnPositionChanged (new DocumentLocationEventArgs (old));
		}

		void CreateSmartTag (List<CodeAction> fixes, DocumentLocation loc)
		{
			Fixes = fixes;
			if (!QuickTaskStrip.EnableFancyFeatures) {
				RemoveWidget ();
				return;
			}
			var editor = document.Editor;
			if (editor == null || editor.Parent == null || !editor.Parent.IsRealized) {
				RemoveWidget ();
				return;
			}
			if (document.ParsedDocument == null || document.ParsedDocument.IsInvalid) {
				RemoveWidget ();
				return;
			}

			var container = editor.Parent;
			if (container == null) {
				RemoveWidget ();
				return;
			}
			bool first = true;
			DocumentLocation smartTagLocBegin = loc;
			foreach (var fix in fixes) {
				if (fix.DocumentRegion.IsEmpty)
					continue;
				if (first || loc < fix.DocumentRegion.Begin) {
					smartTagLocBegin = fix.DocumentRegion.Begin;
				}
				first = false;
			}
			if (smartTagLocBegin.Line != loc.Line)
				smartTagLocBegin = new DocumentLocation (loc.Line, 1);
			// got no fix location -> try to search word start
			if (first) {
				int offset = document.Editor.LocationToOffset (smartTagLocBegin);
				while (offset > 0) {
					char ch = document.Editor.GetCharAt (offset - 1);
					if (!char.IsLetterOrDigit (ch) && ch != '_')
						break;
					offset--;
				}
				smartTagLocBegin = document.Editor.OffsetToLocation (offset);
			}

			if (currentSmartTag != null && currentSmartTagBegin == smartTagLocBegin) {
				currentSmartTag.fixes = fixes;
				return;
			}
			RemoveWidget ();
			currentSmartTagBegin = smartTagLocBegin;
			var line = document.Editor.GetLine (smartTagLocBegin.Line);
			currentSmartTag = new SmartTagMarker ((line.NextLine ?? line).Offset, this, fixes, smartTagLocBegin);
			document.Editor.Document.AddMarker (currentSmartTag);
		}