public TreePath(TreePath parent, object node) { _path=new object[parent.FullPath.Length+1]; for(int i=0; i<_path.Length-1; i++) _path[i]=parent.FullPath[i]; _path[_path.Length-1]=node; }
/// <summary> /// Returns node at specified path /// </summary> public override object GetNodeAtPath (TreePath aPath) { if (Items == null) return (null); if (aPath.Indices.Length == 0) return (null); return (Items.Rows[aPath.Indices[0]]); }
public TaskRowEditingEventArgs(ITask task, TreeIter iter, TreePath path) { if (task == null) throw new ArgumentNullException ("task"); ITask = task; if (path == null) throw new ArgumentNullException ("path"); Path = path; Iter = iter; }
public TaskBeingEdited(ITask task, TreeIter iter, TreePath path) { if (path == null) throw new ArgumentNullException ("path"); if (task == null) throw new ArgumentNullException ("task"); Task = task; Iter = iter; Path = path; }
/// <summary> /// Searches for node in Items /// </summary> public override TreePath PathFromNode (object aNode) { TreePath tp = new TreePath(); if ((aNode == null) || (Items == null) || (Items.Rows.Count == 0)) return (tp); int idx = Items.Rows.IndexOf(aNode as DataRow); if (idx >= 0) tp.AppendIndex (idx); return (tp); }
private void AdjustCursorForCurrentPage() { int page = gamesBook.CurrentPage; TreePath path = new TreePath (new int[]{ page }); gamesList.Selection.SelectPath (path); }
void OnTaskToggled(object o, ToggledArgs args) { Logger.Debug ("OnTaskToggled"); TreeIter iter; var path = new TreePath (args.Path); if (!model.GetIter (out iter, path)) return; // Do nothing var task = model.GetValue (iter, 0) as ITask; if (task == null) return; // remove any timer set up on this task var timerCol = (TimerColumn)view.GetColumn (typeof (TimerColumn)); var tmr = timerCol.GetTimer (task); if (tmr != null) tmr.Cancel (); if (task.State == TaskState.Active) { bool showCompletedTasks = preferences.GetBool (PreferencesKeys.ShowCompletedTasksKey); // When showCompletedTasks is true, complete the tasks right // away. Otherwise, set a timer and show the timer animation // before marking the task completed. if (showCompletedTasks) { task.Complete (); var statusMsg = Catalog.GetString ("Task Completed"); TaskWindow.ShowStatus (statusMsg, 5000); } else { var timer = timerCol.CreateTimer (task); timer.TimerStopped += (s, e) => { if (!e.Canceled) e.Task.Complete (); }; timer.Tick += (s, e) => { var statusMsg = string.Format ( Catalog.GetString ("Completing Task In: {0}"), e.CountdownTick); TaskWindow.ShowStatus (statusMsg, 2000); }; timer.Start (); } } else { var statusMsg = Catalog.GetString ("Action Canceled"); TaskWindow.ShowStatus (statusMsg, 5000); task.Activate (); } }
/// <summary> /// Modify the due date or completion date depending on whether the /// task being modified is completed or active. /// </summary> /// <param name="sender"> /// A <see cref="System.Object"/> /// </param> /// <param name="args"> /// A <see cref="Gtk.EditedArgs"/> /// </param> void OnDateEdited(object sender, Gtk.EditedArgs args) { if (args.NewText == null) { Logger.Debug("New date text null, not setting date"); return; } Gtk.TreeIter iter; Gtk.TreePath path = new TreePath(args.Path); if (!Model.GetIter(out iter, path)) { return; } // 2/11 - Today // 2/12 - Tomorrow // 2/13 - Wed // 2/14 - Thu // 2/15 - Fri // 2/16 - Sat // 2/17 - Sun // -------------- // 2/18 - In 1 Week // -------------- // No Date // --------------- // Choose Date... DateTime newDate = DateTime.MinValue; DateTime today = DateTime.Now; ITask task = Model.GetValue(iter, 0) as ITask; if (args.NewText.CompareTo( today.ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("Today")) == 0) { newDate = today; } else if (args.NewText.CompareTo( today.AddDays(1).ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("Tomorrow")) == 0) { newDate = today.AddDays(1); } else if (args.NewText.CompareTo(Catalog.GetString("No Date")) == 0) { newDate = DateTime.MinValue; } else if (args.NewText.CompareTo( today.AddDays(7).ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("In 1 Week")) == 0) { newDate = today.AddDays(7); } else if (args.NewText.CompareTo(Catalog.GetString("Choose Date...")) == 0) { TaskCalendar tc = new TaskCalendar(task, this.Parent); tc.ShowCalendar(); return; } else { for (int i = 2; i <= 6; i++) { DateTime testDate = today.AddDays(i); if (testDate.ToString(Catalog.GetString("M/d - ddd")).CompareTo( args.NewText) == 0) { newDate = testDate; break; } } } Console.WriteLine("task.State {0}", task.State); if (task.State == TaskState.Completed) { // Modify the completion date task.CompletionDate = newDate; } else { // Modify the due date task.DueDate = newDate; } }
bool TemplateCategoriesTreeViewSelection(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected) { TreeIter iter; if (model.GetIter(out iter, path)) { var category = model.GetValue(iter, TemplateCategoryColumn) as TemplateCategory; if (category?.IsTopLevel == true) // don't allow selection for top level categories { return(false); } } return(true); }
private void ClearHighlighting() { if (last_row < 0 || last_col < 0) return; int idx; MoveDetails details; TreePath path = new TreePath (new int[]{ last_row }); TreeIter lastiter; store.GetIter (out lastiter, path); idx = last_col == WHITE_MOVE_COL ? WHITE_MOVE_DETAILS_COL : BLACK_MOVE_DETAILS_COL; details = (MoveDetails) store. GetValue (lastiter, idx); idx = last_col; store.SetValue (lastiter, idx, GetMove (details)); last_col = last_row = -1; }
public new bool RowDropPossible(TreePath path, SelectionData sel) { return(path.Depth == 2); }
public void DecomposeTree(AbstractTree parentNode, AbstractTree node, TreeBranch branch, TreePath path) { if (!path.IsAdded) { Possibilities.Add(path); path.IsAdded = true; } // Recursive browse if (node is TreeConnector) { TreeConnector treeConnector = (TreeConnector)node; if (treeConnector.Connection == "&") { DecomposeTree(treeConnector, treeConnector.LeftTree, TreeBranch.Left, path); DecomposeTree(treeConnector, treeConnector.RightTree, TreeBranch.Right, path); } else if (treeConnector.Connection == "|") { // In this case, parentNode is a TreeOperator if (parentNode != null) { // Left distribution TreePath clonedPathLeftDistribution = (TreePath)path.Clone(); TreeConnector parentTreeConnectorLeftDistribution = (TreeConnector)parentNode.Clone(); // Right distribution TreePath clonedPathRightDistribution = (TreePath)path.Clone(); TreeConnector parentTreeConnectorRightDistribution = (TreeConnector)parentNode.Clone(); if (branch == TreeBranch.Left) { parentTreeConnectorLeftDistribution.LeftTree = treeConnector.LeftTree; parentTreeConnectorRightDistribution.LeftTree = treeConnector.RightTree; } else if (branch == TreeBranch.Right) { parentTreeConnectorLeftDistribution.RightTree = treeConnector.LeftTree; parentTreeConnectorRightDistribution.RightTree = treeConnector.RightTree; } // Remove obsolete path Possibilities.Remove(path); // Browse recursively distributed tree ; the path must be different (by ref) if the parent operator is 'OR' DecomposeTree( parentTreeConnectorLeftDistribution, parentTreeConnectorLeftDistribution.LeftTree, TreeBranch.Left, parentTreeConnectorLeftDistribution.Connection == "|" ? (TreePath)clonedPathLeftDistribution.Clone() : clonedPathLeftDistribution ); DecomposeTree( parentTreeConnectorLeftDistribution, parentTreeConnectorLeftDistribution.RightTree, TreeBranch.Right, clonedPathLeftDistribution ); DecomposeTree( parentTreeConnectorRightDistribution, parentTreeConnectorRightDistribution.LeftTree, TreeBranch.Left, parentTreeConnectorLeftDistribution.Connection == "|" ? (TreePath)clonedPathRightDistribution.Clone() : clonedPathRightDistribution ); DecomposeTree( parentTreeConnectorRightDistribution, parentTreeConnectorRightDistribution.RightTree, TreeBranch.Right, clonedPathRightDistribution ); } // The operator is the root of the tree; we simply divide the path else { TreePath clonedLeftPath = (TreePath)path.Clone(); TreePath clonedRightPath = (TreePath)path.Clone(); // Remove obsolete path Possibilities.Remove(path); DecomposeTree(treeConnector, treeConnector.LeftTree, TreeBranch.Left, clonedLeftPath); DecomposeTree(treeConnector, treeConnector.RightTree, TreeBranch.Right, clonedRightPath); } } break; } // Leaf else if (node is TreeValue) { TreeValue treeValue = (TreeValue)node; path.Add(treeValue); } }
public void Prepend(ArrayList moves) { TreeIter iter; int end = moves.Count; int nrows = (moves.Count + 1) / 2; if (store.GetIterFirst (out iter)) { int movenumber = (int) store.GetValue (iter, 0); bool black_move = store.GetValue (iter, WHITE_MOVE_DETAILS_COL) == null; end = (movenumber - 1) * 2; nrows = movenumber - 1; if (black_move) { end++; } // create the required number of rows int j; for (j = 0; j < nrows; j++) { store.Insert (j); total_rows++; } if (last_row >= 0) last_row += j; } int row = 0; int i = 0; foreach (MoveDetails md in moves) { TreePath path = new TreePath (new int[]{ row }); if (i >= end) break; if (i % 2 == 0) { store.GetIter (out iter, path); store.SetValue (iter, 0, md. movenumber); store.SetValue (iter, WHITE_MOVE_COL, GetMove (md)); store.SetValue (iter, WHITE_MOVE_DETAILS_COL, md); } else { store.GetIter (out iter, path); store.SetValue (iter, BLACK_MOVE_COL, GetMove (md)); store.SetValue (iter, BLACK_MOVE_DETAILS_COL, md); row++; } i++; } if (total_rows > 0) ScrollToCell (new TreePath (new int[] { total_rows - 1} ), GetColumn (WHITE_MOVE_COL), false, 0, 0); }
public string[] GetParentTreePath() => TreePath.Take(TreePath.Length - 1).ToArray();
public object[] GetParentTreePath() => TreePath.Take(TreePath.Length - 1).ToArray();
public RenderablesList(string file_name) { m_unit_file = new UnitFile(file_name); m_renderables_names = new List <string> (m_unit_file.renderables_names()); m_renderables = new List <Renderable> (m_unit_file.renderables()); Console.Write(m_renderables_names[0]); m_renderables_store = new ListStore(typeof(string), typeof(string), typeof(string), typeof(string), typeof(bool)); TreeView tree = new TreeView(); this.Add(tree); TreeViewColumn nameColumn = new TreeViewColumn(); nameColumn.Title = "Name"; nameColumn.Alignment = 0.5f; TreeViewColumn nodeColumn = new TreeViewColumn(); nodeColumn.Title = "Node"; nodeColumn.Alignment = 0.5f; TreeViewColumn typeColumn = new TreeViewColumn(); typeColumn.Title = "Type"; typeColumn.Alignment = 0.5f; TreeViewColumn resourceColumn = new TreeViewColumn(); resourceColumn.Title = "Resource"; resourceColumn.Alignment = 0.5f; TreeViewColumn visibleColumn = new TreeViewColumn(); visibleColumn.Title = "Visible"; visibleColumn.Alignment = 0.5f; // Assign the model to the TreeView tree.Model = m_renderables_store; CellRendererText nameCell = new CellRendererText(); nameCell.Editable = true; nameCell.Edited += delegate(object o, EditedArgs e) { TreePath path = new TreePath(e.Path); TreeIter iter; m_renderables_store.GetIter(out iter, path); int i = path.Indices[0]; string r = e.NewText; m_renderables_names[i] = r; m_renderables_store.SetValue(iter, 0, r); }; nameColumn.PackStart(nameCell, true); CellRendererText nodeCell = new CellRendererText(); nodeCell.Editable = true; nodeCell.Edited += delegate(object o, EditedArgs e) { TreePath path = new TreePath(e.Path); TreeIter iter; m_renderables_store.GetIter(out iter, path); int i = path.Indices[0]; Renderable r = m_renderables[i]; r.node = e.NewText; m_renderables_store.SetValue(iter, 1, r.node); }; nodeColumn.PackStart(nodeCell, true); CellRendererText typeCell = new CellRendererText(); typeCell.Editable = true; typeCell.Edited += delegate(object o, EditedArgs e) { TreePath path = new TreePath(e.Path); TreeIter iter; m_renderables_store.GetIter(out iter, path); int i = path.Indices[0]; Renderable r = m_renderables[i]; r.type = e.NewText; m_renderables_store.SetValue(iter, 2, r.type); }; typeColumn.PackStart(typeCell, true); CellRendererText resourceCell = new CellRendererText(); resourceCell.Editable = true; resourceCell.Edited += delegate(object o, EditedArgs e) { TreePath path = new TreePath(e.Path); TreeIter iter; m_renderables_store.GetIter(out iter, path); int i = path.Indices[0]; Renderable r = m_renderables[i]; r.resource = e.NewText; m_renderables_store.SetValue(iter, 3, r.resource); }; resourceColumn.PackStart(resourceCell, true); CellRendererToggle visibleCell = new CellRendererToggle(); visibleCell.Activatable = true; visibleCell.Toggled += delegate(object o, ToggledArgs e) { TreePath path = new TreePath(e.Path); TreeIter iter; m_renderables_store.GetIter(out iter, path); int i = path.Indices[0]; Renderable r = m_renderables[i]; bool old = (bool)m_renderables_store.GetValue(iter, 4); r.visible = !old; m_renderables_store.SetValue(iter, 4, !old); }; visibleColumn.PackStart(visibleCell, true); // Add the columns to the TreeView nameColumn.AddAttribute(nameCell, "text", 0); nodeColumn.AddAttribute(nodeCell, "text", 1); typeColumn.AddAttribute(typeCell, "text", 2); resourceColumn.AddAttribute(resourceCell, "text", 3); visibleColumn.AddAttribute(visibleCell, "active", 4); tree.AppendColumn(nameColumn); tree.AppendColumn(nodeColumn); tree.AppendColumn(typeColumn); tree.AppendColumn(resourceColumn); tree.AppendColumn(visibleColumn); create_model(); // Show the window and everything on it ShowAll(); }
/// <summary> /// Determines if a <see cref="TreePath"/> describes a leaf node. /// </summary> /// <param name="treePath">The path.</param> /// <returns><c>True</c> if the paht points to a leaf node.</returns> public override bool IsLeaf(TreePath treePath) { return(treePath.LastNode is ObjectFieldValue); }
public new bool DragDataGet(TreePath path, SelectionData sel) { logger.Debug("DragDataGet path={0}", path); return(Tree.SetRowDragData(sel, this, path)); }
public static void SerializeNullable(TreePath? value, TextWriter sw) { if (value == null) sw.Write("null"); else Serialize(value.Value, sw); }
protected override void Render(Drawable window, Widget widget, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gdk.Rectangle expose_area, CellRendererState flags) { if (isDisposed) { return; } if (diffMode) { if (path.Equals(selctedPath)) { selectedLine = -1; selctedPath = null; } int w, maxy; window.GetSize(out w, out maxy); if (DrawLeft) { cell_area.Width += cell_area.X - leftSpace; cell_area.X = leftSpace; } var treeview = widget as FileTreeView; var p = treeview != null? treeview.CursorLocation : null; cell_area.Width -= RightPadding; window.DrawRectangle(widget.Style.BaseGC(Gtk.StateType.Normal), true, cell_area.X, cell_area.Y, cell_area.Width - 1, cell_area.Height); Gdk.GC normalGC = widget.Style.TextGC(StateType.Normal); Gdk.GC removedGC = new Gdk.GC(window); removedGC.Copy(normalGC); removedGC.RgbFgColor = baseRemoveColor.AddLight(-0.3); Gdk.GC addedGC = new Gdk.GC(window); addedGC.Copy(normalGC); addedGC.RgbFgColor = baseAddColor.AddLight(-0.3); Gdk.GC infoGC = new Gdk.GC(window); infoGC.Copy(normalGC); infoGC.RgbFgColor = widget.Style.Text(StateType.Normal).AddLight(0.2); Cairo.Context ctx = CairoHelper.Create(window); // Rendering is done in two steps: // 1) Get a list of blocks to render // 2) render the blocks int y = cell_area.Y + 2; // cline keeps track of the current source code line (the one to jump to when double clicking) int cline = 1; bool inHeader = true; BlockInfo currentBlock = null; List <BlockInfo> blocks = new List <BlockInfo> (); for (int n = 0; n < lines.Length; n++, y += lineHeight) { string line = lines [n]; if (line.Length == 0) { currentBlock = null; y -= lineHeight; continue; } char tag = line [0]; if (line.StartsWith("---", StringComparison.Ordinal) || line.StartsWith("+++", StringComparison.Ordinal)) { // Ignore this part of the header. currentBlock = null; y -= lineHeight; continue; } if (tag == '@') { int l = ParseCurrentLine(line); if (l != -1) { cline = l - 1; } inHeader = false; } else if (tag != '-' && !inHeader) { cline++; } BlockType type; switch (tag) { case '-': type = BlockType.Removed; break; case '+': type = BlockType.Added; break; case '@': type = BlockType.Info; break; default: type = BlockType.Unchanged; break; } if (currentBlock == null || type != currentBlock.Type) { if (y > maxy) { break; } // Starting a new block. Mark section ends between a change block and a normal code block if (currentBlock != null && IsChangeBlock(currentBlock.Type) && !IsChangeBlock(type)) { currentBlock.SectionEnd = true; } currentBlock = new BlockInfo() { YStart = y, FirstLine = n, Type = type, SourceLineStart = cline, SectionStart = (blocks.Count == 0 || !IsChangeBlock(blocks[blocks.Count - 1].Type)) && IsChangeBlock(type) }; blocks.Add(currentBlock); } // Include the line in the current block currentBlock.YEnd = y + lineHeight; currentBlock.LastLine = n; } // Now render the blocks // The y position of the highlighted line int selectedLineRowTop = -1; BlockInfo lastCodeSegmentStart = null; BlockInfo lastCodeSegmentEnd = null; foreach (BlockInfo block in blocks) { if (block.Type == BlockType.Info) { // Finished drawing the content of a code segment. Now draw the segment border and label. if (lastCodeSegmentStart != null) { DrawCodeSegmentBorder(infoGC, ctx, cell_area.X, cell_area.Width, lastCodeSegmentStart, lastCodeSegmentEnd, lines, widget, window); } lastCodeSegmentStart = block; } lastCodeSegmentEnd = block; if (block.YEnd < 0) { continue; } // Draw the block background DrawBlockBg(ctx, cell_area.X + 1, cell_area.Width - 2, block); // Get all text for the current block StringBuilder sb = new StringBuilder(); for (int n = block.FirstLine; n <= block.LastLine; n++) { string s = ProcessLine(lines [n]); if (n > block.FirstLine) { sb.Append('\n'); } if (block.Type != BlockType.Info && s.Length > 0) { sb.Append(s, 1, s.Length - 1); } else { sb.Append(s); } } // Draw a special background for the selected line if (block.Type != BlockType.Info && p.HasValue && p.Value.X >= cell_area.X && p.Value.X <= cell_area.Right && p.Value.Y >= block.YStart && p.Value.Y <= block.YEnd) { int row = (p.Value.Y - block.YStart) / lineHeight; double yrow = block.YStart + lineHeight * row; double xrow = cell_area.X + LeftPaddingBlock; int wrow = cell_area.Width - 1 - LeftPaddingBlock; if (block.Type == BlockType.Added) { ctx.SetSourceColor(baseAddColor.AddLight(0.1).ToCairoColor()); } else if (block.Type == BlockType.Removed) { ctx.SetSourceColor(baseRemoveColor.AddLight(0.1).ToCairoColor()); } else { ctx.SetSourceColor(widget.Style.Base(Gtk.StateType.Prelight).AddLight(0.1).ToCairoColor()); xrow -= LeftPaddingBlock; wrow += LeftPaddingBlock; } ctx.Rectangle(xrow, yrow, wrow, lineHeight); ctx.Fill(); selectedLine = block.SourceLineStart + row; selctedPath = path; selectedLineRowTop = (int)yrow; } // Draw the line text. Ignore header blocks, since they are drawn as labels in DrawCodeSegmentBorder if (block.Type != BlockType.Info) { layout.SetMarkup(""); layout.SetText(sb.ToString()); Gdk.GC gc; switch (block.Type) { case BlockType.Removed: gc = removedGC; break; case BlockType.Added: gc = addedGC; break; case BlockType.Info: gc = infoGC; break; default: gc = normalGC; break; } window.DrawLayout(gc, cell_area.X + 2 + LeftPaddingBlock, block.YStart, layout); } // Finally draw the change symbol at the left margin DrawChangeSymbol(ctx, cell_area.X + 1, cell_area.Width - 2, block); } // Finish the drawing of the code segment if (lastCodeSegmentStart != null) { DrawCodeSegmentBorder(infoGC, ctx, cell_area.X, cell_area.Width, lastCodeSegmentStart, lastCodeSegmentEnd, lines, widget, window); } // Draw the source line number at the current selected line. It must be done at the end because it must // be drawn over the source code text and segment borders. if (selectedLineRowTop != -1) { DrawLineBox(normalGC, ctx, ((Gtk.TreeView)widget).VisibleRect.Right - 4, selectedLineRowTop, selectedLine, widget, window); } ((IDisposable)ctx).Dispose(); removedGC.Dispose(); addedGC.Dispose(); infoGC.Dispose(); } else { // Rendering a normal text row int y = cell_area.Y + (cell_area.Height - height) / 2; window.DrawLayout(widget.Style.TextGC(GetState(widget, flags)), cell_area.X, y, layout); } }
/// <summary> /// Returns node at specified path /// </summary> public override object GetNodeAtPath (TreePath aPath) { if (DataSource == null) return (null); if (aPath.Indices.Length == 0) return (null); return (GetItemAtIndex (aPath.Indices[0])); }
/// <summary> /// Searches for node in Items /// </summary> public override TreePath PathFromNode (object aNode) { TreePath tp = new TreePath(); return (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; }
void OnTaskToggled(object o, ToggledArgs args) { Logger.Debug ("OnTaskToggled"); TreeIter iter; var path = new TreePath (args.Path); if (!model.GetIter (out iter, path)) return; // Do nothing var task = model.GetValue (iter, 0) as ITask; if (task == null) return; string statusMsg; if (task.State == TaskState.Active) { task.Complete (); statusMsg = Catalog.GetString ("Task Completed"); } else { statusMsg = Catalog.GetString ("Action Canceled"); task.Activate (); } TaskWindow.ShowStatus (statusMsg, 5); }
public PriorityColumn() { TreeViewColumn = new TreeViewColumn { Title = Catalog.GetString ("Priority"), Sizing = TreeViewColumnSizing.Fixed, Alignment = 0.5f, FixedWidth = 30, Resizable = false, Clickable = true }; var priorityStore = new ListStore (typeof (string)); priorityStore.AppendValues (Catalog.GetString ("1")); // High priorityStore.AppendValues (Catalog.GetString ("2")); // Medium priorityStore.AppendValues (Catalog.GetString ("3")); // Low priorityStore.AppendValues (Catalog.GetString ("-")); // None var renderer = new CellRendererCombo { Editable = true, HasEntry = false, Model = priorityStore, TextColumn = 0, Xalign = 0.5f }; renderer.EditingStarted += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); if (!model.GetIter (out iter, path)) return; var task = model.GetValue (iter, 0) as ITask; if (task == null) return; taskBeingEdited = new TaskBeingEdited (task, iter, path); if (CellEditingStarted != null) CellEditingStarted (this, new TaskRowEditingEventArgs (task, iter, path)); }; renderer.EditingCanceled += delegate { EndCellEditing (); }; renderer.Edited += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); if (model.GetIter (out iter, path)) { TaskPriority newPriority; var newText = args.NewText; if (newText == Catalog.GetString ("3")) newPriority = TaskPriority.Low; else if (newText == Catalog.GetString ("2")) newPriority = TaskPriority.Medium; else if (newText == Catalog.GetString ("1")) newPriority = TaskPriority.High; else newPriority = TaskPriority.None; // Update the priority if it's different var task = model.GetValue (iter, 0) as ITask; if (task.Priority != newPriority) task.Priority = newPriority; } EndCellEditing (); }; TreeViewColumn.PackStart (renderer, true); TreeViewColumn.SetCellDataFunc (renderer, TaskPriorityCellDataFunc); }
public new bool RowDraggable(TreePath path) { return(path.Depth == 2); }
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]); }
/* * Método que realiza la misma función que el método OnTreeviewNeighboursRowActivated. BOTON CONEXIÓN * */ protected void OnConnectionPngAction1Activated(object sender, EventArgs e) { TreeIter t; TreePath p = treeviewNeighbours.Selection.GetSelectedRows()[0]; this._infoNeighboursView.GetIter(out t, p); string vecino = (string)this._infoNeighboursView.GetValue(t, 0); //Comprobamos que está el usuario y si la tupla que tiene es del mismo (tipoBBDD,nombreBBDD) if (!this._messages.ContainsKey(vecino)) { this._connectionDialog = new ConnectionDialog(this._user.Nombre, vecino, null, null, this._claves); this._connectionDialog.Run(); switch (this._connectionDialog.TypeOutPut) { case Constants.CANCEL: break; case Constants.MENSAJE_CONEXION: Dictionary <string, PipeMessage> messageC = new Dictionary <string, PipeMessage>(); messageC.Add(Constants.CONNECTION, this._connectionDialog.Connection); Tuple <string, string, Dictionary <string, PipeMessage> > tupl = new Tuple <string, string, Dictionary <string, PipeMessage> >(null, null, messageC); if (!this._messages.ContainsKey(vecino)) { List <Tuple <string, string, Dictionary <string, PipeMessage> > > lista = new List <Tuple <string, string, Dictionary <string, PipeMessage> > >(); lista.Add(tupl); this._messages.Add(vecino, lista); } else { this._messages[vecino].Add(tupl); } if (!this._keyPairClients.ContainsKey(vecino)) { Tuple <RsaKeyParameters, SymmetricAlgorithm> tup = new Tuple <RsaKeyParameters, SymmetricAlgorithm>(this._connectionDialog.Connection.PublicKey, this._connectionDialog.Connection.SymmetricKey); this._keyPairClients.Add(vecino, tup); } this._neighbours.SaveNeighbourDatabases(this._connectionDialog.Connection.MessageResponse); AddValuesDatabasesNeighbours(); MostrarSolicitudConexion(this._connectionDialog.Connection.MessageRequest); MostrarConexion(this._connectionDialog.Connection.MessageResponse); IncrementarConexionesActivas(); break; case Constants.ERROR_CONNECTION: MostrarError(this._connectionDialog.TypeOutPut); break; } } }
/* * Método evento para solicitar consulta BBDD. BOTON SELECT * */ protected void OnSelectPngActionActivated(object sender, EventArgs e) { TreeIter t; TreePath p = treeviewDatabases.Selection.GetSelectedRows()[0]; this._infoBBDDView.GetIter(out t, p); string usuarioDestino = (string)this._infoBBDDView.GetValue(t, 0); string tipoBBDD = (string)this._infoBBDDView.GetValue(t, 1); string nombreBBDD = (string)this._infoBBDDView.GetValue(t, 2); //Comprobamos que está el usuario y si la tupla que tiene es del mismo (tipoBBDD,nombreBBDD) if (this._messages.ContainsKey(usuarioDestino)) { Tuple <string, string, Dictionary <string, PipeMessage> > tupla = DevuelveTupla(usuarioDestino, tipoBBDD, nombreBBDD); if (tupla != null) { int index = this._messages[usuarioDestino].IndexOf(tupla); if (ComprobarTuplaConSchema(usuarioDestino, tipoBBDD, nombreBBDD)) { PipeMessage pipeConexion = null; if (this._messages[usuarioDestino][index].Item3.ContainsKey(Constants.CONNECTION)) { pipeConexion = this._messages[usuarioDestino][index].Item3[Constants.CONNECTION]; } else { Tuple <string, string, Dictionary <string, PipeMessage> > tuplaAuxiliar = DevuelveTupla(usuarioDestino, null, null); int indexAuxiliar = this._messages[usuarioDestino].IndexOf(tuplaAuxiliar); pipeConexion = this._messages[usuarioDestino][indexAuxiliar].Item3[Constants.CONNECTION]; } PipeMessage pipeSchema = this._messages[usuarioDestino][index].Item3[Constants.SCHEMA]; this._connectionDialog = new ConnectionDialog(this._user.Nombre, usuarioDestino, tipoBBDD, nombreBBDD, pipeConexion, pipeSchema, this._claves); } } } this._connectionDialog.Run(); switch (this._connectionDialog.TypeOutPut) { case Constants.CANCEL: break; case Constants.MENSAJE_CONSULTA: Tuple <string, string, Dictionary <string, PipeMessage> > tupla = DevuelveTupla(usuarioDestino, tipoBBDD, nombreBBDD); int index = this._messages[usuarioDestino].IndexOf(tupla); if (this._messages[usuarioDestino][index].Item3.ContainsKey(Constants.SELECT)) { this._messages[usuarioDestino][index].Item3[Constants.SELECT] = this._connectionDialog.Select; } else { this._messages[usuarioDestino][index].Item3.Add(Constants.SELECT, this._connectionDialog.Select); } MostrarSolicitudConsulta(this._connectionDialog.Select.MessageRequest); MostrarResultadoConsulta(this._connectionDialog.Select.MessageRequest, this._connectionDialog.Select.MessageResponse); break; case Constants.ERROR_CONNECTION: MostrarError(this._connectionDialog.TypeOutPut); break; } }
/// <summary> /// Gets a <see cref="FileReference"/> from a given path in the tree. /// </summary> /// <param name="gameContext">The game context for the reference.</param> /// <param name="path">The path in the tree.</param> /// <returns>The FileReference pointed to by the given TreePath.</returns> public FileReference GetReferenceByPath(IGameContext gameContext, TreePath path) { GetIter(out var iter, path); return(GetReferenceByIter(gameContext, iter)); }
/* * Método evento para solicitar esquema BBDD. BOTON ESQUEMA * */ protected void OnSchemaPngActionActivated(object sender, EventArgs e) { TreeIter t; TreePath p = treeviewDatabases.Selection.GetSelectedRows()[0]; this._infoBBDDView.GetIter(out t, p); string usuarioDestino = (string)this._infoBBDDView.GetValue(t, 0); string tipoBBDD = (string)this._infoBBDDView.GetValue(t, 1); string nombreBBDD = (string)this._infoBBDDView.GetValue(t, 2); //Comprobamos que está el usuario y si la tupla que tiene es del mismo (tipoBBDD,nombreBBDD) if (this._messages.ContainsKey(usuarioDestino)) { Tuple <string, string, Dictionary <string, PipeMessage> > tupla = DevuelveTupla(usuarioDestino, tipoBBDD, nombreBBDD); if (tupla == null) { Tuple <string, string, Dictionary <string, PipeMessage> > firstTupla = DevuelvePrimeraTupla(usuarioDestino); int index = this._messages[usuarioDestino].IndexOf(firstTupla); PipeMessage pipeConexion = this._messages[usuarioDestino][index].Item3[Constants.CONNECTION]; this._connectionDialog = new ConnectionDialog(this._user.Nombre, usuarioDestino, tipoBBDD, nombreBBDD, pipeConexion, this._claves); } else { int index = this._messages[usuarioDestino].IndexOf(tupla); if (!ComprobarTuplaConSchema(usuarioDestino, tipoBBDD, nombreBBDD)) { PipeMessage pipeConexion = this._messages[usuarioDestino][index].Item3[Constants.CONNECTION]; this._connectionDialog = new ConnectionDialog(this._user.Nombre, usuarioDestino, tipoBBDD, nombreBBDD, pipeConexion, this._claves); } } } this._connectionDialog.Run(); switch (this._connectionDialog.TypeOutPut) { case Constants.CANCEL: break; case Constants.MENSAJE_ESQUEMA: if (!ComprobarTuplaConSchema(usuarioDestino, tipoBBDD, nombreBBDD)) { Tuple <string, string, Dictionary <string, PipeMessage> > tuplaa = DevuelveTupla(usuarioDestino, tipoBBDD, nombreBBDD); if (tuplaa != null) { //Añadimos un nuevo pipeMessage a la tupla existente int indexx = this._messages[usuarioDestino].IndexOf(tuplaa); this._messages[usuarioDestino][indexx].Item3.Add(Constants.SCHEMA, this._connectionDialog.Schema); } else { Tuple <string, string, Dictionary <string, PipeMessage> > tuplaDiferente = DevuelvePrimeraTupla(usuarioDestino); //Añadimos una nueva tupla Dictionary <string, PipeMessage> diccionarioNuevo = new Dictionary <string, PipeMessage>(); //diccionarioNuevo.Add(Constants.CONNECTION, tuplaDiferente.Item3[Constants.CONNECTION]); diccionarioNuevo.Add(Constants.SCHEMA, this._connectionDialog.Schema); Tuple <string, string, Dictionary <string, PipeMessage> > tuplaNueva = new Tuple <string, string, Dictionary <string, PipeMessage> >(tipoBBDD, nombreBBDD, diccionarioNuevo); this._messages[usuarioDestino].Add(tuplaNueva); } } MostrarSolicitudEsquema(this._connectionDialog.Schema.MessageRequest); MostrarEsquema(this._connectionDialog.Schema.MessageResponse); break; case Constants.ERROR_CONNECTION: MostrarError(this._connectionDialog.TypeOutPut); break; } }
bool IsIterSelected(TreePath selPath, TreeIter iter) { return(selPath != null && store.GetPath(iter).Equals(selPath)); }
/// <summary> /// Sets the active document as selected by the user /// </summary> private bool HandleDocumentSelected(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected) { int index = path.Indices[0]; if (!path_currently_selected && index != PintaCore.Workspace.ActiveDocumentIndex) { PintaCore.Workspace.SetActiveDocument(index); } return(true); }
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(); } }
public void Remove(ObservingGamePage page) { // remove page int num = gamesBook.PageNum (page); // unobserve TreePath path = new TreePath (new int[]{ num }); TreeIter iter; gamesStore.GetIter (out iter, path); gamesStore.Remove (ref iter); if (page.NeedsUnobserve) client.CommandSender. SendCommand ("unobserve " + page.GameId); gamesBook.RemovePage (num); currentGames.Remove (page.GameId); AdjustCursorForCurrentPage (); if (GamePageRemovedEvent != null) GamePageRemovedEvent (this, EventArgs. Empty); }
private bool PathIsValid(TreePath path) { return(PathIsValid(path, n_cells)); }
public void Update(MoveDetails details) { if (!currentGames. ContainsKey (details.gameNumber)) { AddGamePage (details); return; } ObservingGamePage info = (ObservingGamePage) currentGames[details.gameNumber]; info.Update (details); int num = gamesBook.PageNum (info); if (num == gamesBook.CurrentPage) return; TreePath path = new TreePath (new int[]{ num }); TreeIter iter; gamesStore.GetIter (out iter, path); string text = (string) gamesStore.GetValue (iter, 1); string markup = String.Format ("<b>{0}</b>", text); gamesStore.SetValue (iter, 0, markup); }
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(); }
public static void Serialize(TreePath value, TextWriter sw) { sw.Write('"'); sw.Write(value.ToString()); sw.Write('"'); }
public bool PathIsSelected(TreePath path) { return(selected_paths.Contains(path)); }
public TaskNameColumn() { TreeViewColumn = new TreeViewColumn { Title = Catalog.GetString ("Task Name"), Sizing = TreeViewColumnSizing.Autosize, Expand = true, Resizable = true }; // TODO: Add in code to determine how wide we should make the name // column. // TODO: Add in code to readjust the size of the name column if the // user resizes the Task Window. //column.FixedWidth = 250; var renderer = new CellRendererText { Editable = true }; renderer.EditingStarted += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); if (!model.GetIter (out iter, path)) return; var task = model.GetValue (iter, 0) as ITask; if (task == null) return; taskBeingEdited = new TaskBeingEdited (task, iter, path); if (CellEditingStarted != null) CellEditingStarted (this, new TaskRowEditingEventArgs (task, iter, path)); }; renderer.EditingCanceled += delegate { EndCellEditing (); }; renderer.Edited += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); if (model.GetIter (out iter, path)) { var task = model.GetValue (iter, 0) as ITask; if (task == null) return; var newText = args.NewText; // Attempt to derive due date information from text. if (preferences.GetBool (PreferencesKeys.ParseDateEnabledKey) && task.State == TaskState.Active && task.DueDate == DateTime.MinValue) { string parsedTaskText; DateTime parsedDueDate; TaskParser.Instance.TryParse (newText, out parsedTaskText, out parsedDueDate); if (parsedDueDate != DateTime.MinValue) task.DueDate = parsedDueDate; newText = parsedTaskText; } task.Text = newText; } EndCellEditing (); }; TreeViewColumn.PackStart (renderer, true); TreeViewColumn.SetCellDataFunc (renderer, TaskNameTextCellDataFunc); }
public void ScrollToPath(TreePath path) { ScrollToPath(path, false, 0f, 0f); }
/// <summary> /// Searches for node in Items /// </summary> public override TreePath PathFromNode (object aNode) { TreePath tp = new TreePath(); if ((aNode == null) || (DataSource == null) || (GetItemCount() == 0)) return (tp); int idx = GetItemIndex (aNode); if (idx >= 0) tp.AppendIndex (idx); return (tp); }
public void ScrollToPath(TreePath path, float row_align, float col_align) { ScrollToPath(path, true, row_align, col_align); }
private void WhiteMove(MoveDetails details) { TreeIter iter; TreePath path; if (FindMoveRow (details.movenumber, out path, out iter)) { store.SetValue (iter, WHITE_MOVE_COL, GetMove (details)); store.SetValue (iter, WHITE_MOVE_DETAILS_COL, details); } else { iter = store.AppendValues (details. movenumber, GetMove (details), null, details, null); path = new TreePath (new int[] { total_rows}); total_rows++; } blacksMoveNext = true; if (!autoAppend) return; SetHighlighted (iter, path.Indices[0], WHITE_MOVE_COL); ScrollToCell (path, GetColumn (WHITE_MOVE_COL), false, 0, 0); }
protected override bool OnKeyPressEvent(Gdk.EventKey ev) { if (model == null) { return(false); } int r, c; TreePath tmp; // Lame workaround for GtkBinding not being bound switch (ev.Key) { // Activate keycodes case Gdk.Key.space: case Gdk.Key.Return: case Gdk.Key.ISO_Enter: case Gdk.Key.KP_Enter: // Remove this when we can use OnActivate () if (focused_path == null) { return(false); } if ((ev.State & Gdk.ModifierType.ControlMask) == 0) { UnselectAll(); } if (selected_paths.Contains(focused_path)) { UnselectPath(focused_path); } else { SelectPath(focused_path); } if (ItemActivated != null) { ItemActivatedArgs activated_args = new ItemActivatedArgs(); activated_args.Args = new object[] { focused_path }; ItemActivated(this, activated_args); } return(true); case Gdk.Key.a: // if control down, select all if (selection_mode == SelectionMode.Multiple && (ev.State & Gdk.ModifierType.ControlMask) > 0) { SelectAll(); } return(true); case Gdk.Key.A: // if control down and shift down, unselect all if (selection_mode == SelectionMode.Multiple && (ev.State & Gdk.ModifierType.ControlMask) > 0 && (ev.State & Gdk.ModifierType.ShiftMask) > 0) { UnselectAll(); } return(true); case Gdk.Key.Up: case Gdk.Key.KP_Up: // Move focus or selection up if (layout_mode == LayoutMode.Vertical || layout_mode == LayoutMode.Grid) { // find out the currently focused r and c GetRowAndColForPath(focused_path, out r, out c); // decrement the row by 1 if (r > 0) { r--; // find the path at new r, c if (GetPathAtRowAndCol(r, c, out tmp)) { focused_path = tmp; } } } break; case Gdk.Key.Down: case Gdk.Key.KP_Down: // move down if (layout_mode == LayoutMode.Vertical || layout_mode == LayoutMode.Grid) { // find out the currently focused r and c GetRowAndColForPath(focused_path, out r, out c); // increment the row by 1 r++; // find the path at new r, c if (GetPathAtRowAndCol(r, c, out tmp)) { focused_path = tmp; } } break; case Gdk.Key.Left: case Gdk.Key.KP_Left: // move left if (layout_mode == LayoutMode.Horizontal || layout_mode == LayoutMode.Grid) { tmp = focused_path.Copy(); // don't wrap around if (tmp.Prev()) { focused_path = tmp; } } break; case Gdk.Key.Right: case Gdk.Key.KP_Right: // move right if (layout_mode == LayoutMode.Horizontal || layout_mode == LayoutMode.Grid) { tmp = focused_path.Copy(); tmp.Next(); if (PathIsValid(tmp)) { focused_path = tmp; } } break; case Gdk.Key.Home: case Gdk.Key.KP_Home: // select and focus the first item, dropping // current selection tmp = TreePath.NewFirst(); // verify that the path is valid if (PathIsValid(tmp)) { selected_paths.Clear(); focused_path = tmp; SelectPath(focused_path); } return(true); case Gdk.Key.End: case Gdk.Key.KP_End: // select and focus the first item, dropping // current selection tmp = new TreePath(new int[] { n_cells - 1 }); // verify that the path is valid if (PathIsValid(tmp)) { selected_paths.Clear(); focused_path = tmp; SelectPath(focused_path); } return(true); } if (selection_mode == SelectionMode.Multiple && (ev.State & Gdk.ModifierType.ShiftMask) > 0) { selected_paths.Clear(); SelectAllBetween(selection_anchor, focused_path); return(true); } if (selection_mode == SelectionMode.Browse) { SelectPath(focused_path); } else { // TODO: Constrain this to only the previous focus and QueueDraw(); } return(true); }
private MoveDetails GetMove(int row, int col) { // now check if this is present int idx = col == WHITE_MOVE_COL ? WHITE_MOVE_DETAILS_COL : BLACK_MOVE_DETAILS_COL; TreePath path = new TreePath (new int[]{ row }); TreeIter iter; if (!store.GetIter (out iter, path)) return null; MoveDetails details = store.GetValue (iter, idx) as MoveDetails; if (details == null) return null; SetHighlighted (iter, row, col); autoAppend = IsLastMove (row, col); ScrollToCell (path, GetColumn (col), false, 0, 0); return details; }
protected override bool OnMotionNotifyEvent(Gdk.EventMotion ev) { if (!have_rubberband_selection) { return(false); } int x, y; Gdk.ModifierType state; if (ev.IsHint) { GdkWindow.GetPointer(out x, out y, out state); } else { x = (int)ev.X; y = (int)ev.Y; state = ev.State; } if (hadj != null) { x += (int)hadj.Value; } if (vadj != null) { y += (int)vadj.Value; } sel_rect.X = Math.Min(sel_start.X, x); sel_rect.Y = Math.Min(sel_start.Y, y); sel_rect.Width = Math.Abs(sel_start.X - x); sel_rect.Height = Math.Abs(sel_start.Y - y); ArrayList tmp; if ((ev.State & Gdk.ModifierType.ControlMask) > 0) { tmp = (ArrayList)pre_rubberbanded_selection.Clone(); } else { tmp = new ArrayList(); } for (int i = 0; i < n_cells; i++) { GetCellPosition(i, out x, out y); cell_size.X = x; cell_size.Y = y; if (!cell_size.IntersectsWith(sel_rect)) { continue; } TreePath new_path = new TreePath(new int[] { i }); if ((ev.State & Gdk.ModifierType.ControlMask) > 0) { // If control is down and we highlight // something that was selected before we // started rubberbanding, deselect it int index = tmp.IndexOf(new_path); if (index >= 0) { tmp.RemoveAt(index); continue; } } tmp.Add(new_path); } // find out if selection has changed since last time bool dirty = false; if (selected_paths.Count != tmp.Count) { dirty = true; } else { for (int i = 0; i < selected_paths.Count; i++) { if (!((TreePath)selected_paths[i]).Equals((TreePath)tmp[i])) { dirty = true; break; } } } selected_paths = tmp; if (dirty && SelectionChanged != null) { SelectionChanged(this, new EventArgs()); } QueueDraw(); return(true); }
static bool TreeViewSelection(TreeSelection selection, TreeModel model, TreePath path, bool path_currently_selected) { return(false); }
void CellRendererEdited(CellRendererTextAdv sender, string pathStr, string newText, int colNum) { TreeModelSort model = (TreeModelSort)treeDebaters.Model; TreePath path = new TreePath(pathStr); TreeIter iter = TreeIter.Zero; model.GetIter(out iter, path); EditableDebater d = (EditableDebater)model.GetValue(iter, 0); try { ColumnInfo prop = columns[treeDebaters.Columns[colNum].Title]; // This parses the given new string, // and updates the data in store prop.parseAndSet(d, newText); // existing Debater: Update Data in (possibly) existing Rounds // tries to keep data consisting, but there's no guarantee // BlackList/WhiteList and ExtraInfo are not // used in RoundDebater, so skip this by condition colNum<4 if (newDebaterPath == null && colNum < 4) { var rd = new EditableDebater(d); var p = prop.get(d); // Only simple Renaming of Role is possible if Rounds exist if (colNum == 3 && Tournament.I.Rounds.Count > 0 && ((d.Role.IsTeamMember != rd.Role.IsTeamMember) || (d.Role.IsJudge != rd.Role.IsJudge))) { MiscHelpers.ShowMessage(this, "Changing Role from Judge to TeamMember (or vice versa)" + " is not possible since Rounds are already set.", MessageType.Error); // reset to old role... d.Role = rd.Role; return; } // check if new TeamName is already present if (colNum == 3 && d.Role.IsTeamMember) { int n = 0; foreach (object[] row in store) { EditableDebater d_ = (EditableDebater)row[0]; if (!d.Equals(d_) && d_.Role.TeamName == d.Role.TeamName) { n++; } } if (n == 3) { MiscHelpers.ShowMessage(this, "New TeamName is already present in three other Debaters.", MessageType.Error); // reset to old role... d.Role = rd.Role; return; } } // check for duplicate if (colNum < 3) { // need a temporary flag, throwing exceptions in delegates doesnt work... // the following flag stuff isn't elegant, but it should work bool flag = false; model.Foreach((model_, _, iter_) => { if (!iter.Equals(iter_)) { EditableDebater d_ = (EditableDebater)model_.GetValue(iter_, 0); if (d_.Equals(d)) { // reset to old value... prop.get(rd).Set(d); flag = true; return(true); } } return(false); }); if (flag) { throw new TargetInvocationException(new Exception("Debater exists.")); } } // keep data consistent in existing rounds foreach (RoundData round in Tournament.I.Rounds) { foreach (RoomData room in round.Rooms) { foreach (RoundDebater rd_ in room.GetRoomMembers()) { if (rd_ == null) { continue; } if (rd_.Equals(rd)) { p.UnsafeSetRoundDebater(rd_); } if (rd_.Role.TeamName == rd.Role.TeamName) { rd_.Role.TeamName = d.Role.TeamName; } } } if (rd.Role.IsTeamMember) { foreach (TeamData team in round.AllTeams) { foreach (RoundDebater rd_ in team) { if (rd_.Equals(rd)) { p.UnsafeSetRoundDebater(rd_); } if (rd_.Role.TeamName == rd.Role.TeamName) { rd_.Role.TeamName = d.Role.TeamName; } } } } else if (rd.Role.IsJudge) { foreach (RoundDebater rd_ in round.AllJudges) { if (rd_.Equals(rd)) { p.UnsafeSetRoundDebater(rd_); } } } } // Renaming TeamName needs extra Handling if (colNum == 3 && rd.Role.IsTeamMember && d.Role.IsTeamMember) { foreach (object[] row in store) { EditableDebater d_ = (EditableDebater)row[0]; if (d_.Role.TeamName == rd.Role.TeamName) { d_.Role.TeamName = d.Role.TeamName; } } } } // newDebater is entered... else if (newDebaterPath != null && colNum < 3) { // continue with entering data (goto next column) // as idle so that cells are resized GLib.Idle.Add(delegate { treeDebaters.SetCursor(ConvertStorePathToModelPath(newDebaterPath), treeDebaters.Columns[colNum + 1], true); return(false); }); } else if (newDebaterPath != null) { // new Debater entered completely (at least all necessary data) iter = TreeIter.Zero; if (store.GetIter(out iter, newDebaterPath)) { // as idle to prevent gtk critical (no idea why this happens) GLib.Idle.Add(delegate { store.Remove(ref iter); newDebaterPath = null; if (IsNotInStore(d)) { store.AppendValues(d); SaveDebaters(); } else { MiscHelpers.ShowMessage(this, "Debater exists.", MessageType.Error); } UpdateDebatersInfo(); btnDebaterAdd.GrabFocus(); return(false); }); } } // Gui stuff treeDebaters.ColumnsAutosize(); // ugly method of resorting the TreeSortModel... SortType st; int sortColumn; model.GetSortColumnId(out sortColumn, out st); if (st == SortType.Descending) { model.SetSortColumnId(sortColumn, SortType.Ascending); model.SetSortColumnId(sortColumn, SortType.Descending); } else { model.SetSortColumnId(sortColumn, SortType.Descending); model.SetSortColumnId(sortColumn, SortType.Ascending); } // save data from store if not adding new debater if (newDebaterPath == null) { SaveDebaters(); } } catch (TargetInvocationException e) { MessageDialog md = new MessageDialog(this, DialogFlags.Modal, MessageType.Error, ButtonsType.OkCancel, e.InnerException.Message + ". Try again?"); md.DefaultResponse = ResponseType.Ok; ResponseType r = (ResponseType)md.Run(); md.Destroy(); if (r == ResponseType.Ok) { // As Idle otherwise Editable isn't destroyed correctly GLib.Idle.Add(delegate { sender.TempEditString = newText; treeDebaters.SetCursor(path, treeDebaters.Columns[colNum], true); return(false); }); } else { if (newDebaterPath == null) { return; } iter = TreeIter.Zero; if (store.GetIter(out iter, newDebaterPath)) { // remove not finished new debater, // with idle call, // prevents Gtk critical filter model assertion. GLib.Idle.Add(delegate { newDebaterPath = null; store.Remove(ref iter); return(false); }); } } } }
/// <summary> /// Returns node at specified path /// </summary> public override object GetNodeAtPath (TreePath aPath) { return (null); }
public bool IsLeaf(TreePath treePath) { return(((CrackNode)treePath.LastNode).Children.Count == 0); }
public DueDateColumn() { TreeViewColumn = new TreeViewColumn { Title = Catalog.GetString ("Due Date"), Sizing = TreeViewColumnSizing.Fixed, Alignment = 0f, FixedWidth = 90, Resizable = false, Clickable = true }; var dueDateStore = new ListStore (typeof (string)); var today = DateTime.Now; dueDateStore.AppendValues ( today.ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Today")); dueDateStore.AppendValues ( today.AddDays (1).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Tomorrow")); dueDateStore.AppendValues ( today.AddDays (2).ToString (Catalog.GetString ("M/d - ddd"))); dueDateStore.AppendValues ( today.AddDays (3).ToString (Catalog.GetString ("M/d - ddd"))); dueDateStore.AppendValues ( today.AddDays (4).ToString (Catalog.GetString ("M/d - ddd"))); dueDateStore.AppendValues ( today.AddDays (5).ToString (Catalog.GetString ("M/d - ddd"))); dueDateStore.AppendValues ( today.AddDays (6).ToString (Catalog.GetString ("M/d - ddd"))); dueDateStore.AppendValues ( today.AddDays (7).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("In 1 Week")); dueDateStore.AppendValues (Catalog.GetString ("No Date")); dueDateStore.AppendValues (Catalog.GetString ("Choose Date...")); var renderer = new CellRendererCombo { Editable = true, HasEntry = false, Model = dueDateStore, TextColumn = 0, Xalign = 0.0f }; renderer.EditingStarted += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); if (!model.GetIter (out iter, path)) return; var task = model.GetValue (iter, 0) as ITask; if (task == null) return; taskBeingEdited = new TaskBeingEdited (task, iter, path); if (CellEditingStarted != null) CellEditingStarted (this, new TaskRowEditingEventArgs (task, iter, path)); }; renderer.EditingCanceled += delegate { EndCellEditing (); }; renderer.Edited += (o, args) => { TreeIter iter; var path = new TreePath (args.Path); var newText = args.NewText; if (newText != null && model.GetIter (out iter, path)) { // 2/11 - Today // 2/12 - Tomorrow // 2/13 - Wed // 2/14 - Thu // 2/15 - Fri // 2/16 - Sat // 2/17 - Sun // -------------- // 2/18 - In 1 Week // -------------- // No Date // --------------- // Choose Date... var newDate = DateTime.MinValue; var tday = DateTime.Now; var task = model.GetValue (iter, 0) as ITask; if (newText == tday.ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Today")) newDate = tday; else if (newText == tday.AddDays (1).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Tomorrow")) newDate = tday.AddDays (1); else if (newText == Catalog.GetString ("No Date")) newDate = DateTime.MinValue; else if (newText == tday.AddDays (7).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("In 1 Week")) newDate = tday.AddDays (7); else if (newText == Catalog.GetString ("Choose Date...")) { var tc = new TaskCalendar (task, view.TreeView.Parent); tc.ShowCalendar (); return; } else { for (int i = 2; i <= 6; i++) { DateTime testDate = tday.AddDays (i); if (testDate.ToString (Catalog.GetString ("M/d - ddd")) == newText) { newDate = testDate; break; } } } Logger.Debug ("task.State {0}", task.State); if (task.State != TaskState.Completed) { // Modify the due date task.DueDate = newDate; } } EndCellEditing (); }; TreeViewColumn.PackStart (renderer, true); TreeViewColumn.SetCellDataFunc (renderer, DueDateCellDataFunc); }
public System.Collections.IEnumerable GetChildren(TreePath treePath) { return(Children); }
private void OnCursorChanged(object o, System.EventArgs args) { TreePath path; TreeViewColumn col; view.GetCursor (out path, out col); ArrayList moves = new ArrayList (); TreePath tmppath = new TreePath (); foreach (int i in path.Indices) { tmppath.AppendIndex (i); TreeIter iter; store.GetIter (out iter, tmppath); moves.Add (store.GetValue (iter, 0)); } boardWidget.PlayMoves (moves); }
//UPGRADE_NOTE: The equivalent of method 'javax.swing.tree.TreeModel.valueForPathChanged' is not an override method. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1143_3"' //UPGRADE_ISSUE: Class 'javax.swing.tree.TreePath' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javaxswingtreeTreePath_3"' public virtual void valueForPathChanged(TreePath path, System.Object newValue) { System.Console.Out.WriteLine("heh, who is calling this mystery method?"); }