protected virtual void OnGroupListTreeviewButtonReleaseEvent(object o, Gtk.ButtonReleaseEventArgs args)
{
Gtk.TreeIter iter;
groupListTreeview.Selection.GetSelected(out iter);
//bool original_state=(bool)group_store.GetValue(iter,0);
group_store.SetValue(iter, 0, !(bool)group_store.GetValue(iter, 0));
}
protected virtual void OnRemoveGroupButtonClicked(object sender, System.EventArgs e)
{
Gtk.TreePath[] path_array = belongTreeview.Selection.GetSelectedRows();
System.Collections.Generic.List <string> ret_list = new System.Collections.Generic.List <string>();
llum.Core core = llum.Core.getCore();
bool error_found = false;
if (path_array.Length > 0)
{
foreach (Gtk.TreePath path in path_array)
{
Gtk.TreeIter iter = new Gtk.TreeIter();
belong_store.GetIter(out iter, path);
string ret = core.xmlrpc.remove_from_group(user.uid, Convert.ToString(belong_store.GetValue(iter, 0)));
ret_list.Add(Convert.ToString(belong_store.GetValue(iter, 0)) + ": " + ret + "\n");
if (ret == "true")
{
//available_store.AppendValues(belong_store.GetValue(iter,0));
user.groups.Remove(Convert.ToString(belong_store.GetValue(iter, 0)));
//belong_store.Remove(ref iter);
}
else
{
error_found = true;
}
}
if (!error_found)
{
msgLabel.Markup = "<b>" + Mono.Unix.Catalog.GetString("Group modification successful") + "</b>";
}
else
{
string msg = "<span foreground='red'> Error:\n";
foreach (string str in ret_list)
{
msg += str;
}
msg += "</span>";
msgLabel.Markup = msg;
}
populateTrees();
}
}
public bool MoveToParent(Type dataType)
{
AssertIsValid();
Gtk.TreeIter newIter = currentIter;
while (store.IterParent(out newIter, newIter))
{
object data = store.GetValue(newIter, ExtensibleTreeView.DataItemColumn);
if (dataType.IsInstanceOfType(data))
{
MoveToIter(newIter);
return(true);
}
}
return(false);
}
public Node GetNodeFromIter(Gtk.TreeIter iter)
{
Node ret = null;
try
{
ret = _treeStore.GetValue(iter, 0) as Node;
}
catch
{
ret = null;
}
return(ret);
}
Gtk.Widget IOutlinedDocument.GetOutlineWidget()
{
if (outlineTreeView != null)
{
return(outlineTreeView);
}
outlineTreeStore = new Gtk.TreeStore(typeof(string), typeof(Gdk.Color), typeof(Mono.TextTemplating.ISegment));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView(outlineTreeStore);
outlineTreeView.Realized += delegate { RefillOutlineStore(); };
outlineTreeView.TextRenderer.Xpad = 0;
outlineTreeView.TextRenderer.Ypad = 0;
outlineTreeView.AppendColumn("Node", outlineTreeView.TextRenderer, "text", 0, "foreground-gdk", 1);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
Gtk.TreeIter iter;
if (!outlineTreeView.Selection.GetSelected(out iter))
{
return;
}
SelectSegment((Mono.TextTemplating.ISegment)outlineTreeStore.GetValue(iter, 2));
};
RefillOutlineStore();
var sw = new MonoDevelop.Components.CompactScrolledWindow();;
sw.Add(outlineTreeView);
sw.ShowAll();
return(sw);
}
private static bool GetTreeIterForItem(out Gtk.TreeIter itemIter, Gtk.TreeIter parentIter, Gtk.TreeStore treeStore, FileNodeViewModel item, int index)
{
// if item is null, just get iterator at index
itemIter = Gtk.TreeIter.Zero;
var validIter = false;
var putAtFront = (index < 0) && (item == null);
if (parentIter.Equals(Gtk.TreeIter.Zero))
{
if (putAtFront)
{
validIter = treeStore.IterChildren(out itemIter);
}
else
{
validIter = (treeStore.IterNChildren() > index) && treeStore.IterNthChild(out itemIter, index);
}
}
else
{
if (putAtFront)
{
validIter = treeStore.IterChildren(out itemIter, parentIter);
}
else
{
validIter = (treeStore.IterNChildren(parentIter) > index) && treeStore.IterNthChild(out itemIter, parentIter, index);
}
}
var node = validIter ? treeStore.GetValue(itemIter, 0) as FileNodeViewModel : null;
var foundIt = (node == null) || (item == null) || object.ReferenceEquals(node, item);
return(foundIt && !itemIter.Equals(Gtk.TreeIter.Zero));
}
protected virtual void OnUnfreezeUserButtonClicked(object sender, System.EventArgs e)
{
System.Collections.Generic.Dictionary <string, bool> ret = new System.Collections.Generic.Dictionary <string, bool>();
foreach (Gtk.TreePath path in frozenUsersTreeview.Selection.GetSelectedRows())
{
Gtk.TreeIter iter = new Gtk.TreeIter();
frozen_users_store.GetIter(out iter, path);
string uid = (string)frozen_users_store.GetValue(iter, 0);
ret[uid] = llum.Core.getCore().xmlrpc.unfreeze_user(uid);
}
bool ok = true;
string error_list = "";
foreach (System.Collections.Generic.KeyValuePair <string, bool> tmp in ret)
{
if (!tmp.Value)
{
ok = false;
error_list += " - " + tmp.Key + "\n";
}
}
if (ok)
{
msgLabel.Markup = Mono.Unix.Catalog.GetString("Users have been unfrozen successfully");
}
else
{
msgLabel.Markup = Mono.Unix.Catalog.GetString("The following users couldn't get unfrozen:") + "\n" + error_list;
}
populate_available_users_treeview();
}
void HandleRowChanged(object o, Gtk.RowChangedArgs args)
{
Logger.Debug("Handle Row Changed : Task Modified.");
HmTask task = (HmTask)taskStore.GetValue(args.Iter, 0);
Logger.Debug(task.Name);
}
public virtual ServerModel GetCurrentServer()
{
Trace.Call();
Gtk.TreeIter iter;
if (!_TreeView.Selection.GetSelected(out iter))
{
return(null);
}
return((ServerModel)_TreeStore.GetValue(iter, 0));
}
public static string ClearTimeConflicts(Gtk.TreeStore treeContent, Gtk.TreeIter toCheck)
{
// Get first Iter with equal time
string checkVal = (string)treeContent.GetValue(toCheck, (int)ProgrammColumnID.Uhrzeit);
Gtk.TreeIter before = toCheck;
Gtk.TreeIter drag = toCheck;
while (treeContent.IterPrevious(ref before))
{
string refVal = (string)treeContent.GetValue(before, (int)ProgrammColumnID.Uhrzeit);
if (refVal.StartsWith(checkVal.Substring(0, 5)))
{
drag = before;
}
else
{
break;
}
}
// Set all values
bool hasNext = true;
for (int i = 0; hasNext; i++)
{
SetRang(treeContent, drag, i);
GtkHelper.SortInByColumn(treeContent, (int)ProgrammColumnID.Uhrzeit, drag);
hasNext = treeContent.IterNext(ref drag);
if (hasNext)
{
string refVal = (string)treeContent.GetValue(drag, (int)ProgrammColumnID.Uhrzeit);
if (!refVal.StartsWith(checkVal.Substring(0, 5))) // Same HH:MM
{
break;
}
}
}
// Return the new value of the treeIter
return((string)treeContent.GetValue(toCheck, (int)ProgrammColumnID.Uhrzeit));
}
/// <summary>
/// Adds a person to a group and stores it in EDS
/// </summary>
public bool IsPersonInGroup(Person person)
{
Gtk.TreeIter iter;
if (personTreeStore.GetIterFirst(out iter))
{
do
{
Person iterPerson = (Person)personTreeStore.GetValue(iter, 0);
if (person.Id.CompareTo(iterPerson.Id) == 0)
{
return(true);
}
} while(personTreeStore.IterNext(ref iter));
}
return(false);
}
Signal GetSignal(Gtk.TreeIter iter)
{
if (!(bool)store.GetValue(iter, ColHasHandler))
{
return(null);
}
string handler = (string)store.GetValue(iter, ColHandler);
foreach (Signal sig in selection.Signals)
{
if (sig.Handler == handler)
{
return(sig);
}
}
return(null);
}
/// <summary>
/// Reloads assemblies if they are modified after they are loaded in the SolidReflector.
/// </summary>
/// <param name="filepaths">Filepaths of the assemblies that will be monitored.</param>
///
private void WatchFilesForChanges(string[] filepaths)
{
FileSystemWatcher watcher;
List <FileSystemWatcher> watchers = new List <FileSystemWatcher>();
foreach (string filepath in filepaths)
{
if (File.Exists(filepath))
{
watcher = new FileSystemWatcher(Path.GetDirectoryName(filepath));
watcher.NotifyFilter = NotifyFilters.LastWrite;
watcher.Changed += delegate(object sender, FileSystemEventArgs e) {
Gtk.TreeIter assemblyIter;
store.GetIterFirst(out assemblyIter);
foreach (string file in loadedAssemblies)
{
if (file == e.FullPath)
{
do
{
AssemblyDefinition assDef = store.GetValue(assemblyIter, 0) as AssemblyDefinition;
if (assDef.MainModule.FullyQualifiedName == file)
{
store.Remove(ref assemblyIter);
}
} while (store.IterNext(ref assemblyIter));
AssemblyDefinition ad1 = AssemblyDefinition.ReadAssembly(file);
store.AppendValues(ad1);
LoadSelectedAssembliesTreePaths();
}
}
};
watcher.EnableRaisingEvents = true;
watcher.IncludeSubdirectories = false;
watchers.Add(watcher);
}
}
}
Gtk.Widget IOutlinedDocument.GetOutlineWidget()
{
if (outlineTreeView != null)
{
return(outlineTreeView);
}
outlineTreeStore = new Gtk.TreeStore(typeof(object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView(outlineTreeStore);
System.Reflection.PropertyInfo prop = typeof(Gtk.TreeView).GetProperty("EnableTreeLines");
if (prop != null)
{
prop.SetValue(outlineTreeView, true, null);
}
outlineTreeView.Realized += delegate { refillOutlineStore(); };
InitializeOutlineColumns(outlineTreeView);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
Gtk.TreeIter iter;
if (!outlineTreeView.Selection.GetSelected(out iter))
{
return;
}
OutlineSelectionChanged(outlineTreeStore.GetValue(iter, 0));
};
refillOutlineStore();
var sw = new MonoDevelop.Components.CompactScrolledWindow();
sw.Add(outlineTreeView);
sw.ShowAll();
return(sw);
}
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 OnAddUserButtonClicked(object sender, System.EventArgs e)
{
Gtk.TreeIter iter;
Gtk.TreePath[] path_array = otherUsersTreeview.Selection.GetSelectedRows();
llum.Core core = llum.Core.getCore();
System.Collections.Generic.List <string> ret_list = new System.Collections.Generic.List <string>();
System.Collections.Generic.List <string> user_list = new System.Collections.Generic.List <string>();
foreach (Gtk.TreePath path in path_array)
{
available_users_store.GetIter(out iter, path);
bool ok = true;
foreach (LdapGroup grp in group_list)
{
if ((string)available_users_store.GetValue(iter, 0) == grp.gid)
{
ok = false;
}
}
if (ok)
{
if (!opened_group.member_list.Contains((string)available_users_store.GetValue(iter, 0)))
{
//LDAP OPERATION HERE
string return_str = core.xmlrpc.add_to_group((string)available_users_store.GetValue(iter, 0), opened_group.gid);
ret_list.Add(return_str);
user_list.Add((string)available_users_store.GetValue(iter, 0));
/////////////////////
if (return_str == "true")
{
opened_group.member_list.Add((string)available_users_store.GetValue(iter, 0));
}
}
}
}
populate_others_treeview();
populate_users_treeview();
string err = "";
bool error_found = false;
int count = 0;
foreach (string str in ret_list)
{
if (!str.Contains("true"))
{
error_found = true;
int count2 = 0;
string user = "";
foreach (string str2 in user_list)
{
if (count2 == count)
{
user = str2;
break;
}
count2++;
}
err += user + ": " + str + "\n";
}
count++;
}
if (!error_found)
{
msgLabel.Markup = "<b>" + Mono.Unix.Catalog.GetString("Users were added to this group successfully") + "</b>";
}
else
{
string msg = "<span foreground='red'>" + Mono.Unix.Catalog.GetString("The following errors were returned: ") + err + "</span>";
msgLabel.Markup = msg;
}
}
protected virtual void OnAcceptButtonClicked(object sender, System.EventArgs e)
{
System.Threading.Thread thread = null;
string msg2 = "";
msg2 = Mono.Unix.Catalog.GetString("Creating generic users...");
llum.Core.getCore().progress_window = new ProgressWindow(msg2);
llum.Core.getCore().progress_window.ShowAll();
llum.Core.getCore().progress_window.ShowNow();
System.Threading.ThreadStart progressTStart = delegate
{
//ACTIONS
llum.Core core = llum.Core.getCore();
Gtk.TreeIter iter;
templateCombobox.GetActiveIter(out iter);
string template = (string)store.GetValue(iter, 1);
int number = (int)numberSpinbutton.Value;
string group_cn = groupCombobox.ActiveText;
string generic_name = genericNameEntry.Text;
string password = "";
int option = core.xmlrpc.RANDOM_PASSWORDS;
if (sameAsUserRadiobutton.Active)
{
option = core.xmlrpc.PASS_EQUALS_USER;
}
if (setPasswordRadiobutton.Active)
{
option = core.xmlrpc.SAME_PASSWORD;
password = passwordEntry.Text;
}
if (randomPasswordradiobutton.Active)
{
option = core.xmlrpc.RANDOM_PASSWORDS;
}
System.Collections.Generic.List <string> ret = core.xmlrpc.add_generic_users(template, group_cn, number, generic_name, option, password);
Gtk.Application.Invoke(delegate {
string msg = "\n<b>" + Mono.Unix.Catalog.GetString("The following users were created:") + "\n";
foreach (string str in ret)
{
msg += "[*] " + str + "\n";
}
msg += "</b>";
msgLabel.Markup = msg;
Core.getCore().progress_window.Hide();
});
};
thread = new System.Threading.Thread(progressTStart);
thread.Start();
}
private static void SetRang(Gtk.TreeStore store, Gtk.TreeIter iter, int rang)
{
string val = (string)store.GetValue(iter, (int)ProgrammColumnID.Uhrzeit);
store.SetValue(iter, (int)ProgrammColumnID.Uhrzeit, val.Substring(0, 5) + ":" + rang);
}
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;
}
}
}
};
});
}
Gtk.Widget IOutlinedDocument.GetOutlineWidget ()
{
if (outlineTreeView != null)
return outlineTreeView;
outlineTreeStore = new Gtk.TreeStore (typeof (object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView (outlineTreeStore);
System.Reflection.PropertyInfo prop = typeof (Gtk.TreeView).GetProperty ("EnableTreeLines");
if (prop != null)
prop.SetValue (outlineTreeView, true, null);
outlineTreeView.Realized += delegate { refillOutlineStore (); };
InitializeOutlineColumns (outlineTreeView);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
Gtk.TreeIter iter;
if (!outlineTreeView.Selection.GetSelected (out iter))
return;
OutlineSelectionChanged (outlineTreeStore.GetValue (iter, 0));
};
refillOutlineStore ();
var sw = new MonoDevelop.Components.CompactScrolledWindow ();
sw.Add (outlineTreeView);
sw.ShowAll ();
return sw;
}
void AddHandler(Gtk.TreeIter iter, string name)
{
internalChange = true;
Gtk.TreeIter piter = iter;
while (store.IterDepth(piter) != 0)
{
store.IterParent(out piter, piter);
}
Signal signal = GetSignal(iter);
if (signal == null)
{
if (name != "")
{
SignalDescriptor sd = (SignalDescriptor)store.GetValue(iter, ColDescriptorObject);
signal = new Signal(sd);
signal.Handler = name;
selection.Signals.Add(signal);
SetSignalData(iter, signal);
store.SetValue(iter, ColSignalTextWeight, (int)Pango.Weight.Bold);
if (store.IterDepth(iter) == 1)
{
SetEmptySingalRow(store.AppendNode(iter), signal.SignalDescriptor, false);
}
else
{
store.IterParent(out iter, iter);
SetEmptySingalRow(store.AppendNode(iter), signal.SignalDescriptor, false);
}
}
}
else
{
if (name != "")
{
signal.Handler = name;
store.SetValue(iter, ColHandler, signal.Handler);
}
else
{
selection.Signals.Remove(signal);
if (store.IterDepth(iter) == 1)
{
if (store.IterNChildren(iter) == 1)
{
SetEmptySingalRow(iter, signal.SignalDescriptor, true);
// Remove the empty row
store.IterChildren(out iter, iter);
store.Remove(ref iter);
}
else
{
Gtk.TreeIter citer;
store.IterChildren(out citer, iter);
Signal csignal = GetSignal(citer);
store.Remove(ref citer);
SetSignalData(iter, csignal);
if (store.IterNChildren(iter) == 1)
{
tree.CollapseRow(store.GetPath(iter));
}
}
}
else
{
store.Remove(ref iter);
}
}
}
UpdateGroupStatus(piter);
internalChange = false;
}
Gtk.Widget IOutlinedDocument.GetOutlineWidget ()
{
if (outlineTreeView != null)
return outlineTreeView;
outlineTreeStore = new Gtk.TreeStore (typeof(string), typeof (Gdk.Color), typeof (Mono.TextTemplating.ISegment));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView (outlineTreeStore);
outlineTreeView.Realized += delegate { RefillOutlineStore (); };
outlineTreeView.TextRenderer.Xpad = 0;
outlineTreeView.TextRenderer.Ypad = 0;
outlineTreeView.AppendColumn ("Node", outlineTreeView.TextRenderer, "text", 0, "foreground-gdk", 1);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
Gtk.TreeIter iter;
if (!outlineTreeView.Selection.GetSelected (out iter))
return;
SelectSegment ((Mono.TextTemplating.ISegment )outlineTreeStore.GetValue (iter, 2));
};
RefillOutlineStore ();
var sw = new MonoDevelop.Components.CompactScrolledWindow ();;
sw.Add (outlineTreeView);
sw.ShowAll ();
return sw;
}
void TreeviewTemplates_RowActivated(object o, Gtk.RowActivatedArgs args)
{
Gtk.TreeIter iter;
store.GetIter(out iter, args.Path);
headerText.Buffer.InsertAtCursor((string)store.GetValue(iter, 0));
}
