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); } }
/// <summary>Moves the specified node down 1 position.</summary> /// <param name="nodePath">The path of the node to move.</param> public void MoveDown(string nodePath) { TreeIter node = FindNode(nodePath); TreePath path = treemodel.GetPath(node); TreeIter nextnode; path.Next(); if (treemodel.GetIter(out nextnode, path)) { treemodel.MoveAfter(node, nextnode); } }
/// <summary> /// If sequencing, selects the next symbol of the list. /// </summary> /// <param name="sender"> /// A <see cref="System.Object"/> /// </param> /// <param name="args"> /// A <see cref="EventArgas"/> /// </param> private void OnControllerNodeBeingProcessed(object sender, NodeBeingProcessedArgs _args) { Application.Invoke(sender, _args, delegate(object resender, EventArgs args) { NodeBeingProcessedArgs a = args as NodeBeingProcessedArgs; if (!sequencingFinished) { // We are sequencing. // Selects the new first. symbolsIV.SelectPath(processedPath); symbolsIV.ScrollToPath(processedPath, 1, 0.5f); processedPath.Next(); } else { // We are matching SequenceNode node = (SequenceNode)a.Node; node.Select(); Token t = Token.Join(node.Sequence, ""); sequenceNodeImage = t.Image.CreatePixbuf(); sequenceMatchingImageArea.Image = sequenceNodeImage.Copy(); sequenceNodeImage = sequenceNodeImage.CompositeColorSimple(sequenceNodeImage.Width, sequenceNodeImage.Height, Gdk.InterpType.Nearest, 100, 1, 0xAAAAAA, 0xAAAAAA); matchingResultLbl.Markup = "-"; tokenizingRulesTV.Selection.UnselectAll(); tokenizingRulesTV.ScrollToPoint(0, 0); if (controller.StepMode == ControllerStepMode.StepByStep) { tokenizingNextButtonsAlign.Sensitive = true; } } }); }
/// <summary>Moves the specified node down 1 position.</summary> /// <param name="nodePath">The path of the node to move.</param> public void MoveDown(string nodePath) { TreeIter node = FindNode(nodePath); TreePath path = treemodel.GetPath(node); TreeIter nextnode; path.Next(); if (treemodel.GetIter(out nextnode, path)) { treemodel.MoveAfter(node, nextnode); } treeview1.ScrollToCell(path, null, false, 0, 0); }
private void UpdateList() { visibility.Clear(); TreeStore store = new TreeStore(typeof(System.Object)); foreach (Tilemap Tilemap in sector.GetObjects(typeof(Tilemap))) { store.AppendValues(Tilemap); visibility[Tilemap] = application.CurrentRenderer.GetTilemapColor(Tilemap).Alpha; // if no tilemap is yet selected, select the first solid one if ((application.CurrentTilemap == null) && (Tilemap.Solid)) { application.CurrentTilemap = Tilemap; application.EditProperties(application.CurrentTilemap, "Tilemap (" + application.CurrentTilemap.ZPos + ")"); } } store.SetSortFunc(0, compareZPos); store.SetSortColumnId(0, SortType.Ascending); store.AppendValues(separatorObject); visibility[separatorObject] = 0; if (sector.GetObjects(typeof(Background)).Count > 0) { store.AppendValues(backgroundObject); visibility[backgroundObject] = application.CurrentRenderer.GetBackgroundColor().Alpha; } store.AppendValues(badguysObject); visibility[badguysObject] = application.CurrentRenderer.GetObjectsColor().Alpha; Model = store; // Visibly select current Tilemap if (application.CurrentTilemap != null) { TreePath path = TreePath.NewFirst(); TreeIter iter; while (Model.GetIter(out iter, path)) { object obj = Model.GetValue(iter, 0); if (obj == application.CurrentTilemap) { HasFocus = true; ActivateRow(path, GetColumn(0)); SetCursor(path, GetColumn(0), false); } path.Next(); } } }
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); }
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); }
/// <summary> /// Moves the selected rule one postion lower. /// </summary> /// <param name="sender"> /// A <see cref="System.Object"/> /// </param> /// <param name="args"> /// A <see cref="EventArgs"/> /// </param> private void OnDownBtnClicked(object sender, EventArgs args) { TreeIter selected; rulesTV.Selection.GetSelected(out selected); TreePath nextPath = rulesTV.Selection.GetSelectedRows()[0]; nextPath.Next(); TreeIter next; rulesStore.GetIter(out next, nextPath); rulesStore.MoveBefore(selected, next); rulesTV.Selection.UnselectAll(); rulesTV.Selection.SelectPath(nextPath); rulesTV.ScrollToCell(nextPath, rulesTV.Columns[0], true, 1.0f, 0); }
void HandleButtonPressEvent(object o, ButtonPressEventArgs args) { if (args.Event.Button == 3) { var path = GetPathAtPos((int)args.Event.X, (int)args.Event.Y); if (path != null) { if (!PathIsSelected(path)) { bool ctrl = (args.Event.State & Gdk.ModifierType.ControlMask) != 0; bool shift = (args.Event.State & Gdk.ModifierType.ShiftMask) != 0; if (ctrl) { SelectPath(path); } else if (shift) { TreePath cursor; CellRenderer cell; if (GetCursor(out cursor, out cell)) { TreePath first = cursor.Compare(path) < 0 ? cursor : path; do { SelectPath(first); first.Next(); } while (first != path && first != cursor && first != null); } else { SelectPath(path); } } else { UnselectAll(); SelectPath(path); } } HandlePopupMenu(null, null); args.RetVal = true; } } }
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 void OnTilemapChanged(Tilemap Tilemap) { // Visibly select new Tilemap if (Tilemap != null) { TreePath path = TreePath.NewFirst(); TreeIter iter; while (Model.GetIter(out iter, path)) { object obj = Model.GetValue(iter, 0); if (obj == Tilemap) { HasFocus = true; ActivateRow(path, GetColumn(0)); SetCursor(path, GetColumn(0), false); } path.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]); }
// Methods :: Public :: SelectNext public bool SelectNext() { TreeModel model; TreePath [] sel = Selection.GetSelectedRows(out model); if (sel.Length == 0) { return(false); } TreePath last = sel [sel.Length - 1]; last.Next(); TreeIter iter; if (model.GetIter(out iter, last)) { SetCursor(last, Columns [0], false); return(true); } 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(); }
/// <summary> /// Handles the controller's SequenceBeingMatched event. /// </summary> /// <param name="sender"> /// A <see cref="System.Object"/> /// </param> /// <param name="quenceBeingMatchedArgs"> /// A <see cref="Se"/> /// </param> private void OnControllerSequenceBeingMatched(object sender, SequenceBeingMatchedArgs args) { Application.Invoke(sender, args, delegate(object resender, EventArgs _args) { SequenceBeingMatchedArgs a = _args as SequenceBeingMatchedArgs; Gdk.Pixbuf sequenceImage = a.JoinedToken.Image.CreatePixbuf(); Gdk.Pixbuf drawnImage = sequenceNodeImage.Copy(); sequenceImage.CopyArea(0, 0, sequenceImage.Width, sequenceImage.Height, drawnImage, 0, 0); sequenceMatchingImageArea.Image = drawnImage; TreeIter iter; tokenizingRulesTV.Model.GetIterFirst(out iter); TreePath path = tokenizingRulesTV.Model.GetPath(iter); tokenizingRulesTV.Selection.UnselectAll(); string ruleName; do { ruleName = tokenizingRulesTV.Model.GetValue(iter, 0) as string; if (ruleName == a.MatchingRule.Name) { tokenizingRulesTV.Selection.SelectPath(path); tokenizingRulesTV.ScrollToCell(path, tokenizingRulesTV.Columns[0], true, 0.5f, 0); break; } path.Next(); }while(tokenizingRulesTV.Model.GetIter(out iter, path)); if (a.Found) { matchingResultLbl.Markup = String.Format("<b>Sí, se le asigna el item «{0}» a la secuencia actual</b>", a.JoinedToken.Type); } else { matchingResultLbl.Markup = String.Format("<b>No, la regla actual no concuerda con la secuencia</b>"); } // Activate the buttons if necessary. if (controller.StepMode == ControllerStepMode.StepByStep) { tokenizingNextButtonsAlign.Sensitive = true; } }); }
public Dialog(Image image, Drawable drawable, VariableSet variables) : base("Photoshop Actions", variables) { _image = image; _drawable = drawable; var vbox = new VBox(false, 12) { BorderWidth = 12 }; VBox.PackStart(vbox, true, true, 0); var store = CreateActionTree(); var sw = new ScrolledWindow() { HeightRequest = 400 }; vbox.PackStart(sw, true, true, 0); var view = new TreeView(store); sw.Add(view); var activeRenderer = new CellRendererToggle() { Activatable = true }; var columnOne = view.AppendColumn("Enabled", activeRenderer, new TreeCellDataFunc(RenderActive)); activeRenderer.Toggled += delegate(object o, ToggledArgs args) { TreeIter iter; var path = new TreePath(args.Path); if (store.GetIter(out iter, path)) { var executable = store.GetValue(iter, 1) as IExecutable; executable.IsEnabled = !executable.IsEnabled; path.Down(); while (store.GetIter(out iter, path)) { store.EmitRowChanged(path, iter); path.Next(); } } }; var textRenderer = new CellRendererText(); var column = view.AppendColumn("Set Name", textRenderer, new TreeCellDataFunc(RenderText)); var hbox = new HBox(); vbox.PackStart(hbox, false, true, 0); var play = new Button(Stock.Execute); play.Clicked += delegate { RenameToBackground(); var paths = view.Selection.GetSelectedRows(); var path = paths[0]; // Assume only 1 is selected var indices = path.Indices; var actions = _set[indices[0]]; if (indices.Length > 2) { actions.Execute(indices[1], indices[2]); path.Next(); view.Selection.SelectPath(path); } else { actions.Execute(indices[1]); } Gimp.DisplaysFlush(); }; hbox.PackStart(play, false, true, 0); view.Selection.Changed += delegate { var paths = view.Selection.GetSelectedRows(); var indices = paths[0].Indices; play.Sensitive = (indices.Length > 1); }; view.Selection.SetSelectFunction(delegate(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected) { return(path.Indices.Length <= 3); }, IntPtr.Zero, null); ActionEvent.ActionSetCollection = _set; }