public MeasureItemEventArgs( int index, Gtk.TreeIter iter, Gdk.Rectangle rect )
{
this.index = index;
this.ItemHeight = rect.Height;
this.ItemWidth = rect.Width;
this.ItemLeft = rect.X;
this.ItemTop = rect.Y;
this.iter = iter;
}
public InactivateTimer(TaskTreeView treeView,
Gtk.TreeIter taskIter,
Task taskToComplete,
uint delayInSeconds)
{
tree = treeView;
iter = taskIter;
path = treeView.Model.GetPath (iter);
task = taskToComplete;
secondsLeft = delayInSeconds;
delay = delayInSeconds * 1000; // Convert to milliseconds
pulseTimeoutId = 0;
}
internal void MoveToIter(Gtk.TreeIter iter)
{
currentIter = iter;
}
internal void UnregisterNode(object dataObject, Gtk.TreeIter iter, NodeBuilder[] chain)
{
if (dataObject == copyObject)
copyObject = null;
nodeOptions.Remove (iter);
object currentIt = nodeHash [dataObject];
if (currentIt is Gtk.TreeIter[]) {
Gtk.TreeIter[] arr = (Gtk.TreeIter[]) currentIt;
int i = Array.IndexOf (arr, iter);
if (arr.Length > 2) {
Gtk.TreeIter[] newArr = new Gtk.TreeIter[arr.Length - 1];
Array.Copy (arr, 0, newArr, 0, i);
if (i < newArr.Length)
Array.Copy (arr, i+1, newArr, i, arr.Length - i - 1);
nodeHash [dataObject] = newArr;
} else {
if (i == 0) nodeHash [dataObject] = arr[1];
else nodeHash [dataObject] = arr[0];
}
} else {
nodeHash.Remove (dataObject);
if (chain == null) chain = GetBuilderChain (dataObject.GetType());
foreach (NodeBuilder nb in chain)
nb.OnNodeRemoved (dataObject);
}
}
public TreeViewIterBindingTarget(Gtk.TreeView treeView, Gtk.TreeIter iter, Gtk.TreeViewColumn column)
{
mTreeView = treeView;
mIter = iter;
mColumn = column;
}
public bool MoveToParent(Type dataType)
{
Gtk.TreeIter newIter = currentIter;
while (store.IterParent (out newIter, newIter)) {
object data = store.GetValue (newIter, TreeViewPad.DataItemColumn);
if (dataType.IsInstanceOfType (data)) {
currentIter = newIter;
return true;
}
}
return false;
}
void HandleNodesReordered(object sender, TreeNodeOrderEventArgs e)
{
Gtk.TreeIter it = IterFromNode(e.Node);
adapter.EmitRowsReordered(GetPath(it), it, e.ChildrenOrder);
}
public AnimatedTreeStoreIconInfo (Gtk.TreeStore treeStore, Gtk.TreeIter iter, int column, AnimatedIcon anim, string iconId)
{
TreeStore = treeStore;
Iter = iter;
Column = column;
AnimatedIcon = anim;
IconId = iconId;
TreeStore.RowDeleted += HandleRowDeleted;
StartAnimation ();
}
public void SetValue(Gtk.TreeIter iter, int column, object value)
{
GLib.Value val = new GLib.Value(value);
SetValue(iter, column, val);
val.Dispose();
}
public bool IterHasChild(Gtk.TreeIter iter)
{
TreePosition pos = NodeFromIter(iter);
return(source.GetChildrenCount(pos) != 0);
}
void InsertEmptySignalRow(Gtk.TreeIter parent, string name)
{
store.AppendValues(parent, name, EmptyHandlerMarkup, false, false, true, (int)Pango.Weight.Normal);
}
void AddHandler(Gtk.TreeIter iter, string name)
{
internalChange = true;
Gtk.TreeIter piter = iter;
while (store.IterDepth(piter) != 0)
{
store.IterParent(out piter, piter);
}
Signal signal = GetSignal(iter);
if (signal == null)
{
if (name != "")
{
SignalDescriptor sd = GetSignalDescriptor(iter);
signal = new Signal(sd);
signal.Handler = name;
selection.Signals.Add(signal);
SetSignalData(iter, signal);
store.SetValue(iter, ColSignalTextWeight, (int)Pango.Weight.Bold);
if (store.IterDepth(iter) != 1)
{
store.IterParent(out iter, iter);
}
InsertEmptySignalRow(iter, null);
}
}
else
{
if (name != "")
{
signal.Handler = name;
store.SetValue(iter, ColHandler, signal.Handler);
}
else
{
selection.Signals.Remove(signal);
if (store.IterDepth(iter) == 1)
{
if (store.IterNChildren(iter) == 1)
{
Gtk.TreeIter parent;
store.IterParent(out parent, iter);
store.Remove(ref iter);
InsertEmptySignalRow(parent, signal.SignalDescriptor.Name);
}
else
{
Gtk.TreeIter citer;
store.IterChildren(out citer, iter);
Signal csignal = GetSignal(citer);
store.Remove(ref citer);
SetSignalData(iter, csignal);
if (store.IterNChildren(iter) == 1)
{
tree.CollapseRow(store.GetPath(iter));
}
}
}
else
{
store.Remove(ref iter);
}
}
}
UpdateGroupStatus(piter);
internalChange = false;
}
void OutlineTreeDataFunc(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
{
Gtk.CellRendererText txtRenderer = (Gtk.CellRendererText)cell;
XNode n = (XNode)model.GetValue(iter, 0);
txtRenderer.Text = n.FriendlyPathRepresentation;
}
protected void InitIter(Gtk.TreeIter it, object dataObject)
{
currentNavIter = it;
dataItem = dataObject;
}
private void RenderAssemblyDefinition(Gtk.TreeViewColumn column, Gtk.CellRenderer cell,
Gtk.TreeModel model, Gtk.TreeIter iter)
{
}
protected virtual void OnModify(Gtk.ITreeModel child_model, Gtk.TreeIter iter, GLib.Value value, int column)
{
InternalModify(child_model, iter, value, column);
}
public Gtk.TreeIter AppendValues(Array values)
{
Gtk.TreeIter iter = AppendNode();
SetValues(iter, values.Explode());
return(iter);
}
protected virtual void OnRowHasChildToggled(Gtk.TreePath path, Gtk.TreeIter iter)
{
InternalRowHasChildToggled(path, iter);
}
public Gtk.TreeIter AppendValues(params object[] values)
{
Gtk.TreeIter iter = AppendNode();
SetValues(iter, values);
return(iter);
}
public void RefNode(Gtk.TreeIter iter)
{
}
static extern bool gtk_tree_model_iter_children(IntPtr raw, out Gtk.TreeIter iter, IntPtr parent);
protected virtual void OnRowsReordered(Gtk.TreePath path, Gtk.TreeIter iter, out int new_order)
{
new_order = -1;
}
static extern bool gtk_tree_model_iter_nth_child(IntPtr raw, out Gtk.TreeIter iter, IntPtr parent, int n);
void AddConfigurationNodes()
{
configurationTreeNode = treeStore.AppendValues (GettextCatalog.GetString ("Configurations"), null);
foreach (IConfiguration config in project.Configurations) {
Gtk.TreeIter newNode ;
if (config == project.ActiveConfiguration) {
newNode = treeStore.AppendValues (configurationTreeNode, config.Name + " " + GettextCatalog.GetString ("(Active)"), config);
//newNode.NodeFont = boldFont;
} else {
newNode = treeStore.AppendValues (configurationTreeNode, config.Name, config);
//newNode.NodeFont = plainFont;
}
DefaultProperties configNodeProperties = new DefaultProperties();
configNodeProperties.SetProperty("Project", project);
configNodeProperties.SetProperty("Config", config);
AddNodes(configNodeProperties, newNode, configurationNode.BuildChildItems(this));
}
}
private static void ValuePropertyDataFunc(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
{
var treeView = (Gtk.TreeView)column.TreeView;
var info = Templating.GetTemplate(treeView) as TreeViewTemplate;
var textCell = (cell as Gtk.CellRendererText);
textCell.Text = string.Empty;
var value = model.GetValue(iter, 0);
if (value == null)
{
return;
}
foreach (var rowTemplate in info.RowTemplates)
{
if (value.GetType() == rowTemplate.TargetType)
{
//Here we have a value, which is the source for Binding, and a BindingInfo that is given by rowTemplate.ColumnBindings[column.Title] .
//The instance of the BindingInfo is shared among all values (rows), since it was defined once in the rowTemplate.
BindingInfo bindingInfo = null;
if (!rowTemplate.ColumnBindings.TryGetValue(column.Title, out bindingInfo))
{
return;
}
//The actual binding, on the other hand, is specific to the current (row,column) pair.
Binding binding = BindingEngine.GetOrCreateBinding(treeView, value, new TreeViewIterBindingTarget(treeView, iter, column), bindingInfo);
var propValue = binding.GetSourceValue();
textCell.Text = propValue == null ? String.Empty : propValue.ToString();
return;
}
}
}
protected override void AddChildNodes(object customizer, Gtk.TreeIter iter, IDialogPanelDescriptor descriptor)
{
if (descriptor.ID != "Configurations") {
base.AddChildNodes (customizer, iter, descriptor);
} else {
configIter = iter;
FillConfigurations ();
}
}
static int NullSortFunc(Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b)
{
return(0);
}
public bool MoveToPosition(NodePosition position)
{
currentIter = (Gtk.TreeIter) position._iter;
return true;
}
public TreeBuilder(ExtensibleTreeView pad, Gtk.TreeIter iter) : base(pad, iter)
{
}
internal void RegisterNode(Gtk.TreeIter it, object dataObject, NodeBuilder[] chain)
{
object currentIt = nodeHash [dataObject];
if (currentIt == null) {
nodeHash [dataObject] = it;
if (chain == null) chain = GetBuilderChain (dataObject.GetType());
foreach (NodeBuilder nb in chain)
nb.OnNodeAdded (dataObject);
} else {
if (currentIt is Gtk.TreeIter[]) {
Gtk.TreeIter[] arr = (Gtk.TreeIter[]) currentIt;
Gtk.TreeIter[] newArr = new Gtk.TreeIter [arr.Length + 1];
arr.CopyTo (newArr, 0);
newArr [arr.Length] = it;
nodeHash [dataObject] = newArr;
} else {
nodeHash [dataObject] = new Gtk.TreeIter [] { it, (Gtk.TreeIter) currentIt};
}
}
}
static T GetObjectFromTreeIter(Gtk.TreeModel model, Gtk.TreeIter iter)
{
return((T)model.GetValue(iter, 0));
}
protected virtual bool OnVisible(Gtk.ITreeModel child_model, Gtk.TreeIter iter)
{
return(InternalVisible(child_model, iter));
}
public int NodeFromIter(Gtk.TreeIter iter)
{
return(((int)iter.UserData) - 1);
}
protected virtual void OnRowInserted(Gtk.TreePath path, Gtk.TreeIter iter)
{
InternalRowInserted(path, iter);
}
public bool IterHasChild(Gtk.TreeIter iter)
{
return(false);
}
void RefillOutlineStore(T4ParsedDocument doc, Gtk.TreeStore store)
{
if (doc == null)
{
return;
}
Gdk.Color normal = new Gdk.Color(0x00, 0x00, 0x00);
Gdk.Color blue = new Gdk.Color(0x10, 0x40, 0xE0);
Gdk.Color green = new Gdk.Color(0x08, 0xC0, 0x30);
Gdk.Color orange = new Gdk.Color(0xFF, 0xA0, 0x00);
Gdk.Color red = new Gdk.Color(0xC0, 0x00, 0x20);
Gtk.TreeIter parent = Gtk.TreeIter.Zero;
foreach (Mono.TextTemplating.ISegment segment in doc.TemplateSegments)
{
Mono.TextTemplating.Directive dir = segment as Mono.TextTemplating.Directive;
if (dir != null)
{
parent = Gtk.TreeIter.Zero;
store.AppendValues("<#@ " + dir.Name + " #>", red, segment);
continue;
}
Mono.TextTemplating.TemplateSegment ts = segment as Mono.TextTemplating.TemplateSegment;
if (ts != null)
{
string name;
if (ts.Text.Length > 40)
{
name = ts.Text.Substring(0, 40) + "...";
}
else
{
name = ts.Text;
}
name = name.Replace('\n', ' ').Trim();
if (name.Length == 0)
{
continue;
}
if (ts.Type == Mono.TextTemplating.SegmentType.Expression)
{
store.AppendValues(parent, "<#= " + name + " #>", orange, segment);
}
else
{
if (ts.Type == Mono.TextTemplating.SegmentType.Block)
{
name = "<#" + name + " #>";
store.AppendValues(name, blue, segment);
parent = Gtk.TreeIter.Zero;
}
else if (ts.Type == Mono.TextTemplating.SegmentType.Helper)
{
name = "<#+" + name + " #>";
store.AppendValues(name, green, segment);
parent = Gtk.TreeIter.Zero;
}
else if (ts.Type == Mono.TextTemplating.SegmentType.Content)
{
parent = store.AppendValues(name, normal, segment);
}
}
}
}
}
public bool IterParent(out Gtk.TreeIter parent, Gtk.TreeIter child)
{
parent = Gtk.TreeIter.Zero;
return(false);
}
public int IterNChildren(Gtk.TreeIter iter)
{
TreePosition pos = NodeFromIter(iter);
return(source.GetChildrenCount(pos));
}
public TreeOptions(TreeViewPad pad, Gtk.TreeIter iter)
{
this.pad = pad;
this.iter = iter;
}
public void UnrefNode(Gtk.TreeIter iter)
{
}
public TreeNodeNavigator(TreeViewPad pad, Gtk.TreeIter iter)
{
this.pad = pad;
tree = pad.tree;
store = pad.store;
currentIter = iter;
}
void HandleNodeInserted(object sender, TreeNodeEventArgs e)
{
Gtk.TreeIter it = IterFromNode(e.Node);
adapter.EmitRowInserted(GetPath(it), it);
}
public IterPos(int treeVersion, Gtk.TreeIter iter)
{
this.Iter = iter;
this.Version = treeVersion;
}
public void SetValue(Gtk.TreeIter iter, int column, object value)
{
throw new NotImplementedException();
}
protected void InitIter(Gtk.TreeIter it, object dataObject)
{
currentNavIter = it;
dataItem = dataObject;
}
public bool FindChild(object dataObject, bool recursive)
{
object it = pad.nodeHash [dataObject];
if (it == null)
return false;
else if (it is Gtk.TreeIter) {
if (IsChildIter (currentIter, (Gtk.TreeIter)it, recursive)) {
currentIter = (Gtk.TreeIter)it;
return true;
} else
return false;
} else {
foreach (Gtk.TreeIter cit in (Gtk.TreeIter[])it) {
if (IsChildIter (currentIter, cit, recursive)) {
currentIter = (Gtk.TreeIter)cit;
return true;
}
}
return false;
}
}
public TreeOptions (ExtensibleTreeView pad, Gtk.TreeIter iter)
{
this.pad = pad;
this.iter = iter;
}
internal void MoveToIter(Gtk.TreeIter iter)
{
currentNavIter = iter;
if (!iter.Equals (Gtk.TreeIter.Zero))
dataItem = GetStoreValue (ExtensibleTreeView.DataItemColumn);
else
dataItem = null;
}
public bool MoveToChild(string name, Type dataType)
{
EnsureFilled ();
Gtk.TreeIter oldIter = currentIter;
if (!MoveToFirstChild ()) {
currentIter = oldIter;
return false;
}
do {
if (name == NodeName) return true;
} while (MoveNext ());
currentIter = oldIter;
return false;
}
public IterPos(Gtk.TreeIter iter)
{
this.Iter = iter;
}
public bool MoveToFirstChild()
{
EnsureFilled ();
Gtk.TreeIter it;
if (!store.IterChildren (out it, currentIter))
return false;
currentIter = it;
return true;
}
public bool MoveToObject(object dataObject)
{
Gtk.TreeIter iter;
if (!pad.GetFirstNode (dataObject, out iter)) return false;
currentIter = iter;
return true;
}
void OnSelectionChanged(object o, EventArgs args)
{
Gtk.TreeIter iter;
Gtk.TreeModel model;
if (this.Selection.GetSelected (out model, out iter))
{
selectedItem = (FileListItem) model.GetValue (iter, 3);
selectedIter = iter;
}
}
