private void FindItemRecursive(TreeIter iter, Stack <long> path)
{
TreeModel model = tvItems.Model;
bool hasMoreIters = true;
long itemID = path.Pop();
while (hasMoreIters)
{
VolumeItem item = tvItems.GetItem(iter);
if (item.ItemID == itemID)
{
if (path.Count > 0)
{
tvItems.ExpandRow(model.GetPath(iter), false);
model.IterChildren(out iter, iter);
FindItemRecursive(iter, path);
}
else
{
tvItems.Selection.SelectIter(iter);
tvItems.ScrollToCell(model.GetPath(iter), null, false, .0f, .0f);
}
break;
}
hasMoreIters = model.IterNext(ref iter);
}
}
public override bool Select()
{
base.Select();
if (!resultIter.HasValue)
{
return(false);
}
if (ParentWidget is TreeView)
{
TreeView treeView = (TreeView)ParentWidget;
treeView.Selection.UnselectAll();
treeView.ExpandRow(TModel.GetPath(resultIter.Value), false);
treeView.Selection.SelectIter((TreeIter)resultIter);
treeView.SetCursor(TModel.GetPath((TreeIter)resultIter), treeView.Columns [0], false);
}
else if (ParentWidget is ComboBox)
{
ComboBox comboBox = (ComboBox)ParentWidget;
comboBox.SetActiveIter((TreeIter)resultIter);
}
return(true);
}
private void BuildGroupButtonsView()
{
TreeIter iter;
Logger.Debug("GroupWindow.BuildGroupButtonsView adding {0} groups",
groupTreeModel.IterNChildren());
// Loop through the model, create buttons, and add them into the
// groupButtonsVBox.
if (groupTreeModel.GetIterFirst(out iter))
{
do
{
PersonGroup group =
groupTreeModel.GetValue(iter, 0) as PersonGroup;
if (group == null)
{
continue;
}
AddGroupButton(new GroupButton(group),
groupTreeModel.GetPath(iter));
} while (groupTreeModel.IterNext(ref iter));
}
}
protected override int HandleSort(TreeModel model, TreeIter a, TreeIter b)
{
object objecta, objectb;
LMTimelineEventVM tna, tnb;
if (model == null)
{
return(0);
}
objecta = model.GetValue(a, 0);
objectb = model.GetValue(b, 0);
if (objecta == null && objectb == null)
{
return(0);
}
else if (objecta == null)
{
return(-1);
}
else if (objectb == null)
{
return(1);
}
// Dont't store categories
if (objecta is EventTypeTimelineVM && objectb is EventTypeTimelineVM)
{
return(int.Parse(model.GetPath(a).ToString())
- int.Parse(model.GetPath(b).ToString()));
}
else if (objecta is LMTimelineEventVM && objectb is LMTimelineEventVM)
{
tna = objecta as LMTimelineEventVM;
tnb = objectb as LMTimelineEventVM;
switch (tna.Model.EventType.SortMethod)
{
case (SortMethodType.SortByName):
return(String.Compare(tna.Name, tnb.Name));
case (SortMethodType.SortByStartTime):
return((tna.Start - tnb.Start).MSeconds);
case (SortMethodType.SortByStopTime):
return((tna.Stop - tnb.Stop).MSeconds);
case (SortMethodType.SortByDuration):
return((tna.Duration - tnb.Duration).MSeconds);
default:
return(0);
}
}
else
{
return(0);
}
}
protected override int SortFunction(TreeModel model, TreeIter a, TreeIter b)
{
TreeStore store;
TimeNode tna, tnb;
TreeIter parent;
int depth;
Category category;
if (model == null)
{
return(0);
}
store = model as TreeStore;
// Retrieve the iter parent and its depth
// When a new play is inserted, one of the iters is not a valid
// in the model. Get the values from the valid one
if (store.IterIsValid(a))
{
store.IterParent(out parent, a);
depth = store.IterDepth(a);
}
else
{
store.IterParent(out parent, b);
depth = store.IterDepth(b);
}
// Dont't store categories
if (depth == 0)
{
return(int.Parse(model.GetPath(a).ToString())
- int.Parse(model.GetPath(b).ToString()));
}
category = model.GetValue(parent, 0) as Category;
tna = model.GetValue(a, 0) as TimeNode;
tnb = model.GetValue(b, 0) as TimeNode;
switch (category.SortMethod)
{
case (SortMethodType.SortByName):
return(String.Compare(tna.Name, tnb.Name));
case (SortMethodType.SortByStartTime):
return((tna.Start - tnb.Start).MSeconds);
case (SortMethodType.SortByStopTime):
return((tna.Stop - tnb.Stop).MSeconds);
case (SortMethodType.SortByDuration):
return((tna.Duration - tnb.Duration).MSeconds);
default:
return(0);
}
}
/* private methods */
private bool SelectPointHelper(int x, int y, bool select)
{
TreeIter iter = TreeIter.Zero;
if (!GetPointNear(x, y, out iter))
{
return(false);
}
TreePath path = model.GetPath(iter);
// always focus
focused_path = path.Copy();
if (select)
{
// fire SelectionChanged if the
// selection has actually
// changed
if (selected_path == null ||
path.Compare(selected_path) != 0)
{
selected_path = path.Copy();
if (SelectionChanged != null)
{
SelectionChanged(this, new EventArgs());
}
}
}
else
{
// deselect if we previously
// had a selection
if (selected_path != null)
{
selected_path = null;
if (SelectionChanged != null)
{
SelectionChanged(this, new EventArgs());
}
}
}
// always fire PointActivated
if (PointActivated != null)
{
PointActivated(this, model, iter);
}
return(true);
}
private void AddRootClick(object sender, EventArgs e)
{
Node node = new Node("root" + _model.Nodes.Count.ToString());
_model.Nodes.Add(node);
_tree.SelectedNode = _tree.FindNode(_model.GetPath(node));
}
/// <summary>
/// Sets the contents of a cell being display on a grid
/// </summary>
/// <param name="col"></param>
/// <param name="cell"></param>
/// <param name="model"></param>
/// <param name="iter"></param>
public void RenderActivityStatus(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
int colNo;
string text = String.Empty;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
cell.Visible = true;
switch (dataVal.ToString())
{
case "Success":
case "Partial":
case "Ignore":
case "Critical":
case "Calculation":
case "NotNeeded":
case "Timer":
(cell as CellRendererPixbuf).Pixbuf = new Gdk.Pixbuf(null, "ApsimNG.Resources.MenuImages." + dataVal.ToString() + ".png");
break;
default:
// use blank image as setting visible to false did not work.
(cell as CellRendererPixbuf).Pixbuf = new Gdk.Pixbuf(null, "ApsimNG.Resources.MenuImages.blank.png");
break;
}
}
}
public void OnSetCellData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
int colNo;
if (colLookup.TryGetValue(cell, out colNo))
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
Type dataType = dataVal.GetType(); // DataSource.Columns[colNo].DataType;
string text;
if (dataType == typeof(float) ||
dataType == typeof(double))
{
text = String.Format("{0:" + NumericFormat + "}", dataVal);
}
else if (dataType == typeof(DateTime))
{
text = String.Format("{0:d}", dataVal);
}
else
{
text = dataVal.ToString();
}
(cell as CellRendererText).Text = text;
}
}
public TextureBrowserDialog(string initialSelectedPath)
{
InitializeComponent();
int initialSelectedNodeIndex = -1;
graphicsControl.Size = new Size(0, 0);
ResizePanel();
paths = TextureLoader.GetAllPaths();
foreach (string path in paths)
{
//Check if the folderNode is created
Node parent = MakeFolderNode(path);
Node textureNode = new Node(path.Substring(path.LastIndexOfAny(new[] { '\\', '/' }) + 1));
textureNode.Image = File;
textureNode.Tag = textureNodes.Count;
if (path == initialSelectedPath)
{
initialSelectedNodeIndex = textureNodes.Count;
}
textureNodes.Add(textureNode);
if (parent != null)
{
parents[textureNode] = parent;
}
}
//Build the tree view
includeSnapshots.Add(new List <int>());
int i = 0;
foreach (Node textureNode in textureNodes)
{
includeSnapshots[0].Add(i++);
Node node = textureNode;
Node parent = parents.ContainsKey(node) ? parents[node] : null;
while (parent != null)
{
if (parent.Nodes.Contains(node))
{
node = null;
break;
}
parent.Nodes.Add(node);
node = parent;
parent = parents.ContainsKey(node) ? parents[node] : null;
}
if (node != null && !model.Nodes.Contains(node))
{
model.Nodes.Add(node);
}
}
TVTextures.Model = model;
if (initialSelectedNodeIndex != -1)
{
initialSelection = TVTextures.FindNode(model.GetPath(textureNodes[initialSelectedNodeIndex]));
}
}
private bool FilterTags(TreeModel model, TreeIter iter)
{
int index = model.GetPath(iter).Indices[0];
string tag = (string)_tags[index];
string query = entry2.Text;
System.StringComparison comp = System.StringComparison.OrdinalIgnoreCase;
return(tag.IndexOf(query, comp) > -1);
}
public int AppendColumn(GridViewColumn col)
{
col.VisibilityChanged +=
new EventHandler(OnColumnVisibilityChanged);
if (col.Visible)
{
if (orientation == Orientation.Vertical)
{
widths.Add(0);
}
else
{
heights.Add(0);
}
visible.Add(col);
TreeIter i;
if (model != null && model.GetIterFirst(out i))
{
do
{
TreePath path = model.GetPath(i);
MeasureCell(path, col);
} while (model.IterNext(ref i));
}
if (Visible)
{
UpdateDrawingAreaSizeRequests();
}
}
int ret = columns.Add(col);
if (ColumnsChanged != null)
{
ColumnsChanged(this, EventArgs.Empty);
}
return(ret);
}
private void PopulatePersonView()
{
List <Widget> children = new List <Widget> (vbox.Children);
foreach (Widget child in children)
{
vbox.Remove(child);
try {
child.Destroy();
} catch {}
}
// personCardMap.Clear ();
if (model == null)
{
Logger.Debug("PersonView.PopulatePersonView returning since the model is null.");
return;
}
TreeIter iter;
// Loop through the model, create the PersonCard objects and add
// them into the vbox.
if (model.GetIterFirst(out iter))
{
do
{
Person person = model.GetValue(iter, 0) as Person;
if (person == null)
{
continue;
}
TreePath path = model.GetPath(iter);
PersonCard card = new PersonCard(person);
card.Size = personCardSize;
card.ShowAll();
vbox.PackStart(card, false, false, 0);
vbox.ReorderChild(card, path.Indices [0]);
// personCardMap[iter] = card;
} while (model.IterNext(ref iter));
}
}
protected virtual int HandleSort(TreeModel model, TreeIter a, TreeIter b)
{
if (a.Equals(TreeIter.Zero) && b.Equals(TreeIter.Zero))
{
return(0);
}
else if (a.Equals(TreeIter.Zero))
{
return(-1);
}
else if (b.Equals(TreeIter.Zero))
{
return(1);
}
TreePath pathA = model.GetPath(a);
TreePath pathB = model.GetPath(b);
return(pathA.Compare(pathB));
}
public void setupNewSearch(string initialSelectedPath)
{
for (int i = 0; i < paths.Count; ++i)
{
if (paths[i] == initialSelectedPath)
{
initialSelection = TVTextures.FindNode(model.GetPath(textureNodes[i]));
break;
}
}
}
public override bool Click()
{
if (ParentWidget is TreeView && resultIter.HasValue)
{
var path = TModel.GetPath(resultIter.Value);
var tree = ParentWidget as TreeView;
return(tree.ExpandRow(path, true));
}
return(false);
}
internal void ExpandeSelectedItem()
{
if (_parent._tvArtists.Selection.GetSelected(out selectedModel, out selectedIter))
{
string selectedType = selectedModel.GetValue(selectedIter, 3).ToString();
string selectedId = selectedModel.GetValue(selectedIter, 2).ToString();
if (selectedType == "artist")
{
if (!_parent._tvArtists.GetRowExpanded(selectedModel.GetPath(selectedIter)))
{
if (!selectedModel.IterHasChild(selectedIter))
{
_parent._tvArtists.Model = this.GetArtistAlbums(tsArtists.GetValue(selectedIter, 2).ToString());
_parent._tvArtists.ShowAll();
if (albumCount == 0)
{
_parent.oFileBrowser.ShowFiles(selectedType, selectedId);
}
else
{
_parent.oFileBrowser.Clear();
}
albumCount = 0;
}
_parent._tvArtists.ExpandRow(selectedModel.GetPath(selectedIter), false);
}
else
{
_parent._tvArtists.CollapseRow(selectedModel.GetPath(selectedIter));
}
}
else if (selectedType == "album")
{
_parent.oFileBrowser.ShowFiles(selectedType, selectedId);
}
}
}
/// <summary>
/// Sets the contents of a cell being display on a grid
/// </summary>
/// <param name="col"></param>
/// <param name="cell"></param>
/// <param name="model"></param>
/// <param name="iter"></param>
public void RenderActivityStatus(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
int colNo;
string text = String.Empty;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
cell.Visible = true;
string iconName = "blank";
switch (dataVal.ToString())
{
case "0":
iconName = "Success";
break;
case "1":
iconName = "Partial";
break;
case "2":
iconName = "Ignored";
break;
case "3":
iconName = "Critical";
break;
case "4":
iconName = "Timer";
break;
case "5":
iconName = "Calculation";
break;
case "6":
iconName = "NotNeeded";
break;
case "7":
iconName = "Ignored";
break;
case "8":
iconName = "NoTask";
break;
}
(cell as CellRendererPixbuf).Pixbuf = new Gdk.Pixbuf(null, "ApsimNG.Resources.MenuImages." + iconName + ".png");
}
}
protected override int HandleSort(TreeModel model, TreeIter a, TreeIter b)
{
object objecta, objectb;
if (model == null)
{
return(0);
}
objecta = model.GetValue(a, 0);
objectb = model.GetValue(b, 0);
if (objecta == null && objectb == null)
{
return(0);
}
else if (objecta == null)
{
return(-1);
}
else if (objectb == null)
{
return(1);
}
// Dont't store categories
if (objecta is EventTypeTimelineVM && objectb is EventTypeTimelineVM)
{
return(int.Parse(model.GetPath(a).ToString())
- int.Parse(model.GetPath(b).ToString()));
}
else if (objecta is LMTimelineEventVM && objectb is LMTimelineEventVM)
{
return((objecta as LMTimelineEventVM).CompareTo(objectb as LMTimelineEventVM));
}
else
{
return(0);
}
}
public void ExpandSelectedDirectory()
{
if (_parent._tvShares.Selection.GetSelected(out selectedModel, out selectedIter))
{
string selectedType = selectedModel.GetValue(selectedIter, 3).ToString();
if (!_parent._tvShares.GetRowExpanded(selectedModel.GetPath(selectedIter)))
{
selectedPath = selectedModel.GetValue(selectedIter, 2).ToString();
if (!tsShares.IterHasChild(selectedIter))
{
_parent._tvShares.Model = GetDirectories(selectedPath);
_parent._tvShares.ShowAll();
}
if (selectedType == "folder" || selectedType == "share")
{
if (selectedType != "share")
{
tsShares.SetValue(selectedIter, 0, new Pixbuf("Interface/Images/folder_open.png"));
}
_parent._tvShares.ExpandRow(selectedModel.GetPath(selectedIter), false);
}
}
else
{
if (selectedType == "folder" || selectedType == "share")
{
if (selectedType != "share")
{
tsShares.SetValue(selectedIter, 0, new Pixbuf("Interface/Images/folder_closed.png"));
}
_parent._tvShares.CollapseRow(selectedModel.GetPath(selectedIter));
}
}
_parent.oFileBrowser.ShowFiles(selectedType, selectedPath);
}
}
public void ExpandSelectedDirectory()
{
if (this._parent.tvShares.Selection.GetSelected(out this.selectedModel, out this.selectedIter))
{
string selectedType = this.selectedModel.GetValue(selectedIter, 3).ToString();
if (!this._parent.tvShares.GetRowExpanded(selectedModel.GetPath(this.selectedIter)))
{
this.selectedPath = this.selectedModel.GetValue(this.selectedIter, 2).ToString();
if (!this.tsShares.IterHasChild(this.selectedIter))
{
this._parent.tvShares.Model = this.GetDirectories(this.selectedPath);
this._parent.tvShares.ShowAll();
}
if (selectedType == "folder" || selectedType == "share")
{
if (selectedType != "share")
{
this.tsShares.SetValue(this.selectedIter, 0, this._parent.oImages.menu.folder_open);
}
this._parent.tvShares.ExpandRow(selectedModel.GetPath(this.selectedIter), false);
}
}
else
{
if (selectedType == "folder" || selectedType == "share")
{
if (selectedType != "share")
{
tsShares.SetValue(selectedIter, 0, this._parent.oImages.menu.folder_closed);
}
this._parent.tvShares.CollapseRow(selectedModel.GetPath(selectedIter));
}
}
this._parent.oFileBrowser.ShowFiles(selectedType, selectedPath);
}
}
private void button5_Click(object sender, EventArgs e)
{
TreeModel Model = treeListView1.Model as TreeModel;
Node NewNode = new Node("qwerty");
Model.Nodes[0].Nodes.Add(NewNode);
TreeNodeAdv Node = treeListView1.FindNode(Model.GetPath(NewNode));
treeListView1.SelectedNode = Node;
treeListView1.ScrollTo(Node);
}
/// <summary>
/// Sets the contents of a cell being display on a grid
/// </summary>
/// <param name="col"></param>
/// <param name="cell"></param>
/// <param name="model"></param>
/// <param name="iter"></param>
public void OnSetCellData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
TreeView view = col.TreeView as TreeView;
int rowNo = path.Indices[0];
int colNo;
string text = String.Empty;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
text = AsString(dataVal);
}
cell.Visible = true;
(cell as CellRendererText).Text = text;
}
// finds the specified item:
// - select owner volume
// - expand the treeview path to the item
// and select the item
public void FindItem(VolumeItem item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
// get path of volume ids to item
Stack <long> path = new Stack <long>();
VolumeItem tmp = item;
while (tmp.ItemID != 1) // skip root item
{
path.Push(tmp.ItemID);
tmp = database.GetVolumeItem(tmp.VolumeID, tmp.ParentID);
}
// find and select volume of specified item
TreeModel model = tvVolumes.Model;
TreeIter iter;
long volumeID = item.VolumeID;
bool hasMoreIters = true;
model.GetIterFirst(out iter);
while (hasMoreIters)
{
Volume vol = tvVolumes.GetVolume(iter);
if (vol.VolumeID == volumeID)
{
// select owner volume
tvVolumes.Selection.SelectIter(iter);
tvVolumes.ScrollToCell(model.GetPath(iter), null, false, .0f, .0f);
if (path.Count > 0)
{
// find and select specified item
tvItems.Model.GetIterFirst(out iter);
FindItemRecursive(iter, path);
} // else : specified item is the root item so select nothing
break;
}
hasMoreIters = model.IterNext(ref iter);
}
}
public void OnSetGridData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int row = path.Indices[0];
if (cell is CellRendererText)
{
if (row == 1 || row == 2)
{
(cell as CellRendererText).Background = "lightgray";
}
else
{
(cell as CellRendererText).Background = "white";
}
}
}
private void button2_Click_1(object sender, EventArgs e)
{
TreeModel Model = new TreeModel();
Node Root = new Node("Bla bla bla");
for (int i = 0; i < 20; i++)
{
Root.Nodes.Add(new Node("Child " + i.ToString()));
}
Model.Nodes.Add(Root);
treeListView1.Model = Model;
treeListView1.SelectedNode = treeListView1.FindNode(Model.GetPath(Root));
treeListView1.SelectedNode.IsExpanded = true;
treeListView1.Focus();
}
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.Path = model.GetPath (iter);
if (source == null) {
return;
}
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}
private bool FilterPhotos(TreeModel model, TreeIter iter)
{
int index = model.GetPath(iter).Indices[0];
Photo p = (Photo) _photos[index];
return FilterPhoto(p);
}
static void RenderIcon(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
var pixbufCellRenderer = (CellRendererImage)cell;
if (model.IterHasChild(iter))
{
pixbufCellRenderer.Image = ImageService.GetIcon(((TreeView)col.TreeView).GetRowExpanded(model.GetPath(iter)) ? MonoDevelop.Ide.Gui.Stock.OpenFolder : MonoDevelop.Ide.Gui.Stock.ClosedFolder, IconSize.Menu);
}
else
{
pixbufCellRenderer.Image = ImageService.GetIcon(MonoDevelop.Ide.Gui.Stock.Property, IconSize.Menu);
}
}
protected override int SortFunction(TreeModel model, TreeIter a, TreeIter b)
{
object objecta, objectb;
TimelineEvent tna, tnb;
if (model == null)
return 0;
objecta = model.GetValue (a, 0);
objectb = model.GetValue (b, 0);
if (objecta == null && objectb == null) {
return 0;
} else if (objecta == null) {
return -1;
} else if (objectb == null) {
return 1;
}
// Dont't store categories
if (objecta is EventType && objectb is EventType) {
return int.Parse (model.GetPath (a).ToString ())
- int.Parse (model.GetPath (b).ToString ());
} else if (objecta is TimelineEvent && objectb is TimelineEvent) {
tna = objecta as TimelineEvent;
tnb = objectb as TimelineEvent;
switch (tna.EventType.SortMethod) {
case(SortMethodType.SortByName):
return String.Compare (tna.Name, tnb.Name);
case(SortMethodType.SortByStartTime):
return (tna.Start - tnb.Start).MSeconds;
case(SortMethodType.SortByStopTime):
return (tna.Stop - tnb.Stop).MSeconds;
case(SortMethodType.SortByDuration):
return (tna.Duration - tnb.Duration).MSeconds;
default:
return 0;
}
} else {
return 0;
}
}
void CategoryComboBoxDataFunc(CellLayout layout, CellRenderer renderer, TreeModel model, TreeIter iter)
{
var crt = renderer as CellRendererText;
var catName = model.GetValue (iter, 0) as string;
var backend = GtkApplication.Instance.Backend;
int taskCount = 0;
if (model.GetPath (iter).Indices [0] == TreePath.NewFirst ().Indices [0])
taskCount = backend.Tasks.Count (t => !t.IsComplete);
else {
var cat = backend.Categories.SingleOrDefault (c => c.Name == catName);
if (cat != null)
taskCount = cat.Count (t => !t.IsComplete);
else
catName = null;
}
if (catName != null)
crt.Text = string.Format ("{0} ({1})", catName, taskCount);
else
crt.Text = "unknown";
}
private void Redraw(Cairo.Context cr)
{
// Clear the background
cr.Rectangle(0, 0, Allocation.Width, Allocation.Height);
Gdk.CairoHelper.SetSourceColor(cr, Style.Base(State));
cr.Fill();
if (model == null)
{
if (hadj != null)
{
hadj.Upper = hadj.Lower = 0;
hadj.Change();
}
if (vadj != null)
{
vadj.Upper = 0;
vadj.Change();
}
return;
}
if (rows == 0 || cols == 0)
{
return;
}
Gdk.Rectangle background_area = cell_size;
background_area.Width += padding;
background_area.Height += padding;
TreeIter iter;
if (model.GetIterFirst(out iter))
{
do
{
TreePath path = model.GetPath(iter);
int x, y;
GetCellPosition(path.Indices[0], out x, out y);
if (hadj != null &&
(x + cell_size.Width < hadj.Value ||
x > hadj.Value + hadj.PageSize))
{
continue;
}
if (vadj != null &&
(y + cell_size.Height < vadj.Value ||
y > vadj.Value + vadj.PageSize))
{
continue;
}
if (data_func != null)
{
data_func(this, renderer, model, iter);
}
cell_size.X = x;
cell_size.Y = y;
if (hadj != null)
{
cell_size.X -= (int)hadj.Value;
}
if (vadj != null)
{
cell_size.Y -= (int)vadj.Value;
}
background_area.X = cell_size.X - (padding / 2);
background_area.Y = cell_size.Y - (padding / 2);
cr.Rectangle(background_area.X, background_area.Y,
background_area.Width, background_area.Height);
cr.Clip();
renderer.Render(cr, this, background_area,
cell_size, GetCellState(path));
cr.ResetClip();
} while (model.IterNext(ref iter));
}
if (have_rubberband_selection)
{
int hadj_val = (hadj != null) ? (int)hadj.Value : 0;
int vadj_val = (vadj != null) ? (int)vadj.Value : 0;
cr.Rectangle(sel_rect.X - hadj_val + 0.5f, sel_rect.Y - vadj_val + 0.5f,
sel_rect.Width, sel_rect.Height);
Cairo.Color sel_cairo_color = CairoHelper.GetCairoColor(Style.Background(StateType.Selected));
//cr.Color = sel_cairo_color;
cr.SetSourceRGBA(sel_cairo_color.R, sel_cairo_color.G, sel_cairo_color.B, sel_cairo_color.A);
cr.LineWidth = 1.0f;
cr.StrokePreserve();
sel_cairo_color.A = 0.3f;
//cr.Color = sel_cairo_color;
cr.SetSourceRGBA(sel_cairo_color.R, sel_cairo_color.G, sel_cairo_color.B, sel_cairo_color.A);
cr.Fill();
}
}
//generally useful function... why not in model already?
static bool IterPrev (TreeModel model, ref TreeIter iter)
{
TreePath tp = model.GetPath (iter);
return tp.Prev() && model.GetIter (out iter, tp);
}
private bool FilterTags(TreeModel model, TreeIter iter)
{
int index = model.GetPath(iter).Indices[0];
string tag = (string) _tags[index];
string query = entry2.Text;
System.StringComparison comp = System.StringComparison.OrdinalIgnoreCase;
return (tag.IndexOf(query, comp) > -1);
}
//generally useful function... why not in model already?
static bool IterPrev(TreeModel model, ref TreeIter iter)
{
TreePath tp = model.GetPath(iter);
return(tp.Prev() && model.GetIter(out iter, tp));
}
public void OnSetCellData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath startPath;
TreePath endPath;
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
// This gets called a lot, even when it seemingly isn't necessary.
if (numberLockedCols == 0 && gridview.GetVisibleRange(out startPath, out endPath) && (rowNo < startPath.Indices[0] || rowNo > endPath.Indices[0]))
return;
int colNo;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
Type dataType = dataVal.GetType();
string text;
if (dataType == typeof(DBNull))
text = String.Empty;
else if ((dataType == typeof(float) && !float.IsNaN((float)dataVal)) ||
(dataType == typeof(double) && !Double.IsNaN((double)dataVal)))
text = String.Format("{0:" + NumericFormat + "}", dataVal);
else if (dataType == typeof(DateTime))
text = String.Format("{0:d}", dataVal);
else
text = dataVal.ToString();
(cell as CellRendererText).Text = text;
}
}
protected bool FilterFunc(TreeModel model,
TreeIter iter)
{
TreePath path = model.GetPath (iter);
if (path.Depth <= 2)
{
return true;
}
if (path.Indices[1] != OTHER_CATEGORY_IDX
&& path.Indices[1] !=
LIGHTNING_CATEGORY_IDX)
{
path.Up ();
gamesView.ExpandRow (path, false);
}
string filterstr = filterEntry.Text.Trim ();
if (filterstr.Length == 0)
return true;
string str =
model.GetValue (iter, 0) as string;
if (str.IndexOf (filterstr.ToLower ()) >= 0)
return true;
return false;
}
public void OnSetCellData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath startPath;
TreePath endPath;
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
// This gets called a lot, even when it seemingly isn't necessary.
if (numberLockedCols == 0 && gridview.GetVisibleRange(out startPath, out endPath) && (rowNo < startPath.Indices[0] || rowNo > endPath.Indices[0]))
return;
int colNo;
string text = String.Empty;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
Type dataType = dataVal.GetType();
if (dataType == typeof(DBNull))
text = String.Empty;
else if (NumericFormat != null && ((dataType == typeof(float) && !float.IsNaN((float)dataVal)) ||
(dataType == typeof(double) && !Double.IsNaN((double)dataVal))))
text = String.Format("{0:" + NumericFormat + "}", dataVal);
else if (dataType == typeof(DateTime))
text = String.Format("{0:d}", dataVal);
if (col.TreeView == gridview) // Currently not handling booleans and lists in the "fixed" column grid
{
if (dataType == typeof(Boolean))
{
CellRendererToggle toggleRend = col.CellRenderers[1] as CellRendererToggle;
if (toggleRend != null)
{
toggleRend.Active = (Boolean)dataVal;
toggleRend.Activatable = true;
cell.Visible = false;
col.CellRenderers[2].Visible = false;
toggleRend.Visible = true;
return;
}
}
else
{ // This assumes that combobox grid cells are based on the "string" type
ListStore store;
if (comboLookup.TryGetValue(new Tuple<int, int>(rowNo, colNo), out store))
{
CellRendererCombo comboRend = col.CellRenderers[2] as CellRendererCombo;
if (comboRend != null)
{
comboRend.Model = store;
comboRend.TextColumn = 0;
comboRend.Editable = true;
comboRend.HasEntry = false;
cell.Visible = false;
col.CellRenderers[1].Visible = false;
comboRend.Visible = true;
comboRend.Text = dataVal.ToString();
return;
}
}
text = dataVal.ToString();
}
col.CellRenderers[1].Visible = false;
col.CellRenderers[2].Visible = false;
}
}
cell.Visible = true;
(cell as CellRendererText).Text = text;
}
public void OnSetCellData(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
int colNo;
if (colLookup.TryGetValue(cell, out colNo))
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
Type dataType = dataVal.GetType(); // DataSource.Columns[colNo].DataType;
string text;
if (dataType == typeof(float) ||
dataType == typeof(double))
text = String.Format("{0:" + NumericFormat + "}", dataVal);
else if (dataType == typeof(DateTime))
text = String.Format("{0:d}", dataVal);
else
text = dataVal.ToString();
(cell as CellRendererText).Text = text;
}
}
/* Cell Renderers */
private void RenderNumberCell (TreeViewColumn column, CellRenderer cell, TreeModel treeModel, TreeIter iter) {
(cell as CellRendererText).Text = (Util.PathToInt(treeModel.GetPath(iter)) + 1).ToString();
}
void RenderIcon (TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter)
{
var pixbufCellRenderer = (CellRendererPixbuf)cell;
if (model.IterHasChild (iter)) {
pixbufCellRenderer.Pixbuf = ImageService.GetPixbuf (((TreeView)col.TreeView).GetRowExpanded (model.GetPath (iter)) ? MonoDevelop.Ide.Gui.Stock.OpenFolder : MonoDevelop.Ide.Gui.Stock.ClosedFolder, IconSize.Menu);
} else {
pixbufCellRenderer.Pixbuf = ImageService.GetPixbuf (MonoDevelop.Ide.Gui.Stock.Property, IconSize.Menu);
}
}
protected void IdxCellDataFunc(TreeViewColumn col,
CellRenderer r,
TreeModel model,
TreeIter iter)
{
CellRendererText renderer =
(CellRendererText) r;
TreePath path = model.GetPath (iter);
renderer.Markup =
"<b>" + (path.Indices[0] + 1) +
".</b>";
}
