/* 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 RemoveChildren(Node node, TreePath path) { if (node.Empty) { return; } TreePath children = path.Copy(); children.Down(); foreach (Node child in node) { RemoveChildren(child, children); children.Next(); } children.Up(); children.Down(); // Then empty the node for (int i = 0; i < node.Count; ++i) { //Console.WriteLine("Row deleted recurse: {0}, {1}", children, node[i]); d_adapter.EmitRowDeleted(children.Copy()); } }
private CellRenderer NextCell(CellRenderer renderer, TreePath path, bool prev, out TreeViewColumn column, out TreePath nextPath) { TreeViewColumn[] columns = d_treeview.Columns; bool getnext = false; CellRenderer prevedit = null; column = null; nextPath = path.Copy(); for (int j = 0; j < columns.Length; ++j) { CellRenderer[] renderers = columns[j].CellRenderers; for (int i = 0; i < renderers.Length; ++i) { if (renderer == renderers[i]) { getnext = true; if (prev) { if (prevedit == null && nextPath.Prev()) { column = columns[columns.Length - 1]; prevedit = column.CellRenderers[column.CellRenderers.Length - 1]; } return(prevedit); } } else if (getnext) { column = columns[j]; return(renderers[i]); } else { prevedit = renderers[i]; column = columns[j]; } } } nextPath.Next(); if (nextPath.Indices[0] < d_treeview.NodeStore.Count) { column = columns[0]; return(column.CellRenderers[0]); } else { return(null); } }
private void AddNodeToModel(Node node, TreePath path) { // First reorder the child if necessary if (path == null && IsSorted) { Comparison <Node> sorter = Sorter; for (int i = 0; i < node.Parent.Count; ++i) { Node child = node.Parent[i]; if (node != child && sorter(node, child) < 0) { node.Parent.Move(node, i); break; } } } if (path == null) { path = node.Path; } //Console.WriteLine("Row inserted: {0}, {1}", path, node); d_adapter.EmitRowInserted(path.Copy(), node.Iter); TreePath children = path.Copy(); children.Down(); if (IsSorted) { node.Sort(Sorter); } // Then also its children foreach (Node child in node) { AddNodeToModel(child, children); children.Next(); } }
private TreeViewColumn NextColumn(TreePath path, TreeViewColumn column, bool prev, out TreePath next) { TreeViewColumn[] columns = d_treeview.Columns; int idx = Array.IndexOf(columns, column); next = null; if (idx < 0) { return(null); } next = path.Copy(); if (!prev && idx == columns.Length - 1) { next.Next(); idx = 0; } else if (prev && idx == 0) { if (!next.Prev()) { return(null); } idx = columns.Length - 1; } else if (!prev) { ++idx; } else { --idx; } return(columns[idx]); }
public bool SelectType(Type t) { if (t != null && typeIters [t] != null) { TreeIter iter = (TreeIter)typeIters [t]; TreePath path = typeStore.GetPath(iter); Stack stack = new Stack(); while (path.Up()) { stack.Push(path.Copy()); } while (stack.Count > 0) { typeView.ExpandRow((TreePath)stack.Pop(), false); } typeView.Selection.SelectIter(iter); typeView.ScrollToCell(typeStore.GetPath(iter), typeView.GetColumn(0), true, (float)0.5, 0); return(true); } typeView.Selection.UnselectAll(); return(false); }
private void OnDataRowDeleted(object o, RowDeletedArgs args) { if (model == null || args.Path == null) { return; } bool sel_paths_changed = false; // Don't update the real n_cells, as doing this will // throw off ScrollToPath if called before SizeAllocate // is run int n_cells = model.IterNChildren(); for (int i = 0; i < selected_paths.Count; i++) { TreePath path = (TreePath)selected_paths[i]; int cmp = path.Compare(args.Path); if (cmp == 0) { selected_paths.RemoveAt(i); i--; sel_paths_changed = true; continue; } // decrement each path that follows the one we // just deleted if (cmp > 0) { path.Prev(); selected_paths[i] = path; continue; } } if (sel_paths_changed && SelectionChanged != null) { SelectionChanged(this, new EventArgs()); } if (focused_path != null && focused_path.Equals(args.Path)) { focused_path = focused_path.Copy(); // try to advance the focus forward focused_path.Next(); if (!PathIsValid(focused_path, n_cells) && !focused_path.Prev()) { focused_path = null; } } if (selection_anchor != null && selection_anchor.Equals(args.Path)) { selection_anchor = null; } QueueResize(); }
void UpdateOutlineSelection(object sender, Mono.TextEditor.DocumentLocationEventArgs e) { if (clickedOnOutlineItem || SyntaxTree == null || TreeStore == null) { return; } IStatement stmt = null; var caretLocation = Document.Editor.Caret.Location; var caretLocationD = new CodeLocation(caretLocation.Column, caretLocation.Line); var currentblock = DResolver.SearchBlockAt(SyntaxTree, caretLocationD, out stmt); INode selectedASTNode = null; if (currentblock == null) { return; } foreach (var n in currentblock) { if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation) { selectedASTNode = n; break; } } if (selectedASTNode == null) { selectedASTNode = stmt != null ? stmt.ParentNode : currentblock; } if (selectedASTNode == null) { return; } if (lastExpanded != null) { if (TreeView.GetRowExpanded(lastExpanded)) { TreeView.CollapseRow(lastExpanded); } } TreeStore.Foreach((TreeModel model, TreePath path, TreeIter iter) => { var n = model.GetValue(iter, 0); if (n == selectedASTNode) { dontJumpToDeclaration = true; TreePath parentPath = path.Copy(); parentPath.Up(); if (!TreeView.GetRowExpanded(parentPath)) { lastExpanded = parentPath.Copy(); } TreeView.ExpandToPath(path); TreeView.Selection.SelectIter(iter); dontJumpToDeclaration = false; return(true); } return(false); }); }