#include "entityinspector.h"
#include "debugging/debugging.h"
+#include <gtk/gtk.h>
#include "ientity.h"
#include "ifilesystem.h"
#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;
}
class EntityAttribute
{
public:
+virtual ~EntityAttribute() = default;
virtual ui::Widget getWidget() const = 0;
virtual void update() = 0;
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();
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;
+typedef MemberCaller<BooleanAttribute, void(), &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;
+typedef MemberCaller<BooleanAttribute, void(), &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;
}
}
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;
+typedef MemberCaller<StringAttribute, void(), &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;
+typedef MemberCaller<StringAttribute, void(), &StringAttribute::update> UpdateCaller;
};
class ShaderAttribute : public StringAttribute
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;
+typedef MemberCaller<ModelAttribute, void(), &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;
+typedef MemberCaller<ModelAttribute, void(), &ModelAttribute::update> UpdateCaller;
void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
- const char *filename = misc_model_dialog( ui::Widget(gtk_widget_get_toplevel( GTK_WIDGET( m_entry.m_entry.m_frame ) ) ));
+ const char *filename = misc_model_dialog( m_entry.m_entry.m_frame.window() );
if ( filename != 0 ) {
setPath( filename );
apply();
}
}
-typedef MemberCaller1<ModelAttribute, const BrowsedPathEntry::SetPathCallback&, &ModelAttribute::browse> BrowseCaller;
+typedef MemberCaller<ModelAttribute, void(const BrowsedPathEntry::SetPathCallback&), &ModelAttribute::browse> BrowseCaller;
};
const char* browse_sound( ui::Widget parent ){
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_entry.m_entry.m_frame ));
+ return ui::Widget(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<SoundAttribute, &SoundAttribute::apply> ApplyCaller;
+typedef MemberCaller<SoundAttribute, void(), &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;
+typedef MemberCaller<SoundAttribute, void(), &SoundAttribute::update> UpdateCaller;
void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
- const char *filename = browse_sound( ui::Widget(gtk_widget_get_toplevel( GTK_WIDGET( m_entry.m_entry.m_frame ) )) );
+ const char *filename = browse_sound( m_entry.m_entry.m_frame.window() );
if ( filename != 0 ) {
setPath( filename );
apply();
}
}
-typedef MemberCaller1<SoundAttribute, const BrowsedPathEntry::SetPathCallback&, &SoundAttribute::browse> BrowseCaller;
+typedef MemberCaller<SoundAttribute, void(const BrowsedPathEntry::SetPathCallback&), &SoundAttribute::browse> BrowseCaller;
};
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 );
}
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_entry ));
+ return ui::Widget(m_entry );
}
void apply(){
StringOutputStream angle( 32 );
angle << angle_normalised( entry_get_float( m_entry ) );
Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
}
-typedef MemberCaller<AngleAttribute, &AngleAttribute::apply> ApplyCaller;
+typedef MemberCaller<AngleAttribute, void(), &AngleAttribute::apply> ApplyCaller;
void update(){
const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
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;
+typedef MemberCaller<AngleAttribute, void(), &AngleAttribute::update> UpdateCaller;
};
namespace
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 );
+ m_hbox.pack_start( m_radio.m_hbox, TRUE, TRUE, 0 );
+ m_hbox.pack_start( m_entry, TRUE, TRUE, 0 );
}
void release(){
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_hbox ));
+ return ui::Widget(m_hbox );
}
void apply(){
StringOutputStream angle( 32 );
angle << angle_normalised( entry_get_float( m_entry ) );
Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
}
-typedef MemberCaller<DirectionAttribute, &DirectionAttribute::apply> ApplyCaller;
+typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::apply> ApplyCaller;
void update(){
const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
if ( !string_empty( value ) ) {
float f = float(atof( value ) );
if ( f == -1 ) {
- gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), FALSE );
+ gtk_widget_set_sensitive( 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 );
+ gtk_widget_set_sensitive( m_entry , FALSE );
radio_button_set_active_no_signal( m_radio.m_radio, 1 );
- gtk_entry_set_text( m_entry, "" );
+ m_entry.text("");
}
else
{
- gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), TRUE );
+ gtk_widget_set_sensitive( m_entry , TRUE );
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;
+typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::update> UpdateCaller;
void applyRadio(){
int index = radio_button_get_active( m_radio.m_radio );
apply();
}
}
-typedef MemberCaller<DirectionAttribute, &DirectionAttribute::applyRadio> ApplyRadioCaller;
+typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::applyRadio> ApplyRadioCaller;
};
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 ){
}
};
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();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_angles.m_pitch = entry;
m_nonModal.connect( m_angles.m_pitch );
}
{
- GtkEntry* entry = numeric_entry_new();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_angles.m_yaw = entry;
m_nonModal.connect( m_angles.m_yaw );
}
{
- GtkEntry* entry = numeric_entry_new();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_angles.m_roll = entry;
m_nonModal.connect( m_angles.m_roll );
}
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_hbox ));
+ return ui::Widget(m_hbox );
}
void apply(){
StringOutputStream angles( 64 );
<< " " << angle_normalised( entry_get_float( m_angles.m_roll ) );
Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angles.c_str() );
}
-typedef MemberCaller<AnglesAttribute, &AnglesAttribute::apply> ApplyCaller;
+typedef MemberCaller<AnglesAttribute, void(), &AnglesAttribute::apply> ApplyCaller;
void update(){
StringOutputStream angle( 32 );
}
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;
+typedef MemberCaller<AnglesAttribute, void(), &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 ){
}
};
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();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_vector3.m_x = entry;
m_nonModal.connect( m_vector3.m_x );
}
{
- GtkEntry* entry = numeric_entry_new();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_vector3.m_y = entry;
m_nonModal.connect( m_vector3.m_y );
}
{
- GtkEntry* entry = numeric_entry_new();
- gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
+ auto entry = numeric_entry_new();
+ m_hbox.pack_start( entry, TRUE, TRUE, 0 );
m_vector3.m_z = entry;
m_nonModal.connect( m_vector3.m_z );
}
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_hbox ));
+ return ui::Widget(m_hbox );
}
void apply(){
StringOutputStream vector3( 64 );
<< " " << entry_get_float( m_vector3.m_z );
Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), vector3.c_str() );
}
-typedef MemberCaller<Vector3Attribute, &Vector3Attribute::apply> ApplyCaller;
+typedef MemberCaller<Vector3Attribute, void(), &Vector3Attribute::apply> ApplyCaller;
void update(){
StringOutputStream buffer( 32 );
}
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;
+typedef MemberCaller<Vector3Attribute, void(), &Vector3Attribute::update> UpdateCaller;
};
class NonModalComboBox
{
-Callback m_changed;
+Callback<void()> m_changed;
guint m_changedHandler;
-static gboolean changed( GtkComboBox *widget, NonModalComboBox* self ){
+static gboolean changed( ui::ComboBox widget, NonModalComboBox* self ){
self->m_changed();
return FALSE;
}
public:
-NonModalComboBox( const Callback& changed ) : m_changed( changed ), m_changedHandler( 0 ){
+NonModalComboBox( const Callback<void()>& 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 );
class ListAttribute : public EntityAttribute
{
CopiedString m_key;
-GtkComboBox* m_combo;
+ui::ComboBox m_combo;
NonModalComboBox m_nonModal;
const ListAttributeType& m_type;
public:
ListAttribute( const char* key, const ListAttributeType& type ) :
m_key( key ),
- m_combo( 0 ),
+ m_combo( ui::null ),
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;
delete this;
}
ui::Widget getWidget() const {
- return ui::Widget(GTK_WIDGET( m_combo ));
+ return ui::Widget(m_combo );
}
void apply(){
Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), m_type[gtk_combo_box_get_active( m_combo )].second.c_str() );
}
-typedef MemberCaller<ListAttribute, &ListAttribute::apply> ApplyCaller;
+typedef MemberCaller<ListAttribute, void(), &ListAttribute::apply> ApplyCaller;
void update(){
const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
m_nonModal.setActive( m_combo, 0 );
}
}
-typedef MemberCaller<ListAttribute, &ListAttribute::update> UpdateCaller;
+typedef MemberCaller<ListAttribute, void(), &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::TreeView g_entityClassList{ui::null};
+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;
int spawn_table[MAX_FLAGS];
// we change the layout depending on how many spawn flags we need to display
// the table is a 4x4 in which we need to put the comment box g_entityClassComment and the spawn flags..
-GtkTable* g_spawnflagsTable;
+ui::Table g_spawnflagsTable{ui::null};
-GtkVBox* g_attributeBox = 0;
+ui::VBox g_attributeBox{ui::null};
typedef std::vector<EntityAttribute*> EntityAttributes;
EntityAttributes g_entityAttributes;
}
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);
}
};
}
void EntityClassList_clear(){
- gtk_list_store_clear( g_entlist_store );
+ g_entlist_store.clear();
}
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 ){
g_current_flags = eclass;
- int spawnflag_count = 0;
+ unsigned int spawnflag_count = 0;
{
// do a first pass to count the spawn flags, don't touch the widgets, we don't know in what state they are
{
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 );
- g_object_ref( widget );
- gtk_container_remove( GTK_CONTAINER( g_spawnflagsTable ), widget );
+ auto widget = ui::CheckButton::from(g_entitySpawnflagsCheck[i]);
+ auto label = ui::Label::from(gtk_bin_get_child(GTK_BIN(widget)));
+ label.text(" ");
+ widget.hide();
+ widget.ref();
+ g_spawnflagsTable.remove(widget);
}
}
g_spawnflag_count = spawnflag_count;
{
- for ( int i = 0; i < g_spawnflag_count; ++i )
+ for (unsigned int i = 0; (int) i < g_spawnflag_count; ++i)
{
- ui::Widget widget = ui::Widget(GTK_WIDGET( g_entitySpawnflagsCheck[i] ));
- gtk_widget_show( widget );
+ auto widget = ui::CheckButton::from(g_entitySpawnflagsCheck[i] );
+ widget.show();
StringOutputStream str( 16 );
str << LowerCase( eclass->flagnames[spawn_table[i]] );
- 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 );
+ g_spawnflagsTable.attach(widget, {i % 4, i % 4 + 1, i / 4, i / 4 + 1}, {GTK_FILL, GTK_FILL});
+ widget.unref();
- gtk_label_set_text( GTK_LABEL( gtk_bin_get_child(GTK_BIN(widget)) ), str.c_str() );
+ auto label = ui::Label::from(gtk_bin_get_child(GTK_BIN(widget)) );
+ label.text(str.c_str());
}
}
}
void EntityClassList_selectEntityClass( EntityClass* eclass ){
- GtkTreeModel* model = GTK_TREE_MODEL( g_entlist_store );
+ auto model = g_entlist_store;
GtkTreeIter iter;
for ( gboolean good = gtk_tree_model_get_iter_first( model, &iter ); good != FALSE; good = gtk_tree_model_iter_next( model, &iter ) )
{
char* text;
gtk_tree_model_get( model, &iter, 0, &text, -1 );
if ( strcmp( text, eclass->name() ) == 0 ) {
- GtkTreeView* view = g_entityClassList;
- GtkTreePath* path = gtk_tree_model_get_path( model, &iter );
+ auto view = ui::TreeView(g_entityClassList);
+ auto path = gtk_tree_model_get_path( model, &iter );
gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
- if ( gtk_widget_get_realized( GTK_WIDGET(view) ) ) {
+ if ( gtk_widget_get_realized( view ) ) {
gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
}
gtk_tree_path_free( path );
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 )
{
int v = !!( f & ( 1 << spawn_table[i] ) );
- toggle_button_set_active_no_signal( ui::ToggleButton(GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] )), v );
+ toggle_button_set_active_no_signal( ui::ToggleButton::from( g_entitySpawnflagsCheck[i] ), v );
}
}
{
// take care of the remaining ones
for ( int i = g_spawnflag_count; i < MAX_FLAGS; ++i )
{
- toggle_button_set_active_no_signal( ui::ToggleButton(GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] )), FALSE );
+ toggle_button_set_active_no_signal( ui::ToggleButton::from( g_entitySpawnflagsCheck[i] ), FALSE );
}
}
}
// 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 )
{
{
IdleDraw m_idleDraw;
public:
-EntityInspectorDraw() : m_idleDraw( FreeCaller<EntityInspector_updateKeyValues>( ) ){
+EntityInspectorDraw() : m_idleDraw( makeCallbackF(EntityInspector_updateKeyValues) ){
}
void queueDraw(){
m_idleDraw.queueDraw();
// Creates a new entity based on the currently selected brush and entity type.
//
void EntityClassList_createEntity(){
- GtkTreeView* view = g_entityClassList;
+ auto view = g_entityClassList;
// find out what type of entity we are trying to create
GtkTreeModel* model;
GtkTreeIter iter;
- if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( view ), &model, &iter ) == FALSE ) {
- ui::Widget(gtk_widget_get_toplevel( GTK_WIDGET( g_entityClassList ) )).alert( "You must have a selected class to create an entity", "info" );
+ if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( g_entityClassList ), &model, &iter ) == FALSE ) {
+ ui::alert( view.window(), "You must have a selected class to create an entity", "info" );
return;
}
// TTimo: if you change the classname to worldspawn you won't merge back in the structural brushes but create a parasite entity
if ( !strcmp( key.c_str(), "classname" ) && !strcmp( value.c_str(), "worldspawn" ) ) {
- ui::Widget(gtk_widget_get_toplevel( GTK_WIDGET( g_entityKeyEntry )) ).alert( "Cannot change \"classname\" key back to worldspawn.", 0, ui::alert_type::OK );
+ ui::alert( g_entityKeyEntry.window(), "Cannot change \"classname\" key back to worldspawn.", 0, ui::alert_type::OK );
return;
}
// RR2DO2: we don't want spaces in entity keys
if ( strstr( key.c_str(), " " ) ) {
- ui::Widget(gtk_widget_get_toplevel( GTK_WIDGET( g_entityKeyEntry )) ).alert( "No spaces are allowed in entity keys.", 0, ui::alert_type::OK );
+ ui::alert( g_entityKeyEntry.window(), "No spaces are allowed in entity keys.", 0, ui::alert_type::OK );
return;
}
// =============================================================================
// callbacks
-static void EntityClassList_selection_changed( GtkTreeSelection* selection, gpointer data ){
+static void EntityClassList_selection_changed( ui::TreeSelection selection, gpointer data ){
GtkTreeModel* model;
GtkTreeIter selected;
if ( gtk_tree_selection_get_selected( selection, &model, &selected ) ) {
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;
}
// select the entity that starts with the key pressed
if ( code <= 'Z' && code >= 'A' ) {
- GtkTreeView* view = g_entityClassList;
+ auto view = ui::TreeView(g_entityClassList);
GtkTreeModel* model;
GtkTreeIter iter;
if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( view ), &model, &iter ) == FALSE
gtk_tree_model_get( model, &iter, 0, &text, -1 );
if ( toupper( text[0] ) == (int)code ) {
- GtkTreePath* path = gtk_tree_model_get_path( model, &iter );
+ auto path = gtk_tree_model_get_path( model, &iter );
gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
- if ( gtk_widget_get_realized( GTK_WIDGET(view) ) ) {
+ if ( gtk_widget_get_realized( view ) ) {
gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
}
gtk_tree_path_free( path );
return FALSE;
}
-static void EntityProperties_selection_changed( GtkTreeSelection* selection, gpointer data ){
+static void EntityProperties_selection_changed( ui::TreeSelection selection, gpointer data ){
// find out what type of entity we are trying to create
GtkTreeModel* model;
GtkTreeIter iter;
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 );
EntityInspector_applySpawnflags();
}
-static gint EntityEntry_keypress( GtkEntry* widget, GdkEventKey* event, gpointer data ){
- if ( event->keyval == GDK_Return ) {
- if ( widget == g_entityKeyEntry ) {
- gtk_entry_set_text( g_entityValueEntry, "" );
- gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityValueEntry ) );
+static gint EntityEntry_keypress( ui::Entry widget, GdkEventKey* event, gpointer data ){
+ if ( event->keyval == GDK_KEY_Return ) {
+ if ( widget._handle == g_entityKeyEntry._handle ) {
+ g_entityValueEntry.text( "" );
+ gtk_window_set_focus( widget.window(), g_entityValueEntry );
}
else
{
}
return TRUE;
}
- if ( event->keyval == GDK_Escape ) {
- gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), NULL );
+ if ( event->keyval == GDK_KEY_Escape ) {
+ gtk_window_set_focus( widget.window(), NULL );
return TRUE;
}
}
ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
- ui::Widget vbox = ui::VBox( FALSE, 2 );
- gtk_widget_show( vbox );
+ auto vbox = ui::VBox( FALSE, 2 );
+ 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();
- gtk_box_pack_start( GTK_BOX( vbox ), split1, TRUE, TRUE, 0 );
- gtk_widget_show( split1 );
+ auto split1 = ui::VPaned(ui::New);
+ vbox.pack_start( split1, TRUE, TRUE, 0 );
+ 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 );
{
- ui::ListStore store = ui::ListStore(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
+ ui::ListStore store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
- GtkTreeView* view = ui::TreeView( ui::TreeModel( GTK_TREE_MODEL( store ) ));
- gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), FALSE );
+ auto view = ui::TreeView( ui::TreeModel::from( store._handle ));
+ gtk_tree_view_set_enable_search(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();
- GtkTreeViewColumn* column = ui::TreeViewColumn( "Key", renderer, {{"text", 0}} );
+ auto renderer = ui::CellRendererText(ui::New);
+ auto 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::from(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();
- gtk_widget_set_size_request( GTK_WIDGET( text ), 0, -1 ); // allow shrinking
+ auto text = ui::TextView(ui::New);
+ text.dimensions(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 );
+ auto vbox2 = ui::VBox( FALSE, 2 );
+ 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 );
- gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
- gtk_widget_show( GTK_WIDGET( table ) );
+ auto table = ui::Table( 4, 4, FALSE );
+ vbox2.pack_start( table, FALSE, TRUE, 0 );
+ table.show();
g_spawnflagsTable = table;
for ( int i = 0; i < MAX_FLAGS; i++ )
{
- GtkCheckButton* 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 ) ) );
+ auto check = ui::CheckButton( "" );
+ check.ref();
+ 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 );
- gtk_box_pack_start( GTK_BOX( vbox2 ), scr, TRUE, TRUE, 0 );
+ auto scr = ui::ScrolledWindow(ui::New);
+ scr.show();
+ vbox2.pack_start( 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 );
{
- ui::ListStore store = ui::ListStore(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING ));
+ ui::ListStore store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING ));
- ui::Widget 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( GTK_TREE_VIEW( view ), FALSE );
+ auto view = ui::TreeView(ui::TreeModel::from(store._handle));
+ gtk_tree_view_set_enable_search(view, FALSE );
+ gtk_tree_view_set_headers_visible(view, FALSE );
{
- auto renderer = ui::CellRendererText();
- GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", 0}} );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto renderer = ui::CellRendererText(ui::New);
+ auto column = ui::TreeViewColumn( "", renderer, {{"text", 0}} );
+ gtk_tree_view_append_column(view, column );
}
{
- auto renderer = ui::CellRendererText();
- GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", 1}} );
- gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+ auto renderer = ui::CellRendererText(ui::New);
+ auto column = ui::TreeViewColumn( "", renderer, {{"text", 1}} );
+ gtk_tree_view_append_column(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::from(gtk_tree_view_get_selection(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;
}
{
// key/value entry
- GtkTable* table = ui::Table( 2, 2, FALSE );
- gtk_widget_show( GTK_WIDGET( table ) );
- gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
+ auto table = ui::Table( 2, 2, FALSE );
+ table.show();
+ vbox2.pack_start( 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 ) );
- 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 );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_widget_set_events( entry , GDK_KEY_PRESS_MASK );
+ entry.connect( "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
g_entityKeyEntry = entry;
}
{
- GtkEntry* entry = ui::Entry();
- gtk_widget_show( GTK_WIDGET( entry ) );
- 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 );
+ auto entry = ui::Entry(ui::New);
+ entry.show();
+ table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
+ gtk_widget_set_events( entry , GDK_KEY_PRESS_MASK );
+ 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 ) );
- gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 1, 2,
- (GtkAttachOptions)( GTK_FILL ),
- (GtkAttachOptions)( 0 ), 0, 0 );
+ auto label = ui::Label( "Value" );
+ label.show();
+ table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
{
- GtkLabel* label = GTK_LABEL( ui::Label( "Key" ) );
- gtk_widget_show( GTK_WIDGET( label ) );
- gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 0, 1,
- (GtkAttachOptions)( GTK_FILL ),
- (GtkAttachOptions)( 0 ), 0, 0 );
+ auto label = ui::Label( "Key" );
+ label.show();
+ table.attach(label, {0, 1, 0, 1}, {GTK_FILL, 0});
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
}
}
{
- GtkBox* hbox = ui::HBox( TRUE, 4 );
- gtk_widget_show( GTK_WIDGET( hbox ) );
- gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( hbox ), FALSE, TRUE, 0 );
+ auto hbox = ui::HBox( TRUE, 4 );
+ hbox.show();
+ vbox2.pack_start( 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 );
- gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
+ auto button = ui::Button( "Clear All" );
+ button.show();
+ button.connect( "clicked", G_CALLBACK( EntityInspector_clearAllKeyValues ), 0 );
+ hbox.pack_start( 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 );
- gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
+ auto button = ui::Button( "Delete Key" );
+ button.show();
+ button.connect( "clicked", G_CALLBACK( EntityInspector_clearKeyValue ), 0 );
+ hbox.pack_start( 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::from(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 );
}
}
g_entityInspector_windowConstructed = true;
EntityClassList_fill();
- typedef FreeCaller1<const Selectable&, EntityInspector_selectionChanged> EntityInspectorSelectionChangedCaller;
+ typedef FreeCaller<void(const Selectable&), EntityInspector_selectionChanged> EntityInspectorSelectionChangedCaller;
GlobalSelectionSystem().addSelectionChangeCallback( EntityInspectorSelectionChangedCaller() );
GlobalEntityCreator().setKeyValueChangedFunc( EntityInspector_keyValueChanged );
void EntityInspector_construct(){
GlobalEntityClassManager().attach( g_EntityInspector );
- GlobalPreferenceSystem().registerPreference( "EntitySplit1", IntImportStringCaller( g_entitysplit1_position ), IntExportStringCaller( g_entitysplit1_position ) );
- GlobalPreferenceSystem().registerPreference( "EntitySplit2", IntImportStringCaller( g_entitysplit2_position ), IntExportStringCaller( g_entitysplit2_position ) );
+ GlobalPreferenceSystem().registerPreference( "EntitySplit1", make_property_string( g_entitysplit1_position ) );
+ GlobalPreferenceSystem().registerPreference( "EntitySplit2", make_property_string( g_entitysplit2_position ) );
}