| public GetValue ( Gtk iter, int column ) : object | ||
| iter | Gtk | |
| column | int | |
| return | object | |
// load the phone book
// Since we have SelectionMode.Multiple turned on we have to
// jump through these hoops in GTK-2.0 to get a selection
private void on_book_treeview_selection(object o, EventArgs args)
{
Gtk.TreeIter iter = new Gtk.TreeIter();
//Value value = new Value(); delete me
string selectionText = null;
book_store.GetIterFirst(out iter);
if (book.Selection.IterIsSelected(iter))
{
selectionText = (string)book_store.GetValue(iter, 0);
}
while (book_store.IterNext(ref iter))
{
if (book.Selection.IterIsSelected(iter))
{
selectionText = (string)book_store.GetValue(iter, 0);
}
}
// Ok now we can finally load the phone book
foreach (Phonebook p in myPhoneBooks)
{
if (p.Name == selectionText)
{
load_phone_book(p);
}
}
}
bool CanUseNewName(string newName)
{
if (!System.Text.RegularExpressions.Regex.IsMatch(newName, "[\\w-]+"))
{
MessageService.ShowError("Compiler configuration", "Compiler name can only contain letters/digits/'-'");
return(false);
}
Gtk.TreeIter iter;
compilerStore.GetIterFirst(out iter);
do
{
var virtCmp = compilerStore.GetValue(iter, 1) as DCompilerConfiguration;
if (virtCmp.Vendor == newName)
{
MessageService.ShowError("Compiler configuration", "Compiler name already taken");
return(false);
}
} while (compilerStore.IterNext(ref iter));
return(true);
}
void HandleButtonPressEvent(object sender, ButtonPressEventArgs args)
{
TreeViewColumn col;
CellRenderer cr;
TreePath path;
TreeIter iter;
if (args.Event.Button != 1 || !GetCellAtPos((int)args.Event.X, (int)args.Event.Y, out path, out col, out cr))
{
return;
}
if (!store.GetIter(out iter, path))
{
return;
}
if (cr == refresh)
{
var options = DebuggingService.DebuggerSession.Options.EvaluationOptions.Clone();
options.AllowMethodEvaluation = true;
options.AllowToStringCalls = true;
var frame = (StackFrame)store.GetValue(iter, 7);
var method = EvaluateMethodName(frame, options);
store.SetValue(iter, 1, method);
store.SetValue(iter, 8, false);
}
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
mySqlConnection.Open();
MySqlCommand mySqlCommand=mySqlConnection.CreateCommand();
mySqlCommand.CommandText= "select * from categoria";
MySqlDataReader mysqlDataReader= mySqlCommand.ExecuteReader();
int fieldcount=mysqlDataReader.FieldCount;
creaColumnas(fieldcount,mysqlDataReader);
ListStore listStore=new ListStore(creaTipos(fieldcount));
rellenar(fieldcount,listStore,mysqlDataReader);
mysqlDataReader.Close();
removeAction.Sensitive=false;
treeView.Model=listStore;
TreeIter iter;
treeView.Selection.Changed+=delegate{
bool isSelected=treeView.Selection.GetSelected(out iter);
if(isSelected)
removeAction.Sensitive=true;
else
removeAction.Sensitive=false;
};
removeAction.Activated +=delegate{
string nombre=listStore.GetValue(iter,1).ToString();
MessageDialog md2 = new MessageDialog
(this, DialogFlags.Modal, MessageType.Warning, ButtonsType.YesNo,"¿Seguro que quieres borrarlo? \n Borrar: "+nombre);
ResponseType result = (ResponseType)md2.Run ();
string op=listStore.GetValue(iter,0).ToString();
if (result == ResponseType.Yes){
MySqlCommand delete=mySqlConnection.CreateCommand();
delete.CommandText= "Delete from categoria where id="+op+"";
delete.ExecuteNonQuery();
md2.Destroy();
for (int i=0;i<fieldcount;i++){//elimina columnas
treeView.RemoveColumn(treeView.GetColumn(0));
}
listStore.Clear();//vacia el modelo
//volvemos a mostrar treview actualizado
actualizar(mySqlCommand,listStore);
}
else{
md2.Destroy();
}
};
}
private void preferenceToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (PolicyTreeStore.GetIter(out iter, new TreePath(args.Path)))
{
bool old = (bool)PolicyTreeStore.GetValue(iter, 0);
notificationTypes type = (notificationTypes)PolicyTreeStore.GetValue(iter, 2);
setNotificationState(type, !old);
PolicyTreeStore.SetValue(iter, 0, !old);
}
}
void ShowSelectedPad()
{
Gtk.TreeIter iter;
if (treeviewPads.Selection.GetSelected(out iter))
{
MonoDevelop.Ide.Gui.Pad pad = padListStore.GetValue(iter, 2) as MonoDevelop.Ide.Gui.Pad;
ShowType(ImageService.GetPixbuf(!pad.Icon.IsNull ? pad.Icon : MonoDevelop.Ide.Gui.Stock.MiscFiles, Gtk.IconSize.Dialog),
pad.Title,
"",
"");
}
}
TreeIter FindJob(JobInfo job)
{
TreeIter iter;
for (bool ok = listStore.GetIterFirst(out iter); ok; ok = listStore.IterNext(ref iter))
{
if (listStore.GetValue(iter, COLUMN_JOB_INFORMATION) == job)
{
return(iter);
}
}
return(TreeIter.Zero);
}
void OnResourceSelectionChanged(object obj, EventArgs args)
{
Gtk.TreeIter iter;
Gtk.TreeModel model;
if (!resourceList.Selection.GetSelected(out model, out iter))
{
resourceNameEntry.Text = "";
}
else
{
resourceNameEntry.Text = (string)resourceListStore.GetValue(iter, 2);
}
}
public static void SaveList(ListStore list, string path)
{
path = path + "streams.list";
File.Delete(path);
for (int i = 0; i < list.IterNChildren(); i++) {
TreeIter iter;
list.GetIterFromString (out iter, i.ToString ());
File.AppendAllText(path, list.GetValue(iter, 0).ToString());
File.AppendAllText(path, " ");
File.AppendAllText(path, list.GetValue(iter, 1).ToString());
File.AppendAllText(path, "\n");
}
}
private void on_NewPhoneBookDruidEdge_finish(object o, Gnome.FinishClickedArgs args)
{
if (GfaxRadioButton.Active)
{
phonebooktype = "gfax";
booknames.Add(NewPhoneBookNameEntry.Text);
}
else if (EvolutionRadioButton.Active)
{
phonebooktype = "evolution";
Gtk.TreeIter iter = new Gtk.TreeIter();
// Get the first row.
store.GetIterFirst(out iter);
try {
if ((bool)store.GetValue(iter, 0)) // if use is true (toggle set)
{
booknames.Add((string)store.GetValue(iter, 1));
}
} catch (Exception e) {
Console.WriteLine("[newphonebook.NewPhoneBookDruidPage_finish] Exception: {0}", e);
}
// get the rest of the rows
while (store.IterNext(ref iter))
{
try {
if ((bool)store.GetValue(iter, 0))
{
booknames.Add((string)store.GetValue(iter, 1));
}
}
catch (Exception e) {
Console.WriteLine("[newphonebook.NewPhoneBookDruidPage_finish] Exception: {0}", e);
}
}
}
else if (DatabaseRadioButton.Active)
{
phonebooktype = "sql";
}
else if (LDAPRadioButton.Active)
{
phonebooktype = "ldap";
}
NewPhoneBookDialog.Hide();
NewPhoneBookDialog.Dispose();
}
protected void OnButtonEditClicked(object sender, EventArgs e)
{
TreeIter iter;
treeviewUsers.Selection.GetSelected(out iter);
int itemid = Convert.ToInt32(UsersListStore.GetValue(iter, 0));
UserProperty winUser = new UserProperty();
winUser.UserFill(itemid);
winUser.Show();
winUser.Run();
winUser.Destroy();
UpdateUsers();
}
public void NotificationUpdated(CustomNotification notification)
{
TreeIter iter;
Boolean searchMore = NotificationListStore.GetIterFirst(out iter);
while (searchMore)
{
if (NotificationListStore.GetValue(iter, 0) == notification)
{
NotificationListStore.EmitRowChanged(NotificationListStore.GetPath(iter), iter);
}
searchMore = NotificationListStore.IterNext(ref iter);
}
}
private void manager_FileTransferRemoved(object sender, FileTransferEventArgs e)
{
try {
// Remove transfer from list
Gtk.TreeIter iter;
transferListStore.GetIterFirst(out iter);
if (transferListStore.IterIsValid(iter))
{
do
{
IFileTransfer currentItem = (IFileTransfer)transferListStore.GetValue(iter, 0);
if (currentItem == e.Transfer)
{
transferListStore.Remove(ref iter);
return;
}
} while (transferListStore.IterNext(ref iter));
}
Gui.MainWindow.RefreshCounts();
} catch (Exception ex) {
Core.LoggingService.LogError(ex);
Gui.ShowErrorDialog(ex.ToString(), Gui.MainWindow.Window);
}
}
protected void Proceed(object sender, EventArgs e)
{
TreeIter iter;
TreeModel model;
if (!treeview1.Selection.GetSelected(out model, out iter))
{
result.Text = "Select sentence";
}
else
{
string sentence = array1.GetValue(iter, 0).ToString();
int count = 0;
foreach (string word in sentence.Split(' '))
{
if (word != "")
{
count++;
}
}
result.Text = $"Words count: {count}";
}
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
treeView.Selection.Mode = SelectionMode.Multiple;//seleccion multiple de item
treeView.AppendColumn("Columna uno",new CellRendererText(),"text",0);
treeView.AppendColumn("Columna dos",new CellRendererText(),"text",1);
treeView.AppendColumn("Columna tres",new CellRendererText(),"text",2);
ListStore listStore = new ListStore(typeof(string), typeof(string), typeof(string));
treeView.Model = listStore;
listStore.AppendValues("clave uno", "valor uno", "uno");
listStore.AppendValues("clave dos", "valor dos", "dos");
listStore.AppendValues("clave tres", "valor tres", "tres");
listStore.AppendValues("clave cuatro", "valor cuatro", "cuatro");
treeView.Selection.Changed += delegate {//añade la ocurrencia del metodo al evento
int count = treeView.Selection.CountSelectedRows();
Console.WriteLine("treeView.Selection.Changed CountSelectedRows={0}", count);
treeView.Selection.SelectedForeach(delegate(TreeModel model, TreePath path, TreeIter iter)
{
object value = listStore.GetValue(iter, 0);
Console.WriteLine("value={0}", value);
});
};
}
// <summary>
// Return an existing tag for the specified tag name. If no Tag exists
// null will be returned.
// </summary>
public static Tag GetTag(string tag_name)
{
if (tag_name == null)
{
throw new ArgumentNullException("TagManager.GetTag () called with a null tag name.");
}
string normalized_tag_name = tag_name.Trim().ToLower();
if (normalized_tag_name == String.Empty)
{
throw new ArgumentException("TagManager.GetTag () called with an empty tag name.");
}
if (normalized_tag_name.StartsWith(Tag.SYSTEM_TAG_PREFIX) || normalized_tag_name.Split(':').Length > 2)
{
lock (locker) {
if (internal_tags.ContainsKey(normalized_tag_name))
{
return(internal_tags[normalized_tag_name]);
}
return(null);
}
}
if (tag_map.ContainsKey(normalized_tag_name))
{
Gtk.TreeIter iter = tag_map [normalized_tag_name];
return(tags.GetValue(iter, 0) as Tag);
}
return(null);
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
//comboBox.Active = 0; -> Para establecer como predeterminado un item del combo
CellRenderer cellRenderer = new CellRendererText();
comboBox.PackStart(cellRenderer, false); //expand = false
comboBox.AddAttribute(cellRenderer, "text", 0);
CellRenderer cellRenderer2 = new CellRendererText();
comboBox.PackStart(cellRenderer2, false); //expand = false
comboBox.AddAttribute(cellRenderer2, "text", 1);
listStore = new ListStore(typeof(string), typeof(string));
comboBox.Model = listStore;
listStore.AppendValues("1", "uno");
listStore.AppendValues("2", "dos");
comboBox.Changed += comboBoxChanged;
comboBox.Changed += delegate {showItemSelected(listStore);};
comboBox.Changed += delegate {
Console.WriteLine("Evento activado");
TreeIter treeIter;
if (comboBox.GetActiveIter(out treeIter) ){ // item seleccionado.
object value =listStore.GetValue(treeIter, 0);
Console.WriteLine("ComboBox.changed id={0}", value);
}
};
}
private void showActiveItem(ListStore listStore)
{
TreeIter treeIter;
if ( comboBox.GetActiveIter (out treeIter) ) { //item seleccionado
object value = listStore.GetValue (treeIter, 0);
Console.WriteLine ("comboBox.Changed delegate value={0}", value);
}
}
private void OnClickDeleteEntry(object sender, EventArgs e)
{
TreeSelection selectedRow = this.tree.Selection;
ITreeModel model;
TreeIter iter;
Carro carroToDelete;
if (selectedRow.GetSelected(out model, out iter))
{
//If a row is selected in the TreeeView
//get the id_carro and placa to create the carro object to be deleted
int id_carroToDelete = Int32.Parse(carrosListStore.GetValue(iter, 0).ToString());
string placaToDelete = carrosListStore.GetValue(iter, 1).ToString();
carroToDelete = new Carro(placaToDelete);
carroToDelete.id_carro = id_carroToDelete;
}
else
{
return;
}
//Dialog to confirm deletion
var confirmationDialog = new MessageDialog
(
null,
DialogFlags.Modal,
MessageType.Question,
ButtonsType.OkCancel,
$"Deletando o carro de placa {carroToDelete.Placa}.\nConfirma?"
);
confirmationDialog.Show();
int confirmation = confirmationDialog.Run();
confirmationDialog.Dispose();
if (confirmation == (int)ResponseType.Ok)
{
using (var conn = CreateConnection())
{
DeleteData(conn, carroToDelete);
}
}
updateList();
}
protected void onCustomersRowActivated(object o, RowActivatedArgs args)
{
TreeIter iter;
CustomersListStore.GetIter(out iter, args.Path);
int customerId = (int)CustomersListStore.GetValue(iter, 0);
ShowCustomerDialog(customerId);
}
private void showItemSelected(ListStore listStore)
{
Console.WriteLine("Evento activado");
TreeIter treeIter;
if (comboBox.GetActiveIter(out treeIter) ){
object value =listStore.GetValue(treeIter, 0);
Console.WriteLine("ComboBoxChanged id={0}", value);
}
}
private void unknownToggled(object sender, Gtk.ToggledArgs args)
{
Gtk.TreeIter iter;
listStoreAll.GetIter(out iter, new Gtk.TreePath(args.Path));
ChronopicRegisterWindowTypes crwt = (ChronopicRegisterWindowTypes)listStoreAll.GetValue(iter, 0);
if (!crwt.Unknown)
{
crwt.Unknown = true;
crwt.Contacts = false;
crwt.Encoder = false;
}
//store on SQL
SqliteChronopicRegister.Update(false,
new ChronopicRegisterPort(crwt.SerialNumber, ChronopicRegisterPort.Types.UNKNOWN),
ChronopicRegisterPort.Types.UNKNOWN);
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
// MyFunction f;
//
// MyFunction[] functions = new MyFunction[]{suma, resta, multiplica};
//
// int random = new Random().Next(3);
// f= functions[random];
//
// Console.WriteLine("f={0}", f(5,3));
treeView.Selection.Mode=SelectionMode.Multiple;
treeView.AppendColumn("Columna uno", new CellRendererText(), "text",0);
treeView.AppendColumn("Columna dos", new CellRendererText(), "text",1);
CellRenderer cellRenderer = new CellRendererText();
comboBox.PackStart(cellRenderer, false); //expand = false
comboBox.AddAttribute (cellRenderer, "text", 0);
CellRenderer cellRenderer2 = new CellRendererText();
comboBox.PackStart(cellRenderer2, false); //expand = false
comboBox.AddAttribute (cellRenderer2, "text", 1);
listStore = new ListStore (typeof(string), typeof(string));
comboBox.Model = listStore;
treeView.Model = listStore;
listStore.AppendValues("1", "Uno");
listStore.AppendValues("2", "Dos");
treeView.Selection.Changed+=delegate{
int count = treeView.Selection.CountSelectedRows();
Console.WriteLine("treeView.Selection.Changed CountSelectedRows={0}" + count);
treeView.Selection.SelectedForeach(delegate(TreeModel model, TreePath path, TreeIter iter){
object value = listStore.GetValue(iter, 0);
Console.WriteLine("value={0}", value);
});
};
// comboBox.Changed += delegate {
// TreeIter treeIter;
// if(comboBox.GetActiveIter(out treeIter)){ //Item seleccionado
// object value = listStore.GetValue (treeIter, 0);
// Console.WriteLine("comboBoxChanged value={0}", value);
// }
// };
comboBox.Changed += comboBoxChanged;
//comboBox.Changed += delegate {showActiveItem (listStore); };
}
private void pluginsTreeView_RowActivated(object sender, RowActivatedArgs args)
{
TreeIter iter;
if (pluginsListStore.GetIter(out iter, args.Path) == true)
{
PluginInfo pluginInfo = (PluginInfo)pluginsListStore.GetValue(iter, 0);
IPluginConfigDialog configDialog = pluginInfo.CreateConfigDialog();
configDialog.Show(dialog);
}
}
protected void OnRemove(object se, EventArgs args)
{
Gtk.TreeIter iter;
Gtk.TreeModel model;
if (libraryList.Selection.GetSelected(out model, out iter))
{
string s = (string)store.GetValue(iter, 0);
store.Remove(ref iter);
SteticMain.SteticApp.RemoveWidgetLibrary(s);
}
}
private void on_advancedList_button_release_event(object o, ButtonReleaseEventArgs args)
{
TreeIter iter;
TreeModel model;
if (advancedList.Selection.GetSelected(out model, out iter))
{
int index = (int)advancedListStore.GetValue(iter, 1);
advancedNotebook.Page = index;
}
}
private void AddPattern(Pattern pattern)
{
PatternListStore.AppendValues("icon-dark-play", pattern, "icon-dark-pencil-square-o", "icon-dark-clone", "icon-dark-trash");
pattern.Animations.Add(new Animation());
DataModel.Patterns.Add(pattern);
TreeIter iterator;
PatternListStore.GetIterFirst(out iterator);
do
{
if (pattern == (Pattern)PatternListStore.GetValue(iterator, PatternColumn))
{
ignoreNextClick = true;
treeviewPatterns.SetCursor(PatternListStore.GetPath(iterator), treeviewPatterns.Columns[PatternColumn], false);
break;
}
}while (PatternListStore.IterNext(ref iterator));
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
treeView.AppendColumn ("id", new CellRendererText (), "text", 0);
treeView.AppendColumn ("nombre", new CellRendererText(), "text", 1);
ListStore listStore = new ListStore(typeof(long), typeof(string));
treeView.Model = listStore;
//liststore.AppendValues (33L, "Treinta y tres");
App.Instance.DbConnection = new MySqlConnection ("Database=dbprueba;user=root;password=sistemas");
App.Instance.DbConnection.Open ();
fillListStore (listStore);
newAction.Activated += delegate {
CCategoria.CategoriaView categoriaView = new CCategoria.CategoriaView();
};
deleteAction.Activated += delegate {
if (!WindowHelper.Confirm(this, "Quieres eliminar el registro?")){
return;
}
TreeIter treeIter;
treeView.Selection.GetSelected(out treeIter);
object id = listStore.GetValue(treeIter,0);
Console.WriteLine ("deleteAction Activated id = {0}" , id);
IDbCommand deleteDbCommand = App.Instance.DbConnection.CreateCommand();
//TODO usar dbParameters para el id
deleteDbCommand.CommandText = "delete from categoria where id = @id";
DbHelper.DbCommandAddParameter(deleteDbCommand, "id", id);
deleteDbCommand.ExecuteNonQuery();
};
refreshActions.Activated += delegate {
fillListStore (listStore);
};
treeView.Selection.Changed += delegate {
Console.WriteLine ("treeView Selection Changed CountSelectedRows()={0}",
treeView.Selection.CountSelectedRows());
refreshAction();
};
//dbConnection.Close ();
}
void HandleToggle(object sender, ToggledArgs e)
{
TreeIter iter;
if (targetStore.GetIter(out iter, new TreePath(e.Path)))
{
bool currentVal = (bool)targetStore.GetValue(iter, LISTCOL_Checked);
targetStore.SetValue(iter, LISTCOL_Checked, !currentVal);
}
UpdateButtonState();
}
public static void Delete (TreeView treeView,ListStore listStore,IDbConnection dbConnection,String sql){
TreeIter treeIter;
treeView.Selection.GetSelected (out treeIter);
object id = listStore.GetValue (treeIter, 0);
string deleteSql = string.Format (sql, id);
IDbCommand dbCommand = dbConnection.CreateCommand ();
dbCommand.CommandText = deleteSql;
dbCommand.ExecuteNonQuery ();
}
void OnRowClicked(object o, RowActivatedArgs args)
{
TreeIter Iter;
if ((o as TreeView).Selection.GetSelected(out Iter))
{
bool OldValue = (bool)MusicListStore.GetValue(Iter, 0);
MusicListStore.SetValue(Iter, 0, !OldValue);
Log.DebugFormat("Setting Selection Value For Row {0} -> {1}", MusicListStore.GetStringFromIter(Iter), !OldValue);
}
}
void crt_toggled(object o, ToggledArgs args)
{
TreeIter iter;
Console.WriteLine("Toggled");
Gtk.ListStore store = (Gtk.ListStore)tvBar.Model;
if (store.GetIter(out iter, new TreePath(args.Path)))
{
bool old = (bool)store.GetValue(iter, 3);
store.SetValue(iter, 3, !old);
}
}
private void nameCellEdited(object o, Gtk.EditedArgs args)
{
Gtk.TreeIter iter;
treeview_lines_store.GetIter(out iter, new Gtk.TreePath(args.Path));
userLine line = (userLine)treeview_lines_store.GetValue(iter, 0);
line.m_name = args.NewText;
}
private void BuildWidget ()
{
store = new ListStore (typeof (string), typeof (EqualizerSetting));
Model = store;
TextColumn = 0;
store.DefaultSortFunc = (model, ia, ib) => {
var a = GetEqualizerSettingForIter (ia);
var b = GetEqualizerSettingForIter (ib);
if (a != null && b != null) {
return a.IsReadOnly == b.IsReadOnly
? a.Name.CompareTo (b.Name)
: a.IsReadOnly.CompareTo (b.IsReadOnly);
} else if (a == null && b == null) {
return 0;
} else if ((a == null && b.IsReadOnly) || (b == null && !a.IsReadOnly)) {
return -1;
} else if ((a == null && !b.IsReadOnly) || (b == null && a.IsReadOnly)) {
return 1;
}
return 0;
};
store.SetSortColumnId (-1, SortType.Ascending);
RowSeparatorFunc = (model, iter) =>
store.GetValue (iter, 0) as String == String.Empty &&
store.GetValue (iter, 1) == null;
foreach (EqualizerSetting eq in manager) {
AddEqualizerSetting(eq);
}
manager.EqualizerAdded += (o, e) => AddEqualizerSetting (e.Value);
manager.EqualizerRemoved += (o, e) => RemoveEqualizerSetting (e.Value);
}
public RestoreBackupDialog(Gtk.Window parent)
: base("Saves", parent)
{
this.IconName = "document-revert";
XML gxml = new XML(null, "MultiMC.GTKGUI.RestoreBackupDialog.glade", "restoreRoot", null);
gxml.Toplevel = this;
gxml.Autoconnect(this);
this.VBox.PackStart(restoreRoot);
this.WidthRequest = 620;
this.HeightRequest = 380;
// set default button states
btnCancel.Sensitive = true;
btnOK.Sensitive = false;
// FIXME: store date/time properly so ordering works.
backupsStore = new ListStore(typeof(string), typeof(DateTime), typeof(string), typeof(string));
restoreView.Model = backupsStore;
restoreView.AppendColumn("Backup name", new CellRendererText(), "text", 0);
restoreView.AppendColumn("Date", new CellRendererText(), new TreeCellDataFunc(DateTimeCell));
restoreView.AppendColumn("Hash", new CellRendererText(), "text", 2);
restoreView.Selection.Mode = SelectionMode.Single;
// this binds view and model columns together for sorting
restoreView.Columns[0].SortColumnId = 0;
restoreView.Columns[1].SortColumnId = 1;
restoreView.Columns[2].SortColumnId = 2;
// the date column needs a custom sorting function that can compare DateTime objects
backupsStore.SetSortFunc(1,new TreeIterCompareFunc(DateTimeTreeIterCompareFunc));
backupsStore.SetSortColumnId(1,SortType.Ascending); // sort by date
restoreView.Selection.Changed += (sender, e) =>
{
if(restoreView.Selection.CountSelectedRows() != 0)
{
btnOK.Sensitive = true;
TreeIter iter;
restoreView.Selection.GetSelected(out iter);
currentHash = backupsStore.GetValue(iter,3) as string;
}
else
{
btnOK.Sensitive = false;
}
};
ShowAll();
}
private int SelTreeStoreSortFunction(TreeModel model, TreeIter a, TreeIter b)
{
MemberInfo memberA = (MemberInfo)SelTreeStore.GetValue(a, 0);
MemberInfo memberB = (MemberInfo)SelTreeStore.GetValue(b, 0);
if (memberA == null || memberB == null)
{
return(0);
}
string nameA = memberA.FullName;
string nameB = memberB.FullName;
if (nameA == null || nameA.Length < 1)
{
nameA = memberA.Name;
}
if (nameB == null || nameB.Length < 1)
{
nameB = memberB.Name;
}
return(string.Compare(nameA, nameB, true));
}
protected void Proceed(object sender, EventArgs e)
{
TreeIter iter;
TreeModel model;
if (!treeview1.Selection.GetSelected(out model, out iter))
{
result.Text = "Select sentence";
}
else
{
string sentence = array1.GetValue(iter, 0).ToString();
result.Text = $"Words count: {sentence.Split(' ').Length}";
}
}
public GitConfigurationDialog (GitRepository repo)
{
this.Build ();
this.repo = repo;
this.HasSeparator = false;
// Branches list
storeBranches = new ListStore (typeof(Branch), typeof(string), typeof(string), typeof(string));
listBranches.Model = storeBranches;
listBranches.HeadersVisible = true;
listBranches.AppendColumn (GettextCatalog.GetString ("Branch"), new CellRendererText (), "markup", 1);
listBranches.AppendColumn (GettextCatalog.GetString ("Tracking"), new CellRendererText (), "text", 2);
listBranches.Selection.Changed += delegate {
TreeIter it;
if (!listBranches.Selection.GetSelected (out it))
return;
string currentBranch = repo.GetCurrentBranch ();
var b = (Branch) storeBranches.GetValue (it, 0);
buttonRemoveBranch.Sensitive = b.Name != currentBranch;
};
// Sources tree
storeRemotes = new TreeStore (typeof(RemoteSource), typeof(string), typeof(string), typeof(string), typeof(string));
treeRemotes.Model = storeRemotes;
treeRemotes.HeadersVisible = true;
treeRemotes.AppendColumn ("Remote Source / Branch", new CellRendererText (), "markup", 1);
treeRemotes.AppendColumn ("Url", new CellRendererText (), "text", 2);
// Tags list
storeTags = new ListStore (typeof(string));
listTags.Model = storeTags;
listTags.HeadersVisible = true;
listTags.AppendColumn (GettextCatalog.GetString ("Tag"), new CellRendererText (), "text", 0);
// Fill data
FillBranches ();
FillRemotes ();
FillTags ();
}
void SelectDocument(Document doc)
{
Gtk.TreeIter iter;
if (documentListStore.GetIterFirst(out iter))
{
do
{
Document curDocument = documentListStore.GetValue(iter, 2) as Document;
if (doc == curDocument)
{
treeviewDocuments.Selection.SelectIter(iter);
return;
}
} while (documentListStore.IterNext(ref iter));
}
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
MyFunction f;
MyFunction[] functions = new MyFunction[]{suma, resta, multiplica};
int random = new Random().Next(3);
f = functions[random];
// if (new Random().Next(2) ==0){
// f=suma;
// }
// else{
// f=resta;
// }
Console.WriteLine("f={0}", f(5,3));
//comboBox
CellRenderer cellRenderer = new CellRendererText();
combobox.PackStart(cellRenderer, false);
combobox.AddAttribute (cellRenderer, "text", 1);
listStore = new ListStore(typeof(string), typeof(string));
combobox.Model = listStore;
listStore.AppendValues("1", "Uno");
listStore.AppendValues("2", "Dos");
listStore.AppendValues("3", "Tres");
listStore.AppendValues("4", "Cuatro");
listStore.AppendValues("5", "Cinco");
combobox.Changed += delegate {
TreeIter treeIter;
if (combobox.GetActiveIter (out treeIter)) { //item seleccionado
object value = listStore.GetValue(treeIter, 0);
Console.WriteLine ("ComboBox.Changed delegate id={0}", value);
}
};
combobox.Changed += comboBoxChanged;
}
public ComboBoxHelper(ComboBox comboBox, IDbConnection dbConnection, string keyFieldName,
string valueFieldName,string tableName,int initialId)
{
this.comboBox = comboBox;
//this.initalId = initialId;
CellRendererText cellRenderText1 = new CellRendererText();
comboBox.PackStart(cellRenderText1,false);
comboBox.AddAttribute(cellRenderText1,"text",0);//el ultimo parametro el 0 sirve para elegir la columna a visualizar
CellRendererText cellRenderText = new CellRendererText();
comboBox.PackStart(cellRenderText,false);
comboBox.AddAttribute(cellRenderText,"text",1);//el ultimo parametro el 1 sirve para elegir la columna a visualizar
listStore = new ListStore(typeof(int),typeof(string));
TreeIter initialTreeIter;/* = listStore.AppendValues(0, "Sin asignar");*/
IDbCommand dbCommand = dbConnection.CreateCommand();
dbCommand.CommandText = string.Format(selectFormat, keyFieldName,valueFieldName,tableName);
IDataReader dataReader = dbCommand.ExecuteReader();
//Recorre el dataReader para insertar los valores en el comboBox
while(dataReader.Read())
{
int id =(int) dataReader["id"];
string nombre = (string)dataReader["nombre"];
treeIter = listStore.AppendValues(id,nombre);
if (id == initialId)
initialTreeIter = treeIter;
}
dataReader.Close();
comboBox.Model = listStore;
comboBox.SetActiveIter(initialTreeIter);
comboBox.Changed += delegate {
TreeIter treeIter;
comboBox.GetActiveIter(out treeIter);
int id = (int) listStore.GetValue(treeIter,0);
Console.WriteLine("ID = "+ id);
};
}
public bool Store()
{
ApplyToVirtConfiguration();
DCompilerService.Instance.Compilers.Clear();
Gtk.TreeIter iter;
compilerStore.GetIterFirst(out iter);
do
{
var virtCmp = compilerStore.GetValue(iter, 1) as DCompilerConfiguration;
DCompilerService.Instance.Compilers.Add(virtCmp);
} while (compilerStore.IterNext(ref iter));
DCompilerService.Instance.DefaultCompiler = defaultCompilerVendor;
return(true);
}
public EditModsDialog(Instance inst, Gtk.Window parent = null)
: base("Edit Mods", parent, DialogFlags.Modal)
{
Inst = inst;
this.Build();
#region We have to make the treeview ourselves since monodevelop is absolute shit...
this.editModScroll = new ScrolledWindow();
this.editModScroll.HscrollbarPolicy = PolicyType.Never;
this.modView = new Gtk.TreeView();
this.modView.CanFocus = true;
this.modView.Name = "modView";
this.editModScroll.Add(this.modView);
this.VBox.Add(this.editModScroll);
Gtk.Box.BoxChild w3 = ((Gtk.Box.BoxChild)(this.VBox[this.editModScroll]));
w3.Position = 0;
this.ShowAll();
#endregion
modList = new ListStore(typeof(string), typeof(string), typeof(bool), typeof(DateTime));
modView.Model = modList;
modView.AppendColumn("File", new CellRendererText(), "text", 0);
modView.AppendColumn("Install Date", new CellRendererText(), "text", 1);
CellRendererToggle toggleRenderer = new CellRendererToggle();
toggleRenderer.Activatable = true;
toggleRenderer.Sensitive = true;
toggleRenderer.Toggled += (object o, ToggledArgs args) =>
{
TreeIter iter;
if (modList.GetIter(out iter, new TreePath(args.Path)))
modList.SetValue(iter, 2, !(bool)modList.GetValue(iter, 2));
};
modView.AppendColumn("Delete?", toggleRenderer, "active", 2);
modView.Columns[0].Alignment = 0.0f;
modView.Columns[0].Expand = true;
modView.Columns[1].Alignment = 1.0f;
modView.Columns[2].Alignment = 1.0f;
LoadMods();
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
treeView.AppendColumn ("id", new CellRendererText (), "text", 0);
treeView.AppendColumn ("nombre", new CellRendererText (), "text", 1);
ListStore listStore = new ListStore(typeof(long), typeof(String));
treeView.Model = listStore;
fillListStore (listStore);
deleteAction.Sensitive = false;
newAction.Activated += delegate {
new CategoriaView();
};
deleteAction.Activated += delegate {
if (!WindowHelper.Confirm(this, "Quieres eliminar el registro?"))
return;
TreeIter treeIter;
treeView.Selection.GetSelected(out treeIter);
object id = listStore.GetValue(treeIter, 0);
IDbCommand dbCommand = App.Instace.DbConnection.CreateCommand();
IDbCommand.CommandText = "delete from categoria where id = @id";
DbHelper.DbCommandAddParameter(dbCommand, "id", id);
dbCommand.ExecuteNonQuery();
};
refreshAction.Activated += delegate {
fillListStore(listStore);
};
treeView.Selection.Changed += delegate {
deleteAction.Sensitive = treeView.Selection.CountSelectedRows() > 0;
};
}
private void StoreSearch(string query)
{
Gtk.TreeIter iter;
if (history.GetIterFirst(out iter))
{
string val;
do
{
val = (string)history.GetValue(iter, 0);
if (val == query)
{
history.Remove(ref iter);
}
} while (val != query && history.IterNext(ref iter));
}
iter = history.Insert(0);
history.SetValue(iter, 0, query);
}
//private string lastType = null;
private void ChangeType(object o, EventArgs args)
{
Gtk.ComboBox combo = (Gtk.ComboBox)o;
string hit_type = null;
Gtk.TreeIter iter;
if (combo.GetActiveIter(out iter))
{
hit_type = (string)filter_data.GetValue(iter, 1);
}
if (this.hit_type == hit_type)
{
return;
}
this.hit_type = hit_type;
root.SetSource(this.hit_type);
root.HitCollection.PageFirst();
UpdatePage();
}
public ObjectChooser(EditorModel model)
: base(Gtk.WindowType.Toplevel)
{
this.Build ();
Deletable = false; //Why doesn't this work?
//Prevent this window from closing
DeleteEvent += delegate(object o, Gtk.DeleteEventArgs args) {
args.RetVal = true;
};
TreeViewColumn nameColumn = new TreeViewColumn();
CellRendererText nameCell = new CellRendererText();
nameColumn.Title = "Object name";
nameColumn.PackStart(nameCell, true);
nameColumn.AddAttribute(nameCell, "text", 0);
listObjects.AppendColumn(nameColumn);
ListStore objectStore = new ListStore(typeof(string));
listObjects.Model = objectStore;
//Set up object list
foreach (string o in model.ResourceManager.Objects)
{
objectStore.AppendValues(o);
}
listObjects.CursorChanged += delegate(object sender, EventArgs e) {
TreeIter iter;
if (listObjects.Selection.GetSelected(out iter))
{
model.CurrentObject = (objectStore.GetValue(iter, 0) as string);
}
};
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
MyFuction f;
MyFuction[]functions = new MyFuction[]{suma, resta, multiplica};
int random = new Random().Next(3);
f = functions[random];
Console.WriteLine("f={0}", f(5,3));
//ComboBox
CellRenderer cellRenderer = new CellRendererText();
comboBox.PackStart(cellRenderer,false); //expand=false
comboBox.AddAttribute(cellRenderer, "text", 1);
ListStore listStore = new ListStore(typeof(string),typeof(string));
comboBox.Model = listStore;
listStore.AppendValues("1","Valor uno");
listStore.AppendValues("2","Valor dos");
listStore.AppendValues("3","Valor tres");
comboBox.Changed += delegate {
Console.WriteLine ("comboBox.Changed");
TreeIter treeIter;
if(comboBox.GetActiveIter (out treeIter)) { //Item seleccionado
object value = listStore.GetValue(treeIter, 0);
Console.WriteLine("comboBox.Changed value={0}",value);
}
};
comboBox.Changed += comboBoxChanged;
}
public POEditorWidget (TranslationProject project)
{
this.project = project;
this.Build ();
//FIXME: avoid unnecessary creation of old treeview
scrolledwindow1.Remove (treeviewEntries);
treeviewEntries.Destroy ();
treeviewEntries = new MonoDevelop.Components.ContextMenuTreeView ();
treeviewEntries.ShowAll ();
scrolledwindow1.Add (treeviewEntries);
((MonoDevelop.Components.ContextMenuTreeView)treeviewEntries).DoPopupMenu = ShowPopup;
this.headersEditor = new CatalogHeadersWidget ();
this.notebookPages.AppendPage (headersEditor, new Gtk.Label ());
updateTaskThread = new BackgroundWorker ();
updateTaskThread.WorkerSupportsCancellation = true;
updateTaskThread.DoWork += TaskUpdateWorker;
AddButton (GettextCatalog.GetString ("Translation")).Active = true;
AddButton (GettextCatalog.GetString ("Headers")).Active = false;
// entries tree view
store = new ListStore (typeof(CatalogEntry));
this.treeviewEntries.Model = store;
TreeViewColumn fuzzyColumn = new TreeViewColumn ();
fuzzyColumn.SortIndicator = true;
fuzzyColumn.SortColumnId = 0;
fuzzyColumn.Title = GettextCatalog.GetString ("Fuzzy");
var iconRenderer = new CellRendererImage ();
fuzzyColumn.PackStart (iconRenderer, false);
fuzzyColumn.SetCellDataFunc (iconRenderer, CatalogIconDataFunc);
CellRendererToggle cellRendFuzzy = new CellRendererToggle ();
cellRendFuzzy.Activatable = true;
cellRendFuzzy.Toggled += HandleCellRendFuzzyToggled;
fuzzyColumn.PackStart (cellRendFuzzy, false);
fuzzyColumn.SetCellDataFunc (cellRendFuzzy, FuzzyToggleDataFunc);
treeviewEntries.AppendColumn (fuzzyColumn);
TreeViewColumn originalColumn = new TreeViewColumn ();
originalColumn.Expand = true;
originalColumn.SortIndicator = true;
originalColumn.SortColumnId = 1;
originalColumn.Title = GettextCatalog.GetString ("Original string");
CellRendererText original = new CellRendererText ();
original.Ellipsize = Pango.EllipsizeMode.End;
originalColumn.PackStart (original, true);
originalColumn.SetCellDataFunc (original, OriginalTextDataFunc);
treeviewEntries.AppendColumn (originalColumn);
TreeViewColumn translatedColumn = new TreeViewColumn ();
translatedColumn.Expand = true;
translatedColumn.SortIndicator = true;
translatedColumn.SortColumnId = 2;
translatedColumn.Title = GettextCatalog.GetString ("Translated string");
CellRendererText translation = new CellRendererText ();
translation.Ellipsize = Pango.EllipsizeMode.End;
translatedColumn.PackStart (translation, true);
translatedColumn.SetCellDataFunc (translation, TranslationTextDataFunc);
treeviewEntries.AppendColumn (translatedColumn);
treeviewEntries.Selection.Changed += OnEntrySelected;
// found in tree view
foundInStore = new ListStore (typeof(string), typeof(string), typeof(string), typeof(Xwt.Drawing.Image));
this.treeviewFoundIn.Model = foundInStore;
TreeViewColumn fileColumn = new TreeViewColumn ();
var pixbufRenderer = new CellRendererImage ();
fileColumn.PackStart (pixbufRenderer, false);
fileColumn.SetAttributes (pixbufRenderer, "image", FoundInColumns.Pixbuf);
CellRendererText textRenderer = new CellRendererText ();
fileColumn.PackStart (textRenderer, true);
fileColumn.SetAttributes (textRenderer, "text", FoundInColumns.File);
treeviewFoundIn.AppendColumn (fileColumn);
treeviewFoundIn.AppendColumn ("", new CellRendererText (), "text", FoundInColumns.Line);
treeviewFoundIn.HeadersVisible = false;
treeviewFoundIn.GetColumn (1).FixedWidth = 100;
treeviewFoundIn.RowActivated += delegate(object sender, RowActivatedArgs e) {
Gtk.TreeIter iter;
foundInStore.GetIter (out iter, e.Path);
string line = foundInStore.GetValue (iter, (int)FoundInColumns.Line) as string;
string file = foundInStore.GetValue (iter, (int)FoundInColumns.FullFileName) as string;
int lineNr = 1;
try {
lineNr = 1 + int.Parse (line);
} catch {
}
IdeApp.Workbench.OpenDocument (file, lineNr, 1);
};
this.notebookTranslated.RemovePage (0);
this.searchEntryFilter.Entry.Text = "";
searchEntryFilter.Entry.Changed += delegate {
UpdateFromCatalog ();
};
this.togglebuttonFuzzy.Active = PropertyService.Get ("Gettext.ShowFuzzy", true);
this.togglebuttonFuzzy.TooltipText = GettextCatalog.GetString ("Show fuzzy translations");
this.togglebuttonFuzzy.Toggled += delegate {
MonoDevelop.Core.PropertyService.Set ("Gettext.ShowFuzzy", this.togglebuttonFuzzy.Active);
UpdateFromCatalog ();
};
this.togglebuttonMissing.Active = PropertyService.Get ("Gettext.ShowMissing", true);
this.togglebuttonMissing.TooltipText = GettextCatalog.GetString ("Show missing translations");
this.togglebuttonMissing.Toggled += delegate {
MonoDevelop.Core.PropertyService.Set ("Gettext.ShowMissing", this.togglebuttonMissing.Active);
UpdateFromCatalog ();
};
this.togglebuttonOk.Active = PropertyService.Get ("Gettext.ShowTranslated", true);
this.togglebuttonOk.TooltipText = GettextCatalog.GetString ("Show valid translations");
this.togglebuttonOk.Toggled += delegate {
MonoDevelop.Core.PropertyService.Set ("Gettext.ShowTranslated", this.togglebuttonOk.Active);
UpdateFromCatalog ();
};
this.textviewComments.Buffer.Changed += delegate {
if (this.isUpdating)
return;
if (this.currentEntry != null) {
string[] lines = textviewComments.Buffer.Text.Split (CatalogParser.LineSplitStrings, System.StringSplitOptions.None);
for (int i = 0; i < lines.Length; i++) {
if (!lines[i].StartsWith ("#"))
lines[i] = "# " + lines[i];
}
this.currentEntry.Comment = string.Join (System.Environment.NewLine, lines);
}
UpdateProgressBar ();
};
searchEntryFilter.Ready = true;
searchEntryFilter.Visible = true;
searchEntryFilter.ForceFilterButtonVisible = true;
searchEntryFilter.RequestMenu += delegate {
searchEntryFilter.Menu = CreateOptionsMenu ();
};
widgets.Add (this);
checkbuttonWhiteSpaces.Toggled += CheckbuttonWhiteSpacesToggled;
options.ShowLineNumberMargin = false;
options.ShowFoldMargin = false;
options.ShowIconMargin = false;
options.ColorScheme = IdeApp.Preferences.ColorScheme;
options.FontName = PropertyService.Get<string> ("FontName");
this.scrolledwindowOriginal.Child = this.texteditorOriginal;
this.scrolledwindowPlural.Child = this.texteditorPlural;
this.texteditorOriginal.Show ();
this.texteditorPlural.Show ();
texteditorOriginal.ModifyBase (Gtk.StateType.Normal, Style.Base (Gtk.StateType.Insensitive));
texteditorPlural.ModifyBase (Gtk.StateType.Normal, Style.Base (Gtk.StateType.Insensitive));
this.texteditorOriginal.Options = options;
this.texteditorPlural.Options = options;
this.texteditorOriginal.Document.ReadOnly = true;
this.texteditorPlural.Document.ReadOnly = true;
}
public CodeIssuePanelWidget (string mimeType)
{
this.mimeType = mimeType;
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
Build ();
// ensure selected row remains visible
treeviewInspections.SizeAllocated += (o, args) => {
TreeIter iter;
if (treeviewInspections.Selection.GetSelected (out iter)) {
var path = treeviewInspections.Model.GetPath (iter);
treeviewInspections.ScrollToCell (path, treeviewInspections.Columns[0], false, 0f, 0f);
}
};
treeviewInspections.TooltipColumn = 2;
treeviewInspections.HasTooltip = true;
var toggleRenderer = new CellRendererToggle ();
toggleRenderer.Toggled += delegate(object o, ToggledArgs args) {
TreeIter iter;
if (treeStore.GetIterFromString (out iter, args.Path)) {
var provider = (BaseCodeIssueProvider)treeStore.GetValue (iter, 1);
enableState[provider] = !enableState[provider];
}
};
var titleCol = new TreeViewColumn ();
treeviewInspections.AppendColumn (titleCol);
titleCol.PackStart (toggleRenderer, false);
titleCol.Sizing = TreeViewColumnSizing.Autosize;
titleCol.SetCellDataFunc (toggleRenderer, delegate (TreeViewColumn treeColumn, CellRenderer cell, TreeModel model, TreeIter iter) {
var provider = (BaseCodeIssueProvider)model.GetValue (iter, 1);
if (provider == null) {
toggleRenderer.Visible = false;
return;
}
toggleRenderer.Visible = true;
toggleRenderer.Active = enableState[provider];
});
var cellRendererText = new CellRendererText {
Ellipsize = Pango.EllipsizeMode.End
};
titleCol.PackStart (cellRendererText, true);
titleCol.AddAttribute (cellRendererText, "markup", 0);
titleCol.Expand = true;
searchentryFilter.ForceFilterButtonVisible = true;
searchentryFilter.RoundedShape = true;
searchentryFilter.HasFrame = true;
searchentryFilter.Ready = true;
searchentryFilter.Visible = true;
searchentryFilter.Entry.Changed += ApplyFilter;
var comboRenderer = new CellRendererCombo {
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, EditedArgs args) {
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 = (BaseCodeIssueProvider)treeStore.GetValue (iter, 1);
var severity = (Severity)comboBoxStore.GetValue (storeIter, 1);
severities[provider] = severity;
return;
}
} while (comboBoxStore.IterNext (ref storeIter));
};
col.SetCellDataFunc (comboRenderer, delegate (TreeViewColumn treeColumn, CellRenderer cell, TreeModel model, TreeIter iter) {
var provider = (BaseCodeIssueProvider)model.GetValue (iter, 1);
if (provider == null) {
comboRenderer.Visible = false;
return;
}
var severity = severities[provider];
comboRenderer.Visible = true;
comboRenderer.Text = GetDescription (severity);
comboRenderer.BackgroundGdk = GetColor (severity);
});
treeviewInspections.HeadersVisible = false;
treeviewInspections.Model = treeStore;
GetAllSeverities ();
FillInspectors (null);
}
static void UpdateName (ListStore itemStore, TreeIter iter)
{
if (iter.Equals (TreeIter.Zero))
return;
object item = itemStore.GetValue (iter, 0);
string name = item.ToString ();
if (string.IsNullOrEmpty (name))
name = Mono.Unix.Catalog.GetString ("(Empty)");;
itemStore.SetValue(iter, 2, name);
}
public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build ();
List<Categoria> categorias = new List<Categoria> ();
categorias.Add (new Categoria (1, "Uno"));
categorias.Add (new Categoria (2, "Dos"));
categorias.Add (new Categoria (3, "Tres"));
categorias.Add (new Categoria (4, "Cuatro"));
int categoriaId = -1;
CellRendererText cellRendererText = new CellRendererText ();
comboBox.PackStart (cellRendererText, false);
comboBox.AddAttribute (cellRendererText, "text", 1);
// CellRendererText cellRendererText2 = new CellRendererText ();
// comboBox.PackStart (cellRendererText2, false);
// comboBox.AddAttribute (cellRendererText2, "text", 1);
ListStore listStore = new ListStore (typeof(int), typeof(string));
TreeIter treeIterInicial = listStore.AppendValues ((ulong)0, "<sin asignar>");
IDbCommand dbCommand = AppDomain.Instance.DvConnection.CreateCommand ();
dbCommand.CommandText = "selected id, nombre from categoria";
IDataReader dataReader = dbCommand.ExecuteReader ();
while (dataReader.Read()) {
object id = dataReader ["id"];
object nombre = dataReader ["nombre"];
foreach (Categoria categoria in categorias) {
TreeIter currentIter = listStore.AppendValues (categoria.Id, categoria.Nombre);
if (categoria.Id == categoriaId)
treeIterInicial = currentIter;
}
// listStore.AppendValues (1, "Uno");
// listStore.AppendValues (2, "Dos");
comboBox.Model = listStore;
comboBox.SetActiveIter (treeIterInicial);
TreeIter currentTreeIter;
listStore.GetIterFirst (out currentTreeIter);
listStore.GetIterFirst (out currentTreeIter);
do {
if(categoriaId.Equals(listStore.GetValue(treeIterInicial, 0))) {
comboBox.SetActiveIter(currentTreeIter);
break;
}
}
while (listStore.IterNext (ref currentTreeIter));
//listStore.GetValue (currentTreeIter, 0);
propertiesAction.Activated += delegate {
TreeIter treeIter;
bool activeIter = comboBox.GetActiveIter (out treeIter);
object id = activeIter ? listStore.GetValue (treeIter, 0) : null;
// ? significa el boolean si tiene algo dentro ejecuta la primera orden y sino, es null.
Console.WriteLine ("id={0}", id);
};
}
public NewProjectWizzard_New(Window parent)
{
if (parent != null)
this.TransientFor =parent;
else
this.TransientFor = MainClass.MainWindow;
this.Build();
atrApplication = new FileTemplate.Attribute();
atrApplication.Name = "application";
atrApplication.Type = "text";
this.DefaultHeight = 390 ;
this.Title = MainClass.Languages.Translate("moscrif_ide_title_f1");
ntbWizzard.ShowTabs = false;
Pango.FontDescription customFont = lblNewProject.Style.FontDescription.Copy();// Pango.FontDescription.FromString(MainClass.Settings.ConsoleTaskFont);
customFont.Size = customFont.Size+(int)(customFont.Size/2);
customFont.Weight = Pango.Weight.Bold;
lblNewProject.ModifyFont(customFont);
storeTyp = new ListStore (typeof (string), typeof (string), typeof (Gdk.Pixbuf), typeof (string),typeof(ProjectTemplate),typeof (bool));
storeOrientation = new ListStore (typeof (string), typeof (string), typeof (Gdk.Pixbuf), typeof (string));
storeOutput = new ListStore (typeof (string), typeof (string), typeof (Gdk.Pixbuf));
nvOutput.Model = storeOutput;
nvOutput.AppendColumn ("", new Gtk.CellRendererText (), "text", 0);
nvOutput.AppendColumn ("", new Gtk.CellRendererText (), "text", 1);
nvOutput.AppendColumn ("", new Gtk.CellRendererPixbuf (), "pixbuf", 2);
nvOutput.Columns[1].Expand = true;
ivSelectTyp.Model = storeTyp;
ivSelectTyp.SelectionMode = SelectionMode.Single;
ivSelectTyp.Orientation = Orientation.Horizontal;
CellRendererText rendererSelectTyp = new CellRendererText();
rendererSelectTyp.Ypad =0;
ivSelectTyp.PackEnd(rendererSelectTyp,false);
ivSelectTyp.SetCellDataFunc(rendererSelectTyp, new Gtk.CellLayoutDataFunc(RenderTypProject));
ivSelectTyp.PixbufColumn = COL_PIXBUF;
ivSelectTyp.TooltipColumn = COL_DISPLAY_TEXT;
ivSelectTyp.AddAttribute(rendererSelectTyp, "sensitive", 5);
Gdk.Pixbuf icon0 = MainClass.Tools.GetIconFromStock("project.png",IconSize.LargeToolbar);
storeTyp.AppendValues ("New Empty Project", "Create empty application", icon0, "", null,true);
DirectoryInfo[] diTemplates = GetDirectory(MainClass.Paths.FileTemplateDir);
foreach (DirectoryInfo di in diTemplates) {
string name = di.Name;
string iconFile = System.IO.Path.Combine(di.FullName,"icon.png");
string descFile = System.IO.Path.Combine(di.FullName,"description.xml");
if(!File.Exists(iconFile) || !File.Exists(descFile))
continue;
string descr = name;
ProjectTemplate pt = null;
if(File.Exists(descFile)){
pt = ProjectTemplate.OpenProjectTemplate(descFile);
if((pt!= null))
descr = pt.Description;
}
Gdk.Pixbuf icon = new Gdk.Pixbuf(iconFile);
DirectoryInfo[] templates = di.GetDirectories();
bool sensitive = true;
if(templates.Length<1)
sensitive = false;
else
sensitive = true;
storeTyp.AppendValues (name, descr, icon, di.FullName,pt,sensitive);
}
ivSelectTyp.SelectionChanged+= delegate(object sender, EventArgs e)
{
Gtk.TreePath[] selRow = ivSelectTyp.SelectedItems;
if(selRow.Length<1){
lblHint.Text = " ";
btnNext.Sensitive = false;
return;
}
Gtk.TreePath tp = selRow[0];
TreeIter ti = new TreeIter();
storeTyp.GetIter(out ti,tp);
if(tp.Equals(TreeIter.Zero))return;
//string typ = storeTyp.GetValue (ti, 3).ToString();
string text1 = (string) storeTyp.GetValue (ti, 0);
string text2 = (string) storeTyp.GetValue (ti, 1);
bool sensitive = Convert.ToBoolean(storeTyp.GetValue (ti, 5));
if(!sensitive){
ivSelectTyp.SelectPath(selectedTypPrj);
return;
}
selectedTypPrj = selRow[0];
lblHint.Text = text1+" - "+text2;
btnNext.Sensitive = true;
};
CellRendererText rendererOrientation = new CellRendererText();
selectedTypPrj = new TreePath("0");
ivSelectTyp.SelectPath(selectedTypPrj);
ivSelectOrientation.Model = storeOrientation;
ivSelectOrientation.SelectionMode = SelectionMode.Single;
ivSelectOrientation.Orientation = Orientation.Horizontal;
ivSelectOrientation.PackEnd(rendererOrientation,false);
ivSelectOrientation.SetCellDataFunc(rendererOrientation, new Gtk.CellLayoutDataFunc(RenderOrientationProject));
ivSelectOrientation.PixbufColumn = COL_PIXBUF;
ivSelectOrientation.TooltipColumn = COL_DISPLAY_TEXT;
foreach(SettingValue ds in MainClass.Settings.DisplayOrientations){
storeOrientation.AppendValues (ds.Display,ds.Display,null,ds.Value);
}
ivSelectOrientation.SelectPath(new TreePath("0"));
storeWorkspace = new ListStore(typeof(string), typeof(string), typeof(int));
cbeWorkspace = new ComboBoxEntry();
cbeWorkspace.Model = storeWorkspace;
cbeWorkspace.TextColumn = 0;
cbeWorkspace.Changed+= OnCbeWorkspaceChanged;
this.feLocation = new FileEntry();
this.table3.Attach (this.feLocation,1,2,2,3);
Gtk.Table.TableChild w9 = ((Gtk.Table.TableChild)(this.table3 [this.feLocation]));
w9.XOptions = ((Gtk.AttachOptions)(4));
w9.YOptions = ((Gtk.AttachOptions)(4));
table3.Attach(cbeWorkspace,1,2,1,2,AttachOptions.Fill|AttachOptions.Expand,AttachOptions.Fill,0,0);
CellRendererText rendererWorkspace = new CellRendererText();
cbeWorkspace.PackStart(rendererWorkspace, true);
cbeWorkspace.SetCellDataFunc(rendererWorkspace, new Gtk.CellLayoutDataFunc(RenderWorkspacePath));
cbeWorkspace.WidthRequest = 125;
cbeWorkspace.SetCellDataFunc(cbeWorkspace.Cells[0], new Gtk.CellLayoutDataFunc(RenderWorkspaceName));
string currentWorkspace ="";
if((MainClass.Workspace!= null) && !string.IsNullOrEmpty(MainClass.Workspace.FilePath))
{
string name = System.IO.Path.GetFileNameWithoutExtension(MainClass.Workspace.FilePath);
storeWorkspace.AppendValues (name,MainClass.Workspace.FilePath,1);
currentWorkspace = MainClass.Workspace.FilePath;
}
IList<RecentFile> lRecentProjects = MainClass.Settings.RecentFiles.GetWorkspace();
foreach(RecentFile rf in lRecentProjects){
if(rf.FileName == currentWorkspace) continue;
if(File.Exists(rf.FileName)){
string name = System.IO.Path.GetFileNameWithoutExtension(rf.FileName);
storeWorkspace.AppendValues(name,rf.FileName,0);
}
}
//storeWorkspace.AppendValues("","-------------",-1);
worksDefaultName = "Workspace"+MainClass.Settings.WorkspaceCount.ToString();
TreeIter tiNewW = storeWorkspace.AppendValues(worksDefaultName,MainClass.Paths.WorkDir,2);
if(!String.IsNullOrEmpty(currentWorkspace)){
cbeWorkspace.Active =0;
}
else {
feLocation.DefaultPath = MainClass.Paths.WorkDir;
cbeWorkspace.SetActiveIter(tiNewW);
//storeWorkspace.AppendValues(worksDefaultName,MainClass.Paths.WorkDir,2);
}
prjDefaultName = "Project"+MainClass.Settings.ProjectCount.ToString();
entrProjectName.Text = prjDefaultName;
cbeWorkspace.ShowAll();
feLocation.ShowAll();
CellRendererText rendererTemplate = new CellRendererText();
cbTemplate.PackStart(rendererTemplate, true);
storeTemplate = new ListStore(typeof(string), typeof(string), typeof(string));
cbTemplate.Model = storeTemplate;
cbTemplate.Changed+= delegate(object sender, EventArgs e) {
if(cbTemplate.Active <0) return;
if(cbTemplate.ActiveText != KEY_CUSTOM){
tblLibraries.Sensitive = false;
tblScreens.Sensitive = false;
ivSelectOrientation.Sensitive = false;
} else {
ivSelectOrientation.Sensitive = true;
tblLibraries.Sensitive = true;
tblScreens.Sensitive = true;
}
TreeIter tiChb = new TreeIter();
cbTemplate.GetActiveIter(out tiChb);
if(tiChb.Equals(TreeIter.Zero))return;
string appPath = storeTemplate.GetValue(tiChb, 2).ToString();
if(File.Exists(appPath)){
AppFile app = new AppFile(appPath);
List<string> libs = new List<string>(app.Libs);
Widget[] widgets = tblLibraries.Children;
foreach (Widget w in widgets ){
int indx = libs.FindIndex(x=>x==w.Name);
if(indx>-1) {
(w as CheckButton).Active = true;
} else {
(w as CheckButton).Active = false;
}
}
}
};
btnBack.Sensitive = false;
}
public EditModsDialog(Instance inst, Gtk.Window parent = null)
: base("Edit Mods", parent, DialogFlags.Modal)
{
Inst = inst;
using (Button buttonRefresh = new Button("gtk-refresh"))
{
buttonRefresh.Clicked += (sender, e) =>
{
LoadMods();
};
ActionArea.Homogeneous = false;
ActionArea.PackEnd(buttonRefresh, false, true, 0);
buttonRefresh.Visible = true;
}
this.Build();
#region We have to make the treeview ourselves since monodevelop is absolute shit...
this.editModScroll = new ScrolledWindow();
this.editModScroll.HscrollbarPolicy = PolicyType.Never;
this.modView = new Gtk.TreeView();
this.modView.CanFocus = true;
this.modView.Name = "modView";
this.editModScroll.Add(this.modView);
this.VBox.Add(this.editModScroll);
Gtk.Box.BoxChild w3 = ((Gtk.Box.BoxChild)(this.VBox[this.editModScroll]));
w3.Position = 0;
this.ShowAll();
#endregion
modList = new ListStore(typeof(string), typeof(int), typeof(bool));
modView.Model = modList;
using (CellRendererText cr = new CellRendererText())
modView.AppendColumn("Index", cr, "text", 1);
using (CellRendererText cr = new CellRendererText())
modView.AppendColumn("File", cr, "text", 0);
CellRendererToggle toggleRenderer = new CellRendererToggle();
toggleRenderer.Activatable = true;
toggleRenderer.Sensitive = true;
toggleRenderer.Toggled += (object o, ToggledArgs args) =>
{
TreeIter iter;
using (TreePath tp = new TreePath(args.Path))
if (modList.GetIter(out iter, tp))
modList.SetValue(iter, 2, !(bool) modList.GetValue(iter, 2));
};
modView.AppendColumn("Delete?", toggleRenderer, "active", 2);
modView.Columns[0].Alignment = 0.0f;
modView.Columns[1].Alignment = 0.0f;
modView.Columns[1].Expand = true;
modView.Columns[2].Alignment = 1.0f;
modView.Reorderable = true;
LoadMods();
// Auto-refresh
Inst.InstMods.ModFileChanged += (sender, e) =>
Application.Invoke((sender2, e2) => LoadMods());
}
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) {
var provider = (BaseCodeIssueProvider)treeStore.GetValue (iter, 1);
var severity = (Severity)comboBoxStore.GetValue (storeIter, 1);
severities[provider] = severity;
return;
}
} while (comboBoxStore.IterNext (ref storeIter));
};
col.SetCellDataFunc (comboRenderer, delegate (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter) {
var provider = (BaseCodeIssueProvider)model.GetValue (iter, 1);
if (provider == null) {
comboRenderer.Visible = false;
return;
}
var severity = severities[provider];
comboRenderer.Visible = true;
comboRenderer.Text = GetDescription (severity);
comboRenderer.BackgroundGdk = GetColor (severity);
});
treeviewInspections.HeadersVisible = false;
treeviewInspections.Model = treeStore;
treeviewInspections.Selection.Changed += HandleSelectionChanged;
GetAllSeverities ();
FillInspectors (null);
}
public MainWindow (): base (Gtk.WindowType.Toplevel)
{
Build ();
//Crear treeview categorias
treeView.AppendColumn ("Id", new CellRendererText (), "text", 0);
treeView.AppendColumn ("Nombre", new CellRendererText (), "text", 1);
ListStore listStore = new ListStore (typeof(long), typeof(string));
treeView.Model = listStore;
//mysql
App.Instance.DbConnection = new MySqlConnection (
"Database=dbprueba;User=root;Password=sistemas");
App.Instance.DbConnection.Open ();
//operaciones
// IDbCommand insertdbCommand = dbConnection.CreateCommand ();
// insertdbCommand.CommandText =
// "insert into categoria (nombre) values ('categoria 4')";
// insertdbCommand.ExecuteNonQuery ();
//App.Instance.DbConnection.Close ();
CategoriaView categoriaView = new CategoriaView ();
deleteAction.Activated += delegate {
// Confirmar el borrado
// MessageDialog messageDialog= new MessageDialog(
// this,
// DialogFlags.Modal,
// MessageType.Question,
// ButtonsType.YesNo,
// "¿Deseas eliminar el registro?"
// );
// messageDialog.Title=Title;
// ResponseType response=(ResponseType)messageDialog.Run();
// messageDialog.Destroy();
// if(response!=ResponseType.Yes)
// return;
if (!WindowHelper.Confirm (this, "¿Deseas eliminar el registro?"))
return;
Console.WriteLine ("delete activated");
TreeIter treeIter;
treeView.Selection.GetSelected (out treeIter);
object id = listStore.GetValue (treeIter, 0);
Console.WriteLine ("deleteAction Activated id={0}", id);
IDbCommand deleteDbCommand = App.Instance.DbConnection.CreateCommand ();
deleteDbCommand.CommandText = "delete from categoria where id= " + id;
};
treeView.Selection.Changed += delegate {
Console.WriteLine ("Selection changed CountSelectedRows()={0}",
treeView.Selection.CountSelectedRows ());
updateActions ();
};
refreshAction.Activated += delegate {
fillListstore (listStore);
};
deleteAction.Activated += delegate {
MessageDialog messageDialog = new MessageDialog(
this,
DialogFlags.Modal,
MessageType.Question,
ButtonsType.YesNo,
"¿Quieres eliminar el registro?"
);
ResponseType response = (ResponseType)messageDialog.Run();
messageDialog.Destroy();
if (response == ResponseType.Yes)
Console.WriteLine ("ResponseType.Yes");;//lo que toque
updateActions ();
}
void MoveItem (TreeView sourceList, ListStore sourceStore, TreeView targetList, ListStore targetStore)
{
TreeModel model;
TreeIter iter;
if (sourceList.Selection.GetSelected (out model, out iter)) {
TreeIter newiter = targetStore.AppendValues (sourceStore.GetValue (iter, 0), sourceStore.GetValue (iter, 1));
targetList.Selection.SelectIter (newiter);
TreeIter oldIter = iter;
if (sourceStore.IterNext (ref iter))
sourceList.Selection.SelectIter (iter);
sourceStore.Remove (ref oldIter);
}
}
static TreeIter FindTask (ListStore store, Task task)
{
TreeIter iter;
if (!store.GetIterFirst (out iter))
return TreeIter.Zero;
do {
Task t = store.GetValue (iter, (int)Columns.Task) as Task;
if (t == task)
return iter;
}
while (store.IterNext (ref iter));
return TreeIter.Zero;
}
public MainWindow()
{
XML gxml = new XML(null, "MultiMC.GTKGUI.MainWindow.glade",
"mainVBox", null);
gxml.Toplevel = this;
gxml.Autoconnect(this);
XML gxml2 = new XML(null, "MultiMC.GTKGUI.InstContextMenu.glade",
"instContextMenu", null);
gxml2.Autoconnect(this);
/*
* HACK: the nested menu isn't picked up by the first gxml object. It is probably a GTK# bug.
* This is the fix - manually asking for the menu and connecting it.
*/
XML gxml3 = new XML(null, "MultiMC.GTKGUI.MainWindow.glade",
"menunew", null);
gxml3.Autoconnect(this);
newInstButton.Menu = menunew;
this.Add(mainVBox);
ShowAll();
this.WidthRequest = 620;
this.HeightRequest = 380;
DeleteEvent += (o, args) => Application.Quit();
// Set up the instance icon view
instListStore = new ListStore(
typeof(string), typeof(Gdk.Pixbuf), typeof(Instance));
instView.Model = instListStore;
instView.TextColumn = 0;
instView.PixbufColumn = 1;
instView.ItemWidth = -1;
Gtk.CellRendererText crt = instView.Cells[0] as CellRendererText;
crt.Editable = true;
crt.Edited += (object o, EditedArgs args) =>
{
int EditedIndex = int.Parse(args.Path);
TreeIter iter;
// don't allow bad names
if(!Instance.NameIsValid(args.NewText))
return;
System.Console.WriteLine("Path: " + args.Path + " New text: " + args.NewText);
if(instListStore.GetIterFromString(out iter,args.Path))
{
instListStore.SetValue(iter, 0, args.NewText);
Instance inst = instListStore.GetValue(iter, 2) as Instance;
inst.Name = args.NewText;
}
};
instView.Orientation = Orientation.Vertical;
instView.ButtonPressEvent += (o, args) =>
{
if (args.Event.Button == 3 &&
instView.GetPathAtPos((int)args.Event.X,
(int)args.Event.Y) != null)
{
instView.SelectPath(instView.GetPathAtPos(
(int)args.Event.X, (int)args.Event.Y));
instContextMenu.Popup();
}
};
instView.KeyPressEvent += (object o, KeyPressEventArgs args) =>
{
if(args.Event.Key == Gdk.Key.F2)
{
if(instView.SelectedItems.Count() != 0)
instView.SetCursor(instView.SelectedItems[0], instView.Cells[0], true);
}
else if(args.Event.Key == Gdk.Key.Escape)
{
if(EscPressed != null)
EscPressed(this, EventArgs.Empty);
}
};
// Set up the task list
EventfulList<Task> tList = new EventfulList<Task>();
tList.Added += TaskAdded;
tList.Removed += TaskRemoved;
TaskList = tList;
taskProgBars = new Dictionary<int, Box>();
// Set up the instance list
EventfulList<Instance> iList = new EventfulList<Instance>();
iList.Added += InstAdded;
iList.Removed += InstRemoved;
InstanceList = iList;
helpButton.Sensitive = false;
if(OSUtils.OS == OSEnum.Linux)
{
Gtk.MenuItem openalRemoveItem = gxml2.GetWidget("removeOpenALMenuItem") as Gtk.MenuItem;
openalRemoveItem.Visible = true;
}
}
public override void LaunchDialogue ()
{
//the Type in the collection
IList collection = (IList) Value;
string displayName = Property.DisplayName;
//populate list with existing items
ListStore itemStore = new ListStore (typeof (object), typeof (int), typeof (string));
for (int i=0; i<collection.Count; i++)
itemStore.AppendValues(collection [i], i, collection [i].ToString ());
#region Building Dialogue
TreeView itemTree;
PropertyGrid grid;
TreeIter previousIter = TreeIter.Zero;
//dialogue and buttons
Dialog dialog = new Dialog () {
Title = displayName + " Editor",
Modal = true,
AllowGrow = true,
AllowShrink = true,
};
var toplevel = this.Container.Toplevel as Window;
if (toplevel != null)
dialog.TransientFor = toplevel;
dialog.AddActionWidget (new Button (Stock.Cancel), ResponseType.Cancel);
dialog.AddActionWidget (new Button (Stock.Ok), ResponseType.Ok);
//three columns for items, sorting, PropGrid
HBox hBox = new HBox ();
dialog.VBox.PackStart (hBox, true, true, 5);
//propGrid at end
grid = new PropertyGrid (base.EditorManager) {
CurrentObject = null,
WidthRequest = 200,
ShowHelp = false
};
hBox.PackEnd (grid, true, true, 5);
//followed by a ButtonBox
VBox buttonBox = new VBox ();
buttonBox.Spacing = 6;
hBox.PackEnd (buttonBox, false, false, 5);
//add/remove buttons
Button addButton = new Button (new Image (Stock.Add, IconSize.Button));
buttonBox.PackStart (addButton, false, false, 0);
if (types [0].IsAbstract)
addButton.Sensitive = false;
Button removeButton = new Button (new Gtk.Image (Stock.Remove, IconSize.Button));
buttonBox.PackStart (removeButton, false, false, 0);
//sorting buttons
Button upButton = new Button (new Image (Stock.GoUp, IconSize.Button));
buttonBox.PackStart (upButton, false, false, 0);
Button downButton = new Button (new Image (Stock.GoDown, IconSize.Button));
buttonBox.PackStart (downButton, false, false, 0);
//Third column has list (TreeView) in a ScrolledWindow
ScrolledWindow listScroll = new ScrolledWindow ();
listScroll.WidthRequest = 200;
listScroll.HeightRequest = 320;
hBox.PackStart (listScroll, false, false, 5);
itemTree = new TreeView (itemStore);
itemTree.Selection.Mode = SelectionMode.Single;
itemTree.HeadersVisible = false;
listScroll.AddWithViewport (itemTree);
//renderers and attribs for TreeView
CellRenderer rdr = new CellRendererText ();
itemTree.AppendColumn (new TreeViewColumn ("Index", rdr, "text", 1));
rdr = new CellRendererText ();
itemTree.AppendColumn (new TreeViewColumn ("Object", rdr, "text", 2));
#endregion
#region Events
addButton.Clicked += delegate {
//create the object
object instance = System.Activator.CreateInstance (types[0]);
//get existing selection and insert after it
TreeIter oldIter, newIter;
if (itemTree.Selection.GetSelected (out oldIter))
newIter = itemStore.InsertAfter (oldIter);
//or append if no previous selection
else
newIter = itemStore.Append ();
itemStore.SetValue (newIter, 0, instance);
//select, set name and update all the indices
itemTree.Selection.SelectIter (newIter);
UpdateName (itemStore, newIter);
UpdateIndices (itemStore);
};
removeButton.Clicked += delegate {
//get selected iter and the replacement selection
TreeIter iter, newSelection;
if (!itemTree.Selection.GetSelected (out iter))
return;
newSelection = iter;
if (!IterPrev (itemStore, ref newSelection)) {
newSelection = iter;
if (!itemStore.IterNext (ref newSelection))
newSelection = TreeIter.Zero;
}
//new selection. Zeroing previousIter prevents trying to update name of deleted iter.
previousIter = TreeIter.Zero;
if (itemStore.IterIsValid (newSelection))
itemTree.Selection.SelectIter (newSelection);
//and the removal and index update
itemStore.Remove (ref iter);
UpdateIndices (itemStore);
};
upButton.Clicked += delegate {
TreeIter iter, prev;
if (!itemTree.Selection.GetSelected (out iter))
return;
//get previous iter
prev = iter;
if (!IterPrev (itemStore, ref prev))
return;
//swap the two
itemStore.Swap (iter, prev);
//swap indices too
object prevVal = itemStore.GetValue (prev, 1);
object iterVal = itemStore.GetValue (iter, 1);
itemStore.SetValue (prev, 1, iterVal);
itemStore.SetValue (iter, 1, prevVal);
};
downButton.Clicked += delegate {
TreeIter iter, next;
if (!itemTree.Selection.GetSelected (out iter))
return;
//get next iter
next = iter;
if (!itemStore.IterNext (ref next))
return;
//swap the two
itemStore.Swap (iter, next);
//swap indices too
object nextVal = itemStore.GetValue (next, 1);
object iterVal = itemStore.GetValue (iter, 1);
itemStore.SetValue (next, 1, iterVal);
itemStore.SetValue (iter, 1, nextVal);
};
itemTree.Selection.Changed += delegate {
TreeIter iter;
if (!itemTree.Selection.GetSelected (out iter)) {
removeButton.Sensitive = false;
return;
}
removeButton.Sensitive = true;
//update grid
object obj = itemStore.GetValue (iter, 0);
grid.CurrentObject = obj;
//update previously selected iter's name
UpdateName (itemStore, previousIter);
//update current selection so we can update
//name next selection change
previousIter = iter;
};
grid.Changed += delegate {
TreeIter iter;
if (itemTree.Selection.GetSelected (out iter))
UpdateName (itemStore, iter);
};
TreeIter selectionIter;
removeButton.Sensitive = itemTree.Selection.GetSelected (out selectionIter);
dialog.ShowAll ();
grid.ShowToolbar = false;
#endregion
//if 'OK' put items back in collection
//if (MonoDevelop.Ide.MessageService.ShowCustomDialog (dialog, toplevel) == (int)ResponseType.Ok)
{
DesignerTransaction tran = CreateTransaction (Instance);
object old = collection;
try {
collection.Clear();
foreach (object[] o in itemStore)
collection.Add (o[0]);
EndTransaction (Instance, tran, old, collection, true);
}
catch {
EndTransaction (Instance, tran, old, collection, false);
throw;
}
}
}
