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;
}
