diff --git a/ChangeLog b/ChangeLog index 427ae54d1..9736cfa1e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,27 @@ +2003-05-19 Rachel Hestilow + + * glib/ManagedValue.cs, TypeConverter.cs: Added. + * glib/Value.cs: Make Value inherit from IDisposable, and + move dtor to Dispose. Add generic object constructor + with support for ManagedValue. Add a new Val property + which will call the appropriate explicit cast. + + * glue/value.c: Add new glue function + gtksharp_value_get_value_type. + + * gtk/TreeViewColumn.custom: Added. + * gtk/ListStore.custom, TreeStore.custom: Add a number + of SetValue overloads. Add convenience functtion + AppendValues. Add new ctor that takes System.Type instead + of GLib.TypeFundamentals. Add a GetValue convenience wrapper. + * gtk/TreeView.custom: Add AppendColumn convenience + functions. + + * sample/ManagedTreeViewDemo.cs: Added. + * sample/Makefile.in: Update. + * sample/TreeViewDemo.cs: Update to use new convenience + APIs. + 2003-05-18 Mike Kestner * generator/CallbackGen.cs : use non-static symtab, kill doc comments diff --git a/glib/ManagedValue.cs b/glib/ManagedValue.cs new file mode 100644 index 000000000..3d36ec8f2 --- /dev/null +++ b/glib/ManagedValue.cs @@ -0,0 +1,94 @@ +// GLib.ManagedValue.cs : Managed types boxer +// +// Author: Rachel Hestilow +// +// (c) 2002 Rachel Hestilow + +namespace GLibSharp { + using System; + using System.Collections; + using System.Runtime.InteropServices; + + /// + /// Managed types boxer + /// + /// + /// + /// Utility class for creating GBoxed wrappers around managed types + /// + + // FIXME: + // This used to use GCHandles, but I rewrote it to debug + // some odd interactions. Since the boxed code in GLib is designed + // to not interact directly with the pointers, just using our own + // arbitrary pointer values is fine. Still, it might be useful + // to use GCHandle later on. + + public class ManagedValue { + private class ValueHolder { + public object val; + public int ref_count; + } + + private delegate IntPtr CopyFunc (IntPtr ptr); + private delegate void FreeFunc (IntPtr ptr); + + private static Hashtable pointers = new Hashtable (); + private static IntPtr cur_ptr = IntPtr.Zero; + private static CopyFunc copy; + private static FreeFunc free; + private static uint boxed_type = 0; + + [DllImport("gobject-2.0")] + private static extern uint g_boxed_type_register_static (string typename, CopyFunc copy_func, FreeFunc free_func); + + public static uint GType { + get { + if (boxed_type == 0) { + copy = new CopyFunc (Copy); + free = new FreeFunc (Free); + + boxed_type = g_boxed_type_register_static ("GtkSharpValue", copy, free); + } + + return boxed_type; + } + } + + public static IntPtr Copy (IntPtr ptr) + { + ValueHolder holder = (ValueHolder) pointers[ptr]; + holder.ref_count++; + return ptr; + } + + public static void Free (IntPtr ptr) + { + ValueHolder holder = (ValueHolder) pointers[ptr]; + holder.ref_count--; + if (holder.ref_count < 1) + pointers.Remove (ptr); + } + + public static IntPtr WrapObject (object obj) + { + ValueHolder holder = new ValueHolder (); + holder.val = obj; + holder.ref_count = 1; + cur_ptr = new IntPtr (((int) cur_ptr) + 1); + pointers[cur_ptr] = holder; + return cur_ptr; + } + + public static object ObjectForWrapper (IntPtr ptr) + { + if (!pointers.Contains (ptr)) + return null; + + ValueHolder holder = (ValueHolder) pointers[ptr]; + return holder.val; + } + + } +} + diff --git a/glib/TypeConverter.cs b/glib/TypeConverter.cs new file mode 100644 index 000000000..ad1f49ec5 --- /dev/null +++ b/glib/TypeConverter.cs @@ -0,0 +1,51 @@ +// GLib.TypeConverter.cs : Convert between fundamental and .NET types +// +// Author: Rachel Hestilow +// +// (c) 2002 Rachel Hestilow + +namespace GLibSharp { + using System; + using System.Collections; + using GLib; + + /// + /// Fundamental type converter + /// + /// + /// + /// Utilities for converting between TypeFundamentals and System.Type + /// + public class TypeConverter { + public static TypeFundamentals LookupType (System.Type type) + { + if (type.Equals (typeof (string))) + return TypeFundamentals.TypeString; + + if (!type.IsValueType) { + if (type.IsSubclassOf (typeof (GLib.Object))) + return TypeFundamentals.TypeObject; + else if (type.IsSubclassOf (typeof (GLib.Boxed))) + return TypeFundamentals.TypeBoxed; + else + return TypeFundamentals.TypeNone; + } + + if (type.Equals (typeof (bool))) + return TypeFundamentals.TypeBoolean; + if (type.Equals (typeof (int))) + return TypeFundamentals.TypeInt; + if (type.Equals (typeof (double))) + return TypeFundamentals.TypeDouble; + if (type.Equals (typeof (float))) + return TypeFundamentals.TypeFloat; + if (type.Equals (typeof (char))) + return TypeFundamentals.TypeChar; + if (type.Equals (typeof (uint))) + return TypeFundamentals.TypeUInt; + + return TypeFundamentals.TypeInvalid; + } + } +} + diff --git a/glib/Value.cs b/glib/Value.cs index fa7578641..9a2277ba2 100755 --- a/glib/Value.cs +++ b/glib/Value.cs @@ -8,6 +8,7 @@ namespace GLib { using System; using System.Runtime.InteropServices; + using GLibSharp; /// /// Value Class @@ -18,7 +19,7 @@ namespace GLib { /// to get and set properties on Objects. /// - public class Value { + public class Value : IDisposable { IntPtr _val; @@ -31,7 +32,19 @@ namespace GLib { ~Value () { - g_free (_val); + Dispose (); + } + + public void Dispose () { + if (_val != IntPtr.Zero) { + uint type = gtksharp_value_get_value_type (_val); + if (type == ManagedValue.GType) { + ManagedValue.Free (g_value_get_boxed (_val)); + } + + g_free (_val); + _val = IntPtr.Zero; + } } @@ -262,6 +275,8 @@ namespace GLib { static extern void g_value_set_enum (IntPtr val, int data); [DllImport("libgobject-2.0-0.dll")] static extern void g_value_set_flags (IntPtr val, uint data); + [DllImport("gobject-2.0")] + static extern void g_value_set_char (IntPtr val, char data); /// /// Value Constructor @@ -280,6 +295,66 @@ namespace GLib { g_value_set_enum (_val, (int) wrap); } + /// + /// Value Constructor + /// + /// + /// + /// Constructs a Value from any object, including a managed + /// type. + /// + + [DllImport("gobject-2.0")] + static extern void g_value_set_boxed_take_ownership (IntPtr val, IntPtr data); + + public Value (object obj) + { + TypeFundamentals type = TypeConverter.LookupType (obj.GetType ()); + if (type == TypeFundamentals.TypeNone) { + _val = gtksharp_value_create (ManagedValue.GType); + } else if (type == TypeFundamentals.TypeObject) { + _val = gtksharp_value_create (((GLib.Object) obj).GetGType ()); + } else if (type == TypeFundamentals.TypeInvalid) { + throw new Exception ("Unknown type"); + } else { + _val = gtksharp_value_create ((uint) type); + } + + switch (type) { + case TypeFundamentals.TypeNone: + g_value_set_boxed_take_ownership (_val, ManagedValue.WrapObject (obj)); + break; + case TypeFundamentals.TypeString: + g_value_set_string (_val, (string) obj); + break; + case TypeFundamentals.TypeBoolean: + g_value_set_boolean (_val, (bool) obj); + break; + case TypeFundamentals.TypeInt: + g_value_set_int (_val, (int) obj); + break; + case TypeFundamentals.TypeDouble: + g_value_set_double (_val, (double) obj); + break; + case TypeFundamentals.TypeFloat: + g_value_set_float (_val, (float) obj); + break; + case TypeFundamentals.TypeChar: + g_value_set_char (_val, (char) obj); + break; + case TypeFundamentals.TypeUInt: + g_value_set_uint (_val, (uint) obj); + break; + case TypeFundamentals.TypeObject: + g_value_set_object (_val, ((GLib.Object) obj).Handle); + break; + default: + throw new Exception ("Unknown type"); + } + } + + + [DllImport("libgobject-2.0-0.dll")] static extern bool g_value_get_boolean (IntPtr val); @@ -521,6 +596,40 @@ namespace GLib { return new EnumWrapper (g_value_get_enum (val._val), false); } + [DllImport("gtksharpglue")] + static extern uint gtksharp_value_get_value_type (IntPtr val); + + public object Val + { + get { + uint type = gtksharp_value_get_value_type (_val); + if (type == ManagedValue.GType) { + return ManagedValue.ObjectForWrapper (g_value_get_boxed (_val)); + } + + switch (type) { + case TypeFundamentals.TypeString: + return (string) this; + case TypeFundamentals.TypeBoolean: + return (bool) this; + case TypeFundamentals.TypeInt: + return (int) this; + case TypeFundamentals.TypeDouble: + return (double) this; + case TypeFundamentals.TypeFloat: + return (float) this; + case TypeFundamentals.TypeChar: + return (char) this; + case TypeFundamentals.TypeUInt: + return (uint) this; + case TypeFundamentals.TypeObject: + return (GLib.Object) this; + default: + throw new Exception ("Unknown type"); + } + } + } + /// /// Handle Property /// diff --git a/glue/value.c b/glue/value.c index 5cdf86ccd..971cf952b 100644 --- a/glue/value.c +++ b/glue/value.c @@ -29,3 +29,10 @@ gtksharp_value_create_from_property (GObject *obj, const gchar* name) return gtksharp_value_create (spec->value_type); } +GType +gtksharp_value_get_value_type (GValue *value) { + g_return_val_if_fail (value != NULL, G_TYPE_INVALID); + g_return_val_if_fail (G_IS_VALUE (value), G_TYPE_INVALID); + return G_VALUE_TYPE (value); +} + diff --git a/gtk/ListStore.custom b/gtk/ListStore.custom index 065d727aa..9992e6607 100644 --- a/gtk/ListStore.custom +++ b/gtk/ListStore.custom @@ -34,3 +34,84 @@ { SetColumnTypes (types.Length, types); } + + public void SetValue (Gtk.TreeIter iter, int column, bool value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, double value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, int value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, string value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, float value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, uint value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, object value) { + GLib.Value val = new GLib.Value (value); + SetValue (iter, column, val); + val.Dispose (); + } + + public Gtk.TreeIter AppendValues (Array values) { + Gtk.TreeIter iter; + Append (out iter); + + int col = 0; + foreach (object value in values) { + if (value != null) { + GLib.Value val = new GLib.Value (value); + SetValue (iter, col, val); + val.Dispose (); + } + col++; + } + + return iter; + } + + public Gtk.TreeIter AppendValues (params object[] values) { + return AppendValues ((Array) values); + } + + public ListStore (params Type[] types) + { + uint[] ctypes = new uint[types.Length]; + int i = 0; + foreach (Type type in types) { + GLib.TypeFundamentals ctype = GLibSharp.TypeConverter.LookupType (type); + if (ctype == GLib.TypeFundamentals.TypeNone) { + ctypes[i] = GLibSharp.ManagedValue.GType; + } else if (ctype == GLib.TypeFundamentals.TypeInvalid) { + throw new Exception ("Unknown type"); + } else { + ctypes[i] = (uint) ctype; + } + i++; + } + + Raw = gtk_list_store_newv (ctypes.Length, ctypes); + } + + public object GetValue(Gtk.TreeIter iter, int column) { + GLib.Value val; + GetValue (iter, column, out val); + object ret = val.Val; + val.Dispose (); + return ret; + } + + + diff --git a/gtk/TreeStore.custom b/gtk/TreeStore.custom index aa7da12b0..3a00fdf1a 100644 --- a/gtk/TreeStore.custom +++ b/gtk/TreeStore.custom @@ -114,3 +114,91 @@ { SetColumnTypes (types.Length, types); } + + public void SetValue (Gtk.TreeIter iter, int column, bool value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, double value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, int value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, string value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, float value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, uint value) { + SetValue (iter, column, new GLib.Value (value)); + } + + public void SetValue (Gtk.TreeIter iter, int column, object value) { + SetValue (iter, column, new GLib.Value (value)); + } + + private void _AppendValues (Gtk.TreeIter iter, Array values) { + int col = 0; + foreach (object value in values) { + if (value != null) + SetValue (iter, col, new GLib.Value (value)); + col++; + } + } + + public Gtk.TreeIter AppendValues (Gtk.TreeIter parent, Array values) { + Gtk.TreeIter iter; + Append (out iter, parent); + _AppendValues (iter, values); + return iter; + } + + public Gtk.TreeIter AppendValues (Gtk.TreeIter parent, params object[] values) { + return AppendValues (parent, (Array) values); + } + + public Gtk.TreeIter AppendValues (Array values) { + Gtk.TreeIter iter; + Append (out iter); + _AppendValues (iter, values); + return iter; + } + + public Gtk.TreeIter AppendValues (params object[] values) { + return AppendValues ((Array) values); + } + + public TreeStore (params Type[] types) + { + uint[] ctypes = new uint[types.Length]; + int i = 0; + foreach (Type type in types) { + GLib.TypeFundamentals ctype = GLibSharp.TypeConverter.LookupType (type); + if (ctype == GLib.TypeFundamentals.TypeNone) { + ctypes[i] = GLibSharp.ManagedValue.GType; + } else if (ctype == GLib.TypeFundamentals.TypeInvalid) { + throw new Exception ("Unknown type"); + } else { + ctypes[i] = (uint) ctype; + } + i++; + } + + Raw = gtk_tree_store_newv (ctypes.Length, ctypes); + } + + public object GetValue (Gtk.TreeIter iter, int column) { + GLib.Value val; + GetValue (iter, column, out val); + object ret = val.Val; + val.Dispose (); + return ret; + } + + diff --git a/gtk/TreeView.custom b/gtk/TreeView.custom index 7c8a50cae..a946be5c6 100644 --- a/gtk/TreeView.custom +++ b/gtk/TreeView.custom @@ -95,3 +95,19 @@ return raw_ret; } + public Gtk.TreeViewColumn AppendColumn (string title, Gtk.CellRenderer cell, Gtk.TreeCellDataFunc cell_data) { + Gtk.TreeViewColumn col = new Gtk.TreeViewColumn (); + col.Title = title; + col.PackStart (cell, true); + col.SetCellDataFunc (cell, cell_data); + + AppendColumn (col); + return col; + } + + public Gtk.TreeViewColumn AppendColumn (string title, Gtk.CellRenderer cell, params object[] attrs) { + Gtk.TreeViewColumn col = new Gtk.TreeViewColumn (title, cell, attrs); + AppendColumn (col); + return col; + } + diff --git a/gtk/TreeViewColumn.custom b/gtk/TreeViewColumn.custom new file mode 100644 index 000000000..44ae1c1e5 --- /dev/null +++ b/gtk/TreeViewColumn.custom @@ -0,0 +1,34 @@ +// Gtk.TreeViewColumn.Custom - Gtk TreeViewColumn class customizations +// +// Author: Rachel Hestilow +// +// (c) 2003 Rachel Hestilow +// +// This code is inserted after the automatically generated code. + + + public void SetCellDataFunc(Gtk.CellRenderer cell_renderer, Gtk.TreeCellDataFunc func) { + GtkSharp.TreeCellDataFuncWrapper func_wrapper = null; + func_wrapper = new GtkSharp.TreeCellDataFuncWrapper (func, this); + gtk_tree_view_column_set_cell_data_func(Handle, cell_renderer.Handle, func_wrapper.NativeDelegate, IntPtr.Zero, null); + } + + private void _NewWithAttributes (string title, Gtk.CellRenderer cell, Array attrs) { + Title = title; + PackStart (cell, true); + for (int i = 0; (i + 1) < attrs.Length; i += 2) { + AddAttribute (cell, (string) attrs[i], (int) attrs[i + 1]); + } + } + + public TreeViewColumn (string title, Gtk.CellRenderer cell, Array attrs) { + Raw = gtk_tree_view_column_new (); + _NewWithAttributes (title, cell, attrs); + } + + public TreeViewColumn (string title, Gtk.CellRenderer cell, params object[] attrs) + { + Raw = gtk_tree_view_column_new (); + _NewWithAttributes (title, cell, attrs); + } + diff --git a/sample/Makefile.in b/sample/Makefile.in index af9feb635..96375a735 100755 --- a/sample/Makefile.in +++ b/sample/Makefile.in @@ -18,7 +18,7 @@ windows: $(CSC) /unsafe /out:gtk-hello-world.exe /r:../glib/glib-sharp.dll /r:../gtk/gtk-sharp.dll /r:../gdk/gdk-sharp.dll HelloWorld.cs $(CSC) /unsafe /out:button.exe /r:../glib/glib-sharp.dll /r:../gtk/gtk-sharp.dll ButtonApp.cs -linux: gtk-hello-world.exe button.exe calendar.exe subclass.exe menu.exe size.exe scribble.exe treeviewdemo.exe $(GNOME_TARGETS) $(GLADE_TARGETS) +linux: gtk-hello-world.exe button.exe calendar.exe subclass.exe menu.exe size.exe scribble.exe treeviewdemo.exe managedtreeviewdemo.exe $(GNOME_TARGETS) $(GLADE_TARGETS) @ENABLE_GNOME_TRUE@ $(MAKE) -C gconf @ENABLE_GNOME_TRUE@ $(MAKE) -C rsvg @@ -55,6 +55,9 @@ scribble.exe: Scribble.cs treeviewdemo.exe: TreeViewDemo.cs $(MCS) --unsafe -o treeviewdemo.exe $(local_paths) $(all_assemblies) TreeViewDemo.cs +managedtreeviewdemo.exe: ManagedTreeViewDemo.cs + $(MCS) --unsafe -o managedtreeviewdemo.exe $(local_paths) $(all_assemblies) ManagedTreeViewDemo.cs + glade-viewer.exe: GladeViewer.cs $(MCS) --unsafe -o glade-viewer.exe $(local_paths) $(all_assemblies) GladeViewer.cs diff --git a/sample/ManagedTreeViewDemo.cs b/sample/ManagedTreeViewDemo.cs new file mode 100644 index 000000000..72938ad53 --- /dev/null +++ b/sample/ManagedTreeViewDemo.cs @@ -0,0 +1,82 @@ +// ManagedTreeViewDemo.cs - Another TreeView demo +// +// Author: Rachel Hestilow +// +// (c) 2003 Rachel Hestilow + +namespace GtkSamples { + using System; + using System.Drawing; + using System.Runtime.InteropServices; + + using Gtk; + using GtkSharp; + + public class TreeViewDemo { + private static ListStore store = null; + + private class Pair { + public string a, b; + public Pair (string a, string b) { + this.a = a; + this.b = b; + } + } + + private static void PopulateStore () + { + store = new ListStore (typeof (Pair)); + string[] combs = {"foo", "bar", "baz", "quux"}; + foreach (string a in combs) { + foreach (string b in combs) { + store.AppendValues (new Pair (a, b)); + } + } + } + + private static void CellDataA (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter) + { + Pair val = (Pair) store.GetValue (iter, 0); + ((CellRendererText) cell).Text = val.a; + } + + private static void CellDataB (Gtk.TreeViewColumn tree_column, Gtk.CellRenderer cell, Gtk.TreeModel tree_model, Gtk.TreeIter iter) + { + Pair val = (Pair) store.GetValue (iter, 0); + ((CellRendererText) cell).Text = val.b; + } + + [DllImport("gtk-x11-2.0")] + static extern void gtk_init (ref int argc, ref String[] argv); + + public static void Main (string[] args) + { + Application.Init (); + + PopulateStore (); + + Window win = new Window ("TreeView demo"); + win.DeleteEvent += new DeleteEventHandler (DeleteCB); + win.DefaultSize = new Size (320,480); + + ScrolledWindow sw = new ScrolledWindow (); + win.Add (sw); + + TreeView tv = new TreeView (store); + tv.HeadersVisible = true; + + tv.AppendColumn ("One", new CellRendererText (), new TreeCellDataFunc (CellDataA)); + tv.AppendColumn ("Two", new CellRendererText (), new TreeCellDataFunc (CellDataB)); + + sw.Add (tv); + win.ShowAll (); + + Application.Run (); + } + + private static void DeleteCB (System.Object o, DeleteEventArgs args) + { + Application.Quit (); + } + } +} diff --git a/sample/TreeViewDemo.cs b/sample/TreeViewDemo.cs index 814005110..2f21c5fd0 100644 --- a/sample/TreeViewDemo.cs +++ b/sample/TreeViewDemo.cs @@ -20,35 +20,20 @@ namespace GtkSamples { private static void ProcessType (TreeIter parent, System.Type t) { - TreeIter iter = new TreeIter (); - // .GetMembers() won't work due to unimplemented // scary classes. foreach (MemberInfo mi in t.GetMethods ()) { - GLib.Value Name = new GLib.Value (mi.Name); - GLib.Value Type = new GLib.Value (mi.ToString ()); - - store.Append (out iter, parent); - store.SetValue (iter, 0, Name); - store.SetValue (iter, 1, Type); + store.AppendValues (parent, mi.Name, mi.ToString ()); } } private static void ProcessAssembly (TreeIter parent, Assembly asm) { - TreeIter iter = new TreeIter (); string asm_name = asm.GetName ().Name; foreach (System.Type t in asm.GetTypes ()) { UpdateDialog ("Loading from {0}:\n{1}", asm_name, t.ToString ()); - - GLib.Value Name = new GLib.Value (t.Name); - GLib.Value Type = new GLib.Value (t.ToString ()); - - store.Append (out iter, parent); - store.SetValue (iter, 0, Name); - store.SetValue (iter, 1, Type); - + TreeIter iter = store.AppendValues (parent, t.Name, t.ToString ()); ProcessType (iter, t); } } @@ -58,10 +43,7 @@ namespace GtkSamples { if (store != null) return; - store = new TreeStore ((int)TypeFundamentals.TypeString, - (int)TypeFundamentals.TypeString); - - TreeIter iter = new TreeIter (); + store = new TreeStore (typeof (string), typeof (string)); foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies ()) { // we can't show corlib due to some unimplemented @@ -70,13 +52,7 @@ namespace GtkSamples { UpdateDialog ("Loading {0}", asm.GetName ().Name); - GLib.Value Name = new GLib.Value (asm.GetName ().Name); - GLib.Value Type = new GLib.Value ("Assembly"); - - store.Append (out iter); - store.SetValue (iter, 0, Name); - store.SetValue (iter, 1, Type); - + TreeIter iter = store.AppendValues (asm.GetName ().Name, "Assembly"); ProcessAssembly (iter, asm); } } @@ -104,19 +80,8 @@ namespace GtkSamples { TreeView tv = new TreeView (store); tv.HeadersVisible = true; - TreeViewColumn NameCol = new TreeViewColumn (); - CellRenderer NameRenderer = new CellRendererText (); - NameCol.Title = "Name"; - NameCol.PackStart (NameRenderer, true); - NameCol.AddAttribute (NameRenderer, "text", 0); - tv.AppendColumn (NameCol); - - TreeViewColumn TypeCol = new TreeViewColumn (); - CellRenderer TypeRenderer = new CellRendererText (); - TypeCol.Title = "Type"; - TypeCol.PackStart (TypeRenderer, false); - TypeCol.AddAttribute (TypeRenderer, "text", 1); - tv.AppendColumn (TypeCol); + tv.AppendColumn ("Name", new CellRendererText (), "text", 0); + tv.AppendColumn ("Type", new CellRendererText (), "text", 1); sw.Add (tv); @@ -130,7 +95,6 @@ namespace GtkSamples { private static void DeleteCB (System.Object o, DeleteEventArgs args) { Application.Quit (); - args.RetVal = true; } private static void UpdateDialog (string format, params object[] args)