public void UpdateSignal(Stetic.Signal oldSignal, Stetic.Signal newSignal)
{
if (targetObject == null)
{
return;
}
if (oldSignal.Handler == newSignal.Handler)
{
return;
}
IType cls = GetClass();
if (cls == null)
{
return;
}
IMethod met = FindSignalHandler(cls, oldSignal);
if (met == null)
{
return;
}
CodeRefactorer gen = GetCodeGenerator();
gen.RenameMember(new NullProgressMonitor(), cls, met, newSignal.Handler, RefactoryScope.File);
}
/// Adds a field to the class
public void BindToField(Stetic.Component obj)
{
if (targetObject == null)
{
return;
}
string name = GetMemberName(obj);
IType cls = GetClass();
if (FindField(cls, name) != null)
{
return;
}
Document doc = IdeApp.Workbench.OpenDocument(cls.CompilationUnit.FileName, true);
IEditableTextFile editor = doc.GetContent <IEditableTextFile> ();
if (editor != null)
{
CodeRefactorer gen = GetCodeGenerator();
gen.AddMember(cls, GetFieldCode(obj, name));
}
}
public static CodeRefactorer GetCodeGenerator(Project project)
{
CodeRefactorer cr = new CodeRefactorer(project.ParentSolution);
cr.TextFileProvider = MonoDevelop.Ide.TextFileProvider.Instance;
return(cr);
}
void InsertToolboxItemAttributes(WidgetParser parser, CodeRefactorer cref)
{
Dictionary <string, IType> tb_items = parser.GetToolboxItems();
foreach (string clsname in ObjectNames)
{
if (tb_items.ContainsKey(clsname))
{
continue;
}
IType cls = parser.GetClass(clsname);
if (cls == null)
{
continue;
}
cref.AddAttribute(cls, "System.ComponentModel.ToolboxItem", true);
XmlElement elem = DocumentElement.SelectSingleNode("object[@type='" + clsname + "']") as XmlElement;
if (elem != null && elem.HasAttribute("palette-category"))
{
cref.AddAttribute(cls, "System.ComponentModel.Category", elem.GetAttribute("palette-category"));
}
}
}
CodeRefactorer GetCodeGenerator()
{
CodeRefactorer cr = new CodeRefactorer(project.ParentSolution);
cr.TextFileProvider = textFileProvider;
return(cr);
}
/// Adds a signal handler to the class
public void BindSignal(Stetic.Signal signal)
{
if (targetObject == null)
{
return;
}
IType cls = GetClass();
if (cls == null)
{
return;
}
if (FindSignalHandler(cls, signal) != null)
{
return;
}
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));
}
CodeRefactorer gen = GetCodeGenerator();
gen.AddMember(cls, met);
}
internal void OnCompleteStatement()
{
CodeRefactorer refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
DomLocation caretLocation = refactorer.CompleteStatement(ProjectDom, Document.FileName, new DomLocation(Caret.Line, Caret.Column));
Caret.Line = caretLocation.Line;
Caret.Column = caretLocation.Column;
}
public static bool SupportsRefactoring(DotNetProject project)
{
if (project == null || project.LanguageBinding == null || project.LanguageBinding.GetCodeDomProvider() == null)
{
return(false);
}
RefactorOperations ops = RefactorOperations.AddField | RefactorOperations.AddMethod | RefactorOperations.RenameField | RefactorOperations.AddAttribute;
CodeRefactorer cref = IdeApp.Workspace.GetCodeRefactorer(project.ParentSolution);
return(cref.LanguageSupportsOperation(project.LanguageBinding.Language, ops));
}
public override void InsertCompletionText(CompletionListWindow window)
{
Initialize();
string text = insertNamespace ? type.Namespace + "." + type.Name : type.Name;
if (text != GetCurrentWord(window))
{
window.CompletionWidget.SetCompletionText(window.CodeCompletionContext, GetCurrentWord(window), text);
}
if (generateUsing)
{
CodeRefactorer refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
refactorer.AddGlobalNamespaceImport(dom, data.Document.FileName, type.Namespace);
// add using to compilation unit (this way the using is valid before the parser thread updates)
((MonoDevelop.Projects.Dom.CompilationUnit)doc.CompilationUnit).AddAtTop(new DomUsing(new DomRegion(1, 1, int.MaxValue, 1), type.Namespace));
}
}
MemberReferenceCollection GetReferences(RefactoringOptions options, IMember member)
{
CodeRefactorer refactorer;
if (options.TestFileProvider == null)
{
refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
}
else
{
refactorer = new CodeRefactorer();
refactorer.TextFileProvider = options.TestFileProvider;
}
IProgressMonitor monitor = IdeApp.Workbench != null?IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(this.Name, null) : new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor();
return(refactorer.FindMemberReferences(monitor, member.DeclaringType, member, true));
}
MemberReferenceCollection GetReferences(RefactoringOptions options)
{
CodeRefactorer refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(this.Name, null);
if (options.SelectedItem is IType)
{
IType cls = (IType)options.SelectedItem;
return(refactorer.FindClassReferences(monitor, cls, RefactoryScope.Solution, true));
}
else if (options.SelectedItem is LocalVariable)
{
return(refactorer.FindVariableReferences(monitor, (LocalVariable)options.SelectedItem));
}
else if (options.SelectedItem is IParameter)
{
return(refactorer.FindParameterReferences(monitor, (IParameter)options.SelectedItem, true));
}
else if (options.SelectedItem is IMember)
{
IMember member = (IMember)options.SelectedItem;
Dictionary <string, HashSet <DomLocation> > foundLocations = new Dictionary <string, HashSet <DomLocation> > ();
MemberReferenceCollection result = new MemberReferenceCollection();
foreach (IMember m in CollectMembers(member.DeclaringType.SourceProjectDom, member))
{
foreach (MemberReference r in refactorer.FindMemberReferences(monitor, m.DeclaringType, m, true))
{
DomLocation location = new DomLocation(r.Line, r.Column);
if (!foundLocations.ContainsKey(r.FileName))
{
foundLocations[r.FileName] = new HashSet <DomLocation> ();
}
if (foundLocations[r.FileName].Contains(location))
{
continue;
}
foundLocations[r.FileName].Add(location);
result.Add(r);
}
}
return(result);
}
return(null);
}
public void Update(WidgetParser parser, Stetic.Project stetic, CodeRefactorer refactorer)
{
if (AttrSyncState == SyncState.Unspecified)
{
if (refactorer != null)
{
InsertToolboxItemAttributes(parser, refactorer);
AttrSyncState = SyncState.On;
}
return;
}
else if (AttrSyncState == SyncState.Off)
{
return;
}
StringCollection tb_names = new StringCollection();
foreach (IType cls in parser.GetToolboxItems().Values)
{
UpdateClass(parser, stetic, cls, null);
tb_names.Add(cls.FullName);
}
List <XmlElement> toDelete = new List <XmlElement> ();
foreach (XmlElement elem in SelectNodes("objects/object"))
{
string name = elem.GetAttribute("type");
if (!tb_names.Contains(name))
{
toDelete.Add(elem);
}
}
foreach (XmlElement elem in toDelete)
{
elem.ParentNode.RemoveChild(elem);
}
Save();
}
public override void Run(RefactoringOptions options)
{
DocumentLocation location = options.GetTextEditorData().Caret.Location;
IType interfaceType = options.Dom.GetType(options.ResolveResult.ResolvedType);
IType declaringType = options.Document.CompilationUnit.GetTypeAt(location.Line + 1, location.Column + 1);
options.Document.TextEditor.BeginAtomicUndo();
CodeRefactorer refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
List <KeyValuePair <IMember, IReturnType> > members = new List <KeyValuePair <IMember, IReturnType> > ();
foreach (IMember member in interfaceType.Members)
{
if (member.IsAbstract && !declaringType.Members.Any(m => member.Name == m.Name))
{
members.Add(new KeyValuePair <IMember, IReturnType> (member, null));
}
}
refactorer.ImplementMembers(declaringType, members, "implemented abstract members of " + interfaceType.FullName);
options.Document.TextEditor.EndAtomicUndo();
}
public void UpdateField(Stetic.Component obj, string oldName)
{
if (targetObject == null)
{
return;
}
CodeRefactorer cr = GetCodeGenerator();
IType cls;
if (obj == targetObject)
{
return; // The root widget name can only be changed internally.
}
else
{
cls = GetClass(false);
}
string newName = GetObjectName(obj);
if (newName.Length == 0)
{
return;
}
if (cls != null)
{
IField f = ClassUtils.FindWidgetField(cls, oldName);
if (f != null)
{
cr.RenameMember(new NullProgressMonitor(), cls, f, newName, RefactoryScope.File);
}
}
}
public OverridesImplementsDialog(MonoDevelop.Ide.Gui.Document editor, IType cls)
{
this.Build();
this.editor = editor;
this.cls = cls;
// FIXME: title
Title = GettextCatalog.GetString("Override and/or implement members");
store = new TreeStore(typeof(bool), typeof(Gdk.Pixbuf), typeof(string), typeof(bool), typeof(IMember));
// Column #1
TreeViewColumn nameCol = new TreeViewColumn();
nameCol.Title = GettextCatalog.GetString("Name");
nameCol.Expand = true;
nameCol.Resizable = true;
CellRendererToggle cbRenderer = new CellRendererToggle();
cbRenderer.Activatable = true;
cbRenderer.Toggled += OnSelectToggled;
nameCol.PackStart(cbRenderer, false);
nameCol.AddAttribute(cbRenderer, "active", colCheckedIndex);
CellRendererPixbuf iconRenderer = new CellRendererPixbuf();
nameCol.PackStart(iconRenderer, false);
nameCol.AddAttribute(iconRenderer, "pixbuf", colIconIndex);
CellRendererText nameRenderer = new CellRendererText();
nameRenderer.Ellipsize = Pango.EllipsizeMode.End;
nameCol.PackStart(nameRenderer, true);
nameCol.AddAttribute(nameRenderer, "text", colNameIndex);
treeview.AppendColumn(nameCol);
// Column #2
CellRendererToggle explicitRenderer = new CellRendererToggle();
explicitRenderer.Activatable = true;
explicitRenderer.Xalign = 0.0f;
explicitRenderer.Toggled += OnExplicitToggled;
TreeViewColumn explicitCol = new TreeViewColumn();
explicitCol.Title = GettextCatalog.GetString("Explicit");
explicitCol.PackStart(explicitRenderer, true);
explicitCol.SetCellDataFunc(explicitRenderer, new TreeCellDataFunc(RenderExplicitCheckbox));
explicitCol.AddAttribute(explicitRenderer, "active", colExplicitIndex);
treeview.AppendColumn(explicitCol);
store.SetSortColumnId(colNameIndex, SortType.Ascending);
treeview.Model = store;
buttonCancel.Clicked += OnCancelClicked;
buttonOk.Clicked += OnOKClicked;
buttonSelectAll.Clicked += delegate { SelectAll(true); };
buttonUnselectAll.Clicked += delegate { SelectAll(false); };
refactorer = IdeApp.Workspace.GetCodeRefactorer(IdeApp.ProjectOperations.CurrentSelectedSolution);
ambience = AmbienceService.GetAmbienceForFile(cls.CompilationUnit.FileName);
PopulateTreeView();
UpdateOKButton();
}
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);
}
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);
}
