void HandleOnlyClicked(object o, ClickedArgs args)
{
TreeIter iter;
ToggleAll(false);
if (store.GetIterFromString(out iter, args.Path))
{
UpdateSelection(iter, true);
}
}
void OnTitleToggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (treeStore.GetIterFromString(out iter, args.Path))
{
var provider = (Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor>)treeStore.GetValue(iter, 1);
enableState [provider] = !enableState [provider];
}
}
private void boolCellRend_Toggled(object o, ToggledArgs args)
{
TreeIter iter;
restsTreeStore.GetIterFromString(out iter, args.Path);
bool oldVal = (bool)restsTreeStore.GetValue(iter, 1);
bool newVal = !oldVal;
SetTreeStoreChildren(iter, newVal);
if (newVal)
{
SetTreeStoreParent(iter, true);
}
btnApply.Sensitive = true;
if (selectedAccessLevel == null)
{
return;
}
UserAccessLevel changedAccessLevel = selectedAccessLevel.Value;
if (!changedAccessLevels.Contains(changedAccessLevel))
{
changedAccessLevels.Add(changedAccessLevel);
}
}
protected virtual void OnToggled(object sender, Gtk.ToggledArgs args)
{
TreeIter iter;
store.GetIterFromString(out iter, args.Path);
bool sel = (bool)store.GetValue(iter, 2);
string cat = (string)store.GetValue(iter, 0);
if (sel)
{
selection.Remove(cat);
}
else
{
selection.Add(cat);
}
store.SetValue(iter, 2, !sel);
// A 'main' category must always be selected when a subcategory is selected
while (store.IterParent(out iter, iter))
{
string txt = (string)store.GetValue(iter, 1);
if (txt.StartsWith("<b>"))
{
store.SetValue(iter, 2, true);
cat = (string)store.GetValue(iter, 0);
if (!selection.Contains(cat))
{
selection.Add(cat);
}
}
}
}
void OnCommitToggledHandler(object o, ToggledArgs args)
{
TreeIter pos;
if (!filestore.GetIterFromString(out pos, args.Path))
{
return;
}
string localpath = (string)filestore.GetValue(pos, ColFullPath);
if (changeSet.ContainsFile(localpath))
{
changeSet.RemoveFile(localpath);
}
else
{
VersionInfo vi = GetVersionInfo(localpath);
if (vi != null)
{
changeSet.AddFile(vi);
}
}
filestore.SetValue(pos, ColCommit, changeSet.ContainsFile(localpath));
UpdateSelectionStatus();
}
void OnCategoryEdited(object sender, EditedArgs args)
{
TreeIter iter;
if (!store.GetIterFromString(out iter, args.Path))
{
return;
}
string old = (string)store.GetValue(iter, 0);
if (args.NewText.Length == 0)
{
options.Categories.Remove(old);
store.Remove(ref iter);
}
else
{
int i = options.Categories.IndexOf(old);
if (i == -1)
{
options.Categories.Add(args.NewText);
}
else
{
options.Categories [i] = args.NewText;
}
store.SetValue(iter, 0, args.NewText);
}
}
void OnExpEditing(object s, Gtk.EditingStartedArgs args)
{
TreeIter it;
if (!store.GetIterFromString(out it, args.Path))
{
return;
}
Gtk.Entry e = (Gtk.Entry)args.Editable;
if (e.Text == createMsg)
{
e.Text = string.Empty;
}
OnStartEditing(args);
}
void HandleSpinEdited(object o, EditedArgs args)
{
TreeIter it;
if (bugsStore.GetIterFromString(out it, args.Path))
{
int val;
if (int.TryParse(args.NewText, out val))
{
if (val < 0)
{
val = 0;
}
if (val > 10)
{
val = 10;
}
BugInfo bi = (BugInfo)bugsStore.GetValue(it, ColBug);
if (bi != null)
{
bugsStore.SetValue(it, ColPriority, val);
bi.LocalPriority = val;
}
}
}
}
void ToggleRendererToggled(object o, ToggledArgs args)
{
Gtk.TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
bool active = (bool)store.GetValue(iter, 0);
store.SetValue(iter, 0, !active);
}
}
private void toglCellRend_Toggled(object o, ToggledArgs args)
{
TreeIter iter;
groupsTreeStore.GetIterFromString(out iter, args.Path);
bool oldVal = (bool)groupsTreeStore.GetValue(iter, 1);
groupsTreeStore.SetValue(iter, 1, !oldVal);
}
public ContextActionPanelWidget(string mimeType)
{
this.mimeType = mimeType;
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
this.Build();
// ensure selected row remains visible
treeviewContextActions.SizeAllocated += (o, args) => {
TreeIter iter;
if (treeviewContextActions.Selection.GetSelected(out iter))
{
var path = treeviewContextActions.Model.GetPath(iter);
treeviewContextActions.ScrollToCell(path, treeviewContextActions.Columns[0], false, 0f, 0f);
}
};
var col = new TreeViewColumn();
searchentryFilter.ForceFilterButtonVisible = true;
searchentryFilter.RoundedShape = true;
searchentryFilter.HasFrame = true;
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 = (CodeRefactoringDescriptor)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 {
Ellipsize = Pango.EllipsizeMode.End
};
col.PackStart(textRender, true);
col.AddAttribute(textRender, "markup", 0);
treeviewContextActions.AppendColumn(col);
treeviewContextActions.HeadersVisible = false;
treeviewContextActions.Model = treeStore;
treeviewContextActions.SearchColumn = -1; // disable the interactive search
GetAllProviderStates();
FillTreeStore(null);
treeviewContextActions.TooltipColumn = 3;
treeviewContextActions.HasTooltip = true;
}
protected void HandleFilterCellToggled(object o, ToggledArgs args)
{
Gtk.TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
bool active = !((bool)store.GetValue(iter, 1));
UpdateSelection(iter, active);
}
}
void CellRendererToggle_Toggled(object o, ToggledArgs args)
{
TreeIter iter;
if (model.GetIterFromString(out iter, args.Path))
{
var tag_id = (uint)model.GetValue(iter, 0);
ToggleTag(tag_id);
}
}
void ToggleEventHandler(object o, ToggledArgs args)
{
TreeIter itr;
if (store.GetIterFromString(out itr, args.Path))
{
bool isToggled = !(bool)store.GetValue(itr, 0);
store.SetValue(itr, 0, isToggled);
}
}
private void ItemToggled(object o, ToggledArgs args)
{
Gtk.TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
Task task = (Task)store.GetValue(iter, DataColumns.Task);
task.Completed = !task.Completed;
TaskService.FireTaskToggleEvent(this, new TaskEventArgs(task));
}
}
protected void ToggleSelection(object sender, ToggledArgs args)
{
//Console.WriteLine("Toggle");
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
var file = store.GetValue(iter, 0) as AudioFile;
file.Selected = !file.Selected;
}
}
void OnSelectToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (!store.GetIterFromString(out iter, args.Path))
{
return;
}
bool old_value = GetChecked(iter);
store.SetValue(iter, colCheckedIndex, !old_value);
TreeIter parent;
if (store.IterParent(out parent, iter))
{
// Member(method/property/etc) row clicked
// Set the parent's 'checked' state according to the children's state
bool all_children_checked = true;
foreach (TreeIter child in GetAllNodes(parent, false))
{
if (!GetChecked(child))
{
all_children_checked = false;
break;
}
}
store.SetValue(parent, colCheckedIndex, all_children_checked);
}
else
{
// Mark children's state to match parent's checked state
foreach (TreeIter child in GetAllNodes(iter, false))
{
store.SetValue(child, colCheckedIndex, !old_value);
}
}
UpdateOKButton();
}
void ToggleRenderToggled(object o, ToggledArgs args)
{
Gtk.TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
bool isToggled = !(bool)store.GetValue(iter, Columns.IsToggled);
store.SetValue(iter, Columns.IsToggled, isToggled);
if (store.IterHasChild(iter))
{
SetSubtreeIsToggled(iter, isToggled);
}
}
}
void OnActionToggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
var provider = (CodeRefactoringDescriptor)treeStore.GetValue(iter, 2);
providerStates [provider] = !providerStates [provider];
treeStore.SetValue(iter, 1, providerStates [provider]);
}
void OnToggleItem (object ob, Gtk.ToggledArgs args)
{
Gtk.TreeIter it;
if (store.GetIterFromString (out it, args.Path)) {
bool b = (bool) store.GetValue (it, ColChecked);
ItemToolboxNode item = (ItemToolboxNode) store.GetValue (it, ColItem);
if (!b)
currentItems.Add (item, item);
else
currentItems.Remove (item);
store.SetValue (it, ColChecked, !b);
}
}
public void SelectHeaderLine()
{
TreeIter iter = new TreeIter();
TreeModel myModel = treeview.Model;
if (treeview.Selection.GetSelected(out myModel, out iter))
{
string pathString = store.GetPath(iter).ToString();
string [] myStrFull = pathString.Split(new char[] { ':' });
string pathStringZero = myStrFull[0] + ":" + myStrFull[1];
TreeIter iter2;
store.GetIterFromString(out iter2, pathStringZero);
treeview.Selection.SelectIter(iter2);
}
}
public void ComboboxEdited(object o, EditedArgs args)
{
TreeIter iter;
if (model.GetIterFromString(out iter, args.Path))
{
var info = GetProperty(model, iter);
if (info == null)
{
return;
}
var value = ConvertProperty(info.PropertyType, args.NewText);
info.SetValue(dialog.profile, value, null);
dialog.UpdateExample(model, iter);
}
}
ExecutionTarget GetActiveTarget()
{
int active = runtimeCombo.Active;
if (active < 0)
{
return(null);
}
TreeIter iter;
if (!runtimeStore.GetIterFromString(out iter, active.ToString()))
{
return(null);
}
return((ExecutionTarget)runtimeStore.GetValue(iter, 2));
}
string GetActiveConfiguration()
{
int active = configurationCombo.Active;
if (active < 0)
{
return(null);
}
TreeIter iter;
if (!configurationStore.GetIterFromString(out iter, active.ToString()))
{
return(null);
}
return((string)configurationStore.GetValue(iter, 1));
}
void OnToggled(object sender, Gtk.ToggledArgs args)
{
TreeIter iter;
store.GetIterFromString(out iter, args.Path);
IBuildTarget ob = (IBuildTarget)store.GetValue(iter, 2);
if (activeItems.Contains(ob))
{
activeItems.Remove(ob);
if (CascadeCheckboxSelection)
{
foreach (var i in GetAllChildren(ob))
{
activeItems.Remove(i);
}
SetSelection(iter, null, new HashSet <IBuildTarget> ());
}
else
{
store.SetValue(iter, 3, false);
}
}
else
{
activeItems.Add(ob);
if (CascadeCheckboxSelection)
{
foreach (var i in GetAllChildren(ob))
{
activeItems.Add(i);
}
SetSelection(iter, null, activeItems);
}
else
{
store.SetValue(iter, 3, true);
}
}
if (ActiveChanged != null)
{
ActiveChanged(this, EventArgs.Empty);
}
}
public void UpdateCbSelectMarking()
{
// try to save old selected marking
TreeIter oldIter;
string oldPath;
if (cbSelectMarking.GetActiveIter(out oldIter))
{
oldPath = cbSelectMarking.Model.GetStringFromIter(oldIter);
}
else
{
oldPath = "0"; // root by default
}
// create new store
TreeStore store = new TreeStore(typeof(string));
TreeIter iter0 = store.AppendValues("None");
TreeIter iter1 = store.AppendValues("BreakroundOnRanking");
string[][] pre = AppSettings.I.GenerateRound.breakConfigPresets;
for (int i = 0; i < pre.Length; i++)
{
store.AppendValues(iter1, pre[i][0]);
}
TreeIter iter2 = store.AppendValues("BreakroundOnRound");
foreach (RoundData rd in Tournament.I.Rounds)
{
store.AppendValues(iter2, rd.RoundName);
}
cbSelectMarking.Model = store;
// try to set to old marking
TreeIter newIter;
if (store.GetIterFromString(out newIter, oldPath))
{
cbSelectMarking.SetActiveIter(newIter);
}
else
{
cbSelectMarking.SetActiveIter(iter0); // select root by default
}
}
public void Toggled(object o, ToggledArgs args)
{
TreeIter iter;
if (model.GetIterFromString(out iter, args.Path))
{
var info = GetProperty(model, iter);
if (info == null || info.PropertyType != typeof(bool))
{
return;
}
bool value = (bool)info.GetValue(dialog.profile, null);
info.SetValue(dialog.profile, !value, null);
dialog.UpdateExample(model, iter);
// When toggeling with the keyboard the tree view doesn't update automatically
// see 'Bug 188 - Pressing space to select does not update checkbox'
treeView.QueueDraw();
}
}
void ItemToggled(object o, ToggledArgs args)
{
breakpoints.Changed -= OnBreakpointChanged;
try {
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
BreakEvent bp = (BreakEvent)store.GetValue(iter, (int)Columns.Breakpoint);
bp.Enabled = !bp.Enabled;
store.SetValue(iter, (int)Columns.Icon, GetIconId(bp));
store.SetValue(iter, (int)Columns.Selected, bp.Enabled);
}
} finally {
breakpoints.Changed += OnBreakpointChanged;
}
}
//checkbox state changed
private void OnCelltoggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
HTreeNode nod = getNodeFromIter(iter);
nod.Checked = !nod.Checked;
//(de)select all childs
if (nod.Checked)
{
nod.selectAllChilds();
}
else
{
nod.deselectAllChilds();
}
}
}
public NameConventionEditRuleDialog(NameConventionRule rule)
{
if (rule == null)
{
throw new System.ArgumentNullException("rule");
}
this.rule = rule;
this.Build();
treeviewEntities.AppendColumn("Entity", new CellRendererText(), "text", 0);
var ct1 = new CellRendererToggle();
ct1.Toggled += delegate(object o, Gtk.ToggledArgs args)
{
TreeIter iter;
if (!entityStore.GetIterFromString(out iter, args.Path))
{
return;
}
entityStore.SetValue(iter, 2, !(bool)entityStore.GetValue(iter, 2));
};
treeviewEntities.AppendColumn("IsChecked", ct1, "active", 2);
treeviewEntities.Model = entityStore;
treeviewAccessibility.AppendColumn("Entity", new CellRendererText(), "text", 0);
var ct2 = new CellRendererToggle();
ct2.Toggled += delegate(object o, Gtk.ToggledArgs args)
{
TreeIter iter;
if (!accessibiltyStore.GetIterFromString(out iter, args.Path))
{
return;
}
accessibiltyStore.SetValue(iter, 2, !(bool)accessibiltyStore.GetValue(iter, 2));
};
treeviewAccessibility.AppendColumn("IsChecked", ct2, "active", 2);
treeviewAccessibility.Model = accessibiltyStore;
buttonOk.Clicked += (sender, e) => Apply();
FillDialog();
}
