public static void ExpandOnlyCSharpProjects(ITreeNavigator node)
{
if (node == null)
{
return;
}
var typename = node.DataItem.GetType().Name;
if (typename == "Solution")
{
node.ExpandToNode();
}
if (node.HasChildren())
{
var continueLoop = node.MoveToFirstChild();
while (continueLoop)
{
if (node.DataItem is Project proj)
{
var filter = EssentialProperties.ExpandFilterArray;
if (filter.Length == 0)
{
node.MoveToFirstChild();
node.ExpandToNode();
node.MoveToParent();
}
else
{
foreach (var item in filter)
{
if (proj.Name.ToLower().Contains(item))
{
node.MoveToFirstChild();
node.ExpandToNode();
node.MoveToParent();
break;
}
}
}
}
else
{
ExpandOnlyCSharpProjects(node);
}
continueLoop = node.MoveNext();
}
node.MoveToParent();
}
}
internal static void RestoreState(ExtensibleTreeView pad, ITreeNavigator nav, NodeState es)
{
if (es == null)
{
return;
}
pad.ResetState(nav);
nav.Expanded = es.Expanded;
if (es.ChildrenState != null)
{
foreach (NodeState ces in es.ChildrenState)
{
if (nav.MoveToChild(ces.NodeName, null))
{
RestoreState(pad, nav, ces);
nav.MoveToParent();
}
}
}
if (es.Selected)
{
nav.Selected = true;
}
}
void FillDetailPanel()
{
ITreeNavigator nav = TreeView.GetSelectedNode();
ITreeDetailBuilder tdb;
if (nav == null)
{
SetDetailWidget(null);
return;
}
do
{
tdb = nav.TypeNodeBuilder as ITreeDetailBuilder;
} while (nav != null && tdb == null && nav.MoveToParent());
if (nav == null || tdb == null)
{
SetDetailWidget(null);
return;
}
if (detailItem == nav.DataItem)
{
return;
}
detailItem = nav.DataItem;
SetDetailWidget(tdb.GetDetailWidget(detailItem));
}
public void Fill (Extension ext, ITreeNavigator nav)
{
labelName.Markup = "<small>Extension</small>\n<big><b>" + GLib.Markup.EscapeText (Util.GetDisplayName (ext)) + "</b></big>";
object parent = ext.GetExtendedObject ();
if (parent is ExtensionPoint) {
ExtensionPoint ep = (ExtensionPoint) parent;
string txt = "<small>Extension Point</small>\n<b>" + GLib.Markup.EscapeText (Util.GetDisplayName (ep)) + "</b>";
if (!string.IsNullOrEmpty (ep.Description))
txt += "\n" + GLib.Markup.EscapeText (ep.Description);
Gtk.Label lab = new Gtk.Label ();
lab.Xalign = lab.Yalign = 0;
lab.Markup = txt;
lab.WidthRequest = 400;
lab.Wrap = true;
Gtk.Image img = new Gtk.Image (ImageService.GetPixbuf ("md-extension-point", Gtk.IconSize.Menu));
img.Yalign = 0;
Gtk.HBox box = new Gtk.HBox (false, 6);
box.PackStart (img, false, false, 0);
box.PackStart (lab, true, true, 0);
buttonExt.Add (box);
buttonExt.ShowAll ();
buttonExt.Clicked += delegate {
if (nav.MoveToObject (ext)) {
nav.MoveToParent (typeof(Solution));
nav.Expanded = true;
if (nav.MoveToObject (ep.ParentAddinDescription)) {
nav.Expanded = true;
if (nav.MoveToObject (ep))
nav.Selected = true;
}
}
};
}
}
static NodeState SaveStateRec(ExtensibleTreeView pad, ITreeNavigator nav)
{
List <NodeState> childrenState = null;
if (nav.Filled && nav.MoveToFirstChild())
{
do
{
NodeState cs = SaveStateRec(pad, nav);
if (cs != null)
{
cs.NodeName = nav.NodeName;
if (childrenState == null)
{
childrenState = new List <NodeState> ();
}
childrenState.Add(cs);
}
} while (nav.MoveNext());
nav.MoveToParent();
}
if (nav.Expanded || childrenState != null || nav.Selected)
{
NodeState es = new NodeState();
es.Expanded = nav.Expanded;
es.Selected = nav.Selected;
es.ChildrenState = childrenState;
return(es);
}
else
{
return(null);
}
}
ITreeNavigator SearchMember(ITreeNavigator nav, string helpUrl)
{
do
{
if (IsMatch(nav, helpUrl))
{
return(nav);
}
if (!SkipChildren(nav, helpUrl) && nav.HasChildren())
{
DispatchService.RunPendingEvents();
nav.MoveToFirstChild();
ITreeNavigator result = SearchMember(nav, helpUrl);
if (result != null)
{
return(result);
}
if (!nav.MoveToParent())
{
return(null);
}
try {
if (nav.DataItem is DomCecilType && nav.Options["PublicApiOnly"])
{
nav.Options["PublicApiOnly"] = false;
nav.MoveToFirstChild();
result = SearchMember(nav, helpUrl);
if (result != null)
{
return(result);
}
nav.MoveToParent();
}
} catch (Exception) {
return(null);
}
}
} while (nav.MoveNext());
return(null);
}
public static void ExpandAll(ITreeNavigator node)
{
if (node == null)
{
return;
}
var typename = node.DataItem.GetType().Name;
if (typename == "Solution")
{
node.ExpandToNode();
}
if (node.HasChildren())
{
var continueLoop = node.MoveToFirstChild();
while (continueLoop)
{
var wso = node.DataItem as WorkspaceObject;
if (node.DataItem is Project)
{
if (!string.IsNullOrWhiteSpace(EssentialProperties.ExpandFilter))
{
foreach (var item in EssentialProperties.ExpandFilterArray)
{
if (wso.Name.ToLower().Contains(item))
{
ExpandProjectFiles(node);
break;
}
}
}
else
{
ExpandProjectFiles(node);
}
}
else
{
ExpandAll(node);
}
continueLoop = node.MoveNext();
}
node.MoveToParent();
}
}
public static ITreeNavigator MoveToParentFolderOrProjectNode(ITreeNavigator currentNode, ITreeNavigator node)
{
while (node.MoveToParent())
{
var parentItem = currentNode.DataItem;
if (parentItem is ProjectFolder ||
parentItem is Project)
{
return(node);
}
node = currentNode;
}
return(null);
}
private void GetFiles (ITreeNavigator nav, List<SystemFile> filesToAdd)
{
nav.MoveToFirstChild ();
do {
if (nav.HasChildren ()) {
ProjectFolder pf = nav.DataItem as ProjectFolder;
if (pf != null && (File.GetAttributes (pf.Path) & FileAttributes.Hidden) == 0) {
ITreeNavigator newNav = nav.Clone ();
GetFiles (newNav, filesToAdd);
}
} else if (nav.DataItem is SystemFile) {
filesToAdd.Add ((SystemFile) nav.DataItem);
}
} while (nav.MoveNext ());
nav.MoveToParent ();
}
private static void ExpandProjectFiles(ITreeNavigator node)
{
if (node == null)
{
return;
}
#if DEBUG
if (node.DataItem is ProjectFile f)
{
if (f.Name.ToLower().Contains("appstart.cs"))
{
Debug.WriteLine("BINGO !!");
}
}
if (node.DataItem is ProjectFolder folder)
{
if (folder.Name.ToLower().Contains("views"))
{
Debug.WriteLine("BINGO !!");
}
}
#endif
if (FilteredProjectCache.IsProjectItemExpanded(node.DataItem))
{
node.ExpandToNode();
node.Expanded = true;
}
if (node.HasChildren())
{
var continueLoop = node.MoveToFirstChild();
while (continueLoop)
{
if (!(node.DataItem is ProjectFile pf) || string.IsNullOrEmpty(pf.DependsOn))
{
ExpandProjectFiles(node);
}
continueLoop = node.MoveNext();
}
node.MoveToParent();
return;
}
}
public void Fill(Extension ext, ITreeNavigator nav)
{
labelName.Markup = "<small>Extension</small>\n<big><b>" + GLib.Markup.EscapeText(Util.GetDisplayName(ext)) + "</b></big>";
object parent = ext.GetExtendedObject();
if (parent is ExtensionPoint)
{
ExtensionPoint ep = (ExtensionPoint)parent;
string txt = "<small>Extension Point</small>\n<b>" + GLib.Markup.EscapeText(Util.GetDisplayName(ep)) + "</b>";
if (!string.IsNullOrEmpty(ep.Description))
{
txt += "\n" + GLib.Markup.EscapeText(ep.Description);
}
Gtk.Label lab = new Gtk.Label();
lab.Xalign = lab.Yalign = 0;
lab.Markup = txt;
lab.WidthRequest = 400;
lab.Wrap = true;
Gtk.Image img = new Gtk.Image(ImageService.GetPixbuf("md-extension-point", Gtk.IconSize.Menu));
img.Yalign = 0;
Gtk.HBox box = new Gtk.HBox(false, 6);
box.PackStart(img, false, false, 0);
box.PackStart(lab, true, true, 0);
buttonExt.Add(box);
buttonExt.ShowAll();
buttonExt.Clicked += delegate {
if (nav.MoveToObject(ext))
{
nav.MoveToParent(typeof(Solution));
nav.Expanded = true;
if (nav.MoveToObject(ep.ParentAddinDescription))
{
nav.Expanded = true;
if (nav.MoveToObject(ep))
{
nav.Selected = true;
}
}
}
};
}
}
void Dispose(ITreeNavigator nav)
{
if (nav == null)
{
return;
}
IDisposable d = nav.DataItem as IDisposable;
if (d != null)
{
d.Dispose();
}
if (nav.HasChildren())
{
nav.MoveToFirstChild();
do
{
Dispose(nav);
} while (nav.MoveNext());
nav.MoveToParent();
}
}
internal static void RestoreState(TreeViewPad pad, ITreeNavigator nav, NodeState es)
{
if (es == null) return;
Gtk.TreeIter it = nav.CurrentPosition._iter;
if (es.Options != null) {
pad.SetIterOptions (it, es.Options);
}
pad.ResetState (it);
nav.Expanded = es.Expanded;
if (es.ChildrenState != null) {
foreach (NodeState ces in es.ChildrenState) {
if (nav.MoveToChild (ces.NodeName, null)) {
RestoreState (pad, nav, ces);
nav.MoveToParent ();
}
}
}
if (es.Selected)
nav.Selected = true;
}
static NodeState SaveStateRec(TreeViewPad pad, ITreeNavigator nav)
{
Gtk.TreeIter it = nav.CurrentPosition._iter;
ArrayList childrenState = null;
if (nav.Filled && nav.MoveToFirstChild ()) {
do {
NodeState cs = SaveStateRec (pad, nav);
if (cs != null) {
cs.NodeName = nav.NodeName;
if (childrenState == null) childrenState = new ArrayList ();
childrenState.Add (cs);
}
} while (nav.MoveNext ());
nav.MoveToParent ();
}
TreeViewPad.TreeOptions ops = pad.GetIterOptions (it);
if (ops != null || nav.Expanded || childrenState != null || nav.Selected) {
NodeState es = new NodeState ();
es.Expanded = nav.Expanded;
es.Selected = nav.Selected;
es.Options = ops;
es.ChildrenState = childrenState;
return es;
} else
return null;
}
ITreeNavigator SearchMember (ITreeNavigator nav, string helpUrl)
{
bool searchType = helpUrl.StartsWith ("T:");
do {
if (IsMatch (nav, helpUrl, searchType)) {
nav.ExpandToNode ();
nav.Selected = nav.Expanded = true;
return nav;
}
if (!SkipChildren (nav, helpUrl, searchType) && nav.HasChildren ()) {
nav.MoveToFirstChild ();
ITreeNavigator result = SearchMember (nav, helpUrl);
if (result != null)
return result;
if (!nav.MoveToParent ()) {
return null;
}
try {
if (nav.DataItem is TypeDefinition && nav.Options ["PublicApiOnly"]) {
nav.Options ["PublicApiOnly"] = PublicApiOnly;
nav.MoveToFirstChild ();
result = SearchMember (nav, helpUrl);
if (result != null)
return result;
nav.MoveToParent ();
}
} catch (Exception) {
}
}
} while (nav.MoveNext());
return null;
}
ITreeNavigator SearchMember (ITreeNavigator nav, string helpUrl, bool expandNode = true)
{
if (nav == null)
return null;
bool searchType = helpUrl.StartsWith ("T:", StringComparison.Ordinal);
do {
if (IsMatch (nav, helpUrl, searchType)) {
inspectEditor.ClearSelection ();
nav.ExpandToNode ();
if (expandNode) {
nav.Selected = nav.Expanded = true;
nav.ScrollToNode ();
} else {
nav.Selected = true;
nav.ScrollToNode ();
}
return nav;
}
if (!SkipChildren (nav, helpUrl, searchType) && nav.HasChildren ()) {
nav.MoveToFirstChild ();
ITreeNavigator result = SearchMember (nav, helpUrl, expandNode);
if (result != null)
return result;
if (!nav.MoveToParent ()) {
return null;
}
}
} while (nav.MoveNext());
return null;
}
private void GetFiles(ITreeNavigator nav, List<SystemFile> filesToAdd)
{
nav.MoveToFirstChild ();
do {
if (nav.HasChildren ()) {
ProjectFolder pf = nav.DataItem as ProjectFolder;
if (pf != null && (File.GetAttributes (pf.Path) & FileAttributes.Hidden) == 0) {
ITreeNavigator newNav = nav.Clone ();
GetFiles (newNav, filesToAdd);
}
} else if (nav.DataItem is SystemFile) {
filesToAdd.Add ((SystemFile) nav.DataItem);
}
} while (nav.MoveNext ());
nav.MoveToParent ();
}
ITreeNavigator SearchMember (ITreeNavigator nav, string helpUrl)
{
do {
if (IsMatch (nav, helpUrl))
return nav;
if (!SkipChildren (nav, helpUrl) && nav.HasChildren ()) {
DispatchService.RunPendingEvents ();
nav.MoveToFirstChild ();
ITreeNavigator result = SearchMember (nav, helpUrl);
if (result != null)
return result;
if (!nav.MoveToParent ())
return null;
try {
if (nav.DataItem is DomCecilType && nav.Options["PublicApiOnly"]) {
nav.Options["PublicApiOnly"] = false;
nav.MoveToFirstChild ();
result = SearchMember (nav, helpUrl);
if (result != null)
return result;
nav.MoveToParent ();
}
} catch (Exception) {
return null;
}
}
} while (nav.MoveNext());
return null;
}
void OnClassInformationChanged(object sender, TypeUpdateInformationEventArgs e)
{
// DateTime t = DateTime.Now;
Dictionary <object, bool> oldStatus = new Dictionary <object, bool> ();
List <string> namespacesToClean = new List <string> ();
ITreeBuilder tb = Context.GetTreeBuilder();
foreach (IType cls in e.TypeUpdateInformation.Removed)
{
if (tb.MoveToObject(new ClassData(e.Project, cls)))
{
oldStatus [tb.DataItem] = tb.Expanded;
ITreeNavigator np = tb.Clone();
np.MoveToParent();
oldStatus [np.DataItem] = np.Expanded;
tb.Remove(true);
}
namespacesToClean.Add(cls.Namespace);
}
foreach (IType cls in e.TypeUpdateInformation.Modified)
{
ClassData ucd = new ClassData(e.Project, cls);
if (tb.MoveToObject(ucd))
{
ClassData cd = (ClassData)tb.DataItem;
cd.UpdateFrom(ucd);
tb.UpdateAll();
}
}
foreach (IType cls in e.TypeUpdateInformation.Added)
{
AddClass(e.Project, cls);
}
// Clean empty namespaces
foreach (string ns in namespacesToClean)
{
string subns = ns;
while (subns != null)
{
bool found = tb.MoveToObject(new ProjectNamespaceData(e.Project, subns));
if (!found)
{
found = tb.MoveToObject(new ProjectNamespaceData(null, subns));
}
if (found)
{
while (tb.DataItem is NamespaceData && !tb.HasChildren())
{
tb.Remove(true);
}
break;
}
int i = subns.LastIndexOf('.');
if (i != -1)
{
subns = subns.Substring(0, i);
}
else
{
subns = null;
}
}
}
// Restore expand status
foreach (KeyValuePair <object, bool> de in oldStatus)
{
if (de.Value && tb.MoveToObject(de.Key))
{
tb.ExpandToNode();
tb.Expanded = true;
}
}
}
void Dispose (ITreeNavigator nav)
{
if (nav == null)
return;
IDisposable d = nav.DataItem as IDisposable;
if (d != null)
d.Dispose ();
if (nav.HasChildren ()) {
nav.MoveToFirstChild ();
do {
Dispose (nav);
} while (nav.MoveNext ());
nav.MoveToParent ();
}
}
ITreeNavigator SearchMember (ITreeNavigator nav, string helpUrl)
{
if (nav == null)
return null;
bool searchType = helpUrl.StartsWith ("T:", StringComparison.Ordinal);
do {
if (IsMatch (nav, helpUrl, searchType)) {
inspectEditor.ClearSelection ();
nav.ExpandToNode ();
nav.Selected = nav.Expanded = true;
nav.ScrollToNode ();
return nav;
}
if (!SkipChildren (nav, helpUrl, searchType) && nav.HasChildren ()) {
nav.MoveToFirstChild ();
ITreeNavigator result = SearchMember (nav, helpUrl);
if (result != null)
return result;
if (!nav.MoveToParent ()) {
return null;
}
try {
if (nav.DataItem is TypeDefinition && PublicApiOnly) {
nav.MoveToFirstChild ();
result = SearchMember (nav, helpUrl);
if (result != null)
return result;
nav.MoveToParent ();
}
} catch (Exception) {
}
}
} while (nav.MoveNext());
return null;
}
static NodeState SaveStateRec (ExtensibleTreeView pad, ITreeNavigator nav)
{
List<NodeState> childrenState = null;
if (nav.Filled && nav.MoveToFirstChild ()) {
do {
NodeState cs = SaveStateRec (pad, nav);
if (cs != null) {
cs.NodeName = nav.NodeName;
if (childrenState == null)
childrenState = new List<NodeState> ();
childrenState.Add (cs);
}
} while (nav.MoveNext ());
nav.MoveToParent ();
}
ExtensibleTreeView.TreeOptions ops = pad.GetNodeOptions (nav);
if (ops != null || nav.Expanded || childrenState != null || nav.Selected) {
NodeState es = new NodeState ();
es.Expanded = nav.Expanded;
es.Selected = nav.Selected;
es.Options = ops;
es.ChildrenState = childrenState;
return es;
} else
return null;
}
public override void OnNodeDrop(object dataObject, DragOperation operation)
{
// It allows dropping either project references or projects.
// Dropping a project creates a new project reference to that project
DotNetProject project = dataObject as DotNetProject;
if (project != null)
{
ProjectReference pr = new ProjectReference(project);
DotNetProject p = CurrentNode.GetParentDataItem(typeof(DotNetProject), false) as DotNetProject;
if (ProjectReferencesProject(project, p.Name))
{
return;
}
p.References.Add(pr);
IdeApp.ProjectOperations.Save(p);
return;
}
// It's dropping a ProjectReference object.
ProjectReference pref = dataObject as ProjectReference;
ITreeNavigator nav = CurrentNode;
if (operation == DragOperation.Move)
{
NodePosition pos = nav.CurrentPosition;
nav.MoveToObject(dataObject);
DotNetProject p = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject;
nav.MoveToPosition(pos);
DotNetProject p2 = nav.GetParentDataItem(typeof(DotNetProject), true) as DotNetProject;
p.References.Remove(pref);
// Check if there is a cyclic reference after removing from the source project
if (pref.ReferenceType == ReferenceType.Project)
{
DotNetProject pdest = p.ParentSolution.FindProjectByName(pref.Reference) as DotNetProject;
if (pdest == null || ProjectReferencesProject(pdest, p2.Name))
{
// Restore the dep
p.References.Add(pref);
return;
}
}
p2.References.Add(pref);
IdeApp.ProjectOperations.Save(p);
IdeApp.ProjectOperations.Save(p2);
}
else
{
nav.MoveToParent(typeof(DotNetProject));
DotNetProject p = nav.DataItem as DotNetProject;
// Check for cyclic referencies
if (pref.ReferenceType == ReferenceType.Project)
{
DotNetProject pdest = p.ParentSolution.FindProjectByName(pref.Reference) as DotNetProject;
if (pdest == null || ProjectReferencesProject(pdest, p.Name))
{
return;
}
}
p.References.Add((ProjectReference)pref.Clone());
IdeApp.ProjectOperations.Save(p);
}
}
internal static void RestoreState (ExtensibleTreeView pad, ITreeNavigator nav, NodeState es)
{
if (es == null)
return;
if (es.Options != null)
pad.SetNodeOptions (nav, es.Options);
pad.ResetState (nav);
nav.Expanded = es.Expanded;
if (es.ChildrenState != null) {
foreach (NodeState ces in es.ChildrenState) {
if (nav.MoveToChild (ces.NodeName, null)) {
RestoreState (pad, nav, ces);
nav.MoveToParent ();
}
}
}
if (es.Selected)
nav.Selected = true;
}
