private void HandleRemoveAction() { if (fileSystem == null) { return; } List <TreeIter> selectedIters = packTreeView.GetSelected().ToList(); if (selectedIters.Count == 0) { return; } TreePath path = folderStore.GetPath(selectedIters.Last()); for (int i = 0; i < selectedIters.Count - 1; i++) { path.Prev(); } selectedIters.ForEach(selectedInFolder => { if (TreeIter.Zero.Equals(selectedInFolder)) { return; } Packer.Item selectedItem = folderStore.GetValue(selectedInFolder, 2) as Packer.Item; if (selectedItem.IsRoot) { return; } TreeIter selectedInPack = FindInPack(selectedItem); if (!TreeIter.Zero.Equals(selectedInPack)) { List <TreeIter> iterInPack = packStore.GetTree(selectedInPack).ToList(); iterInPack.Select(iter => packStore.GetValue(iter, 0) as Packer.Item).ToList() .ForEach(item => { if (!item.IsFolder) { fileSystem.Remove(item); } }); packStore.Remove(ref selectedInPack); } folderStore.Remove(ref selectedInFolder); }); while (path.Indices.Last() >= folderStore.IterNChildren() && path.Prev()) { ; } packTreeView.SelectAndFocus(path); }
public bool DragDataReceived(TreePath path, SelectionData data) { Console.WriteLine("DragDataReceived dstPath={0}", path); TreeModel srcModel; TreePath srcPath; if (Tree.GetRowDragData(data, out srcModel, out srcPath)) { Console.WriteLine("DragDataReceived srcPath={0}", srcPath); object row = NodeAtPath(srcPath); SourceList.RemoveAt(srcPath.Indices[0]); if (srcPath.Indices [0] < path.Indices [0]) { path.Prev(); } if (path.Indices [0] == SourceList.Count) { SourceList.Add(row); } else { SourceList.Insert(path.Indices [0], row); } return(true); } return(false); }
public new bool DragDataReceived(TreePath path, SelectionData data) { logger.Debug("DragDataReceived dstPath={0}", path); TreeModel srcModel; TreePath srcPath; TreeIter srcIter, dstIter, newIter, ParentIter; if (Tree.GetRowDragData(data, out srcModel, out srcPath)) { logger.Debug("DragDataReceived srcPath={0}", srcPath); bool Last = false; if (!this.GetIter(out dstIter, path)) { path.Prev(); Last = true; this.GetIter(out dstIter, path); } this.GetIter(out srcIter, srcPath); this.IterParent(out ParentIter, dstIter); if (Last) { newIter = this.InsertNodeAfter(ParentIter, dstIter); } else { newIter = this.InsertNodeBefore(ParentIter, dstIter); } CopyValues(srcIter, newIter); return(true); } return(false); }
/// <summary>Deletes the specified node.</summary> /// <param name="nodePath">The node path.</param> public void Delete(string nodePath) { TreeIter node = FindNode(nodePath); // We will typically be deleting the currently selected node. If this is the case, // Gtk will not automatically move the cursor for us. // We need to work out where we want selection to be after this node is deleted TreePath cursorPath; TreeViewColumn cursorCol; treeview1.GetCursor(out cursorPath, out cursorCol); TreeIter nextSel = node; TreePath pathToSelect = treemodel.GetPath(node); if (pathToSelect.Compare(cursorPath) != 0) { pathToSelect = null; } else if (!treemodel.IterNext(ref nextSel)) // If there's a "next" sibling, the current TreePath will do { // Otherwise if (!pathToSelect.Prev()) // If there's a "previous" sibling, use that { pathToSelect.Up(); // and if that didn't work, use the parent } } treemodel.Remove(ref node); if (pathToSelect != null) { treeview1.SetCursor(pathToSelect, treeview1.GetColumn(0), false); } }
protected void RemoveReference(object sender, EventArgs e) { TreeIter iter; TreeModel mdl; if (ReferencesTreeView.Selection.GetSelected(out mdl, out iter)) { ProjectReference pref = (ProjectReference)refTreeStore.GetValue(iter, ProjectReferenceColumn); foreach (var p in panels) { p.SignalRefChange(pref, false); } TreeIter newIter = iter; if (refTreeStore.IterNext(ref newIter)) { ReferencesTreeView.Selection.SelectIter(newIter); refTreeStore.Remove(ref iter); } else { TreePath path = refTreeStore.GetPath(iter); if (path.Prev()) { ReferencesTreeView.Selection.SelectPath(path); refTreeStore.Remove(ref iter); } else { refTreeStore.Remove(ref iter); } } } }
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); } }
/// <summary>Moves the specified node up 1 position.</summary> /// <param name="nodePath">The path of the node to move.</param> public void MoveUp(string nodePath) { TreeIter node = FindNode(nodePath); TreePath path = treemodel.GetPath(node); TreeIter prevnode; if (path.Prev() && treemodel.GetIter(out prevnode, path)) { treemodel.MoveBefore(node, prevnode); } }
/// <summary> /// Moves the selected item up if possible. /// </summary> protected void OnButtonUpClicked (object sender, System.EventArgs e) { TreePath[] paths = treeview.Selection.GetSelectedRows (); if (paths.Length > 0) { TreePath p = paths [0]; TreeIter it1, it2; listStore.GetIter (out it2, p); if (p.Prev () && listStore.GetIter (out it1, p)) { listStore.Swap (it1, it2); } } }
/// <summary> /// Updates the greyed out state of the up and down buttons /// depending on the currently selected item. /// </summary> protected void UpdatePriorityButtons () { TreePath[] paths = treeview.Selection.GetSelectedRows (); if (paths.Length > 0) { TreePath p = paths [0]; TreeIter it; listStore.GetIter (out it, p); buttonDown.Sensitive = listStore.IterNext (ref it); buttonUp.Sensitive = p.Prev (); } else { buttonDown.Sensitive = buttonUp.Sensitive = false; } }
/// <summary>Moves the specified node up 1 position.</summary> /// <param name="nodePath">The path of the node to move.</param> public void MoveUp(string nodePath) { TreeIter node = FindNode(nodePath); TreePath path = treemodel.GetPath(node); TreeIter prevnode; if (path.Prev() && treemodel.GetIter(out prevnode, path)) { treemodel.MoveBefore(node, prevnode); } treeview1.ScrollToCell(path, null, false, 0, 0); }
protected void OnButtonOrdinalUpClicked(object sender, EventArgs e) { TreeIter SelectIter, BeforeIter; treeviewref.Selection.GetSelected(out SelectIter); SelectIter = filter.ConvertIterToChildIter(SelectIter); TreePath path = RefListStore.GetPath(SelectIter); path.Prev(); RefListStore.GetIter(out BeforeIter, path); RefListStore.Swap(SelectIter, BeforeIter); OnTreeviewrefCursorChanged(treeviewref, EventArgs.Empty); TestOrdinalChanged(); }
protected void Remove(TreeIter iter) { // select prev/next row ListStore store = (ListStore)Model; TreePath p = store.GetPath(iter); if (!p.Prev()) { p.Next(); } Selection.SelectPath(p); // remove selected row store.Remove(ref iter); }
void MoveUp(object o, EventArgs e) { if (content_treeview.Selection.GetSelected(out var model, out var selected)) { //no IterPrev :( TreePath path = model.GetPath(selected); if (path.Prev()) { if (model.GetIter(out var prev, path)) { (model as ListStore).Swap(prev, selected); } } } }
private bool IncrementPathForKeyPress(Gdk.EventKey press, TreePath path) { switch (press.Key) { case Gdk.Key.Up: case Gdk.Key.KP_Up: return(path.Prev()); case Gdk.Key.Down: case Gdk.Key.KP_Down: path.Next(); return(true); } return(false); }
void move_selected_jar_mods(bool move_up) { TreeIter iter; TreeModel model; ListStore model_real; // get selected item, if any if (jarModList.Selection.GetSelected(out model, out iter)) { model_real = model as ListStore; if (move_up) { TreeIter firstIter; // is there at least one row? (better to be sure!) if (!model_real.GetIterFirst(out firstIter)) { return; } // don't move first line up into the void if (firstIter.Equals(iter)) { return; } System.Console.WriteLine("Can move up"); TreePath path = model.GetPath(iter); TreePath prevPath = path; if (prevPath.Prev()) { TreeIter prevIter; model.GetIter(out prevIter, prevPath); model_real.Swap(iter, prevIter); changed_mod_order = true; } } else { TreeIter iternext = iter; if (model.IterNext(ref iternext)) { model_real.Swap(iter, iternext); changed_mod_order = true; } } } }
/// <summary>Deletes the specified node.</summary> /// <param name="nodePath">The node path.</param> public void Delete(string nodePath) { TreeIter node = FindNode(nodePath); if (node.Equals(TreeIter.Zero)) { return; } // We will typically be deleting the currently selected node. If this is the case, // Gtk will not automatically move the cursor for us. // We need to work out where we want selection to be after this node is deleted TreePath cursorPath; TreeViewColumn cursorCol; treeview1.GetCursor(out cursorPath, out cursorCol); TreeIter nextSel = node; TreePath pathToSelect = treemodel.GetPath(node); if (pathToSelect.Compare(cursorPath) != 0) { pathToSelect = null; } else if (treemodel.IterNext(ref nextSel)) // If there's a "next" sibling, the current TreePath will do { pathToSelect = treemodel.GetPath(nextSel); } else { // Otherwise if (!pathToSelect.Prev()) // If there's a "previous" sibling, use that { pathToSelect.Up(); // and if that didn't work, use the parent } } // Note: gtk_tree_store_remove() seems quite slow if the node being // deleted is selected. Therefore, we select the next node *before* // deleting the specified node. if (pathToSelect != null) { treeview1.SetCursor(pathToSelect, treeview1.GetColumn(0), false); } treemodel.Remove(ref node); }
protected void OnButtonUpClicked(object sender, EventArgs e) { TreeIter ti; if (this.treeviewProcesses.Selection.GetSelected(out ti)) { TreePath tp = lsPrcs.GetPath(ti); if (tp.Prev()) { TreeIter ti_prev; lsPrcs.GetIter(out ti_prev, tp); lsPrcs.MoveBefore(ti, ti_prev); Process selectedPrc = currentTsk.processes [tp.Indices [0] + 1]; currentTsk.processes.Remove(selectedPrc); currentTsk.processes.Insert(tp.Indices [0], selectedPrc); } } }
/// <summary> /// Moves the selected rule one positon higher. /// </summary> /// <param name="sender"> /// A <see cref="System.Object"/> /// </param> /// <param name="args"> /// A <see cref="EventArgs"/> /// </param> private void OnUpBtnClicked(object sender, EventArgs args) { TreeIter selected; rulesTV.Selection.GetSelected(out selected); TreePath previousPath = rulesTV.Selection.GetSelectedRows()[0]; previousPath.Prev(); TreeIter previous; rulesStore.GetIter(out previous, previousPath); rulesStore.MoveBefore(selected, previous); rulesTV.Selection.UnselectAll(); rulesTV.Selection.SelectPath(previousPath); rulesTV.ScrollToCell(previousPath, rulesTV.Columns[0], true, 0, 0); }
protected virtual void OnButtonUpClicked(object sender, System.EventArgs e) { TreeIter iter; if (!treeItems.Selection.GetSelected(out iter)) { return; } TreePath tp = listStore.GetPath(iter); Gtk.TreeIter pi; if (tp.Prev() && listStore.GetIter(out pi, tp)) { listStore.Swap(pi, iter); treeItems.ScrollToCell(listStore.GetPath(iter), treeItems.Columns[0], false, 0, 0); UpdateButtons(); } }
// Methods :: Public :: SelectPrevious public bool SelectPrevious() { TreeModel model; TreePath [] sel = Selection.GetSelectedRows(out model); if (sel.Length == 0) { return(false); } TreePath first = sel [0]; if (first.Prev()) { SetCursor(first, Columns [0], false); return(true); } return(false); }
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]); }
protected void RemoveReference(object sender, EventArgs e) { TreeIter iter; TreeModel mdl; if (ReferencesTreeView.Selection.GetSelected(out mdl, out iter)) { switch (((ProjectReference)refTreeStore.GetValue(iter, ProjectReferenceColumn)).ReferenceType) { case ReferenceType.Gac: gacRefPanel.SignalRefChange((ProjectReference)refTreeStore.GetValue(iter, ProjectReferenceColumn), false); break; case ReferenceType.Project: projectRefPanel.SignalRefChange((string)refTreeStore.GetValue(iter, NameColumn), false); break; } TreeIter newIter = iter; if (refTreeStore.IterNext(ref newIter)) { ReferencesTreeView.Selection.SelectIter(newIter); refTreeStore.Remove(ref iter); } else { TreePath path = refTreeStore.GetPath(iter); if (path.Prev()) { ReferencesTreeView.Selection.SelectPath(path); refTreeStore.Remove(ref iter); } else { refTreeStore.Remove(ref iter); } } } }
protected virtual void OnButtonRemoveClicked(object sender, System.EventArgs e) { TreeIter it; if (listView.Selection.GetSelected(out it)) { var s = (XmlFormattingSettings)store.GetValue(it, 1); policy.Formats.Remove(s); TreePath p = store.GetPath(it); store.Remove(ref it); if (store.IterIsValid(it)) { listView.Selection.SelectIter(it); } else { if (p.Prev()) { store.GetIter(out it, p); listView.Selection.SelectIter(it); } } } }
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(); }
//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 FindMoveRow(int movenumber, out TreePath path, out TreeIter iter) { iter = TreeIter.Zero; if (total_rows <= 0) { path = null; return false; } path = new TreePath (new int[] { total_rows - 1}); do { store.GetIter (out iter, path); int number = (int) store.GetValue (iter, 0); if (number == movenumber) return true; if (number < movenumber) return false; } while (path.Prev ()); return false; }