IMember GetMemberToDocument()
{
var parsedDocument = ProjectDomService.Parse(Document.Project, Document.FileName, Document.Editor.Document.Text);
IType type = parsedDocument.CompilationUnit.GetTypeAt(textEditorData.Caret.Line, textEditorData.Caret.Column);
if (type == null)
{
foreach (var t in parsedDocument.CompilationUnit.Types)
{
if (t.Location.Line > textEditorData.Caret.Line)
{
return(t);
}
}
return(null);
}
IMember result = null;
foreach (IMember member in type.Members)
{
if (member.Location > new DomLocation(textEditorData.Caret.Line, textEditorData.Caret.Column) && (result == null || member.Location < result.Location) && IsEmptyBetweenLines(textEditorData.Caret.Line, member.Location.Line))
{
result = member;
}
}
return(result);
}
void StartReparseThread()
{
// Don't directly parse the document because doing it at every key press is
// very inefficient. Do it after a small delay instead, so several changes can
// be parsed at the same time.
string currentParseFile = FileName;
if (parseTimeout != 0)
{
GLib.Source.Remove(parseTimeout);
}
parseTimeout = GLib.Timeout.Add(ParseDelay, delegate {
string currentParseText = Editor.Text;
Project curentParseProject = Project;
// parser revice queue takes care of the locking
ProjectDomService.QueueParseJob(dom, delegate(string name, IProgressMonitor monitor) {
var currentParsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, currentParseText);
Application.Invoke(delegate {
this.parsedDocument = currentParsedDocument;
if (this.parsedDocument != null && !this.parsedDocument.HasErrors)
{
this.lastErrorFreeParsedDocument = parsedDocument;
}
OnDocumentParsed(EventArgs.Empty);
});
}, FileName);
parseTimeout = 0;
return(false);
});
}
void ReplaceFile(string targetRelativePath, string sourceRelativePath)
{
string tfile = mainProject.Project.GetAbsoluteChildPath(targetRelativePath);
string sfile = mainProject.Project.GetAbsoluteChildPath(sourceRelativePath);
File.Copy(sfile, tfile, true);
ProjectDomService.Parse(tfile, null);
}
internal static IParameterDataProvider CreateProvider(string text)
{
string parsedText;
string editorText;
int cursorPosition = text.IndexOf('$');
int endPos = text.IndexOf('$', cursorPosition + 1);
if (endPos == -1)
{
parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
else
{
parsedText = text.Substring(0, cursorPosition) + new string (' ', endPos - cursorPosition) + text.Substring(endPos + 1);
editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
cursorPosition = endPos - 1;
}
TestWorkbenchWindow tww = new TestWorkbenchWindow();
TestViewContent sev = new TestViewContent();
DotNetProject project = new DotNetAssemblyProject("C#");
project.FileName = GetTempFile(".csproj");
string file = GetTempFile(".cs");
project.AddFile(file);
ProjectDomService.Load(project);
// ProjectDom dom = ProjectDomService.GetProjectDom (project);
ProjectDomService.Parse(project, file, null, delegate { return(parsedText); });
ProjectDomService.Parse(project, file, null, delegate { return(parsedText); });
sev.Project = project;
sev.ContentName = file;
sev.Text = editorText;
sev.CursorPosition = cursorPosition;
tww.ViewContent = sev;
Document doc = new Document(tww);
doc.ParsedDocument = new NRefactoryParser().Parse(null, sev.ContentName, parsedText);
CSharpTextEditorCompletion textEditorCompletion = new CSharpTextEditorCompletion(doc);
CodeCompletionContext ctx = new CodeCompletionContext();
ctx.TriggerOffset = sev.CursorPosition;
int line, column;
sev.GetLineColumnFromPosition(sev.CursorPosition, out line, out column);
ctx.TriggerLine = line;
ctx.TriggerLineOffset = column;
IParameterDataProvider result = textEditorCompletion.HandleParameterCompletion(ctx, editorText[cursorPosition - 1]);
ProjectDomService.Unload(project);
return(result);
}
void OnClosed(object s, EventArgs a)
{
ProjectDomService.DomRegistered -= UpdateRegisteredDom;
if (parseTimeout != 0)
{
GLib.Source.Remove(parseTimeout);
parseTimeout = 0;
}
ClearTasks();
string currentParseFile = FileName;
Project curentParseProject = Project;
if (window is SdiWorkspaceWindow)
{
((SdiWorkspaceWindow)window).DetachFromPathedDocument();
}
window.Closed -= OnClosed;
window.ActiveViewContentChanged -= OnActiveViewContentChanged;
if (IdeApp.Workspace != null)
{
IdeApp.Workspace.ItemRemovedFromSolution -= OnEntryRemoved;
}
try {
OnClosed(a);
} catch (Exception ex) {
LoggingService.LogError("Exception while calling OnClosed.", ex);
}
while (editorExtension != null)
{
try {
editorExtension.Dispose();
} catch (Exception ex) {
LoggingService.LogError("Exception while disposing extension:" + editorExtension, ex);
}
editorExtension = editorExtension.Next as TextEditorExtension;
}
// Parse the file when the document is closed. In this way if the document
// is closed without saving the changes, the saved compilation unit
// information will be restored
if (currentParseFile != null)
{
ProjectDomService.QueueParseJob(dom, delegate(string name, IProgressMonitor monitor) {
ProjectDomService.Parse(curentParseProject, currentParseFile);
}, FileName);
}
if (isFileDom)
{
ProjectDomService.RemoveFileDom(FileName);
dom = null;
}
Counters.OpenDocuments--;
}
void OnClosed(object s, EventArgs a)
{
closed = true;
ClearTasks();
string currentParseFile = FileName;
Project curentParseProject = Project;
if (window is SdiWorkspaceWindow)
{
((SdiWorkspaceWindow)window).DetachFromPathedDocument();
}
window.Closed -= OnClosed;
window.ActiveViewContentChanged -= OnActiveViewContentChanged;
if (IdeApp.Workspace != null)
{
IdeApp.Workspace.ItemRemovedFromSolution -= OnEntryRemoved;
}
try {
OnClosed(a);
} catch (Exception ex) {
LoggingService.LogError("Exception while calling OnClosed.", ex);
}
while (editorExtension != null)
{
try {
editorExtension.Dispose();
} catch (Exception ex) {
LoggingService.LogError("Exception while disposing extension:" + editorExtension, ex);
}
editorExtension = editorExtension.Next as TextEditorExtension;
}
// Parse the file when the document is closed. In this way if the document
// is closed without saving the changes, the saved compilation unit
// information will be restored
if (currentParseFile != null)
{
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
// Don't access Document properties from the thread
ProjectDomService.Parse(curentParseProject, currentParseFile, DesktopService.GetMimeTypeForUri(currentParseFile));
});
}
if (fileDom != null)
{
ProjectDomService.RemoveFileDom(FileName);
fileDom = null;
}
Counters.OpenDocuments--;
}
protected override string GenerateInfo(string filename)
{
try {
var doc = ProjectDomService.Parse(Project, filename) as AspNetParsedDocument;
if (doc != null && !string.IsNullOrEmpty(doc.Info.InheritedClass))
{
return(doc.Info.InheritedClass);
}
} catch (Exception ex) {
LoggingService.LogError("Error reading codebehind name for file '" + filename + "'", ex);
}
return(null);
}
// public IType ImplementInterface (ICompilationUnit pinfo, IType klass, IType iface, bool explicitly, IType declaringClass, IReturnType hintReturnType)
// {
// if (klass == null)
// throw new ArgumentNullException ("klass");
// if (iface == null)
// throw new ArgumentNullException ("iface");
// RefactorerContext gctx = GetGeneratorContext (klass);
// klass = GetUpdatedClass (gctx, klass);
//
// bool alreadyImplemented;
// IReturnType prefix = null;
//
// List<KeyValuePair<IMember,IReturnType>> toImplement = new List<KeyValuePair<IMember,IReturnType>> ();
//
// prefix = new DomReturnType (iface);
//
// // Stub out non-implemented events defined by @iface
// foreach (IEvent ev in iface.Events) {
// if (ev.IsSpecialName)
// continue;
// bool needsExplicitly = explicitly;
//
// alreadyImplemented = gctx.ParserContext.GetInheritanceTree (klass).Any (x => x.ClassType != ClassType.Interface && x.Events.Any (y => y.Name == ev.Name));
//
// if (!alreadyImplemented)
// toImplement.Add (new KeyValuePair<IMember,IReturnType> (ev, needsExplicitly ? prefix : null));
// }
//
// // Stub out non-implemented methods defined by @iface
// foreach (IMethod method in iface.Methods) {
// if (method.IsSpecialName)
// continue;
// bool needsExplicitly = explicitly;
// alreadyImplemented = false;
// foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
// if (t.ClassType == ClassType.Interface)
// continue;
// foreach (IMethod cmet in t.Methods) {
// if (cmet.Name == method.Name && Equals (cmet.Parameters, method.Parameters)) {
// if (!needsExplicitly && !cmet.ReturnType.Equals (method.ReturnType))
// needsExplicitly = true;
// else
// alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cmet.ExplicitInterfaces));
// }
// }
// }
//
// if (!alreadyImplemented)
// toImplement.Add (new KeyValuePair<IMember,IReturnType> (method, needsExplicitly ? prefix : null));
// }
//
// // Stub out non-implemented properties defined by @iface
// foreach (IProperty prop in iface.Properties) {
// if (prop.IsSpecialName)
// continue;
// bool needsExplicitly = explicitly;
// alreadyImplemented = false;
// foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
// if (t.ClassType == ClassType.Interface)
// continue;
// foreach (IProperty cprop in t.Properties) {
// if (cprop.Name == prop.Name) {
// if (!needsExplicitly && !cprop.ReturnType.Equals (prop.ReturnType))
// needsExplicitly = true;
// else
// alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cprop.ExplicitInterfaces));
// }
// }
// }
// if (!alreadyImplemented)
// toImplement.Add (new KeyValuePair<IMember,IReturnType> (prop, needsExplicitly ? prefix : null)); }
//
// Ambience ambience = AmbienceService.GetAmbienceForFile (klass.CompilationUnit.FileName);
// //implement members
// ImplementMembers (klass, toImplement, ambience.GetString (iface, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters) + " implementation");
// gctx.Save ();
//
// klass = GetUpdatedClass (gctx, klass);
// foreach (IType baseClass in iface.SourceProjectDom.GetInheritanceTree (iface)) {
// if (baseClass.Equals (iface) || baseClass.FullName == "System.Object")
// continue;
// klass = ImplementInterface (pinfo, klass, baseClass, explicitly, declaringClass, hintReturnType);
// }
//
//
// return klass;
// }
IType GetUpdatedClass(RefactorerContext gctx, IType klass)
{
IEditableTextFile file = gctx.GetFile(klass.CompilationUnit.FileName);
ParsedDocument doc = ProjectDomService.Parse(gctx.ParserContext.Project, file.Name, delegate() { return(file.Text); });
IType result = gctx.ParserContext.GetType(klass.FullName, klass.TypeParameters.Count, true);
if (result is CompoundType)
{
IType hintType = doc.CompilationUnit.GetType(klass.FullName, klass.TypeParameters.Count);
if (hintType != null)
{
((CompoundType)result).SetMainPart(file.Name, hintType.Location);
}
}
return(result);
}
protected override void ParseFile(string fileName, IProgressMonitor monitor)
{
if (monitor != null)
{
monitor.BeginTask(string.Format(GettextCatalog.GetString("Parsing file: {0}"), Path.GetFileName(fileName)), 1);
}
try {
ProjectDomService.Parse(project, fileName, delegate() { return(File.ReadAllText(fileName)); });
// The call to ProjectDomService.Parse will call UpdateFromParseInfo when done
} finally {
if (monitor != null)
{
monitor.EndTask();
}
}
}
void ParseCallback(object ob, IProgressMonitor monitor)
{
string fileName = (string)ob;
ProjectDomService.Parse(Project, fileName, delegate() { return(File.ReadAllText(fileName)); });
/*
* ParseFile (fileName, monitor);
* lock (rwlock) {
* FileEntry file = GetFile (fileName);
* if (file != null) {
* file.InParseQueue = false;
* FileInfo fi = new FileInfo (fileName);
* file.LastParseTime = fi.LastWriteTime;
* }
* }*/
}
public static IMember AddCodeDomMember(IType type, CodeTypeMember newMember)
{
bool isOpen;
var data = TextFileProvider.Instance.GetTextEditorData(type.CompilationUnit.FileName, out isOpen);
var parsedDocument = ProjectDomService.GetParsedDocument(type.SourceProjectDom, type.CompilationUnit.FileName);
var insertionPoints = GetInsertionPoints(data, parsedDocument, type);
var suitableInsertionPoint = GetSuitableInsertionPoint(insertionPoints, type, newMember);
var dotNetProject = type.SourceProject 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 = "\t";
if (newMember is CodeMemberMethod)
{
options.BracingStyle = "C";
}
generator.GenerateCodeFromMember(newMember, sw, options);
suitableInsertionPoint.Insert(data, sw.ToString());
if (!isOpen)
{
try {
File.WriteAllText(type.CompilationUnit.FileName, data.Text);
} catch (Exception e) {
LoggingService.LogError(string.Format("Failed to write file '{0}'.", type.CompilationUnit.FileName), e);
MessageService.ShowError(GettextCatalog.GetString("Failed to write file '{0}'.", type.CompilationUnit.FileName));
}
}
var newDocument = ProjectDomService.Parse(type.SourceProject as Project, type.CompilationUnit.FileName, data.Text);
return(newDocument.CompilationUnit.GetMemberAt(suitableInsertionPoint.Location.Line, int.MaxValue));
}
/// <summary>
/// This method can take some time to finish. It's not threaded
/// </summary>
/// <returns>
/// A <see cref="ParsedDocument"/> that contains the current dom.
/// </returns>
public ParsedDocument UpdateParseDocument()
{
parsing = true;
try {
string currentParseFile = FileName;
string mime = DesktopService.GetMimeTypeForUri(currentParseFile);
string currentParseText = TextEditor.Text;
Project curentParseProject = Project;
this.parsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, mime, currentParseText);
if (this.parsedDocument != null && !this.parsedDocument.HasErrors)
{
this.lastErrorFreeParsedDocument = parsedDocument;
}
} finally {
parsing = false;
OnDocumentParsed(EventArgs.Empty);
}
return(this.parsedDocument);
}
IMember GetMemberToDocument()
{
var parsedDocument = ProjectDomService.Parse(Document.Project, Document.FileName, Document.TextEditorData.Document.MimeType, Document.TextEditorData.Document.Text);
IType type = parsedDocument.CompilationUnit.GetTypeAt(textEditorData.Caret.Line, textEditorData.Caret.Column);
if (type == null)
{
return(null);
}
IMember result = null;
foreach (IMember member in type.Members)
{
if (member.Location > new DomLocation(textEditorData.Caret.Line + 1, textEditorData.Caret.Column + 1) && (result == null || member.Location < result.Location))
{
result = member;
}
}
return(result);
}
/// <summary>
/// This method can take some time to finish. It's not threaded
/// </summary>
/// <returns>
/// A <see cref="ParsedDocument"/> that contains the current dom.
/// </returns>
public ParsedDocument UpdateParseDocument()
{
try {
string currentParseFile = FileName;
var editor = Editor;
if (editor == null)
{
return(null);
}
string currentParseText = editor.Text;
Project curentParseProject = Project;
this.parsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, currentParseText);
if (this.parsedDocument != null && !this.parsedDocument.HasErrors)
{
this.lastErrorFreeParsedDocument = parsedDocument;
}
} finally {
OnDocumentParsed(EventArgs.Empty);
}
return(this.parsedDocument);
}
/// Synchronizes the bindings between the object and the source code
public void UpdateBindings(string fileName)
{
if (targetObject == null)
{
return;
}
ParsedDocument doc = ProjectDomService.Parse(project, fileName, null);
classFile = fileName;
if (doc != null && doc.CompilationUnit != null)
{
IType cls = GetClass();
UpdateBindings(targetObject, cls);
if (cls != null)
{
targetObject.GeneratePublic = cls.IsPublic;
}
}
}
void OnDocumentChanged(object o, EventArgs a)
{
// Don't directly parse the document because doing it at every key press is
// very inefficient. Do it after a small delay instead, so several changes can
// be parsed at the same time.
if (parsing)
{
return;
}
parsing = true;
string currentParseFile = FileName;
string mime = DesktopService.GetMimeTypeForUri(currentParseFile);
GLib.Timeout.Add(ParseDelay, delegate {
if (closed)
{
return(false);
}
parsing = false;
string currentParseText = TextEditor.Text;
Project curentParseProject = Project;
System.Threading.ThreadPool.QueueUserWorkItem(delegate {
// Don't access Document properties from the thread
this.parsedDocument = ProjectDomService.Parse(curentParseProject, currentParseFile, mime, currentParseText);
if (this.parsedDocument != null && !this.parsedDocument.HasErrors)
{
this.lastErrorFreeParsedDocument = parsedDocument;
}
DispatchService.GuiSyncDispatch(delegate {
OnDocumentParsed(EventArgs.Empty);
});
});
return(false);
});
}
static void GenerateSteticCodeStructure(DotNetProject project, Stetic.ProjectItemInfo item, Stetic.Component component, Stetic.ComponentNameEventArgs args, bool saveToFile, bool overwrite)
{
// Generate a class which contains fields for all bound widgets of the component
string name = item != null ? item.Name : component.Name;
string fileName = GetBuildCodeFileName(project, name);
if (fileName == null)
{
return;
}
string ns = "";
int i = name.LastIndexOf('.');
if (i != -1)
{
ns = name.Substring(0, i);
name = name.Substring(i + 1);
}
if (saveToFile && !overwrite && File.Exists(fileName))
{
return;
}
if (item != null)
{
component = item.Component;
}
CodeCompileUnit cu = new CodeCompileUnit();
if (project.UsePartialTypes)
{
CodeNamespace cns = new CodeNamespace(ns);
cu.Namespaces.Add(cns);
CodeTypeDeclaration type = new CodeTypeDeclaration(name);
type.IsPartial = true;
type.Attributes = MemberAttributes.Public;
type.TypeAttributes = System.Reflection.TypeAttributes.Public;
cns.Types.Add(type);
foreach (Stetic.ObjectBindInfo binfo in component.GetObjectBindInfo())
{
// When a component is being renamed, we have to generate the
// corresponding field using the old name, since it will be renamed
// later using refactory
string nname = args != null && args.NewName == binfo.Name ? args.OldName : binfo.Name;
type.Members.Add(
new CodeMemberField(
binfo.TypeName,
nname
)
);
}
}
else
{
if (!saveToFile)
{
return;
}
CodeNamespace cns = new CodeNamespace();
cns.Comments.Add(new CodeCommentStatement("Generated code for component " + component.Name));
cu.Namespaces.Add(cns);
}
CodeDomProvider provider = project.LanguageBinding.GetCodeDomProvider();
if (provider == null)
{
throw new UserException("Code generation not supported for language: " + project.LanguageName);
}
TextWriter fileStream;
if (saveToFile)
{
fileStream = new StreamWriter(fileName);
}
else
{
fileStream = new StringWriter();
}
try {
provider.GenerateCodeFromCompileUnit(cu, fileStream, new CodeGeneratorOptions());
} finally {
fileStream.Close();
}
if (ProjectDomService.HasDom(project))
{
// Only update the parser database if the project is actually loaded in the IDE.
if (saveToFile)
{
ProjectDomService.Parse(project, fileName, "");
FileService.NotifyFileChanged(fileName);
}
else
{
ProjectDomService.Parse(project, fileName, ((StringWriter)fileStream).ToString());
}
}
}
public static AspNetParsedDocument GetCompileUnit(Project project, string filename, bool ensureUpToDate)
{
return(ProjectDomService.Parse(project, filename, null) as AspNetParsedDocument);
}
void CreateClass(string name, string namspace, string folder)
{
string fullName = namspace.Length > 0 ? namspace + "." + name : name;
CodeRefactorer gen = new CodeRefactorer(fproject.Project.ParentSolution);
bool partialSupport = fproject.Project.UsePartialTypes;
Stetic.WidgetComponent component = (Stetic.WidgetComponent)rootWidget.Component;
CodeTypeDeclaration type = new CodeTypeDeclaration();
type.Name = name;
type.IsClass = true;
type.IsPartial = partialSupport;
type.BaseTypes.Add(new CodeTypeReference(component.Type.ClassName));
// Generate the constructor. It contains the call that builds the widget.
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
foreach (object val in component.Type.InitializationValues)
{
if (val is Enum)
{
ctor.BaseConstructorArgs.Add(
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(val.GetType()),
val.ToString()
)
);
}
else
{
ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(val));
}
}
if (partialSupport)
{
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(),
"Build"
)
);
ctor.Statements.Add(call);
}
else
{
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("Stetic.Gui"),
"Build"
),
new CodeThisReferenceExpression(),
new CodeTypeOfExpression(fullName)
);
ctor.Statements.Add(call);
}
type.Members.Add(ctor);
// Add signal handlers
AddSignalsRec(type, component);
foreach (Stetic.Component ag in component.GetActionGroups())
{
AddSignalsRec(type, ag);
}
// Create the class
IType cls = gen.CreateClass(Project.Project, ((DotNetProject)Project.Project).LanguageName, folder, namspace, type);
if (cls == null)
{
throw new UserException("Could not create class " + fullName);
}
Project.Project.AddFile(cls.CompilationUnit.FileName, BuildAction.Compile);
IdeApp.ProjectOperations.Save(Project.Project);
// Make sure the database is up-to-date
ProjectDomService.Parse(Project.Project, cls.CompilationUnit.FileName);
}
static IType CreateClass(Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder)
{
string fullName = namspace.Length > 0 ? namspace + "." + name : name;
CodeRefactorer gen = new CodeRefactorer(project.ParentSolution);
CodeTypeDeclaration type = new CodeTypeDeclaration();
type.Name = name;
type.IsClass = true;
type.BaseTypes.Add(new CodeTypeReference("Gtk.ActionGroup"));
// Generate the constructor. It contains the call that builds the widget.
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(fullName));
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression("Stetic.Gui"),
"Build"
),
new CodeThisReferenceExpression(),
new CodeTypeOfExpression(fullName)
);
ctor.Statements.Add(call);
type.Members.Add(ctor);
// Add signal handlers
foreach (Stetic.ActionComponent action in group.GetActions())
{
foreach (Stetic.Signal signal in action.GetSignals())
{
CodeMemberMethod met = new CodeMemberMethod();
met.Name = signal.Handler;
met.Attributes = MemberAttributes.Family;
met.ReturnType = new CodeTypeReference(signal.SignalDescriptor.HandlerReturnTypeName);
foreach (Stetic.ParameterDescriptor pinfo in signal.SignalDescriptor.HandlerParameters)
{
met.Parameters.Add(new CodeParameterDeclarationExpression(pinfo.TypeName, pinfo.Name));
}
type.Members.Add(met);
}
}
// Create the class
IType cls = null;
cls = gen.CreateClass(project, ((DotNetProject)project).LanguageName, folder, namspace, type);
if (cls == null)
{
throw new UserException("Could not create class " + fullName);
}
project.AddFile(cls.CompilationUnit.FileName, BuildAction.Compile);
IdeApp.ProjectOperations.Save(project);
#if TRUNK
// Make sure the database is up-to-date
ProjectDomService.Parse(project, cls.CompilationUnit.FileName);
#else
ProjectDomService.Parse(project, cls.CompilationUnit.FileName, null);
#endif
return(cls);
}
public static CompletionDataList CreateProvider(string text, string extension, bool isCtrlSpace)
{
string parsedText;
string editorText;
int cursorPosition = text.IndexOf('$');
int endPos = text.IndexOf('$', cursorPosition + 1);
if (endPos == -1)
{
parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
else
{
parsedText = text.Substring(0, cursorPosition) + new string (' ', endPos - cursorPosition) + text.Substring(endPos + 1);
editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
cursorPosition = endPos - 1;
}
var tww = new MonoDevelop.CSharpBinding.Tests.TestWorkbenchWindow();
var sev = new MonoDevelop.CSharpBinding.Tests.TestViewContent();
var project = new AspNetAppProject("C#");
project.FileName = UnitTests.TestBase.GetTempFile(".csproj");
string file = UnitTests.TestBase.GetTempFile(extension);
project.AddFile(file);
ProjectDomService.Load(project);
ProjectDom dom = ProjectDomService.GetProjectDom(project);
dom.ForceUpdate(true);
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
sev.Project = project;
sev.ContentName = file;
sev.Text = editorText;
sev.CursorPosition = cursorPosition;
tww.ViewContent = sev;
var doc = new MonoDevelop.Ide.Gui.Document(tww);
doc.ParsedDocument = new MonoDevelop.AspNet.Parser.AspNetParser().Parse(null, sev.ContentName, parsedText);
foreach (var e in doc.ParsedDocument.Errors)
{
Console.WriteLine(e);
}
var textEditorCompletion = new MonoDevelop.AspNet.Gui.AspNetEditorExtension();
Initialize(textEditorCompletion, doc);
int triggerWordLength = 1;
CodeCompletionContext ctx = new CodeCompletionContext();
ctx.TriggerOffset = sev.CursorPosition;
int line, column;
sev.GetLineColumnFromPosition(sev.CursorPosition, out line, out column);
ctx.TriggerLine = line;
ctx.TriggerLineOffset = column - 1;
if (isCtrlSpace)
{
return(textEditorCompletion.CodeCompletionCommand(ctx) as CompletionDataList);
}
else
{
return(textEditorCompletion.HandleCodeCompletion(ctx, editorText[cursorPosition - 1], ref triggerWordLength) as CompletionDataList);
}
}
public IType GetClass(bool getUserClass)
{
if (targetObject == null)
{
return(null);
}
IType cls = gproject.FindClass(className, getUserClass);
if (cls != null)
{
return(cls);
}
// The class name may have changed. Try to guess the new name.
ArrayList matches = new ArrayList();
ICompilationUnit unit = null;
ProjectDom ctx = gproject.GetParserContext();
ParsedDocument doc = ProjectDomService.Parse(project, classFile, null);
if (doc != null && doc.CompilationUnit != null)
{
unit = doc.CompilationUnit;
foreach (IType fcls in unit.Types)
{
if (IsValidClass(ctx, fcls, targetObject))
{
matches.Add(fcls);
}
}
}
// If found the class, just return it
if (matches.Count == 1)
{
cls = (IType)matches [0];
className = cls.FullName;
targetObject.Name = className;
gproject.Save(true);
return(cls);
}
// If not found, warn the user.
if (unit != null && unit.Types.Count > 0)
{
using (SelectRenamedClassDialog dialog = new SelectRenamedClassDialog(unit.Types)) {
if (dialog.Run())
{
className = dialog.SelectedClass;
if (className == null)
{
return(null);
}
else
{
targetObject.Name = className;
gproject.Save(true);
return(gproject.FindClass(className));
}
}
}
}
else
{
MessageService.ShowError(GettextCatalog.GetString("The class bound to the component '{0}' could not be found. This may be due to syntax errors in the source code file.", GetObjectName(targetObject)));
}
return(null);
}
protected override BuildResult Build(IProgressMonitor monitor, SolutionEntityItem project, ConfigurationSelector configuration)
{
AspNetAppProject aspProject = project as AspNetAppProject;
//get the config object and validate
AspNetAppProjectConfiguration config = (AspNetAppProjectConfiguration)aspProject.GetConfiguration(configuration);
if (config == null)
{
monitor.Log.WriteLine(GettextCatalog.GetString
("Project configuration is invalid. Skipping CodeBehind member generation."));
return(base.Build(monitor, project, configuration));
}
if (config.DisableCodeBehindGeneration)
{
monitor.Log.WriteLine(GettextCatalog.GetString
("Skipping updating of CodeBehind partial classes, because this feature is disabled."));
return(base.Build(monitor, project, configuration));
}
CodeBehindWriter writer = CodeBehindWriter.CreateForProject(monitor, aspProject);
if (!writer.SupportsPartialTypes)
{
monitor.Log.WriteLine(GettextCatalog.GetString
("The code generator for {0} does not support partial classes. Skipping CodeBehind member generation.",
aspProject.LanguageBinding.Language));;
return(base.Build(monitor, project, configuration));
}
//get the extension used for codebehind files
string langExt = aspProject.LanguageBinding.GetFileName("a");
langExt = langExt.Substring(1, langExt.Length - 1);
List <CodeBehindWarning> errors = new List <CodeBehindWarning> ();
monitor.Log.WriteLine(GettextCatalog.GetString("Generating CodeBehind members..."));
bool updatedParseDb = false;
//go over all the files generating members where necessary
foreach (ProjectFile file in aspProject.Files)
{
WebSubtype type = AspNetAppProject.DetermineWebSubtype(file.FilePath);
if (type != WebSubtype.WebForm && type != WebSubtype.WebControl && type != WebSubtype.MasterPage)
{
continue;
}
//find the designer file
ProjectFile designerFile = aspProject.Files.GetFile(file.Name + ".designer" + langExt);
if (designerFile == null)
{
aspProject.Files.GetFile(file.Name + ".Designer" + langExt);
}
if (designerFile == null)
{
continue;
}
//only regenerate the designer class if it's older than the aspx (etc) file
if (System.IO.File.GetLastWriteTimeUtc(designerFile.FilePath)
> System.IO.File.GetLastWriteTimeUtc(file.FilePath))
{
continue;
}
//need parse DB to be up to date
if (!updatedParseDb)
{
updatedParseDb = true;
monitor.Log.Write(GettextCatalog.GetString("Waiting for project type database to finish updating..."));
ProjectDom dom = ProjectDomService.GetProjectDom(aspProject);
dom.ForceUpdate(true);
monitor.Log.WriteLine(GettextCatalog.GetString(" complete."));
}
//parse the ASP.NET file
var parsedDocument = ProjectDomService.Parse(aspProject, file.FilePath) as AspNetParsedDocument;
if (parsedDocument == null)
{
continue;
}
var ccu = CodeBehind.GenerateCodeBehind(aspProject, designerFile.FilePath, parsedDocument, errors);
if (ccu == null)
{
continue;
}
writer.Write(ccu, designerFile.FilePath);
}
writer.WriteOpenFiles();
//write out a friendly message aout what we did
if (writer.WrittenCount > 0)
{
monitor.Log.WriteLine(GettextCatalog.GetString("{0} CodeBehind designer classes updated.", writer.WrittenCount));
}
else
{
monitor.Log.WriteLine(GettextCatalog.GetString("No changes made to CodeBehind classes."));
}
//and construct and return a build result
BuildResult baseResult = base.Build(monitor, project, configuration);
foreach (CodeBehindWarning cbw in errors)
{
if (cbw.FileName != null)
{
baseResult.AddWarning(cbw.FileName, cbw.Line, cbw.Column, null, cbw.WarningText);
}
else
{
baseResult.AddWarning(cbw.WarningText);
}
}
return(baseResult);
}
public override bool AddToProject(SolutionItem policyParent, Project project, string language, string directory, string name)
{
if (!GtkDesignInfo.SupportsDesigner(project))
{
ReferenceManager mgr = new ReferenceManager(project as DotNetProject);
mgr.GtkPackageVersion = mgr.DefaultGtkVersion;
mgr.Dispose();
}
GtkDesignInfo info = GtkDesignInfo.FromProject((DotNetProject)project);
GuiBuilderProject gproject = info.GuiBuilderProject;
string fileName = fileTemplate.GetFileName(policyParent, project, language, directory, name);
fileTemplate.AddToProject(policyParent, project, language, directory, name);
ProjectDomService.Parse(project, fileName, null);
DotNetProject netProject = project as DotNetProject;
string ns = netProject != null?netProject.GetDefaultNamespace(fileName) : "";
string cname = Path.GetFileNameWithoutExtension(fileName);
string fullName = ns.Length > 0 ? ns + "." + cname : cname;
string[,] tags =
{
{ "Name", cname },
{ "Namespace", ns },
{ "FullName", fullName }
};
XmlElement widgetElem = steticTemplate ["widget"];
if (widgetElem != null)
{
string content = widgetElem.OuterXml;
content = StringParserService.Parse(content, tags);
XmlDocument doc = new XmlDocument();
doc.LoadXml(content);
gproject.AddNewComponent(doc.DocumentElement);
gproject.Save(false);
IdeApp.ProjectOperations.Save(project);
return(true);
}
widgetElem = steticTemplate ["action-group"];
if (widgetElem != null)
{
string content = widgetElem.OuterXml;
content = StringParserService.Parse(content, tags);
XmlDocument doc = new XmlDocument();
doc.LoadXml(content);
gproject.SteticProject.AddNewActionGroup(doc.DocumentElement);
gproject.Save(false);
IdeApp.ProjectOperations.Save(project);
return(true);
}
throw new InvalidOperationException("<widget> or <action-group> element not found in widget template.");
}
public static System.CodeDom.CodeCompileUnit GenerateCodeBehind(AspNetAppProject project,
string filename,
AspNetParsedDocument document,
List <CodeBehindWarning> errors)
{
string className = document.Info.InheritedClass;
if (document.HasErrors)
{
AddFail(errors, document, document.Errors.Where(x => x.ErrorType == ErrorType.Error).First());
return(null);
}
if (string.IsNullOrEmpty(className))
{
return(null);
}
var refman = new DocumentReferenceManager(project)
{
Doc = document
};
var memberList = new MemberListVisitor(document, refman);
document.RootNode.AcceptVisit(memberList);
var err = memberList.Errors.Where(x => x.ErrorType == ErrorType.Error).FirstOrDefault();
if (err != null)
{
AddFail(errors, document, err);
return(null);
}
//initialise the generated type
var ccu = new CodeCompileUnit();
var namespac = new CodeNamespace();
ccu.Namespaces.Add(namespac);
var typeDecl = new System.CodeDom.CodeTypeDeclaration()
{
IsClass = true,
IsPartial = true,
};
namespac.Types.Add(typeDecl);
//name the class and namespace
int namespaceSplit = className.LastIndexOf('.');
string namespaceName = null;
if (namespaceSplit > -1)
{
namespac.Name = project.StripImplicitNamespace(className.Substring(0, namespaceSplit));
typeDecl.Name = className.Substring(namespaceSplit + 1);
}
else
{
typeDecl.Name = className;
}
string masterTypeName = null;
if (!String.IsNullOrEmpty(document.Info.MasterPageTypeName))
{
masterTypeName = document.Info.MasterPageTypeName;
}
else if (!String.IsNullOrEmpty(document.Info.MasterPageTypeVPath))
{
try {
ProjectFile resolvedMaster = project.ResolveVirtualPath(document.Info.MasterPageTypeVPath, document.FileName);
AspNetParsedDocument masterParsedDocument = null;
if (resolvedMaster != null)
{
masterParsedDocument = ProjectDomService.Parse(project, resolvedMaster.FilePath) as AspNetParsedDocument;
}
if (masterParsedDocument != null && !String.IsNullOrEmpty(masterParsedDocument.Info.InheritedClass))
{
masterTypeName = masterParsedDocument.Info.InheritedClass;
}
else
{
errors.Add(new CodeBehindWarning(String.Format("Could not find type for master '{0}'",
document.Info.MasterPageTypeVPath),
document.FileName));
}
} catch (Exception ex) {
errors.Add(new CodeBehindWarning(String.Format("Could not find type for master '{0}'",
document.Info.MasterPageTypeVPath),
document.FileName));
LoggingService.LogWarning("Error resolving master page type", ex);
}
}
if (masterTypeName != null)
{
var masterProp = new CodeMemberProperty()
{
Name = "Master",
Type = new CodeTypeReference(masterTypeName),
HasGet = true,
HasSet = false,
Attributes = System.CodeDom.MemberAttributes.Public | System.CodeDom.MemberAttributes.New
| System.CodeDom.MemberAttributes.Final,
};
masterProp.GetStatements.Add(new System.CodeDom.CodeMethodReturnStatement(
new System.CodeDom.CodeCastExpression(masterTypeName,
new System.CodeDom.CodePropertyReferenceExpression(
new System.CodeDom.CodeBaseReferenceExpression(), "Master"))));
typeDecl.Members.Add(masterProp);
}
//shortcut building the existing members type map
if (memberList.Members.Count == 0)
{
return(ccu);
}
var dom = refman.TypeCtx.ProjectDom;
var cls = dom.GetType(className);
var members = GetDesignerMembers(memberList.Members.Values, cls, filename, dom, dom);
//add fields for each control in the page
foreach (var member in members)
{
var type = new CodeTypeReference(member.Type.FullName);
typeDecl.Members.Add(new CodeMemberField(type, member.Name)
{
Attributes = MemberAttributes.Family
});
}
return(ccu);
}
internal static RefactoringOptions CreateRefactoringOptions(string text)
{
int cursorPosition = -1;
int endPos = text.IndexOf('$');
if (endPos >= 0)
{
cursorPosition = endPos;
text = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
int selectionStart = -1;
int selectionEnd = -1;
int idx = text.IndexOf("<-");
if (idx >= 0)
{
selectionStart = idx;
text = text.Substring(0, idx) + text.Substring(idx + 2);
selectionEnd = idx = text.IndexOf("->");
text = text.Substring(0, idx) + text.Substring(idx + 2);
if (cursorPosition < 0)
{
cursorPosition = selectionEnd - 1;
}
}
TestWorkbenchWindow tww = new TestWorkbenchWindow();
TestViewContent sev = new TestViewContent();
// return new RefactoringOptions ();
DotNetProject project = new DotNetAssemblyProject("C#");
Solution solution = new Solution();
solution.RootFolder.Items.Add(project);
project.FileName = GetTempFile(".csproj");
string file = GetTempFile(".cs");
project.AddFile(file);
string parsedText = text;
string editorText = text;
ProjectDomService.Load(project);
ProjectDom dom = ProjectDomService.GetProjectDom(project);
dom.ForceUpdate(true);
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
ProjectDomService.Parse(project, file, delegate { return(parsedText); });
sev.Project = project;
sev.ContentName = file;
sev.Text = editorText;
sev.CursorPosition = cursorPosition;
tww.ViewContent = sev;
var doc = new MonoDevelop.Ide.Gui.Document(tww);
doc.Editor.Document.MimeType = "text/x-csharp";
doc.Editor.Document.FileName = file;
doc.ParsedDocument = new McsParser().Parse(null, sev.ContentName, parsedText);
foreach (var e in doc.ParsedDocument.Errors)
{
Console.WriteLine(e);
}
if (cursorPosition >= 0)
{
doc.Editor.Caret.Offset = cursorPosition;
}
if (selectionStart >= 0)
{
doc.Editor.SetSelection(selectionStart, selectionEnd);
}
NRefactoryResolver resolver = new NRefactoryResolver(dom,
doc.ParsedDocument.CompilationUnit,
sev.Data,
file);
ExpressionResult expressionResult;
if (selectionStart >= 0)
{
expressionResult = new ExpressionResult(editorText.Substring(selectionStart, selectionEnd - selectionStart).Trim());
endPos = selectionEnd;
}
else
{
expressionResult = new NewCSharpExpressionFinder(dom).FindFullExpression(doc.Editor, cursorPosition + 1);
}
ResolveResult resolveResult = endPos >= 0 ? resolver.Resolve(expressionResult, new DomLocation(doc.Editor.Caret.Line, doc.Editor.Caret.Column)) : null;
RefactoringOptions result = new RefactoringOptions {
Document = doc,
Dom = dom,
ResolveResult = resolveResult,
SelectedItem = null
};
if (resolveResult is MemberResolveResult)
{
result.SelectedItem = ((MemberResolveResult)resolveResult).ResolvedMember;
}
if (resolveResult is LocalVariableResolveResult)
{
result.SelectedItem = ((LocalVariableResolveResult)resolveResult).LocalVariable;
}
if (resolveResult is ParameterResolveResult)
{
result.SelectedItem = ((ParameterResolveResult)resolveResult).Parameter;
}
result.TestFileProvider = new FileProvider(result);
return(result);
}
public ParsedDocument ParseDocument()
{
return(ProjectDomService.Parse(Dom.Project, Document.FileName, Document.Editor.Text));
}
public ParsedDocument ParseDocument()
{
return(ProjectDomService.Parse(Dom.Project, Document.FileName, DesktopService.GetMimeTypeForUri(Document.FileName), Document.TextEditor.Text));
}
