radiant/entitylist.cpp

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   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 "entitylist.h"
  23
  24 #include "iselection.h"
  25
  26 #include <uilib/uilib.h>
  27 #include <gtk/gtk.h>
  28 #include <gtk/gtkcheckbutton.h>
  29
  30 #include "string/string.h"
  31 #include "scenelib.h"
  32 #include "nameable.h"
  33 #include "signal/isignal.h"
  34 #include "generic/object.h"
  35
  36 #include "gtkutil/widget.h"
  37 #include "gtkutil/window.h"
  38 #include "gtkutil/idledraw.h"
  39 #include "gtkutil/accelerator.h"
  40 #include "gtkutil/closure.h"
  41
  42 #include "treemodel.h"
  43
  44 #include "mainframe.h"
  45
  46 void RedrawEntityList();
  47 typedef FreeCaller<void(), RedrawEntityList> RedrawEntityListCaller;
  48
  49
  50 class EntityList
  51 {
  52 public:
  53 enum EDirty
  54 {
  55         eDefault,
  56         eSelection,
  57         eInsertRemove,
  58 };
  59
  60 EDirty m_dirty;
  61
  62 IdleDraw m_idleDraw;
  63 WindowPositionTracker m_positionTracker;
  64
  65 ui::Window m_window;
  66 ui::Widget m_check;
  67 ui::TreeView m_tree_view{ui::null};
  68 ui::TreeModel m_tree_model{ui::null};
  69 bool m_selection_disabled;
  70
  71 EntityList() :
  72         m_dirty( EntityList::eDefault ),
  73         m_idleDraw( RedrawEntityListCaller() ),
  74         m_window( ui::null ),
  75         m_check( ui::null ),
  76         m_selection_disabled( false ){
  77 }
  78
  79 bool visible() {
  80         return m_window.visible();
  81 }
  82 };
  83
  84 namespace
  85 {
  86 EntityList* g_EntityList;
  87
  88 inline EntityList& getEntityList(){
  89         ASSERT_NOTNULL( g_EntityList );
  90         return *g_EntityList;
  91 }
  92 }
  93
  94
  95 inline Nameable* Node_getNameable( scene::Node& node ){
  96         return NodeTypeCast<Nameable>::cast( node );
  97 }
  98
  99 const char* node_get_name( scene::Node& node ){
 100         Nameable* nameable = Node_getNameable( node );
 101         return ( nameable != 0 )
 102                    ? nameable->name()
 103                    : "node";
 104 }
 105
 106 template<typename value_type>
 107 inline void gtk_tree_model_get_pointer( ui::TreeModel model, GtkTreeIter* iter, gint column, value_type** pointer ){
 108         GValue value = GValue_default();
 109         gtk_tree_model_get_value( model, iter, column, &value );
 110         *pointer = (value_type*)g_value_get_pointer( &value );
 111 }
 112
 113
 114
 115 void entitylist_treeviewcolumn_celldatafunc( ui::TreeViewColumn column, ui::CellRenderer renderer, ui::TreeModel model, GtkTreeIter* iter, gpointer data ){
 116         scene::Node* node;
 117         gtk_tree_model_get_pointer( model, iter, 0, &node );
 118         scene::Instance* instance;
 119         gtk_tree_model_get_pointer( model, iter, 1, &instance );
 120         if ( node != 0 ) {
 121                 gtk_cell_renderer_set_fixed_size( renderer, -1, -1 );
 122                 char* name = const_cast<char*>( node_get_name( *node ) );
 123                 g_object_set( G_OBJECT( renderer ), "text", name, "visible", TRUE, NULL );
 124
 125                 //globalOutputStream() << "rendering cell " << makeQuoted(name) << "\n";
 126                 auto style = gtk_widget_get_style( ui::TreeView( getEntityList().m_tree_view ) );
 127                 if ( instance->childSelected() ) {
 128                         g_object_set( G_OBJECT( renderer ), "cell-background-gdk", &style->base[GTK_STATE_ACTIVE], NULL );
 129                 }
 130                 else
 131                 {
 132                         g_object_set( G_OBJECT( renderer ), "cell-background-gdk", &style->base[GTK_STATE_NORMAL], NULL );
 133                 }
 134         }
 135         else
 136         {
 137                 gtk_cell_renderer_set_fixed_size( renderer, -1, 0 );
 138                 g_object_set( G_OBJECT( renderer ), "text", "", "visible", FALSE, NULL );
 139         }
 140 }
 141
 142 static gboolean entitylist_tree_select( ui::TreeSelection selection, ui::TreeModel model, ui::TreePath path, gboolean path_currently_selected, gpointer data ){
 143         GtkTreeIter iter;
 144         gtk_tree_model_get_iter( model, &iter, path );
 145         scene::Node* node;
 146         gtk_tree_model_get_pointer( model, &iter, 0, &node );
 147         scene::Instance* instance;
 148         gtk_tree_model_get_pointer( model, &iter, 1, &instance );
 149         Selectable* selectable = Instance_getSelectable( *instance );
 150
 151         if ( node == 0 ) {
 152                 if ( path_currently_selected != FALSE ) {
 153                         getEntityList().m_selection_disabled = true;
 154                         GlobalSelectionSystem().setSelectedAll( false );
 155                         getEntityList().m_selection_disabled = false;
 156                 }
 157         }
 158         else if ( selectable != 0 ) {
 159                 getEntityList().m_selection_disabled = true;
 160                 selectable->setSelected( path_currently_selected == FALSE );
 161                 getEntityList().m_selection_disabled = false;
 162                 if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( getEntityList().m_check ) ) ){
 163                         FocusAllViews();
 164                 }
 165                 return TRUE;
 166         }
 167
 168         return FALSE;
 169 }
 170
 171 static gboolean entitylist_tree_select_null( ui::TreeSelection selection, ui::TreeModel model, ui::TreePath path, gboolean path_currently_selected, gpointer data ){
 172         return TRUE;
 173 }
 174
 175 void EntityList_ConnectSignals( ui::TreeView view ){
 176         auto select = gtk_tree_view_get_selection( view );
 177         gtk_tree_selection_set_select_function(select, reinterpret_cast<GtkTreeSelectionFunc>(entitylist_tree_select), NULL, 0 );
 178 }
 179
 180 void EntityList_DisconnectSignals( ui::TreeView view ){
 181         auto select = gtk_tree_view_get_selection( view );
 182         gtk_tree_selection_set_select_function(select, reinterpret_cast<GtkTreeSelectionFunc>(entitylist_tree_select_null), 0, 0 );
 183 }
 184
 185
 186
 187 gboolean treemodel_update_selection( ui::TreeModel model, ui::TreePath path, GtkTreeIter* iter, gpointer data ){
 188         auto view = ui::TreeView::from( data );
 189
 190         scene::Instance* instance;
 191         gtk_tree_model_get_pointer( model, iter, 1, &instance );
 192         Selectable* selectable = Instance_getSelectable( *instance );
 193
 194         if ( selectable != 0 ) {
 195                 auto selection = gtk_tree_view_get_selection( view );
 196                 if ( selectable->isSelected() ) {
 197                         gtk_tree_selection_select_path( selection, path );
 198                 }
 199                 else
 200                 {
 201                         gtk_tree_selection_unselect_path( selection, path );
 202                 }
 203         }
 204
 205         return FALSE;
 206 }
 207
 208 void EntityList_UpdateSelection( ui::TreeModel model, ui::TreeView view ){
 209         EntityList_DisconnectSignals( view );
 210         gtk_tree_model_foreach(model, reinterpret_cast<GtkTreeModelForeachFunc>(treemodel_update_selection), view._handle );
 211         EntityList_ConnectSignals( view );
 212 }
 213
 214
 215 void RedrawEntityList(){
 216         switch ( getEntityList().m_dirty )
 217         {
 218         case EntityList::eInsertRemove:
 219         case EntityList::eSelection:
 220                 EntityList_UpdateSelection( getEntityList().m_tree_model, getEntityList().m_tree_view );
 221         default:
 222                 break;
 223         }
 224         getEntityList().m_dirty = EntityList::eDefault;
 225 }
 226
 227 void entitylist_queue_draw(){
 228         getEntityList().m_idleDraw.queueDraw();
 229 }
 230
 231 void EntityList_SelectionUpdate(){
 232         if ( getEntityList().m_selection_disabled ) {
 233                 return;
 234         }
 235
 236         if ( getEntityList().m_dirty < EntityList::eSelection ) {
 237                 getEntityList().m_dirty = EntityList::eSelection;
 238         }
 239         entitylist_queue_draw();
 240 }
 241
 242 void EntityList_SelectionChanged( const Selectable& selectable ){
 243         EntityList_SelectionUpdate();
 244 }
 245
 246 void entitylist_treeview_rowcollapsed( ui::TreeView view, GtkTreeIter* iter, ui::TreePath path, gpointer user_data ){
 247 }
 248
 249 void entitylist_treeview_row_expanded( ui::TreeView view, GtkTreeIter* iter, ui::TreePath path, gpointer user_data ){
 250         EntityList_SelectionUpdate();
 251 }
 252
 253
 254 void EntityList_SetShown( bool shown ){
 255         getEntityList().m_window.visible(shown);
 256 }
 257
 258 void EntityList_toggleShown(){
 259         EntityList_SetShown( !getEntityList().visible() );
 260 }
 261
 262 gint graph_tree_model_compare_name( ui::TreeModel model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data ){
 263         scene::Node* first;
 264         gtk_tree_model_get( model, a, 0, (gpointer*)&first, -1 );
 265         scene::Node* second;
 266         gtk_tree_model_get( model, b, 0, (gpointer*)&second, -1 );
 267         int result = 0;
 268         if ( first != 0 && second != 0 ) {
 269                 result = string_compare( node_get_name( *first ), node_get_name( *second ) );
 270         }
 271         if ( result == 0 ) {
 272                 return ( first < second ) ? -1 : ( second < first ) ? 1 : 0;
 273         }
 274         return result;
 275 }
 276
 277 extern GraphTreeModel* scene_graph_get_tree_model();
 278 void AttachEntityTreeModel(){
 279         getEntityList().m_tree_model = ui::TreeModel::from(scene_graph_get_tree_model());
 280
 281         gtk_tree_view_set_model( getEntityList().m_tree_view, getEntityList().m_tree_model );
 282 }
 283
 284 void DetachEntityTreeModel(){
 285         getEntityList().m_tree_model = ui::TreeModel(ui::null);
 286
 287         gtk_tree_view_set_model( getEntityList().m_tree_view, 0 );
 288 }
 289
 290 void EntityList_constructWindow( ui::Window main_window ){
 291         ASSERT_TRUE( !getEntityList().m_window );
 292
 293         auto window = ui::Window(create_persistent_floating_window( "Entity List", main_window ));
 294
 295         window.add_accel_group(global_accel);
 296
 297         getEntityList().m_positionTracker.connect( window );
 298
 299
 300         getEntityList().m_window = window;
 301
 302         {
 303                 ui::VBox vbox = ui::VBox( FALSE, 0 );
 304                 gtk_container_set_border_width( GTK_CONTAINER( vbox ), 0 );
 305                 vbox.show();
 306                 window.add( vbox );
 307
 308                 auto scr = create_scrolled_window( ui::Policy::AUTOMATIC, ui::Policy::AUTOMATIC );
 309                 vbox.pack_start( scr, TRUE, TRUE, 0 );
 310
 311                 {
 312             auto view = ui::TreeView(ui::New);
 313                         gtk_tree_view_set_headers_visible(view, FALSE );
 314
 315                         auto renderer = ui::CellRendererText(ui::New);
 316                         auto column = gtk_tree_view_column_new();
 317                         gtk_tree_view_column_pack_start( column, renderer, TRUE );
 318                         gtk_tree_view_column_set_cell_data_func(column, renderer, reinterpret_cast<GtkTreeCellDataFunc>(entitylist_treeviewcolumn_celldatafunc), 0, 0 );
 319
 320                         auto select = gtk_tree_view_get_selection(view );
 321                         gtk_tree_selection_set_mode( select, GTK_SELECTION_MULTIPLE );
 322
 323                         view.connect( "row_expanded", G_CALLBACK( entitylist_treeview_row_expanded ), 0 );
 324                         view.connect( "row_collapsed", G_CALLBACK( entitylist_treeview_rowcollapsed ), 0 );
 325
 326                         gtk_tree_view_append_column(view, column );
 327
 328                         view.show();
 329                         scr.add(view);
 330                         getEntityList().m_tree_view = view;
 331                 }
 332                 {
 333                         ui::Widget check = ui::Widget::from( gtk_check_button_new_with_label( "Focus on Selected" ) );
 334                         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( check ), FALSE );
 335                         check.show();
 336                         vbox.pack_start( check, FALSE, FALSE, 0 );
 337                         getEntityList().m_check = check;
 338                 }
 339         }
 340
 341         EntityList_ConnectSignals( getEntityList().m_tree_view );
 342         AttachEntityTreeModel();
 343 }
 344
 345 void EntityList_destroyWindow(){
 346         DetachEntityTreeModel();
 347         EntityList_DisconnectSignals( getEntityList().m_tree_view );
 348         destroy_floating_window( getEntityList().m_window );
 349 }
 350
 351 #include "preferencesystem.h"
 352
 353 #include "iselection.h"
 354
 355 namespace
 356 {
 357 scene::Node* nullNode = 0;
 358 }
 359
 360 class NullSelectedInstance : public scene::Instance, public Selectable
 361 {
 362 class TypeCasts
 363 {
 364 InstanceTypeCastTable m_casts;
 365 public:
 366 TypeCasts(){
 367         InstanceStaticCast<NullSelectedInstance, Selectable>::install( m_casts );
 368 }
 369 InstanceTypeCastTable& get(){
 370         return m_casts;
 371 }
 372 };
 373
 374 public:
 375 typedef LazyStatic<TypeCasts> StaticTypeCasts;
 376
 377 NullSelectedInstance() : Instance( scene::Path( makeReference( *nullNode ) ), 0, this, StaticTypeCasts::instance().get() ){
 378 }
 379
 380 void setSelected( bool select ){
 381         ERROR_MESSAGE( "error" );
 382 }
 383 bool isSelected() const {
 384         return true;
 385 }
 386 };
 387
 388 typedef LazyStatic<NullSelectedInstance> StaticNullSelectedInstance;
 389
 390
 391 void EntityList_Construct(){
 392         graph_tree_model_insert( scene_graph_get_tree_model(), StaticNullSelectedInstance::instance() );
 393
 394         g_EntityList = new EntityList;
 395
 396         getEntityList().m_positionTracker.setPosition( c_default_window_pos );
 397
 398         GlobalPreferenceSystem().registerPreference( "EntityInfoDlg", make_property<WindowPositionTracker_String>( getEntityList().m_positionTracker ) );
 399
 400         typedef FreeCaller<void(const Selectable&), EntityList_SelectionChanged> EntityListSelectionChangedCaller;
 401         GlobalSelectionSystem().addSelectionChangeCallback( EntityListSelectionChangedCaller() );
 402 }
 403 void EntityList_Destroy(){
 404         delete g_EntityList;
 405
 406         graph_tree_model_erase( scene_graph_get_tree_model(), StaticNullSelectedInstance::instance() );
 407 }