2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "entityinspector.h"
24 #include "debugging/debugging.h"
28 #include "ifilesystem.h"
30 #include "iscenegraph.h"
31 #include "iselection.h"
36 #include <gdk/gdkkeysyms.h>
37 #include <uilib/uilib.h>
41 #include "eclasslib.h"
43 #include "generic/callback.h"
45 #include "stream/stringstream.h"
46 #include "moduleobserver.h"
50 #include "gtkutil/accelerator.h"
51 #include "gtkutil/dialog.h"
52 #include "gtkutil/filechooser.h"
53 #include "gtkutil/messagebox.h"
54 #include "gtkutil/nonmodal.h"
55 #include "gtkutil/button.h"
56 #include "gtkutil/entry.h"
57 #include "gtkutil/container.h"
63 #include "mainframe.h"
64 #include "textureentry.h"
65 #include "groupdialog.h"
67 ui::Entry numeric_entry_new(){
68 auto entry = ui::Entry(ui::New);
70 entry.dimensions(64, -1);
76 typedef std::map<CopiedString, CopiedString> KeyValues;
77 KeyValues g_selectedKeyValues;
78 KeyValues g_selectedDefaultKeyValues;
81 const char* SelectedEntity_getValueForKey( const char* key ){
83 KeyValues::const_iterator i = g_selectedKeyValues.find( key );
84 if ( i != g_selectedKeyValues.end() ) {
85 return ( *i ).second.c_str();
89 KeyValues::const_iterator i = g_selectedDefaultKeyValues.find( key );
90 if ( i != g_selectedDefaultKeyValues.end() ) {
91 return ( *i ).second.c_str();
97 void Scene_EntitySetKeyValue_Selected_Undoable( const char* key, const char* value ){
98 StringOutputStream command( 256 );
99 command << "entitySetKeyValue -key " << makeQuoted( key ) << " -value " << makeQuoted( value );
100 UndoableCommand undo( command.c_str() );
101 Scene_EntitySetKeyValue_Selected( key, value );
104 class EntityAttribute
107 virtual ~EntityAttribute() = default;
108 virtual ui::Widget getWidget() const = 0;
109 virtual void update() = 0;
110 virtual void release() = 0;
113 class BooleanAttribute : public EntityAttribute
116 ui::CheckButton m_check;
118 static gboolean toggled( ui::Widget widget, BooleanAttribute* self ){
123 BooleanAttribute( const char* key ) :
126 auto check = ui::CheckButton(ui::New);
131 guint handler = check.connect( "toggled", G_CALLBACK( toggled ), this );
132 g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( handler ) );
136 ui::Widget getWidget() const {
143 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), m_check.active() ? "1" : "0" );
145 typedef MemberCaller<BooleanAttribute, void(), &BooleanAttribute::apply> ApplyCaller;
148 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
149 if ( !string_empty( value ) ) {
150 toggle_button_set_active_no_signal( m_check, atoi( value ) != 0 );
154 toggle_button_set_active_no_signal( m_check, false );
157 typedef MemberCaller<BooleanAttribute, void(), &BooleanAttribute::update> UpdateCaller;
161 class StringAttribute : public EntityAttribute
165 NonModalEntry m_nonModal;
167 StringAttribute( const char* key ) :
170 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
171 auto entry = ui::Entry(ui::New);
173 entry.dimensions(50, -1);
176 m_nonModal.connect( m_entry );
178 ui::Widget getWidget() const {
181 ui::Entry getEntry() const {
189 StringOutputStream value( 64 );
190 value << m_entry.text();
191 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
193 typedef MemberCaller<StringAttribute, void(), &StringAttribute::apply> ApplyCaller;
196 StringOutputStream value( 64 );
197 value << SelectedEntity_getValueForKey( m_key.c_str() );
198 m_entry.text(value.c_str());
200 typedef MemberCaller<StringAttribute, void(), &StringAttribute::update> UpdateCaller;
203 class ShaderAttribute : public StringAttribute
206 ShaderAttribute( const char* key ) : StringAttribute( key ){
207 GlobalShaderEntryCompletion::instance().connect( StringAttribute::getEntry() );
212 class ModelAttribute : public EntityAttribute
215 BrowsedPathEntry m_entry;
216 NonModalEntry m_nonModal;
218 ModelAttribute( const char* key ) :
220 m_entry( BrowseCaller( *this ) ),
221 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
222 m_nonModal.connect( m_entry.m_entry.m_entry );
227 ui::Widget getWidget() const {
228 return m_entry.m_entry.m_frame;
231 StringOutputStream value( 64 );
232 value << m_entry.m_entry.m_entry.text();
233 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
235 typedef MemberCaller<ModelAttribute, void(), &ModelAttribute::apply> ApplyCaller;
237 StringOutputStream value( 64 );
238 value << SelectedEntity_getValueForKey( m_key.c_str() );
239 m_entry.m_entry.m_entry.text(value.c_str());
241 typedef MemberCaller<ModelAttribute, void(), &ModelAttribute::update> UpdateCaller;
242 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
243 const char *filename = misc_model_dialog( m_entry.m_entry.m_frame.window() );
245 if ( filename != 0 ) {
250 typedef MemberCaller<ModelAttribute, void(const BrowsedPathEntry::SetPathCallback&), &ModelAttribute::browse> BrowseCaller;
253 const char* browse_sound( ui::Widget parent ){
254 StringOutputStream buffer( 1024 );
256 buffer << g_qeglobals.m_userGamePath.c_str() << "sound/";
258 if ( !file_readable( buffer.c_str() ) ) {
261 buffer << g_qeglobals.m_userGamePath.c_str() << "/";
264 const char* filename = parent.file_dialog(TRUE, "Open Wav File", buffer.c_str(), "sound" );
265 if ( filename != 0 ) {
266 const char* relative = path_make_relative( filename, GlobalFileSystem().findRoot( filename ) );
267 if ( relative == filename ) {
268 globalOutputStream() << "WARNING: could not extract the relative path, using full path instead\n";
275 class SoundAttribute : public EntityAttribute
278 BrowsedPathEntry m_entry;
279 NonModalEntry m_nonModal;
281 SoundAttribute( const char* key ) :
283 m_entry( BrowseCaller( *this ) ),
284 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
285 m_nonModal.connect( m_entry.m_entry.m_entry );
290 ui::Widget getWidget() const {
291 return ui::Widget(m_entry.m_entry.m_frame );
294 StringOutputStream value( 64 );
295 value << m_entry.m_entry.m_entry.text();
296 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
298 typedef MemberCaller<SoundAttribute, void(), &SoundAttribute::apply> ApplyCaller;
300 StringOutputStream value( 64 );
301 value << SelectedEntity_getValueForKey( m_key.c_str() );
302 m_entry.m_entry.m_entry.text(value.c_str());
304 typedef MemberCaller<SoundAttribute, void(), &SoundAttribute::update> UpdateCaller;
305 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
306 const char *filename = browse_sound( m_entry.m_entry.m_frame.window() );
308 if ( filename != 0 ) {
313 typedef MemberCaller<SoundAttribute, void(const BrowsedPathEntry::SetPathCallback&), &SoundAttribute::browse> BrowseCaller;
316 inline double angle_normalised( double angle ){
317 return float_mod( angle, 360.0 );
320 class AngleAttribute : public EntityAttribute
324 NonModalEntry m_nonModal;
326 AngleAttribute( const char* key ) :
329 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
330 auto entry = numeric_entry_new();
332 m_nonModal.connect( m_entry );
337 ui::Widget getWidget() const {
338 return ui::Widget(m_entry );
341 StringOutputStream angle( 32 );
342 angle << angle_normalised( entry_get_float( m_entry ) );
343 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
345 typedef MemberCaller<AngleAttribute, void(), &AngleAttribute::apply> ApplyCaller;
348 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
349 if ( !string_empty( value ) ) {
350 StringOutputStream angle( 32 );
351 angle << angle_normalised( atof( value ) );
352 m_entry.text(angle.c_str());
359 typedef MemberCaller<AngleAttribute, void(), &AngleAttribute::update> UpdateCaller;
364 typedef const char* String;
365 const String buttons[] = { "up", "down", "z-axis" };
368 class DirectionAttribute : public EntityAttribute
372 NonModalEntry m_nonModal;
374 NonModalRadio m_nonModalRadio;
375 ui::HBox m_hbox{ui::null};
377 DirectionAttribute( const char* key ) :
380 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ),
381 m_radio( RadioHBox_new( STRING_ARRAY_RANGE( buttons ) ) ),
382 m_nonModalRadio( ApplyRadioCaller( *this ) ){
383 auto entry = numeric_entry_new();
385 m_nonModal.connect( m_entry );
387 m_nonModalRadio.connect( m_radio.m_radio );
389 m_hbox = ui::HBox( FALSE, 4 );
392 m_hbox.pack_start( m_radio.m_hbox, TRUE, TRUE, 0 );
393 m_hbox.pack_start( m_entry, TRUE, TRUE, 0 );
398 ui::Widget getWidget() const {
399 return ui::Widget(m_hbox );
402 StringOutputStream angle( 32 );
403 angle << angle_normalised( entry_get_float( m_entry ) );
404 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
406 typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::apply> ApplyCaller;
409 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
410 if ( !string_empty( value ) ) {
411 float f = float(atof( value ) );
413 gtk_widget_set_sensitive( m_entry , FALSE );
414 radio_button_set_active_no_signal( m_radio.m_radio, 0 );
417 else if ( f == -2 ) {
418 gtk_widget_set_sensitive( m_entry , FALSE );
419 radio_button_set_active_no_signal( m_radio.m_radio, 1 );
424 gtk_widget_set_sensitive( m_entry , TRUE );
425 radio_button_set_active_no_signal( m_radio.m_radio, 2 );
426 StringOutputStream angle( 32 );
427 angle << angle_normalised( f );
428 m_entry.text(angle.c_str());
436 typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::update> UpdateCaller;
439 int index = radio_button_get_active( m_radio.m_radio );
441 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), "-1" );
443 else if ( index == 1 ) {
444 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), "-2" );
446 else if ( index == 2 ) {
450 typedef MemberCaller<DirectionAttribute, void(), &DirectionAttribute::applyRadio> ApplyRadioCaller;
460 AnglesEntry() : m_roll( ui::null ), m_pitch( ui::null ), m_yaw( ui::null ){
464 typedef BasicVector3<double> DoubleVector3;
466 class AnglesAttribute : public EntityAttribute
469 AnglesEntry m_angles;
470 NonModalEntry m_nonModal;
473 AnglesAttribute( const char* key ) :
475 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ),
476 m_hbox(ui::HBox( TRUE, 4 ))
480 auto entry = numeric_entry_new();
481 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
482 m_angles.m_pitch = entry;
483 m_nonModal.connect( m_angles.m_pitch );
486 auto entry = numeric_entry_new();
487 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
488 m_angles.m_yaw = entry;
489 m_nonModal.connect( m_angles.m_yaw );
492 auto entry = numeric_entry_new();
493 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
494 m_angles.m_roll = entry;
495 m_nonModal.connect( m_angles.m_roll );
501 ui::Widget getWidget() const {
502 return ui::Widget(m_hbox );
505 StringOutputStream angles( 64 );
506 angles << angle_normalised( entry_get_float( m_angles.m_pitch ) )
507 << " " << angle_normalised( entry_get_float( m_angles.m_yaw ) )
508 << " " << angle_normalised( entry_get_float( m_angles.m_roll ) );
509 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angles.c_str() );
511 typedef MemberCaller<AnglesAttribute, void(), &AnglesAttribute::apply> ApplyCaller;
514 StringOutputStream angle( 32 );
515 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
516 if ( !string_empty( value ) ) {
517 DoubleVector3 pitch_yaw_roll;
518 if ( !string_parse_vector3( value, pitch_yaw_roll ) ) {
519 pitch_yaw_roll = DoubleVector3( 0, 0, 0 );
522 angle << angle_normalised( pitch_yaw_roll.x() );
523 m_angles.m_pitch.text(angle.c_str());
526 angle << angle_normalised( pitch_yaw_roll.y() );
527 m_angles.m_yaw.text(angle.c_str());
530 angle << angle_normalised( pitch_yaw_roll.z() );
531 m_angles.m_roll.text(angle.c_str());
536 m_angles.m_pitch.text("0");
537 m_angles.m_yaw.text("0");
538 m_angles.m_roll.text("0");
541 typedef MemberCaller<AnglesAttribute, void(), &AnglesAttribute::update> UpdateCaller;
550 Vector3Entry() : m_x( ui::null ), m_y( ui::null ), m_z( ui::null ){
554 class Vector3Attribute : public EntityAttribute
557 Vector3Entry m_vector3;
558 NonModalEntry m_nonModal;
559 ui::Box m_hbox{ui::null};
561 Vector3Attribute( const char* key ) :
563 m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
564 m_hbox = ui::HBox( TRUE, 4 );
567 auto entry = numeric_entry_new();
568 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
569 m_vector3.m_x = entry;
570 m_nonModal.connect( m_vector3.m_x );
573 auto entry = numeric_entry_new();
574 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
575 m_vector3.m_y = entry;
576 m_nonModal.connect( m_vector3.m_y );
579 auto entry = numeric_entry_new();
580 m_hbox.pack_start( entry, TRUE, TRUE, 0 );
581 m_vector3.m_z = entry;
582 m_nonModal.connect( m_vector3.m_z );
588 ui::Widget getWidget() const {
589 return ui::Widget(m_hbox );
592 StringOutputStream vector3( 64 );
593 vector3 << entry_get_float( m_vector3.m_x )
594 << " " << entry_get_float( m_vector3.m_y )
595 << " " << entry_get_float( m_vector3.m_z );
596 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), vector3.c_str() );
598 typedef MemberCaller<Vector3Attribute, void(), &Vector3Attribute::apply> ApplyCaller;
601 StringOutputStream buffer( 32 );
602 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
603 if ( !string_empty( value ) ) {
605 if ( !string_parse_vector3( value, x_y_z ) ) {
606 x_y_z = DoubleVector3( 0, 0, 0 );
610 m_vector3.m_x.text(buffer.c_str());
614 m_vector3.m_y.text(buffer.c_str());
618 m_vector3.m_z.text(buffer.c_str());
623 m_vector3.m_x.text("0");
624 m_vector3.m_y.text("0");
625 m_vector3.m_z.text("0");
628 typedef MemberCaller<Vector3Attribute, void(), &Vector3Attribute::update> UpdateCaller;
631 class NonModalComboBox
633 Callback<void()> m_changed;
634 guint m_changedHandler;
636 static gboolean changed( ui::ComboBox widget, NonModalComboBox* self ){
642 NonModalComboBox( const Callback<void()>& changed ) : m_changed( changed ), m_changedHandler( 0 ){
644 void connect( ui::ComboBox combo ){
645 m_changedHandler = combo.connect( "changed", G_CALLBACK( changed ), this );
647 void setActive( ui::ComboBox combo, int value ){
648 g_signal_handler_disconnect( G_OBJECT( combo ), m_changedHandler );
649 gtk_combo_box_set_active( combo, value );
654 class ListAttribute : public EntityAttribute
657 ui::ComboBox m_combo;
658 NonModalComboBox m_nonModal;
659 const ListAttributeType& m_type;
661 ListAttribute( const char* key, const ListAttributeType& type ) :
664 m_nonModal( ApplyCaller( *this ) ),
666 auto combo = ui::ComboBoxText(ui::New);
668 for ( ListAttributeType::const_iterator i = type.begin(); i != type.end(); ++i )
670 gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT( combo ), ( *i ).first.c_str() );
674 m_nonModal.connect( combo );
681 ui::Widget getWidget() const {
682 return ui::Widget(m_combo );
685 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), m_type[gtk_combo_box_get_active( m_combo )].second.c_str() );
687 typedef MemberCaller<ListAttribute, void(), &ListAttribute::apply> ApplyCaller;
690 const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
691 ListAttributeType::const_iterator i = m_type.findValue( value );
692 if ( i != m_type.end() ) {
693 m_nonModal.setActive( m_combo, static_cast<int>( std::distance( m_type.begin(), i ) ) );
697 m_nonModal.setActive( m_combo, 0 );
700 typedef MemberCaller<ListAttribute, void(), &ListAttribute::update> UpdateCaller;
706 GtkWidget* g_entity_split0 = 0;
707 ui::Widget g_entity_split1{ui::null};
708 ui::Widget g_entity_split2{ui::null};
709 int g_entitysplit0_position;
710 int g_entitysplit1_position;
711 int g_entitysplit2_position;
713 bool g_entityInspector_windowConstructed = false;
715 ui::TreeView g_entityClassList{ui::null};
716 ui::TextView g_entityClassComment{ui::null};
718 GtkCheckButton* g_entitySpawnflagsCheck[MAX_FLAGS];
720 ui::Entry g_entityKeyEntry{ui::null};
721 ui::Entry g_entityValueEntry{ui::null};
723 ui::ListStore g_entlist_store{ui::null};
724 ui::ListStore g_entprops_store{ui::null};
725 const EntityClass* g_current_flags = 0;
726 const EntityClass* g_current_comment = 0;
727 const EntityClass* g_current_attributes = 0;
729 // the number of active spawnflags
730 int g_spawnflag_count;
731 // table: index, match spawnflag item to the spawnflag index (i.e. which bit)
732 int spawn_table[MAX_FLAGS];
733 // we change the layout depending on how many spawn flags we need to display
734 // the table is a 4x4 in which we need to put the comment box g_entityClassComment and the spawn flags..
735 ui::Table g_spawnflagsTable{ui::null};
737 ui::VBox g_attributeBox{ui::null};
738 typedef std::vector<EntityAttribute*> EntityAttributes;
739 EntityAttributes g_entityAttributes;
742 void GlobalEntityAttributes_clear(){
743 for ( EntityAttributes::iterator i = g_entityAttributes.begin(); i != g_entityAttributes.end(); ++i )
747 g_entityAttributes.clear();
750 class GetKeyValueVisitor : public Entity::Visitor
752 KeyValues& m_keyvalues;
754 GetKeyValueVisitor( KeyValues& keyvalues )
755 : m_keyvalues( keyvalues ){
758 void visit( const char* key, const char* value ){
759 m_keyvalues.insert( KeyValues::value_type( CopiedString( key ), CopiedString( value ) ) );
764 void Entity_GetKeyValues( const Entity& entity, KeyValues& keyvalues, KeyValues& defaultValues ){
765 GetKeyValueVisitor visitor( keyvalues );
767 entity.forEachKeyValue( visitor );
769 const EntityClassAttributes& attributes = entity.getEntityClass().m_attributes;
771 for ( EntityClassAttributes::const_iterator i = attributes.begin(); i != attributes.end(); ++i )
773 defaultValues.insert( KeyValues::value_type( ( *i ).first, ( *i ).second.m_value ) );
777 void Entity_GetKeyValues_Selected( KeyValues& keyvalues, KeyValues& defaultValues ){
778 class EntityGetKeyValues : public SelectionSystem::Visitor
780 KeyValues& m_keyvalues;
781 KeyValues& m_defaultValues;
782 mutable std::set<Entity*> m_visited;
784 EntityGetKeyValues( KeyValues& keyvalues, KeyValues& defaultValues )
785 : m_keyvalues( keyvalues ), m_defaultValues( defaultValues ){
787 void visit( scene::Instance& instance ) const {
788 Entity* entity = Node_getEntity( instance.path().top() );
789 if ( entity == 0 && instance.path().size() != 1 ) {
790 entity = Node_getEntity( instance.path().parent() );
792 if ( entity != 0 && m_visited.insert( entity ).second ) {
793 Entity_GetKeyValues( *entity, m_keyvalues, m_defaultValues );
796 } visitor( keyvalues, defaultValues );
797 GlobalSelectionSystem().foreachSelected( visitor );
800 const char* keyvalues_valueforkey( KeyValues& keyvalues, const char* key ){
801 KeyValues::iterator i = keyvalues.find( CopiedString( key ) );
802 if ( i != keyvalues.end() ) {
803 return ( *i ).second.c_str();
808 class EntityClassListStoreAppend : public EntityClassVisitor
812 EntityClassListStoreAppend( ui::ListStore store_ ) : store( store_ ){
814 void visit( EntityClass* e ){
815 store.append(0, e->name(), 1, e);
819 void EntityClassList_fill(){
820 EntityClassListStoreAppend append( g_entlist_store );
821 GlobalEntityClassManager().forEach( append );
824 void EntityClassList_clear(){
825 g_entlist_store.clear();
828 void SetComment( EntityClass* eclass ){
829 if ( eclass == g_current_comment ) {
833 g_current_comment = eclass;
835 g_entityClassComment.text(eclass->comments());
838 void SurfaceFlags_setEntityClass( EntityClass* eclass ){
839 if ( eclass == g_current_flags ) {
843 g_current_flags = eclass;
845 unsigned int spawnflag_count = 0;
848 // do a first pass to count the spawn flags, don't touch the widgets, we don't know in what state they are
849 for ( int i = 0 ; i < MAX_FLAGS ; i++ )
851 if ( eclass->flagnames[i] && eclass->flagnames[i][0] != 0 && strcmp( eclass->flagnames[i],"-" ) ) {
852 spawn_table[spawnflag_count] = i;
858 // disable all remaining boxes
859 // NOTE: these boxes might not even be on display
861 for ( int i = 0; i < g_spawnflag_count; ++i )
863 auto widget = ui::CheckButton::from(g_entitySpawnflagsCheck[i]);
864 auto label = ui::Label::from(gtk_bin_get_child(GTK_BIN(widget)));
868 g_spawnflagsTable.remove(widget);
872 g_spawnflag_count = spawnflag_count;
875 for (unsigned int i = 0; (int) i < g_spawnflag_count; ++i)
877 auto widget = ui::CheckButton::from(g_entitySpawnflagsCheck[i] );
880 StringOutputStream str( 16 );
881 str << LowerCase( eclass->flagnames[spawn_table[i]] );
883 g_spawnflagsTable.attach(widget, {i % 4, i % 4 + 1, i / 4, i / 4 + 1}, {GTK_FILL, GTK_FILL});
886 auto label = ui::Label::from(gtk_bin_get_child(GTK_BIN(widget)) );
887 label.text(str.c_str());
892 void EntityClassList_selectEntityClass( EntityClass* eclass ){
893 auto model = g_entlist_store;
895 for ( gboolean good = gtk_tree_model_get_iter_first( model, &iter ); good != FALSE; good = gtk_tree_model_iter_next( model, &iter ) )
898 gtk_tree_model_get( model, &iter, 0, &text, -1 );
899 if ( strcmp( text, eclass->name() ) == 0 ) {
900 auto view = ui::TreeView(g_entityClassList);
901 auto path = gtk_tree_model_get_path( model, &iter );
902 gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
903 if ( gtk_widget_get_realized( view ) ) {
904 gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
906 gtk_tree_path_free( path );
913 void EntityInspector_appendAttribute( const char* name, EntityAttribute& attribute ){
914 auto row = DialogRow_new( name, attribute.getWidget() );
915 DialogVBox_packRow( ui::VBox(g_attributeBox), row );
919 template<typename Attribute>
920 class StatelessAttributeCreator
923 static EntityAttribute* create( const char* name ){
924 return new Attribute( name );
928 class EntityAttributeFactory
930 typedef EntityAttribute* ( *CreateFunc )( const char* name );
931 typedef std::map<const char*, CreateFunc, RawStringLess> Creators;
934 EntityAttributeFactory(){
935 m_creators.insert( Creators::value_type( "string", &StatelessAttributeCreator<StringAttribute>::create ) );
936 m_creators.insert( Creators::value_type( "color", &StatelessAttributeCreator<StringAttribute>::create ) );
937 m_creators.insert( Creators::value_type( "integer", &StatelessAttributeCreator<StringAttribute>::create ) );
938 m_creators.insert( Creators::value_type( "real", &StatelessAttributeCreator<StringAttribute>::create ) );
939 m_creators.insert( Creators::value_type( "shader", &StatelessAttributeCreator<ShaderAttribute>::create ) );
940 m_creators.insert( Creators::value_type( "boolean", &StatelessAttributeCreator<BooleanAttribute>::create ) );
941 m_creators.insert( Creators::value_type( "angle", &StatelessAttributeCreator<AngleAttribute>::create ) );
942 m_creators.insert( Creators::value_type( "direction", &StatelessAttributeCreator<DirectionAttribute>::create ) );
943 m_creators.insert( Creators::value_type( "angles", &StatelessAttributeCreator<AnglesAttribute>::create ) );
944 m_creators.insert( Creators::value_type( "model", &StatelessAttributeCreator<ModelAttribute>::create ) );
945 m_creators.insert( Creators::value_type( "sound", &StatelessAttributeCreator<SoundAttribute>::create ) );
946 m_creators.insert( Creators::value_type( "vector3", &StatelessAttributeCreator<Vector3Attribute>::create ) );
947 m_creators.insert( Creators::value_type( "real3", &StatelessAttributeCreator<Vector3Attribute>::create ) );
949 EntityAttribute* create( const char* type, const char* name ){
950 Creators::iterator i = m_creators.find( type );
951 if ( i != m_creators.end() ) {
952 return ( *i ).second( name );
954 const ListAttributeType* listType = GlobalEntityClassManager().findListType( type );
955 if ( listType != 0 ) {
956 return new ListAttribute( name, *listType );
962 typedef Static<EntityAttributeFactory> GlobalEntityAttributeFactory;
964 void EntityInspector_setEntityClass( EntityClass *eclass ){
965 EntityClassList_selectEntityClass( eclass );
966 SurfaceFlags_setEntityClass( eclass );
968 if ( eclass != g_current_attributes ) {
969 g_current_attributes = eclass;
971 container_remove_all( g_attributeBox );
972 GlobalEntityAttributes_clear();
974 for ( EntityClassAttributes::const_iterator i = eclass->m_attributes.begin(); i != eclass->m_attributes.end(); ++i )
976 EntityAttribute* attribute = GlobalEntityAttributeFactory::instance().create( ( *i ).second.m_type.c_str(), ( *i ).first.c_str() );
977 if ( attribute != 0 ) {
978 g_entityAttributes.push_back( attribute );
979 EntityInspector_appendAttribute( EntityClassAttributePair_getName( *i ), *g_entityAttributes.back() );
985 void EntityInspector_updateSpawnflags(){
987 int f = atoi( SelectedEntity_getValueForKey( "spawnflags" ) );
988 for ( int i = 0; i < g_spawnflag_count; ++i )
990 int v = !!( f & ( 1 << spawn_table[i] ) );
992 toggle_button_set_active_no_signal( ui::ToggleButton::from( g_entitySpawnflagsCheck[i] ), v );
996 // take care of the remaining ones
997 for ( int i = g_spawnflag_count; i < MAX_FLAGS; ++i )
999 toggle_button_set_active_no_signal( ui::ToggleButton::from( g_entitySpawnflagsCheck[i] ), FALSE );
1004 void EntityInspector_applySpawnflags(){
1009 for ( i = 0; i < g_spawnflag_count; ++i )
1011 v = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] ) );
1012 f |= v << spawn_table[i];
1015 sprintf( sz, "%i", f );
1016 const char* value = ( f == 0 ) ? "" : sz;
1019 StringOutputStream command;
1020 command << "entitySetFlags -flags " << f;
1021 UndoableCommand undo( "entitySetSpawnflags" );
1023 Scene_EntitySetKeyValue_Selected( "spawnflags", value );
1028 void EntityInspector_updateKeyValues(){
1029 g_selectedKeyValues.clear();
1030 g_selectedDefaultKeyValues.clear();
1031 Entity_GetKeyValues_Selected( g_selectedKeyValues, g_selectedDefaultKeyValues );
1033 EntityInspector_setEntityClass( GlobalEntityClassManager().findOrInsert( keyvalues_valueforkey( g_selectedKeyValues, "classname" ), false ) );
1035 EntityInspector_updateSpawnflags();
1037 ui::ListStore store = g_entprops_store;
1039 // save current key/val pair around filling epair box
1040 // row_select wipes it and sets to first in list
1041 CopiedString strKey( g_entityKeyEntry.text() );
1042 CopiedString strVal( g_entityValueEntry.text() );
1045 // Walk through list and add pairs
1046 for ( KeyValues::iterator i = g_selectedKeyValues.begin(); i != g_selectedKeyValues.end(); ++i )
1048 StringOutputStream key( 64 );
1049 key << ( *i ).first.c_str();
1050 StringOutputStream value( 64 );
1051 value << ( *i ).second.c_str();
1052 store.append(0, key.c_str(), 1, value.c_str());
1055 g_entityKeyEntry.text( strKey.c_str() );
1056 g_entityValueEntry.text( strVal.c_str() );
1058 for ( EntityAttributes::const_iterator i = g_entityAttributes.begin(); i != g_entityAttributes.end(); ++i )
1064 class EntityInspectorDraw
1066 IdleDraw m_idleDraw;
1068 EntityInspectorDraw() : m_idleDraw( makeCallbackF(EntityInspector_updateKeyValues) ){
1071 m_idleDraw.queueDraw();
1075 EntityInspectorDraw g_EntityInspectorDraw;
1078 void EntityInspector_keyValueChanged(){
1079 g_EntityInspectorDraw.queueDraw();
1081 void EntityInspector_selectionChanged( const Selectable& ){
1082 EntityInspector_keyValueChanged();
1085 // Creates a new entity based on the currently selected brush and entity type.
1087 void EntityClassList_createEntity(){
1088 auto view = g_entityClassList;
1090 // find out what type of entity we are trying to create
1091 GtkTreeModel* model;
1093 if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( g_entityClassList ), &model, &iter ) == FALSE ) {
1094 ui::alert( view.window(), "You must have a selected class to create an entity", "info" );
1099 gtk_tree_model_get( model, &iter, 0, &text, -1 );
1102 StringOutputStream command;
1103 command << "entityCreate -class " << text;
1105 UndoableCommand undo( command.c_str() );
1107 Entity_createFromSelection( text, g_vector3_identity );
1112 void EntityInspector_applyKeyValue(){
1113 // Get current selection text
1114 StringOutputStream key( 64 );
1115 key << gtk_entry_get_text( g_entityKeyEntry );
1116 StringOutputStream value( 64 );
1117 value << gtk_entry_get_text( g_entityValueEntry );
1120 // TTimo: if you change the classname to worldspawn you won't merge back in the structural brushes but create a parasite entity
1121 if ( !strcmp( key.c_str(), "classname" ) && !strcmp( value.c_str(), "worldspawn" ) ) {
1122 ui::alert( g_entityKeyEntry.window(), "Cannot change \"classname\" key back to worldspawn.", 0, ui::alert_type::OK );
1127 // RR2DO2: we don't want spaces in entity keys
1128 if ( strstr( key.c_str(), " " ) ) {
1129 ui::alert( g_entityKeyEntry.window(), "No spaces are allowed in entity keys.", 0, ui::alert_type::OK );
1133 if ( strcmp( key.c_str(), "classname" ) == 0 ) {
1134 StringOutputStream command;
1135 command << "entitySetClass -class " << value.c_str();
1136 UndoableCommand undo( command.c_str() );
1137 Scene_EntitySetClassname_Selected( value.c_str() );
1141 Scene_EntitySetKeyValue_Selected_Undoable( key.c_str(), value.c_str() );
1145 void EntityInspector_clearKeyValue(){
1146 // Get current selection text
1147 StringOutputStream key( 64 );
1148 key << gtk_entry_get_text( g_entityKeyEntry );
1150 if ( strcmp( key.c_str(), "classname" ) != 0 ) {
1151 StringOutputStream command;
1152 command << "entityDeleteKey -key " << key.c_str();
1153 UndoableCommand undo( command.c_str() );
1154 Scene_EntitySetKeyValue_Selected( key.c_str(), "" );
1158 static gint EntityInspector_clearKeyValueKB( GtkEntry* widget, GdkEventKey* event, gpointer data ){
1159 if ( event->keyval == GDK_Delete ) {
1160 // Get current selection text
1161 StringOutputStream key( 64 );
1162 key << gtk_entry_get_text( g_entityKeyEntry );
1164 if ( strcmp( key.c_str(), "classname" ) != 0 ) {
1165 StringOutputStream command;
1166 command << "entityDeleteKey -key " << key.c_str();
1167 UndoableCommand undo( command.c_str() );
1168 Scene_EntitySetKeyValue_Selected( key.c_str(), "" );
1175 void EntityInspector_clearAllKeyValues(){
1176 UndoableCommand undo( "entityClear" );
1178 // remove all keys except classname
1179 for ( KeyValues::iterator i = g_selectedKeyValues.begin(); i != g_selectedKeyValues.end(); ++i )
1181 if ( strcmp( ( *i ).first.c_str(), "classname" ) != 0 ) {
1182 Scene_EntitySetKeyValue_Selected( ( *i ).first.c_str(), "" );
1187 // =============================================================================
1190 static void EntityClassList_selection_changed( ui::TreeSelection selection, gpointer data ){
1191 GtkTreeModel* model;
1192 GtkTreeIter selected;
1193 if ( gtk_tree_selection_get_selected( selection, &model, &selected ) ) {
1194 EntityClass* eclass;
1195 gtk_tree_model_get( model, &selected, 1, &eclass, -1 );
1196 if ( eclass != 0 ) {
1197 SetComment( eclass );
1202 static gint EntityClassList_button_press( ui::Widget widget, GdkEventButton *event, gpointer data ){
1203 if ( event->type == GDK_2BUTTON_PRESS ) {
1204 EntityClassList_createEntity();
1210 static gint EntityClassList_keypress( ui::Widget widget, GdkEventKey* event, gpointer data ){
1211 unsigned int code = gdk_keyval_to_upper( event->keyval );
1213 if ( event->keyval == GDK_KEY_Return ) {
1214 EntityClassList_createEntity();
1218 // select the entity that starts with the key pressed
1219 if ( code <= 'Z' && code >= 'A' ) {
1220 auto view = ui::TreeView(g_entityClassList);
1221 GtkTreeModel* model;
1223 if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( view ), &model, &iter ) == FALSE
1224 || gtk_tree_model_iter_next( model, &iter ) == FALSE ) {
1225 gtk_tree_model_get_iter_first( model, &iter );
1228 for ( std::size_t count = gtk_tree_model_iter_n_children( model, 0 ); count > 0; --count )
1231 gtk_tree_model_get( model, &iter, 0, &text, -1 );
1233 if ( toupper( text[0] ) == (int)code ) {
1234 auto path = gtk_tree_model_get_path( model, &iter );
1235 gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
1236 if ( gtk_widget_get_realized( view ) ) {
1237 gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
1239 gtk_tree_path_free( path );
1245 if ( gtk_tree_model_iter_next( model, &iter ) == FALSE ) {
1246 gtk_tree_model_get_iter_first( model, &iter );
1255 static void EntityProperties_selection_changed( ui::TreeSelection selection, gpointer data ){
1256 // find out what type of entity we are trying to create
1257 GtkTreeModel* model;
1259 if ( gtk_tree_selection_get_selected( selection, &model, &iter ) == FALSE ) {
1265 gtk_tree_model_get( model, &iter, 0, &key, 1, &val, -1 );
1267 g_entityKeyEntry.text( key );
1268 g_entityValueEntry.text( val );
1274 static void SpawnflagCheck_toggled( ui::Widget widget, gpointer data ){
1275 EntityInspector_applySpawnflags();
1278 static gint EntityEntry_keypress( ui::Entry widget, GdkEventKey* event, gpointer data ){
1279 if ( event->keyval == GDK_KEY_Return ) {
1280 if ( widget._handle == g_entityKeyEntry._handle ) {
1281 g_entityValueEntry.text( "" );
1282 gtk_window_set_focus( widget.window(), g_entityValueEntry );
1286 EntityInspector_applyKeyValue();
1290 if ( event->keyval == GDK_Tab ) {
1291 if ( widget._handle == g_entityKeyEntry._handle ) {
1292 gtk_window_set_focus( widget.window(), g_entityValueEntry );
1296 gtk_window_set_focus( widget.window(), g_entityKeyEntry );
1300 if ( event->keyval == GDK_Escape ) {
1301 // gtk_window_set_focus( widget.window(), NULL );
1308 void EntityInspector_destroyWindow( ui::Widget widget, gpointer data ){
1309 g_entitysplit0_position = gtk_paned_get_position( GTK_PANED( g_entity_split0 ) );
1310 g_entitysplit1_position = gtk_paned_get_position( GTK_PANED( g_entity_split1 ) );
1311 g_entitysplit2_position = gtk_paned_get_position( GTK_PANED( g_entity_split2 ) );
1312 g_entityInspector_windowConstructed = false;
1313 GlobalEntityAttributes_clear();
1316 static gint EntityInspector_hideWindowKB( GtkWidget* widget, GdkEventKey* event, gpointer data ){
1317 //if ( event->keyval == GDK_Escape && GTK_WIDGET_VISIBLE( GTK_WIDGET( widget ) ) ) {
1318 if ( event->keyval == GDK_Escape ) {
1319 //GroupDialog_showPage( g_page_entity );
1320 gtk_widget_hide( GTK_WIDGET( GroupDialog_getWindow() ) );
1323 if ( event->keyval == GDK_Tab ) {
1324 gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityKeyEntry ) );
1330 ui::Widget EntityInspector_constructWindow( ui::Window toplevel ){
1331 auto vbox = ui::VBox( FALSE, 2 );
1333 gtk_container_set_border_width( GTK_CONTAINER( vbox ), 2 );
1335 g_signal_connect( G_OBJECT( toplevel ), "key_press_event", G_CALLBACK( EntityInspector_hideWindowKB ), 0 );
1336 vbox.connect( "destroy", G_CALLBACK( EntityInspector_destroyWindow ), 0 );
1339 auto split1 = ui::VPaned(ui::New);
1340 vbox.pack_start( split1, TRUE, TRUE, 0 );
1343 g_entity_split1 = split1;
1346 ui::Widget split2 = ui::VPaned(ui::New);
1347 //gtk_paned_add1( GTK_PANED( split1 ), split2 );
1348 gtk_paned_pack1( GTK_PANED( split1 ), split2, FALSE, FALSE );
1351 g_entity_split2 = split2;
1355 auto scr = ui::ScrolledWindow(ui::New);
1357 //gtk_paned_add1( GTK_PANED( split2 ), scr );
1358 gtk_paned_pack1( GTK_PANED( split2 ), scr, FALSE, FALSE );
1359 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
1360 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1363 ui::ListStore store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ));
1365 auto view = ui::TreeView( ui::TreeModel::from( store._handle ));
1366 gtk_tree_view_set_enable_search(view, FALSE );
1367 gtk_tree_view_set_headers_visible( view, FALSE );
1368 view.connect( "button_press_event", G_CALLBACK( EntityClassList_button_press ), 0 );
1369 view.connect( "key_press_event", G_CALLBACK( EntityClassList_keypress ), 0 );
1372 auto renderer = ui::CellRendererText(ui::New);
1373 auto column = ui::TreeViewColumn( "Key", renderer, {{"text", 0}} );
1374 gtk_tree_view_append_column( view, column );
1378 auto selection = ui::TreeSelection::from(gtk_tree_view_get_selection( view ));
1379 selection.connect( "changed", G_CALLBACK( EntityClassList_selection_changed ), 0 );
1387 g_entityClassList = view;
1388 g_entlist_store = store;
1393 auto scr = ui::ScrolledWindow(ui::New);
1395 //gtk_paned_add2( GTK_PANED( split2 ), scr );
1396 gtk_paned_pack2( GTK_PANED( split2 ), scr, FALSE, FALSE );
1397 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
1398 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1401 auto text = ui::TextView(ui::New);
1402 text.dimensions(0, -1); // allow shrinking
1403 gtk_text_view_set_wrap_mode( text, GTK_WRAP_WORD );
1404 gtk_text_view_set_editable( text, FALSE );
1407 g_entityClassComment = text;
1413 ui::Widget split0 = ui::VPaned(ui::New);
1414 //gtk_paned_add2( GTK_PANED( split1 ), split0 );
1415 gtk_paned_pack2( GTK_PANED( split1 ), split0, FALSE, FALSE );
1417 g_entity_split0 = split0;
1420 auto vbox2 = ui::VBox( FALSE, 2 );
1422 gtk_paned_pack1( GTK_PANED( split0 ), vbox2, FALSE, FALSE );
1425 // Spawnflags (4 colums wide max, or window gets too wide.)
1426 auto table = ui::Table( 4, 4, FALSE );
1427 vbox2.pack_start( table, FALSE, TRUE, 0 );
1430 g_spawnflagsTable = table;
1432 for ( int i = 0; i < MAX_FLAGS; i++ )
1434 auto check = ui::CheckButton( "" );
1436 g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( check.connect( "toggled", G_CALLBACK( SpawnflagCheck_toggled ), 0 ) ) );
1437 g_entitySpawnflagsCheck[i] = check;
1443 auto scr = ui::ScrolledWindow(ui::New);
1445 vbox2.pack_start( scr, TRUE, TRUE, 0 );
1446 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1447 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1450 ui::ListStore store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING ));
1452 auto view = ui::TreeView(ui::TreeModel::from(store._handle));
1453 gtk_tree_view_set_enable_search(view, FALSE );
1454 gtk_tree_view_set_headers_visible(view, FALSE );
1455 g_signal_connect( G_OBJECT( view ), "key_press_event", G_CALLBACK( EntityInspector_clearKeyValueKB ), 0 );
1458 auto renderer = ui::CellRendererText(ui::New);
1459 auto column = ui::TreeViewColumn( "", renderer, {{"text", 0}} );
1460 gtk_tree_view_append_column(view, column );
1464 auto renderer = ui::CellRendererText(ui::New);
1465 auto column = ui::TreeViewColumn( "", renderer, {{"text", 1}} );
1466 gtk_tree_view_append_column(view, column );
1470 auto selection = ui::TreeSelection::from(gtk_tree_view_get_selection(view));
1471 selection.connect( "changed", G_CALLBACK( EntityProperties_selection_changed ), 0 );
1480 g_entprops_store = store;
1486 auto table = ui::Table( 2, 2, FALSE );
1488 vbox2.pack_start( table, FALSE, TRUE, 0 );
1489 gtk_table_set_row_spacings( table, 3 );
1490 gtk_table_set_col_spacings( table, 5 );
1493 auto entry = ui::Entry(ui::New);
1495 table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0});
1496 gtk_widget_set_events( entry , GDK_KEY_PRESS_MASK );
1497 entry.connect( "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
1498 g_entityKeyEntry = entry;
1502 auto entry = ui::Entry(ui::New);
1504 table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0});
1505 gtk_widget_set_events( entry , GDK_KEY_PRESS_MASK );
1506 entry.connect( "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
1507 g_entityValueEntry = entry;
1511 auto label = ui::Label( "Value" );
1513 table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0});
1514 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
1518 auto label = ui::Label( "Key" );
1520 table.attach(label, {0, 1, 0, 1}, {GTK_FILL, 0});
1521 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
1526 auto hbox = ui::HBox( TRUE, 4 );
1528 vbox2.pack_start( hbox, FALSE, TRUE, 0 );
1531 auto button = ui::Button( "Clear All" );
1533 button.connect( "clicked", G_CALLBACK( EntityInspector_clearAllKeyValues ), 0 );
1534 hbox.pack_start( button, TRUE, TRUE, 0 );
1537 auto button = ui::Button( "Delete Key" );
1539 button.connect( "clicked", G_CALLBACK( EntityInspector_clearKeyValue ), 0 );
1540 hbox.pack_start( button, TRUE, TRUE, 0 );
1546 auto scr = ui::ScrolledWindow(ui::New);
1548 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
1550 auto viewport = ui::Container::from(gtk_viewport_new( 0, 0 ));
1552 gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport ), GTK_SHADOW_NONE );
1554 g_attributeBox = ui::VBox( FALSE, 2 );
1555 g_attributeBox.show();
1557 viewport.add(g_attributeBox);
1559 gtk_paned_pack2( GTK_PANED( split0 ), scr, FALSE, FALSE );
1566 // show the sliders in any case //no need, gtk can care
1567 /*if ( g_entitysplit2_position < 22 ) {
1568 g_entitysplit2_position = 22;
1570 gtk_paned_set_position( GTK_PANED( g_entity_split2 ), g_entitysplit2_position );
1571 /*if ( ( g_entitysplit1_position - g_entitysplit2_position ) < 27 ) {
1572 g_entitysplit1_position = g_entitysplit2_position + 27;
1574 gtk_paned_set_position( GTK_PANED( g_entity_split1 ), g_entitysplit1_position );
1575 gtk_paned_set_position( GTK_PANED( g_entity_split0 ), g_entitysplit0_position );
1578 g_entityInspector_windowConstructed = true;
1579 EntityClassList_fill();
1581 typedef FreeCaller<void(const Selectable&), EntityInspector_selectionChanged> EntityInspectorSelectionChangedCaller;
1582 GlobalSelectionSystem().addSelectionChangeCallback( EntityInspectorSelectionChangedCaller() );
1583 GlobalEntityCreator().setKeyValueChangedFunc( EntityInspector_keyValueChanged );
1586 gtk_container_set_focus_chain( GTK_CONTAINER( vbox ), NULL );
1591 class EntityInspector : public ModuleObserver
1593 std::size_t m_unrealised;
1595 EntityInspector() : m_unrealised( 1 ){
1598 if ( --m_unrealised == 0 ) {
1599 if ( g_entityInspector_windowConstructed ) {
1600 //globalOutputStream() << "Entity Inspector: realise\n";
1601 EntityClassList_fill();
1606 if ( ++m_unrealised == 1 ) {
1607 if ( g_entityInspector_windowConstructed ) {
1608 //globalOutputStream() << "Entity Inspector: unrealise\n";
1609 EntityClassList_clear();
1615 EntityInspector g_EntityInspector;
1617 #include "preferencesystem.h"
1618 #include "stringio.h"
1620 void EntityInspector_construct(){
1621 GlobalEntityClassManager().attach( g_EntityInspector );
1623 GlobalPreferenceSystem().registerPreference( "EntitySplit0", make_property_string( g_entitysplit0_position ) );
1624 GlobalPreferenceSystem().registerPreference( "EntitySplit1", make_property_string( g_entitysplit1_position ) );
1625 GlobalPreferenceSystem().registerPreference( "EntitySplit2", make_property_string( g_entitysplit2_position ) );
1629 void EntityInspector_destroy(){
1630 GlobalEntityClassManager().detach( g_EntityInspector );
1633 const char *EntityInspector_getCurrentKey(){
1634 if ( !GroupDialog_isShown() ) {
1637 if ( GroupDialog_getPage() != g_page_entity ) {
1640 return gtk_entry_get_text( g_entityKeyEntry );