private static int CompareDateTime(ITreeModel model, TreeIter lhs, TreeIter rhs)
{
var l = (DateTime)model.GetValue(lhs, 1);
var r = (DateTime)model.GetValue(rhs, 1);
return(DateTime.Compare(l, r));
}
public static void CellDataHandler(ICellLayout layout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
SourceRowRenderer renderer = cell as SourceRowRenderer;
if (renderer == null)
{
return;
}
var type = model.GetValue(iter, (int)SourceModel.Columns.Type);
if (type == null || (SourceModel.EntryType)type != SourceModel.EntryType.Source)
{
renderer.Visible = false;
return;
}
Source source = model.GetValue(iter, 0) as Source;
renderer.Source = source;
renderer.Iter = iter;
if (source == null)
{
return;
}
renderer.Visible = true;
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}
private static int FileSizeSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 8).ToString();
string bValue = model.GetValue(b, 8).ToString();
if (aValue.Substring(aValue.Length - 2) == "GB")
{
aValue = (float.Parse(aValue[0..^ 2]) * 1024).ToString();
public static int TimePlayedSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 5).ToString();
string bValue = model.GetValue(b, 5).ToString();
if (aValue.Length > 4 && aValue[^ 4..] == "mins")
{
aValue = (float.Parse(aValue[0..^ 5]) * 60).ToString();
/// <summary>
/// Sorts the game explorer row.
/// </summary>
/// <returns>The sorting priority of the row. This value can be -1, 0 or 1 if
/// A sorts before B, A sorts with B or A sorts after B, respectively.</returns>
/// <param name="model">Model.</param>
/// <param name="a">Iter a.</param>
/// <param name="b">Iter b.</param>
private int SortGameTreeRow(ITreeModel model, TreeIter a, TreeIter b)
{
const int sortABeforeB = -1;
const int sortAWithB = 0;
const int sortAAfterB = 1;
var nodeA = (SerializedNode)model.GetValue(a, 0);
var nodeB = (SerializedNode)model.GetValue(b, 0);
var typeofA = nodeA.Type;
var typeofB = nodeB.Type;
// Special case for meta nodes - if A is a meta node, but B is not
if (typeofA.HasFlag(NodeType.Meta) && !typeofB.HasFlag(NodeType.Meta))
{
// Then it should always sort after B
return(sortAAfterB);
}
if (typeofB.HasFlag(NodeType.Meta) && !typeofA.HasFlag(NodeType.Meta))
{
// Then it should always sort before B
return(sortABeforeB);
}
if (typeofA < typeofB)
{
return(sortAAfterB);
}
if (typeofA > typeofB)
{
return(sortABeforeB);
}
var nodeAName = _treeModel.GetNodeName(nodeA);
var nodeBName = _treeModel.GetNodeName(nodeB);
var result = string.CompareOrdinal(nodeAName, nodeBName);
if (result <= sortABeforeB)
{
return(sortAAfterB);
}
if (result >= sortAAfterB)
{
return(sortABeforeB);
}
return(sortAWithB);
}
private static int TimePlayedSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 5).ToString();
string bValue = model.GetValue(b, 5).ToString();
if (aValue.Length > 4 && aValue.Substring(aValue.Length - 4) == "mins")
{
aValue = (float.Parse(aValue.Substring(0, aValue.Length - 5)) * 60).ToString();
}
else if (aValue.Length > 3 && aValue.Substring(aValue.Length - 3) == "hrs")
{
aValue = (float.Parse(aValue.Substring(0, aValue.Length - 4)) * 3600).ToString();
}
else if (aValue.Length > 4 && aValue.Substring(aValue.Length - 4) == "days")
{
aValue = (float.Parse(aValue.Substring(0, aValue.Length - 5)) * 86400).ToString();
}
else
{
aValue = aValue.Substring(0, aValue.Length - 1);
}
if (bValue.Length > 4 && bValue.Substring(bValue.Length - 4) == "mins")
{
bValue = (float.Parse(bValue.Substring(0, bValue.Length - 5)) * 60).ToString();
}
else if (bValue.Length > 3 && bValue.Substring(bValue.Length - 3) == "hrs")
{
bValue = (float.Parse(bValue.Substring(0, bValue.Length - 4)) * 3600).ToString();
}
else if (bValue.Length > 4 && bValue.Substring(bValue.Length - 4) == "days")
{
bValue = (float.Parse(bValue.Substring(0, bValue.Length - 5)) * 86400).ToString();
}
else
{
bValue = bValue.Substring(0, bValue.Length - 1);
}
if (float.Parse(aValue) > float.Parse(bValue))
{
return(-1);
}
else if (float.Parse(bValue) > float.Parse(aValue))
{
return(1);
}
else
{
return(0);
}
}
bool TasksTreeFilterFunc(ITreeModel model, TreeIter iter)
{
var task = model.GetValue(iter, 0) as Task;
if (task == null)
{
return(true);
}
bool ok = !task.IsDone || showDoneCheckButton.Active;
if (currentFilterFunc != null)
{
ok &= currentFilterFunc(task);
}
string searchText = searchTaskEntry.Text;
if (!string.IsNullOrEmpty(searchText))
{
ok &= task.Description.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0 ||
task.Title.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0;
}
return(ok);
}
private void RenderTaskItemCategory(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var item = (Activity)model.GetValue(iter, 0);
if (!(cell is CellRendererText value))
{
return;
}
if (new Guid(item.Category) == Guid.Empty)
{
value.Text = "None";
}
else
{
_categoryStore.Foreach(delegate(ITreeModel categoryModel, TreePath path, TreeIter categoryIter)
{
var categoryItem = (Category)categoryModel.GetValue(categoryIter, 0);
if (categoryItem.Id == item.Category)
{
value.Text = categoryItem.CategoryName;
return(true);
}
value.Text = "None";
return(false);
});
}
}
private static void RenderTaskItemFinish(TreeViewColumn column, CellRenderer cell, ITreeModel model,
TreeIter iter)
{
var item = (Activity)model.GetValue(iter, 0);
if (!(cell is CellRendererText value))
{
return;
}
if (item.DueDate.Date != DateTime.MinValue.Date)
{
var render = item.DueDate;
var current = DateTime.Now;
if (render < current)
{
value.Text = "Overdue since " + CheckDate(render);
}
else
{
value.Text = CheckDate(render);
}
}
else
{
value.Text = "Not set";
}
}
/// <summary>
/// Renders the name of a model variation in the variation dropdown.
/// </summary>
/// <param name="cellLayout">The layout of the cell.</param>
/// <param name="cell">The cell.</param>
/// <param name="model">The model of the combobox.</param>
/// <param name="iter">The iter pointing to the rendered row.</param>
public static void RenderModelVariationName(ICellLayout cellLayout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
CellRendererText cellText = cell as CellRendererText;
if (cellText == null)
{
return;
}
string storedText = (string)model.GetValue(iter, 0);
// Builtin override for the standard set name
if (storedText.ToLowerInvariant().Contains("set_$defaultglobal"))
{
cellText.Text = "Default";
return;
}
string transientText = storedText.FastReplaceCaseInsensitive("set_", string.Empty);
// Insert spaces between words and abbreviations
transientText = Regex.Replace(transientText, @"(\B[A-Z0-9]+?(?=[A-Z][^A-Z])|\B[A-Z0-9]+?(?=[^A-Z]))", " $1");
cellText.Text = transientText;
}
/// <summary>
/// This function is used internally by the tree filter to determine which rows are visible and which are not.
/// </summary>
/// <param name="model">The model of the tree.</param>
/// <param name="iter">The iter to determine visibility for.</param>
/// <returns>true if the iter should be visible; false otherwise.</returns>
private bool TreeModelVisibilityFunc(ITreeModel model, TreeIter iter)
{
if (!_isFiltered)
{
return(true);
}
var node = (SerializedNode)model.GetValue(iter, 0);
var nodeTypes = node.FileType;
if (!this.ShouldDisplayUnknownFiles)
{
// If the node is strictly an unknown file, don't display it.
if (nodeTypes == WarcraftFileType.Unknown)
{
return(false);
}
}
// If the file types of the node and the filtered types overlap in any way, then it should
// be displayed.
if ((nodeTypes & _filteredFileTypes) != 0)
{
return(true);
}
return(false);
}
private void RenderCombo(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
Options temp = (Options)model.GetValue(iter, 0);
cell.Visible = temp.ValueType == ValueType.ComboBox;
if (cell.Visible)
{
CellRendererCombo combo = (CellRendererCombo)cell;
ListStore t = new ListStore(typeof(string));
int length = temp.ComboBoxValues.Count;
for (int i = 0; i < length; i++)
{
t.AppendValues(temp.ComboBoxValues[i]);
}
combo.Model = t;
if (temp.Value == null)
{
combo.Text = (string)temp.DefaultValue;
}
else
{
combo.Text = temp.Value;
}
}
}
private static int LastPlayedSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 6).ToString();
string bValue = model.GetValue(b, 6).ToString();
if (aValue == "Never")
{
aValue = DateTime.UnixEpoch.ToString();
}
if (bValue == "Never")
{
bValue = DateTime.UnixEpoch.ToString();
}
return(DateTime.Compare(DateTime.Parse(bValue), DateTime.Parse(aValue)));
}
private static void SetDateTimeRendererText(
TreeViewColumn column, CellRenderer renderer, ITreeModel model, TreeIter iter)
{
var dateTime = (DateTime)model.GetValue(iter, 1);
var textRenderer = (CellRendererText)renderer;
textRenderer.Text = dateTime.ToString();
}
private static void RenderTaskItemName(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var item = (Activity)model.GetValue(iter, 0);
if (cell is CellRendererText value)
{
value.Text = item.Name;
}
}
private static void Func(ICellLayout cellLayout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var item = (Category)model.GetValue(iter, 0);
if (cell is CellRendererText value)
{
value.Text = item.CategoryName;
}
}
public static int PrioritySortFunc(ITreeModel model, TreeIter a, TreeIter b)
{
try
{
string val1 = (string)model.GetValue(a, 3);
string val2 = (string)model.GetValue(b, 3);
if (val1 == "" || val2 == "")
{
return(1);
}
return(String.CompareOrdinal(val1, val2));
}
catch (NullReferenceException e)
{
return(0);
}
}
private static void RenderCategoryToggle(TreeViewColumn treeColumn, CellRenderer cell, ITreeModel model,
TreeIter iter)
{
var item = (Category)model.GetValue(iter, 0);
if (cell is CellRendererToggle value)
{
value.Active = item.CategoryActive;
}
}
private static void RenderCategoryName(TreeViewColumn treeColumn, CellRenderer cell, ITreeModel model,
TreeIter iter)
{
var item = (Category)model.GetValue(iter, 0);
if (cell is CellRendererText value)
{
value.Text = item.CategoryName;
}
}
private static void RenderTaskItemStart(TreeViewColumn column, CellRenderer cell, ITreeModel model,
TreeIter iter)
{
var item = (Activity)model.GetValue(iter, 0);
if (!(cell is CellRendererText value))
{
return;
}
value.Text = item.StartDate.Date != DateTime.MinValue.Date ? CheckDate(item.StartDate) : "Not set";
}
private bool FilterPackets(ITreeModel model, TreeIter iter)
{
var pkt = new Value();
model.GetValue(iter, 0, ref pkt);
var packet = (PacketInfo)pkt.Val;
return(packet == null ||
(_filterTargetNetId == 0 || packet.NetId == _filterTargetNetId) &&
_packetTypeFilter[packet.msgType]);
}
public static int StartTimeSortFunc(ITreeModel model, TreeIter a, TreeIter b)
{
try
{
string val1 = model.GetValue(a, 9).ToString();
string val2 = model.GetValue(b, 9).ToString();
if (val1 == "" || val2 == "")
{
return(1);
}
long s1 = Convert.ToInt64(val1, CultureInfo.InvariantCulture);
long s2 = Convert.ToInt64(val2, CultureInfo.InvariantCulture);
return(s1.CompareTo(s2));
}
catch (NullReferenceException e)
{
return(0);
}
}
public static int CpuUsageSortFunc(ITreeModel model, TreeIter a, TreeIter b)
{
try
{
string val1 = model.GetValue(a, 7).ToString();
string val2 = model.GetValue(b, 7).ToString();
if (val1 == "" || val2 == "")
{
return(1);
}
double s1 = Convert.ToDouble(val1, CultureInfo.InvariantCulture);
double s2 = Convert.ToDouble(val2, CultureInfo.InvariantCulture);
return(s1.CompareTo(s2));
}
catch (NullReferenceException e)
{
return(0);
}
}
/// <summary>
/// Renders the name of a file reference in the export queue.
/// </summary>
/// <param name="column">The column which the cell is in.</param>
/// <param name="cell">The cell which the reference is in.</param>
/// <param name="model">The model of the treeview.</param>
/// <param name="iter">The <see cref="TreeIter"/> pointing to the row the reference is in.</param>
public static void RenderExportQueueReferenceName(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
CellRendererText cellText = cell as CellRendererText;
FileReference reference = (FileReference)model.GetValue(iter, 0);
if (reference == null || cellText == null)
{
return;
}
cellText.Text = reference.FilePath.Replace('\\', Path.DirectorySeparatorChar);
}
void RenderCell(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var textCell = (cell as CellRendererText);
Debug.Assert(cell != null);
var task = (Task)model.GetValue(iter, 0);
System.Action ResetColors = () => textCell.Background = "white";
textCell.Strikethrough = task.IsDone;
if (task.IsDone || !task.Deadline.HasValue)
{
ResetColors();
}
else
{
var now = DateTime.Now.Date;
var threshold = task.Deadline.Value.AddDays(-1);
if (now > task.Deadline.Value)
{
textCell.Background = "red";
}
else if (now > threshold)
{
textCell.Background = "lightgreen";
}
else
{
ResetColors();
}
}
int columnNr = Array.IndexOf(tasksTreeView.Columns, column) + 1; // first column is not visible
textCell.Text = (string)model.GetValue(iter, columnNr);
tasksTreeView.QueueDraw();
}
private void RenderEditableText(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, ITreeModel model, Gtk.TreeIter iter)
{
Options temp = (Options)model.GetValue(iter, 0);
cell.Visible = temp.ValueType == ValueType.One || temp.ValueType == ValueType.OneOrEmpty;
if (cell.Visible)
{
if (temp.Value != null)
{
(cell as CellRendererText).Text = temp.Value;
}
}
}
private void RenderText(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, ITreeModel model, Gtk.TreeIter iter)
{
Options temp = (Options)model.GetValue(iter, 0);
if (temp != null)
{
(cell as Gtk.CellRendererText).Text = temp.Name;
if (temp.AdditionalInfo != null)
{
(cell as Gtk.CellRendererText).Text += temp.AdditionalInfo;
}
}
}
private void PacketsCellDataFunc(TreeViewColumn treeColumn, CellRenderer cell, ITreeModel treeModel,
TreeIter iter)
{
var pkt = new Value();
treeModel.GetValue(iter, 0, ref pkt);
var packet = (PacketInfo)pkt.Val;
var val = new Value(GType.String)
{
Val = packet.Error != null ? "#8B0000" : "#000000"
};
cell.SetProperty("foreground", val);
}
private bool FilterTree(ITreeModel model, TreeIter iter)
{
string username = model.GetValue(iter, 0).ToString();
/*if (filterEntry.Text == "")
* return true;
*
* if (artistName.IndexOf(filterEntry.Text) > -1)
* return true;
* else
* return false;*/
return(true);
}
public static List <T> GetListStoreValues <T>(ITreeModel model, int dataIndex)
{
var list = new List <T>();
if (!model.GetIterFirst(out TreeIter iter))
{
return(list);
}
do
{
list.Add((T)model.GetValue(iter, dataIndex));
}while (model.IterNext(ref iter));
return(list);
}
private bool IsRowSeparator (ITreeModel model, TreeIter iter)
{
return String.IsNullOrEmpty (model.GetValue (iter, 0) as string);
}
bool TasksTreeFilterFunc(ITreeModel model, TreeIter iter)
{
var task = model.GetValue (iter, 0) as Task;
if (task == null) {
return true;
}
bool ok = !task.IsDone || showDoneCheckButton.Active;
if (currentFilterFunc != null)
ok &= currentFilterFunc (task);
string searchText = searchTaskEntry.Text;
if (!string.IsNullOrEmpty (searchText)) {
ok &= task.Description.IndexOf (searchText, StringComparison.OrdinalIgnoreCase) >= 0 ||
task.Title.IndexOf (searchText, StringComparison.OrdinalIgnoreCase) >= 0;
}
return ok;
}
void RenderCell(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var textCell = (cell as CellRendererText);
Debug.Assert (cell != null);
var task = (Task)model.GetValue (iter, 0);
System.Action ResetColors = () => textCell.Background = "white";
textCell.Strikethrough = task.IsDone;
if (task.IsDone || !task.Deadline.HasValue) {
ResetColors ();
} else {
var now = DateTime.Now.Date;
var threshold = task.Deadline.Value.AddDays (-1);
if (now > task.Deadline.Value) {
textCell.Background = "red";
} else if (now > threshold) {
textCell.Background = "lightgreen";
} else {
ResetColors ();
}
}
int columnNr = Array.IndexOf (tasksTreeView.Columns, column) + 1; // first column is not visible
textCell.Text = (string) model.GetValue (iter, columnNr);
tasksTreeView.QueueDraw ();
}
static TreeIter FindTask(Task task, ITreeModel model)
{
TreeIter iter;
model.GetIterFirst (out iter);
if (iter.Equals (TreeIter.Zero)) {
return TreeIter.Zero;
}
do {
if (model.GetValue (iter, 0) == task) {
return iter;
}
} while (model.IterNext (ref iter));
return TreeIter.Zero;
}
private bool RowSeparatorFunc(ITreeModel model, TreeIter iter)
{
return (bool)model.GetValue (iter, 2);
}
private void RenderServiceColumn (TreeViewColumn column, CellRenderer cell,
ITreeModel model, TreeIter iter)
{
string markup = (string) model.GetValue (iter, 2);
TreeSelection selection = (column.TreeView as TreeView).Selection;
if (selection.IterIsSelected (iter))
markup = markup.Replace (Program.UI.SecondaryTextColor, Program.UI.SecondaryTextColorSelected);
else
markup = markup.Replace (Program.UI.SecondaryTextColorSelected, Program.UI.SecondaryTextColor);
(cell as CellRendererText).Markup = markup;
}
public static void CellDataHandler(ICellLayout layout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
SourceRowRenderer renderer = cell as SourceRowRenderer;
if (renderer == null) {
return;
}
var type = model.GetValue (iter, (int)SourceModel.Columns.Type);
if (type == null || (SourceModel.EntryType) type != SourceModel.EntryType.Source) {
renderer.Visible = false;
return;
}
Source source = model.GetValue (iter, 0) as Source;
renderer.Source = source;
renderer.Iter = iter;
if (source == null) {
return;
}
renderer.Visible = true;
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}