protected void UpdateToolbox()
{
Gtk.TreeStore store = treeView.Model as Gtk.TreeStore;
//if (store == null) store = new Gtk.TreeStore(typeof(string), typeof(Tool<Gdk.Event, Cairo.Context, Model>), typeof(Shape));
IServiceContainer plugins = solidIDE.GetServiceContainer();
IDesigner designer = plugins.GetService <IDesigner>();
//TODO: Scan for Shape types
var model = (designer.CurrentSheet as Sheet <Gdk.Event, Cairo.Context, Model>).Model;
var view = (designer.CurrentSheet as Sheet <Gdk.Event, Cairo.Context, Model>).View;
ITool <Gdk.Event, Cairo.Context, Model> tool;
//
tool = new Tool <Gdk.Event, Cairo.Context, Model>(new FocusRectangleController(model, view), new AddNewShapeCommand(designer, null));
(tool.Controller() as FocusRectangleController).FocusedRectangleFinish += HandleFocusedRectangleFinish;
store.AppendValues("Rectangle", tool, new RectangleShape(new Rectangle(0, 0, 100, 50)));
//
tool = new Tool <Gdk.Event, Cairo.Context, Model>(new FocusRectangleController(model, view), new AddNewShapeCommand(designer, null));
(tool.Controller() as FocusRectangleController).FocusedRectangleFinish += HandleFocusedRectangleFinish;
store.AppendValues("Ellipse", tool, new EllipseShape(new Rectangle(0, 0, 50, 100)));
//
Shape Nowhere = new Glue(new Rectangle(0, 0, 0, 0));
tool = new Tool <Gdk.Event, Cairo.Context, Model>(null, new AddNewBinaryRelationCommand(designer, new ArrowShape(Nowhere, Nowhere)));
store.AppendValues("Arrow Connector", tool, new ArrowShape(Nowhere, Nowhere));
}
public TreeViewExample()
{
Gtk.Window window = new Gtk.Window("TreeView Example");
window.SetSizeRequest(500, 200);
Gtk.TreeView tree = new Gtk.TreeView();
window.Add(tree);
Gtk.TreeViewColumn Parent = new Gtk.TreeViewColumn();
Parent.Title = "Parent";
Gtk.CellRendererText Parent1 = new Gtk.CellRendererText();
Parent.PackStart(Parent1, true);
Gtk.TreeViewColumn ChildColoumn1 = new Gtk.TreeViewColumn();
ChildColoumn1.Title = "Column 1";
Gtk.CellRendererText Child1 = new Gtk.CellRendererText();
ChildColoumn1.PackStart(Child1, true);
Gtk.TreeViewColumn ChildColumn2 = new Gtk.TreeViewColumn();
ChildColumn2.Title = "Column 2";
Gtk.CellRendererText Child2 = new Gtk.CellRendererText();
ChildColumn2.PackStart(Child2, true);
tree.AppendColumn(Parent);
tree.AppendColumn(ChildColoumn1);
tree.AppendColumn(ChildColumn2);
Parent.AddAttribute(Parent1, "text", 0);
ChildColoumn1.AddAttribute(Child1, "text", 1);
ChildColumn2.AddAttribute(Child2, "text", 2);
Gtk.TreeStore Tree = new Gtk.TreeStore(typeof(string), typeof(string), typeof(string));
Gtk.TreeIter iter = Tree.AppendValues("Parent1");
Tree.AppendValues(iter, "Child1", "Node 1");
iter = Tree.AppendValues("Parent2");
Tree.AppendValues(iter, "Child1", "Node 1", "Node 2");
tree.Model = Tree;
window.ShowAll();
}
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());
}
}
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 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;
}
void NewTable(GameState state)
{
tableId = state.TableId;
playIndex = -1;
tableLogIter = logModel.AppendValues("Table " + tableId.ToString(), "", "", "");
chipHistory.Clear();
estimateHistory.Clear();
estimateShortTermHistory.Clear();
diffHistory.Clear();
correlationHistory.Clear();
_chips = 10000;
}
void BuildTreeChildren(Gtk.TreeStore store, Gtk.TreeIter parent, ParentNode p, IList <Block> blocks)
{
foreach (Node node in p)
{
if (!(node is TagNode))
{
var startLoc = new TextLocation(node.Location.BeginLine, node.Location.BeginColumn);
var endLoc = new TextLocation(node.Location.EndLine, node.Location.EndColumn);
var doc = defaultDocument.Editor.Document;
var blocksBetween = blocks.Where(n => n.Start.AbsoluteIndex >= doc.GetOffset(startLoc) &&
n.Start.AbsoluteIndex <= doc.GetOffset(endLoc));
foreach (var block in blocksBetween)
{
var outlineNode = new OutlineNode(block)
{
Location = new DomRegion(doc.OffsetToLocation(block.Start.AbsoluteIndex),
doc.OffsetToLocation(block.Start.AbsoluteIndex + block.Length))
};
if (!parent.Equals(Gtk.TreeIter.Zero))
{
store.AppendValues(parent, outlineNode);
}
else
{
store.AppendValues(outlineNode);
}
}
continue;
}
Gtk.TreeIter childIter;
if (!parent.Equals(Gtk.TreeIter.Zero))
{
childIter = store.AppendValues(parent, new OutlineNode(node as TagNode));
}
else
{
childIter = store.AppendValues(new OutlineNode(node as TagNode));
}
ParentNode pChild = node as ParentNode;
if (pChild != null)
{
BuildTreeChildren(store, childIter, pChild, blocks);
}
}
}
static void BuildTreeChildren(Gtk.TreeStore store, Gtk.TreeIter parent, XContainer p)
{
foreach (XNode n in p.Nodes)
{
Gtk.TreeIter childIter;
if (!parent.Equals (Gtk.TreeIter.Zero))
childIter = store.AppendValues (parent, n);
else
childIter = store.AppendValues (n);
XContainer c = n as XContainer;
if (c != null && c.FirstChild != null)
BuildTreeChildren (store, childIter, c);
}
}
protected Gtk.TreeStore getTreeStoreWithData()
{
Gtk.TreeStore ts = getTreeStore();
ts.DefaultSortFunc = null;
if (this.Root != null)
{
addData(ts, Gtk.TreeIter.Zero, this.Root.RootRow, false);
}
else
{
//startStopWatch("AppendValues");
foreach (VirtualGridRow row in Rows)
{
//String[] values = row.Values;
ts.AppendValues(row.Datas);
}
//ts.AppendValues(
//stopStopWatch("AppendValues");
}
return(ts);
}
public void Fill(IList dossiers)
{
//Gtk.Image folderImage = new Gtk.Image(Gtk.Stock.Directory, Gtk.IconSize.Menu);
Gdk.Pixbuf folderImage = Gdk.Pixbuf.LoadFromResource("stock-folder.png");
Gdk.Pixbuf documentImage = Gdk.Pixbuf.LoadFromResource("stock-generic.png");
foreach (Dossier dossier in dossiers)
{
Gtk.TreeIter iter = _TreeStore.AppendValues(folderImage, dossier);
foreach (Document document in dossier.Documents)
{
//TODO : Déterminer l'icone en fonction du document
_TreeStore.AppendValues(iter, documentImage, document);
}
}
}
public void populate_users_treeview()
{
users_in_group_store.Clear();
foreach (string str in opened_group.member_list)
{
users_in_group_store.AppendValues(str);
}
}
void BuildTreeChildren(Gtk.TreeStore store, Gtk.TreeIter parent, XContainer p, IList <Block> blocks)
{
foreach (XNode node in p.Nodes)
{
var el = node as XElement;
if (el == null)
{
var startLoc = node.Region.Begin;
var endLoc = node.Region.End;
var doc = defaultDocument.Editor.Document;
var blocksBetween = blocks.Where(n => n.Start.AbsoluteIndex >= doc.GetOffset(startLoc) &&
n.Start.AbsoluteIndex <= doc.GetOffset(endLoc));
foreach (var block in blocksBetween)
{
var outlineNode = new OutlineNode(block)
{
Location = new DomRegion(doc.OffsetToLocation(block.Start.AbsoluteIndex),
doc.OffsetToLocation(block.Start.AbsoluteIndex + block.Length))
};
if (!parent.Equals(Gtk.TreeIter.Zero))
{
store.AppendValues(parent, outlineNode);
}
else
{
store.AppendValues(outlineNode);
}
}
continue;
}
Gtk.TreeIter childIter;
if (!parent.Equals(Gtk.TreeIter.Zero))
{
childIter = store.AppendValues(parent, new OutlineNode(el));
}
else
{
childIter = store.AppendValues(new OutlineNode(el));
}
BuildTreeChildren(store, childIter, el, blocks);
}
}
private void AddNodes(Node node, Gtk.TreeIter iter = new Gtk.TreeIter())
{
if (iter.Stamp == 0)
{
iter = _treeStore.AppendValues(node);
}
foreach (var child in node.Children)
{
_treeStore.AppendValues(iter, child);
if (child.Children.Any())
{
AddNodes(child, iter);
}
}
}
public static Gtk.TreeStore DataBind(this Gtk.TreeView tree, SyncItem data)
{
Gtk.TreeStore syncItems = new Gtk.TreeStore(typeof(SyncItem));
var iter = syncItems.AppendValues(data);
SetChildItems(syncItems, iter, data.ChildItems.Values);
return syncItems;
}
/// <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]);
}
}
public static Gtk.TreeStore DataBind(this Gtk.TreeView tree, SyncItem data)
{
Gtk.TreeStore syncItems = new Gtk.TreeStore(typeof(SyncItem));
var iter = syncItems.AppendValues(data);
SetChildItems(syncItems, iter, data.ChildItems.Values);
return(syncItems);
}
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();
}
private static void SetChildItems(Gtk.TreeStore syncItems, Gtk.TreeIter iter, IEnumerable <SyncItem> items)
{
foreach (var item in items)
{
var childIter = syncItems.AppendValues(iter, item);
if (item.ChildItems.Count > 0)
{
SetChildItems(syncItems, childIter, item.ChildItems.Values);
}
}
}
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 AddItemsToTreeStore(Gtk.TreeStore treeStore, IList <FileNodeViewModel> itemsToAdd, int startingIndex)
{
Gtk.TreeIter treeIter;
var gotSelfIter = GetIterForItem(out treeIter, treeStore);
Gtk.TreeIter insertIter;
bool putAtFront = startingIndex == 0;
var insertIterValid = GetTreeIterForItem(out insertIter, treeIter, treeStore, null, startingIndex - 1);
for (int i = 0; i < itemsToAdd.Count; ++i)
{
var item = itemsToAdd[i];
var folder = item as FolderViewModel;
if (folder != null)
{
// Ensure that the tree store is properly initialized.
folder.InitializeGtkModel(treeStore);
}
if (insertIterValid)
{
if (putAtFront)
{
insertIter = treeStore.InsertNodeBefore(insertIter);
putAtFront = false;
}
else
{
insertIter = treeStore.InsertNodeAfter(insertIter);
}
treeStore.SetValue(insertIter, 0, item);
}
else if (treeIter.Equals(Gtk.TreeIter.Zero))
{
treeStore.AppendValues(item);
}
else
{
treeStore.AppendValues(treeIter, item);
}
}
}
public TreeViewExample()
{
Gtk.Window window = new Gtk.Window("TreeView Example");
window.SetSizeRequest(500, 200);
Gtk.TreeView tree = new Gtk.TreeView();
window.Add(tree);
Gtk.TreeViewColumn artistColumn = new Gtk.TreeViewColumn();
artistColumn.Title = "Artist";
Gtk.CellRendererText artistNameCell = new Gtk.CellRendererText();
artistColumn.PackStart(artistNameCell, true);
Gtk.TreeViewColumn songColumn = new Gtk.TreeViewColumn();
songColumn.Title = "Song Title";
Gtk.CellRendererText songTitleCell = new Gtk.CellRendererText();
songColumn.PackStart(songTitleCell, true);
tree.AppendColumn(artistColumn);
tree.AppendColumn(songColumn);
artistColumn.AddAttribute(artistNameCell, "text", 0);
songColumn.AddAttribute(songTitleCell, "text", 1);
Gtk.TreeStore musicListStore = new Gtk.TreeStore(typeof(string), typeof(string));
Gtk.TreeIter iter = musicListStore.AppendValues("Dance");
musicListStore.AppendValues(iter, "Fannypack", "Nu Nu (Yeah Yeah) (double j and haze radio edit)");
iter = musicListStore.AppendValues("Hip-hop");
musicListStore.AppendValues(iter, "Nelly", "Country Grammer");
tree.Model = musicListStore;
window.ShowAll();
}
/// <summary>
/// Inserts the given child FileNodeViewModels into the given Gtk.TreeStore using the supplied Gtk.TreeIter as the point of insertion.
/// </summary>
/// <param name="treeStore">The Gtk.TreeStore to add child objects to.</param>
/// <param name="children">The child ViewModels.</param>
/// <param name="iter">The Gtk.TreeIter of the parent to which children are added.</param>
protected static void InsertChildren(Gtk.TreeStore treeStore, ObservableCollection <FileNodeViewModel> children, Gtk.TreeIter iter)
{
foreach (var child in children)
{
Gtk.TreeIter childIter;
if (iter.Equals(Gtk.TreeIter.Zero))
{
childIter = treeStore.AppendValues(child);
}
else
{
childIter = treeStore.AppendValues(iter, child);
}
var folder = child as FolderViewModel;
if (folder != null)
{
// Ensure the child folder has properly initialized Gtk.TreeStore.
folder.InitializeGtkModel(treeStore);
InsertChildren(treeStore, folder.Items, childIter);
}
}
}
public AddGenericUsersWidget()
{
this.Build();
store = new Gtk.TreeStore(typeof(string), typeof(string));
store.AppendValues(Mono.Unix.Catalog.GetString("Students"), "Students");
store.AppendValues(Mono.Unix.Catalog.GetString("Teachers"), "Teachers");
//store.AppendValues(Mono.Unix.Catalog.GetString("Other"),"Other");
templateCombobox.Model = store;
templateCombobox.Active = 0;
image = new Gtk.Image();
image.SetFromIconName("gtk-add", Gtk.IconSize.Dnd);
label = new Gtk.Label(Mono.Unix.Catalog.GetString("Add Generic Users"));
label.Show();
}
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.AppendValues(group.Label, null, false, false, false, (int)Pango.Weight.Normal);
if (FillGroup(iter, group))
{
store.SetValue(iter, ColSignalTextWeight, (int)Pango.Weight.Bold);
}
}
RestoreStatus(status);
}
static void BuildTreeChildren(Gtk.TreeStore store, Gtk.TreeIter parent, ParentNode p)
{
foreach (Node n in p)
{
if (!(n is TagNode || n is DirectiveNode || n is ExpressionNode))
{
continue;
}
Gtk.TreeIter childIter;
if (!parent.Equals(Gtk.TreeIter.Zero))
{
childIter = store.AppendValues(parent, n);
}
else
{
childIter = store.AppendValues(n);
}
ParentNode pChild = n as ParentNode;
if (pChild != null)
{
BuildTreeChildren(store, childIter, pChild);
}
}
}
internal StandardHeaderPolicyPanelWidget(StandardHeaderPolicyPanel parent)
{
this.parent = parent;
this.Build();
headerText.Buffer.Changed += NotifyChanged;
includeAutoCheck.Toggled += NotifyChanged;
this.treeviewTemplates.AppendColumn(GettextCatalog.GetString("Templates"), new Gtk.CellRendererText(), "text", 0);
foreach (var template in templates)
{
store.AppendValues("${" + template + "}");
}
this.treeviewTemplates.Model = store;
treeviewTemplates.RowActivated += TreeviewTemplates_RowActivated;
var w4 = ((global::Gtk.Box.BoxChild)(this.hbox2 [this.GtkScrolledWindow1]));
w4.Expand = false;
treeviewTemplates.WidthRequest = 200;
treeviewTemplates.QueueResize();
}
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);
}
}
}
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 static Gtk.Window CreateTreeWindow()
{
Gtk.Window window = new Gtk.Window("Sortable TreeView");
Gtk.TreeIter iter;
Gtk.TreeViewColumn col;
Gtk.CellRendererText cell;
Gtk.TreeView tree = new Gtk.TreeView();
cell = new Gtk.CellRendererText();
col = new Gtk.TreeViewColumn();
col.Title = "Column 1";
col.PackStart(cell, true);
col.AddAttribute(cell, "text", 0);
col.SortColumnId = 0;
tree.AppendColumn(col);
cell = new Gtk.CellRendererText();
col = new Gtk.TreeViewColumn();
col.Title = "Column 2";
col.PackStart(cell, true);
col.AddAttribute(cell, "text", 1);
tree.AppendColumn(col);
Gtk.TreeStore store = new Gtk.TreeStore(typeof(string), typeof(string));
iter = store.AppendValues("BBB");
store.AppendValues(iter, "AAA", "Zzz");
store.AppendValues(iter, "DDD", "Ttt");
store.AppendValues(iter, "CCC", "Ggg");
iter = store.AppendValues("AAA");
store.AppendValues(iter, "ZZZ", "Zzz");
store.AppendValues(iter, "GGG", "Ggg");
store.AppendValues(iter, "TTT", "Ttt");
Gtk.TreeModelSort sortable = new Gtk.TreeModelSort(store);
sortable.SetSortFunc(0, delegate(TreeModel model, TreeIter a, TreeIter b) {
string s1 = (string)model.GetValue(a, 0);
string s2 = (string)model.GetValue(b, 0);
return(String.Compare(s1, s2));
});
tree.Model = sortable;
window.Add(tree);
return(window);
}
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);
}
}
}
public DeleteGroupsWidget(System.Collections.Generic.List <LdapGroup> list)
{
this.Build();
group_list = list;
groupListTreeview.Selection.Mode = Gtk.SelectionMode.None;
userListTreeview.Selection.Mode = Gtk.SelectionMode.None;
System.Collections.Generic.List <LdapUser> ulist = llum.Core.getCore().xmlrpc.get_user_list();
user_list = new System.Collections.Generic.List <LdapUser>();
foreach (LdapUser user in ulist)
{
foreach (LdapGroup grp in group_list)
{
if (grp.member_list.Contains(user.uid) && !user_list.Contains(user) && user.main_group != "admin")
{
user_list.Add(user);
}
}
}
Gtk.TreeViewColumn grp_id_column;
Gtk.CellRendererText grp_id_cell;
Gtk.TreeViewColumn grp_description_column;
Gtk.CellRendererText grp_description_cell;
Gtk.TreeStore group_store;
grp_id_column = new Gtk.TreeViewColumn();
grp_id_column.Title = Mono.Unix.Catalog.GetString("Group ID");
grp_id_cell = new Gtk.CellRendererText();
grp_id_column.PackStart(grp_id_cell, true);
grp_id_column.AddAttribute(grp_id_cell, "text", 0);
groupListTreeview.AppendColumn(grp_id_column);
grp_description_column = new Gtk.TreeViewColumn();
grp_description_column.Title = Mono.Unix.Catalog.GetString("Description");
grp_description_cell = new Gtk.CellRendererText();
grp_description_column.PackStart(grp_description_cell, true);
grp_description_column.AddAttribute(grp_description_cell, "text", 1);
groupListTreeview.AppendColumn(grp_description_column);
group_store = new Gtk.TreeStore(typeof(string), typeof(string));
groupListTreeview.Model = group_store;
foreach (LdapGroup grp in group_list)
{
group_store.AppendValues(grp.gid, grp.description);
}
Gtk.TreeViewColumn user_id_column;
Gtk.CellRendererText user_id_cell_renderer;
Gtk.TreeViewColumn user_name_column;
Gtk.CellRendererText user_name_cell_renderer;
Gtk.TreeViewColumn user_surname_column;
Gtk.CellRendererText user_surname_cell_renderer;
Gtk.ListStore store;
user_id_column = new Gtk.TreeViewColumn();
user_id_column.Title = Mono.Unix.Catalog.GetString("User ID");
user_id_cell_renderer = new Gtk.CellRendererText();
user_id_column.PackStart(user_id_cell_renderer, true);
user_id_column.AddAttribute(user_id_cell_renderer, "text", 0);
userListTreeview.AppendColumn(user_id_column);
store = new Gtk.ListStore(typeof(string), typeof(string), typeof(string));
userListTreeview.Model = store;
user_name_column = new Gtk.TreeViewColumn();
user_name_column.Title = Mono.Unix.Catalog.GetString("Name");
user_name_cell_renderer = new Gtk.CellRendererText();
user_name_column.PackStart(user_name_cell_renderer, true);
user_name_column.AddAttribute(user_name_cell_renderer, "text", 1);
userListTreeview.AppendColumn(user_name_column);
user_surname_column = new Gtk.TreeViewColumn();
user_surname_column.Title = Mono.Unix.Catalog.GetString("Surname");
user_surname_cell_renderer = new Gtk.CellRendererText();
user_surname_column.PackEnd(user_surname_cell_renderer, true);
user_surname_column.AddAttribute(user_surname_cell_renderer, "text", 2);
userListTreeview.AppendColumn(user_surname_column);
foreach (LdapUser user in user_list)
{
store.AppendValues(user.uid, user.name, user.surname);
}
userListTreeview.ShowAll();
}
