public void SetSelectedFile(string filename)
{
TreeIter iter = new TreeIter();
store.Foreach((model, path, iterr) =>
{
string myPath = store.GetValue(iterr, PATH_ROW).ToString();
if ((myPath == filename))
{
//iter = iterr;
iter = filter.ConvertChildIterToIter(iterr);
if (!iter.Equals(TreeIter.Zero))
{
TreePath tp = filter.GetPath(iter);
treeView.ExpandToPath(tp);
treeView.ScrollToCell(tp, null, true, 0.9f, 0);
//treeView.Selection.UnselectAll();
treeView.Selection.SelectIter(iter);
}
return(true);
}
return(false);
});
}
async void SaveAndQuit(object o, EventArgs e)
{
Sensitive = false;
List <Task> saveTasks = new List <Task> ();
tsFiles.Foreach(delegate(TreeModel model, TreePath path, TreeIter iter) {
var window = tsFiles.GetValue(iter, 2) as SdiWorkspaceWindow;
if (window == null)
{
return(false);
}
if ((bool)tsFiles.GetValue(iter, 1))
{
saveTasks.Add(window.ViewContent.Save(window.ViewContent.ContentName));
}
else
{
window.ViewContent.DiscardChanges();
}
return(false);
});
try {
await Task.WhenAll(saveTasks);
} finally {
Sensitive = true;
}
Respond(Gtk.ResponseType.Ok);
Hide();
}
private void ExpandPath(string path)
{
if (string.IsNullOrEmpty(path))
{
return;
}
TreeIter iter = TreeIter.Zero;
_treeStore.Foreach((m, p, i) =>
{
var item = ((BaseItem)m.GetValue(i, 0));
if (string.Equals(item.ServerPath, path, StringComparison.OrdinalIgnoreCase))
{
iter = i;
return(true);
}
return(false);
});
if (iter.Equals(TreeIter.Zero))
{
return;
}
_treeView.CollapseAll();
_treeView.ExpandToPath(_treeStore.GetPath(iter));
_treeView.Selection.SelectIter(iter);
}
public void GetSelectedComponents(ref List <ComponentFactoryInformation> components, ref List <Component> instances)
{
components.Clear();
instances.Clear();
// cannot operate on "instances" or "components" directly due to the lambda expression below (won't compile)
List <ComponentFactoryInformation> components_ = new List <ComponentFactoryInformation>();
List <Component> instances_ = new List <Component>();
m_TreeStore.Foreach((TreeModel model, TreePath path, TreeIter iter) =>
{
UIComponentDescriptor item = model.GetValue(iter, 0) as UIComponentDescriptor;
if (item != null)
{
if (item.Selected)
{
if (item.Instance == null)
{
components_.Add(item.ComponentFactoryInformation);
}
else
{
instances_.Add(item.Instance);
}
}
}
return(false);
});
// cannot operate on "instances" or "components" directly due to the lambda expression below (won't compile)
components = components_;
instances = instances_;
}
async void SaveAndQuit(object o, EventArgs e)
{
Sensitive = false;
List <Task> saveTasks = new List <Task> ();
tsFiles.Foreach(delegate(TreeModel model, TreePath path, TreeIter iter) {
var doc = tsFiles.GetValue(iter, 2) as Document;
if (doc == null)
{
return(false);
}
if ((bool)tsFiles.GetValue(iter, 1))
{
saveTasks.Add(doc.Save());
}
return(false);
});
try {
await Task.WhenAll(saveTasks);
} finally {
Sensitive = true;
}
Respond(Gtk.ResponseType.Ok);
Hide();
}
void UpdateOutlineSelection(object sender, Mono.TextEditor.DocumentLocationEventArgs e)
{
if (clickedOnOutlineItem || SyntaxTree == null || TreeStore == null)
{
return;
}
IStatement stmt = null;
var caretLocation = Document.Editor.Caret.Location;
var caretLocationD = new CodeLocation(caretLocation.Column, caretLocation.Line);
var currentblock = DResolver.SearchBlockAt(SyntaxTree, caretLocationD, out stmt);
INode selectedASTNode = null;
if (currentblock == null)
{
return;
}
foreach (var n in currentblock)
{
if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation)
{
selectedASTNode = n;
break;
}
}
if (selectedASTNode == null)
{
selectedASTNode = stmt != null ? stmt.ParentNode : currentblock;
}
if (selectedASTNode == null)
{
return;
}
TreeStore.Foreach((TreeModel model, TreePath path, TreeIter iter) =>
{
var n = model.GetValue(iter, 0);
if (n == selectedASTNode)
{
dontJumpToDeclaration = true;
TreeView.Selection.SelectIter(iter);
TreeView.ScrollToCell(path, TreeView.GetColumn(0), true, 0, 0);
dontJumpToDeclaration = false;
return(true);
}
return(false);
});
}
void SaveAndQuit(object o, EventArgs e)
{
tsFiles.Foreach(new TreeModelForeachFunc(CollectWorkbenches));
foreach (SdiWorkspaceWindow window in arrSaveWorkbenches)
{
window.ViewContent.Save(window.ViewContent.ContentName);
}
Respond(Gtk.ResponseType.Ok);
Hide();
}
void SaveAndQuit(object o, EventArgs e)
{
tsFiles.Foreach(delegate(TreeModel model, TreePath path, TreeIter iter) {
var window = tsFiles.GetValue(iter, 2) as SdiWorkspaceWindow;
if (window == null)
{
return(false);
}
if ((bool)tsFiles.GetValue(iter, 1))
{
window.ViewContent.Save(window.ViewContent.ContentName);
}
else
{
window.ViewContent.DiscardChanges();
}
return(false);
});
Respond(Gtk.ResponseType.Ok);
Hide();
}
void AddColumns()
{
CellRendererImage iconRender = new CellRendererImage();
Gtk.CellRendererToggle toggleRender = new Gtk.CellRendererToggle();
toggleRender.Toggled += new ToggledHandler(ItemToggled);
TreeViewColumn col;
col = view.AppendColumn("!", iconRender, "image", DataColumns.Type);
col = view.AppendColumn("", toggleRender);
col.SetCellDataFunc(toggleRender, new Gtk.TreeCellDataFunc(ToggleDataFunc));
col = view.AppendColumn(GettextCatalog.GetString("Line"), view.TextRenderer);
col.SetCellDataFunc(view.TextRenderer, new Gtk.TreeCellDataFunc(LineDataFunc));
var descriptionCellRenderer = new CellRendererText();
view.RegisterRenderForFontChanges(descriptionCellRenderer);
var descriptionCol = view.AppendColumn(GettextCatalog.GetString("Description"), descriptionCellRenderer);
descriptionCol.SetCellDataFunc(descriptionCellRenderer, new Gtk.TreeCellDataFunc(DescriptionDataFunc));
descriptionCol.Resizable = true;
descriptionCellRenderer.WrapMode = Pango.WrapMode.Word;
descriptionCol.AddNotification("width", delegate
{
descriptionCellRenderer.WrapWidth = descriptionCol.Width;
store.Foreach((model, path, iter) =>
{
model.EmitRowChanged(path, iter);
return(false);
});
});
col = view.AppendColumn(GettextCatalog.GetString("File"), view.TextRenderer);
col.SetCellDataFunc(view.TextRenderer, new Gtk.TreeCellDataFunc(FileDataFunc));
col.Resizable = true;
col = view.AppendColumn(GettextCatalog.GetString("Project"), view.TextRenderer);
col.SetCellDataFunc(view.TextRenderer, new Gtk.TreeCellDataFunc(ProjectDataFunc));
col.Resizable = true;
col = view.AppendColumn(GettextCatalog.GetString("Path"), view.TextRenderer);
col.SetCellDataFunc(view.TextRenderer, new Gtk.TreeCellDataFunc(PathDataFunc));
col.Resizable = true;
col = view.AppendColumn(GettextCatalog.GetString("Category"), view.TextRenderer);
col.SetCellDataFunc(view.TextRenderer, new Gtk.TreeCellDataFunc(CategoryDataFunc));
col.Resizable = true;
}
public static TreeIter IterFor <T> (this TreeStore model, T item)
{
var iter = TreeIter.Zero;
model.Foreach((m, path, i) => {
if (model.Get <T> (i).Equals(item))
{
iter = i;
return(true);
}
return(false);
});
return(iter);
}
Gtk.TreeIter FindChatIter(ChatView view)
{
Gtk.TreeIter chatIter = Gtk.TreeIter.Zero;
TreeStore.Foreach((model, path, iter) => {
var candidate = (ChatView)model.GetValue(iter, 0);
if (candidate == view)
{
chatIter = iter;
return(true);
}
return(false);
});
return(chatIter);
}
protected bool treeSearch(TreeStore t, string fp)
{
if (t == null)
{
return(false);
}
t.Foreach(new TreeModelForeachFunc(delegate(TreeModel m, TreePath p, TreeIter i) {
t.GetIter(out i, p);
if ((string)m.GetValue(i, 1) == fp)
{
return(true);
}
return(false);
}));
return(false);
}
private TreeIter FindInPack(Packer.Item item)
{
// find iter in tree store of current pack
TreeIter foundIter = TreeIter.Zero;
packStore.Foreach((model, path, iter) =>
{
Packer.Item foundItem = packStore.GetValue(iter, 0) as Packer.Item;
if (item.FullName.CompareTo(foundItem.FullName) == 0)
{
foundIter = iter;
return(true);
}
return(false);
});
return(foundIter);
}
bool TryFindChatIter(ChatView view, out Gtk.TreeIter chatIter)
{
var found = false;
var foundIter = Gtk.TreeIter.Zero;
TreeStore.Foreach((model, path, iter) => {
var candidate = (ChatView)model.GetValue(iter, 0);
if (candidate == view)
{
foundIter = iter;
found = true;
return(true);
}
return(false);
});
chatIter = foundIter;
return(found);
}
private void SetFormatterView(string newLanguage)
{
formatterStore.Foreach(new TreeModelForeachFunc(
new FormatterToggler(newLanguage).Foreach));
}
void UpdateOutlineSelection(object sender, Mono.TextEditor.DocumentLocationEventArgs e)
{
if (clickedOnOutlineItem || SyntaxTree == null || TreeStore == null)
{
return;
}
var caretLocation = Document.Editor.Caret.Location;
var caretLocationD = new CodeLocation(caretLocation.Column, caretLocation.Line);
var currentblock = DResolver.SearchBlockAt(SyntaxTree, caretLocationD);
INode selectedASTNode = null;
if (currentblock == null)
{
return;
}
foreach (var n in currentblock)
{
if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation)
{
selectedASTNode = n;
break;
}
}
// Select parameter node if needed
if (selectedASTNode == null && currentblock is DMethod)
{
foreach (var n in (currentblock as DMethod).Parameters)
{
if (caretLocationD >= n.Location && caretLocationD <= n.EndLocation)
{
selectedASTNode = n;
break;
}
}
}
if (selectedASTNode == null)
{
selectedASTNode = currentblock;
}
if (selectedASTNode == null)
{
return;
}
TreeStore.Foreach((TreeModel model, TreePath path, TreeIter iter) =>
{
var n = model.GetValue(iter, 0);
if (n == selectedASTNode)
{
dontJumpToDeclaration = true;
//var parentPath = path.Copy().Up();
TreeView.ExpandToPath(path);
TreeView.Selection.SelectIter(iter);
dontJumpToDeclaration = false;
return(true);
}
return(false);
});
}
private void UpdateStore(object sourceObj, ToolboxChangedArgs args)
{
ToolboxChangedArgs.ChangeTypes changeType = args.ChangeType;
ToolboxItem changedItem = args.ChangedItem;
TreeStore store = this.Model as TreeStore;
if (changeType == ToolboxChangedArgs.ChangeTypes.ItemUnselected)
{
foreach (TreePath path in this.Selection.GetSelectedRows())
{
TreeIter iter;
if (store.GetIter(out iter, path))
{
ToolboxItem val = GetItem(iter);
if (val == changedItem)
{
this.Selection.UnselectIter(iter);
}
}
}
}
else if (changeType == ToolboxChangedArgs.ChangeTypes.ItemAdded)
{
ToolboxDrawer containingDrawer = null;
ToolboxItem itemBefore = null;
foreach (ToolboxDrawer drawer in source.Drawers)
{
ToolboxItem prev = null;
foreach (ToolboxItem item in drawer.GetContents())
{
if (item == changedItem)
{
containingDrawer = drawer;
itemBefore = prev;
}
prev = item;
}
}
store.Foreach((model, path, iter) => {
if (itemBefore == null)
{
if (GetItem(iter) == containingDrawer)
{
TreeIter node = store.PrependNode(iter);
store.SetValue(node, 0, changedItem);
return(true);
}
}
else
{
if (GetItem(iter) == itemBefore)
{
TreeIter parent;
store.IterParent(out parent, iter);
TreeIter node = store.InsertNodeAfter(parent, iter);
store.SetValue(node, 0, changedItem);
return(true);
}
}
return(false);
});
}
else
{
store.Foreach((model, path, iter) => {
if (GetItem(iter) == changedItem)
{
if (changeType == ToolboxChangedArgs.ChangeTypes.ItemRemoved)
{
store.Remove(ref iter);
}
else if (changeType == ToolboxChangedArgs.ChangeTypes.ItemRenamed)
{
store.EmitRowChanged(path, iter);
}
return(true);
}
return(false);
});
}
}
public AddinView()
{
var hbox = new HBox()
{
Spacing = 6
};
var filter_label = new Label(Catalog.GetString("Show:"));
var filter_combo = new ComboBoxText();
filter_combo.AppendText(Catalog.GetString("All"));
filter_combo.AppendText(Catalog.GetString("Enabled"));
filter_combo.AppendText(Catalog.GetString("Not Enabled"));
filter_combo.Active = 0;
var search_label = new Label(Catalog.GetString("Search:"));
var search_entry = new Banshee.Widgets.SearchEntry()
{
WidthRequest = 160,
Visible = true,
Ready = true
};
hbox.PackStart(filter_label, false, false, 0);
hbox.PackStart(filter_combo, false, false, 0);
hbox.PackEnd(search_entry, false, false, 0);
hbox.PackEnd(search_label, false, false, 0);
var model = new TreeStore(typeof(bool), typeof(bool), typeof(string), typeof(Addin));
var addins = AddinManager.Registry.GetAddins().Where(a => { return
(a.Name != a.Id && a.Description != null &&
!String.IsNullOrEmpty(a.Description.Category) && !a.Description.Category.StartsWith("required:") &&
(!a.Description.Category.Contains("Debug") || ApplicationContext.Debugging)); });
var categorized_addins = addins.GroupBy <Addin, string> (a => a.Description.Category)
.Select(c => new {
Addins = c.OrderBy(a => Catalog.GetString(a.Name)).ToList(),
Name = c.Key,
NameLocalized = Catalog.GetString(c.Key)
})
.OrderBy(c => c.NameLocalized)
.ToList();
tree_view = new TreeView()
{
FixedHeightMode = false,
HeadersVisible = false,
SearchColumn = 1,
RulesHint = true,
Model = model
};
var update_model = new System.Action(() => {
string search = search_entry.Query;
bool?enabled = filter_combo.Active > 0 ? (bool?)(filter_combo.Active == 1 ? true : false) : null;
model.Clear();
foreach (var cat in categorized_addins)
{
var cat_iter = model.AppendValues(false, false, String.Format("<b>{0}</b>", GLib.Markup.EscapeText(cat.NameLocalized)), null);
bool any = false;
foreach (var a in cat.Addins.Matching(search))
{
if (enabled == null || (a.Enabled == enabled.Value))
{
model.AppendValues(cat_iter, true,
a.Enabled,
String.Format(
"<b>{0}</b>\n<small>{1}</small>",
GLib.Markup.EscapeText(Catalog.GetString(a.Name)),
GLib.Markup.EscapeText(Catalog.GetString(a.Description.Description))),
a
);
any = true;
}
}
if (!any)
{
model.Remove(ref cat_iter);
}
}
tree_view.ExpandAll();
});
var txt_cell = new CellRendererText()
{
WrapMode = Pango.WrapMode.Word
};
tree_view.AppendColumn("Name", txt_cell, "markup", Columns.Name);
var check_cell = new CellRendererToggle()
{
Activatable = true
};
tree_view.AppendColumn("Enable", check_cell, "visible", Columns.IsAddin, "active", Columns.IsEnabled);
check_cell.Toggled += (o, a) => {
TreeIter iter;
if (model.GetIter(out iter, new TreePath(a.Path)))
{
var addin = model.GetValue(iter, 3) as Addin;
bool enabled = (bool)model.GetValue(iter, 1);
addin.Enabled = !enabled;
model.SetValue(iter, 1, addin.Enabled);
model.Foreach(delegate(ITreeModel current_model, TreePath path, TreeIter current_iter) {
var an = current_model.GetValue(current_iter, 3) as Addin;
if (an != null)
{
current_model.SetValue(current_iter, 1, an.Enabled);
}
return(false);
});
}
};
update_model();
search_entry.Changed += (o, a) => update_model();
filter_combo.Changed += (o, a) => update_model();
var tree_scroll = new Hyena.Widgets.ScrolledWindow()
{
HscrollbarPolicy = PolicyType.Never
};
tree_scroll.AddWithFrame(tree_view);
Spacing = 6;
PackStart(hbox, false, false, 0);
PackStart(tree_scroll, true, true, 0);
ShowAll();
search_entry.GrabFocus();
txt_cell.WrapWidth = 300;
}
public NoteRenameDialog(IList <Note> notes, string oldTitle, Note renamedNote) :
base(Catalog.GetString("Rename Note Links?"), renamedNote.Window, DialogFlags.NoSeparator)
{
this.DefaultResponse = ResponseType.Cancel;
this.BorderWidth = 10;
var renameButton = (Button)
AddButton(Catalog.GetString("_Rename Links"),
ResponseType.Yes);
var dontRenameButton = (Button)
AddButton(Catalog.GetString("_Don't Rename Links"),
ResponseType.No);
this.notes = notes;
notesModel = new Gtk.TreeStore(typeof(bool), typeof(string), typeof(Note));
foreach (var note in notes)
{
notesModel.AppendValues(true, note.Title, note);
}
var labelText = Catalog.GetString("Rename links in other notes from \"<span underline=\"single\">{0}</span>\" " +
"to \"<span underline=\"single\">{1}</span>\"?\n\n" +
"If you do not rename the links, " +
"they will no longer link to anything.");
var label = new Label();
label.UseMarkup = true;
label.Markup = String.Format(labelText,
GLib.Markup.EscapeText(oldTitle),
GLib.Markup.EscapeText(renamedNote.Title));
label.LineWrap = true;
VBox.PackStart(label, false, true, 5);
var notesView = new TreeView(notesModel);
notesView.SetSizeRequest(-1, 200);
var toggleCell = new CellRendererToggle();
toggleCell.Activatable = true;
var column = new TreeViewColumn(Catalog.GetString("Rename Links"),
toggleCell, "active", 0);
column.SortColumnId = 0;
column.Resizable = true;
notesView.AppendColumn(column);
toggleCell.Toggled += (o, args) => {
TreeIter iter;
if (!notesModel.GetIterFromString(out iter, args.Path))
{
return;
}
bool val = (bool)notesModel.GetValue(iter, 0);
notesModel.SetValue(iter, 0, !val);
};
column = new TreeViewColumn(Catalog.GetString("Note Title"),
new CellRendererText(), "text", 1);
column.SortColumnId = 1;
column.Resizable = true;
notesView.AppendColumn(column);
notesView.RowActivated += (o, args) => {
TreeIter iter;
if (!notesModel.GetIter(out iter, args.Path))
{
return;
}
Note note = (Note)notesModel.GetValue(iter, 2);
if (note != null)
{
note.Window.Present();
NoteFindBar find = note.Window.Find;
find.ShowAll();
find.Visible = true;
find.SearchText = "\"" + oldTitle + "\"";
}
};
var notesBox = new VBox(false, 5);
var selectAllButton = new Button();
// Translators: This button causes all notes in the list to be selected
selectAllButton.Label = Catalog.GetString("Select All");
selectAllButton.Clicked += (o, e) => {
notesModel.Foreach((model, path, iter) => {
notesModel.SetValue(iter, 0, true);
return(false);
});
};
var selectNoneButton = new Button();
// Translators: This button causes all notes in the list to be unselected
selectNoneButton.Label = Catalog.GetString("Select None");
selectNoneButton.Clicked += (o, e) => {
notesModel.Foreach((model, path, iter) => {
notesModel.SetValue(iter, 0, false);
return(false);
});
};
var notesButtonBox = new HButtonBox();
notesButtonBox.Add(selectNoneButton);
notesButtonBox.Add(selectAllButton);
notesButtonBox.Spacing = 5;
notesButtonBox.LayoutStyle = ButtonBoxStyle.End;
var notesScroll = new ScrolledWindow();
notesScroll.Add(notesView);
notesBox.PackStart(notesScroll);
notesBox.PackStart(notesButtonBox, false, true, 0);
var advancedExpander = new Expander(Catalog.GetString("Ad_vanced"));
var expandBox = new VBox();
expandBox.PackStart(notesBox);
alwaysShowDlgRadio = new RadioButton(Catalog.GetString("Always show this _window"));
alwaysShowDlgRadio.Clicked += (o, e) => {
selectAllButton.Click();
notesBox.Sensitive = true;
renameButton.Sensitive = true;
dontRenameButton.Sensitive = true;
};
neverRenameRadio = new RadioButton(alwaysShowDlgRadio,
Catalog.GetString("Never rename _links"));
neverRenameRadio.Clicked += (o, e) => {
selectNoneButton.Click();
notesBox.Sensitive = false;
renameButton.Sensitive = false;
dontRenameButton.Sensitive = true;
};
alwaysRenameRadio = new RadioButton(alwaysShowDlgRadio,
Catalog.GetString("Alwa_ys rename links"));
alwaysRenameRadio.Clicked += (o, e) => {
selectAllButton.Click();
notesBox.Sensitive = false;
renameButton.Sensitive = true;
dontRenameButton.Sensitive = false;
};
expandBox.PackStart(alwaysShowDlgRadio, false, true, 0);
expandBox.PackStart(neverRenameRadio, false, true, 0);
expandBox.PackStart(alwaysRenameRadio, false, true, 0);
advancedExpander.Add(expandBox);
VBox.PackStart(advancedExpander, true, true, 5);
advancedExpander.Activated += (o, e) =>
this.Resizable = advancedExpander.Expanded;
this.Focus = dontRenameButton;
VBox.ShowAll();
}
