TaskBindingTreeNode AddBindingsTreeNode(TaskRunnerBindEvent bindEvent)
{
var node = new TaskBindingTreeNode(bindEvent);
TreeNavigator navigator = bindingsTreeStore.AddNode();
navigator.SetValue(bindingNodeNameField, node.Name);
navigator.SetValue(bindingNodeField, node);
return(node);
}
void SetNodeText(TreeNavigator nav, string text, TextSpan span, Color color, object node)
{
nav.SetValues(
markupField,
$"<span color='{color.ToHexString ()}'>{GLib.Markup.EscapeText (text)} [{span.Start}-{span.End}]</span>",
spanField,
span,
nodeField,
node
);
}
TreePosition AddInteraction(TreePosition category, string name, Interaction interaction)
{
Sample sample = new Sample(category, name, interaction);
TreeNavigator node = store.AddNode(category);
TreeNavigator nameNavigator = node.SetValue(nameCol, name);
TreeNavigator iconNavigator = nameNavigator.SetValue(iconCol, icon);
TreeNavigator sampleNavigator = iconNavigator.SetValue(sampleCol, sample);
return(sampleNavigator.CurrentPosition);
}
void UpdateChildrenForRootCheck(TreeNavigator rootnode, CheckBoxState newCheck)
{
if (!rootnode.MoveToChild())
{
return;
}
do
{
rootnode.SetValue(nodeCheck, newCheck);
} while (rootnode.MoveNext());
}
public void AddChildTemplateCategory(
TemplateCategoryViewModel parentCategory,
TemplateCategoryViewModel category)
{
TreeNavigator navigator = FindCategoryNavigator(parentCategory);
if (navigator != null)
{
AddTemplateCategory(navigator.CurrentPosition, category);
treeView.ExpandRow(navigator.CurrentPosition, true);
}
}
private void TreenavigatorItemsUpdate(TreeNavigator sender, SelectionStateChangedEventArgs e)
{
TreeNavigator tree = sender as TreeNavigator;
int i = 2;
if (e.SelectedItem.Text.Equals("Desktop"))
{
string[] folders = System.IO.Directory.GetDirectories(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "*", System.IO.SearchOption.TopDirectoryOnly);
foreach (string folder in folders)
{
(tree.Items[0] as TreeMenuItem).Items.Add(new TreeMenuItem()
{
Text = folder
});
}
}
if (e.SelectedItem.Text.Equals("Documents"))
{
string[] folders = System.IO.Directory.GetDirectories(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "*", System.IO.SearchOption.TopDirectoryOnly);
foreach (string folder in folders)
{
(tree.Items[1] as TreeMenuItem).Items.Add(new TreeMenuItem()
{
Text = folder
});
}
}
foreach (string s in drives)
{
if (s.Equals(e.SelectedItem.Text))
{
string[] folders = System.IO.Directory.GetDirectories(s, "*", SearchOption.TopDirectoryOnly);
foreach (string folder in folders)
{
DirectoryInfo info = new DirectoryInfo(folder);
try
{
if ((info.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden || (info.Attributes & FileAttributes.System) != FileAttributes.System)
{
(tree.Items[i] as TreeMenuItem).Items.Add(new TreeMenuItem()
{
Text = folder
});
}
}
catch (UnauthorizedAccessException)
{
}
}
}
i++;
}
}
void AddTaskChildNodes(TreeNavigator navigator, TaskRunnerTreeNode node)
{
foreach (TaskRunnerTreeNode childNode in node.GetChildNodes())
{
TreeNavigator childNavigator = navigator.AddChild();
childNavigator.SetValue(taskRunnerNodeNameField, childNode.Name);
childNavigator.SetValue(taskRunnerField, childNode);
AddTaskChildNodes(childNavigator, childNode);
navigator.MoveToParent();
}
}
void LoadModes()
{
storeModes.Clear();
var currentMode = SelectedExecutionMode;
bool nodeSelected = false;
var ctx = new CommandExecutionContext(item, h => item.CanExecute(new ExecutionContext(h, null, IdeApp.Workspace.ActiveExecutionTarget), IdeApp.Workspace.ActiveConfiguration, SelectedConfiguration));
foreach (var modeSet in Runtime.ProcessService.GetExecutionModes())
{
TreeNavigator setNode = null;
foreach (var mode in modeSet.ExecutionModes)
{
if (ctx.CanExecute(mode.ExecutionHandler))
{
if (setNode == null)
{
setNode = storeModes.AddNode();
setNode.SetValue(modeNameField, modeSet.Name);
setNode.SetValue(modeField, mode);
setNode.SetValue(modeSetField, modeSet);
if (mode.Id == currentMode?.Id)
{
treeModes.SelectRow(setNode.CurrentPosition);
nodeSelected = true;
}
}
var node = storeModes.AddNode(setNode.CurrentPosition);
node.SetValue(modeNameField, mode.Name);
node.SetValue(modeField, mode);
node.SetValue(modeSetField, modeSet);
if (!nodeSelected && mode.Id == currentMode?.Id)
{
treeModes.SelectRow(node.CurrentPosition);
nodeSelected = true;
}
}
}
// If the mode only has one child, remove it, we don't need to show it
if (setNode != null && setNode.MoveToChild())
{
var pos = setNode.Clone();
if (!setNode.MoveNext())
{
pos.Remove();
}
}
}
if (!nodeSelected && storeModes.GetFirstNode()?.CurrentPosition != null)
{
treeModes.SelectRow(storeModes.GetFirstNode().CurrentPosition);
}
}
void SelectAlgorithm(AlgorithmInfo algorithm)
{
TreeNavigator nav = store.GetFirstNode();
do
{
if (nav.GetValue(infoCol) == algorithm)
{
algorithmTree.SelectRow(nav.CurrentPosition);
break;
}
} while (nav.MoveNext());
}
public void AddItem(TreeNavigator root, IProjectItem citem, string path, string currentPath)
{
var split = path.Split('/');
var item = GetorAddItem(root, split.Length > 1 ? new DirectoryItem(split[0], currentPath)
{
Exists = citem.Exists
} : citem);
if (path.Contains("/"))
{
AddItem(item, citem, string.Join("/", split, 1, split.Length - 1), (currentPath + Path.DirectorySeparatorChar + split[0]));
}
}
public static void ShowToken(IApp app, IDataModel model, IPEImage image, MDToken token)
{
TreeNavigator.Create()
.Path <dnModuleModel>(m => m.Module.Image == image ? NavigationState.In : NavigationState.Next)
.Path <MetaDataModel>(m => NavigationState.In)
.Path <MDTablesStreamModel>(m => NavigationState.In)
.Path <MDTableHeapModel>(m => NavigationState.Done)
.Handler(node => {
var targetView = (MDTableHeapView)app.Views.LocateViews(node.Model).Single();
targetView.SelectItem(token);
})
.Goto(model);
}
private TreeNavigator setData(TreeNavigator tn, object[] data)
{
TreeNavigator ret = null;
int i = 0;
foreach (DatafieldContainer dc in Fields)
{
ret = SetValue(tn, new object[] { dc.Field, data[i] }, dc.Typename);
i++;
}
return(ret);
}
public void AddTopLevelCategory(TemplateCategoryViewModel category)
{
TreePosition position = AddTemplateCategory(null, category);
treeView.ExpandRow(position, true);
// Ensure last child is visible and selected.
TreeNavigator navigator = treeStore.GetNavigatorAt(position);
navigator.MoveToChild();
navigator.MoveToChild();
treeView.ScrollToRow(navigator.CurrentPosition);
treeView.SelectRow(navigator.CurrentPosition);
}
private void treeNavigator1_SelectionChanged(TreeNavigator sender, SelectionStateChangedEventArgs e)
{
if (e.SelectedItem == thisPCtreeMenuItem)
{
groupView1.Visible = false;
openTabPCPanel.Visible = true;
FillThisPCItems(this.treeNavigator4);
}
else
{
groupView1.Visible = true;
openTabPCPanel.Visible = false;
}
}
void HandleSamplesTreeSelectionChanged(object sender, EventArgs e)
{
if (samplesTree.SelectedRow != null)
{
// Remove currentInteraction if there is one
if (currentInteraction != null)
{
// must already have a valid plot sample with the interaction added to it
PlotSample ps = (PlotSample)currentWidget;
PlotCanvas pc = ps.PlotCanvas;
// Remove current interaction from PlotCanvas
pc.RemoveInteraction(currentInteraction);
currentInteraction = null;
}
// get newSample from selected row
TreePosition viewRow = samplesTree.SelectedRow;
TreeNavigator storeRow = store.GetNavigatorAt(viewRow);
Sample newSample = storeRow.GetValue(sampleCol);
TreePosition newCategory = newSample.Category;
if (newCategory == interactionCategory)
{
// only allow interaction if there is already a plotSample
if (currentCategory == plotCategory)
{
PlotSample ps = (PlotSample)currentWidget;
PlotCanvas pc = ps.PlotCanvas;
// Add new interaction to existing PlotCanvas
currentInteraction = newSample.Interaction;
pc.AddInteraction(currentInteraction);
}
}
else
{
// plotCategory or testCategory
currentCategory = newCategory;
if (currentWidget != null)
{
sampleBox.Remove(currentWidget);
}
if (newSample.Type != null)
{
currentWidget = (Widget)Activator.CreateInstance(newSample.Type);
sampleBox.PackStart(currentWidget, true);
Dump(currentWidget, 0);
}
}
}
}
void SetTreeNodeValues(TreeNavigator navigator, BaseViewModel viewModel)
{
if (viewModel is NodeViewModel nodeViewModel)
{
navigator.SetValue(textDataField, GetTreeNodeText(nodeViewModel));
navigator.SetValue(imageDataField, GetTreeNodeImage(nodeViewModel));
}
else
{
navigator.SetValue(textDataField, GLib.Markup.EscapeText(viewModel.Text));
}
navigator.SetValue(viewModelDataField, viewModel);
}
{
saveAs();
}
/// <summary>
/// remove the selected files from the treestore
/// </summary>
/// <param name='sender'>
/// Sender.
/// </param>
/// <param name='e'>
/// E.
/// </param>
void HandleBtnRemoveClicked (object sender, EventArgs e)
{
// TreePosition[] tp = Treeview1.SelectedRows;
// foreach (TreePosition p in tp)
// {
// TsData.GetNavigatorAt(p).Remove();
// }
TreeNavigator tn = TsData.GetFirstNode();
do
{
public TreeNavigator InitNode(BaseItem documentItem, TreeNavigator paretn = null)
{
var tn = paretn == null?Store.AddNode() : Store.AddNode(paretn.CurrentPosition);
tn.SetValues(dfName, documentItem.GetType().FullName,
dfTag, documentItem);
if (documentItem is DocumentElementCollection)
{
foreach (BaseItem item in (DocumentElementCollection)documentItem)
{
InitNode(item, tn);
}
}
return(tn);
}
void SetNode(TreeNavigator navigator, IIssueTreeNode node)
{
if (navigator == null)
{
throw new ArgumentNullException("navigator");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
navigator.SetValue(nodeField, node);
Debug.Assert(!nodePositions.ContainsKey(node));
var position = navigator.CurrentPosition;
nodePositions.Add(node, position);
node.ChildAdded += (sender, e) => {
Debug.Assert(e.Parent == node);
Application.Invoke(delegate {
var newNavigator = store.GetNavigatorAt(position);
newNavigator.AddChild();
SetNode(newNavigator, e.Child);
SyncNode(newNavigator);
});
};
node.ChildrenInvalidated += (sender, e) => {
Application.Invoke(delegate {
SyncNode(store.GetNavigatorAt(position));
});
};
node.TextChanged += (sender, e) => {
lock (queueLock) {
if (!updateQueue.Contains(e.Node))
{
updateQueue.Enqueue(e.Node);
}
}
};
node.VisibleChanged += (sender, e) => {
lock (queueLock) {
if (!updateQueue.Contains(e.Node))
{
updateQueue.Enqueue(e.Node);
}
}
};
}
TaskRunnerTreeNode GetTaskRunnerTreeNode(TreePosition position)
{
if (position == null)
{
return(null);
}
TreeNavigator navigator = tasksTreeStore.GetNavigatorAt(position);
if (navigator == null)
{
return(null);
}
return(navigator.GetValue(taskRunnerField));
}
protected object GetValue(TreeNavigator navigator, String fieldname)
{
if (navigator.CurrentPosition == null)
{
return(null);
}
foreach (DatafieldContainer df in Fields)
{
if (df.Title.Equals(fieldname, StringComparison.OrdinalIgnoreCase))
{
return(GetValue(navigator, df.Field, df.Typename));
}
}
return(null);
}
void AddTaskNodes(TaskRunnerInformation task)
{
var rootNode = new TaskRunnerTreeNode(task);
TreeNavigator navigator = tasksTreeStore.AddNode();
IconId icon = rootNode.Icon;
if (!icon.IsNull)
{
navigator.SetValue(taskRunnerNodeIconField, ImageService.GetIcon(icon, Gtk.IconSize.Menu));
}
navigator.SetValue(taskRunnerNodeNameField, rootNode.Name);
navigator.SetValue(taskRunnerField, rootNode);
AddTaskChildNodes(navigator, rootNode);
}
BaseViewModel GetBaseViewModel(TreePosition position)
{
if (position == null)
{
return(null);
}
TreeNavigator navigator = treeStore.GetNavigatorAt(position);
if (navigator == null)
{
return(null);
}
return(navigator.GetValue(viewModelDataField));
}
public void SelectItem(MDToken token)
{
var table = Model.Stream.Get(token.Table);
var rid = token.Rid;
if (table == null || !table.IsValidRID(rid))
{
MessageBox.Show("Invalid token.", App.AppName, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
TreeNavigator.Create()
.Path <MDTableModel>(m => m.MDTable == table ? NavigationState.In : NavigationState.Next)
.Path <MDRowModel>(m => m.Rid == rid ? NavigationState.Done : NavigationState.Next)
.Goto(treeView);
}
private bool FindItem(TreeNavigator root, string path, out TreeNavigator item)
{
var split = path.Split('/');
if (GetItem(root, split[0], out item))
{
if (split.Length != 1)
{
return(FindItem(item, string.Join("/", split, 1, split.Length - 1), out item));
}
return(true);
}
return(false);
}
TreePosition AddTemplateCategory(
TreePosition position,
TemplateCategoryViewModel categoryViewModel)
{
TreeNavigator node = treeStore.AddNode(position);
node.SetValue(nameColumn, categoryViewModel.GetNameWithIsNewMessage());
node.SetValue(categoryColumn, categoryViewModel);
foreach (TemplateCategoryViewModel childCategory in categoryViewModel.GetChildCategories())
{
AddTemplateCategory(node.CurrentPosition, childCategory);
}
return(node.CurrentPosition);
}
TaskBindingTreeNode GetBindingTreeNode(TreePosition position)
{
if (position == null)
{
return(null);
}
TreeNavigator navigator = bindingsTreeStore.GetNavigatorAt(position);
if (navigator == null)
{
return(null);
}
return(navigator.GetValue(bindingNodeField));
}
// void HandleButtonPressed (object sender, ButtonEventArgs e)
// {
// if (e.MultiplePress == 2)
// {
// TreeView tv = sender as TreeView;
//
// TreePosition tp = tv.SelectedRow;
// TreeNavigator tn = DataStore.GetNavigatorAt (tp);
// //SetValue(tn,new object[] { true },"System.Boolean");
//
// //SetValue(tn,
//
// SetValue(tn,new object[] {Fields[2].Field,true},"System.Boolean");
//
//
// //Tree.Columns[0].Views[0]
// }
//
// }
public override void afterSetData(VirtualGridRow row, string columnName, object data)
{
base.afterSetData(row, columnName, data);
if (data == null)
{
throw new Exception("data is null");
}
TreeNavigator tn = GetNavigator(row);
if (tn != null)
{
SetValue(tn, columnName, data);
}
}
void UpdateNextChildrenOffset(TreeNavigator node, CheckBoxState newCheck)
{
var iter = node.Clone();
var change = node.GetValue(nodeEditor);
var diff = change.NewText.Length - change.Span.Length;
if (newCheck == CheckBoxState.Off)
{
diff = -diff;
}
while (iter.MoveNext())
{
var currentOffset = iter.GetValue(nodeOffset);
iter.SetValue(nodeOffset, currentOffset + diff);
}
}
private void FillThisPCItems(TreeNavigator tree)
{
tree.Items.Add(new TreeMenuItem()
{
Text = "Desktop"
});
tree.Items.Add(new TreeMenuItem()
{
Text = "Documents"
});
foreach (string s in drives)
{
tree.Items.Add(new TreeMenuItem()
{
Text = s
});
}
}
protected void SetValue(TreeNavigator navigator,String fieldname, object value)
{
foreach (DatafieldContainer df in Fields)
{
if (df.Title.Equals(fieldname,StringComparison.OrdinalIgnoreCase))
{
SetValue(navigator,new object[] {df.Field, value }, df.Typename);
return;
}
}
}
void SetChunkStyle (TreeNavigator navigator, ChunkStyle oldStyle)
{
var newStyle = new ChunkStyle (oldStyle);
newStyle.Foreground = GetColorFromButton (colorbuttonPrimary);
newStyle.Background = GetColorFromButton (colorbuttonSecondary);
if (togglebuttonBold.Active) {
newStyle.FontWeight = FontWeight.Bold;
} else {
newStyle.FontWeight = FontWeight.Normal;
}
if (togglebuttonItalic.Active) {
newStyle.FontStyle = FontStyle.Italic;
} else {
newStyle.FontStyle = FontStyle.Normal;
}
navigator.SetValue (styleField, newStyle);
var newscheme = colorScheme.Clone ();
ApplyStyle (newscheme);
this.textEditor.TextViewMargin.PurgeLayoutCache ();
this.textEditor.Document.MimeType = "text/x-csharp";
this.textEditor.GetTextEditorData ().ColorStyle = newscheme;
this.textEditor.QueueDraw ();
}
private object GetValue(TreeNavigator navigator, IDataField datafield, String typenmae)
{
//DataStore.AddNode().SetValue
MethodInfo method = typeof(TreeNavigator).GetMethod("GetValue");
MethodInfo generic = method.MakeGenericMethod(Type.GetType(typenmae));
return (generic.Invoke(navigator,new object[] {datafield}));
}
private TreeNavigator GetNavigator(VirtualGridRow row,TreeNavigator parent=null)
{
TreeNavigator first = null;
if (parent != null)
{
first = parent;
} else
{
first = DataStore.GetFirstNode();
}
if (first.CurrentPosition != null)
{
do
{
VirtualGridRow o = (VirtualGridRow)GetValue(first,"row");
if (o == row)
{
return first;
}
if (first.MoveToChild())
{
TreeNavigator tn = GetNavigator(row,first);
if (tn != null)
{
return tn;
}
first.MoveToParent();
}
} while(first.MoveNext());
}
return null;
}
/// <summary>
/// set a value of a xwt treenavigator
/// </summary>
/// <returns>
/// The value.
/// </returns>
/// <param name='navigator'>
/// Navigator.
/// </param>
/// <param name='data'>
/// Data.
/// </param>
/// <param name='typenmae'>
/// Typenmae.
/// </param>
private TreeNavigator SetValue(TreeNavigator navigator, object[] data, String typenmae)
{
//DataStore.AddNode().SetValue
MethodInfo method = typeof(TreeNavigator).GetMethod("SetValue");
MethodInfo generic = method.MakeGenericMethod(Type.GetType(typenmae));
return (generic.Invoke(navigator,data) as TreeNavigator);
}
private TreeNavigator setData(TreeNavigator tn, object[] data)
{
TreeNavigator ret = null;
int i=0;
foreach (DatafieldContainer dc in Fields)
{
ret = SetValue(tn,new object[] {dc.Field,data[i]},dc.Typename);
i++;
}
return ret;
}
void AddDummyChild (TreeNavigator navigator)
{
navigator.AddChild ();
navigator.SetValue (textField, "Loading...");
navigator.MoveToParent ();
}
void UpdateParents (TreeNavigator navigator)
{
do {
var node = navigator.GetValue (nodeField);
UpdateText (navigator, node);
} while (navigator.MoveToParent ());
}
void SyncNode (TreeNavigator navigator, bool forceExpansion = false)
{
var node = navigator.GetValue (nodeField);
UpdateText (navigator, node);
bool isExpanded = forceExpansion || view.IsRowExpanded (navigator.CurrentPosition);
ClearChildNodes (navigator);
syncedNodes.Remove (node);
navigator.RemoveChildren ();
if (!node.HasVisibleChildren)
return;
if (isExpanded) {
foreach (var childNode in node.Children.Where (child => child.Visible)) {
navigator.AddChild ();
SetNode (navigator, childNode);
SyncNode (navigator);
navigator.MoveToParent ();
}
} else {
AddDummyChild (navigator);
}
if (isExpanded) {
syncedNodes.Add (node);
view.ExpandRow (navigator.CurrentPosition, false);
}
}
void UpdateText (TreeNavigator navigator, IIssueTreeNode node)
{
navigator.SetValue (textField, node.Text);
}
void ClearChildNodes (TreeNavigator navigator)
{
if (navigator.MoveToChild ()) {
ClearSiblingNodes (navigator);
navigator.MoveToParent ();
}
}
protected object GetValue(TreeNavigator navigator,String fieldname)
{
if (navigator.CurrentPosition == null)
{
return null;
}
foreach (DatafieldContainer df in Fields)
{
if (df.Title.Equals(fieldname,StringComparison.OrdinalIgnoreCase))
{
return GetValue(navigator,df.Field,df.Typename);
}
}
return null;
}
private void AddChilds(TreeNavigator node, List<HierarchyItem> children)
{
foreach (var child in children)
{
node.AddChild().SetValue(_name, child.Name).SetValue(_path, child.ServerPath);
AddChilds(node, child.Children);
node.MoveToParent();
}
}
public TreeViewCellBounds ()
{
MinHeight = 120;
MinWidth = 100;
container = new VBox ();
TreeView = new TreeView ();
TreeStore = new TreeStore (triState, check, text, desc);
TreeView.GridLinesVisible = GridLines.Both;
TreeView.Columns.Add ("TriCheck", triState);
TreeView.Columns.Add ("Check", check);
TreeView.Columns.Add ("Item", text);
TreeView.Columns.Add ("Desc", desc, check, text);
TreeView.DataSource = TreeStore;
TreeStore.AddNode ().SetValue (text, "One").SetValue (desc, "First").SetValue (triState, CheckBoxState.Mixed);
TreeStore.AddNode ().SetValue (text, "Two").SetValue (desc, "Second").AddChild ()
.SetValue (text, "Sub two").SetValue (desc, "Sub second");
TreeStore.AddNode ().SetValue (text, "Three").SetValue (desc, "Third").AddChild ()
.SetValue (text, "Sub three").SetValue (desc, "Sub third");
TreeView.ExpandAll ();
TreeView.SelectionChanged += (sender, e) => UpdateTracker (TreeView.SelectedRow);
TreeView.MouseMoved += (sender, e) => UpdateTracker (TreeView.GetRowAtPosition (e.X, e.Y));
drawer = new TreeTrackingCanvas (this);
container.PackStart (TreeView, true);
container.PackStart (drawer);
AddChild (container);
if (currentRow == null)
currentRow = TreeStore.GetFirstNode ();
}
void SetAmbientColor (TreeNavigator navigator, AmbientColor oldStyle)
{
var newStyle = new AmbientColor ();
newStyle.Color = GetColorFromButton (colorbuttonPrimary);
newStyle.SecondColor = GetColorFromButton (colorbuttonSecondary);
navigator.SetValue (styleField, newStyle);
var newscheme = colorScheme.Clone ();
ApplyStyle (newscheme);
this.textEditor.TextViewMargin.PurgeLayoutCache ();
this.textEditor.Document.MimeType = "text/x-csharp";
this.textEditor.GetTextEditorData ().ColorStyle = newscheme;
this.textEditor.QueueDraw ();
}
void SetNode (TreeNavigator navigator, IIssueTreeNode node)
{
if (navigator == null)
throw new ArgumentNullException ("navigator");
if (node == null)
throw new ArgumentNullException ("node");
navigator.SetValue (nodeField, node);
Debug.Assert (!nodePositions.ContainsKey (node));
var position = navigator.CurrentPosition;
nodePositions.Add (node, position);
node.ChildAdded += (sender, e) => {
Debug.Assert (e.Parent == node);
Application.Invoke (delegate {
var newNavigator = store.GetNavigatorAt (position);
newNavigator.AddChild ();
SetNode (newNavigator, e.Child);
SyncNode (newNavigator);
});
};
node.ChildrenInvalidated += (sender, e) => {
Application.Invoke (delegate {
SyncNode (store.GetNavigatorAt (position));
});
};
node.TextChanged += (sender, e) => {
lock (queueLock) {
if (!updateQueue.Contains (e.Node)) {
updateQueue.Enqueue (e.Node);
}
}
};
node.VisibleChanged += (sender, e) => {
lock (queueLock) {
if (!updateQueue.Contains (e.Node)) {
updateQueue.Enqueue (e.Node);
}
}
};
}
void ClearSiblingNodes (TreeNavigator navigator)
{
if (navigator.CurrentPosition == null)
return;
do {
var node = navigator.GetValue (nodeField);
if (node != null) {
if (syncedNodes.Contains (node)) {
syncedNodes.Remove (node);
}
if (nodePositions.ContainsKey (node)) {
nodePositions.Remove (node);
}
}
ClearChildNodes (navigator);
} while (navigator.MoveNext ());
}
private void AddLesson(TreeNavigator navigator, Lesson lesson)
{
navigator.AddChild()
.SetValue(imageCol, LessonIcon)
.SetValue(nameCol, lesson.Title)
.SetValue(subjectCol, lesson.Subject)
.SetValue(lessonCol, lesson)
.MoveToParent();
}
// public VirtualGridRow GetSelectedGridRow()
// {
// TreePosition tp = Tree.SelectedRow;
//
// foreach (VirtualGridRow row in Rows)
// {
// TreeNavigator tn = DataStore.GetNavigatorAt (tp);
// //DataStore.
// //VirtualGridRow rw = (VirtualGridRow)GetValue(tn,"");
// //tn.GetValue(
// }
// return null;
// }
public void addData(TreeNavigator navigator, VirtualTreeRow row)
{
if (navigator == null)
{
throw new ArgumentNullException("navigator");
}
if (row == null)
{
throw new ArgumentNullException("row");
}
//add children
if ((row.Children != null) && (row.Children.Count > 0))
{
TreeNavigator current = navigator;
int idx = 0;
foreach (KeyValuePair<String,VirtualTreeRow> kp in row.Children)
{
if (idx > 0)
{
current.InsertAfter();
}
setData(current,kp.Value.Data);
if (kp.Value.Children.Count > 0)
{
addData(current.AddChild(),kp.Value);
current.MoveToParent();
} else
{
if (kp.Value.Rows.Count > 0)
{
addData(current.AddChild(),kp.Value);
current.MoveToParent();
}
}
idx++;
}
}
//if no children available add the assigned rows
if ((row.Children == null) || (row.Children.Count < 1))
{
int idx = 0;
foreach (VirtualGridRow rw in row.Rows)
{
if (idx > 0)
{
navigator.InsertAfter();
}
setData(navigator,rw.Datas);
idx++;
}
}
}
