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