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