radiant/entityinspector.cpp

   1 /*
   2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3    For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5    This file is part of GtkRadiant.
   6
   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.
  11
  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.
  16
  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
  20  */
  21
  22 #include "entityinspector.h"
  23
  24 #include "debugging/debugging.h"
  25
  26 #include "ientity.h"
  27 #include "ifilesystem.h"
  28 #include "imodel.h"
  29 #include "iscenegraph.h"
  30 #include "iselection.h"
  31 #include "iundo.h"
  32
  33 #include <map>
  34 #include <set>
  35 #include <gdk/gdkkeysyms.h>
  36 #include <gtk/gtktreemodel.h>
  37 #include <gtk/gtktreeview.h>
  38 #include <gtk/gtkcellrenderertext.h>
  39 #include <gtk/gtktreeselection.h>
  40 #include <gtk/gtkliststore.h>
  41 #include <gtk/gtktextview.h>
  42 #include <gtk/gtklabel.h>
  43 #include <gtk/gtktable.h>
  44 #include <gtk/gtktogglebutton.h>
  45 #include <gtk/gtkcheckbutton.h>
  46 #include <gtk/gtkhbox.h>
  47 #include <gtk/gtkvbox.h>
  48 #include <gtk/gtkvpaned.h>
  49 #include <gtk/gtkscrolledwindow.h>
  50 #include <gtk/gtkentry.h>
  51 #include <gtk/gtkcombobox.h>
  52
  53
  54 #include "os/path.h"
  55 #include "eclasslib.h"
  56 #include "scenelib.h"
  57 #include "generic/callback.h"
  58 #include "os/file.h"
  59 #include "stream/stringstream.h"
  60 #include "moduleobserver.h"
  61 #include "convert.h"
  62 #include "stringio.h"
  63
  64 #include "gtkutil/accelerator.h"
  65 #include "gtkutil/dialog.h"
  66 #include "gtkutil/filechooser.h"
  67 #include "gtkutil/messagebox.h"
  68 #include "gtkutil/nonmodal.h"
  69 #include "gtkutil/button.h"
  70 #include "gtkutil/entry.h"
  71 #include "gtkutil/container.h"
  72
  73 #include "qe3.h"
  74 #include "gtkmisc.h"
  75 #include "gtkdlgs.h"
  76 #include "entity.h"
  77 #include "mainframe.h"
  78 #include "textureentry.h"
  79 #include "groupdialog.h"
  80
  81 GtkEntry* numeric_entry_new(){
  82         GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
  83         gtk_widget_show( GTK_WIDGET( entry ) );
  84         gtk_widget_set_size_request( GTK_WIDGET( entry ), 64, -1 );
  85         return entry;
  86 }
  87
  88 namespace
  89 {
  90 typedef std::map<CopiedString, CopiedString> KeyValues;
  91 KeyValues g_selectedKeyValues;
  92 KeyValues g_selectedDefaultKeyValues;
  93 }
  94
  95 const char* SelectedEntity_getValueForKey( const char* key ){
  96         {
  97                 KeyValues::const_iterator i = g_selectedKeyValues.find( key );
  98                 if ( i != g_selectedKeyValues.end() ) {
  99                         return ( *i ).second.c_str();
 100                 }
 101         }
 102         {
 103                 KeyValues::const_iterator i = g_selectedDefaultKeyValues.find( key );
 104                 if ( i != g_selectedDefaultKeyValues.end() ) {
 105                         return ( *i ).second.c_str();
 106                 }
 107         }
 108         return "";
 109 }
 110
 111 void Scene_EntitySetKeyValue_Selected_Undoable( const char* key, const char* value ){
 112         StringOutputStream command( 256 );
 113         command << "entitySetKeyValue -key " << makeQuoted( key ) << " -value " << makeQuoted( value );
 114         UndoableCommand undo( command.c_str() );
 115         Scene_EntitySetKeyValue_Selected( key, value );
 116 }
 117
 118 class EntityAttribute
 119 {
 120 public:
 121 virtual GtkWidget* getWidget() const = 0;
 122 virtual void update() = 0;
 123 virtual void release() = 0;
 124 };
 125
 126 class BooleanAttribute : public EntityAttribute
 127 {
 128 CopiedString m_key;
 129 GtkCheckButton* m_check;
 130
 131 static gboolean toggled( GtkWidget *widget, BooleanAttribute* self ){
 132         self->apply();
 133         return FALSE;
 134 }
 135 public:
 136 BooleanAttribute( const char* key ) :
 137         m_key( key ),
 138         m_check( 0 ){
 139         GtkCheckButton* check = GTK_CHECK_BUTTON( gtk_check_button_new() );
 140         gtk_widget_show( GTK_WIDGET( check ) );
 141
 142         m_check = check;
 143
 144         guint handler = g_signal_connect( G_OBJECT( check ), "toggled", G_CALLBACK( toggled ), this );
 145         g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( handler ) );
 146
 147         update();
 148 }
 149 GtkWidget* getWidget() const {
 150         return GTK_WIDGET( m_check );
 151 }
 152 void release(){
 153         delete this;
 154 }
 155 void apply(){
 156         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( m_check ) ) ? "1" : "0" );
 157 }
 158 typedef MemberCaller<BooleanAttribute, &BooleanAttribute::apply> ApplyCaller;
 159
 160 void update(){
 161         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 162         if ( !string_empty( value ) ) {
 163                 toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( m_check ), atoi( value ) != 0 );
 164         }
 165         else
 166         {
 167                 toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( m_check ), false );
 168         }
 169 }
 170 typedef MemberCaller<BooleanAttribute, &BooleanAttribute::update> UpdateCaller;
 171 };
 172
 173
 174 class StringAttribute : public EntityAttribute
 175 {
 176 CopiedString m_key;
 177 GtkEntry* m_entry;
 178 NonModalEntry m_nonModal;
 179 public:
 180 StringAttribute( const char* key ) :
 181         m_key( key ),
 182         m_entry( 0 ),
 183         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 184         GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
 185         gtk_widget_show( GTK_WIDGET( entry ) );
 186         gtk_widget_set_size_request( GTK_WIDGET( entry ), 50, -1 );
 187
 188         m_entry = entry;
 189         m_nonModal.connect( m_entry );
 190 }
 191 GtkWidget* getWidget() const {
 192         return GTK_WIDGET( m_entry );
 193 }
 194 GtkEntry* getEntry() const {
 195         return m_entry;
 196 }
 197
 198 void release(){
 199         delete this;
 200 }
 201 void apply(){
 202         StringOutputStream value( 64 );
 203         value << gtk_entry_get_text( m_entry );
 204         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 205 }
 206 typedef MemberCaller<StringAttribute, &StringAttribute::apply> ApplyCaller;
 207
 208 void update(){
 209         StringOutputStream value( 64 );
 210         value << SelectedEntity_getValueForKey( m_key.c_str() );
 211         gtk_entry_set_text( m_entry, value.c_str() );
 212 }
 213 typedef MemberCaller<StringAttribute, &StringAttribute::update> UpdateCaller;
 214 };
 215
 216 class ShaderAttribute : public StringAttribute
 217 {
 218 public:
 219 ShaderAttribute( const char* key ) : StringAttribute( key ){
 220         GlobalShaderEntryCompletion::instance().connect( StringAttribute::getEntry() );
 221 }
 222 };
 223
 224
 225 class ModelAttribute : public EntityAttribute
 226 {
 227 CopiedString m_key;
 228 BrowsedPathEntry m_entry;
 229 NonModalEntry m_nonModal;
 230 public:
 231 ModelAttribute( const char* key ) :
 232         m_key( key ),
 233         m_entry( BrowseCaller( *this ) ),
 234         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 235         m_nonModal.connect( m_entry.m_entry.m_entry );
 236 }
 237 void release(){
 238         delete this;
 239 }
 240 GtkWidget* getWidget() const {
 241         return GTK_WIDGET( m_entry.m_entry.m_frame );
 242 }
 243 void apply(){
 244         StringOutputStream value( 64 );
 245         value << gtk_entry_get_text( GTK_ENTRY( m_entry.m_entry.m_entry ) );
 246         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 247 }
 248 typedef MemberCaller<ModelAttribute, &ModelAttribute::apply> ApplyCaller;
 249 void update(){
 250         StringOutputStream value( 64 );
 251         value << SelectedEntity_getValueForKey( m_key.c_str() );
 252         gtk_entry_set_text( GTK_ENTRY( m_entry.m_entry.m_entry ), value.c_str() );
 253 }
 254 typedef MemberCaller<ModelAttribute, &ModelAttribute::update> UpdateCaller;
 255 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
 256         const char *filename = misc_model_dialog( gtk_widget_get_toplevel( GTK_WIDGET( m_entry.m_entry.m_frame ) ) );
 257
 258         if ( filename != 0 ) {
 259                 setPath( filename );
 260                 apply();
 261         }
 262 }
 263 typedef MemberCaller1<ModelAttribute, const BrowsedPathEntry::SetPathCallback&, &ModelAttribute::browse> BrowseCaller;
 264 };
 265
 266 const char* browse_sound( GtkWidget* parent ){
 267         StringOutputStream buffer( 1024 );
 268
 269         buffer << g_qeglobals.m_userGamePath.c_str() << "sound/";
 270
 271         if ( !file_readable( buffer.c_str() ) ) {
 272                 // just go to fsmain
 273                 buffer.clear();
 274                 buffer << g_qeglobals.m_userGamePath.c_str() << "/";
 275         }
 276
 277         const char* filename = file_dialog( parent, TRUE, "Open Wav File", buffer.c_str(), "sound" );
 278         if ( filename != 0 ) {
 279                 const char* relative = path_make_relative( filename, GlobalFileSystem().findRoot( filename ) );
 280                 if ( relative == filename ) {
 281                         globalOutputStream() << "WARNING: could not extract the relative path, using full path instead\n";
 282                 }
 283                 return relative;
 284         }
 285         return filename;
 286 }
 287
 288 class SoundAttribute : public EntityAttribute
 289 {
 290 CopiedString m_key;
 291 BrowsedPathEntry m_entry;
 292 NonModalEntry m_nonModal;
 293 public:
 294 SoundAttribute( const char* key ) :
 295         m_key( key ),
 296         m_entry( BrowseCaller( *this ) ),
 297         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 298         m_nonModal.connect( m_entry.m_entry.m_entry );
 299 }
 300 void release(){
 301         delete this;
 302 }
 303 GtkWidget* getWidget() const {
 304         return GTK_WIDGET( m_entry.m_entry.m_frame );
 305 }
 306 void apply(){
 307         StringOutputStream value( 64 );
 308         value << gtk_entry_get_text( GTK_ENTRY( m_entry.m_entry.m_entry ) );
 309         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), value.c_str() );
 310 }
 311 typedef MemberCaller<SoundAttribute, &SoundAttribute::apply> ApplyCaller;
 312 void update(){
 313         StringOutputStream value( 64 );
 314         value << SelectedEntity_getValueForKey( m_key.c_str() );
 315         gtk_entry_set_text( GTK_ENTRY( m_entry.m_entry.m_entry ), value.c_str() );
 316 }
 317 typedef MemberCaller<SoundAttribute, &SoundAttribute::update> UpdateCaller;
 318 void browse( const BrowsedPathEntry::SetPathCallback& setPath ){
 319         const char *filename = browse_sound( gtk_widget_get_toplevel( GTK_WIDGET( m_entry.m_entry.m_frame ) ) );
 320
 321         if ( filename != 0 ) {
 322                 setPath( filename );
 323                 apply();
 324         }
 325 }
 326 typedef MemberCaller1<SoundAttribute, const BrowsedPathEntry::SetPathCallback&, &SoundAttribute::browse> BrowseCaller;
 327 };
 328
 329 inline double angle_normalised( double angle ){
 330         return float_mod( angle, 360.0 );
 331 }
 332
 333 class AngleAttribute : public EntityAttribute
 334 {
 335 CopiedString m_key;
 336 GtkEntry* m_entry;
 337 NonModalEntry m_nonModal;
 338 public:
 339 AngleAttribute( const char* key ) :
 340         m_key( key ),
 341         m_entry( 0 ),
 342         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 343         GtkEntry* entry = numeric_entry_new();
 344         m_entry = entry;
 345         m_nonModal.connect( m_entry );
 346 }
 347 void release(){
 348         delete this;
 349 }
 350 GtkWidget* getWidget() const {
 351         return GTK_WIDGET( m_entry );
 352 }
 353 void apply(){
 354         StringOutputStream angle( 32 );
 355         angle << angle_normalised( entry_get_float( m_entry ) );
 356         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
 357 }
 358 typedef MemberCaller<AngleAttribute, &AngleAttribute::apply> ApplyCaller;
 359
 360 void update(){
 361         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 362         if ( !string_empty( value ) ) {
 363                 StringOutputStream angle( 32 );
 364                 angle << angle_normalised( atof( value ) );
 365                 gtk_entry_set_text( m_entry, angle.c_str() );
 366         }
 367         else
 368         {
 369                 gtk_entry_set_text( m_entry, "0" );
 370         }
 371 }
 372 typedef MemberCaller<AngleAttribute, &AngleAttribute::update> UpdateCaller;
 373 };
 374
 375 namespace
 376 {
 377 typedef const char* String;
 378 const String buttons[] = { "up", "down", "z-axis" };
 379 }
 380
 381 class DirectionAttribute : public EntityAttribute
 382 {
 383 CopiedString m_key;
 384 GtkEntry* m_entry;
 385 NonModalEntry m_nonModal;
 386 RadioHBox m_radio;
 387 NonModalRadio m_nonModalRadio;
 388 GtkHBox* m_hbox;
 389 public:
 390 DirectionAttribute( const char* key ) :
 391         m_key( key ),
 392         m_entry( 0 ),
 393         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ),
 394         m_radio( RadioHBox_new( STRING_ARRAY_RANGE( buttons ) ) ),
 395         m_nonModalRadio( ApplyRadioCaller( *this ) ){
 396         GtkEntry* entry = numeric_entry_new();
 397         m_entry = entry;
 398         m_nonModal.connect( m_entry );
 399
 400         m_nonModalRadio.connect( m_radio.m_radio );
 401
 402         m_hbox = GTK_HBOX( gtk_hbox_new( FALSE, 4 ) );
 403         gtk_widget_show( GTK_WIDGET( m_hbox ) );
 404
 405         gtk_box_pack_start( GTK_BOX( m_hbox ), GTK_WIDGET( m_radio.m_hbox ), TRUE, TRUE, 0 );
 406         gtk_box_pack_start( GTK_BOX( m_hbox ), GTK_WIDGET( m_entry ), TRUE, TRUE, 0 );
 407 }
 408 void release(){
 409         delete this;
 410 }
 411 GtkWidget* getWidget() const {
 412         return GTK_WIDGET( m_hbox );
 413 }
 414 void apply(){
 415         StringOutputStream angle( 32 );
 416         angle << angle_normalised( entry_get_float( m_entry ) );
 417         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angle.c_str() );
 418 }
 419 typedef MemberCaller<DirectionAttribute, &DirectionAttribute::apply> ApplyCaller;
 420
 421 void update(){
 422         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 423         if ( !string_empty( value ) ) {
 424                 float f = float(atof( value ) );
 425                 if ( f == -1 ) {
 426                         gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), FALSE );
 427                         radio_button_set_active_no_signal( m_radio.m_radio, 0 );
 428                         gtk_entry_set_text( m_entry, "" );
 429                 }
 430                 else if ( f == -2 ) {
 431                         gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), FALSE );
 432                         radio_button_set_active_no_signal( m_radio.m_radio, 1 );
 433                         gtk_entry_set_text( m_entry, "" );
 434                 }
 435                 else
 436                 {
 437                         gtk_widget_set_sensitive( GTK_WIDGET( m_entry ), TRUE );
 438                         radio_button_set_active_no_signal( m_radio.m_radio, 2 );
 439                         StringOutputStream angle( 32 );
 440                         angle << angle_normalised( f );
 441                         gtk_entry_set_text( m_entry, angle.c_str() );
 442                 }
 443         }
 444         else
 445         {
 446                 gtk_entry_set_text( m_entry, "0" );
 447         }
 448 }
 449 typedef MemberCaller<DirectionAttribute, &DirectionAttribute::update> UpdateCaller;
 450
 451 void applyRadio(){
 452         int index = radio_button_get_active( m_radio.m_radio );
 453         if ( index == 0 ) {
 454                 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), "-1" );
 455         }
 456         else if ( index == 1 ) {
 457                 Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), "-2" );
 458         }
 459         else if ( index == 2 ) {
 460                 apply();
 461         }
 462 }
 463 typedef MemberCaller<DirectionAttribute, &DirectionAttribute::applyRadio> ApplyRadioCaller;
 464 };
 465
 466
 467 class AnglesEntry
 468 {
 469 public:
 470 GtkEntry* m_roll;
 471 GtkEntry* m_pitch;
 472 GtkEntry* m_yaw;
 473 AnglesEntry() : m_roll( 0 ), m_pitch( 0 ), m_yaw( 0 ){
 474 }
 475 };
 476
 477 typedef BasicVector3<double> DoubleVector3;
 478
 479 class AnglesAttribute : public EntityAttribute
 480 {
 481 CopiedString m_key;
 482 AnglesEntry m_angles;
 483 NonModalEntry m_nonModal;
 484 GtkBox* m_hbox;
 485 public:
 486 AnglesAttribute( const char* key ) :
 487         m_key( key ),
 488         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 489         m_hbox = GTK_BOX( gtk_hbox_new( TRUE, 4 ) );
 490         gtk_widget_show( GTK_WIDGET( m_hbox ) );
 491         {
 492                 GtkEntry* entry = numeric_entry_new();
 493                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 494                 m_angles.m_pitch = entry;
 495                 m_nonModal.connect( m_angles.m_pitch );
 496         }
 497         {
 498                 GtkEntry* entry = numeric_entry_new();
 499                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 500                 m_angles.m_yaw = entry;
 501                 m_nonModal.connect( m_angles.m_yaw );
 502         }
 503         {
 504                 GtkEntry* entry = numeric_entry_new();
 505                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 506                 m_angles.m_roll = entry;
 507                 m_nonModal.connect( m_angles.m_roll );
 508         }
 509 }
 510 void release(){
 511         delete this;
 512 }
 513 GtkWidget* getWidget() const {
 514         return GTK_WIDGET( m_hbox );
 515 }
 516 void apply(){
 517         StringOutputStream angles( 64 );
 518         angles << angle_normalised( entry_get_float( m_angles.m_pitch ) )
 519                    << " " << angle_normalised( entry_get_float( m_angles.m_yaw ) )
 520                    << " " << angle_normalised( entry_get_float( m_angles.m_roll ) );
 521         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), angles.c_str() );
 522 }
 523 typedef MemberCaller<AnglesAttribute, &AnglesAttribute::apply> ApplyCaller;
 524
 525 void update(){
 526         StringOutputStream angle( 32 );
 527         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 528         if ( !string_empty( value ) ) {
 529                 DoubleVector3 pitch_yaw_roll;
 530                 if ( !string_parse_vector3( value, pitch_yaw_roll ) ) {
 531                         pitch_yaw_roll = DoubleVector3( 0, 0, 0 );
 532                 }
 533
 534                 angle << angle_normalised( pitch_yaw_roll.x() );
 535                 gtk_entry_set_text( m_angles.m_pitch, angle.c_str() );
 536                 angle.clear();
 537
 538                 angle << angle_normalised( pitch_yaw_roll.y() );
 539                 gtk_entry_set_text( m_angles.m_yaw, angle.c_str() );
 540                 angle.clear();
 541
 542                 angle << angle_normalised( pitch_yaw_roll.z() );
 543                 gtk_entry_set_text( m_angles.m_roll, angle.c_str() );
 544                 angle.clear();
 545         }
 546         else
 547         {
 548                 gtk_entry_set_text( m_angles.m_pitch, "0" );
 549                 gtk_entry_set_text( m_angles.m_yaw, "0" );
 550                 gtk_entry_set_text( m_angles.m_roll, "0" );
 551         }
 552 }
 553 typedef MemberCaller<AnglesAttribute, &AnglesAttribute::update> UpdateCaller;
 554 };
 555
 556 class Vector3Entry
 557 {
 558 public:
 559 GtkEntry* m_x;
 560 GtkEntry* m_y;
 561 GtkEntry* m_z;
 562 Vector3Entry() : m_x( 0 ), m_y( 0 ), m_z( 0 ){
 563 }
 564 };
 565
 566 class Vector3Attribute : public EntityAttribute
 567 {
 568 CopiedString m_key;
 569 Vector3Entry m_vector3;
 570 NonModalEntry m_nonModal;
 571 GtkBox* m_hbox;
 572 public:
 573 Vector3Attribute( const char* key ) :
 574         m_key( key ),
 575         m_nonModal( ApplyCaller( *this ), UpdateCaller( *this ) ){
 576         m_hbox = GTK_BOX( gtk_hbox_new( TRUE, 4 ) );
 577         gtk_widget_show( GTK_WIDGET( m_hbox ) );
 578         {
 579                 GtkEntry* entry = numeric_entry_new();
 580                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 581                 m_vector3.m_x = entry;
 582                 m_nonModal.connect( m_vector3.m_x );
 583         }
 584         {
 585                 GtkEntry* entry = numeric_entry_new();
 586                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 587                 m_vector3.m_y = entry;
 588                 m_nonModal.connect( m_vector3.m_y );
 589         }
 590         {
 591                 GtkEntry* entry = numeric_entry_new();
 592                 gtk_box_pack_start( m_hbox, GTK_WIDGET( entry ), TRUE, TRUE, 0 );
 593                 m_vector3.m_z = entry;
 594                 m_nonModal.connect( m_vector3.m_z );
 595         }
 596 }
 597 void release(){
 598         delete this;
 599 }
 600 GtkWidget* getWidget() const {
 601         return GTK_WIDGET( m_hbox );
 602 }
 603 void apply(){
 604         StringOutputStream vector3( 64 );
 605         vector3 << entry_get_float( m_vector3.m_x )
 606                         << " " << entry_get_float( m_vector3.m_y )
 607                         << " " << entry_get_float( m_vector3.m_z );
 608         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), vector3.c_str() );
 609 }
 610 typedef MemberCaller<Vector3Attribute, &Vector3Attribute::apply> ApplyCaller;
 611
 612 void update(){
 613         StringOutputStream buffer( 32 );
 614         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 615         if ( !string_empty( value ) ) {
 616                 DoubleVector3 x_y_z;
 617                 if ( !string_parse_vector3( value, x_y_z ) ) {
 618                         x_y_z = DoubleVector3( 0, 0, 0 );
 619                 }
 620
 621                 buffer << x_y_z.x();
 622                 gtk_entry_set_text( m_vector3.m_x, buffer.c_str() );
 623                 buffer.clear();
 624
 625                 buffer << x_y_z.y();
 626                 gtk_entry_set_text( m_vector3.m_y, buffer.c_str() );
 627                 buffer.clear();
 628
 629                 buffer << x_y_z.z();
 630                 gtk_entry_set_text( m_vector3.m_z, buffer.c_str() );
 631                 buffer.clear();
 632         }
 633         else
 634         {
 635                 gtk_entry_set_text( m_vector3.m_x, "0" );
 636                 gtk_entry_set_text( m_vector3.m_y, "0" );
 637                 gtk_entry_set_text( m_vector3.m_z, "0" );
 638         }
 639 }
 640 typedef MemberCaller<Vector3Attribute, &Vector3Attribute::update> UpdateCaller;
 641 };
 642
 643 class NonModalComboBox
 644 {
 645 Callback m_changed;
 646 guint m_changedHandler;
 647
 648 static gboolean changed( GtkComboBox *widget, NonModalComboBox* self ){
 649         self->m_changed();
 650         return FALSE;
 651 }
 652
 653 public:
 654 NonModalComboBox( const Callback& changed ) : m_changed( changed ), m_changedHandler( 0 ){
 655 }
 656 void connect( GtkComboBox* combo ){
 657         m_changedHandler = g_signal_connect( G_OBJECT( combo ), "changed", G_CALLBACK( changed ), this );
 658 }
 659 void setActive( GtkComboBox* combo, int value ){
 660         g_signal_handler_disconnect( G_OBJECT( combo ), m_changedHandler );
 661         gtk_combo_box_set_active( combo, value );
 662         connect( combo );
 663 }
 664 };
 665
 666 class ListAttribute : public EntityAttribute
 667 {
 668 CopiedString m_key;
 669 GtkComboBox* m_combo;
 670 NonModalComboBox m_nonModal;
 671 const ListAttributeType& m_type;
 672 public:
 673 ListAttribute( const char* key, const ListAttributeType& type ) :
 674         m_key( key ),
 675         m_combo( 0 ),
 676         m_nonModal( ApplyCaller( *this ) ),
 677         m_type( type ){
 678         GtkComboBox* combo = GTK_COMBO_BOX( gtk_combo_box_new_text() );
 679
 680         for ( ListAttributeType::const_iterator i = type.begin(); i != type.end(); ++i )
 681         {
 682                 gtk_combo_box_append_text( GTK_COMBO_BOX( combo ), ( *i ).first.c_str() );
 683         }
 684
 685         gtk_widget_show( GTK_WIDGET( combo ) );
 686         m_nonModal.connect( combo );
 687
 688         m_combo = combo;
 689 }
 690 void release(){
 691         delete this;
 692 }
 693 GtkWidget* getWidget() const {
 694         return GTK_WIDGET( m_combo );
 695 }
 696 void apply(){
 697         Scene_EntitySetKeyValue_Selected_Undoable( m_key.c_str(), m_type[gtk_combo_box_get_active( m_combo )].second.c_str() );
 698 }
 699 typedef MemberCaller<ListAttribute, &ListAttribute::apply> ApplyCaller;
 700
 701 void update(){
 702         const char* value = SelectedEntity_getValueForKey( m_key.c_str() );
 703         ListAttributeType::const_iterator i = m_type.findValue( value );
 704         if ( i != m_type.end() ) {
 705                 m_nonModal.setActive( m_combo, static_cast<int>( std::distance( m_type.begin(), i ) ) );
 706         }
 707         else
 708         {
 709                 m_nonModal.setActive( m_combo, 0 );
 710         }
 711 }
 712 typedef MemberCaller<ListAttribute, &ListAttribute::update> UpdateCaller;
 713 };
 714
 715
 716 namespace
 717 {
 718 GtkWidget* g_entity_split1 = 0;
 719 GtkWidget* g_entity_split2 = 0;
 720 int g_entitysplit1_position;
 721 int g_entitysplit2_position;
 722
 723 bool g_entityInspector_windowConstructed = false;
 724
 725 GtkTreeView* g_entityClassList;
 726 GtkTextView* g_entityClassComment;
 727
 728 GtkCheckButton* g_entitySpawnflagsCheck[MAX_FLAGS];
 729
 730 GtkEntry* g_entityKeyEntry;
 731 GtkEntry* g_entityValueEntry;
 732
 733 GtkListStore* g_entlist_store;
 734 GtkListStore* g_entprops_store;
 735 const EntityClass* g_current_flags = 0;
 736 const EntityClass* g_current_comment = 0;
 737 const EntityClass* g_current_attributes = 0;
 738
 739 // the number of active spawnflags
 740 int g_spawnflag_count;
 741 // table: index, match spawnflag item to the spawnflag index (i.e. which bit)
 742 int spawn_table[MAX_FLAGS];
 743 // we change the layout depending on how many spawn flags we need to display
 744 // the table is a 4x4 in which we need to put the comment box g_entityClassComment and the spawn flags..
 745 GtkTable* g_spawnflagsTable;
 746
 747 GtkVBox* g_attributeBox = 0;
 748 typedef std::vector<EntityAttribute*> EntityAttributes;
 749 EntityAttributes g_entityAttributes;
 750 }
 751
 752 void GlobalEntityAttributes_clear(){
 753         for ( EntityAttributes::iterator i = g_entityAttributes.begin(); i != g_entityAttributes.end(); ++i )
 754         {
 755                 ( *i )->release();
 756         }
 757         g_entityAttributes.clear();
 758 }
 759
 760 class GetKeyValueVisitor : public Entity::Visitor
 761 {
 762 KeyValues& m_keyvalues;
 763 public:
 764 GetKeyValueVisitor( KeyValues& keyvalues )
 765         : m_keyvalues( keyvalues ){
 766 }
 767
 768 void visit( const char* key, const char* value ){
 769         m_keyvalues.insert( KeyValues::value_type( CopiedString( key ), CopiedString( value ) ) );
 770 }
 771
 772 };
 773
 774 void Entity_GetKeyValues( const Entity& entity, KeyValues& keyvalues, KeyValues& defaultValues ){
 775         GetKeyValueVisitor visitor( keyvalues );
 776
 777         entity.forEachKeyValue( visitor );
 778
 779         const EntityClassAttributes& attributes = entity.getEntityClass().m_attributes;
 780
 781         for ( EntityClassAttributes::const_iterator i = attributes.begin(); i != attributes.end(); ++i )
 782         {
 783                 defaultValues.insert( KeyValues::value_type( ( *i ).first, ( *i ).second.m_value ) );
 784         }
 785 }
 786
 787 void Entity_GetKeyValues_Selected( KeyValues& keyvalues, KeyValues& defaultValues ){
 788         class EntityGetKeyValues : public SelectionSystem::Visitor
 789         {
 790         KeyValues& m_keyvalues;
 791         KeyValues& m_defaultValues;
 792         mutable std::set<Entity*> m_visited;
 793 public:
 794         EntityGetKeyValues( KeyValues& keyvalues, KeyValues& defaultValues )
 795                 : m_keyvalues( keyvalues ), m_defaultValues( defaultValues ){
 796         }
 797         void visit( scene::Instance& instance ) const {
 798                 Entity* entity = Node_getEntity( instance.path().top() );
 799                 if ( entity == 0 && instance.path().size() != 1 ) {
 800                         entity = Node_getEntity( instance.path().parent() );
 801                 }
 802                 if ( entity != 0 && m_visited.insert( entity ).second ) {
 803                         Entity_GetKeyValues( *entity, m_keyvalues, m_defaultValues );
 804                 }
 805         }
 806         } visitor( keyvalues, defaultValues );
 807         GlobalSelectionSystem().foreachSelected( visitor );
 808 }
 809
 810 const char* keyvalues_valueforkey( KeyValues& keyvalues, const char* key ){
 811         KeyValues::iterator i = keyvalues.find( CopiedString( key ) );
 812         if ( i != keyvalues.end() ) {
 813                 return ( *i ).second.c_str();
 814         }
 815         return "";
 816 }
 817
 818 class EntityClassListStoreAppend : public EntityClassVisitor
 819 {
 820 GtkListStore* store;
 821 public:
 822 EntityClassListStoreAppend( GtkListStore* store_ ) : store( store_ ){
 823 }
 824 void visit( EntityClass* e ){
 825         GtkTreeIter iter;
 826         gtk_list_store_append( store, &iter );
 827         gtk_list_store_set( store, &iter, 0, e->name(), 1, e, -1 );
 828 }
 829 };
 830
 831 void EntityClassList_fill(){
 832         EntityClassListStoreAppend append( g_entlist_store );
 833         GlobalEntityClassManager().forEach( append );
 834 }
 835
 836 void EntityClassList_clear(){
 837         gtk_list_store_clear( g_entlist_store );
 838 }
 839
 840 void SetComment( EntityClass* eclass ){
 841         if ( eclass == g_current_comment ) {
 842                 return;
 843         }
 844
 845         g_current_comment = eclass;
 846
 847         GtkTextBuffer* buffer = gtk_text_view_get_buffer( g_entityClassComment );
 848         gtk_text_buffer_set_text( buffer, eclass->comments(), -1 );
 849 }
 850
 851 void SurfaceFlags_setEntityClass( EntityClass* eclass ){
 852         if ( eclass == g_current_flags ) {
 853                 return;
 854         }
 855
 856         g_current_flags = eclass;
 857
 858         int spawnflag_count = 0;
 859
 860         {
 861                 // do a first pass to count the spawn flags, don't touch the widgets, we don't know in what state they are
 862                 for ( int i = 0 ; i < MAX_FLAGS ; i++ )
 863                 {
 864                         if ( eclass->flagnames[i] && eclass->flagnames[i][0] != 0 && strcmp( eclass->flagnames[i],"-" ) ) {
 865                                 spawn_table[spawnflag_count] = i;
 866                                 spawnflag_count++;
 867                         }
 868                 }
 869         }
 870
 871         // disable all remaining boxes
 872         // NOTE: these boxes might not even be on display
 873         {
 874                 for ( int i = 0; i < g_spawnflag_count; ++i )
 875                 {
 876                         GtkWidget* widget = GTK_WIDGET( g_entitySpawnflagsCheck[i] );
 877                         gtk_label_set_text( GTK_LABEL( GTK_BIN( widget )->child ), " " );
 878                         gtk_widget_hide( widget );
 879                         gtk_widget_ref( widget );
 880                         gtk_container_remove( GTK_CONTAINER( g_spawnflagsTable ), widget );
 881                 }
 882         }
 883
 884         g_spawnflag_count = spawnflag_count;
 885
 886         {
 887                 for ( int i = 0; i < g_spawnflag_count; ++i )
 888                 {
 889                         GtkWidget* widget = GTK_WIDGET( g_entitySpawnflagsCheck[i] );
 890                         gtk_widget_show( widget );
 891
 892                         StringOutputStream str( 16 );
 893                         str << LowerCase( eclass->flagnames[spawn_table[i]] );
 894
 895                         gtk_table_attach( g_spawnflagsTable, widget, i % 4, i % 4 + 1, i / 4, i / 4 + 1,
 896                                                           (GtkAttachOptions)( GTK_FILL ),
 897                                                           (GtkAttachOptions)( GTK_FILL ), 0, 0 );
 898                         gtk_widget_unref( widget );
 899
 900                         gtk_label_set_text( GTK_LABEL( GTK_BIN( widget )->child ), str.c_str() );
 901                 }
 902         }
 903 }
 904
 905 void EntityClassList_selectEntityClass( EntityClass* eclass ){
 906         GtkTreeModel* model = GTK_TREE_MODEL( g_entlist_store );
 907         GtkTreeIter iter;
 908         for ( gboolean good = gtk_tree_model_get_iter_first( model, &iter ); good != FALSE; good = gtk_tree_model_iter_next( model, &iter ) )
 909         {
 910                 char* text;
 911                 gtk_tree_model_get( model, &iter, 0, &text, -1 );
 912                 if ( strcmp( text, eclass->name() ) == 0 ) {
 913                         GtkTreeView* view = g_entityClassList;
 914                         GtkTreePath* path = gtk_tree_model_get_path( model, &iter );
 915                         gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
 916                         if ( GTK_WIDGET_REALIZED( view ) ) {
 917                                 gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
 918                         }
 919                         gtk_tree_path_free( path );
 920                         good = FALSE;
 921                 }
 922                 g_free( text );
 923         }
 924 }
 925
 926 void EntityInspector_appendAttribute( const char* name, EntityAttribute& attribute ){
 927         GtkTable* row = DialogRow_new( name, attribute.getWidget() );
 928         DialogVBox_packRow( g_attributeBox, GTK_WIDGET( row ) );
 929 }
 930
 931
 932 template<typename Attribute>
 933 class StatelessAttributeCreator
 934 {
 935 public:
 936 static EntityAttribute* create( const char* name ){
 937         return new Attribute( name );
 938 }
 939 };
 940
 941 class EntityAttributeFactory
 942 {
 943 typedef EntityAttribute* ( *CreateFunc )( const char* name );
 944 typedef std::map<const char*, CreateFunc, RawStringLess> Creators;
 945 Creators m_creators;
 946 public:
 947 EntityAttributeFactory(){
 948         m_creators.insert( Creators::value_type( "string", &StatelessAttributeCreator<StringAttribute>::create ) );
 949         m_creators.insert( Creators::value_type( "color", &StatelessAttributeCreator<StringAttribute>::create ) );
 950         m_creators.insert( Creators::value_type( "integer", &StatelessAttributeCreator<StringAttribute>::create ) );
 951         m_creators.insert( Creators::value_type( "real", &StatelessAttributeCreator<StringAttribute>::create ) );
 952         m_creators.insert( Creators::value_type( "shader", &StatelessAttributeCreator<ShaderAttribute>::create ) );
 953         m_creators.insert( Creators::value_type( "boolean", &StatelessAttributeCreator<BooleanAttribute>::create ) );
 954         m_creators.insert( Creators::value_type( "angle", &StatelessAttributeCreator<AngleAttribute>::create ) );
 955         m_creators.insert( Creators::value_type( "direction", &StatelessAttributeCreator<DirectionAttribute>::create ) );
 956         m_creators.insert( Creators::value_type( "angles", &StatelessAttributeCreator<AnglesAttribute>::create ) );
 957         m_creators.insert( Creators::value_type( "model", &StatelessAttributeCreator<ModelAttribute>::create ) );
 958         m_creators.insert( Creators::value_type( "sound", &StatelessAttributeCreator<SoundAttribute>::create ) );
 959         m_creators.insert( Creators::value_type( "vector3", &StatelessAttributeCreator<Vector3Attribute>::create ) );
 960         m_creators.insert( Creators::value_type( "real3", &StatelessAttributeCreator<Vector3Attribute>::create ) );
 961 }
 962 EntityAttribute* create( const char* type, const char* name ){
 963         Creators::iterator i = m_creators.find( type );
 964         if ( i != m_creators.end() ) {
 965                 return ( *i ).second( name );
 966         }
 967         const ListAttributeType* listType = GlobalEntityClassManager().findListType( type );
 968         if ( listType != 0 ) {
 969                 return new ListAttribute( name, *listType );
 970         }
 971         return 0;
 972 }
 973 };
 974
 975 typedef Static<EntityAttributeFactory> GlobalEntityAttributeFactory;
 976
 977 void EntityInspector_setEntityClass( EntityClass *eclass ){
 978         EntityClassList_selectEntityClass( eclass );
 979         SurfaceFlags_setEntityClass( eclass );
 980
 981         if ( eclass != g_current_attributes ) {
 982                 g_current_attributes = eclass;
 983
 984                 container_remove_all( GTK_CONTAINER( g_attributeBox ) );
 985                 GlobalEntityAttributes_clear();
 986
 987                 for ( EntityClassAttributes::const_iterator i = eclass->m_attributes.begin(); i != eclass->m_attributes.end(); ++i )
 988                 {
 989                         EntityAttribute* attribute = GlobalEntityAttributeFactory::instance().create( ( *i ).second.m_type.c_str(), ( *i ).first.c_str() );
 990                         if ( attribute != 0 ) {
 991                                 g_entityAttributes.push_back( attribute );
 992                                 EntityInspector_appendAttribute( EntityClassAttributePair_getName( *i ), *g_entityAttributes.back() );
 993                         }
 994                 }
 995         }
 996 }
 997
 998 void EntityInspector_updateSpawnflags(){
 999         {
1000                 int f = atoi( SelectedEntity_getValueForKey( "spawnflags" ) );
1001                 for ( int i = 0; i < g_spawnflag_count; ++i )
1002                 {
1003                         int v = !!( f & ( 1 << spawn_table[i] ) );
1004
1005                         toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] ), v );
1006                 }
1007         }
1008         {
1009                 // take care of the remaining ones
1010                 for ( int i = g_spawnflag_count; i < MAX_FLAGS; ++i )
1011                 {
1012                         toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] ), FALSE );
1013                 }
1014         }
1015 }
1016
1017 void EntityInspector_applySpawnflags(){
1018         int f, i, v;
1019         char sz[32];
1020
1021         f = 0;
1022         for ( i = 0; i < g_spawnflag_count; ++i )
1023         {
1024                 v = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( g_entitySpawnflagsCheck[i] ) );
1025                 f |= v << spawn_table[i];
1026         }
1027
1028         sprintf( sz, "%i", f );
1029         const char* value = ( f == 0 ) ? "" : sz;
1030
1031         {
1032                 StringOutputStream command;
1033                 command << "entitySetFlags -flags " << f;
1034                 UndoableCommand undo( "entitySetSpawnflags" );
1035
1036                 Scene_EntitySetKeyValue_Selected( "spawnflags", value );
1037         }
1038 }
1039
1040
1041 void EntityInspector_updateKeyValues(){
1042         g_selectedKeyValues.clear();
1043         g_selectedDefaultKeyValues.clear();
1044         Entity_GetKeyValues_Selected( g_selectedKeyValues, g_selectedDefaultKeyValues );
1045
1046         EntityInspector_setEntityClass( GlobalEntityClassManager().findOrInsert( keyvalues_valueforkey( g_selectedKeyValues, "classname" ), false ) );
1047
1048         EntityInspector_updateSpawnflags();
1049
1050         GtkListStore* store = g_entprops_store;
1051
1052         // save current key/val pair around filling epair box
1053         // row_select wipes it and sets to first in list
1054         CopiedString strKey( gtk_entry_get_text( g_entityKeyEntry ) );
1055         CopiedString strVal( gtk_entry_get_text( g_entityValueEntry ) );
1056
1057         gtk_list_store_clear( store );
1058         // Walk through list and add pairs
1059         for ( KeyValues::iterator i = g_selectedKeyValues.begin(); i != g_selectedKeyValues.end(); ++i )
1060         {
1061                 GtkTreeIter iter;
1062                 gtk_list_store_append( store, &iter );
1063                 StringOutputStream key( 64 );
1064                 key << ( *i ).first.c_str();
1065                 StringOutputStream value( 64 );
1066                 value << ( *i ).second.c_str();
1067                 gtk_list_store_set( store, &iter, 0, key.c_str(), 1, value.c_str(), -1 );
1068         }
1069
1070         gtk_entry_set_text( g_entityKeyEntry, strKey.c_str() );
1071         gtk_entry_set_text( g_entityValueEntry, strVal.c_str() );
1072
1073         for ( EntityAttributes::const_iterator i = g_entityAttributes.begin(); i != g_entityAttributes.end(); ++i )
1074         {
1075                 ( *i )->update();
1076         }
1077 }
1078
1079 class EntityInspectorDraw
1080 {
1081 IdleDraw m_idleDraw;
1082 public:
1083 EntityInspectorDraw() : m_idleDraw( FreeCaller<EntityInspector_updateKeyValues>( ) ){
1084 }
1085 void queueDraw(){
1086         m_idleDraw.queueDraw();
1087 }
1088 };
1089
1090 EntityInspectorDraw g_EntityInspectorDraw;
1091
1092
1093 void EntityInspector_keyValueChanged(){
1094         g_EntityInspectorDraw.queueDraw();
1095 }
1096 void EntityInspector_selectionChanged( const Selectable& ){
1097         EntityInspector_keyValueChanged();
1098 }
1099
1100 // Creates a new entity based on the currently selected brush and entity type.
1101 //
1102 void EntityClassList_createEntity(){
1103         GtkTreeView* view = g_entityClassList;
1104
1105         // find out what type of entity we are trying to create
1106         GtkTreeModel* model;
1107         GtkTreeIter iter;
1108         if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( view ), &model, &iter ) == FALSE ) {
1109                 gtk_MessageBox( gtk_widget_get_toplevel( GTK_WIDGET( g_entityClassList ) ), "You must have a selected class to create an entity", "info" );
1110                 return;
1111         }
1112
1113         char* text;
1114         gtk_tree_model_get( model, &iter, 0, &text, -1 );
1115
1116         {
1117                 StringOutputStream command;
1118                 command << "entityCreate -class " << text;
1119
1120                 UndoableCommand undo( command.c_str() );
1121
1122                 Entity_createFromSelection( text, g_vector3_identity );
1123         }
1124         g_free( text );
1125 }
1126
1127 void EntityInspector_applyKeyValue(){
1128         // Get current selection text
1129         StringOutputStream key( 64 );
1130         key << gtk_entry_get_text( g_entityKeyEntry );
1131         StringOutputStream value( 64 );
1132         value << gtk_entry_get_text( g_entityValueEntry );
1133
1134
1135         // TTimo: if you change the classname to worldspawn you won't merge back in the structural brushes but create a parasite entity
1136         if ( !strcmp( key.c_str(), "classname" ) && !strcmp( value.c_str(), "worldspawn" ) ) {
1137                 gtk_MessageBox( gtk_widget_get_toplevel( GTK_WIDGET( g_entityKeyEntry ) ),  "Cannot change \"classname\" key back to worldspawn.", 0, eMB_OK );
1138                 return;
1139         }
1140
1141
1142         // RR2DO2: we don't want spaces in entity keys
1143         if ( strstr( key.c_str(), " " ) ) {
1144                 gtk_MessageBox( gtk_widget_get_toplevel( GTK_WIDGET( g_entityKeyEntry ) ), "No spaces are allowed in entity keys.", 0, eMB_OK );
1145                 return;
1146         }
1147
1148         if ( strcmp( key.c_str(), "classname" ) == 0 ) {
1149                 StringOutputStream command;
1150                 command << "entitySetClass -class " << value.c_str();
1151                 UndoableCommand undo( command.c_str() );
1152                 Scene_EntitySetClassname_Selected( value.c_str() );
1153         }
1154         else
1155         {
1156                 Scene_EntitySetKeyValue_Selected_Undoable( key.c_str(), value.c_str() );
1157         }
1158 }
1159
1160 void EntityInspector_clearKeyValue(){
1161         // Get current selection text
1162         StringOutputStream key( 64 );
1163         key << gtk_entry_get_text( g_entityKeyEntry );
1164
1165         if ( strcmp( key.c_str(), "classname" ) != 0 ) {
1166                 StringOutputStream command;
1167                 command << "entityDeleteKey -key " << key.c_str();
1168                 UndoableCommand undo( command.c_str() );
1169                 Scene_EntitySetKeyValue_Selected( key.c_str(), "" );
1170         }
1171 }
1172
1173 void EntityInspector_clearAllKeyValues(){
1174         UndoableCommand undo( "entityClear" );
1175
1176         // remove all keys except classname
1177         for ( KeyValues::iterator i = g_selectedKeyValues.begin(); i != g_selectedKeyValues.end(); ++i )
1178         {
1179                 if ( strcmp( ( *i ).first.c_str(), "classname" ) != 0 ) {
1180                         Scene_EntitySetKeyValue_Selected( ( *i ).first.c_str(), "" );
1181                 }
1182         }
1183 }
1184
1185 // =============================================================================
1186 // callbacks
1187
1188 static void EntityClassList_selection_changed( GtkTreeSelection* selection, gpointer data ){
1189         GtkTreeModel* model;
1190         GtkTreeIter selected;
1191         if ( gtk_tree_selection_get_selected( selection, &model, &selected ) ) {
1192                 EntityClass* eclass;
1193                 gtk_tree_model_get( model, &selected, 1, &eclass, -1 );
1194                 if ( eclass != 0 ) {
1195                         SetComment( eclass );
1196                 }
1197         }
1198 }
1199
1200 static gint EntityClassList_button_press( GtkWidget *widget, GdkEventButton *event, gpointer data ){
1201         if ( event->type == GDK_2BUTTON_PRESS ) {
1202                 EntityClassList_createEntity();
1203                 return TRUE;
1204         }
1205         return FALSE;
1206 }
1207
1208 static gint EntityClassList_keypress( GtkWidget* widget, GdkEventKey* event, gpointer data ){
1209         unsigned int code = gdk_keyval_to_upper( event->keyval );
1210
1211         if ( event->keyval == GDK_Return ) {
1212                 EntityClassList_createEntity();
1213                 return TRUE;
1214         }
1215
1216         // select the entity that starts with the key pressed
1217         if ( code <= 'Z' && code >= 'A' ) {
1218                 GtkTreeView* view = g_entityClassList;
1219                 GtkTreeModel* model;
1220                 GtkTreeIter iter;
1221                 if ( gtk_tree_selection_get_selected( gtk_tree_view_get_selection( view ), &model, &iter ) == FALSE
1222                          || gtk_tree_model_iter_next( model, &iter ) == FALSE ) {
1223                         gtk_tree_model_get_iter_first( model, &iter );
1224                 }
1225
1226                 for ( std::size_t count = gtk_tree_model_iter_n_children( model, 0 ); count > 0; --count )
1227                 {
1228                         char* text;
1229                         gtk_tree_model_get( model, &iter, 0, &text, -1 );
1230
1231                         if ( toupper( text[0] ) == (int)code ) {
1232                                 GtkTreePath* path = gtk_tree_model_get_path( model, &iter );
1233                                 gtk_tree_selection_select_path( gtk_tree_view_get_selection( view ), path );
1234                                 if ( GTK_WIDGET_REALIZED( view ) ) {
1235                                         gtk_tree_view_scroll_to_cell( view, path, 0, FALSE, 0, 0 );
1236                                 }
1237                                 gtk_tree_path_free( path );
1238                                 count = 1;
1239                         }
1240
1241                         g_free( text );
1242
1243                         if ( gtk_tree_model_iter_next( model, &iter ) == FALSE ) {
1244                                 gtk_tree_model_get_iter_first( model, &iter );
1245                         }
1246                 }
1247
1248                 return TRUE;
1249         }
1250         return FALSE;
1251 }
1252
1253 static void EntityProperties_selection_changed( GtkTreeSelection* selection, gpointer data ){
1254         // find out what type of entity we are trying to create
1255         GtkTreeModel* model;
1256         GtkTreeIter iter;
1257         if ( gtk_tree_selection_get_selected( selection, &model, &iter ) == FALSE ) {
1258                 return;
1259         }
1260
1261         char* key;
1262         char* val;
1263         gtk_tree_model_get( model, &iter, 0, &key, 1, &val, -1 );
1264
1265         gtk_entry_set_text( g_entityKeyEntry, key );
1266         gtk_entry_set_text( g_entityValueEntry, val );
1267
1268         g_free( key );
1269         g_free( val );
1270 }
1271
1272 static void SpawnflagCheck_toggled( GtkWidget *widget, gpointer data ){
1273         EntityInspector_applySpawnflags();
1274 }
1275
1276 static gint EntityEntry_keypress( GtkEntry* widget, GdkEventKey* event, gpointer data ){
1277         if ( event->keyval == GDK_Return ) {
1278                 if ( widget == g_entityKeyEntry ) {
1279                         gtk_entry_set_text( g_entityValueEntry, "" );
1280                         gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityValueEntry ) );
1281                 }
1282                 else
1283                 {
1284                         EntityInspector_applyKeyValue();
1285                 }
1286                 return TRUE;
1287         }
1288         if ( event->keyval == GDK_Escape ) {
1289                 gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), NULL );
1290                 return TRUE;
1291         }
1292
1293         return FALSE;
1294 }
1295
1296 void EntityInspector_destroyWindow( GtkWidget* widget, gpointer data ){
1297         g_entitysplit1_position = gtk_paned_get_position( GTK_PANED( g_entity_split1 ) );
1298         g_entitysplit2_position = gtk_paned_get_position( GTK_PANED( g_entity_split2 ) );
1299
1300         g_entityInspector_windowConstructed = false;
1301         GlobalEntityAttributes_clear();
1302 }
1303
1304 GtkWidget* EntityInspector_constructWindow( GtkWindow* toplevel ){
1305         GtkWidget* vbox = gtk_vbox_new( FALSE, 2 );
1306         gtk_widget_show( vbox );
1307         gtk_container_set_border_width( GTK_CONTAINER( vbox ), 2 );
1308
1309         g_signal_connect( G_OBJECT( vbox ), "destroy", G_CALLBACK( EntityInspector_destroyWindow ), 0 );
1310
1311         {
1312                 GtkWidget* split1 = gtk_vpaned_new();
1313                 gtk_box_pack_start( GTK_BOX( vbox ), split1, TRUE, TRUE, 0 );
1314                 gtk_widget_show( split1 );
1315
1316                 g_entity_split1 = split1;
1317
1318                 {
1319                         GtkWidget* split2 = gtk_vpaned_new();
1320                         gtk_paned_add1( GTK_PANED( split1 ), split2 );
1321                         gtk_widget_show( split2 );
1322
1323                         g_entity_split2 = split2;
1324
1325                         {
1326                                 // class list
1327                                 GtkWidget* scr = gtk_scrolled_window_new( 0, 0 );
1328                                 gtk_widget_show( scr );
1329                                 gtk_paned_add1( GTK_PANED( split2 ), scr );
1330                                 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
1331                                 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1332
1333                                 {
1334                                         GtkListStore* store = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER );
1335
1336                                         GtkTreeView* view = GTK_TREE_VIEW( gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) ) );
1337                                         gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), FALSE );
1338                                         gtk_tree_view_set_headers_visible( view, FALSE );
1339                                         g_signal_connect( G_OBJECT( view ), "button_press_event", G_CALLBACK( EntityClassList_button_press ), 0 );
1340                                         g_signal_connect( G_OBJECT( view ), "key_press_event", G_CALLBACK( EntityClassList_keypress ), 0 );
1341
1342                                         {
1343                                                 GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
1344                                                 GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Key", renderer, "text", 0, 0 );
1345                                                 gtk_tree_view_append_column( view, column );
1346                                         }
1347
1348                                         {
1349                                                 GtkTreeSelection* selection = gtk_tree_view_get_selection( view );
1350                                                 g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( EntityClassList_selection_changed ), 0 );
1351                                         }
1352
1353                                         gtk_widget_show( GTK_WIDGET( view ) );
1354
1355                                         gtk_container_add( GTK_CONTAINER( scr ), GTK_WIDGET( view ) );
1356
1357                                         g_object_unref( G_OBJECT( store ) );
1358                                         g_entityClassList = view;
1359                                         g_entlist_store = store;
1360                                 }
1361                         }
1362
1363                         {
1364                                 GtkWidget* scr = gtk_scrolled_window_new( 0, 0 );
1365                                 gtk_widget_show( scr );
1366                                 gtk_paned_add2( GTK_PANED( split2 ), scr );
1367                                 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
1368                                 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1369
1370                                 {
1371                                         GtkTextView* text = GTK_TEXT_VIEW( gtk_text_view_new() );
1372                                         gtk_widget_set_size_request( GTK_WIDGET( text ), 0, -1 ); // allow shrinking
1373                                         gtk_text_view_set_wrap_mode( text, GTK_WRAP_WORD );
1374                                         gtk_text_view_set_editable( text, FALSE );
1375                                         gtk_widget_show( GTK_WIDGET( text ) );
1376                                         gtk_container_add( GTK_CONTAINER( scr ), GTK_WIDGET( text ) );
1377                                         g_entityClassComment = text;
1378                                 }
1379                         }
1380                 }
1381
1382                 {
1383                         GtkWidget* split2 = gtk_vpaned_new();
1384                         gtk_paned_add2( GTK_PANED( split1 ), split2 );
1385                         gtk_widget_show( split2 );
1386
1387                         {
1388                                 GtkWidget* vbox2 = gtk_vbox_new( FALSE, 2 );
1389                                 gtk_widget_show( vbox2 );
1390                                 gtk_paned_pack1( GTK_PANED( split2 ), vbox2, FALSE, FALSE );
1391
1392                                 {
1393                                         // Spawnflags (4 colums wide max, or window gets too wide.)
1394                                         GtkTable* table = GTK_TABLE( gtk_table_new( 4, 4, FALSE ) );
1395                                         gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
1396                                         gtk_widget_show( GTK_WIDGET( table ) );
1397
1398                                         g_spawnflagsTable = table;
1399
1400                                         for ( int i = 0; i < MAX_FLAGS; i++ )
1401                                         {
1402                                                 GtkCheckButton* check = GTK_CHECK_BUTTON( gtk_check_button_new_with_label( "" ) );
1403                                                 gtk_widget_ref( GTK_WIDGET( check ) );
1404                                                 g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( g_signal_connect( G_OBJECT( check ), "toggled", G_CALLBACK( SpawnflagCheck_toggled ), 0 ) ) );
1405                                                 g_entitySpawnflagsCheck[i] = check;
1406                                         }
1407                                 }
1408
1409                                 {
1410                                         // key/value list
1411                                         GtkWidget* scr = gtk_scrolled_window_new( 0, 0 );
1412                                         gtk_widget_show( scr );
1413                                         gtk_box_pack_start( GTK_BOX( vbox2 ), scr, TRUE, TRUE, 0 );
1414                                         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1415                                         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scr ), GTK_SHADOW_IN );
1416
1417                                         {
1418                                                 GtkListStore* store = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_STRING );
1419
1420                                                 GtkWidget* view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
1421                                                 gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), FALSE );
1422                                                 gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
1423
1424                                                 {
1425                                                         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
1426                                                         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "", renderer, "text", 0, 0 );
1427                                                         gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
1428                                                 }
1429
1430                                                 {
1431                                                         GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
1432                                                         GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "", renderer, "text", 1, 0 );
1433                                                         gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
1434                                                 }
1435
1436                                                 {
1437                                                         GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
1438                                                         g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( EntityProperties_selection_changed ), 0 );
1439                                                 }
1440
1441                                                 gtk_widget_show( view );
1442
1443                                                 gtk_container_add( GTK_CONTAINER( scr ), view );
1444
1445                                                 g_object_unref( G_OBJECT( store ) );
1446
1447                                                 g_entprops_store = store;
1448                                         }
1449                                 }
1450
1451                                 {
1452                                         // key/value entry
1453                                         GtkTable* table = GTK_TABLE( gtk_table_new( 2, 2, FALSE ) );
1454                                         gtk_widget_show( GTK_WIDGET( table ) );
1455                                         gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( table ), FALSE, TRUE, 0 );
1456                                         gtk_table_set_row_spacings( table, 3 );
1457                                         gtk_table_set_col_spacings( table, 5 );
1458
1459                                         {
1460                                                 GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
1461                                                 gtk_widget_show( GTK_WIDGET( entry ) );
1462                                                 gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 0, 1,
1463                                                                                   (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1464                                                                                   (GtkAttachOptions)( 0 ), 0, 0 );
1465                                                 gtk_widget_set_events( GTK_WIDGET( entry ), GDK_KEY_PRESS_MASK );
1466                                                 g_signal_connect( G_OBJECT( entry ), "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
1467                                                 g_entityKeyEntry = entry;
1468                                         }
1469
1470                                         {
1471                                                 GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
1472                                                 gtk_widget_show( GTK_WIDGET( entry ) );
1473                                                 gtk_table_attach( table, GTK_WIDGET( entry ), 1, 2, 1, 2,
1474                                                                                   (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
1475                                                                                   (GtkAttachOptions)( 0 ), 0, 0 );
1476                                                 gtk_widget_set_events( GTK_WIDGET( entry ), GDK_KEY_PRESS_MASK );
1477                                                 g_signal_connect( G_OBJECT( entry ), "key_press_event", G_CALLBACK( EntityEntry_keypress ), 0 );
1478                                                 g_entityValueEntry = entry;
1479                                         }
1480
1481                                         {
1482                                                 GtkLabel* label = GTK_LABEL( gtk_label_new( "Value" ) );
1483                                                 gtk_widget_show( GTK_WIDGET( label ) );
1484                                                 gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 1, 2,
1485                                                                                   (GtkAttachOptions)( GTK_FILL ),
1486                                                                                   (GtkAttachOptions)( 0 ), 0, 0 );
1487                                                 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
1488                                         }
1489
1490                                         {
1491                                                 GtkLabel* label = GTK_LABEL( gtk_label_new( "Key" ) );
1492                                                 gtk_widget_show( GTK_WIDGET( label ) );
1493                                                 gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 0, 1,
1494                                                                                   (GtkAttachOptions)( GTK_FILL ),
1495                                                                                   (GtkAttachOptions)( 0 ), 0, 0 );
1496                                                 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
1497                                         }
1498                                 }
1499
1500                                 {
1501                                         GtkBox* hbox = GTK_BOX( gtk_hbox_new( TRUE, 4 ) );
1502                                         gtk_widget_show( GTK_WIDGET( hbox ) );
1503                                         gtk_box_pack_start( GTK_BOX( vbox2 ), GTK_WIDGET( hbox ), FALSE, TRUE, 0 );
1504
1505                                         {
1506                                                 GtkButton* button = GTK_BUTTON( gtk_button_new_with_label( "Clear All" ) );
1507                                                 gtk_widget_show( GTK_WIDGET( button ) );
1508                                                 g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( EntityInspector_clearAllKeyValues ), 0 );
1509                                                 gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
1510                                         }
1511                                         {
1512                                                 GtkButton* button = GTK_BUTTON( gtk_button_new_with_label( "Delete Key" ) );
1513                                                 gtk_widget_show( GTK_WIDGET( button ) );
1514                                                 g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( EntityInspector_clearKeyValue ), 0 );
1515                                                 gtk_box_pack_start( hbox, GTK_WIDGET( button ), TRUE, TRUE, 0 );
1516                                         }
1517                                 }
1518                         }
1519
1520                         {
1521                                 GtkWidget* scr = gtk_scrolled_window_new( 0, 0 );
1522                                 gtk_widget_show( scr );
1523                                 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scr ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
1524
1525                                 GtkWidget* viewport = gtk_viewport_new( 0, 0 );
1526                                 gtk_widget_show( viewport );
1527                                 gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport ), GTK_SHADOW_NONE );
1528
1529                                 g_attributeBox = GTK_VBOX( gtk_vbox_new( FALSE, 2 ) );
1530                                 gtk_widget_show( GTK_WIDGET( g_attributeBox ) );
1531
1532                                 gtk_container_add( GTK_CONTAINER( viewport ), GTK_WIDGET( g_attributeBox ) );
1533                                 gtk_container_add( GTK_CONTAINER( scr ), viewport );
1534                                 gtk_paned_pack2( GTK_PANED( split2 ), scr, FALSE, FALSE );
1535                         }
1536                 }
1537         }
1538
1539
1540         {
1541                 // show the sliders in any case
1542                 if ( g_entitysplit2_position > 22 ) {
1543                         gtk_paned_set_position( GTK_PANED( g_entity_split2 ), g_entitysplit2_position );
1544                 }
1545                 else {
1546                         g_entitysplit2_position = 22;
1547                         gtk_paned_set_position( GTK_PANED( g_entity_split2 ), 22 );
1548                 }
1549                 if ( ( g_entitysplit1_position - g_entitysplit2_position ) > 27 ) {
1550                         gtk_paned_set_position( GTK_PANED( g_entity_split1 ), g_entitysplit1_position );
1551                 }
1552                 else {
1553                         gtk_paned_set_position( GTK_PANED( g_entity_split1 ), g_entitysplit2_position + 27 );
1554                 }
1555         }
1556
1557         g_entityInspector_windowConstructed = true;
1558         EntityClassList_fill();
1559
1560         typedef FreeCaller1<const Selectable&, EntityInspector_selectionChanged> EntityInspectorSelectionChangedCaller;
1561         GlobalSelectionSystem().addSelectionChangeCallback( EntityInspectorSelectionChangedCaller() );
1562         GlobalEntityCreator().setKeyValueChangedFunc( EntityInspector_keyValueChanged );
1563
1564         // hack
1565         gtk_container_set_focus_chain( GTK_CONTAINER( vbox ), NULL );
1566
1567         return vbox;
1568 }
1569
1570 class EntityInspector : public ModuleObserver
1571 {
1572 std::size_t m_unrealised;
1573 public:
1574 EntityInspector() : m_unrealised( 1 ){
1575 }
1576 void realise(){
1577         if ( --m_unrealised == 0 ) {
1578                 if ( g_entityInspector_windowConstructed ) {
1579                         //globalOutputStream() << "Entity Inspector: realise\n";
1580                         EntityClassList_fill();
1581                 }
1582         }
1583 }
1584 void unrealise(){
1585         if ( ++m_unrealised == 1 ) {
1586                 if ( g_entityInspector_windowConstructed ) {
1587                         //globalOutputStream() << "Entity Inspector: unrealise\n";
1588                         EntityClassList_clear();
1589                 }
1590         }
1591 }
1592 };
1593
1594 EntityInspector g_EntityInspector;
1595
1596 #include "preferencesystem.h"
1597 #include "stringio.h"
1598
1599 void EntityInspector_construct(){
1600         GlobalEntityClassManager().attach( g_EntityInspector );
1601
1602         GlobalPreferenceSystem().registerPreference( "EntitySplit1", IntImportStringCaller( g_entitysplit1_position ), IntExportStringCaller( g_entitysplit1_position ) );
1603         GlobalPreferenceSystem().registerPreference( "EntitySplit2", IntImportStringCaller( g_entitysplit2_position ), IntExportStringCaller( g_entitysplit2_position ) );
1604
1605 }
1606
1607 void EntityInspector_destroy(){
1608         GlobalEntityClassManager().detach( g_EntityInspector );
1609 }
1610
1611 const char *EntityInspector_getCurrentKey(){
1612         if ( !GroupDialog_isShown() ) {
1613                 return 0;
1614         }
1615         if ( GroupDialog_getPage() != g_page_entity ) {
1616                 return 0;
1617         }
1618         return gtk_entry_get_text( g_entityKeyEntry );
1619 }