vbnetdesignerdisplaybindingwrapper.cs

全功能c#编译器

			
			IClass generatedClass = cu.Classes[0];
			IMethod generatedInitializeComponents = GetInitializeComponents(cu.Classes[0]);
			IDocument newDoc = new DocumentFactory().CreateDocument();
			newDoc.TextContent = currentForm;
			string newInitializeComponents = GetInitializeComponentsString(newDoc, generatedInitializeComponents);
			TextEditorControl textArea = textAreaControlProvider.TextEditorControl;
			textArea.BeginUpdate();
			
			// save old fold markers
			FoldMarker[] marker = (FoldMarker[])textArea.Document.FoldingManager.FoldMarker.ToArray(typeof(FoldMarker));
			textArea.Document.FoldingManager.FoldMarker.Clear();
			
			
			IDocument oldDoc = new DocumentFactory().CreateDocument();
			oldDoc.TextContent = textArea.Document.TextContent;
			Reparse(FileName, oldDoc.TextContent);
			DeleteFormFields(oldDoc);
			
			// replace the old initialize components method with the new one
			Reparse(FileName, oldDoc.TextContent);
			LineSegment beginLine = oldDoc.GetLineSegment(initializeComponents.Region.BeginLine - 1);
			int startOffset = beginLine.Offset + initializeComponents.Region.BeginColumn - 1;
			
			oldDoc.Replace(startOffset, GetInitializeComponentsString(oldDoc, initializeComponents).Length, newInitializeComponents);
			
			Reparse(FileName, oldDoc.TextContent);
			
			// insert new fields
			int lineNr = c.Region.BeginLine - 1;
			while (true) {
				if (lineNr >= textArea.Document.TotalNumberOfLines - 2) {
					break;
				}
				LineSegment curLine = oldDoc.GetLineSegment(lineNr);
				// search Sub New()
				string lineText = oldDoc.GetText(curLine.Offset, curLine.Length).Trim();
				if (lineText.Length == 0) {
					++lineNr;
					break;
				}
				if (lineText.EndsWith("New()")) {
					++lineNr;
					break;
				}
				++lineNr;
			}
			
			beginLine = oldDoc.GetLineSegment(lineNr - 1);
			int insertOffset = beginLine.Offset;
			foreach (IField field in generatedClass.Fields) {
				LineSegment fieldLine = newDoc.GetLineSegment(field.Region.BeginLine - 1);
				oldDoc.Insert(insertOffset,newDoc.GetText(fieldLine.Offset, fieldLine.TotalLength));
			}
			textArea.Document.TextContent = oldDoc.TextContent;
			
			// indent fields
			textArea.Document.FormattingStrategy.IndentLines(this.textAreaControlProvider.TextEditorControl.ActiveTextAreaControl.TextArea, lineNr - 1, lineNr - 1 + generatedClass.Fields.Count);
			
			// update folding states
			IParseInformation parseInfo = parserService.ParseFile(FileName, textArea.Document.TextContent, false);
			textArea.Document.FoldingManager.UpdateFoldings(FileName, parseInfo);
			for (int i = 0; i < marker.Length && i < textArea.Document.FoldingManager.FoldMarker.Count; ++i) {
				((FoldMarker)textArea.Document.FoldingManager.FoldMarker[i]).IsFolded = marker[i].IsFolded;
			}
			textArea.EndUpdate();
			textArea.OptionsChanged();
			viewContent.IsDirty = dirty;
		}
		
		void Reparse(string fileName, string content)
		{
			if (fileName == null) {
				fileName = FileName;
			}
			// get new initialize components
			IParserService parserService    = (IParserService)ICSharpCode.Core.Services.ServiceManager.Services.GetService(typeof(IParserService));
			IParseInformation info = parserService.ParseFile(fileName, content, false);
			ICompilationUnit cu = (ICompilationUnit)info.BestCompilationUnit;
			foreach (IClass c in cu.Classes) {
				if (IsBaseClassDesignable(c)) {
					initializeComponents = GetInitializeComponents(c);
					if (initializeComponents != null) {
						this.c = c;
						break;
					}
				}
			}
		}
		
		
		IMethod GetInitializeComponents(IClass c)
		{
			foreach (IMethod method in c.Methods) {
				if ((method.Name == "InitializeComponents" || method.Name == "InitializeComponent") && method.Parameters.Count == 0) {
					 return method;
				}
			}
			return null;
		}
		#endregion
		
		public override void Selected()
		{
			isFormDesignerVisible = true;
			Reload();
			if (!failedDesignerInitialize) {
				if (base.designPanel != null) {
					base.designPanel.Enable();
				}
//				base.SelectMe(this, EventArgs.Empty);
			} else {
				if (base.designPanel != null) {
					base.designPanel.SetErrorState(compilationErrors);
				}
			}
		}
		
		public override void Deselected()
		{
			isFormDesignerVisible = false;
			base.designPanel.Disable();
			if (!failedDesignerInitialize) {
				MergeFormChanges();
				textAreaControlProvider.TextEditorControl.Refresh();
//				base.DeSelectMe(this, EventArgs.Empty);
			}
			DeselectAllComponents();
		}
		
		public void NotifyAfterSave(bool successful)
		{
			//ifko: save the resources if there are any
			if (successful) {
				DesignerResourceService designerResourceService = (DesignerResourceService)host.GetService(typeof(System.ComponentModel.Design.IResourceService));
				if (designerResourceService != null) {
						designerResourceService.Save();
				}
			}
		}

		public void NotifyBeforeSave()
		{
			MergeFormChanges();
		}
		
		public override void ShowSourceCode()
		{
			WorkbenchWindow.SwitchView(0);
		}
		
		public override void ShowSourceCode(int lineNumber)
		{
			ShowSourceCode();
			textAreaControlProvider.TextEditorControl.ActiveTextAreaControl.JumpTo(lineNumber, 255);
		}
		
		protected static string GenerateParams(EventDescriptor edesc, bool paramNames)
		{
			System.Type type =  edesc.EventType;
			MethodInfo mInfo = type.GetMethod("Invoke");
			string param = "";
			IAmbience csa = null;
			try {
				csa = (IAmbience)AddInTreeSingleton.AddInTree.GetTreeNode("/SharpDevelop/Workbench/Ambiences").BuildChildItem("VB.NET", typeof(VBNetDesignerDisplayBindingWrapper));
			} catch {}
			
			for (int i = 0; i < mInfo.GetParameters().Length; ++i)  {
				ParameterInfo pInfo  = mInfo.GetParameters()[i];
				
				string typeStr = pInfo.ParameterType.ToString();
				if (csa != null) {
					typeStr = csa.GetIntrinsicTypeName(typeStr);
				}
				param += pInfo.Name + " As " + typeStr;
				if (i + 1 < mInfo.GetParameters().Length) {
					param += ", ";
				}
			}
			return param;
		}
		
		/// <summary>
		/// If found return true and int as position
		/// </summary>
		/// <param name="component"></param>
		/// <param name="edesc"></param>
		/// <returns></returns>
		protected bool InsertComponentEvent(IComponent component, EventDescriptor edesc, string eventMethodName, string body, out int position)
		{
			if (this.failedDesignerInitialize) {
				position = 0;
				return false;
			}

			Reparse(FileName, Document.TextContent);
			foreach (IMethod method in c.Methods) {
				if (method.Name == eventMethodName) {
					position = method.Region.BeginLine;
					return true;
				}
			}
			Deselected();
			MergeFormChanges();
			Reparse(FileName, Document.TextContent);
			position = c.Region.EndLine - 1;
			
			int offset = Document.GetLineSegment(c.Region.EndLine - 1).Offset;
			
			string param = GenerateParams(edesc, true);
			
			string text = "Private Sub " + eventMethodName + "(" + param + ")\n" +
			"\n" + body +
			"\nEnd Sub\n\n";
			Document.Insert(offset, text);
			Document.FormattingStrategy.IndentLines(this.textAreaControlProvider.TextEditorControl.ActiveTextAreaControl.TextArea, c.Region.EndLine - 1, c.Region.EndLine + 3);
			return false;
		}
		
		public override void ShowSourceCode(IComponent component, EventDescriptor edesc, string eventMethodName)
		{
			int position;
			if (InsertComponentEvent(component, edesc, eventMethodName, "", out position)) {
				ShowSourceCode(position);
			} else {
				ShowSourceCode(c.Region.EndLine);
			}
		}
		
		public override ICollection GetCompatibleMethods(EventInfo edesc)
		{
			Reparse(FileName, Document.TextContent);
			ArrayList compatibleMethods = new ArrayList();
			MethodInfo methodInfo = edesc.GetAddMethod();
			ParameterInfo pInfo = methodInfo.GetParameters()[0];
			string eventName = pInfo.ParameterType.ToString().ToUpper().Replace("EVENTHANDLER", "EVENTARGS");
			
			foreach (IMethod method in c.Methods) {
				if (method.Parameters.Count == 2) {
					bool found = true;
					
					IParameter p = method.Parameters[1];
					if (p.ReturnType.FullyQualifiedName.ToUpper() != eventName) {
						found = false;
					}
					if (found) {
						compatibleMethods.Add(method.Name);
					}
				}
			}
			
			return compatibleMethods;
		}
		
		public override ICollection GetCompatibleMethods(EventDescriptor edesc)
		{
			Reparse(FileName, Document.TextContent);
			ArrayList compatibleMethods = new ArrayList();
			MethodInfo methodInfo = edesc.EventType.GetMethod("Invoke");
			foreach (IMethod method in c.Methods) {
				if (method.Parameters.Count == methodInfo.GetParameters().Length) {
					bool found = true;
					for (int i = 0; i < methodInfo.GetParameters().Length; ++i) {
						ParameterInfo pInfo = methodInfo.GetParameters()[i];
						IParameter p = method.Parameters[i];
						if (p.ReturnType.FullyQualifiedName != pInfo.ParameterType.ToString()) {
							found = false;
							break;
						}
					}
					if (found) {
						compatibleMethods.Add(method.Name);
					}
				}
			}
			
			return compatibleMethods;
		}
	}
}