Wrap more GTK
[xonotic/netradiant.git] / radiant / entityinspector.cpp
index 3160bf4..8c67825 100644 (file)
@@ -22,6 +22,7 @@
 #include "entityinspector.h"
 
 #include "debugging/debugging.h"
+#include <gtk/gtk.h>
 
 #include "ientity.h"
 #include "ifilesystem.h"
@@ -33,7 +34,6 @@
 #include <map>
 #include <set>
 #include <gdk/gdkkeysyms.h>
-#include <gtk/gtk.h>
 #include <uilib/uilib.h>
 
 
 #include "textureentry.h"
 #include "groupdialog.h"
 
-GtkEntry* numeric_entry_new(){
-       GtkEntry* entry = ui::Entry();
-       gtk_widget_show( GTK_WIDGET( entry ) );
-       gtk_widget_set_size_request( GTK_WIDGET( entry ), 64, -1 );
+ui::Entry numeric_entry_new(){
+       auto entry = ui::Entry(ui::New);
+       entry.show();
+       entry.dimensions(64, -1);
        return entry;
 }
 
@@ -104,6 +104,7 @@ void Scene_EntitySetKeyValue_Selected_Undoable( const char* key, const char* val
 class EntityAttribute
 {
 public:
+virtual ~EntityAttribute() = default;
 virtual ui::Widget getWidget() const = 0;
 virtual void update() = 0;
 virtual void release() = 0;
@@ -112,7 +113,7 @@ virtual void release() = 0;
 class BooleanAttribute : public EntityAttribute
 {
 CopiedString m_key;
-GtkCheckButton* m_check;
+ui::CheckButton m_check;
 
 static gboolean toggled( ui::Widget widget, BooleanAttribute* self ){
        self->apply();
@@ -121,36 +122,36 @@ static gboolean toggled( ui::Widget widget, BooleanAttribute* self ){
 public:
 BooleanAttribute( const char* key ) :
        m_key( key ),
-       m_check( 0 ){
-       GtkCheckButton* check = GTK_CHECK_BUTTON( gtk_check_button_new() );
-       gtk_widget_show( GTK_WIDGET( check ) );
+       m_check( ui::null ){
+       auto check = ui::CheckButton(ui::New);
+       check.show();
 
        m_check = check;
 
-       guint handler = g_signal_connect( G_OBJECT( check ), "toggled", G_CALLBACK( toggled ), this );
+       guint handler = check.connect( "toggled", G_CALLBACK( toggled ), this );
        g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( handler ) );
 
        update();
 }
 ui::Widget getWidget() const {
-       return ui::Widget(GTK_WIDGET( m_check ));
+       return m_check;
 }
 void release(){
        delete this;
 }
 void apply(){
-       Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( m_check ) ) ? "1" : "0" );
+       Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), m_check.active() ? "1" : "0" );
 }
 typedef MemberCaller<BooleanAttribute, &BooleanAttribute::apply> ApplyCaller;
 
 void update(){
        const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
        if ( !string_empty( value ) ) {
-               toggle_button_set_active_no_signal( ui::ToggleButton(GTK_TOGGLE_BUTTON( m_check )), atoi( value ) != 0 );
+               toggle_button_set_active_no_signal( m_check, atoi( value ) != 0 );
        }
        else
        {
-               toggle_button_set_active_no_signal( ui::ToggleButton(GTK_TOGGLE_BUTTON( m_check )), false );
+               toggle_button_set_active_no_signal( m_check, false );
        }
 }
 typedef MemberCaller<BooleanAttribute, &BooleanAttribute::update> UpdateCaller;
@@ -160,24 +161,24 @@ typedef MemberCaller<BooleanAttribute, &BooleanAttribute::update> UpdateCaller;
 class StringAttribute : public EntityAttribute
 {
 CopiedString m_key;
-GtkEntry* m_entry;
+ui::Entry m_entry;
 NonModalEntry m_nonModal;
 public:
 StringAttribute( const char* key ) :
        m_key( key ),
-       m_entry( 0 ),
+       m_entry( ui::null ),
        m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
-       GtkEntry* entry = ui::Entry();
-       gtk_widget_show( GTK_WIDGET( entry ) );
-       gtk_widget_set_size_request( GTK_WIDGET( entry ), 50, -1 );
+       auto entry = ui::Entry(ui::New);
+       entry.show();
+       entry.dimensions(50, -1);
 
        m_entry = entry;
        m_nonModal.connect( m_entry );
 }
 ui::Widget getWidget() const {
-       return ui::Widget(GTK_WIDGET( m_entry ));
+       return m_entry;
 }
-GtkEntry* getEntry() const {
+ui::Entry getEntry() const {
        return m_entry;
 }
 
@@ -186,7 +187,7 @@ void release(){
 }
 void apply(){
        StringOutputStream value( 64 );
-       value << gtk_entry_get_text( m_entry );
+       value << m_entry.text();
        Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 }
 typedef MemberCaller<StringAttribute, &StringAttribute::apply> ApplyCaller;
@@ -194,7 +195,7 @@ typedef MemberCaller<StringAttribute, &StringAttribute::apply> ApplyCaller;
 void update(){
        StringOutputStream value( 64 );
        value << SelectedEntity_getValueForKey( m_key.c_str() );
-       gtk_entry_set_text( m_entry, value.c_str() );
+       m_entry.text(value.c_str());
 }
 typedef MemberCaller<StringAttribute, &StringAttribute::update> UpdateCaller;
 };
@@ -224,18 +225,18 @@ void release(){
        delete this;
 }
 ui::Widget getWidget() const {
-       return ui::Widget(GTK_WIDGET( m_entry.m_entry.m_frame ));
+       return m_entry.m_entry.m_frame;
 }
 void apply(){
        StringOutputStream value( 64 );
-       value << gtk_entry_get_text( GTK_ENTRY( m_entry.m_entry.m_entry ) );
+       value << m_entry.m_entry.m_entry.text();
        Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 }
 typedef MemberCaller<ModelAttribute, &ModelAttribute::apply> ApplyCaller;
 void update(){
        StringOutputStream value( 64 );
        value << SelectedEntity_getValueForKey( m_key.c_str() );
-       gtk_entry_set_text( GTK_ENTRY( m_entry.m_entry.m_entry ), value.c_str() );
+       m_entry.m_entry.m_entry.text(value.c_str());
 }
 typedef MemberCaller<ModelAttribute, &ModelAttribute::update> UpdateCaller;
 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
@@ -291,14 +292,14 @@ ui::Widget getWidget() const {
 }
 void apply(){
        StringOutputStream value( 64 );
-       value << gtk_entry_get_text( GTK_ENTRY( m_entry.m_entry.m_entry ) );
+       value << m_entry.m_entry.m_entry.text();
        Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 }
 typedef MemberCaller<SoundAttribute, &SoundAttribute::apply> ApplyCaller;
 void update(){
        StringOutputStream value( 64 );
        value << SelectedEntity_getValueForKey( m_key.c_str() );
-       gtk_entry_set_text( GTK_ENTRY( m_entry.m_entry.m_entry ), value.c_str() );
+       m_entry.m_entry.m_entry.text(value.c_str());
 }
 typedef MemberCaller<SoundAttribute, &SoundAttribute::update> UpdateCaller;
 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
@@ -319,14 +320,14 @@ inline double angle_normalised( double angle ){
 class AngleAttribute : public EntityAttribute
 {
 CopiedString m_key;
-GtkEntry* m_entry;
+ui::Entry m_entry;
 NonModalEntry m_nonModal;
 public:
 AngleAttribute( const char* key ) :
        m_key( key ),
-       m_entry( 0 ),
+       m_entry( ui::null ),
        m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
-       GtkEntry* entry = numeric_entry_new();
+       auto entry = numeric_entry_new();
        m_entry = entry;
        m_nonModal.connect( m_entry );
 }
@@ -348,11 +349,11 @@ void update(){
        if ( !string_empty( value ) ) {
                StringOutputStream angle( 32 );
                angle << angle_normalised( atof( value ) );
-               gtk_entry_set_text( m_entry, angle.c_str() );
+               m_entry.text(angle.c_str());
        }
        else
        {
-               gtk_entry_set_text( m_entry, "0" );
+               m_entry.text("0");
        }
 }
 typedef MemberCaller<AngleAttribute, &AngleAttribute::update> UpdateCaller;
@@ -367,26 +368,26 @@ const String buttons[] = { "up", "down", "z-axis" };
 class DirectionAttribute : public EntityAttribute
 {
 CopiedString m_key;
-GtkEntry* m_entry;
+ui::Entry m_entry;
 NonModalEntry m_nonModal;
 RadioHBox m_radio;
 NonModalRadio m_nonModalRadio;
-GtkHBox* m_hbox;
+ui::HBox m_hbox{ui::null};
 public:
 DirectionAttribute( const char* key ) :
        m_key( key ),
-       m_entry( 0 ),
+       m_entry( ui::null ),
        m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ),
        m_radio( RadioHBox_new( STRING_ARRAY_RANGE( buttons ) ) ),
        m_nonModalRadio( ApplyRadioCaller( *this ) ){
-       GtkEntry* entry = numeric_entry_new();
+       auto entry = numeric_entry_new();
        m_entry = entry;
        m_nonModal.connect( m_entry );
 
        m_nonModalRadio.connect( m_radio.m_radio );
 
        m_hbox = ui::HBox( FALSE, 4 );
-       gtk_widget_show( GTK_WIDGET( m_hbox ) );
+       m_hbox.show();
 
        gtk_box_pack_start( GTK_BOX( m_hbox ), GTK_WIDGET( m_radio.m_hbox ), TRUE, TRUE, 0 );
        gtk_box_pack_start( GTK_BOX( m_hbox ), GTK_WIDGET( m_entry ), TRUE, TRUE, 0 );
@@ -411,12 +412,12 @@ void update(){
                if ( f == -1 ) {
                        gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), FALSE );
                        radio_button_set_active_no_signal( m_radio.m_radio, 0 );
-                       gtk_entry_set_text( m_entry, "" );
+                       m_entry.text("");
                }
                else if ( f == -2 ) {
                        gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), FALSE );
                        radio_button_set_active_no_signal( m_radio.m_radio, 1 );
-                       gtk_entry_set_text( m_entry, "" );
+                       m_entry.text("");
                }
                else
                {
@@ -424,12 +425,12 @@ void update(){
                        radio_button_set_active_no_signal( m_radio.m_radio, 2 );
                        StringOutputStream angle( 32 );
                        angle << angle_normalised( f );
-                       gtk_entry_set_text( m_entry, angle.c_str() );
+                       m_entry.text(angle.c_str());
                }
        }
        else
        {
-               gtk_entry_set_text( m_entry, "0" );
+               m_entry.text("0");
        }
 }
 typedef MemberCaller<DirectionAttribute, &DirectionAttribute::update> UpdateCaller;
@@ -453,10 +454,10 @@ typedef MemberCaller<DirectionAttribute, &DirectionAttribute::applyRadio> ApplyR
 class AnglesEntry
 {
 public:
-GtkEntry* m_roll;
-GtkEntry* m_pitch;
-GtkEntry* m_yaw;
-AnglesEntry() : m_roll( 0 ), m_pitch( 0 ), m_yaw( 0 ){
+ui::Entry m_roll;
+ui::Entry m_pitch;
+ui::Entry m_yaw;
+AnglesEntry() : m_roll( ui::null ), m_pitch( ui::null ), m_yaw( ui::null ){
 }
 };
 
@@ -474,21 +475,21 @@ AnglesAttribute( const char* key ) :
        m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ),
        m_hbox(ui::HBox( TRUE, 4 ))
 {
-       gtk_widget_show( GTK_WIDGET( m_hbox ) );
+       m_hbox.show();
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_angles.m_pitch = entry;
                m_nonModal.connect( m_angles.m_pitch );
        }
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_angles.m_yaw = entry;
                m_nonModal.connect( m_angles.m_yaw );
        }
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_angles.m_roll = entry;
                m_nonModal.connect( m_angles.m_roll );
@@ -519,22 +520,22 @@ void update(){
                }
 
                angle << angle_normalised( pitch_yaw_roll.x() );
-               gtk_entry_set_text( m_angles.m_pitch, angle.c_str() );
+               m_angles.m_pitch.text(angle.c_str());
                angle.clear();
 
                angle << angle_normalised( pitch_yaw_roll.y() );
-               gtk_entry_set_text( m_angles.m_yaw, angle.c_str() );
+               m_angles.m_yaw.text(angle.c_str());
                angle.clear();
 
                angle << angle_normalised( pitch_yaw_roll.z() );
-               gtk_entry_set_text( m_angles.m_roll, angle.c_str() );
+               m_angles.m_roll.text(angle.c_str());
                angle.clear();
        }
        else
        {
-               gtk_entry_set_text( m_angles.m_pitch, "0" );
-               gtk_entry_set_text( m_angles.m_yaw, "0" );
-               gtk_entry_set_text( m_angles.m_roll, "0" );
+               m_angles.m_pitch.text("0");
+               m_angles.m_yaw.text("0");
+               m_angles.m_roll.text("0");
        }
 }
 typedef MemberCaller<AnglesAttribute, &AnglesAttribute::update> UpdateCaller;
@@ -543,10 +544,10 @@ typedef MemberCaller<AnglesAttribute, &AnglesAttribute::update> UpdateCaller;
 class Vector3Entry
 {
 public:
-GtkEntry* m_x;
-GtkEntry* m_y;
-GtkEntry* m_z;
-Vector3Entry() : m_x( 0 ), m_y( 0 ), m_z( 0 ){
+ui::Entry m_x;
+ui::Entry m_y;
+ui::Entry m_z;
+Vector3Entry() : m_x( ui::null ), m_y( ui::null ), m_z( ui::null ){
 }
 };
 
@@ -555,27 +556,27 @@ class Vector3Attribute : public EntityAttribute
 CopiedString m_key;
 Vector3Entry m_vector3;
 NonModalEntry m_nonModal;
-GtkBox* m_hbox;
+ui::Box m_hbox{ui::null};
 public:
 Vector3Attribute( const char* key ) :
        m_key( key ),
        m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
        m_hbox = ui::HBox( TRUE, 4 );
-       gtk_widget_show( GTK_WIDGET( m_hbox ) );
+       m_hbox.show();
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_vector3.m_x = entry;
                m_nonModal.connect( m_vector3.m_x );
        }
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_vector3.m_y = entry;
                m_nonModal.connect( m_vector3.m_y );
        }
        {
-               GtkEntry* entry = numeric_entry_new();
+               auto entry = numeric_entry_new();
                gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
                m_vector3.m_z = entry;
                m_nonModal.connect( m_vector3.m_z );
@@ -606,22 +607,22 @@ void update(){
                }
 
                buffer << x_y_z.x();
-               gtk_entry_set_text( m_vector3.m_x, buffer.c_str() );
+               m_vector3.m_x.text(buffer.c_str());
                buffer.clear();
 
                buffer << x_y_z.y();
-               gtk_entry_set_text( m_vector3.m_y, buffer.c_str() );
+               m_vector3.m_y.text(buffer.c_str());
                buffer.clear();
 
                buffer << x_y_z.z();
-               gtk_entry_set_text( m_vector3.m_z, buffer.c_str() );
+               m_vector3.m_z.text(buffer.c_str());
                buffer.clear();
        }
        else
        {
-               gtk_entry_set_text( m_vector3.m_x, "0" );
-               gtk_entry_set_text( m_vector3.m_y, "0" );
-               gtk_entry_set_text( m_vector3.m_z, "0" );
+               m_vector3.m_x.text("0");
+               m_vector3.m_y.text("0");
+               m_vector3.m_z.text("0");
        }
 }
 typedef MemberCaller<Vector3Attribute, &Vector3Attribute::update> UpdateCaller;
@@ -640,10 +641,10 @@ static gboolean changed( GtkComboBox *widget, NonModalComboBox* self ){
 public:
 NonModalComboBox( const Callback& changed ) : m_changed( changed ), m_changedHandler( 0 ){
 }
-void connect( GtkComboBox* combo ){
-       m_changedHandler = g_signal_connect( G_OBJECT( combo ), "changed", G_CALLBACK( changed ), this );
+void connect( ui::ComboBox combo ){
+       m_changedHandler = combo.connect( "changed", G_CALLBACK( changed ), this );
 }
-void setActive( GtkComboBox* combo, int value ){
+void setActive( ui::ComboBox combo, int value ){
        g_signal_handler_disconnect( G_OBJECT( combo ), m_changedHandler );
        gtk_combo_box_set_active( combo, value );
        connect( combo );
@@ -653,7 +654,7 @@ void setActive( GtkComboBox* combo, int value ){
 class ListAttribute : public EntityAttribute
 {
 CopiedString m_key;
-GtkComboBox* m_combo;
+ui::ComboBox m_combo;
 NonModalComboBox m_nonModal;
 const ListAttributeType& m_type;
 public:
@@ -662,14 +663,14 @@ ListAttribute( const char* key, const ListAttributeType& type ) :
        m_combo( 0 ),
        m_nonModal( ApplyCaller( *this ) ),
        m_type( type ){
-       auto combo = ui::ComboBoxText();
+       auto combo = ui::ComboBoxText(ui::New);
 
        for ( ListAttributeType::const_iterator i = type.begin(); i != type.end(); ++i )
        {
                gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT( combo ), ( *i ).first.c_str() );
        }
 
-       gtk_widget_show( GTK_WIDGET( combo ) );
+       combo.show();
        m_nonModal.connect( combo );
 
        m_combo = combo;
@@ -702,23 +703,23 @@ typedef MemberCaller<ListAttribute, &ListAttribute::update> UpdateCaller;
 
 namespace
 {
-ui::Widget g_entity_split1;
-ui::Widget g_entity_split2;
+ui::Widget g_entity_split1{ui::null};
+ui::Widget g_entity_split2{ui::null};
 int g_entitysplit1_position;
 int g_entitysplit2_position;
 
 bool g_entityInspector_windowConstructed = false;
 
 GtkTreeView* g_entityClassList;
-GtkTextView* g_entityClassComment;
+ui::TextView g_entityClassComment{ui::null};
 
 GtkCheckButton* g_entitySpawnflagsCheck[MAX_FLAGS];
 
-GtkEntry* g_entityKeyEntry;
-GtkEntry* g_entityValueEntry;
+ui::Entry g_entityKeyEntry{ui::null};
+ui::Entry g_entityValueEntry{ui::null};
 
-ui::ListStore g_entlist_store{nullptr};
-ui::ListStore g_entprops_store{nullptr};
+ui::ListStore g_entlist_store{ui::null};
+ui::ListStore g_entprops_store{ui::null};
 const EntityClass* g_current_flags = 0;
 const EntityClass* g_current_comment = 0;
 const EntityClass* g_current_attributes = 0;
@@ -731,7 +732,7 @@ int spawn_table[MAX_FLAGS];
 // the table is a 4x4 in which we need to put the comment box g_entityClassComment and the spawn flags..
 GtkTable* g_spawnflagsTable;
 
-GtkVBox* g_attributeBox = 0;
+ui::VBox g_attributeBox{ui::null};
 typedef std::vector<EntityAttribute*> EntityAttributes;
 EntityAttributes g_entityAttributes;
 }
@@ -809,9 +810,7 @@ public:
 EntityClassListStoreAppend( ui::ListStore store_ ) : store( store_ ){
 }
 void visit( EntityClass* e ){
-       GtkTreeIter iter;
-       gtk_list_store_append( store, &iter );
-       gtk_list_store_set( store, &iter, 0, e->name(), 1, e, -1 );
+       store.append(0, e->name(), 1, e);
 }
 };
 
@@ -821,7 +820,7 @@ void EntityClassList_fill(){
 }
 
 void EntityClassList_clear(){
-       gtk_list_store_clear( g_entlist_store );
+       g_entlist_store.clear();
 }
 
 void SetComment( EntityClass* eclass ){
@@ -831,8 +830,7 @@ void SetComment( EntityClass* eclass ){
 
        g_current_comment = eclass;
 
-       GtkTextBuffer* buffer = gtk_text_view_get_buffer( g_entityClassComment );
-       gtk_text_buffer_set_text( buffer, eclass->comments(), -1 );
+       g_entityClassComment.text(eclass->comments());
 }
 
 void SurfaceFlags_setEntityClass( EntityClass* eclass ){
@@ -860,11 +858,12 @@ void SurfaceFlags_setEntityClass( EntityClass* eclass ){
        {
                for ( int i = 0; i < g_spawnflag_count; ++i )
                {
-                       ui::Widget widget = ui::Widget(GTK_WIDGET( g_entitySpawnflagsCheck[i] ));
-                       gtk_label_set_text( GTK_LABEL( gtk_bin_get_child(GTK_BIN(widget)) ), " " );
-                       gtk_widget_hide( widget );
+                       auto widget = ui::Widget(GTK_WIDGET(g_entitySpawnflagsCheck[i]));
+                       auto label = ui::Label(GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget))));
+                       label.text(" ");
+                       widget.hide();
                        g_object_ref( widget );
-                       gtk_container_remove( GTK_CONTAINER( g_spawnflagsTable ), widget );
+                       ui::Container(GTK_CONTAINER(g_spawnflagsTable)).remove(widget);
                }
        }
 
@@ -874,7 +873,7 @@ void SurfaceFlags_setEntityClass( EntityClass* eclass ){
                for ( int i = 0; i < g_spawnflag_count; ++i )
                {
                        ui::Widget widget = ui::Widget(GTK_WIDGET( g_entitySpawnflagsCheck[i] ));
-                       gtk_widget_show( widget );
+                       widget.show();
 
                        StringOutputStream str( 16 );
                        str << LowerCase( eclass->flagnames[spawn_table[i]] );
@@ -882,9 +881,10 @@ void SurfaceFlags_setEntityClass( EntityClass* eclass ){
                        gtk_table_attach( g_spawnflagsTable, widget, i % 4, i % 4 + 1, i / 4, i / 4 + 1,
                                                          (GtkAttachOptions)( GTK_FILL ),
                                                          (GtkAttachOptions)( GTK_FILL ), 0, 0 );
-                       g_object_unref( widget );
+                       widget.unref();
 
-                       gtk_label_set_text( GTK_LABEL( gtk_bin_get_child(GTK_BIN(widget)) ), str.c_str() );
+                       auto label = ui::Label(GTK_LABEL(gtk_bin_get_child(GTK_BIN(widget)) ));
+                       label.text(str.c_str());
                }
        }
 }
@@ -968,7 +968,7 @@ void EntityInspector_setEntityClass( EntityClass *eclass ){
        if ( eclass != g_current_attributes ) {
                g_current_attributes = eclass;
 
-               container_remove_all( GTK_CONTAINER( g_attributeBox ) );
+               container_remove_all( g_attributeBox );
                GlobalEntityAttributes_clear();
 
                for ( EntityClassAttributes::const_iterator i = eclass->m_attributes.begin(); i != eclass->m_attributes.end(); ++i )
@@ -1038,24 +1038,22 @@ void EntityInspector_updateKeyValues(){
 
        // save current key/val pair around filling epair box
        // row_select wipes it and sets to first in list
-       CopiedString strKey( gtk_entry_get_text( g_entityKeyEntry ) );
-       CopiedString strVal( gtk_entry_get_text( g_entityValueEntry ) );
+       CopiedString strKey( g_entityKeyEntry.text() );
+       CopiedString strVal( g_entityValueEntry.text() );
 
-       gtk_list_store_clear( store );
+       store.clear();
        // Walk through list and add pairs
        for ( KeyValues::iterator i = g_selectedKeyValues.begin(); i != g_selectedKeyValues.end(); ++i )
        {
-               GtkTreeIter iter;
-               gtk_list_store_append( store, &iter );
                StringOutputStream key( 64 );
                key << ( *i ).first.c_str();
                StringOutputStream value( 64 );
                value << ( *i ).second.c_str();
-               gtk_list_store_set( store, &iter, 0, key.c_str(), 1, value.c_str(), -1 );
+               store.append(0, key.c_str(), 1, value.c_str());
        }
 
-       gtk_entry_set_text( g_entityKeyEntry, strKey.c_str() );
-       gtk_entry_set_text( g_entityValueEntry, strVal.c_str() );
+       g_entityKeyEntry.text( strKey.c_str() );
+       g_entityValueEntry.text( strVal.c_str() );
 
        for ( EntityAttributes::const_iterator i = g_entityAttributes.begin(); i != g_entityAttributes.end(); ++i )
        {
@@ -1195,7 +1193,7 @@ static gint EntityClassList_button_press( ui::Widget widget, GdkEventButton *eve
 static gint EntityClassList_keypress( ui::Widget widget, GdkEventKey* event, gpointer data ){
        unsigned int code = gdk_keyval_to_upper( event->keyval );
 
-       if ( event->keyval == GDK_Return ) {
+       if ( event->keyval == GDK_KEY_Return ) {
                EntityClassList_createEntity();
                return TRUE;
        }
@@ -1249,8 +1247,8 @@ static void EntityProperties_selection_changed( GtkTreeSelection* selection, gpo
        char* val;
        gtk_tree_model_get( model, &iter, 0, &key, 1, &val, -1 );
 
-       gtk_entry_set_text( g_entityKeyEntry, key );
-       gtk_entry_set_text( g_entityValueEntry, val );
+       g_entityKeyEntry.text( key );
+       g_entityValueEntry.text( val );
 
        g_free( key );
        g_free( val );
@@ -1261,9 +1259,9 @@ static void SpawnflagCheck_toggled( ui::Widget widget, gpointer data ){
 }
 
 static gint EntityEntry_keypress( GtkEntry* widget, GdkEventKey* event, gpointer data ){
-       if ( event->keyval == GDK_Return ) {
+       if ( event->keyval == GDK_KEY_Return ) {
                if ( widget == g_entityKeyEntry ) {
-                       gtk_entry_set_text( g_entityValueEntry, "" );
+                       g_entityValueEntry.text( "" );
                        gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityValueEntry ) );
                }
                else
@@ -1272,7 +1270,7 @@ static gint EntityEntry_keypress( GtkEntry* widget, GdkEventKey* event, gpointer
                }
                return TRUE;
        }
-       if ( event->keyval == GDK_Escape ) {
+       if ( event->keyval == GDK_KEY_Escape ) {
                gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), NULL );
                return TRUE;
        }
@@ -1290,29 +1288,29 @@ void EntityInspector_destroyWindow( ui::Widget widget, gpointer data ){
 
 ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
        ui::Widget vbox = ui::VBox( FALSE, 2 );
-       gtk_widget_show( vbox );
+       vbox.show();
        gtk_container_set_border_width( GTK_CONTAINER( vbox ), 2 );
 
-       g_signal_connect( G_OBJECT( vbox ), "destroy", G_CALLBACK( EntityInspector_destroyWindow ), 0 );
+       vbox.connect( "destroy", G_CALLBACK( EntityInspector_destroyWindow ), 0 );
 
        {
-               ui::Widget split1 = ui::VPaned();
+               ui::Widget split1 = ui::VPaned(ui::New);
                gtk_box_pack_start( GTK_BOX( vbox ), split1, TRUE, TRUE, 0 );
-               gtk_widget_show( split1 );
+               split1.show();
 
                g_entity_split1 = split1;
 
                {
-                       ui::Widget split2 = ui::VPaned();
+                       ui::Widget split2 = ui::VPaned(ui::New);
                        gtk_paned_add1( GTK_PANED( split1 ), split2 );
-                       gtk_widget_show( split2 );
+                       split2.show();
 
                        g_entity_split2 = split2;
 
                        {
                                // class list
-                               ui::Widget scr = ui::ScrolledWindow();
-                               gtk_widget_show( scr );
+                               auto scr = ui::ScrolledWindow(ui::New);
+                               scr.show();
                                gtk_paned_add1( GTK_PANED( split2 ), scr );
                                gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
                                gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
@@ -1320,83 +1318,83 @@ ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
                                {
                                        ui::ListStore store = ui::ListStore(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
 
-                                       GtkTreeView* view = ui::TreeView( ui::TreeModel( GTK_TREE_MODEL( store ) ));
+                                       auto view = ui::TreeView( ui::TreeModel( GTK_TREE_MODEL( store ) ));
                                        gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), FALSE );
                                        gtk_tree_view_set_headers_visible( view, FALSE );
-                                       g_signal_connect( G_OBJECT( view ), "button_press_event", G_CALLBACK( EntityClassList_button_press ), 0 );
-                                       g_signal_connect( G_OBJECT( view ), "key_press_event", G_CALLBACK( EntityClassList_keypress ), 0 );
+                                       view.connect( "button_press_event", G_CALLBACK( EntityClassList_button_press ), 0 );
+                                       view.connect( "key_press_event", G_CALLBACK( EntityClassList_keypress ), 0 );
 
                                        {
-                                               auto renderer = ui::CellRendererText();
+                                               auto renderer = ui::CellRendererText(ui::New);
                                                GtkTreeViewColumn* column = ui::TreeViewColumn( "Key", renderer, {{"text", 0}} );
                                                gtk_tree_view_append_column( view, column );
                                        }
 
                                        {
-                                               GtkTreeSelection* selection = gtk_tree_view_get_selection( view );
-                                               g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( EntityClassList_selection_changed ), 0 );
+                                               auto selection = ui::TreeSelection(gtk_tree_view_get_selection( view ));
+                                               selection.connect( "changed", G_CALLBACK( EntityClassList_selection_changed ), 0 );
                                        }
 
-                                       gtk_widget_show( GTK_WIDGET( view ) );
+                                       view.show();
 
-                                       gtk_container_add( GTK_CONTAINER( scr ), GTK_WIDGET( view ) );
+                                       scr.add(view);
 
-                                       g_object_unref( G_OBJECT( store ) );
+                                       store.unref();
                                        g_entityClassList = view;
                                        g_entlist_store = store;
                                }
                        }
 
                        {
-                               ui::Widget scr = ui::ScrolledWindow();
-                               gtk_widget_show( scr );
+                               auto scr = ui::ScrolledWindow(ui::New);
+                               scr.show();
                                gtk_paned_add2( GTK_PANED( split2 ), scr );
                                gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
                                gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
 
                                {
-                                       GtkTextView* text = ui::TextView();
+                                       auto text = ui::TextView(ui::New);
                                        gtk_widget_set_size_request( GTK_WIDGET( text ), 0, -1 ); // allow shrinking
                                        gtk_text_view_set_wrap_mode( text, GTK_WRAP_WORD );
                                        gtk_text_view_set_editable( text, FALSE );
-                                       gtk_widget_show( GTK_WIDGET( text ) );
-                                       gtk_container_add( GTK_CONTAINER( scr ), GTK_WIDGET( text ) );
+                                       text.show();
+                                       scr.add(text);
                                        g_entityClassComment = text;
                                }
                        }
                }
 
                {
-                       ui::Widget split2 = ui::VPaned();
+                       ui::Widget split2 = ui::VPaned(ui::New);
                        gtk_paned_add2( GTK_PANED( split1 ), split2 );
-                       gtk_widget_show( split2 );
+                       split2.show();
 
                        {
                                ui::Widget vbox2 = ui::VBox( FALSE, 2 );
-                               gtk_widget_show( vbox2 );
+                               vbox2.show();
                                gtk_paned_pack1( GTK_PANED( split2 ), vbox2, FALSE, FALSE );
 
                                {
                                        // Spawnflags (4 colums wide max, or window gets too wide.)
-                                       GtkTable* table = ui::Table( 4, 4, FALSE );
+                                       auto table = ui::Table( 4, 4, FALSE );
                                        gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
-                                       gtk_widget_show( GTK_WIDGET( table ) );
+                                       table.show();
 
                                        g_spawnflagsTable = table;
 
                                        for ( int i = 0; i < MAX_FLAGS; i++ )
                                        {
-                                               GtkCheckButton* check = ui::CheckButton( "" );
+                                               auto check = ui::CheckButton( "" );
                                                g_object_ref( GTK_WIDGET( check ) );
-                                               g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( g_signal_connect( G_OBJECT( check ), "toggled", G_CALLBACK( SpawnflagCheck_toggled ), 0 ) ) );
+                                               g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( check.connect( "toggled", G_CALLBACK( SpawnflagCheck_toggled ), 0 ) ) );
                                                g_entitySpawnflagsCheck[i] = check;
                                        }
                                }
 
                                {
                                        // key/value list
-                                       ui::Widget scr = ui::ScrolledWindow();
-                                       gtk_widget_show( scr );
+                                       auto scr = ui::ScrolledWindow(ui::New);
+                                       scr.show();
                                        gtk_box_pack_start( GTK_BOX( vbox2 ), scr, TRUE, TRUE, 0 );
                                        gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
                                        gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
@@ -1409,27 +1407,27 @@ ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
                                                gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
 
                                                {
-                                                       auto renderer = ui::CellRendererText();
+                                                       auto renderer = ui::CellRendererText(ui::New);
                                                        GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", 0}} );
                                                        gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
                                                }
 
                                                {
-                                                       auto renderer = ui::CellRendererText();
+                                                       auto renderer = ui::CellRendererText(ui::New);
                                                        GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", 1}} );
                                                        gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
                                                }
 
                                                {
-                                                       GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
-                                                       g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( EntityProperties_selection_changed ), 0 );
+                                                       auto selection = ui::TreeSelection(gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) ));
+                                                       selection.connect( "changed", G_CALLBACK( EntityProperties_selection_changed ), 0 );
                                                }
 
-                                               gtk_widget_show( view );
+                                               view.show();
 
-                                               gtk_container_add( GTK_CONTAINER( scr ), view );
+                                               scr.add(view);
 
-                                               g_object_unref( G_OBJECT( store ) );
+                                               store.unref();
 
                                                g_entprops_store = store;
                                        }
@@ -1437,37 +1435,37 @@ ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
 
                                {
                                        // key/value entry
-                                       GtkTable* table = ui::Table( 2, 2, FALSE );
-                                       gtk_widget_show( GTK_WIDGET( table ) );
+                                       auto table = ui::Table( 2, 2, FALSE );
+                                       table.show();
                                        gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
                                        gtk_table_set_row_spacings( table, 3 );
                                        gtk_table_set_col_spacings( table, 5 );
 
                                        {
-                                               GtkEntry* entry = ui::Entry();
-                                               gtk_widget_show( GTK_WIDGET( entry ) );
+                                               auto entry = ui::Entry(ui::New);
+                                               entry.show();
                                                gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 0, 1,
                                                                                  (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                                                                                  (GtkAttachOptions)( 0 ), 0, 0 );
                                                gtk_widget_set_events( GTK_WIDGET( entry ), GDK_KEY_PRESS_MASK );
-                                               g_signal_connect( G_OBJECT( entry ), "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
+                                               entry.connect( "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
                                                g_entityKeyEntry = entry;
                                        }
 
                                        {
-                                               GtkEntry* entry = ui::Entry();
-                                               gtk_widget_show( GTK_WIDGET( entry ) );
+                                               auto entry = ui::Entry(ui::New);
+                                               entry.show();
                                                gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
                                                                                  (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                                                                                  (GtkAttachOptions)( 0 ), 0, 0 );
                                                gtk_widget_set_events( GTK_WIDGET( entry ), GDK_KEY_PRESS_MASK );
-                                               g_signal_connect( G_OBJECT( entry ), "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
+                                               entry.connect( "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
                                                g_entityValueEntry = entry;
                                        }
 
                                        {
-                                               GtkLabel* label = GTK_LABEL( ui::Label( "Value" ) );
-                                               gtk_widget_show( GTK_WIDGET( label ) );
+                                               auto label = ui::Label( "Value" );
+                                               label.show();
                                                gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 1, 2,
                                                                                  (GtkAttachOptions)( GTK_FILL ),
                                                                                  (GtkAttachOptions)( 0 ), 0, 0 );
@@ -1475,8 +1473,8 @@ ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
                                        }
 
                                        {
-                                               GtkLabel* label = GTK_LABEL( ui::Label( "Key" ) );
-                                               gtk_widget_show( GTK_WIDGET( label ) );
+                                               auto label = ui::Label( "Key" );
+                                               label.show();
                                                gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 0, 1,
                                                                                  (GtkAttachOptions)( GTK_FILL ),
                                                                                  (GtkAttachOptions)( 0 ), 0, 0 );
@@ -1485,39 +1483,39 @@ ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
                                }
 
                                {
-                                       GtkBox* hbox = ui::HBox( TRUE, 4 );
-                                       gtk_widget_show( GTK_WIDGET( hbox ) );
+                                       auto hbox = ui::HBox( TRUE, 4 );
+                                       hbox.show();
                                        gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( hbox ), FALSE, TRUE, 0 );
 
                                        {
-                                               GtkButton* button = ui::Button( "Clear All" );
-                                               gtk_widget_show( GTK_WIDGET( button ) );
-                                               g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( EntityInspector_clearAllKeyValues ), 0 );
+                                               auto button = ui::Button( "Clear All" );
+                                               button.show();
+                                               button.connect( "clicked", G_CALLBACK( EntityInspector_clearAllKeyValues ), 0 );
                                                gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
                                        }
                                        {
-                                               GtkButton* button = ui::Button( "Delete Key" );
-                                               gtk_widget_show( GTK_WIDGET( button ) );
-                                               g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( EntityInspector_clearKeyValue ), 0 );
+                                               auto button = ui::Button( "Delete Key" );
+                                               button.show();
+                                               button.connect( "clicked", G_CALLBACK( EntityInspector_clearKeyValue ), 0 );
                                                gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
                                        }
                                }
                        }
 
                        {
-                               ui::Widget scr = ui::ScrolledWindow();
-                               gtk_widget_show( scr );
+                               auto scr = ui::ScrolledWindow(ui::New);
+                               scr.show();
                                gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
 
-                               ui::Widget viewport = ui::Widget(gtk_viewport_new( 0, 0 ));
-                               gtk_widget_show( viewport );
+                               auto viewport = ui::Container(GTK_CONTAINER(gtk_viewport_new( 0, 0 )));
+                               viewport.show();
                                gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport ), GTK_SHADOW_NONE );
 
                                g_attributeBox = ui::VBox( FALSE, 2 );
-                               gtk_widget_show( GTK_WIDGET( g_attributeBox ) );
+                               g_attributeBox.show();
 
-                               gtk_container_add( GTK_CONTAINER( viewport ), GTK_WIDGET( g_attributeBox ) );
-                               gtk_container_add( GTK_CONTAINER( scr ), viewport );
+                               viewport.add(g_attributeBox);
+                               scr.add(viewport);
                                gtk_paned_pack2( GTK_PANED( split2 ), scr, FALSE, FALSE );
                        }
                }