| public GetValue ( Gtk iter, int column ) : object | ||
| iter | Gtk | |
| column | int | |
| return | object | |
public ContextActionPanelWidget(string mimeType)
{
this.mimeType = mimeType;
this.Build();
var col = new TreeViewColumn();
var togRender = new CellRendererToggle();
togRender.Toggled += delegate(object o, ToggledArgs args) {
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
bool enabled = (bool)treeStore.GetValue(iter, 1);
treeStore.SetValue(iter, 1, !enabled);
};
col.PackStart(togRender, false);
col.AddAttribute(togRender, "active", 1);
var textRender = new CellRendererText();
col.PackStart(textRender, true);
col.AddAttribute(textRender, "text", 0);
treeviewContextActions.AppendColumn(col);
treeviewContextActions.HeadersVisible = false;
treeviewContextActions.Model = treeStore;
FillTreeStore();
treeviewContextActions.Selection.Changed += HandleTreeviewContextActionsSelectionChanged;
}
private void HandleTimeComboChanged(object o, EventArgs e)
{
TreeIter iter;
if (time_combo.GetActiveIter(out iter))
{
datetime.Hour = (int)time_store.GetValue(iter, 1);
datetime.Minute = (int)time_store.GetValue(iter, 2);
}
}
void checkToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (transactionsStore.GetIter(out iter, new TreePath(args.Path)))
{
bool old = (bool)transactionsStore.GetValue(iter, 1);
transactionsStore.SetValue(iter, 1, !old);
}
}
void CellRendererToggleToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
CodeFormatOption option = (CodeFormatOption)store.GetValue(iter, objectColumn);
bool value = !(bool)store.GetValue(iter, toggleColumn);
description.SetValue(settings, option, value ? "True" : "False");
store.SetValue(iter, toggleColumn, value);
UpdateExample();
}
}
void HandleRowActivated(object o, RowActivatedArgs args)
{
Gtk.TreeIter it;
if (!stackStore.GetIter(out it, args.Path))
{
return;
}
string file = (string)stackStore.GetValue(it, 1);
int line = (int)stackStore.GetValue(it, 2);
if (!string.IsNullOrEmpty(file))
{
IdeApp.Workbench.OpenDocument(file, line, 0);
}
}
private void MyRowExpandedHandler(object o, RowExpandedArgs args)
{
string path = itemStore.GetValue(args.Iter, 1).ToString() + "/*";
int indx = 0;
Microsoft.TeamFoundation.VersionControl.Client.Item[] items = ItemsForPath(path);
if (items.Length == 0)
{
SetRowValue(args.Iter, indx, " - item list not available - ", "");
}
foreach (Microsoft.TeamFoundation.VersionControl.Client.Item item in items)
{
string shortPath = item.ServerItem.Substring(item.ServerItem.LastIndexOf('/') + 1);
if (item.ItemType == ItemType.Folder)
{
shortPath += "/";
}
Gtk.TreeIter child = SetRowValue(args.Iter, indx, shortPath, item.ServerItem);
if (item.ItemType == ItemType.Folder)
{
itemStore.AppendValues(child, "", "");
}
indx++;
}
}
void SyntaxCellRenderer(Gtk.CellLayout cell_layout, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter)
{
var renderer = (Gtk.CellRendererText)cell;
var data = (ColorMetaData)colorStore.GetValue(iter, 2);
var style = (ChunkStyle)colorStore.GetValue(iter, 1);
string markup = GLib.Markup.EscapeText(data.Description);
if (style.Bold)
{
markup = "<b>" + markup + "</b>";
}
if (style.Italic)
{
markup = "<i>" + markup + "</i>";
}
renderer.Markup = markup;
if (data.ColorsAvailable == ColorsAvailable.Text || data.ColorsAvailable == ColorsAvailable.FgBg)
{
renderer.ForegroundGdk = style.Color;
renderer.BackgroundGdk = style.GotBackgroundColorAssigned ? style.BackgroundColor : Style.Base(StateType.Normal);
}
else
{
var b = Math.Abs(HslColor.Brightness(style.Color) - HslColor.Brightness(Style.Text(StateType.Normal)));
renderer.ForegroundGdk = b < 0.4 ? Style.Background(StateType.Normal) : Style.Text(StateType.Normal);
renderer.BackgroundGdk = style.Color;
}
}
private void _sceneEditorGameElementsTreeView_RowActivated(object o, Gtk.RowActivatedArgs args)
{
if (_sceneEditorGameElementsTreeStore.GetIter(out Gtk.TreeIter it, args.Path))
{
string name = (string)_sceneEditorGameElementsTreeStore.GetValue(it, 1);
_sceneGLWidget.SelectGameElement(name);
}
}
private void sectionCell_edit(object o, Gtk.EditedArgs args)
{
Gtk.TreeIter iter;
store.GetIter(out iter, new Gtk.TreePath(args.Path));
TexString sec = (TexString)store.GetValue(iter, 0);
sec.Text = args.NewText;
}
protected void OnProperties()
{
TreeIter iter;
if (tree.Selection.GetSelected(out iter))
{
Breakpoint bp = (Breakpoint)store.GetValue(iter, (int)Columns.Breakpoint);
if (DebuggingService.ShowBreakpointProperties(bp, false))
{
UpdateDisplay();
}
}
}
private void OnAutoConnectItemToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (autoConnectTreeStore.GetIter(out iter, new TreePath(args.Path)))
{
TrustedNodeInfo node = (TrustedNodeInfo)autoConnectTreeStore.GetValue(iter, 0);
node.AllowAutoConnect = !node.AllowAutoConnect;
autoConnectList.QueueDraw();
}
}
void ButtonRemoveClicked(object sender, EventArgs e)
{
TreeIter selected;
if (treeviewCodeTemplates.Selection.GetSelected(out selected))
{
var template = (CodeTemplate)templateStore.GetValue(selected, 0);
if (template != null)
{
if (MessageService.AskQuestion(GettextCatalog.GetString("Remove template"),
GettextCatalog.GetString("Are you sure you want to remove this template?"),
AlertButton.Cancel, AlertButton.Remove) == AlertButton.Remove)
{
templates.Remove(template);
templateStore.Remove(ref selected);
templatesToRemove.Add(template);
}
}
}
}
void OnAddinToggled(object o, ToggledArgs args)
{
TreeIter it;
if (treeStore.GetIter(out it, new TreePath(args.Path)))
{
bool sel = !(bool)treeStore.GetValue(it, 5);
treeStore.SetValue(it, 5, sel);
AddinHeader info = (AddinHeader)treeStore.GetValue(it, 0);
if (sel)
{
selected.Add(info);
}
else
{
selected.Remove(info);
}
OnSelectionChanged(EventArgs.Empty);
}
}
void OnRowActivated(object s, Gtk.RowActivatedArgs args)
{
TreeIter it;
tree.Selection.GetSelected(out it);
ThreadInfo t = store.GetValue(it, (int)Columns.Object) as ThreadInfo;
if (t != null)
{
DebuggingService.ActiveThread = t;
}
}
private void OnToggled(object o, Gtk.ToggledArgs e)
{
TreeIter iter;
store.GetIter(out iter, new TreePath(e.Path));
bool value = !(bool)store.GetValue(iter, 1);
store.SetValue(iter, 1, value);
TorrentFile file = (TorrentFile)store.GetValue(iter, 2);
if (file != null)
{
file.Priority = value ? Priority.Normal : Priority.DoNotDownload;
}
if (store.IterHasChild(iter))
{
store.IterChildren(out iter, iter);
RecurseToggle(iter, value);
}
}
//Přídání eventu na kliknutí řádku v treeview
private void appendEventHandlers()
{
this.treeview.RowActivated += (sender, e) =>
{
//Třída TreeIter je důležitá pro upravení hodnot řádku
Gtk.TreeIter iterator;
//Získa TreeIter z cesty řádku, na který bylo kliknuto
foodTreeStore.GetIterFromString(out iterator, e.Path.ToString());
//Kontola, jestli řádek na který bylo kliknuto je řádek, který se může upravovat, což jsou jen řádky s jídlem
if (foodTreeStore.GetValue(iterator, 2) != null)
{
//Název jídla
string label = foodTreeStore.GetValue(iterator, 0).ToString();
//Najde index v listu jídla a podle toho je třída předána do dialogu, který přídává nebo upraví jídlo
int result = food.FindFoodIndex(label);
var dlg = new AddFoodDialog(food[result]);
//dlg.SetAllergenes(food[result].GetAllergenIds());
if (dlg.Run() == (int)ResponseType.Ok)
{
//Upraví data
foodTreeStore.SetValues(iterator, dlg.Values.ToArray().SubArray(1, 5));
food[result].SetValues(dlg.Values.ToArray());
//Clear all relations with allergens
food[result].Allergen.Clear();
//aId = allergen Id
foreach (int aId in dlg.Allergenes)
{
//Pole alergenů jsou ve výchozí hodnotě 0, opět aby se dali kontrolovat
if (aId == 0)
{
continue;
}
//Vezme se alergen přímo z databáze, aby se nevytvářel v DB nový záznam, ale aby vznikla vazba
var allergen = (from a in this.server.database.Allergenes.ToList() where a.Id == aId select a).First();
food[result].SetAllergen(allergen);
}
}
}
};
}
private void OnTestExpandRow(object sender, Gtk.TestExpandRowArgs args)
{
bool filled = (bool)store.GetValue(args.Iter, FilledCol);
ReferenceNode parent = (ReferenceNode)store.GetValue(args.Iter, ReferenceCol);
if (!filled)
{
store.SetValue(args.Iter, FilledCol, true);
TreeIter iter;
store.IterChildren(out iter, args.Iter);
store.Remove(ref iter);
if (parent.References.Count > 0 || parent.FieldReferences.Count > 0)
{
int nr = 0;
foreach (ReferenceNode nod in parent.References)
{
if (!AddNode(args.Iter, nod).Equals(TreeIter.Zero))
{
nr++;
}
}
foreach (FieldReference fref in parent.FieldReferences)
{
if (!AddNode(args.Iter, fref).Equals(TreeIter.Zero))
{
nr++;
}
}
if (nr == 0)
{
args.RetVal = true;
}
}
else
{
args.RetVal = true;
}
}
}
public ContextActionPanelWidget(string mimeType)
{
this.mimeType = mimeType;
this.Build();
var col = new TreeViewColumn();
searchentryFilter.Ready = true;
searchentryFilter.Visible = true;
searchentryFilter.Entry.Changed += ApplyFilter;
var togRender = new CellRendererToggle();
togRender.Toggled += delegate(object o, ToggledArgs args) {
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
var provider = (CodeActionProvider)treeStore.GetValue(iter, 2);
providerStates [provider] = !providerStates [provider];
treeStore.SetValue(iter, 1, providerStates [provider]);
};
col.PackStart(togRender, false);
col.AddAttribute(togRender, "active", 1);
var textRender = new CellRendererText();
col.PackStart(textRender, true);
col.AddAttribute(textRender, "markup", 0);
treeviewContextActions.AppendColumn(col);
treeviewContextActions.HeadersVisible = false;
treeviewContextActions.Model = treeStore;
GetAllProviderStates();
FillTreeStore(null);
treeviewContextActions.Selection.Changed += HandleTreeviewContextActionsSelectionChanged;
}
// IWorkbenchWindow workbenchWindow;
// RegexToolkitWidget regexWidget;
public ElementHelpWidget (IWorkbenchWindow workbenchWindow, RegexToolkitWidget regexWidget)
{
// this.workbenchWindow = workbenchWindow;
// this.regexWidget = regexWidget;
this.Build ();
elementsStore = new Gtk.TreeStore (typeof(string), typeof(string), typeof(string), typeof(string));
this.elementsTreeview.Model = this.elementsStore;
this.elementsTreeview.HeadersVisible = false;
this.elementsTreeview.Selection.Mode = SelectionMode.Browse;
var col = new TreeViewColumn ();
this.elementsTreeview.AppendColumn (col);
var pix = new CellRendererPixbuf ();
var cellRendText = new CellRendererText ();
col.PackStart (pix, false);
col.AddAttribute (pix, "stock_id", 0);
col.PackStart (cellRendText, false);
col.AddAttribute (cellRendText, "text", 1);
var cellRendText2 = new CellRendererText ();
col.PackStart (cellRendText2, true);
col.SetCellDataFunc (cellRendText2, ElementDescriptionFunc);
// this.elementsTreeview.Selection.Changed += delegate {
// ShowTooltipForSelectedEntry ();
// };
// this.elementsTreeview.MotionNotifyEvent += HandleMotionNotifyEvent;
this.elementsTreeview.RowActivated += delegate (object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
if (elementsStore.GetIter (out iter, e.Path)) {
string text = elementsStore.GetValue (iter, 3) as string;
if (!System.String.IsNullOrEmpty (text)) {
regexWidget.InsertText (text);
workbenchWindow.SwitchView (0);
}
}
};
this.LeaveNotifyEvent += delegate {
this.HideTooltipWindow ();
};
FillElementsBox ();
Show ();
}
protected void OnProperties()
{
var selected = tree.Selection.GetSelectedRows();
TreeIter iter;
if (selected.Length == 1 && store.GetIter(out iter, selected[0]))
{
Breakpoint bp = (Breakpoint)store.GetValue(iter, (int)Columns.Breakpoint);
if (DebuggingService.ShowBreakpointProperties(bp, false))
{
UpdateDisplay();
}
}
}
void OnRowActivated(object sender, Gtk.RowActivatedArgs args)
{
// TODO: Store GUID hidden in model; use instead of title
Gtk.TreeIter iter;
if (!model.GetIter(out iter, args.Path))
{
return;
}
string noteTitle = (string)model.GetValue(iter, 0 /* note title */);
Note note = Tomboy.DefaultNoteManager.Find(noteTitle);
if (note != null)
{
note.Window.Present();
}
}
protected virtual void OnButtonRemoveClicked(object sender, System.EventArgs e)
{
TreeIter iter;
TreeModel model;
if (repoTree.Selection.GetSelected(out model, out iter))
{
VersionControlService.RemoveRepository(
(Repository)store.GetValue(iter, RepositoryCol));
VersionControlService.SaveConfiguration();
store.Remove(ref iter);
}
}
//finds the row number (starting at 0) of a cell
private static int getRowNumOfThisName(Gtk.TreeStore store, int colNum, string searchedName)
{
TreeIter iter;
int count = 0;
bool iterOk = store.GetIterFirst(out iter);
while (iterOk)
{
string thisName = (string)store.GetValue(iter, colNum);
if (thisName == searchedName)
{
return(count);
}
count++;
iterOk = store.IterNext(ref iter);
}
return(-1);
}
//finds the row number (starting at 0) of a cell (usually an uniqueID in col 0)
private static int getRowNumOfThisID(Gtk.TreeStore store, int colNum, int searchedID)
{
TreeIter iter;
int count = 0;
bool iterOk = store.GetIterFirst(out iter);
while (iterOk)
{
int thisID = Convert.ToInt32((string)store.GetValue(iter, colNum));
if (thisID == searchedID)
{
return(count);
}
count++;
iterOk = store.IterNext(ref iter);
}
return(-1);
}
Gtk.Widget IOutlinedDocument.GetOutlineWidget()
{
if (outlineTreeView != null)
{
return(outlineTreeView);
}
outlineTreeStore = new Gtk.TreeStore(typeof(object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView(outlineTreeStore);
System.Reflection.PropertyInfo prop = typeof(Gtk.TreeView).GetProperty("EnableTreeLines");
if (prop != null)
{
prop.SetValue(outlineTreeView, true, null);
}
outlineTreeView.Realized += delegate
{
refillOutlineStore();
};
InitializeOutlineColumns(outlineTreeView);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate
{
Gtk.TreeIter iter;
if (!outlineTreeView.Selection.GetSelected(out iter))
{
return;
}
OutlineSelectionChanged(outlineTreeStore.GetValue(iter, 0));
};
refillOutlineStore();
var sw = new MonoDevelop.Components.CompactScrolledWindow();
sw.Add(outlineTreeView);
sw.ShowAll();
return(sw);
}
void FormatTreeView(TreeStore treeStore)
{
treeView.HeadersVisible = false;
treeView.EnableTreeLines = true;
CellRendererToggle checkboxCellRenderer = new CellRendererToggle();
checkboxCellRenderer.Activatable = true;
checkboxCellRenderer.Toggled += delegate(object o, ToggledArgs args)
{
TreeIter iter;
if (treeStore.GetIter(out iter, new TreePath(args.Path)))
{
PackageReferenceNode node = (PackageReferenceNode)treeStore.GetValue(iter, 0);
node.State = !node.State;
}
};
treeView.AppendColumn("CheckBox", checkboxCellRenderer);
CellRendererText nameCellRenderer = new CellRendererText();
treeView.AppendColumn("Name", nameCellRenderer);
treeView.Columns[0].SetCellDataFunc(checkboxCellRenderer, new TreeCellDataFunc(RenderCheckBox));
treeView.Columns[1].SetCellDataFunc(nameCellRenderer, new TreeCellDataFunc(RenderName));
}
Widget IOutlinedDocument.GetOutlineWidget()
{
if (outlineView != null)
{
return(outlineView);
}
if (outlineStore == null)
{
throw new Exception("The treestore should be built, before initializing the TreeView of the DocumentOutline");
}
outlineView = new MonoDevelop.Ide.Gui.Components.PadTreeView(outlineStore);
System.Reflection.PropertyInfo prop = typeof(Gtk.TreeView).GetProperty("EnableTreeLines");
if (prop != null)
{
prop.SetValue(outlineView, true, null);
}
outlineView.TextRenderer.Xpad = 0;
outlineView.TextRenderer.Ypad = 0;
outlineView.ExpandAll();
outlineView.AppendColumn("Node", outlineView.TextRenderer, new Gtk.TreeCellDataFunc(OutlineTreeDataFunc));
outlineView.HeadersVisible = false;
outlineView.Selection.Changed += delegate {
Gtk.TreeIter iter = Gtk.TreeIter.Zero;
outlineView.Selection.GetSelected(out iter);
DocumentOutlineSelectionChanged(outlineStore.GetValue(iter, 0) as XNode);
};
var sw = new MonoDevelop.Components.CompactScrolledWindow();
sw.Add(outlineView);
sw.ShowAll();
return(sw);
}
private IMember GetMember(TreeStore store, TreeIter iter)
{
return (IMember)store.GetValue (iter, 3);
}
void CreateTreeView()
{
//CreateColumns
TreeViewColumn col = new TreeViewColumn ();
CellRendererText cell = new CellRendererText ();
cell.Editable = true;
col.Title = "Nodes";
col.PackStart (cell, true);
col.AddAttribute (cell, "text", 0);
treeview1.AppendColumn (col);
TreeViewColumn col2 = new TreeViewColumn ();
CellRendererText cell2 = new CellRendererText ();
cell2.Editable = true;
col2.Title = "Url";
col2.PackStart (cell2, true);
col2.AddAttribute (cell2, "text", 1);
col2.Visible = false;
treeview1.AppendColumn (col2);
treeview1.HeadersVisible = false;
//Add Store
treestore = new TreeStore (typeof(string), typeof(string));
treeview1.Model = treestore;
cell.Edited += (o, args) => {
Gtk.TreeIter iter;
treestore.GetIter (out iter, new Gtk.TreePath (args.Path));
String newvalue = (String)treestore.GetValue (iter, 0);
Console.WriteLine (newvalue);
treestore.SetValue (iter, 0, args.NewText);
};
cell2.Edited += (o, args) => {
Gtk.TreeIter iter;
treestore.GetIter (out iter, new Gtk.TreePath (args.Path));
String newvalue = (String)treestore.GetValue (iter, 1);
Console.WriteLine (newvalue);
treestore.SetValue (iter, 1, args.NewText);
};
TargetEntry[] ten = new TargetEntry[]{ new TargetEntry ("tree", TargetFlags.App, 1) };
treeview1.EnableModelDragDest (ten, Gdk.DragAction.Move);
treeview1.EnableModelDragSource (Gdk.ModifierType.Button1Mask, ten, Gdk.DragAction.Move);
ShowAll ();
treeview1.DragDataGet += (o, args) => {
TreeModel model;
((TreeSelection)treeview1.Selection).GetSelected (out model, out SourceIter);
args.SelectionData.Set (args.SelectionData.Target, 8, Encoding.UTF8.GetBytes (model.GetValue (SourceIter, 0).ToString ()));
};
treeview1.DragDataReceived += Tree_DragDataReceived;
treeview1.ButtonPressEvent += Tree_ButtonPressEvent;
}
Widget MonoDevelop.DesignerSupport.IOutlinedDocument.GetOutlineWidget ()
{
if (outlineTreeView != null)
return outlineTreeView;
outlineTreeStore = new TreeStore (typeof(object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView (outlineTreeStore);
var pixRenderer = new CellRendererPixbuf ();
pixRenderer.Xpad = 0;
pixRenderer.Ypad = 0;
outlineTreeView.TextRenderer.Xpad = 0;
outlineTreeView.TextRenderer.Ypad = 0;
TreeViewColumn treeCol = new TreeViewColumn ();
treeCol.PackStart (pixRenderer, false);
treeCol.SetCellDataFunc (pixRenderer, new TreeCellDataFunc (OutlineTreeIconFunc));
treeCol.PackStart (outlineTreeView.TextRenderer, true);
treeCol.SetCellDataFunc (outlineTreeView.TextRenderer, new TreeCellDataFunc (OutlineTreeTextFunc));
outlineTreeView.AppendColumn (treeCol);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
TreeIter iter;
if (!outlineTreeView.Selection.GetSelected (out iter))
return;
object o = outlineTreeStore.GetValue (iter, 0);
IdeApp.ProjectOperations.JumpToDeclaration (o as INode);
};
this.lastCU = Document.ParsedDocument;
outlineTreeView.Realized += delegate { RefillOutlineStore (); };
var sw = new CompactScrolledWindow ();
sw.Add (outlineTreeView);
sw.ShowAll ();
return sw;
}
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;
}
void FillInnerExceptionsStore (TreeStore store, ExceptionInfo exception, TreeIter parentIter = default (TreeIter))
{
TreeIter iter;
if (parentIter.Equals (TreeIter.Zero)) {
iter = store.AppendValues (exception);
ReverseInnerExceptions [exception] = null;
} else {
ReverseInnerExceptions [exception] = (ExceptionInfo)store.GetValue (parentIter, 0);
iter = store.AppendValues (parentIter, exception);
}
var updateInnerExceptions = new System.Action (() => {
if (!InnerExceptionsStore.IterHasChild (iter)) {
var innerExceptions = exception.InnerExceptions;
if (innerExceptions != null && innerExceptions.Count > 0) {
foreach (var inner in innerExceptions) {
FillInnerExceptionsStore (store, inner, iter);
}
} else {
var inner = exception.InnerException;
if (inner != null)
FillInnerExceptionsStore (store, inner, iter);
}
}
});
exception.Changed += delegate {
Application.Invoke (delegate {
InnerExceptionsStore.EmitRowChanged (InnerExceptionsStore.GetPath (iter), iter);
updateInnerExceptions ();
InnerExceptionsTreeView.ExpandRow (InnerExceptionsStore.GetPath (iter), true);
});
};
updateInnerExceptions ();
}
Widget IOutlinedDocument.GetOutlineWidget ()
{
if (outlineTreeView != null)
return outlineTreeView;
outlineTreeStore = new TreeStore (typeof (object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView (outlineTreeStore);
System.Reflection.PropertyInfo prop = typeof (TreeView).GetProperty ("EnableTreeLines");
if (prop != null)
prop.SetValue (outlineTreeView, true, null);
outlineTreeView.Realized += delegate { refillOutlineStore (); };
InitializeOutlineColumns (outlineTreeView);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
TreeIter iter;
if (!outlineTreeView.Selection.GetSelected (out iter))
return;
OutlineSelectionChanged (outlineTreeStore.GetValue (iter, 0));
};
refillOutlineStore ();
var sw = new CompactScrolledWindow ();
sw.Add (outlineTreeView);
sw.ShowAll ();
return sw;
}
private bool GetChecked(TreeStore store, TreeIter iter)
{
return (bool)store.GetValue (iter, 0);
}
public RegexToolkitWidget ()
{
this.Build ();
optionsStore = new ListStore (typeof(bool), typeof(string), typeof(Options));
resultStore = new Gtk.TreeStore (typeof(string), typeof(string), typeof(int), typeof(int));
FillOptionsBox ();
this.buttonStart.Sensitive = false;
this.entryRegEx.Changed += UpdateStartButtonSensitivity;
this.inputTextview.Buffer.Changed += UpdateStartButtonSensitivity;
this.buttonStart.Clicked += delegate {
if (regexThread != null && regexThread.IsAlive) {
regexThread.Abort ();
regexThread.Join ();
SetButtonStart (GettextCatalog.GetString ("Start Regular E_xpression"), "gtk-execute");
regexThread = null;
return;
}
regexThread = new Thread (delegate() {
PerformQuery (inputTextview.Buffer.Text, this.entryRegEx.Text, this.entryReplace.Text, GetOptions ());
});
regexThread.IsBackground = true;
regexThread.Name = "regex thread";
regexThread.Start ();
SetButtonStart (GettextCatalog.GetString ("Stop e_xecution"), "gtk-media-stop");
SetFindMode (!checkbuttonReplace.Active);
};
SetFindMode (true);
var cellRendText = new CellRendererText ();
cellRendText.Ellipsize = Pango.EllipsizeMode.End;
this.optionsTreeview.Model = this.optionsStore;
this.optionsTreeview.HeadersVisible = false;
CellRendererToggle cellRendToggle = new CellRendererToggle ();
cellRendToggle.Toggled += new ToggledHandler (OptionToggled);
cellRendToggle.Activatable = true;
this.optionsTreeview.AppendColumn ("", cellRendToggle, "active", 0);
this.optionsTreeview.AppendColumn ("", cellRendText, "text", 1);
this.resultsTreeview.Model = this.resultStore;
this.resultsTreeview.HeadersVisible = false;
var col = new TreeViewColumn ();
this.resultsTreeview.AppendColumn (col);
var pix = new CellRendererImage ();
col.PackStart (pix, false);
col.AddAttribute (pix, "stock_id", 0);
col.PackStart (cellRendText, true);
col.AddAttribute (cellRendText, "text", 1);
this.resultsTreeview.RowActivated += delegate(object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
if (resultStore.GetIter (out iter, e.Path)) {
int index = (int)resultStore.GetValue (iter, 2);
int length = (int)resultStore.GetValue (iter, 3);
if (index >= 0) {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (index),
this.inputTextview.Buffer.GetIterAtOffset (index + length));
} else {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (0), this.inputTextview.Buffer.GetIterAtOffset (0));
}
}
};
this.entryReplace.Sensitive = this.checkbuttonReplace.Active = false;
this.checkbuttonReplace.Toggled += delegate {
this.entryReplace.Sensitive = this.checkbuttonReplace.Active;
};
this.vbox4.WidthRequest = 380;
this.scrolledwindow5.HeightRequest = 150;
this.scrolledwindow1.HeightRequest = 150;
Show ();
}
public FontChooserPanelWidget ()
{
this.Build ();
fontStore = new TreeStore (typeof (string), typeof (string), typeof (string));
treeviewFonts.Model = fontStore;
treeviewFonts.AppendColumn (GettextCatalog.GetString ("Name"), textRenderer, "text", colDisplayName);
comboRenderer.Edited += delegate(object o, Gtk.EditedArgs args) {
TreeIter iter;
if (!fontStore.GetIterFromString (out iter, args.Path))
return;
string fontName = (string)fontStore.GetValue (iter, colName);
if (args.NewText == GettextCatalog.GetString ("Default")) {
SetFont (fontName, FontService.GetFont (fontName).FontDescription);
fontStore.SetValue (iter, colValue, GettextCatalog.GetString ("Default"));
return;
}
var selectionDialog = new FontSelectionDialog (GettextCatalog.GetString ("Select Font"));
string fontValue = FontService.FilterFontName (GetFont (fontName));
selectionDialog.SetFontName (fontValue);
selectionDialog.OkButton.Clicked += delegate {
fontValue = selectionDialog.FontName;
if (fontValue == FontService.FilterFontName (FontService.GetFont (fontName).FontDescription))
fontValue = FontService.GetFont (fontName).FontDescription;
SetFont (fontName, fontValue);
fontStore.SetValue (iter, colValue, selectionDialog.FontName);
};
MessageService.ShowCustomDialog (selectionDialog);
selectionDialog.Destroy ();
};
comboRenderer.EditingStarted += delegate(object o, EditingStartedArgs args) {
TreeIter iter;
if (!fontStore.GetIterFromString (out iter, args.Path))
return;
string fontName = (string)fontStore.GetValue (iter, colName);
string fontValue = GetFont (fontName);
comboBoxStore.Clear ();
if (fontValue != FontService.GetFont (fontName).FontDescription)
comboBoxStore.AppendValues (fontValue);
comboBoxStore.AppendValues (GettextCatalog.GetString ("Default"));
comboBoxStore.AppendValues (GettextCatalog.GetString ("Edit..."));
};
var fontCol = new TreeViewColumn ();
fontCol.Title = GettextCatalog.GetString ("Font");
comboRenderer.HasEntry = false;
comboRenderer.Mode = CellRendererMode.Activatable;
comboRenderer.TextColumn = 0;
comboRenderer.Editable = true;
fontCol.PackStart (comboRenderer, true);
fontCol.SetCellDataFunc (comboRenderer, delegate (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter) {
string fontValue = (string)fontStore.GetValue (iter, colValue);
string fontName = (string)fontStore.GetValue (iter, colName);
var d = FontService.GetFont (fontName);
if (d == null || d.FontDescription != fontValue) {
comboRenderer.Text = fontValue;
} else {
comboRenderer.Text = GettextCatalog.GetString ("Default");
}
});
treeviewFonts.AppendColumn (fontCol);
comboBoxStore = new ListStore (typeof (string));
comboRenderer.Model = comboBoxStore;
LoadFonts ();
}
public GitConfigurationDialog (GitRepository repo)
{
this.Build ();
this.repo = repo;
this.HasSeparator = false;
this.UseNativeContextMenus ();
// Branches list
storeBranches = new ListStore (typeof(Branch), typeof(string), typeof(string), typeof(string));
listBranches.Model = storeBranches;
listBranches.HeadersVisible = true;
SemanticModelAttribute modelAttr = new SemanticModelAttribute ("storeBranches__Branch", "storeBranches__DisplayName", "storeBranches__Tracking", "storeBranches__Name");
TypeDescriptor.AddAttributes (storeBranches, modelAttr);
listBranches.AppendColumn (GettextCatalog.GetString ("Branch"), new CellRendererText (), "markup", 1);
listBranches.AppendColumn (GettextCatalog.GetString ("Tracking"), new CellRendererText (), "text", 2);
listBranches.Selection.Changed += delegate {
TreeIter it;
bool anythingSelected =
buttonRemoveBranch.Sensitive = buttonEditBranch.Sensitive = buttonSetDefaultBranch.Sensitive = listBranches.Selection.GetSelected (out it);
if (!anythingSelected)
return;
string currentBranch = repo.GetCurrentBranch ();
var b = (Branch) storeBranches.GetValue (it, 0);
buttonRemoveBranch.Sensitive = b.FriendlyName != currentBranch;
};
buttonRemoveBranch.Sensitive = buttonEditBranch.Sensitive = buttonSetDefaultBranch.Sensitive = false;
// Sources tree
storeRemotes = new TreeStore (typeof(Remote), typeof(string), typeof(string), typeof(string), typeof(string));
treeRemotes.Model = storeRemotes;
treeRemotes.HeadersVisible = true;
SemanticModelAttribute remotesModelAttr = new SemanticModelAttribute ("storeRemotes__Remote", "storeRemotes__Name", "storeRemotes__Url", "storeRemotes__BranchName", "storeRemotes__FullName");
TypeDescriptor.AddAttributes (storeRemotes, remotesModelAttr);
treeRemotes.AppendColumn ("Remote Source / Branch", new CellRendererText (), "markup", 1);
treeRemotes.AppendColumn ("Url", new CellRendererText (), "text", 2);
treeRemotes.Selection.Changed += delegate {
TreeIter it;
bool anythingSelected = treeRemotes.Selection.GetSelected (out it);
buttonTrackRemote.Sensitive = false;
buttonFetch.Sensitive = buttonEditRemote.Sensitive = buttonRemoveRemote.Sensitive = anythingSelected;
if (!anythingSelected)
return;
string branchName = (string) storeRemotes.GetValue (it, 3);
if (branchName != null)
buttonTrackRemote.Sensitive = true;
};
buttonTrackRemote.Sensitive = buttonFetch.Sensitive = buttonEditRemote.Sensitive = buttonRemoveRemote.Sensitive = false;
// Tags list
storeTags = new ListStore (typeof(string));
listTags.Model = storeTags;
listTags.HeadersVisible = true;
listTags.AppendColumn (GettextCatalog.GetString ("Tag"), new CellRendererText (), "text", 0);
listTags.Selection.Changed += delegate {
TreeIter it;
buttonRemoveTag.Sensitive = buttonPushTag.Sensitive = listTags.Selection.GetSelected (out it);
};
buttonRemoveTag.Sensitive = buttonPushTag.Sensitive = false;
// Fill data
FillBranches ();
FillRemotes ();
FillTags ();
}
public CodeIssuePanelWidget(string mimeType)
{
this.mimeType = mimeType;
Build();
var col1 = treeviewInspections.AppendColumn("Title", new CellRendererText(), "markup", 0);
col1.Expand = true;
searchentryFilter.Ready = true;
searchentryFilter.Visible = true;
searchentryFilter.Entry.Changed += ApplyFilter;
var comboRenderer = new CellRendererCombo();
comboRenderer.Alignment = Pango.Alignment.Center;
var col = treeviewInspections.AppendColumn("Severity", comboRenderer);
col.Sizing = TreeViewColumnSizing.GrowOnly;
col.MinWidth = 100;
col.Expand = false;
var comboBoxStore = new ListStore(typeof(string), typeof(Severity));
comboBoxStore.AppendValues(GetDescription(Severity.None), Severity.None);
comboBoxStore.AppendValues(GetDescription(Severity.Error), Severity.Error);
comboBoxStore.AppendValues(GetDescription(Severity.Warning), Severity.Warning);
comboBoxStore.AppendValues(GetDescription(Severity.Hint), Severity.Hint);
comboBoxStore.AppendValues(GetDescription(Severity.Suggestion), Severity.Suggestion);
comboRenderer.Model = comboBoxStore;
comboRenderer.Mode = CellRendererMode.Activatable;
comboRenderer.TextColumn = 0;
comboRenderer.Editable = true;
comboRenderer.HasEntry = false;
comboRenderer.Edited += delegate(object o, Gtk.EditedArgs args) {
Gtk.TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
Gtk.TreeIter storeIter;
if (!comboBoxStore.GetIterFirst(out storeIter))
{
return;
}
do
{
if ((string)comboBoxStore.GetValue(storeIter, 0) == args.NewText)
{
treeStore.SetValue(iter, 1, (Severity)comboBoxStore.GetValue(storeIter, 1));
return;
}
} while (comboBoxStore.IterNext(ref storeIter));
};
col.SetCellDataFunc(comboRenderer, delegate(Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter) {
var val = treeStore.GetValue(iter, 1);
if (val == null)
{
comboRenderer.Visible = false;
return;
}
var severity = (Severity)val;
comboRenderer.Visible = true;
comboRenderer.Text = GetDescription(severity);
comboRenderer.BackgroundGdk = GetColor(severity);
});
treeviewInspections.HeadersVisible = false;
treeviewInspections.Model = treeStore;
treeviewInspections.Selection.Changed += HandleSelectionChanged;
FillInspectors(null);
}
public RegexToolkitWindow () : base(Gtk.WindowType.Toplevel)
{
this.Build ();
this.TransientFor = IdeApp.Workbench.RootWindow;
optionsStore = new ListStore (typeof(bool), typeof(string), typeof(Options));
resultStore = new Gtk.TreeStore (typeof(string), typeof(string), typeof(int), typeof(int));
FillOptionsBox ();
this.buttonCancel.Clicked += delegate {
this.Destroy ();
};
var isWindows = System.IO.Path.DirectorySeparatorChar == '\\';
this.buttonLibrary.Visible = !isWindows;
this.buttonStart.Sensitive = false;
this.entryRegEx.Changed += UpdateStartButtonSensitivity;
this.inputTextview.Buffer.Changed += UpdateStartButtonSensitivity;
this.buttonStart.Clicked += delegate {
if (regexThread != null && regexThread.IsAlive) {
regexThread.Abort ();
regexThread.Join ();
SetButtonStart (GettextCatalog.GetString ("_Start Regular Expression"), "gtk-media-play");
regexThread = null;
return;
}
regexThread = new Thread (delegate() {
PerformQuery (inputTextview.Buffer.Text, this.entryRegEx.Text, this.entryReplace.Text, GetOptions ());
});
regexThread.IsBackground = true;
regexThread.Name = "regex thread";
regexThread.Start ();
SetButtonStart (GettextCatalog.GetString ("_Stop execution"), "gtk-media-stop");
SetFindMode (!checkbuttonReplace.Active);
};
this.buttonLibrary.Clicked += delegate {
if (regexLib == null) {
regexLib = new RegexLibraryWindow ();
regexLib.TransientFor = this;
regexLib.Destroyed += delegate {
regexLib = null;
};
regexLib.Show ();
}
};
SetFindMode (true);
var cellRendText = new CellRendererText ();
cellRendText.Ellipsize = Pango.EllipsizeMode.End;
var pix = new CellRendererPixbuf ();
this.optionsTreeview.Model = this.optionsStore;
this.optionsTreeview.HeadersVisible = false;
CellRendererToggle cellRendToggle = new CellRendererToggle ();
cellRendToggle.Toggled += new ToggledHandler (OptionToggled);
cellRendToggle.Activatable = true;
this.optionsTreeview.AppendColumn ("", cellRendToggle, "active", 0);
this.optionsTreeview.AppendColumn ("", cellRendText, "text", 1);
this.resultsTreeview.Model = this.resultStore;
this.resultsTreeview.HeadersVisible = false;
var col = new TreeViewColumn ();
this.resultsTreeview.AppendColumn (col);
col.PackStart (pix, false);
col.AddAttribute (pix, "stock_id", 0);
col.PackStart (cellRendText, true);
col.AddAttribute (cellRendText, "text", 1);
this.resultsTreeview.RowActivated += delegate(object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
if (resultStore.GetIter (out iter, e.Path)) {
int index = (int)resultStore.GetValue (iter, 2);
int length = (int)resultStore.GetValue (iter, 3);
if (index >= 0) {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (index),
this.inputTextview.Buffer.GetIterAtOffset (index + length));
} else {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (0), this.inputTextview.Buffer.GetIterAtOffset (0));
}
}
};
elementsStore = new Gtk.TreeStore (typeof(string), typeof(string), typeof(string), typeof(string));
this.elementsTreeview.Model = this.elementsStore;
this.elementsTreeview.HeadersVisible = false;
this.elementsTreeview.Selection.Mode = SelectionMode.Browse;
col = new TreeViewColumn ();
this.elementsTreeview.AppendColumn (col);
col.PackStart (pix, false);
col.AddAttribute (pix, "stock_id", 0);
col.PackStart (cellRendText, true);
col.AddAttribute (cellRendText, "text", 1);
var cellRendText2 = new CellRendererText ();
col.PackStart (cellRendText2, false);
col.SetCellDataFunc (cellRendText2, ElementDescriptionFunc);
this.elementsTreeview.Selection.Changed += delegate {
ShowTooltipForSelectedEntry ();
};
this.LeaveNotifyEvent += delegate {
this.HideTooltipWindow ();
};
this.elementsTreeview.MotionNotifyEvent += HandleMotionNotifyEvent;
this.elementsTreeview.RowActivated += delegate (object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
if (elementsStore.GetIter (out iter, e.Path)) {
string text = elementsStore.GetValue (iter, 3) as string;
if (!System.String.IsNullOrEmpty (text)) {
this.entryRegEx.InsertText (text);
}
}
};
this.entryReplace.Sensitive = this.checkbuttonReplace.Active = false;
this.checkbuttonReplace.Toggled += delegate {
this.entryReplace.Sensitive = this.checkbuttonReplace.Active;
};
FillElementsBox ();
this.vbox4.Hide ();
}
public RegexToolkitWidget ()
{
this.Build ();
optionsStore = new ListStore (typeof(bool), typeof(string), typeof(Options));
resultStore = new Gtk.TreeStore (typeof(string), typeof(string), typeof(int), typeof(int));
FillOptionsBox ();
this.entryRegEx.Changed += UpdateStartButtonSensitivity;
this.inputTextview.Buffer.Changed += UpdateStartButtonSensitivity;
SetFindMode (true);
var cellRendText = new CellRendererText ();
cellRendText.Ellipsize = Pango.EllipsizeMode.End;
this.optionsTreeview.Model = this.optionsStore;
this.optionsTreeview.HeadersVisible = false;
CellRendererToggle cellRendToggle = new CellRendererToggle ();
cellRendToggle.Toggled += new ToggledHandler (OptionToggled);
cellRendToggle.Activatable = true;
this.optionsTreeview.AppendColumn ("", cellRendToggle, "active", 0);
this.optionsTreeview.AppendColumn ("", cellRendText, "text", 1);
this.resultsTreeview.Model = this.resultStore;
this.resultsTreeview.HeadersVisible = false;
var col = new TreeViewColumn ();
this.resultsTreeview.AppendColumn (col);
var pix = new CellRendererImage ();
col.PackStart (pix, false);
col.AddAttribute (pix, "stock_id", 0);
col.PackStart (cellRendText, true);
col.AddAttribute (cellRendText, "text", 1);
this.resultsTreeview.RowActivated += delegate(object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
if (resultStore.GetIter (out iter, e.Path)) {
int index = (int)resultStore.GetValue (iter, 2);
int length = (int)resultStore.GetValue (iter, 3);
if (index >= 0) {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (index),
this.inputTextview.Buffer.GetIterAtOffset (index + length));
} else {
this.inputTextview.Buffer.SelectRange (this.inputTextview.Buffer.GetIterAtOffset (0), this.inputTextview.Buffer.GetIterAtOffset (0));
}
}
};
this.entryReplace.Sensitive = this.checkbuttonReplace.Active = false;
this.entryReplace.Changed += delegate {
UpdateRegex ();
};
this.checkbuttonReplace.Toggled += delegate {
this.entryReplace.Sensitive = this.checkbuttonReplace.Active;
UpdateRegex ();
};
this.expandMatches.Toggled += delegate {
UpdateRegex ();
};
this.vbox4.WidthRequest = 380;
this.scrolledwindow5.HeightRequest = 150;
this.scrolledwindow1.HeightRequest = 150;
Show ();
}
Widget MonoDevelop.DesignerSupport.IOutlinedDocument.GetOutlineWidget ()
{
if (outlineTreeView != null)
return outlineTreeView;
outlineTreeStore = new TreeStore (typeof(object));
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView (outlineTreeStore);
var pixRenderer = new CellRendererPixbuf ();
pixRenderer.Xpad = 0;
pixRenderer.Ypad = 0;
outlineTreeView.TextRenderer.Xpad = 0;
outlineTreeView.TextRenderer.Ypad = 0;
TreeViewColumn treeCol = new TreeViewColumn ();
treeCol.PackStart (pixRenderer, false);
treeCol.SetCellDataFunc (pixRenderer, new TreeCellDataFunc (OutlineTreeIconFunc));
treeCol.PackStart (outlineTreeView.TextRenderer, true);
treeCol.SetCellDataFunc (outlineTreeView.TextRenderer, new TreeCellDataFunc (OutlineTreeTextFunc));
outlineTreeView.AppendColumn (treeCol);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
TreeIter iter;
if (!outlineTreeView.Selection.GetSelected (out iter))
return;
object o = outlineTreeStore.GetValue (iter, 0);
int line = -1, col = -1;
if (o is IType) {
line = ((IType)o).BodyRegion.Start.Line;
col = ((IType)o).BodyRegion.Start.Column;
} else if (o is IMember) {
line = ((IMember)o).BodyRegion.Start.Line;
col = ((IMember)o).BodyRegion.Start.Column;
}
if (line > -1) {
Editor.JumpTo (line, Math.Max (1, col));
}
};
this.lastCU = Document.ParsedDocument;
outlineTreeView.Realized += delegate { RefillOutlineStore (); };
var sw = new CompactScrolledWindow ();
sw.Add (outlineTreeView);
sw.ShowAll ();
return sw;
}
public NoteRenameDialog (IList<Note> notes, string oldTitle, Note renamedNote) :
base (Catalog.GetString ("Rename Note Links?"), renamedNote.Window, 0)
{
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;
ContentArea.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, true, true, 0);
notesBox.PackStart (notesButtonBox, false, true, 0);
var advancedExpander = new Expander (Catalog.GetString ("Ad_vanced"));
var expandBox = new VBox ();
expandBox.PackStart (notesBox, true, true, 0);
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);
ContentArea.PackStart (advancedExpander, true, true, 5);
advancedExpander.Activated += (o, e) =>
this.Resizable = advancedExpander.Expanded;
this.Focus = dontRenameButton;
ContentArea.ShowAll ();
}
public InspectionPanelWidget(string mimeType)
{
this.Build();
// this.mimeType = mimeType;
treeviewInspections.AppendColumn("Title", new CellRendererText(), "text", 0);
var comboRenderer = new CellRendererCombo();
var col = treeviewInspections.AppendColumn("Severity", comboRenderer);
var comboBoxStore = new ListStore(typeof(string), typeof(QuickTaskSeverity));
comboBoxStore.AppendValues(GetDescription(QuickTaskSeverity.None), QuickTaskSeverity.None);
comboBoxStore.AppendValues(GetDescription(QuickTaskSeverity.Error), QuickTaskSeverity.Error);
comboBoxStore.AppendValues(GetDescription(QuickTaskSeverity.Warning), QuickTaskSeverity.Warning);
comboBoxStore.AppendValues(GetDescription(QuickTaskSeverity.Hint), QuickTaskSeverity.Hint);
comboBoxStore.AppendValues(GetDescription(QuickTaskSeverity.Suggestion), QuickTaskSeverity.Suggestion);
comboRenderer.Model = comboBoxStore;
comboRenderer.Mode = CellRendererMode.Activatable;
comboRenderer.TextColumn = 0;
comboRenderer.Editable = true;
comboRenderer.HasEntry = false;
comboRenderer.Edited += delegate(object o, Gtk.EditedArgs args) {
Gtk.TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
Gtk.TreeIter storeIter;
if (!comboBoxStore.GetIterFirst(out storeIter))
{
return;
}
Console.WriteLine("new text:" + args.NewText);
do
{
if ((string)comboBoxStore.GetValue(storeIter, 0) == args.NewText)
{
treeStore.SetValue(iter, 1, (QuickTaskSeverity)comboBoxStore.GetValue(storeIter, 1));
return;
}
} while (comboBoxStore.IterNext(ref storeIter));
};
col.SetCellDataFunc(comboRenderer, delegate(Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter) {
var severity = (QuickTaskSeverity)treeStore.GetValue(iter, 1);
comboRenderer.Text = GetDescription(severity);
});
treeviewInspections.HeadersVisible = false;
treeviewInspections.Model = treeStore;
treeviewInspections.Selection.Changed += HandleSelectionChanged;
foreach (var node in RefactoringService.GetInspectors(mimeType))
{
treeStore.AppendValues(node.Title, node.GetSeverity(), node);
}
}
