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