/// <summary>
/// Use a list of modifications to update Gtk.TreeStore
/// </summary>
public static void Update(RemoteTreeStore remoteStore, Gtk.TreeStore gtkStore)
{
RemoteTreeModification[] modifications = remoteStore.GetModifications();
if (modifications.Length > 0) {
Console.WriteLine(String.Format("Received {0} modifications from {1}", modifications.Length, remoteStore));
}
foreach(RemoteTreeModification mod in modifications) {
Console.WriteLine(mod);
if (mod is RemoteTreeModification.InsertNode) {
RemoteTreeModification.InsertNode insertMod = (RemoteTreeModification.InsertNode)mod;
if (insertMod.ParentNodePath.Indices.Length == 0) {
// Insert to the top level
gtkStore.InsertNode(insertMod.NodeIndex);
} else {
TreeIter it;
gtkStore.GetIter(out it, new TreePath(insertMod.ParentNodePath.Indices));
gtkStore.InsertNode(it, insertMod.NodeIndex);
}
}
if (mod is RemoteTreeModification.RemoveNode) {
RemoteTreeModification.RemoveNode removeMod = (RemoteTreeModification.RemoveNode)mod;
TreeIter it;
gtkStore.GetIter(out it, new TreePath(removeMod.NodePath.Indices));
gtkStore.Remove(ref it);
}
if (mod is RemoteTreeModification.UpdateNode) {
RemoteTreeModification.UpdateNode updateMod = (RemoteTreeModification.UpdateNode)mod;
// Igonre the root node
if (updateMod.NodePath.IsRoot) {
continue;
}
TreeIter it;
gtkStore.GetIter(out it, new TreePath(updateMod.NodePath.Indices));
object value = updateMod.Value;
// If it is image, dereference it
if (value is PixmapRef) {
value = ((PixmapRef)value).GetPixbuf();
}
gtkStore.SetValue(it, updateMod.ColumnIndex, value);
}
}
}
protected Gtk.TreeIter SetRowValue(Gtk.TreeStore store, Gtk.TreeIter parent,
int childIndx, params object[] values)
{
Gtk.TreeIter child;
if (store.IterNthChild(out child, parent, childIndx))
{
for (int i=0; i < values.Length; i++)
{
if (null == values[i]) continue;
store.SetValue(child, i, values[i]);
}
}
else
child = store.AppendValues (parent, values);
return child;
}
/// <summary>
/// This function handles the icons and colors in list
/// </summary>
/// <param name="column"></param>
/// <param name="cell"></param>
/// <param name="model"></param>
/// <param name="iter"></param>
private void UserListRendererTool(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
{
try
{
ItemType type = (ItemType)model.GetValue(iter, 2);
Window window = null;
switch (type)
{
case ItemType.Server:
Network nw = (Network)model.GetValue(iter, 1);
if (nw == null)
{
Core.DebugLog("UserListRendererTool(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter): NULL network");
return;
}
if (nw.IsDestroyed)
{
Values.Remove(ref iter);
return;
}
string info = null;
if (nw.IrcdVersion != null)
{
info = "IRCD version " + nw.IrcdVersion;
}
string nwinfo = (string)model.GetValue(iter, 4);
if (nwinfo != info && info != null)
{
model.SetValue(iter, 4, info);
}
if (nw != null && !nw.IsDestroyed && nw.SystemWindow != null)
{
(cell as Gtk.CellRendererText).ForegroundGdk = Core.FromColor(nw.SystemWindow.MenuColor);
if (nw.SystemWindow.needIcon)
{
nw.SystemWindow.needIcon = false;
if (nw.IsConnected)
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ExclamationMark);
}
else
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ShadowMark);
}
}
}
break;
case ItemType.User:
User user = (User)model.GetValue(iter, 1);
if (user == null)
{
Core.DebugLog("UserListRendererTool(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter): NULL user");
return;
}
if (user.IsDestroyed)
{
Values.Remove(ref iter);
}
lock (user._Network.PrivateWins)
{
if (user._Network.PrivateWins.ContainsKey(user))
{
window = user._Network.PrivateWins[user];
}
}
if (window != null && !window.IsDestroyed)
{
(cell as Gtk.CellRendererText).ForegroundGdk = Core.FromColor(window.MenuColor);
if (window.needIcon)
{
window.needIcon = false;
if (user._Network == null || !user._Network.IsConnected)
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ShadowAt);
}
else
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_At);
}
}
}
break;
case ItemType.DCC:
ProtocolDCC dc = (ProtocolDCC)model.GetValue(iter, 1);
if (dc == null)
{
Core.DebugLog("UserListRendererTool(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter): NULL dc");
return;
}
if (dc.IsDestroyed)
{
Values.Remove(ref iter);
}
if (dc.SystemWindow.needIcon)
{
dc.SystemWindow.needIcon = false;
if (dc.IsConnected)
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ExclamationMark);
}
else
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ShadowMark);
}
}
break;
case ItemType.Channel:
Channel channel = (Channel)model.GetValue(iter, 1);
if (channel == null)
{
Core.DebugLog("UserListRendererTool(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter): NULL channel");
return;
}
if (channel.IsDestroyed)
{
Values.Remove(ref iter);
}
string data = (string)model.GetValue(iter, 4);
if (data != channel.MenuData)
{
model.SetValue(iter, 4, channel.MenuData);
}
window = channel.RetrieveWindow();
if (window != null)
{
(cell as Gtk.CellRendererText).ForegroundGdk = Core.FromColor(window.MenuColor);
if (window.needIcon)
{
window.needIcon = false;
if (!channel.IsAlive)
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_ShadowHash);
}
else
{
model.SetValue(iter, 5, Configuration.CurrentSkin.Icon_Hash);
}
}
}
break;
case ItemType.Services:
(cell as Gtk.CellRendererText).ForegroundGdk = Core.FromColor(Configuration.CurrentSkin.ColorDefault);
break;
}
}
catch (Exception fail)
{
Core.handleException(fail);
}
}
public static void SetModelValue(Gtk.TreeModel store, Gtk.TreeIter it, int column, Type type, object value)
{
if (type == typeof(ObjectWrapper) && value != null)
store.SetValue (it, column, new ObjectWrapper (value));
else if (value is string)
store.SetValue (it, column, (string)value);
else
store.SetValue (it, column, value ?? DBNull.Value);
}
public static Gtk.CellRenderer CreateCellRenderer(ApplicationContext actx, ICellRendererTarget col, object target, CellView view, Gtk.TreeModel model)
{
if (view is TextCellView) {
Gtk.CellRendererText cr = new Gtk.CellRendererText ();
if (((TextCellView)view).Editable) {
cr.Editable = true;
cr.Edited += (o, args) => {
Gtk.TreeIter iter;
if (model.GetIterFromString (out iter, args.Path))
model.SetValue (iter, ((TextCellView)view).TextField.Index, args.NewText);
};
}
col.PackStart (target, cr, false);
col.AddAttribute (target, cr, "text", ((TextCellView)view).TextField.Index);
return cr;
}
else if (view is CheckBoxCellView) {
Gtk.CellRendererToggle cr = new Gtk.CellRendererToggle ();
col.PackStart (target, cr, false);
col.AddAttribute (target, cr, "active", ((CheckBoxCellView)view).ActiveField.Index);
return cr;
}
else if (view is ImageCellView) {
CellRendererImage cr = new CellRendererImage (actx);
col.PackStart (target, cr, false);
col.AddAttribute (target, cr, "image", ((ImageCellView)view).ImageField.Index);
return cr;
}
else if (view is CanvasCellView) {
var canvas = (CanvasCellView) view;
var cr = new CustomCellRenderer (canvas);
col.PackStart (target, cr, false);
col.SetCellDataFunc (target, cr, delegate (CellLayout cell_layout, CellRenderer cell, TreeModel tree_model, TreeIter iter) {
cr.LoadData (cell_layout, cell, tree_model, iter);
((CanvasCellView) view).Initialize (cr);
});
return cr;
}
throw new NotSupportedException ("Unknown cell view type: " + view.GetType ());
}
private void AddTagToStore(Tag tag, Gtk.ListStore tagStore)
{
if(tag.TreeIter.Equals (Gtk.TreeIter.Zero)) {
tag.TreeIter = tagStore.AppendValues(tag.Name, tag.Count);
Debug.Assert(!tag.TreeIter.Equals(Gtk.TreeIter.Zero));
} else {
tagStore.SetValue(tag.TreeIter, (int)TagCols.Count, tag.Count);
}
}
private void AddNoteToStore(Note note, Gtk.ListStore notesStore)
{
if (note.TreeIter.Equals (Gtk.TreeIter.Zero)) {
note.TreeIter = notesStore.AppendValues (note.Title, note);
Debug.Assert(!note.TreeIter.Equals(Gtk.TreeIter.Zero));
} else {
notesStore.SetValue(note.TreeIter, (int)NoteCols.Title, note.Title);
}
}
