internal void InsertNewNode(TreeNode parent, ITreeModel tag, int rowIndex, int index)
{
TreeNode node = new TreeNode(this, tag);
if (index >= 0 && index < parent.Children.Count)
{
parent.Children.Insert(index, node);
}
else
{
index = parent.Children.Count;
parent.Children.Add(node);
}
var idx = rowIndex + index + 1;
if (idx < Rows.Count)
{
Rows.Insert(idx, node);
}
else
{
Rows.Add(node);
}
mTreeNodeDic[tag] = node;
}
internal TreeNode(TreeList tree, ITreeModel tag)
{
if (tree == null)
{
throw new ArgumentNullException("tree");
}
_tree = tree;
_children = new NodeCollection(this);
_nodes = new ReadOnlyCollection <TreeNode>(_children);
_tag = tag;
// todo: µã»÷ÁбêÌâÅÅÐò
//if(tag != null)
//{
// foreach (var property in tag.GetType().GetProperties())
// {
// var atts = property.GetCustomAttributes(typeof(PropertyInTreeNodeAttribute), true);
// if (atts.Length == 0)
// continue;
// var curProInfo = this.GetType().GetProperty(property.Name);
// if (curProInfo == null)
// continue;
// curProInfo.SetValue(this, property.GetValue(tag));
// }
//}
}
public PiscesTree(ITreeModel model)
{
this.model = model;
InitializeComponent();
treeView1.SelectionChanged += new EventHandler(treeView1_SelectionChanged);
treeView1.SelectionMode = TreeSelectionMode.Multi;
treeView1.NodeControls.Clear();
treeView1.AutoRowHeight = true;
NodeStateIcon ni = new NodeStateIcon();
ni.DataPropertyName = "Icon";
ni.ScaleMode = ImageScaleMode.Fit;
treeView1.NodeControls.Add(ni);
NodeTextBox tb = new NodeTextBox();
treeView1.NodeControls.Add(tb);
tb.DataPropertyName = "Name";
tb.EditEnabled = true;
tb.LabelChanged += new EventHandler <LabelEventArgs>(tb_LabelChanged);
treeView1.Model = model;
hydrometCommandLine1.OnSubmit += new EventHandler(hydrometCommandLine1_OnSubmit);
}
private static TreeIter GetIter(ITreeModel model, TreePath path)
{
TreeIter iter;
model.GetIter(out iter, path);
return(iter);
}
private void pluginBrowserTreeView_SelectionChanged(object sender, System.EventArgs e)
{
if (pluginBrowserTreeView.SelectedNode == null || pluginBrowserTreeView.SelectedNode.Tag == null)
{
return;
}
ITreeModel detailsModel = null;
if (pluginBrowserTreeView.SelectedNode.Tag is PluginNode)
{
var node = (PluginNode)pluginBrowserTreeView.SelectedNode.Tag;
var details = model.GetPluginDetails(node.Text);
detailsModel = new PluginDetailsTreeModel(details);
}
else if (pluginBrowserTreeView.SelectedNode.Tag is ServiceNode)
{
var node = (ServiceNode)pluginBrowserTreeView.SelectedNode.Tag;
var details = model.GetServiceDetails(node.Text);
detailsModel = new ServiceDetailsTreeModel(details);
}
else if (pluginBrowserTreeView.SelectedNode.Tag is ComponentNode)
{
var node = (ComponentNode)pluginBrowserTreeView.SelectedNode.Tag;
var details = model.GetComponentDetails(node.Text);
detailsModel = new ComponentDetailsTreeModel(details);
}
pluginDetailsTreeView.Model = detailsModel;
}
private void ReturnModelC(object sender, EventArgs e)
{
var node = TreeM.SelectedNode;
Result = node.Tag as ITreeModel;
this.DialogResult = DialogResult.OK;
}
public static void CellDataHandler(ICellLayout layout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
SourceRowRenderer renderer = cell as SourceRowRenderer;
if (renderer == null)
{
return;
}
var type = model.GetValue(iter, (int)SourceModel.Columns.Type);
if (type == null || (SourceModel.EntryType)type != SourceModel.EntryType.Source)
{
renderer.Visible = false;
return;
}
Source source = model.GetValue(iter, 0) as Source;
renderer.Source = source;
renderer.Iter = iter;
if (source == null)
{
return;
}
renderer.Visible = true;
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}
private static int CompareDateTime(ITreeModel model, TreeIter lhs, TreeIter rhs)
{
var l = (DateTime)model.GetValue(lhs, 1);
var r = (DateTime)model.GetValue(rhs, 1);
return(DateTime.Compare(l, r));
}
/// <summary>
/// This function is used internally by the tree filter to determine which rows are visible and which are not.
/// </summary>
/// <param name="model">The model of the tree.</param>
/// <param name="iter">The iter to determine visibility for.</param>
/// <returns>true if the iter should be visible; false otherwise.</returns>
private bool TreeModelVisibilityFunc(ITreeModel model, TreeIter iter)
{
if (!_isFiltered)
{
return(true);
}
var node = (SerializedNode)model.GetValue(iter, 0);
var nodeTypes = node.FileType;
if (!this.ShouldDisplayUnknownFiles)
{
// If the node is strictly an unknown file, don't display it.
if (nodeTypes == WarcraftFileType.Unknown)
{
return(false);
}
}
// If the file types of the node and the filtered types overlap in any way, then it should
// be displayed.
if ((nodeTypes & _filteredFileTypes) != 0)
{
return(true);
}
return(false);
}
public virtual void Select(T item)
{
if (item != null)
{
ITreeModel model = (ITreeModel)item;
if (model.Node == null)
{
model.Node = new TreeNode(View, null)
{
IsExpanded = true
};
View.Model = model;
View.Clear();
}
else
{
View.Model = model;
View.Update();
}
}
else
{
View.Model = null;
View.Clear();
}
Update();
}
private void RenderCombo(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
Options temp = (Options)model.GetValue(iter, 0);
cell.Visible = temp.ValueType == ValueType.ComboBox;
if (cell.Visible)
{
CellRendererCombo combo = (CellRendererCombo)cell;
ListStore t = new ListStore(typeof(string));
int length = temp.ComboBoxValues.Count;
for (int i = 0; i < length; i++)
{
t.AppendValues(temp.ComboBoxValues[i]);
}
combo.Model = t;
if (temp.Value == null)
{
combo.Text = (string)temp.DefaultValue;
}
else
{
combo.Text = temp.Value;
}
}
}
private void InventoryTreeView_SelectionChanged(object sender, EventArgs e)
{
ITreeModel model = base.Model;
this.SelectedInventory = new InventoryBase[base.SelectedNodes.Count];
ReadOnlyCollection <TreeNodeAdv> selectedNodes = base.SelectedNodes;
int index = 0;
bool folders = false;
bool items = false;
foreach (TreeNodeAdv node in selectedNodes)
{
Node innerNode = node.Tag as Node;
this.SelectedInventory[index] = innerNode.Tag as InventoryBase;
folders |= this.SelectedInventory[index] is InventoryFolder;
items |= this.SelectedInventory[index] is InventoryItem;
index++;
}
if (this.SelectionChanged != null)
{
this.SelectionChanged(this, e);
}
if (folders && !items)
{
base.BeginInvoke(new ContextMenuStripFunc(this.SetContextMenuStrip), new object[] { this.FolderContextMenu });
}
else if (items && !folders)
{
base.BeginInvoke(new ContextMenuStripFunc(this.SetContextMenuStrip), new object[] { this.ItemContextMenu });
}
else
{
base.BeginInvoke(new ContextMenuStripFunc(this.SetContextMenuStrip), new object[] { this.GeneralContextMenu });
}
}
public void SetModel(ITreeModel model)
{
treeView1.Model = null;
this.model = model;
treeView1.Model = model;
ExpandRootNodes();
}
bool TasksTreeFilterFunc(ITreeModel model, TreeIter iter)
{
var task = model.GetValue(iter, 0) as Task;
if (task == null)
{
return(true);
}
bool ok = !task.IsDone || showDoneCheckButton.Active;
if (currentFilterFunc != null)
{
ok &= currentFilterFunc(task);
}
string searchText = searchTaskEntry.Text;
if (!string.IsNullOrEmpty(searchText))
{
ok &= task.Description.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0 ||
task.Title.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0;
}
return(ok);
}
internal InProgressEntryWrapper(InProgressDownloadItem downloadEntry,
TreeIter treeIter,
ITreeModel store)
{
this.DownloadEntry = downloadEntry;
this.treeIter = treeIter;
this.store = store;
}
private static void SetDateTimeRendererText(
TreeViewColumn column, CellRenderer renderer, ITreeModel model, TreeIter iter)
{
var dateTime = (DateTime)model.GetValue(iter, 1);
var textRenderer = (CellRendererText)renderer;
textRenderer.Text = dateTime.ToString();
}
public SortedTreeModel(ITreeModel innerModel)
{
_innerModel=innerModel;
_innerModel.NodesChanged+=new EventHandler<TreeModelEventArgs>(_innerModel_NodesChanged);
_innerModel.NodesInserted+=new EventHandler<TreeModelEventArgs>(_innerModel_NodesInserted);
_innerModel.NodesRemoved+=new EventHandler<TreeModelEventArgs>(_innerModel_NodesRemoved);
_innerModel.StructureChanged+=new EventHandler<TreePathEventArgs>(_innerModel_StructureChanged);
}
public static int TimePlayedSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 5).ToString();
string bValue = model.GetValue(b, 5).ToString();
if (aValue.Length > 4 && aValue[^ 4..] == "mins")
{
aValue = (float.Parse(aValue[0..^ 5]) * 60).ToString();
private static int FileSizeSort(ITreeModel model, TreeIter a, TreeIter b)
{
string aValue = model.GetValue(a, 8).ToString();
string bValue = model.GetValue(b, 8).ToString();
if (aValue.Substring(aValue.Length - 2) == "GB")
{
aValue = (float.Parse(aValue[0..^ 2]) * 1024).ToString();
public SortedTreeModel(ITreeModel innerModel)
{
_innerModel = innerModel;
_innerModel.NodesChanged += _innerModel_NodesChanged;
_innerModel.NodesInserted += _innerModel_NodesInserted;
_innerModel.NodesRemoved += _innerModel_NodesRemoved;
_innerModel.StructureChanged += _innerModel_StructureChanged;
}
public SortedTreeModel(ITreeModel innerModel)
{
_innerModel = innerModel;
_innerModel.NodesChanged += new EventHandler <TreeModelEventArgs>(_innerModel_NodesChanged);
_innerModel.NodesInserted += new EventHandler <TreeModelEventArgs>(_innerModel_NodesInserted);
_innerModel.NodesRemoved += new EventHandler <TreeModelEventArgs>(_innerModel_NodesRemoved);
_innerModel.StructureChanged += new EventHandler <TreePathEventArgs>(_innerModel_StructureChanged);
}
private static void Func(ICellLayout cellLayout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var item = (Category)model.GetValue(iter, 0);
if (cell is CellRendererText value)
{
value.Text = item.CategoryName;
}
}
private static TreeIter FindIter(ITreeModel model, string text)
{
var iter = GetIter(model, 0);
while (GetText(model, iter) != text && model.IterNext(ref iter))
{
}
return(iter);
}
public TreeEnumerator (ITreeModel model)
{
this.model = model;
model.RowChanged += new RowChangedHandler (row_changed);
model.RowDeleted += new RowDeletedHandler (row_deleted);
model.RowInserted += new RowInsertedHandler (row_inserted);
model.RowsReordered += new RowsReorderedHandler (rows_reordered);
}
protected TreeModelDecorator(ITreeModel innerTreeModel)
{
this.innerTreeModel = innerTreeModel;
innerTreeModel.NodesChanged += (sender, e) => OnNodesChanged(e);
innerTreeModel.NodesInserted += (sender, e) => OnNodesInserted(e);
innerTreeModel.NodesRemoved += (sender, e) => OnNodesRemoved(e);
innerTreeModel.StructureChanged += (sender, e) => OnStructureChanged(e);
}
public TreeEnumerator(ITreeModel model)
{
this.model = model;
model.RowChanged += new RowChangedHandler(row_changed);
model.RowDeleted += new RowDeletedHandler(row_deleted);
model.RowInserted += new RowInsertedHandler(row_inserted);
model.RowsReordered += new RowsReorderedHandler(rows_reordered);
}
protected TreeModelDecorator(ITreeModel innerTreeModel)
{
this.innerTreeModel = innerTreeModel;
innerTreeModel.NodesChanged += (sender, e) => OnNodesChanged(e);
innerTreeModel.NodesInserted += (sender, e) => OnNodesInserted(e);
innerTreeModel.NodesRemoved += (sender, e) => OnNodesRemoved(e);
innerTreeModel.StructureChanged += (sender, e) => OnStructureChanged(e);
}
private static TreeIter GetIter(ITreeModel model, uint row)
{
TreeIter rootIter;
model.GetIterFirst(out rootIter);
var path = new TreePath(new int[] { (int)row });
return(GetIter(model, path));
}
private void renderCol(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
if (model.GetPath(iter).Indices[0] % 2 == 0)
{
cell.CellBackground = "#e6e9ef";
}
else
{
cell.CellBackground = "#FFFFFF";
}
}
private bool FilterFunc(ITreeModel model, TreeIter iter)
{
if (filter == null)
{
return(true);
}
var text = ClipboardItemStore.GetText(model, iter);
return(filter.IsMatch(text));
}
public static void ListStoreForEach(ITreeModel model, Action <TreeIter> iterCallback)
{
if (!model.GetIterFirst(out TreeIter iter))
{
return;
}
do
{
iterCallback.Invoke(iter);
}while (model.IterNext(ref iter));
}
/// <summary>
/// Sets the contents of a cell being display on a grid
/// </summary>
/// <param name="col"></param>
/// <param name="cell"></param>
/// <param name="model"></param>
/// <param name="iter"></param>
public void RenderActivityStatus(TreeViewColumn col, CellRenderer cell, ITreeModel model, TreeIter iter)
{
TreePath path = model.GetPath(iter);
int rowNo = path.Indices[0];
int colNo;
string text = String.Empty;
if (colLookup.TryGetValue(cell, out colNo) && rowNo < this.DataSource.Rows.Count && colNo < this.DataSource.Columns.Count)
{
object dataVal = this.DataSource.Rows[rowNo][colNo];
cell.Visible = true;
string iconName = "blank";
switch (dataVal.ToString())
{
case "Success":
iconName = "Success";
break;
case "Partial":
iconName = "Partial";
break;
case "Ignored":
iconName = "NoTask";
break;
case "Critical":
iconName = "Critical";
break;
case "Timer":
iconName = "Timer";
break;
case "Calculation":
iconName = "Calculation";
break;
case "NotNeeded":
iconName = "NotNeeded";
break;
case "Warning":
iconName = "Ignored";
break;
case "NoTask":
iconName = "NoTask";
break;
}
(cell as CellRendererPixbuf).Pixbuf = new Gdk.Pixbuf(null, "ApsimNG.Resources.MenuImages." + iconName + ".png");
}
}
private bool FilterPackets(ITreeModel model, TreeIter iter)
{
var pkt = new Value();
model.GetValue(iter, 0, ref pkt);
var packet = (PacketInfo)pkt.Val;
return(packet == null ||
(_filterTargetNetId == 0 || packet.NetId == _filterTargetNetId) &&
_packetTypeFilter[packet.msgType]);
}
public TestTreeModelDecorator(ITreeModel innerTreeModel)
: base(innerTreeModel)
{ }
private bool RowSeparatorFunc(ITreeModel model, TreeIter iter)
{
return (bool)model.GetValue (iter, 2);
}
private bool IsRowSeparator (ITreeModel model, TreeIter iter)
{
return String.IsNullOrEmpty (model.GetValue (iter, 0) as string);
}
public void SetModel(ITreeModel model, bool expandRoot)
{
if (_treeView.Model == null)
expandRoot = true;
string selectedTreePath = null;
Dictionary<string, bool> collapsing = new Dictionary<string, bool>();
if (this.SelectedNode != null)
selectedTreePath = this.SelectedNode.TreePath;
if (expandRoot == false)
{
foreach (TreeNodeAdv node in _treeView.AllNodes)
{
BaseNode tag = node.Tag as BaseNode;
if (tag != null)
{
try
{
if (node.IsLeaf == false)
collapsing.Add(tag.TreePath, node.IsExpanded);
}
catch
{
}
}
}
}
_treeView.Model = model;
if (expandRoot)
ExpandRootNode();
else
{
TreeNodeAdv selectedNode = null;
_treeView.SuspendLayout();
foreach (TreeNodeAdv node in _treeView.AllNodes)
{
BaseNode tag = node.Tag as BaseNode;
if (tag != null)
{
if (selectedTreePath != null)
{
if (selectedTreePath == tag.TreePath)
{
selectedNode = node;
}
}
bool isExpanded;
if (collapsing.TryGetValue(tag.TreePath, out isExpanded))
node.IsExpanded = isExpanded;
}
}
if (selectedNode != null)
_treeView.SelectedNode = selectedNode;
else
ExpandRootNode();
_treeView.ResumeLayout();
}
}
protected void SetModel(ITreeModel model)
{
_treeView.SetModel(model, false);
}
void RenderCell(TreeViewColumn column, CellRenderer cell, ITreeModel model, TreeIter iter)
{
var textCell = (cell as CellRendererText);
Debug.Assert (cell != null);
var task = (Task)model.GetValue (iter, 0);
System.Action ResetColors = () => textCell.Background = "white";
textCell.Strikethrough = task.IsDone;
if (task.IsDone || !task.Deadline.HasValue) {
ResetColors ();
} else {
var now = DateTime.Now.Date;
var threshold = task.Deadline.Value.AddDays (-1);
if (now > task.Deadline.Value) {
textCell.Background = "red";
} else if (now > threshold) {
textCell.Background = "lightgreen";
} else {
ResetColors ();
}
}
int columnNr = Array.IndexOf (tasksTreeView.Columns, column) + 1; // first column is not visible
textCell.Text = (string) model.GetValue (iter, columnNr);
tasksTreeView.QueueDraw ();
}
bool TasksTreeFilterFunc(ITreeModel model, TreeIter iter)
{
var task = model.GetValue (iter, 0) as Task;
if (task == null) {
return true;
}
bool ok = !task.IsDone || showDoneCheckButton.Active;
if (currentFilterFunc != null)
ok &= currentFilterFunc (task);
string searchText = searchTaskEntry.Text;
if (!string.IsNullOrEmpty (searchText)) {
ok &= task.Description.IndexOf (searchText, StringComparison.OrdinalIgnoreCase) >= 0 ||
task.Title.IndexOf (searchText, StringComparison.OrdinalIgnoreCase) >= 0;
}
return ok;
}
public void Establish_context()
{
treeModel = MockRepository.GenerateStub<ITreeModel>();
decorator = new TestTreeModelDecorator(treeModel);
}
static TreeIter FindTask(Task task, ITreeModel model)
{
TreeIter iter;
model.GetIterFirst (out iter);
if (iter.Equals (TreeIter.Zero)) {
return TreeIter.Zero;
}
do {
if (model.GetValue (iter, 0) == task) {
return iter;
}
} while (model.IterNext (ref iter));
return TreeIter.Zero;
}
public GeoTree(IApplicationContext appContext)
{
this.m_Controller = new GeoTreeController(appContext);
this.m_Model = this.m_Controller.TreeModel;
this.InitializeComponent();
}
private void RenderServiceColumn (TreeViewColumn column, CellRenderer cell,
ITreeModel model, TreeIter iter)
{
string markup = (string) model.GetValue (iter, 2);
TreeSelection selection = (column.TreeView as TreeView).Selection;
if (selection.IterIsSelected (iter))
markup = markup.Replace (Program.UI.SecondaryTextColor, Program.UI.SecondaryTextColorSelected);
else
markup = markup.Replace (Program.UI.SecondaryTextColorSelected, Program.UI.SecondaryTextColor);
(cell as CellRendererText).Markup = markup;
}
protected void SetupTree(InventoryTree tree, ITreeModel model, bool expandRoot)
{
tree.NodeControls.Clear();
NodeCheckBox checkBox = tree.AddCheckBoxControl("Checked");
checkBox.IsVisibleValueNeeded += new EventHandler<NodeControlValueEventArgs>(IsCheckBoxVisible);
checkBox.IsEditEnabledValueNeeded += new EventHandler<NodeControlValueEventArgs>(IsCheckBoxEnabled);
checkBox.CheckStateChanged += new EventHandler<TreePathEventArgs>(CheckBoxStateChanged);
tree.AddIconControl("Icon");
tree.AddTextBoxControl("Name");
tree.SetModel(model, expandRoot);
}
public void Bind(IEditorService service, IWebLayout wl, IMenu menu)
{
_edsvc = service;
Bind(_edsvc);
_wl = wl;
_wl.CommandSet.CustomCommandAdded += OnCustomCommandAdded;
_wl.CommandSet.CustomCommandRemoved += OnCustomCommandRemoved;
_rootMenu = menu;
this.Model = _model = new MenuTreeModel(menu, wl);
InitBuiltinCommandMenu();
InitCustomCommandMenu();
}
public static void CellDataHandler(ICellLayout layout, CellRenderer cell, ITreeModel model, TreeIter iter)
{
SourceRowRenderer renderer = cell as SourceRowRenderer;
if (renderer == null) {
return;
}
var type = model.GetValue (iter, (int)SourceModel.Columns.Type);
if (type == null || (SourceModel.EntryType) type != SourceModel.EntryType.Source) {
renderer.Visible = false;
return;
}
Source source = model.GetValue (iter, 0) as Source;
renderer.Source = source;
renderer.Iter = iter;
if (source == null) {
return;
}
renderer.Visible = true;
renderer.Text = source.Name;
renderer.Sensitive = source.CanActivate;
}
