public static void CellDataHandler (CellLayout layout, CellRenderer cell, TreeModel 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;
}
/// <summary>
/// Fill a list of events from a list of paths, if the first and unique path is an EventType the list
/// is filled with al the child events in this EventType category.
/// </summary>
/// <param name = "model">Model.</param>
/// <param name="events">Events.</param>
/// <param name="paths">Paths.</param>
public static List<TimelineEventLongoMatch> EventsListFromPaths(TreeModel model, TreePath[] paths)
{
List<TimelineEventLongoMatch> events = new List<TimelineEventLongoMatch> ();
// If it's an EventType or a Player, traverse all children to fill the list
if (paths.Length == 1 && !(model.GetValue (paths [0]) is TimelineEventLongoMatch)) {
TreeIter parentIter;
TreeIter child;
bool hasChild;
model.GetIter (out parentIter, paths [0]);
hasChild = model.IterHasChild (parentIter);
model.IterChildren (out child, parentIter);
while (hasChild) {
TimelineEventLongoMatch evt = model.GetValue (child, 0) as TimelineEventLongoMatch;
if (evt != null) {
events.Add (evt);
}
hasChild = model.IterNext (ref child);
}
} else {
foreach (var path in paths) {
TimelineEventLongoMatch evt = model.GetValue (path) as TimelineEventLongoMatch;
if (evt != null) {
events.Add (evt);
}
}
}
return events;
}
static int CompareTagsSortFunc (TreeModel model, TreeIter a, TreeIter b)
{
Tag tag_a = model.GetValue (a, 0) as Tag;
Tag tag_b = model.GetValue (b, 0) as Tag;
if (tag_a == null || tag_b == null)
return 0;
return string.Compare (tag_a.NormalizedName, tag_b.NormalizedName);
}
public static void ProfileNameDataFunc (CellLayout layout, CellRenderer renderer, TreeModel model, TreeIter iter)
{
if (model.GetValue (iter, 0) != null) {
Cms.Profile profile = (Cms.Profile) model.GetValue (iter, 0);
if (profile.ProductName.Length < NameLenth)
(renderer as Gtk.CellRendererText).Text = profile.ProductName;
else
(renderer as Gtk.CellRendererText).Text = profile.ProductName.Substring(0, NameLenth) + "...";
}
else
(renderer as Gtk.CellRendererText).Text = "";
}
private bool GetActionByAccel(TreeModel model, TreePath path, TreeIter iter, uint accelKey, Gdk.ModifierType accelMods)
{
var rowAccelKey = (uint)model.GetValue(iter, (int)Column.AccelKey);
var rowAccelMods = (Gdk.ModifierType)model.GetValue(iter, (int)Column.AccelMods);
if (rowAccelKey == accelKey && rowAccelMods == accelMods)
{
this.actionConflict = (string)model.GetValue(iter, (int)Column.Action);
return true;
}
return false;
}
private void OnPixbufCellLayout(CellLayout layout, CellRenderer cell,
TreeModel model, TreeIter iter)
{
CellRendererPixbuf pixbufCell = (cell as CellRendererPixbuf);
IVirtualDevice device = (IVirtualDevice) model.GetValue (iter, 0);
switch (device.DeviceType) {
case VirtualDeviceType.HardDisk:
pixbufCell.Pixbuf = hdPixbuf;
break;
case VirtualDeviceType.CdRom:
pixbufCell.Pixbuf = cdromPixbuf;
break;
case VirtualDeviceType.Ethernet:
pixbufCell.Pixbuf = ethernetPixbuf;
break;
case VirtualDeviceType.Floppy:
pixbufCell.Pixbuf = floppyPixbuf;
break;
default:
pixbufCell.Pixbuf = null;
break;
}
}
protected override bool OnMatchSelected (TreeModel filter, TreeIter iter){
Entry entry = (Entry)Entry;
entry.Text = ((ItemTag)filter.GetValue(iter,0)).Name;
entry.FinishEditing();
entry.RemoveWidget();
return true;
}
protected override bool OnMatchSelected (TreeModel filter, TreeIter iter){
Location.Item = (Model.Item)filter.GetValue(iter,0);
Entry entry = (Entry)Entry;
entry.FinishEditing();
entry.RemoveWidget();
return true;
}
/// <summary>
/// Override the default filter mechanism so that we show only
/// completed tasks in this group.
/// </summary>
/// <param name="model">
/// A <see cref="TreeModel"/>
/// </param>
/// <param name="iter">
/// A <see cref="TreeIter"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
protected override bool FilterTasks(TreeModel model, TreeIter iter)
{
// Don't show any task here if showCompletedTasks is false
if (!showCompletedTasks)
return false;
ITask task = model.GetValue (iter, 0) as ITask;
if (task == null || task.State != TaskState.Completed)
return false;
// Make sure that the task fits into the specified range depending
// on what the user has set the range slider to be.
if (task.CompletionDate < this.timeRangeStart)
return false;
if (task.CompletionDate == DateTime.MinValue)
return true; // Just in case
// Don't show tasks in the completed group that were completed
// today. Tasks completed today should still appear under their
// original group until tomorrow.
DateTime today = DateTime.Now;
if (today.Year == task.CompletionDate.Year
&& today.DayOfYear == task.CompletionDate.DayOfYear)
return false;
return true;
}
private void AlbumCellDataFunc(TreeViewColumn column,
CellRenderer renderer,
TreeModel model,
TreeIter iter)
{
MusicStoreTrackInfo track = (MusicStoreTrackInfo) model.GetValue (iter, 0);
((CellRendererText)renderer).Text = track.Album;
}
static void ImageDataFunc (TreeViewColumn tree_column, CellRenderer cell, TreeModel tree_model, TreeIter iter)
{
var isError = (bool)tree_model.GetValue (iter, 2);
var crpixbuf = (CellRendererPixbuf)cell;
crpixbuf.Visible = isError;
crpixbuf.Pixbuf = isError ? errorPixbuf.Value : null;
}
private void ContentDataFunc (CellLayout layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
object dataObject = model.GetValue (iter, columnIndex);
if (dataObject == null)
nullRenderer.SetContent (cell as CellRendererText, dataObject);
else
contentRenderer.SetContent (cell as CellRendererText, dataObject);
}
public static void RenderCoverage (TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
var txt = cell as CellRendererText;
CodeRecord rc = (CodeRecord)model.GetValue (iter, 0);
if (txt != null) {
txt.Foreground = CellColor (rc.Coverage);
txt.Text = String.Format ("{0:00.0}%", rc.Coverage * 100.0);
}
}
private void RenderFont (CellLayout layout, CellRenderer renderer, TreeModel model, TreeIter iter)
{
string fontName = (string)model.GetValue (iter, 0);
CellRendererText cell = renderer as CellRendererText;
cell.Text = fontName;
cell.Font = string.Format ("{0} 10", fontName);
cell.Family = fontName;
}
bool CheckForText (TreeModel model, TreeIter iter, bool exact)
{
string modelText = model.GetValue (iter, Column) as string;
if (modelText == null) {
return false;
}
if (exact) {
return modelText == DesiredText;
} else {
return (modelText.IndexOf (DesiredText) > -1);
}
}
private void RenderValue(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
WorkspaceUnit workspaceUnit = (WorkspaceUnit)model.GetValue(iter, 2);
CellRendererText renderer = (CellRendererText)cell;
if (workspaceUnit.Type.IsPrimitive || workspaceUnit.Type == String.Empty.GetType())
{
renderer.Visible = true;
renderer.Text = workspaceUnit.Data.ToString();
}
else
{
renderer.Visible = false;
}
}
void OutlineTreeTextFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
var txtRenderer = (CellRendererText)cell;
object o = model.GetValue(iter, 0);
var syntaxNode = o as SyntaxNode;
if (syntaxNode != null)
{
txtRenderer.Markup = astAmbience.GetEntityMarkup(syntaxNode);
}
else if (o is SyntaxTrivia)
{
txtRenderer.Text = ((SyntaxTrivia)o).ToString();
}
}
protected void OnTreeview2RowActivated(object o, RowActivatedArgs args)
{
TreeIter iter;
TreeModel model = treeview2.Model;
model.GetIter(out iter, args.Path);
List <string> record = new List <string>();
for (int i = 0; i < 10; i++)
{
var value = model.GetValue(iter, i);
record.Add(value.ToString());
}
values = record;
}
static void FileIconDataFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
if (TreeIter.Zero.Equals(iter))
{
return;
}
var fileNamePixbufRenderer = (CellRendererImage)cell;
var searchResult = (SearchResult)model.GetValue(iter, SearchResultColumn);
if (searchResult == null)
{
return;
}
fileNamePixbufRenderer.Image = IdeServices.DesktopService.GetIconForFile(searchResult.FileName, IconSize.Menu);
}
bool TemplatesTreeViewSelection(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected)
{
TreeIter iter;
if (model.GetIter(out iter, path))
{
var template = model.GetValue(iter, TemplateColumn) as SolutionTemplate;
if (template == null)
{
return(false);
}
}
return(true);
}
bool TemplateCategoriesTreeViewSelection(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected)
{
TreeIter iter;
if (model.GetIter(out iter, path))
{
var category = model.GetValue(iter, TemplateCategoryColumn) as TemplateCategory;
if (category?.IsTopLevel == true) // don't allow selection for top level categories
{
return(false);
}
}
return(true);
}
private int TimeSortFunc(TreeModel model, TreeIter iter1, TreeIter iter2)
{
LogMessage m1 = (LogMessage)model.GetValue(iter1, (int)Columns.Message);
LogMessage m2 = (LogMessage)model.GetValue(iter2, (int)Columns.Message);
if (m1 == null || m2 == null)
{
return(0);
}
SortType order;
int sid;
store.GetSortColumnId(out sid, out order);
if (order == SortType.Ascending)
{
return(DateTime.Compare(m1.TimeStamp, m2.TimeStamp));
}
else
{
return(DateTime.Compare(m2.TimeStamp, m1.TimeStamp));
}
}
void TxtDataFunc(TreeViewColumn tree_column, CellRenderer cell, TreeModel tree_model, TreeIter iter)
{
CellRendererText txtRenderer = (CellRendererText)cell;
string dirname = (string)tree_model.GetValue(iter, 0);
if (dirname.Length == 0)
{
txtRenderer.Text = project.Name;
return;
}
int lastSlash = dirname.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
txtRenderer.Text = lastSlash < 0? dirname : dirname.Substring(lastSlash + 1);
}
private bool default_port_compare(TreeModel model, TreePath path, TreeIter iter)
{
string port = model.GetValue(iter, 0) as string;
if (port != null)
{
Console.WriteLine("considering " + port + " while looking for " + default_port_name);
if (port.Equals(default_port_name))
{
combo_Port.SetActiveIter(iter);
return(true);
}
}
return(false);
}
private void RenderHasTypesCheckBox(TreeViewColumn layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
PackageHeirarchyItem hierarchyItem = model.GetValue(iter, 0) as PackageHeirarchyItem;
if (hierarchyItem != null)
{
(cell as CellRendererToggle).Active = hierarchyItem.HasTypes;
cell.Visible = true;
}
else
{
//if it is just a file not directory hide the checkbox
cell.Visible = false;
}
}
private void SourcesFunc (TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
SearchResult result = (SearchResult)model.GetValue(iter, 0);
if (result.Type == SearchResultType.File) {
int numberOfSources = search.AllFileResults[result.InfoHash].Count;
if (numberOfSources == 1) {
(cell as CellRendererText).Text = "1 source";
} else {
(cell as CellRendererText).Text = numberOfSources + " sources";
}
} else {
(cell as CellRendererText).Text = string.Empty;
}
}
private void NetworkTextFunc(CellLayout layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
Network network = (model.GetValue(iter, 0) as Network);
if (network != null)
{
(cell as CellRendererText).Text = network.NetworkName;
(cell as CellRendererText).Sensitive = true;
}
else
{
(cell as CellRendererText).Text = "(Select a network)";
(cell as CellRendererText).Sensitive = false;
}
}
void CellDataFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
var item = model.GetValue(iter, 0) as Session;
if (item != null)
{
if (ColumnMap.ContainsKey(column.Title))
{
int pos = ColumnMap[column.Title];
if (pos < item.Columns.Length)
{
((CellRendererText)cell).Text = item.Columns[pos];
}
}
}
}
bool FilterFuncWrapper(TreeModel model, TreeIter iter)
{
if (filterFunc == null)
{
return(true);
}
var item = (TemplateItem)model.GetValue(iter, 0);
//gets called while the rows are being inserted and don't yet have data
if (item == null)
{
return(false);
}
return(filterFunc(item));
}
private void MemoSubjectDataFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
object item = (object)model.GetValue(iter, 0);
if (item is Memo)
{
Memo memo = (Memo)item;
(cell as CellRendererText).Text = memo.Subject;
(cell as CellRendererText).Weight = memo.Unread ? (int)Pango.Weight.Bold : (int)Pango.Weight.Normal;
}
else
{
(cell as CellRendererText).Text = (item as Network).NetworkName;
(cell as CellRendererText).Weight = (int)Pango.Weight.Bold;
}
}
private void peersTreeView_ProgressFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
IFileTransferPeer peer = (IFileTransferPeer)model.GetValue(iter, 0);
CellRendererProgress progressCell = (CellRendererProgress)cell;
if (peer.Progress > int.MinValue && peer.Progress < int.MaxValue)
{
progressCell.Value = Convert.ToInt32(peer.Progress);
progressCell.Text = $"{progressCell.Value}%";
}
else
{
progressCell.Value = 0;
progressCell.Text = "Unknown";
}
}
void RenderActive(TreeViewColumn column, CellRenderer cell,
TreeModel model, TreeIter iter)
{
var executable = model.GetValue(iter, 1) as IExecutable;
var toggle = cell as CellRendererToggle;
if (executable != null)
{
toggle.Visible = true;
toggle.Active = executable.IsEnabled;
}
else
{
toggle.Visible = false;
}
}
void PixDataFunc(TreeViewColumn tree_column, CellRenderer cell, TreeModel tree_model, TreeIter iter)
{
var pixRenderer = (CellRendererPixbuf)cell;
string dirname = (string)tree_model.GetValue(iter, 0);
if (dirname.Length == 0)
{
pixRenderer.PixbufExpanderOpen = projBuf;
pixRenderer.PixbufExpanderClosed = projBuf;
pixRenderer.Pixbuf = projBuf;
return;
}
pixRenderer.PixbufExpanderOpen = dirOpenBuf;
pixRenderer.PixbufExpanderClosed = dirClosedBuf;
pixRenderer.Pixbuf = dirClosedBuf;
}
static void OutlineTreeTextFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
var astAmbience = new AstAmbience(IdeApp.TypeSystemService.Workspace.Options);
var txtRenderer = (CellRendererText)cell;
object o = model.GetValue(iter, 0);
var syntaxNode = o as SyntaxNode;
if (syntaxNode != null)
{
txtRenderer.Markup = astAmbience.GetEntityMarkup(syntaxNode);
}
else if (o is SyntaxTrivia)
{
txtRenderer.Text = ((SyntaxTrivia)o).ToString();
}
}
private void RenderBirthday(TreeViewColumn column, CellRenderer cell,
TreeModel model, TreeIter iter)
{
Person p = (Person)model.GetValue(iter, 0);
// If birthday was not set, show nothing
if (!p.BirthdayDate.Equals(DateTime.MinValue))
{
(cell as CellRendererText).Text =
this.FormatBirthdayDateTime(p.BirthdayDate);
}
else
{
(cell as CellRendererText).Text = "";
}
}
private void RenderServiceColumn(TreeViewColumn column, CellRenderer cell,
TreeModel model, TreeIter iter)
{
string markup = (string)model.GetValue(iter, 1);
TreeSelection selection = (column.TreeView as TreeView).Selection;
if (selection.IterIsSelected(iter))
{
markup = markup.Replace(SecondaryTextColor, SecondaryTextColorSelected);
}
else
{
markup = markup.Replace(SecondaryTextColorSelected, SecondaryTextColor);
}
(cell as CellRendererText).Markup = markup;
}
private void ShowAutoConnectToggle(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
CellRendererToggle toggleCell = (CellRendererToggle)cell;
if (((TreeStore)model).IterDepth(iter) > 0)
{
TrustedNodeInfo node = (TrustedNodeInfo)model.GetValue(iter, 0);
toggleCell.Active = node.AllowAutoConnect;
toggleCell.Activatable = true;
toggleCell.Visible = true;
}
else
{
toggleCell.Visible = false;
}
}
private void ToFromFunc(TreeViewColumn tree_column, CellRenderer cell,
TreeModel tree_model, TreeIter iter)
{
var info = (MessageInfo)tree_model.GetValue(iter, 0);
if (info != null)
{
/*
* Node node = null;
*
* if (info.Connection.Transport.Network != null) {
* if (info is SentMessageInfo) {
* node = info.Connection.Transport.Network.Nodes[info.Message.To];
* } else {
* node = info.Connection.Transport.Network.Nodes[info.Message.From];
* }
* (cell as CellRendererText).Text = node.ToString();
* } else { */
string nodeId = null;
if (info is SentMessageInfo)
{
nodeId = info.Message.To;
}
else
{
nodeId = info.Message.From;
}
if (info.Connection.Transport.Network != null && info.Connection.Transport.Network.Nodes.ContainsKey(nodeId))
{
var node = info.Connection.Transport.Network.Nodes[nodeId];
(cell as CellRendererText).Text = node.ToString();
}
else if (nodeId == Network.BroadcastNodeID)
{
(cell as CellRendererText).Text = "(Broadcast)";
}
else
{
(cell as CellRendererText).Text = string.Format("({0})", nodeId);
}
/*}*/
}
}
private bool FilterByKeyVisibleFunc(TreeModel model, TreeIter iter)
{
if (string.IsNullOrEmpty(_filterByKeyEntry.Text))
{
return(true);
}
string key = model.GetValue(iter, 0).ToString();
if (key.ToLower().Contains(_filterByKeyEntry.Text.ToLower()))
{
return(true);
}
return(false);
}
bool FilterSmallAssets(TreeModel model, Gtk.TreeIter iter)
{
var balance = model.GetValue(iter, 0) as Balance;
if (balance == null)
{
return(true);
}
if (balance.TotalBtc >= 0.001m)
{
return(true);
}
else
{
return(false);
}
}
void HandleValueCellDataFunc(TreeViewColumn tree_column, CellRenderer cell, TreeModel tree_model, TreeIter iter)
{
var key = (string)tree_model.GetValue(iter, 0);
var value = _textResourcesManager.GetValue(tree_column.Title, key);
var cellText = (CellRendererText)cell;
if (value == null)
{
cellText.Background = "red";
}
else
{
cellText.Background = null;
}
cellText.Text = value;
}
private void RenderPrediction(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
Movie movie = (Movie)model.GetValue(iter, 0);
double prediction;
if (!predictions.TryGetValue(movie.ID, out prediction))
{
// predictions.TryGetValue(movie.ID, out prediction);
Console.Error.WriteLine("{0}: {1}", movie.ID, movie.Title);
}
if (ratings.ContainsKey(movie.ID))
{
prediction = ratings[movie.ID];
}
string text;
if (prediction < rating_predictor.MinRating)
{
text = "";
}
else if (prediction < 1.5)
{
text = string.Format(CultureInfo.InvariantCulture, "{0,0:0.00} ★", prediction);
}
else if (prediction < 2.5)
{
text = string.Format(CultureInfo.InvariantCulture, "{0,0:0.00} ★★", prediction);
}
else if (prediction < 3.5)
{
text = string.Format(CultureInfo.InvariantCulture, "{0,0:0.00} ★★★", prediction);
}
else if (prediction < 4.5)
{
text = string.Format(CultureInfo.InvariantCulture, "{0,0:0.00} ★★★★", prediction);
}
else
{
text = string.Format(CultureInfo.InvariantCulture, "{0,0:0.00} ★★★★★", prediction);
}
(cell as CellRendererText).Text = text;
}
static void TextCellDataFunc(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreeIter parent;
bool toplevel = !model.IterParent(out parent, iter);
var crt = (CellRendererText)cell;
var section = (OptionsDialogSection)model.GetValue(iter, 0);
if (toplevel)
{
crt.Markup = "<b>" + GLib.Markup.EscapeText(section.Label) + "</b>";
}
else
{
crt.Text = section.Label;
}
}
private void RenderTradesSide(TreeViewColumn tree_column, CellRenderer cell, TreeModel model, TreeIter iter)
{
var order = model.GetValue(iter, 0) as Order;
if (order != null)
{
if (order.Side == TradeSide.Buy)
{
(cell as CellRendererText).ForegroundGdk = bullColor;
}
else
{
(cell as CellRendererText).ForegroundGdk = bearColor;
}
(cell as CellRendererText).Text = order.Side.ToString();
}
}
bool CheckForText(TreeModel model, TreeIter iter, bool exact)
{
string modelText = model.GetValue(iter, Column) as string;
if (modelText == null)
{
return(false);
}
if (exact)
{
return(modelText == DesiredText);
}
else
{
return(modelText.IndexOf(DesiredText) > -1);
}
}
public static void CellDataHandler (CellLayout layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
SourceRowRenderer renderer = cell as SourceRowRenderer;
Source source = model.GetValue (iter, 0) as Source;
if (renderer == null) {
return;
}
renderer.Source = source;
renderer.Iter = iter;
if (source == null) {
return;
}
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}
void RuntimeRenderCell (CellLayout layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
var target = (ExecutionTarget) model.GetValue (iter, RuntimeExecutionTarget);
var indent = (bool) model.GetValue (iter, RuntimeIsIndented);
var renderer = (CellRendererText) cell;
renderer.Sensitive = !(target is ExecutionTargetGroup);
if (target == null) {
renderer.Xpad = (uint) 0;
return;
}
renderer.Xpad = indent ? (uint) 18 : (uint) 3;
if (!runtimeCombo.PopupShown)
renderer.Text = target.FullName;
else
renderer.Text = target.Name;
}
static bool RuntimeIsSeparator (TreeModel model, TreeIter iter)
{
var target = (ExecutionTarget) model.GetValue (iter, RuntimeExecutionTarget);
return target == null;
}
public int PodcastFeedTitleTreeIterCompareFunc(TreeModel tree_model,
TreeIter a,
TreeIter b)
{
PodcastFeedInfo feed_a = tree_model.GetValue (a, 0) as PodcastFeedInfo;
PodcastFeedInfo feed_b = tree_model.GetValue (b, 0) as PodcastFeedInfo;
if (feed_a == PodcastFeedInfo.All ||
feed_b == PodcastFeedInfo.All)
{
return 1;
}
return feed_a.CompareTo (feed_b);
}
private int Sort (TreeModel model, TreeIter left, TreeIter right)
{
int result = 0;
if (stringMatcher != null) {
result = ((int)model.GetValue (right, ColMatchRank)).CompareTo ((int)model.GetValue (left, ColMatchRank));
if (result != 0)
return result;
}
result = String.Compare ((string)model.GetValue (left, 0), (string)model.GetValue (right, 0), StringComparison.InvariantCultureIgnoreCase);
if (result != 0)
return result;
return String.Compare ((string)model.GetValue (left, ColVersion), (string)model.GetValue (right, ColVersion), StringComparison.InvariantCultureIgnoreCase);
}
private int ContractPlaceSortFunction(TreeModel model, TreeIter a, TreeIter b)
{
string oa = (string) model.GetValue(a, (int)ContractCol.place_no);
string ob = (string) model.GetValue(b, (int)ContractCol.place_no);
if (ob == null)
return 1;
if (oa == null)
return -1;
return StringWorks.NaturalStringComparer.Compare (oa, ob);
}
private int ContractEndDateSortFunction(TreeModel model, TreeIter a, TreeIter b)
{
object oa = model.GetValue(a, (int)ContractCol.end_date);
object ob = model.GetValue(b, (int)ContractCol.end_date);
if (ob == null)
return 1;
if (oa == null)
return -1;
return ((DateTime)oa).CompareTo((DateTime)ob);
}
static PropertyInfo GetProperty (TreeModel model, TreeIter iter)
{
string propertyName = (string)model.GetValue (iter, propertyColumn);
if (string.IsNullOrEmpty (propertyName))
return null;
return GetPropertyByName (propertyName);
}
void UpdateExample (TreeModel model, TreeIter iter)
{
string example = (string)model.GetValue (iter, exampleTextColumn);
UpdateExample (example);
}
// render the media file into the treeview
private void renderMedia(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter)
{
Media media = (Media) model.GetValue (iter, 0);
string text = System.IO.Path.GetFileNameWithoutExtension (media.Path);
(cell as CellRendererText).Markup = Utils.ParseMarkup (text);
}
// ============================================
// PROTECTED Methods
// ============================================
// ============================================
// PRIVATE Methods
// ============================================
private int StoreSortFunc(TreeModel model, TreeIter a, TreeIter b)
{
// Sort Folders Before Files
string a_name = (string) model.GetValue(a, COL_NAME);
string b_name = (string) model.GetValue(b, COL_NAME);
return(String.Compare(a_name, b_name));
}
void SetTemplateTextCellData (TreeViewColumn col, CellRenderer renderer, TreeModel model, TreeIter it)
{
var template = (SolutionTemplate)model.GetValue (it, TemplateColumn);
templateTextRenderer.Template = template;
templateTextRenderer.TemplateIcon = model.GetValue (it, TemplateIconColumn) as Xwt.Drawing.Image;
templateTextRenderer.TemplateCategory = model.GetValue (it, TemplateNameColumn) as string;
}
void SetTemplateCategoryCellData (TreeViewColumn col, CellRenderer renderer, TreeModel model, TreeIter it)
{
categoryTextRenderer.Category = (TemplateCategory)model.GetValue (it, TemplateCategoryColumn);
categoryTextRenderer.CategoryIcon = model.GetValue (it, TemplateCategoryIconColumn) as Xwt.Drawing.Image;
categoryTextRenderer.CategoryName = model.GetValue (it, TemplateCategoryNameColumn) as string;
}
bool TemplatesTreeViewSelection (TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected)
{
TreeIter iter;
if (model.GetIter (out iter, path)) {
var template = model.GetValue (iter, TemplateColumn) as SolutionTemplate;
if (template == null) {
return false;
}
}
return true;
}
bool TemplateCategoriesTreeViewSelection (TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected)
{
TreeIter iter;
if (model.GetIter (out iter, path)) {
var category = model.GetValue (iter, TemplateCategoryColumn) as TemplateCategory;
if (category.IsTopLevel) {
return false;
}
}
return true;
}
