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();
}
protected void attachSubTree(Gtk.TreeModel model, Gtk.TreeIter parent, params object[] elements)
{
Gtk.TreeStore store = model as Gtk.TreeStore;
// remove the values if they were added before.
Gtk.TreePath path = store.GetPath(parent);
path.Down();
Gtk.TreeIter iter;
while (store.GetIter(out iter, path))
{
store.Remove(ref iter);
}
// Add the elements to the tree view.
DirectoryInfo[] di = elements[0] as DirectoryInfo[];
FileInfo[] fi = elements[1] as FileInfo[];
for (uint i = 0; i < di.Length; ++i)
{
store.AppendValues(parent, di[i].ToString());
}
for (uint i = 0; i < fi.Length; ++i)
{
store.AppendValues(parent, fi[i].ToString());
}
}
void HandleRowDeleted(object o, Gtk.RowDeletedArgs args)
{
Gtk.TreeIter outIter;
if (TreeStore.GetIter(out outIter, args.Path) && outIter.Equals(Iter))
{
UnregisterTreeAnimation(this);
}
}
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();
}
}
void OnRowActivated(object sender, Gtk.RowActivatedArgs args)
{
Gtk.TreeIter iter;
if (!store.GetIter(out iter, args.Path))
{
return;
}
SignalDescriptor sd = GetSignalDescriptor(iter);
if (sd != null)
{
if (GetSignal(iter) == null)
{
AddHandler(iter, GetHandlerName(sd.Name));
}
frontend.NotifySignalActivated();
}
}
/// <summary>
/// Attaches a submodel to the tree view's model.
/// </summary>
/// <param name='model'>
/// The root model to be attached to.
/// </param>
/// <param name='parent'>[ref]
/// The pointer where the elements to be attached to.
/// </param>
/// <param name='elements'>
/// Elements.
/// </param>
protected void AttachSubTree(Gtk.TreeModel model, Gtk.TreeIter parent, object[] elements)
{
Debug.Assert(store != null, "TreeModel shouldn't be flat");
// remove the values if they were added before.
Gtk.TreePath path = store.GetPath(parent);
path.Down();
Gtk.TreeIter iter;
while (store.GetIter(out iter, path))
{
store.Remove(ref iter);
}
// Add the elements to the tree view.
for (uint i = 0; i < elements.Length; ++i)
{
store.AppendValues(parent, elements[i]);
}
}
/// <summary>
/// Gets a Gtk.TreeIter for the node.
/// </summary>
/// <param name="iter">Receives the iterator to the node within the Gtk.TreeStore.</param>
/// <param name="treeStore">The tree store containing reference to this node.</param>
/// <returns><c>true</c>, if iter was successfully retrieved, or this node is the root, <c>false</c> otherwise.</returns>
/// <remarks>If this is the root node, <paramref name="iter"/> contains Gtk.TreeIter.Zero. Caller must check for this.</remarks>
internal bool GetIterForItem(out Gtk.TreeIter iter, Gtk.TreeStore treeStore)
{
iter = Gtk.TreeIter.Zero;
var path = new Gtk.TreePath();
var node = Model;
var parent = Parent;
while (parent != null)
{
var index = parent.IndexOfChild(node);
path.PrependIndex(index);
node = parent;
parent = node.Parent;
}
var succeeded = (path.Depth == 0) || treeStore.GetIter(out iter, path);
return(succeeded);
}
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);
};
});
}
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));
}
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;
}
}
