void RefreshTree()
{
ArrayList status = SaveStatus();
store.Clear();
if (selection == null)
{
return;
}
ClassDescriptor klass = selection.ClassDescriptor;
foreach (ItemGroup group in klass.SignalGroups)
{
Gtk.TreeIter iter = store.AppendNode();
store.SetValue(iter, ColSignal, group.Label);
if (FillGroup(iter, group))
{
store.SetValue(iter, ColSignalTextWeight, (int)Pango.Weight.Bold);
}
else
{
store.SetValue(iter, ColSignalTextWeight, (int)Pango.Weight.Normal);
}
}
RestoreStatus(status);
}
public void populate_others_treeview()
{
available_users_store.Clear();
foreach (LdapGroup grp2 in group_list)
{
if (grp2.gid != opened_group.gid)
{
if (grp2.member_list.Capacity > 0)
{
Gtk.TreeIter iter;
iter = available_users_store.AppendValues(grp2.gid);
int count = 0;
foreach (string str in grp2.member_list)
{
if (!opened_group.member_list.Contains(str))
{
available_users_store.AppendValues(iter, str);
count++;
}
}
if (count == 0)
{
available_users_store.Remove(ref iter);
}
}
}
}
}
public void populate_users_treeview()
{
users_in_group_store.Clear();
foreach (string str in opened_group.member_list)
{
users_in_group_store.AppendValues(str);
}
}
public static void Populate()
{
_treeStore.Clear();
_gameElementsPaths.Clear();
var elements = GameElement.GameElements;
foreach (var element in elements)
{
if (!element.Value.IsSceneEditorGameElement())
{
Gdk.Pixbuf icon;
if (element.Value.HasComponent <Camera>())
{
icon = _cameraIcon;
}
else if (element.Value.HasComponent(out Light light))
{
switch (light.Type)
{
case LightType.Spot:
icon = _lightDirectional;
break;
case LightType.Directional:
icon = _lightDirectional;
break;
case LightType.Point:
icon = _lightDirectional;
break;
default:
icon = _lightDirectional;
break;
}
}
else
{
icon = _meshIcon;
}
var iter = _treeStore.AppendValues(icon, element.Key);
_gameElementsPaths.Add(element.Value, iter);
if (element.Value.HasChilds)
{
_populateInternal(ref iter, element.Value);
}
}
}
_treeView.Model = _treeStore;
}
protected virtual void OnSendGescenButtonClicked(object sender, System.EventArgs e)
{
if (gescenFilechooserbutton.Filename != null)
{
group_store.Clear();
string file = gescenFilechooserbutton.Filename;
/*
* string[] list=file.Split('/');
* string file_name=list[list.Length-1];
*/
//llum.Core.getCore().xmlrpc.send_file_to_server(file,"/home/lliurex/"+file_name);
string passwd = "";
if (apply_passwd_checkbutton.Active)
{
passwd = itaca_passwd_entry.Text;
}
string ret = llum.Core.getCore().xmlrpc.send_xml_to_server(file, passwd);
if (ret == "true")
{
System.Collections.Generic.List <string> list = llum.Core.getCore().xmlrpc.gescen_groups();
if (list != null)
{
foreach (string str in list)
{
group_store.AppendValues(false, str);
}
}
groupHbox.Sensitive = true;
}
else
{
if (ret.Contains("false:encrypted:"))
{
ret = ret.Replace("false:encrypted:", "");
msgLabel.Markup = "<span foreground='red'>" + ret + "</span>";
}
else
{
msgLabel.Markup = "<span foreground='red'>" + ret + "</span>";
Console.WriteLine(ret);
}
}
}
//llum.Core.getCore().xmlrpc.send_file_to_server(gescenFilechooserbutton.Filename,"/home/lliurex/test.xml");
}
private void populateTrees()
{
belong_store.Clear();
foreach (string group_ in user.groups)
{
belong_store.AppendValues((group_));
}
available_store.Clear();
foreach (string tmp in llum.Core.getCore().xmlrpc.get_available_groups())
{
if (!user.groups.Contains(tmp))
{
available_store.AppendValues((tmp));
}
}
}
public void populate_available_users_treeview()
{
available_users_store.Clear();
frozen_users_store.Clear();
System.Collections.Generic.List <string> frozen_users = llum.Core.getCore().xmlrpc.get_frozen_users();
foreach (string user in frozen_users)
{
frozen_users_store.AppendValues(user);
}
foreach (LdapUser user in user_list)
{
if (!frozen_users.Contains(user.uid) && user.main_group == "students")
{
available_users_store.AppendValues(user.uid);
}
}
}
public virtual void Load()
{
Trace.Call();
_TreeStore.Clear();
// group servers by protocol
Dictionary <string, List <ServerModel> > protocols = new Dictionary <string, List <ServerModel> >();
IList <ServerModel> servers = _Controller.GetServerList();
foreach (ServerModel server in servers)
{
List <ServerModel> protocolServers = null;
protocols.TryGetValue(server.Protocol, out protocolServers);
if (protocolServers == null)
{
protocolServers = new List <ServerModel>();
protocols.Add(server.Protocol, protocolServers);
}
protocolServers.Add(server);
}
// add grouped servers to treeview
foreach (KeyValuePair <string, List <ServerModel> > pair in protocols)
{
Gtk.TreeIter parentIter = _TreeStore.AppendValues(null, pair.Key, String.Empty);
foreach (ServerModel server in pair.Value)
{
// a server with an empty hostname has only one default/hardcoded
// hostname, thus don't create a sub-node for it
if (String.IsNullOrEmpty(server.Hostname))
{
_TreeStore.SetValue(parentIter, 0, server);
continue;
}
_TreeStore.AppendValues(parentIter, server, String.Empty, server.Hostname);
}
}
_TreeView.ExpandAll();
}
void RefillOutlineStore()
{
Runtime.AssertMainThread();
Gdk.Threads.Enter();
refreshingOutline = false;
if (outlineTreeStore == null || !outlineTreeView.IsRealized)
{
return;
}
outlineTreeStore.Clear();
if (ParsedDoc != null)
{
DateTime start = DateTime.Now;
RefillOutlineStore(ParsedDoc, outlineTreeStore);
outlineTreeView.ExpandAll();
outlineTreeView.ExpandAll();
MonoDevelop.Core.LoggingService.LogDebug("Built outline in {0}ms", (DateTime.Now - start).Milliseconds);
}
Gdk.Threads.Leave();
}
public void populate_available_groups_treeview()
{
available_groups_store.Clear();
frozen_groups_store.Clear();
System.Collections.Generic.List <string> frozen_groups = llum.Core.getCore().xmlrpc.get_frozen_groups();
foreach (string frozen_group in frozen_groups)
{
frozen_groups_store.AppendValues(frozen_group);
}
foreach (string grp in group_list_str)
{
if (!frozen_groups.Contains(grp))
{
available_groups_store.AppendValues(grp);
}
}
}
void refillOutlineStore()
{
DispatchService.AssertGuiThread();
Gdk.Threads.Enter();
refreshingOutline = false;
if (outlineTreeStore == null || !outlineTreeView.IsRealized)
{
return;
}
outlineTreeStore.Clear();
if (CU != null)
{
DateTime start = DateTime.Now;
RefillOutlineStore(CU, outlineTreeStore);
outlineTreeView.ExpandAll();
outlineTreeView.ExpandAll();
LoggingService.LogDebug("Built outline in {0}ms", (DateTime.Now - start).Milliseconds);
}
Gdk.Threads.Leave();
}
public static void Load()
{
Style.Add <FormHandler>("MainWindow", h =>
{
if (!Global.UseHeaderBar)
{
return;
}
h.Menu = null;
h.ToolBar = null;
var builder = new Gtk.Builder(null, "MainWindow.glade", null);
var headerBar = new Gtk.Widget(builder.GetObject("headerbar").Handle);
var separator = new Gtk.Widget(builder.GetObject("separator1").Handle);
popovermenu1 = new Gtk.Widget(builder.GetObject("popovermenu1").Handle);
popovermenu2 = new Gtk.Widget(builder.GetObject("popovermenu2").Handle);
Gtk3Wrapper.gtk_window_set_titlebar(h.Control.Handle, headerBar.Handle);
Gtk3Wrapper.gtk_header_bar_set_show_close_button(headerBar.Handle, true);
Connect(builder.GetObject("new_button").Handle, MainWindow.Instance.cmdNew);
Connect(builder.GetObject("save_button").Handle, MainWindow.Instance.cmdSave);
Connect(builder.GetObject("build_button").Handle, MainWindow.Instance.cmdBuild, false);
Connect(builder.GetObject("rebuild_button").Handle, MainWindow.Instance.cmdRebuild, false);
Connect(builder.GetObject("cancel_button").Handle, MainWindow.Instance.cmdCancelBuild, false);
Connect(builder.GetObject("open_other_button").Handle, MainWindow.Instance.cmdOpen);
Connect(builder.GetObject("import_button").Handle, MainWindow.Instance.cmdImport);
Connect(builder.GetObject("saveas_button").Handle, MainWindow.Instance.cmdSaveAs);
Connect(builder.GetObject("undo_button").Handle, MainWindow.Instance.cmdUndo);
Connect(builder.GetObject("redo_button").Handle, MainWindow.Instance.cmdRedo);
Connect(builder.GetObject("close_button").Handle, MainWindow.Instance.cmdClose);
Connect(builder.GetObject("clean_button").Handle, MainWindow.Instance.cmdClean);
Connect(builder.GetObject("help_button").Handle, MainWindow.Instance.cmdHelp);
Connect(builder.GetObject("about_button").Handle, MainWindow.Instance.cmdAbout);
Connect(builder.GetObject("exit_button").Handle, MainWindow.Instance.cmdExit);
Connect(builder.GetObject("debugmode_button").Handle, MainWindow.Instance.cmdDebugMode);
MainWindow.Instance.cmdBuild.EnabledChanged += (sender, e) =>
separator.Visible = MainWindow.Instance.cmdBuild.Enabled || MainWindow.Instance.cmdCancelBuild.Enabled;
MainWindow.Instance.cmdCancelBuild.EnabledChanged += (sender, e) =>
separator.Visible = MainWindow.Instance.cmdBuild.Enabled || MainWindow.Instance.cmdCancelBuild.Enabled;
MainWindow.Instance.TitleChanged += delegate
{
var title = MainWindow.TitleBase;
var subtitle = "";
if (PipelineController.Instance.ProjectOpen)
{
title = (PipelineController.Instance.ProjectDirty) ? "*" : "";
title += Path.GetFileName(PipelineController.Instance.ProjectItem.OriginalPath);
subtitle = Path.GetDirectoryName(PipelineController.Instance.ProjectItem.OriginalPath);
}
h.Control.Title = title;
Gtk3Wrapper.gtk_header_bar_set_subtitle(headerBar.Handle, subtitle);
};
var treeview1 = new Gtk.TreeView(builder.GetObject("treeview1").Handle);
var store = new Gtk.TreeStore(typeof(string), typeof(string));
var column = new Gtk.TreeViewColumn();
var textCell = new Gtk.CellRendererText();
var dataCell = new Gtk.CellRendererText();
dataCell.Visible = false;
column.PackStart(textCell, false);
column.PackStart(dataCell, false);
treeview1.AppendColumn(column);
column.AddAttribute(textCell, "markup", 0);
column.AddAttribute(dataCell, "text", 1);
treeview1.Model = store;
MainWindow.Instance.RecentChanged += (sender, e) =>
{
store.Clear();
var recentList = sender as List <string>;
foreach (var project in recentList)
{
store.InsertWithValues(0, "<b>" + Path.GetFileName(project) + "</b>\n" +
Path.GetDirectoryName(project), project);
}
};
treeview1.RowActivated += (o, args) =>
{
popovermenu2.Hide();
Gtk.TreeIter iter;
if (!store.GetIter(out iter, args.Path))
{
return;
}
var project = store.GetValue(iter, 1).ToString();
PipelineController.Instance.OpenProject(project);
};
h.Control.ShowAll();
});
Style.Add <DialogHandler>("HeaderBar", h =>
{
var title = h.Title;
var headerBar = Gtk3Wrapper.gtk_header_bar_new();
Gtk3Wrapper.gtk_window_set_titlebar(h.Control.Handle, headerBar);
h.Title = title;
if (h.AbortButton.Text == "Close")
{
Gtk3Wrapper.gtk_header_bar_set_show_close_button(headerBar, true);
return;
}
var defButton = (Gtk.Button)h.DefaultButton.ControlObject;
defButton.StyleContext.AddClass("suggested-action");
Gtk3Wrapper.gtk_header_bar_pack_end(headerBar, defButton.Handle);
Gtk3Wrapper.gtk_header_bar_pack_start(headerBar, ((Gtk.Button)h.AbortButton.ControlObject).Handle);
});
Style.Add <LabelHandler>("Wrap", h => h.Control.MaxWidthChars = 55);
Style.Add <ToolBarHandler>("ToolBar", h =>
{
h.Control.ToolbarStyle = Gtk.ToolbarStyle.Icons;
h.Control.IconSize = Gtk.IconSize.SmallToolbar;
});
Style.Add <TreeViewHandler>("Scroll", h =>
{
var treeView = h.Control.Child as Gtk.TreeView;
Gtk.TreeIter lastIter, iter;
if (treeView.Model.GetIterFirst(out iter))
{
do
{
lastIter = iter;
}while (treeView.Model.IterNext(ref iter));
var path = treeView.Model.GetPath(lastIter);
treeView.ScrollToCell(path, null, false, 0, 0);
}
});
Style.Add <DrawableHandler>("Stretch", h =>
{
var parent = h.Control.Parent.Parent.Parent.Parent.Parent.Parent;
parent.SizeAllocated += delegate
{
var al = h.Control.Allocation;
al.Width = parent.AllocatedWidth - 2;
h.Control.SetAllocation(al);
};
});
Style.Add <PixelLayoutHandler>("Stretch", h =>
{
var parent = h.Control.Parent.Parent.Parent.Parent.Parent;
parent.SizeAllocated += delegate
{
var al = h.Control.Allocation;
al.Width = parent.AllocatedWidth;
h.Control.SetAllocation(al);
};
});
Style.Add <TextBoxHandler>("OverrideSize", h =>
{
h.Control.WidthChars = 0;
});
Style.Add <ScrollableHandler>("BuildOutput", h =>
{
var child = ((((h.Control.Child as Gtk.Viewport).Child as Gtk.VBox).Children[0] as Gtk.HBox).Children[0] as Gtk.Alignment).Child;
var ok = false;
h.Control.SizeAllocated += delegate
{
// Set Width of the Drawable
var al = child.Allocation;
al.Width = h.Control.AllocatedWidth - 2;
if (BuildOutput.ReqWidth > al.Width)
{
al.Width = BuildOutput.ReqWidth;
}
child.SetAllocation(al);
if (PipelineSettings.Default.AutoScrollBuildOutput)
{
// Scroll to bottom
if (BuildOutput.Count == -1)
{
ok = false;
}
if (!ok)
{
var adj = h.Control.Vadjustment;
adj.Value = adj.Upper - adj.PageSize;
if (adj.Upper >= BuildOutput.Count && BuildOutput.Count != -1)
{
ok = true;
}
}
}
};
});
}
public static void Load()
{
Style.Add <ApplicationHandler>("PipelineTool", h =>
{
Global.Application = h.Control;
if (Gtk.Global.MajorVersion >= 3 && Gtk.Global.MinorVersion >= 16)
{
Global.UseHeaderBar = Global.Application.PrefersAppMenu();
}
if (Global.UseHeaderBar)
{
Global.Application.AppMenu = new GLib.MenuModel((new Gtk.Builder("AppMenu.glade")).GetObject("appmenu").Handle);
}
});
Style.Add <FormHandler>("MainWindow", h =>
{
if (!Global.UseHeaderBar)
{
return;
}
var builder = new Gtk.Builder("MainWindow.glade");
var headerBar = new Gtk.HeaderBar(builder.GetObject("headerbar").Handle);
h.Menu = null;
h.ToolBar = null;
Connect("new", MainWindow.Instance.cmdNew);
Connect("open", MainWindow.Instance.cmdOpen);
Connect("save", MainWindow.Instance.cmdSave);
Connect("saveas", MainWindow.Instance.cmdSaveAs);
Connect("import", MainWindow.Instance.cmdImport);
Connect("close", MainWindow.Instance.cmdClose);
Connect("help", MainWindow.Instance.cmdHelp);
Connect("about", MainWindow.Instance.cmdAbout);
Connect("quit", MainWindow.Instance.cmdExit);
Connect("undo", MainWindow.Instance.cmdUndo);
Connect("redo", MainWindow.Instance.cmdRedo);
Connect("build", MainWindow.Instance.cmdBuild);
Connect("rebuild", MainWindow.Instance.cmdRebuild);
Connect("clean", MainWindow.Instance.cmdClean);
Connect("cancel", MainWindow.Instance.cmdCancelBuild);
var widget = new Gtk.ModelButton(builder.GetObject("button_debug").Handle);
widget.Active = MainWindow.Instance.cmdDebugMode.Checked;
widget.Clicked += (e, sender) =>
{
var newstate = !PipelineSettings.Default.DebugMode;
widget.Active = newstate;
PipelineSettings.Default.DebugMode = newstate;
};
_accelGroup = new Gtk.AccelGroup();
Connect(MainWindow.Instance.cmdNew, Gdk.Key.N, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdOpen, Gdk.Key.O, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdSave, Gdk.Key.S, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdExit, Gdk.Key.Q, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdUndo, Gdk.Key.Z, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdRedo, Gdk.Key.Y, Gdk.ModifierType.ControlMask);
Connect(MainWindow.Instance.cmdBuild, Gdk.Key.F6);
Connect(MainWindow.Instance.cmdHelp, Gdk.Key.F1);
h.Control.AddAccelGroup(_accelGroup);
_popovermenu1 = new Gtk.Widget(builder.GetObject("popovermenu1").Handle);
_popovermenu2 = new Gtk.Widget(builder.GetObject("popovermenu2").Handle);
h.Control.Titlebar = headerBar;
headerBar.ShowCloseButton = true;
_buttonbox = new Gtk.Widget(builder.GetObject("build_buttonbox").Handle);
_cancelbox = new Gtk.Widget(builder.GetObject("cancel_button").Handle);
_separator = new Gtk.Widget(builder.GetObject("separator1").Handle);
MainWindow.Instance.cmdBuild.EnabledChanged += (sender, e) => ReloadBuildbox();
MainWindow.Instance.cmdCancelBuild.EnabledChanged += (sender, e) => ReloadBuildbox();
MainWindow.Instance.TitleChanged += delegate
{
var title = MainWindow.TitleBase;
var subtitle = "";
if (PipelineController.Instance.ProjectOpen)
{
title = (PipelineController.Instance.ProjectDirty) ? "*" : "";
title += Path.GetFileName(PipelineController.Instance.ProjectItem.OriginalPath);
subtitle = Path.GetDirectoryName(PipelineController.Instance.ProjectItem.OriginalPath);
}
h.Control.Title = title;
headerBar.Subtitle = subtitle;
};
var treeview1 = new Gtk.TreeView(builder.GetObject("treeview1").Handle);
var store = new Gtk.TreeStore(typeof(string), typeof(string));
var column = new Gtk.TreeViewColumn();
var textCell = new Gtk.CellRendererText();
var dataCell = new Gtk.CellRendererText();
dataCell.Visible = false;
column.PackStart(textCell, false);
column.PackStart(dataCell, false);
treeview1.AppendColumn(column);
column.AddAttribute(textCell, "markup", 0);
column.AddAttribute(dataCell, "text", 1);
treeview1.Model = store;
MainWindow.Instance.RecentChanged += (sender, e) =>
{
store.Clear();
var recentList = sender as List <string>;
foreach (var project in recentList)
{
store.InsertWithValues(0, "<b>" + Path.GetFileName(project) + "</b>\n" +
Path.GetDirectoryName(project), project);
}
};
treeview1.RowActivated += (o, args) =>
{
_popovermenu2.Hide();
Gtk.TreeIter iter;
if (!store.GetIter(out iter, args.Path))
{
return;
}
var project = store.GetValue(iter, 1).ToString();
PipelineController.Instance.OpenProject(project);
};
headerBar.Show();
});
Style.Add <ButtonHandler>("Destuctive", h => h.Control.StyleContext.AddClass("destructive-action"));
Style.Add <LabelHandler>("Wrap", h => h.Control.MaxWidthChars = 55);
Style.Add <ToolBarHandler>("ToolBar", h =>
{
h.Control.ToolbarStyle = Gtk.ToolbarStyle.Icons;
h.Control.IconSize = Gtk.IconSize.SmallToolbar;
});
Style.Add <DrawableHandler>("Stretch", h =>
{
var parent = h.Control.Parent.Parent.Parent.Parent.Parent.Parent;
parent.SizeAllocated += delegate
{
var al = h.Control.Allocation;
al.Width = parent.AllocatedWidth - 2;
h.Control.SetAllocation(al);
};
});
Style.Add <PixelLayoutHandler>("Stretch", h =>
{
var parent = h.Control.Parent.Parent.Parent.Parent.Parent;
parent.SizeAllocated += delegate
{
var al = h.Control.Allocation;
al.Width = parent.AllocatedWidth;
h.Control.SetAllocation(al);
};
});
}
protected virtual void OnImportButtonClicked(object sender, System.EventArgs e)
{
if (partialRadiobutton.Active)
{
Gtk.TreeIter iter;
System.Collections.Generic.List <string> list = new System.Collections.Generic.List <string>();
if (group_store.IterNChildren() > 0)
{
group_store.GetIterFirst(out iter);
if ((bool)group_store.GetValue(iter, 0))
{
list.Add((string)group_store.GetValue(iter, 1));
}
while (group_store.IterNext(ref iter))
{
if ((bool)group_store.GetValue(iter, 0))
{
list.Add((string)group_store.GetValue(iter, 1));
}
}
}
string[] str_array = new string[list.Count];
int i;
for (i = 0; i < list.Count; i++)
{
str_array[i] = list[i];
}
System.Threading.Thread thread = null;
llum.Core.getCore().progress_window = new ProgressWindow(Mono.Unix.Catalog.GetString("Importing users and groups..."));
llum.Core.getCore().progress_window.ShowAll();
llum.Core.getCore().progress_window.ShowNow();
System.Threading.ThreadStart progressTStart = delegate
{
bool ret = llum.Core.getCore().xmlrpc.gescen_partial(str_array);
Gtk.Application.Invoke(delegate {
if (ret)
{
msgLabel.Markup = "<b>" + Mono.Unix.Catalog.GetString("Importation successful") + "</b>";
}
else
{
string txt = "<span foreground='red'>" + Mono.Unix.Catalog.GetString("Importation failed") + "</span>";
msgLabel.Markup = txt;
}
llum.Core.getCore().progress_window.Hide();
});
};
thread = new System.Threading.Thread(progressTStart);
thread.Start();
}
if (completeRadiobutton.Active)
{
System.Threading.Thread thread2 = null;
System.Threading.ThreadStart tstart = delegate
{
Gtk.Application.Invoke(delegate {
llum.Core.getCore().progress_window = new ProgressWindow(Mono.Unix.Catalog.GetString("Importing users and groups..."));
llum.Core.getCore().progress_window.ShowAll();
llum.Core.getCore().progress_window.ShowNow();
});
};
thread2 = new System.Threading.Thread(tstart);
thread2.Start();
System.Threading.Thread thread = null;
System.Threading.ThreadStart progressTStart = delegate
{
//bool ret=llum.Core.getCore().xmlrpc.gescen_partial(str_array);
System.Collections.Generic.List <LdapUser> ret = llum.Core.getCore().xmlrpc.gescen_full();
Gtk.Application.Invoke(delegate {
if (ret != null)
{
msgLabel.Markup = "<b>" + Mono.Unix.Catalog.GetString("Importation successful") + "</b>";
user_store.Clear();
foreach (LdapUser user in ret)
{
user_store.AppendValues(user.uid, user.name + " " + user.surname, user.main_group);
}
if (ret.Count > 0)
{
usersToDeleteHbox.Sensitive = true;
to_delete = ret;
}
}
else
{
string txt = "<span foreground='red'>" + Mono.Unix.Catalog.GetString("Importation failed") + "</span>";
msgLabel.Markup = txt;
}
groupHbox.Sensitive = false;
Core.getCore().progress_window.Hide();
thread.Abort();
});
};
thread = new System.Threading.Thread(progressTStart);
thread.Start();
}
}
public void Clear()
{
version++;
Tree.Clear();
}
