void ItemToggled(int columnThis, int columnOther, object o, ToggledArgs args)
{
TreeIter iter;
if (store.GetIter(out iter, new TreePath(args.Path)))
{
bool val = (bool)store.GetValue(iter, columnThis);
LogB.Information(string.Format("toggled {0} with value {1}", args.Path, !val));
if (args.Path == "0")
{
if (store.GetIterFirst(out iter))
{
val = (bool)store.GetValue(iter, columnThis);
store.SetValue(iter, columnThis, !val);
store.SetValue(iter, columnOther, val);
while (store.IterNext(ref iter))
{
store.SetValue(iter, columnThis, !val);
store.SetValue(iter, columnOther, val);
}
}
}
else
{
store.SetValue(iter, columnThis, !val);
store.SetValue(iter, columnOther, val);
//usnelect "all" checkboxes
store.GetIterFirst(out iter);
store.SetValue(iter, columnThis, false);
store.SetValue(iter, columnOther, false);
}
}
}
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();
}
private void ItemToggled(object o, ToggledArgs args)
{
int column = 1;
TreeIter iter;
if (store.GetIter(out iter, new TreePath(args.Path)))
{
//Log.WriteLine(args.Path);
if (!Util.FoundInArrayList(nonSensitiveRows,
Convert.ToInt32(args.Path)))
{
bool val = (bool)store.GetValue(iter, column);
//Log.WriteLine (string.Format("toggled {0} with value {1}", args.Path, !val));
store.SetValue(iter, column, !val);
combo_all_none_selected.Active =
UtilGtk.ComboMakeActive(
comboCheckBoxesOptions, Catalog.GetString("Selected"));
//check if there are rows checked for having sensitive or not
//buttonRecuperateChangeSensitiveness();
hbox_error.Hide();
}
else
{
label_error.Text = "Cannot select rows without data";
hbox_error.Show();
}
}
}
private void MarkAction(ToggledArgs e)
{
TreePath treePath = new TreePath(e.Path);
TreeIter row;
treeViewActions.Model.GetIter(out row, treePath);
PriceRule.ActionType actionType = (PriceRule.ActionType)treeViewActions.Model.GetValue(row, 4);
PriceRuleAction action = priceRule.Actions.Find(a => a.Type == actionType);
bool isChecked = (bool)treeViewActions.Model.GetValue(row, 0);
if (isChecked)
{
action.IsActive = false;
treeViewActions.Model.SetValue(row, 0, false);
RefreshPreview();
}
else
{
if (action == null)
{
ManageAction(treeViewActions, treePath);
}
else
{
action.IsActive = true;
treeViewActions.Model.SetValue(row, 0, true);
treeViewActions.Model.SetValue(row, 2, action.ToString());
RefreshPreview();
}
}
}
public void OnCellRendererColumnsToggleEvent(object o, ToggledArgs args)
{
TreeIter iter;
if (!this.attendances.GetIter(out iter, new TreePath(args.Path)))
{
return;
}
CustomCellRendererToggle cellRendererEvent = (CustomCellRendererToggle)o;
// Invert values
bool oldValue = (bool)this.attendances.GetValue(iter, cellRendererEvent.ColumnNumber);
bool newValue = !oldValue;
this.attendances.SetValue(iter, cellRendererEvent.ColumnNumber, !oldValue);
// Depending on newValue, we add or remove the attendance
Person person = this.GetPersonFromAttendancesIter(iter);
if (newValue == true)
{
AttendancesManager.Instance.AddAttendance(person, cellRendererEvent.Event);
}
else
{
AttendancesManager.Instance.RemoveAttendance(person, cellRendererEvent.Event);
}
}
void OnTaskToggled(object o, ToggledArgs args)
{
Logger.Debug("OnTaskToggled");
TreeIter iter;
var path = new TreePath(args.Path);
if (!model.GetIter(out iter, path))
{
return; // Do nothing
}
var task = model.GetValue(iter, 0) as ITask;
if (task == null)
{
return;
}
string statusMsg;
if (task.State == TaskState.Active)
{
task.Complete();
statusMsg = Catalog.GetString("Task Completed");
}
else
{
statusMsg = Catalog.GetString("Action Canceled");
task.Activate();
}
TaskWindow.ShowStatus(statusMsg, 5);
}
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);
}
}
private void OnCelltoggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
int item_index = int.Parse(args.Path);
//if it's checked, remove the check index
//else, add it
bool new_value = (checked_items.IndexOf(item_index) != -1);
if (new_value)
{
checked_items.Remove(item_index);
}
else
{
checked_items.Add(item_index);
}
//raise itemcheck event
if (ItemCheck != null)
{
ItemCheck(this, new ListItemCheckEventArgs(item_index, new_value));
}
}
}
private void DoImplicitToggled(object source, ToggledArgs args)
{
Node node = d_treeview.NodeStore.FindPath(args.Path);
CellRendererToggle toggle = (CellRendererToggle)source;
d_actions.Do(new Undo.ModifyFunctionArgumentExplicit(d_function, node.Argument, !toggle.Active));
}
private void OnDownloadToggled(object o, ToggledArgs args)
{
try
{
CellRendererToggle renderer = (CellRendererToggle)o;
if (!renderer.Sensitive)
{
return;
}
TreeIter iter;
if (!sort.GetIter(out iter, new TreePath(args.Path)))
{
return;
}
PodcastInfo pi = sort.GetValue(iter, 0) as PodcastInfo;
if (!pi.IsQueued)
{
PodcastCore.QueuePodcastDownload(pi);
}
else
{
PodcastCore.CancelPodcastDownload(pi);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
void RandomLocationToggled(object o, ToggledArgs args)
{
TreeIter iter;
store.GetIter(out iter, new TreePath(args.Path));
store.SetValue(iter, 6, !((bool)store.GetValue(iter, 6)));
}
private void ToggleRendererToggled(object o, ToggledArgs args)
{
var path = new TreePath(args.Path);
var listItem = (InterfaceListItem)this.NodeStore.GetNode(path);
listItem.Active = !listItem.Active;
}
protected void OnComponentSelected(object _inst, ToggledArgs _args)
{
TreeIter it;
m_TreeStore.GetIter(out it, new TreePath(_args.Path));
(m_TreeStore.GetValue(it, 0) as UIComponentDescriptor).Selected = !(_inst as CellRendererToggle).Active;
}
protected void OnPluginToggle(object sender, ToggledArgs args)
{
string addinId;
bool enabled;
TreeIter iter;
ListStore store;
store = Model as ListStore;
if (!store.GetIter(out iter, new TreePath(args.Path)))
{
return;
}
addinId = (string)store.GetValue(iter, (int)Column.Id);
enabled = (bool)store.GetValue(iter, (int)Column.Enabled);
// Set the check state.
store.SetValue(iter, (int)Column.Enabled, !enabled);
// Flush the gui thread so the checkbox state changes right away.
Services.Application.FlushMainThreadQueue();
// Notify subscribers.
if (null != PluginToggled)
{
PluginToggled(addinId, !enabled);
}
// Set checked state again (don't assume enable/disable worked).
store.SetValue(iter, (int)Column.Enabled,
AddinManager.Registry.IsAddinEnabled(addinId));
}
private void FavToggle_Toggled(object sender, ToggledArgs args)
{
_tableStore.GetIter(out TreeIter treeIter, new TreePath(args.Path));
string titleId = _tableStore.GetValue(treeIter, 2).ToString().Split("\n")[1].ToLower();
string metadataPath = System.IO.Path.Combine(new VirtualFileSystem().GetBasePath(), "games", titleId, "gui", "metadata.json");
IJsonFormatterResolver resolver = CompositeResolver.Create(new[] { StandardResolver.AllowPrivateSnakeCase });
ApplicationMetadata appMetadata;
using (Stream stream = File.OpenRead(metadataPath))
{
appMetadata = JsonSerializer.Deserialize <ApplicationMetadata>(stream, resolver);
}
if ((bool)_tableStore.GetValue(treeIter, 0))
{
_tableStore.SetValue(treeIter, 0, false);
appMetadata.Favorite = false;
}
else
{
_tableStore.SetValue(treeIter, 0, true);
appMetadata.Favorite = true;
}
byte[] saveData = JsonSerializer.Serialize(appMetadata, resolver);
File.WriteAllText(metadataPath, Encoding.UTF8.GetString(saveData, 0, saveData.Length).PrettyPrintJson());
}
void OnAttributeViewerToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (attrPluginStore.GetIter(out iter, new TreePath(args.Path)))
{
bool old = (bool)attrPluginStore.GetValue(iter, 0);
string name = (string)attrPluginStore.GetValue(iter, 1);
AttributeViewPlugin vp = Global.Plugins.FindAttributeView(name);
if (!conn.AttributeViewers.Contains(vp.GetType().ToString()))
{
conn.AttributeViewers.Add(vp.GetType().ToString());
}
else
{
conn.AttributeViewers.Remove(vp.GetType().ToString());
}
Global.Connections [conn.Settings.Name] = conn;
attrPluginStore.SetValue(iter, 0, !old);
}
}
void OnItemToggled(object s, ToggledArgs args)
{
Gtk.TreeIter it;
listStore.GetIterFromString(out it, args.Path);
bool run = (bool)listStore.GetValue(it, 1);
listStore.SetValue(it, 1, !run);
}
private void FixedToggled(object o, ToggledArgs args)
{
Gtk.TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
bool val = (bool)store.GetValue(iter, 0);
store.SetValue(iter, 0, !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);
}
private void CategoryItem_Toggled(object sender, ToggledArgs args)
{
_categoryStore.GetIter(out var iter, new TreePath(args.Path));
Console.WriteLine(iter);
var item = (Category)_categoryStore.GetValue(iter, 0);
item.CategoryActive = !item.CategoryActive;
}
private void OnRendererToggleToggled(object o, ToggledArgs args)
{
WrapperNode node = d_treeview.NodeStore.FindPath(args.Path);
if (node != null)
{
node.Checked = !node.Checked;
}
}
private void ItemToggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (store.Store.GetIterFromString(out iter, args.Path))
{
store.ToggleSelect(iter);
}
}
void ToggleHandler(object o, ToggledArgs args)
{
TreeIter iter;
treeview.Model.GetIter(out iter, new TreePath(args.Path));
bool oldVal = (bool)treeview.Model.GetValue(iter, 0);
treeview.Model.SetValue(iter, 0, !oldVal);
}
void AnswerTypeToggled(object o, ToggledArgs args)
{
TreeIter iter;
testAnswers.GetIter(out iter, new Gtk.TreePath(args.Path));
var answer = testAnswers.GetValue(iter, 0) as TestAnswer;
answer.Correct = !answer.Correct;
}
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));
}
}
void PackageSourceCheckBoxToggled(object o, ToggledArgs args)
{
TreeIter iter;
packageSourcesStore.GetIterFromString(out iter, args.Path);
PackageSourceViewModel packageSourceViewModel = GetPackageSourceViewModel(iter);
packageSourceViewModel.IsEnabled = !packageSourceViewModel.IsEnabled;
packageSourcesStore.SetValue(iter, IsEnabledCheckBoxColumn, packageSourceViewModel.IsEnabled);
}
/// <summary>
/// Handles the export mip toggle clicked event.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">E.</param>
protected void OnExportMipToggleClicked(object sender, ToggledArgs e)
{
TreeIter Iter;
MipLevelListStore.GetIterFromString(out Iter, e.Path);
bool currentValue = (bool)MipLevelListStore.GetValue(Iter, 0);
MipLevelListStore.SetValue(Iter, 0, !currentValue);
}
private void ItemToggled(object sender, ToggledArgs args)
{
TreeIter iter;
if (store.GetIterFromString(out iter, args.Path))
{
bool val = (bool)store.GetValue(iter, columnSelected);
store.SetValue(iter, columnSelected, !val);
}
}
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 OnTaskToggled(object o, ToggledArgs args)
{
Logger.Debug ("OnTaskToggled");
TreeIter iter;
var path = new TreePath (args.Path);
if (!model.GetIter (out iter, path))
return; // Do nothing
var task = model.GetValue (iter, 0) as ITask;
if (task == null)
return;
string statusMsg;
if (task.State == TaskState.Active) {
task.Complete ();
statusMsg = Catalog.GetString ("Task Completed");
} else {
statusMsg = Catalog.GetString ("Action Canceled");
task.Activate ();
}
TaskWindow.ShowStatus (statusMsg, 5);
}
void OnTaskToggled(object o, ToggledArgs args)
{
Logger.Debug ("OnTaskToggled");
TreeIter iter;
var path = new TreePath (args.Path);
if (!model.GetIter (out iter, path))
return; // Do nothing
var task = model.GetValue (iter, 0) as ITask;
if (task == null)
return;
// remove any timer set up on this task
var timerCol = (TimerColumn)view.GetColumn (typeof (TimerColumn));
var tmr = timerCol.GetTimer (task);
if (tmr != null)
tmr.Cancel ();
if (task.State == TaskState.Active) {
bool showCompletedTasks = preferences.GetBool (PreferencesKeys.ShowCompletedTasksKey);
// When showCompletedTasks is true, complete the tasks right
// away. Otherwise, set a timer and show the timer animation
// before marking the task completed.
if (showCompletedTasks) {
task.Complete ();
var statusMsg = Catalog.GetString ("Task Completed");
TaskWindow.ShowStatus (statusMsg, 5000);
} else {
var timer = timerCol.CreateTimer (task);
timer.TimerStopped += (s, e) => {
if (!e.Canceled)
e.Task.Complete ();
};
timer.Tick += (s, e) => {
var statusMsg = string.Format (
Catalog.GetString ("Completing Task In: {0}"), e.CountdownTick);
TaskWindow.ShowStatus (statusMsg, 2000);
};
timer.Start ();
}
} else {
var statusMsg = Catalog.GetString ("Action Canceled");
TaskWindow.ShowStatus (statusMsg, 5000);
task.Activate ();
}
}
