static void BuildTreeChildren (Gtk.TreeStore store, Gtk.TreeIter parent, XContainer p)
{
foreach (XNode n in p.Nodes) {
Gtk.TreeIter childIter;
if (!parent.Equals (Gtk.TreeIter.Zero))
childIter = store.AppendValues (parent, n);
else
childIter = store.AppendValues (n);
XContainer c = n as XContainer;
if (c != null && c.FirstChild != null)
BuildTreeChildren (store, childIter, c);
}
}
protected bool AddToMenu(Gtk.MenuItem parentMenu,
Gtk.MenuItem itemToBeAdded,
Gtk.MenuItem beforeThis)
{
Gtk.Menu menu = (Gtk.Menu) parentMenu.Submenu;
if (menu == null)
{
menu = new Menu ();
menu.Show ();
parentMenu.Submenu = menu;
}
if (beforeThis == null)
{
menu.Append (itemToBeAdded);
return true;
}
// find the index
int index = 0;
foreach (Gtk.MenuItem item in menu.
AllChildren)
{
if (beforeThis.Equals (item))
{
menu.Insert (itemToBeAdded,
index);
return true;
}
index++;
}
return false;
}
void BuildTreeChildren (Gtk.TreeStore store, Gtk.TreeIter parent, ParentNode p, IList<Block> blocks)
{
foreach (Node node in p) {
if (!(node is TagNode)) {
var startLoc = new TextLocation (node.Location.BeginLine, node.Location.BeginColumn);
var endLoc = new TextLocation (node.Location.EndLine, node.Location.EndColumn);
var doc = defaultDocument.Editor.Document;
var blocksBetween = blocks.Where (n => n.Start.AbsoluteIndex >= doc.GetOffset (startLoc)
&& n.Start.AbsoluteIndex <= doc.GetOffset (endLoc));
foreach (var block in blocksBetween) {
var outlineNode = new OutlineNode (block) {
Location = new DomRegion (doc.OffsetToLocation (block.Start.AbsoluteIndex),
doc.OffsetToLocation (block.Start.AbsoluteIndex + block.Length))
};
if (!parent.Equals (Gtk.TreeIter.Zero))
store.AppendValues (parent, outlineNode);
else
store.AppendValues (outlineNode);
}
continue;
}
Gtk.TreeIter childIter;
if (!parent.Equals (Gtk.TreeIter.Zero))
childIter = store.AppendValues (parent, new OutlineNode(node as TagNode));
else
childIter = store.AppendValues (new OutlineNode(node as TagNode));
ParentNode pChild = node as ParentNode;
if (pChild != null)
BuildTreeChildren (store, childIter, pChild, blocks);
}
}
void AddToTree (Gtk.TreeStore treeStore, Gtk.TreeIter iter, PDictionary dict)
{
iterTable[dict] = iter;
foreach (var item in dict) {
var key = item.Key.ToString ();
var subIter = iter.Equals (TreeIter.Zero) ? treeStore.AppendValues (key, item.Value) : treeStore.AppendValues (iter, key, item.Value);
if (item.Value is PArray)
AddToTree (treeStore, subIter, (PArray)item.Value);
if (item.Value is PDictionary)
AddToTree (treeStore, subIter, (PDictionary)item.Value);
if (expandedObjects.Contains (item.Value))
treeview.ExpandRow (treeStore.GetPath (subIter), true);
}
AddCreateNewEntry (iter);
if (!rebuildArrays.Contains (dict)) {
rebuildArrays.Add (dict);
dict.Changed += HandleDictRebuild;
}
}
void BuildTreeChildren (Gtk.TreeStore store, Gtk.TreeIter parent, XContainer p, IList<Block> blocks)
{
foreach (XNode node in p.Nodes) {
var el = node as XElement;
if (el == null) {
var startLoc = node.Region.Begin;
var endLoc = node.Region.End;
var doc = defaultDocument.Editor.Document;
var blocksBetween = blocks.Where (n => n.Start.AbsoluteIndex >= doc.GetOffset (startLoc)
&& n.Start.AbsoluteIndex <= doc.GetOffset (endLoc));
foreach (var block in blocksBetween) {
var outlineNode = new RazorOutlineNode (block) {
Location = new DomRegion (doc.OffsetToLocation (block.Start.AbsoluteIndex),
doc.OffsetToLocation (block.Start.AbsoluteIndex + block.Length))
};
if (!parent.Equals (Gtk.TreeIter.Zero))
store.AppendValues (parent, outlineNode);
else
store.AppendValues (outlineNode);
}
continue;
}
Gtk.TreeIter childIter;
if (!parent.Equals (Gtk.TreeIter.Zero))
childIter = store.AppendValues (parent, new RazorOutlineNode(el));
else
childIter = store.AppendValues (new RazorOutlineNode(el));
BuildTreeChildren (store, childIter, el, blocks);
}
}
protected override void OnAdded(Gtk.Widget widget)
{
if (widget.Equals(this.vboxWindow))
base.OnAdded (widget);
this.vboxClient.PackStart (widget, true, true, 0);
widget.Show();
}
public void LoadRepositories (Repository r, Gtk.TreeIter parent)
{
if (r.VersionControlSystem == null)
return;
TreeIter it;
if (!parent.Equals (TreeIter.Zero))
it = store.AppendValues (parent, r, r.Name, r.VersionControlSystem.Name, false, "vc-repository");
else
it = store.AppendValues (r, r.Name, r.VersionControlSystem.Name, false, "vc-repository");
try {
if (r.HasChildRepositories)
store.AppendValues (it, null, "", "", true, null);
}
catch (Exception ex) {
LoggingService.LogError (ex.ToString ());
}
}
public int IterNChildren (Gtk.TreeIter iter)
{
if (iter.Equals (TreeIter.Zero))
return Nodes.Count;
else
return GetNode (iter).ChildCount;
}
protected virtual void AddNode(string label, object customizer, Gtk.TreeIter iter, IDialogPanelDescriptor descriptor)
{
if (descriptor.DialogPanel != null) { // may be null, if it is only a "path"
descriptor.DialogPanel.CustomizationObject = customizer;
((Gtk.Frame)descriptor.DialogPanel.Control).Shadow = Gtk.ShadowType.None;
OptionPanels.Add (descriptor.DialogPanel);
mainBook.AppendPage (descriptor.DialogPanel.Control, new Gtk.Label ("a"));
}
Gtk.TreeIter i;
if (iter.Equals (Gtk.TreeIter.Zero)) {
i = treeStore.AppendValues (label, descriptor);
} else {
i = treeStore.AppendValues (iter, label, descriptor);
}
AddChildNodes (customizer, i, descriptor);
}
bool IsChildIter(Gtk.TreeIter pit, Gtk.TreeIter cit, bool recursive)
{
while (store.IterParent (out cit, cit)) {
if (cit.Equals (pit)) return true;
if (!recursive) return false;
}
return false;
}
/**
* Gets both iters from the provided ListStore obj based on the passed TreePath object(the selected row)
*/
private bool getPrevIterFromSelection(out Gtk.TreeIter selectedIter, out Gtk.TreeIter prevIter,
Gtk.TreePath selectedRow, Gtk.ListStore listModel)
{
listModel.GetIter(out selectedIter, selectedRow);
selectedRow.Prev();
listModel.GetIter(out prevIter, selectedRow);
return (prevIter.Stamp!=0 && !prevIter.Equals(selectedIter));
}
/**
* Gets both iters from the provided ListStore obj based on the passed TreePath object(the selected row)
*/
private bool getNextIterFromSelection(out Gtk.TreeIter selectedIter, out Gtk.TreeIter nextIter,
Gtk.TreePath selectedRow, Gtk.ListStore listModel)
{
listModel.GetIter(out selectedIter, selectedRow);
selectedRow.Next();
listModel.GetIter(out nextIter, selectedRow);
return (nextIter.Stamp!=0 && !nextIter.Equals(selectedIter));
}
public void GetSelectedFileDirectory(out string filename, out int fileTyp, out Gtk.TreeIter ti)
{
GetSelectedFile(out filename, out fileTyp, out ti);
if(fileTyp == (int)TypeFile.Directory)
return;
ti = GetSelectedParentTreeIter(false);
//if (ti. != null) {
if(!ti.Equals(TreeIter.Zero)){
filename = store.GetValue(ti, PATH_ROW).ToString();
fileTyp = (Int32)store.GetValue(ti, TYPE_ROW);
} else {
filename = "";
fileTyp = -1;
}
}
public void GetSelectedFile(out string filename, out int fileTyp, out Gtk.TreeIter ti)
{
ti = GetSelectedIter();
//if(ti.Equals(TreeIter.Zero)) return;
//if (ti == TreeIter.Zero)
//if (ti. != null) {
if(!ti.Equals(TreeIter.Zero)){
filename = store.GetValue(ti, PATH_ROW).ToString();
fileTyp = (Int32)store.GetValue(ti, TYPE_ROW);
} else {
filename = "";
fileTyp = -1;
}
}
ChildInfo FillDirRec (Gtk.TreeIter iter, IWorkspaceFileObject item, HashSet<string> itemFiles, HashSet<string> knownPaths, FilePath dir, bool forceSet)
{
ChildInfo cinfo = ChildInfo.AllSelected;
bool hasChildren = false;
foreach (string sd in knownSubdirs) {
if (dir == item.BaseDirectory.Combine (sd)) {
forceSet = true;
break;
}
}
TreeIter dit;
if (!iter.Equals (TreeIter.Zero)) {
dit = store.AppendValues (iter, false, DesktopService.GetPixbufForFile (dir, IconSize.Menu), dir.FileName.ToString (), dir.ToString ());
fileList.ExpandRow (store.GetPath (iter), false);
}
else
dit = store.AppendValues (false, DesktopService.GetPixbufForFile (dir, IconSize.Menu), dir.FileName.ToString (), dir.ToString ());
paths [dir] = dit;
foreach (string file in Directory.GetFiles (dir)) {
string path = System.IO.Path.GetFileName (file);
Gdk.Pixbuf pix = DesktopService.GetPixbufForFile (file, IconSize.Menu);
bool active = itemFiles.Contains (file);
string color = null;
if (!active) {
pix = ImageService.MakeTransparent (pix, 0.5);
color = "dimgrey";
} else
cinfo |= ChildInfo.HasProjectFiles;
active = active || forceSet || knownPaths.Contains (file);
if (!active)
cinfo &= ~ChildInfo.AllSelected;
else
cinfo |= ChildInfo.SomeSelected;
paths [file] = store.AppendValues (dit, active, pix, path, file, color);
if (!hasChildren) {
hasChildren = true;
fileList.ExpandRow (store.GetPath (dit), false);
}
}
foreach (string cdir in Directory.GetDirectories (dir)) {
hasChildren = true;
ChildInfo ci = FillDirRec (dit, item, itemFiles, knownPaths, cdir, forceSet);
if ((ci & ChildInfo.AllSelected) == 0)
cinfo &= ~ChildInfo.AllSelected;
cinfo |= ci & (ChildInfo.SomeSelected | ChildInfo.HasProjectFiles);
}
if ((cinfo & ChildInfo.AllSelected) != 0 && hasChildren)
store.SetValue (dit, 0, true);
if ((cinfo & ChildInfo.HasProjectFiles) == 0) {
Gdk.Pixbuf pix = DesktopService.GetPixbufForFile (dir, IconSize.Menu);
pix = ImageService.MakeTransparent (pix, 0.5);
store.SetValue (dit, 1, pix);
store.SetValue (dit, 4, "dimgrey");
}
if ((cinfo & ChildInfo.SomeSelected) != 0 && (cinfo & ChildInfo.AllSelected) == 0) {
fileList.ExpandRow (store.GetPath (dit), false);
} else {
fileList.CollapseRow (store.GetPath (dit));
}
return cinfo;
}
public bool IterChildren (out Gtk.TreeIter first_child, Gtk.TreeIter parent)
{
first_child = Gtk.TreeIter.Zero;
if (parent.Equals (TreeIter.Zero)) {
if (Nodes.Count <= 0)
return false;
first_child = GetIter (Nodes [0] as ITreeNode);
} else {
ITreeNode node = GetNode (parent);
if (node.ChildCount <= 0)
return false;
first_child = GetIter (node [0]);
}
return true;
}
protected virtual Gtk.TreeIter AddPath(string label, Gtk.TreeIter iter)
{
if (iter.Equals (Gtk.TreeIter.Zero))
return treeStore.AppendValues (label, null);
else
return treeStore.AppendValues (iter, label, null);
}
public bool IterNthChild (out Gtk.TreeIter child, Gtk.TreeIter parent, int n)
{
child = TreeIter.Zero;
if (parent.Equals (TreeIter.Zero)) {
if (Nodes.Count <= n)
return false;
child = GetIter (Nodes [n] as ITreeNode);
} else {
ITreeNode parent_node = GetNode (parent);
if (parent_node.ChildCount <= n)
return false;
child = GetIter (parent_node [n]);
}
return true;
}
bool FindChildByName (string name, ref Gtk.TreeIter iter)
{
if (iter.Equals (Gtk.TreeIter.Zero)) {
if (!store.GetIterFirst (out iter))
return false;
} else if (!store.IterChildren (out iter, iter))
return false;
do {
if (name == (string) store.GetValue (iter, ColSignal))
return true;
}
while (store.IterNext (ref iter));
return false;
}
private byte [] SerializeToHtml (Gtk.TextBuffer register_buffer, Gtk.TextBuffer content_buffer, Gtk.TextIter start, Gtk.TextIter end)
{
if (start.Equals (end) || start.Equals (Gtk.TextIter.Zero) || end.Equals (Gtk.TextIter.Zero) || HtmlTransform == null) {
return new byte [0];
}
Logger.Debug ("Handling text/html Clipboard copy/cut request");
var xsl = HtmlTransform;
string xml = String.Format (
"<note version=\"0.3\" xmlns:link=\"http://beatniksoftware.com/tomboy/link\" xmlns:size=\"http://beatniksoftware.com/tomboy/size\">{0}</note>",
NoteBufferArchiver.Serialize (register_buffer, start, end)
);
var reader = new StringReader (xml);
var doc = new XPathDocument (reader);
var args = new XsltArgumentList ();
var writer = new StringWriter ();
xsl.Transform (doc, args, writer);
string html = writer.ToString ();
byte [] bytes = System.Text.Encoding.UTF8.GetBytes (html);
return bytes;
}
internal void MoveToIter(Gtk.TreeIter iter)
{
currentNavIter = iter;
if (!iter.Equals (Gtk.TreeIter.Zero))
dataItem = GetStoreValue (ExtensibleTreeView.DataItemColumn);
else
dataItem = null;
}
void SetNoEntries (Gtk.TreeIter iter)
{
if (iter.Equals (TreeIter.Zero)) {
treeStore.AppendValues (GettextCatalog.GetString ("No entries"), null);
return;
}
treeStore.AppendValues (iter, GettextCatalog.GetString ("No entries"), null);
}
public int IterNChildren (Gtk.TreeIter iter)
{
if (iter.Equals (Gtk.TreeIter.Zero))
return source.RowCount;
else
return 0;
}
void AddCreateNewEntry (Gtk.TreeIter iter)
{
if (iter.Equals (TreeIter.Zero)) {
treeStore.AppendValues (GettextCatalog.GetString (AddKeyNode), null);
return;
}
treeStore.AppendValues (iter, GettextCatalog.GetString (AddKeyNode), null);
}
public bool IterNthChild (out Gtk.TreeIter iter, Gtk.TreeIter parent, int n)
{
if (parent.Equals (Gtk.TreeIter.Zero)) {
iter = IterFromNode (n);
return true;
} else {
iter = Gtk.TreeIter.Zero;
return false;
}
}
void AddToTree (Gtk.TreeStore treeStore, Gtk.TreeIter iter, PArray arr)
{
iterTable[arr] = iter;
for (int i = 0; i < arr.Count; i++) {
var item = arr[i];
var txt = string.Format (GettextCatalog.GetString ("Item {0}"), i);
var subIter = iter.Equals (TreeIter.Zero) ? treeStore.AppendValues (txt, item) : treeStore.AppendValues (iter, txt, item);
if (item is PArray)
AddToTree (treeStore, subIter, (PArray)item);
if (item is PDictionary)
AddToTree (treeStore, subIter, (PDictionary)item);
if (expandedObjects.Contains (item))
treeview.ExpandRow (treeStore.GetPath (subIter), true);
}
AddCreateNewEntry (iter);
if (!rebuildArrays.Contains (arr)) {
rebuildArrays.Add (arr);
arr.Changed += HandleArrRebuild;
}
}
public TreeMapItem(Gtk.TreeModel m,
ref Gtk.TreeIter iter,
bool horiz,
int textColumn,
int weightColumn)
{
if (m == null)
throw new ArgumentNullException ("m");
if (iter.Equals (Gtk.TreeIter.Zero))
throw new ArgumentException ("iter");
if (textColumn < 0)
throw new ArgumentException ("textColumn");
if (weightColumn < 0)
throw new ArgumentException ("weightColumn");
Path = m.GetPath (iter);
Title = (string)m.GetValue (iter, textColumn);
Weight = (double)m.GetValue (iter, weightColumn);
X = 0;
Y = 0;
Width = 0;
Height = 0;
Children = null;
Horiz = horiz;
Gtk.TreeIter citer;
double c_total = 0.0;
if (m.IterChildren (out citer, iter)) {
do {
AddChild (new TreeMapItem (m, ref citer, !horiz, textColumn, weightColumn));
} while (m.IterNext (ref citer));
// Get total weight
Children.ForEach (delegate (TreeMapItem i) {
c_total += Math.Abs (i.Weight);
});
this.ChildrenWeight = c_total;
}
}
