void nameCell_Edited(object o, EditedArgs args)
{
TreeIter iter;
TreeStore.GetIter(out iter, new Gtk.TreePath(args.Path));
var n = TreeStore.GetValue(iter, 0) as INode;
if (n != null && args.NewText != n.Name &&
DRenameRefactoring.CanRenameNode(n) &&
DRenameRefactoring.IsValidIdentifier(args.NewText))
{
RefactoringService.AcceptChanges(
IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor("Rename item", null),
new DRenameRefactoring().PerformChanges(
new RefactoringOptions(IdeApp.Workbench.ActiveDocument)
{
SelectedItem = n
},
new MonoDevelop.Refactoring.Rename.RenameRefactoring.RenameProperties {
NewName = args.NewText
}));
TreeView.Selection.SelectIter(iter);
TreeView.GrabFocus();
}
}
void handleExtensionSet(object sender, EditedArgs args)
{
//check extension is valid and not a duplicate
string newval = args.NewText == null? null : args.NewText.ToLowerInvariant().Trim();
if (string.IsNullOrEmpty(newval))
{
//FIXME: give an error message?
return;
}
foreach (char c in newval)
{
if (!char.IsLetterOrDigit(c) && c != '.')
{
//FIXME: give an error message?
return;
}
}
foreach (string s in WalkStore(defaultAssociationsStore, COL_EXT))
{
if (s == newval)
{
//FIXME: give an error message?
return;
}
}
setAssocValAndMarkChanged(args.Path, COL_EXT, newval);
}
void KeyRendererEditingFinished(object o, EditedArgs args)
{
try {
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
var obj = (PObject)treeStore.GetValue(iter, 1);
var dict = obj.Parent as PDictionary;
if (dict != null)
{
var keys = Scheme.Keys.Cast <PListScheme.SchemaItem> ();
if (treeStore.IterParent(out iter, iter))
{
var subkey = (PListScheme.SchemaItem)treeStore.GetValue(iter, 2) ?? PListScheme.Key.Empty;
keys = subkey.Values;
}
var key = keys.FirstOrDefault(k => k.Identifier == args.NewText || k.Description == args.NewText);
var newKey = key == null ? args.NewText : key.Identifier;
dict.ChangeKey(obj, newKey, key == null ? null : key.Create());
}
} catch (Exception ex) {
GLib.ExceptionManager.RaiseUnhandledException(ex, false);
}
}
void IdCell_Edited(object o, EditedArgs args)
{
string value = args.NewText;
int parsedValue;
//check if NewText is a int
bool successfullyParsed = int.TryParse(value, out parsedValue);
if (!successfullyParsed)
{
lblMessageBottom.Visible = true;
lblMessageBottom.Text = "ID moet een getal zijn!";
}
else
{
if (model.GetIter(out iter, new TreePath(args.Path)))
{
//write new value to liststore
personsListStore.SetValue(iter, 0, args.NewText);
lblMessageBottom.Visible = true;
lblMessageBottom.Text = "";
lblMessageBottom.Visible = false;
}
}
}
void ZipcodeCell_Edited(object o, EditedArgs args)
{
string value = args.NewText;
int parsedValue;
//check if NewText is a int
bool successfullyParsed = int.TryParse(value, out parsedValue);
if (!successfullyParsed)
{
lblMessageBottom.Visible = true;
lblMessageBottom.Text = "Postcode moet een getal zijn!";
}
else
{
if (Convert.ToInt32(args.NewText) >= 1000 && Convert.ToInt32(args.NewText) <= 9992)
{
if (model.GetIter(out iter, new TreePath(args.Path)))
{
//write new value to liststore
personsListStore.SetValue(iter, 4, args.NewText);
lblMessageBottom.Visible = true;
lblMessageBottom.Text = "";
lblMessageBottom.Visible = false;
}
}
else
{
lblMessageBottom.Visible = true;
lblMessageBottom.Text = "Postcode tussen 1000 en 9992";
}
}
}
private void OnCellEdited(object sender, EditedArgs args)
{
int row;
int col;
// Get current position
TreePath rowPath;
TreeIter rowPointer;
TreeViewColumn colPath;
// Convert path in row and rowPointer
rowPath = new Gtk.TreePath(args.Path);
tvTable.Model.GetIter(out rowPointer, rowPath);
row = rowPath.Indices[0];
// Find out the column order
tvTable.GetCursor(out rowPath, out colPath);
for (col = 0; col < tvTable.Columns.Length; ++col)
{
if (tvTable.Columns[col] == colPath)
{
break;
}
}
// Store data
tvTable.Model.SetValue(rowPointer, col, args.NewText);
if (tableChanged != null)
{
tableChanged(row, col, args.NewText);
}
}
void OnCategoryEdited(object sender, EditedArgs args)
{
TreeIter iter;
if (!store.GetIter(out iter, new TreePath(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);
}
}
private void TextEditedForSize(object sender, EditedArgs args)
{
TreeIter iter;
if (treeviewMain.Model.GetIterFromString(out iter, args.Path))
{
string tmpSize = (string)treeviewMain.Model.GetValue(iter, (int)FixedColumns.Size);
if (tmpSize == ROW_TERMINATOR)
{
if ((args.NewText != ROW_TERMINATOR) &&
(args.NewText != "0"))
{
treeviewMain.Model.SetValue(iter, (int)FixedColumns.Size, args.NewText);
treeviewMain.Model.SetValue(iter, (int)FixedColumns.Type, "Hex");
ListStore tmp = (ListStore)treeviewMain.Model;
tmp.AppendValues(ROW_TERMINATOR, "");
treeviewMain.Model = tmp;
}
}
else if (args.NewText == "0")
{
ListStore tmp = (ListStore)treeviewMain.Model;
tmp.Remove(ref iter);
treeviewMain.Model = tmp;
}
else
{
treeviewMain.Model.SetValue(iter, (int)FixedColumns.Size, args.NewText);
}
}
}
void OnEditedTip(object o, EditedArgs args)
{
TreeIter iter;
treeview_orderlist.Model.GetIter(out iter, new TreePath(args.Path));
int index = (int)treeview_orderlist.Model.GetValue(iter, 5);
int tip;
if (!Utils.ParseInteger(args.NewText, out tip, this))
{
return;
}
m_allOrders[index].tip = tip;
treeview_orderlist.Model.SetValue(iter, 3, args.NewText);
var order = m_allOrders[index];
int ordIdx = IsContainOrder(ref m_updateOrders, order.customer, order.food);
if (ordIdx != -1)
{// 已经在数组里面
m_updateOrders[ordIdx] = order;
}
else
{
m_updateOrders.Add(order);
}
}
private void TypeEdited(object sender, EditedArgs args)
{
TreeIter iter;
if (storeColumns.GetIterFromString(out iter, args.Path))
{
if (!string.IsNullOrEmpty(args.NewText))
{
ColumnSchema column = storeColumns.GetValue(iter, colObjIndex) as ColumnSchema;
int len = int.Parse(storeColumns.GetValue(iter, colLengthIndex) as string);
if (column.DataType.LengthRange.Default == len)
{
//change the length if it is still the default length
DataTypeSchema dtNew = schemaProvider.GetDataType(args.NewText);
storeColumns.SetValue(iter, colLengthIndex, dtNew.LengthRange.Default.ToString());
}
storeColumns.SetValue(iter, colTypeIndex, args.NewText);
column.DataTypeName = args.NewText;
EmitContentChanged();
}
else
{
string oldText = storeColumns.GetValue(iter, colTypeIndex) as string;
(sender as CellRendererText).Text = oldText;
}
}
}
/// <summary>
/// Editar a celula de texto
/// </summary>
private void EditText(object o, EditedArgs args)
{
// Obtendo referencia do processo apartir dos argumentos recebidos
processListStore.GetIter(out TreeIter iter, new Gtk.TreePath(args.Path));
Process process = (Process)processListStore.GetValue(iter, 0);
// Obtendo referencia da coluna apartir da referencia da celula
CellRendererText cell = (CellRendererText)o;
TreeViewColumn column = columns[cells.IndexOf(cell)];
switch (column.Title)
{
case "Nome":
process.name = args.NewText;
break;
case "Tempo de Chegada":
int.TryParse(args.NewText, out process.arrivalTime);
break;
case "Tempo de Execução":
int.TryParse(args.NewText, out process.runtime);
break;
default:
(cell as CellRendererText).Text = "Coluna Indefinida";
break;
}
}
void HandleEdited(object o, EditedArgs args)
{
Gtk.TreeIter iter;
templates.GetIter(out iter, new Gtk.TreePath(args.Path));
string name = (string)templates.GetValue(iter, 2);
if (name != args.NewText)
{
if (templatesNames.Contains(args.NewText))
{
Config.GUIToolkit.ErrorMessage(Catalog.GetString("A dashboard with the same name already exists"), this);
args.RetVal = false;
}
else
{
try {
Dashboard dashboard = provider.Load(name);
dashboard.Name = args.NewText;
provider.Save(dashboard);
provider.Delete(name);
templatesNames.Remove(name);
templatesNames.Add(dashboard.Name);
// Change displayed name and template name in our store
templates.SetValue(iter, 1, args.NewText);
templates.SetValue(iter, 2, args.NewText);
} catch (Exception ex) {
Config.GUIToolkit.ErrorMessage(ex.Message);
}
}
}
}
void HandleDescriptionCellEdited(object o, EditedArgs args)
{
TreeIter iter;
subtaskList.GetIterFromString(out iter, args.Path);
subtaskList.SetValue(iter, 1, args.NewText);
}
void on_cellrender_edited(object sender, EditedArgs args)
{
// root group can't be edited
if (selected_id == root_group.ID)
{
return;
}
BookmarkBase bk = null;
BookmarkManager.GetBookmarkBase(root_group, selected_id, ref bk);
if (bk == null)
{
Console.WriteLine("error, could not retrieve bookmark:{0}", selected_id);
return;
}
// it is not a bookmark
bk.Name = args.NewText;
//refreshing tree_view
BookmarkManager.Refresh();
BuildTreeView();
}
private void ListCell_Edited(object o, EditedArgs args)
{
TreeIter iter;
ListStore.GetIter(out iter, new TreePath(args.Path));
int i = Convert.ToInt32(args.Path);
if (args.NewText != "")
{
if ((string)ListStore.GetValue(iter, 0) == "")
{
ListStore.AppendValues("");
Selected.ComboBoxValues.Add(args.NewText);
}
else
{
Selected.ComboBoxValues[i] = args.NewText;
}
ListStore.SetValue(iter, 0, args.NewText);
}
else
if ((string)ListStore.GetValue(iter, 0) != "")
{
ListStore.Remove(ref iter);
Selected.ComboBoxValues.RemoveAt(i);
}
}
void OnEditedConsiderTime(object o, EditedArgs args)
{
TreeIter iter;
treeview_orderlist.Model.GetIter(out iter, new TreePath(args.Path));
int index = (int)treeview_orderlist.Model.GetValue(iter, 5);
float considerTime;
if (!Utils.ParseFloat(args.NewText, out considerTime, this))
{
return;
}
m_allOrders[index].consider_time = considerTime;
treeview_orderlist.Model.SetValue(iter, 4, args.NewText);
var order = m_allOrders[index];
int ordIdx = IsContainOrder(ref m_updateOrders, order.customer, order.food);
if (ordIdx != -1)
{// 已经在数组里面
m_updateOrders[ordIdx] = order;
}
else
{
m_updateOrders.Add(order);
}
}
private void ListWithValues2Cell_Edited(object o, EditedArgs args)
{
TreeIter iter;
ListWithValuesStore.GetIter(out iter, new TreePath(args.Path));
int i = Convert.ToInt32(args.Path);
string another = (string)ListWithValuesStore.GetValue(iter, 0);
if (args.NewText != "")
{
if ((string)ListWithValuesStore.GetValue(iter, 1) == "" && another != "")
{
ListWithValuesStore.AppendValues("", "");
Selected.ComboBoxValues.Add(another + ": " + args.NewText);
}
}
else
if ((string)ListWithValuesStore.GetValue(iter, 1) != "" && another != "")
{
Selected.ComboBoxValues.RemoveAt(i);
}
else
{
ListWithValuesStore.Remove(ref iter);
}
ListWithValuesStore.SetValue(iter, 1, args.NewText);
}
void AppearanceEdited(object o, EditedArgs args)
{
TreeIter iter;
store.GetIter(out iter, new TreePath(args.Path));
int value;
string NewText;
if (args.NewText.EndsWith("%"))
{
NewText = args.NewText.Substring(0, args.NewText.Length - 1);
}
else
{
NewText = args.NewText;
}
if (int.TryParse(NewText, out value))
{
if (value < 0)
{
value = 0;
}
if (value > 100)
{
value = 100;
}
store.SetValue(iter, 5, value);
}
}
private void OnCommentForFineEdited(object o, EditedArgs args)
{
if (!string.IsNullOrEmpty(args.NewText))
{
ViewModel.SelectedItem.CommentForFineAuthor = ViewModel.CurrentEmployee;
}
}
protected void HandleCellRendererComboEdited(object o, EditedArgs args)
{
TreeIter iter;
if (!treeModel.GetIter(out iter, new TreePath(args.Path)))
{
return;
}
TableType ttNew;
if (!TableTypes.TryParse(args.NewText, out ttNew))
{
return;
}
int colNr = CursorColNr;
// so far there's only ComboBox for TableType column
var ttOld = (TableType)treeModel.GetValue(iter, colNr);
if (ttOld != ttNew)
{
treeModel.SetValue(iter, colNr, (int)ttNew);
OnTableTypeChanged(iter, ttNew);
// follow it in case this column is being sorted
ScrollTo(iter);
}
}
/// <summary>User has finished renaming a node.</summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The EventArgs instance containing the event data.</param>
private void OnAfterLabelEdit(object sender, EditedArgs e)
{
try
{
textRender.Editable = false;
// TreeView.ContextMenuStrip = this.PopupMenu;
if (Renamed != null && !string.IsNullOrEmpty(e.NewText))
{
NodeRenameArgs args = new NodeRenameArgs()
{
NodePath = this.nodePathBeforeRename,
NewName = e.NewText
};
Renamed(this, args);
if (!args.CancelEdit)
{
previouslySelectedNodePath = args.NodePath;
}
}
}
catch (Exception err)
{
ShowError(err);
}
}
void OnLoadTimeEdited(object o, EditedArgs args)
{
var routeList = (RouteList)ytreeRoutes.YTreeModel.NodeAtPath(new TreePath(args.Path));
bool NeedRecalculate = false;
if (string.IsNullOrWhiteSpace(args.NewText))
{
NeedRecalculate = routeList.OnloadTimeFixed;
routeList.OnloadTimeFixed = false;
}
else if (TimeSpan.TryParse(args.NewText, out TimeSpan fixedTime))
{
if (fixedTime != routeList.OnLoadTimeStart)
{
NeedRecalculate = true;
}
routeList.OnloadTimeFixed = true;
routeList.OnLoadTimeStart = fixedTime;
routeList.OnLoadTimeEnd = fixedTime.Add(TimeSpan.FromMinutes(routeList.TimeOnLoadMinuts));
}
if (NeedRecalculate)
{
ViewModel.RecalculateOnLoadTime();
}
}
void AddressCell_Edited(object o, EditedArgs args)
{
if (treeView.Selection.GetSelected(out model, out iter))
{
personsListStore.SetValue(iter, 3, args.NewText);
}
}
void OnComboEdited(object sender, EditedArgs args)
{
var renderer = (CustomCellRenderer)sender;
var comboBoxStore = renderer.Model;
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
TreeIter storeIter;
if (!comboBoxStore.GetIterFirst(out storeIter))
{
return;
}
do
{
if ((string)comboBoxStore.GetValue(storeIter, 0) == args.NewText)
{
var provider = (Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor>)treeStore.GetValue(iter, 1);
var severity = (DiagnosticSeverity)comboBoxStore.GetValue(storeIter, 1);
severities [provider] = severity;
return;
}
} while (comboBoxStore.IterNext(ref storeIter));
}
void CellphonenumberCell_Edited(object o, EditedArgs args)
{
if (treeView.Selection.GetSelected(out model, out iter))
{
personsListStore.SetValue(iter, 7, args.NewText);
}
}
protected void OnCellEdited(object o, EditedArgs args)
{
data.GetIter(out TreeIter iter, new TreePath(args.Path));
CellRendererText cellRenderer = (CellRendererText)o;
int col = (int)cellRenderer.Data["column"];
try
{
object helper = data.GetValue(iter, col);
if (helper.ToString() == args.NewText)
{
return;
}
object newValue = Convert.ChangeType(args.NewText, helper.GetType());
data.SetValue(iter, col, newValue);
AddToSave(new Tuple <TreeIter, int>(iter, col));
}
catch (FormatException /* ex */)
{
MessageDialog dialog = new MessageDialog(this, DialogFlags.DestroyWithParent,
MessageType.Error, ButtonsType.Ok,
"El tipo de datos no es correcto");
dialog.Run();
dialog.Destroy();
}
}
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;
}
}
}
}
public void HandleRatioEdited(object sender, EditedArgs args)
{
args.RetVal = false;
if (!constraints_store.GetIterFromString(out var iter, args.Path))
{
return;
}
double ratio;
try {
ratio = ParseRatio(args.NewText);
} catch (FormatException fe) {
Log.Exception(fe);
return;
}
if (ratio < 1.0)
{
ratio = 1.0 / ratio;
}
using (var val = new GLib.Value(ratio))
constraints_store.SetValue(iter, 1, val);
args.RetVal = true;
}
void PropRendererEditingFinished(object o, EditedArgs args)
{
try {
TreeIter iter;
string newText = args.NewText;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
var obj = (PObject)treeStore.GetValue(iter, 1);
var values = PListScheme.AvailableValues(obj, CurrentTree);
if (values != null)
{
var value = values.FirstOrDefault(v => v.Description == newText || v.Identifier == newText);
if (value != null)
{
newText = value.Identifier;
}
}
obj.SetValue(newText);
} catch (Exception ex) {
GLib.ExceptionManager.RaiseUnhandledException(ex, false);
}
}
private void ComboCellRenderer_Edited(object o, EditedArgs args)
{
ProjectileEffectType selectedType = ProjectileEffectType.Damage;
TreeIter iter;
if (EffectsModel.GetIterFromString(out iter, args.Path))
{
var values = Enum.GetValues(typeof(ProjectileEffectType));
var names = Enum.GetNames(typeof(ProjectileEffectType));
for (int i = 0; i < names.Length; i++)
{
if (args.NewText == names[i])
{
selectedType = (ProjectileEffectType)values.GetValue(i);
break;
}
}
int row = (int)EffectsModel.GetValue(iter, 0);
ProjectileEffectType currentType = Projectile.Effects[row].EffectType;
if (selectedType != currentType)
{
EffectsModel.SetValue(iter, 1, args.NewText);
Projectile.Effects[row].EffectType = selectedType;
WriteChanges();
}
}
}
