X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=radiant%2Fentitylist.cpp;h=c13d8d6c674ffb2193f388bbc607b8e89df2ca22;hb=1f9ff6307712d98d9d36e288c9134219407e3690;hp=dad00e4e0c8780950e526fd498e9ad0c37341af0;hpb=a726c43661057f338f342f13c93ee0fe76698cf7;p=xonotic%2Fnetradiant.git

diff --git a/radiant/entitylist.cpp b/radiant/entitylist.cpp
index dad00e4e..c13d8d6c 100644
--- a/radiant/entitylist.cpp
+++ b/radiant/entitylist.cpp
@@ -41,347 +41,377 @@
 #include "treemodel.h"
 
 void RedrawEntityList();
-typedef FreeCaller<RedrawEntityList> RedrawEntityListCaller;
 
+typedef FreeCaller<void(), RedrawEntityList> RedrawEntityListCaller;
 
-class EntityList
-{
+
+class EntityList {
 public:
-enum EDirty
-{
-	eDefault,
-	eSelection,
-	eInsertRemove,
+    enum EDirty {
+        eDefault,
+        eSelection,
+        eInsertRemove,
+    };
+
+    EDirty m_dirty;
+
+    IdleDraw m_idleDraw;
+    WindowPositionTracker m_positionTracker;
+
+    ui::Window m_window;
+    ui::TreeView m_tree_view{ui::null};
+    ui::TreeModel m_tree_model{ui::null};
+    bool m_selection_disabled;
+
+    EntityList() :
+            m_dirty(EntityList::eDefault),
+            m_idleDraw(RedrawEntityListCaller()),
+            m_window(ui::null),
+            m_selection_disabled(false)
+    {
+    }
+
+    bool visible()
+    {
+        return m_window.visible();
+    }
 };
 
-EDirty m_dirty;
-
-IdleDraw m_idleDraw;
-WindowPositionTracker m_positionTracker;
+namespace {
+    EntityList *g_EntityList;
 
-ui::Window m_window;
-GtkTreeView* m_tree_view;
-GraphTreeModel* m_tree_model;
-bool m_selection_disabled;
-
-EntityList() :
-	m_dirty( EntityList::eDefault ),
-	m_idleDraw( RedrawEntityListCaller() ),
-	m_window( 0 ),
-	m_selection_disabled( false ){
+    inline EntityList &getEntityList()
+    {
+        ASSERT_NOTNULL(g_EntityList);
+        return *g_EntityList;
+    }
 }
 
-bool visible() const {
-	return gtk_widget_get_visible( m_window );
-}
-};
 
-namespace
+inline Nameable *Node_getNameable(scene::Node &node)
 {
-EntityList* g_EntityList;
-
-inline EntityList& getEntityList(){
-	ASSERT_NOTNULL( g_EntityList );
-	return *g_EntityList;
-}
-}
-
-
-inline Nameable* Node_getNameable( scene::Node& node ){
-	return NodeTypeCast<Nameable>::cast( node );
+    return NodeTypeCast<Nameable>::cast(node);
 }
 
-const char* node_get_name( scene::Node& node ){
-	Nameable* nameable = Node_getNameable( node );
-	return ( nameable != 0 )
-		   ? nameable->name()
-		   : "node";
+const char *node_get_name(scene::Node &node)
+{
+    Nameable *nameable = Node_getNameable(node);
+    return (nameable != 0)
+           ? nameable->name()
+           : "node";
 }
 
 template<typename value_type>
-inline void gtk_tree_model_get_pointer( GtkTreeModel* model, GtkTreeIter* iter, gint column, value_type** pointer ){
-	GValue value = GValue_default();
-	gtk_tree_model_get_value( model, iter, column, &value );
-	*pointer = (value_type*)g_value_get_pointer( &value );
-}
-
-
-
-void entitylist_treeviewcolumn_celldatafunc( GtkTreeViewColumn* column, GtkCellRenderer* renderer, GtkTreeModel* model, GtkTreeIter* iter, gpointer data ){
-	scene::Node* node;
-	gtk_tree_model_get_pointer( model, iter, 0, &node );
-	scene::Instance* instance;
-	gtk_tree_model_get_pointer( model, iter, 1, &instance );
-	if ( node != 0 ) {
-		gtk_cell_renderer_set_fixed_size( renderer, -1, -1 );
-		char* name = const_cast<char*>( node_get_name( *node ) );
-		g_object_set( G_OBJECT( renderer ), "text", name, "visible", TRUE, NULL );
-
-		//globalOutputStream() << "rendering cell " << makeQuoted(name) << "\n";
-		GtkStyle* style = gtk_widget_get_style( GTK_WIDGET( getEntityList().m_tree_view ) );
-		if ( instance->childSelected() ) {
-			g_object_set( G_OBJECT( renderer ), "cell-background-gdk", &style->base[GTK_STATE_ACTIVE], NULL );
-		}
-		else
-		{
-			g_object_set( G_OBJECT( renderer ), "cell-background-gdk", &style->base[GTK_STATE_NORMAL], NULL );
-		}
-	}
-	else
-	{
-		gtk_cell_renderer_set_fixed_size( renderer, -1, 0 );
-		g_object_set( G_OBJECT( renderer ), "text", "", "visible", FALSE, NULL );
-	}
+inline void gtk_tree_model_get_pointer(ui::TreeModel model, GtkTreeIter *iter, gint column, value_type **pointer)
+{
+    GValue value = GValue_default();
+    gtk_tree_model_get_value(model, iter, column, &value);
+    *pointer = (value_type *) g_value_get_pointer(&value);
 }
 
-static gboolean entitylist_tree_select( GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data ){
-	GtkTreeIter iter;
-	gtk_tree_model_get_iter( model, &iter, path );
-	scene::Node* node;
-	gtk_tree_model_get_pointer( model, &iter, 0, &node );
-	scene::Instance* instance;
-	gtk_tree_model_get_pointer( model, &iter, 1, &instance );
-	Selectable* selectable = Instance_getSelectable( *instance );
-
-	if ( node == 0 ) {
-		if ( path_currently_selected != FALSE ) {
-			getEntityList().m_selection_disabled = true;
-			GlobalSelectionSystem().setSelectedAll( false );
-			getEntityList().m_selection_disabled = false;
-		}
-	}
-	else if ( selectable != 0 ) {
-		getEntityList().m_selection_disabled = true;
-		selectable->setSelected( path_currently_selected == FALSE );
-		getEntityList().m_selection_disabled = false;
-		return TRUE;
-	}
-
-	return FALSE;
-}
 
-static gboolean entitylist_tree_select_null( GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer data ){
-	return TRUE;
+void entitylist_treeviewcolumn_celldatafunc(ui::TreeViewColumn column, ui::CellRenderer renderer, ui::TreeModel model,
+                                            GtkTreeIter *iter, gpointer data)
+{
+    scene::Node *node;
+    gtk_tree_model_get_pointer(model, iter, 0, &node);
+    scene::Instance *instance;
+    gtk_tree_model_get_pointer(model, iter, 1, &instance);
+    if (node != 0) {
+        gtk_cell_renderer_set_fixed_size(renderer, -1, -1);
+        char *name = const_cast<char *>( node_get_name(*node));
+        g_object_set(G_OBJECT(renderer), "text", name, "visible", TRUE, NULL);
+
+        //globalOutputStream() << "rendering cell " << makeQuoted(name) << "\n";
+        auto style = gtk_widget_get_style(ui::TreeView(getEntityList().m_tree_view));
+        if (instance->childSelected()) {
+            g_object_set(G_OBJECT(renderer), "cell-background-gdk", &style->base[GTK_STATE_ACTIVE], NULL);
+        } else {
+            g_object_set(G_OBJECT(renderer), "cell-background-gdk", &style->base[GTK_STATE_NORMAL], NULL);
+        }
+    } else {
+        gtk_cell_renderer_set_fixed_size(renderer, -1, 0);
+        g_object_set(G_OBJECT(renderer), "text", "", "visible", FALSE, NULL);
+    }
+}
+
+static gboolean entitylist_tree_select(ui::TreeSelection selection, ui::TreeModel model, ui::TreePath path,
+                                       gboolean path_currently_selected, gpointer data)
+{
+    GtkTreeIter iter;
+    gtk_tree_model_get_iter(model, &iter, path);
+    scene::Node *node;
+    gtk_tree_model_get_pointer(model, &iter, 0, &node);
+    scene::Instance *instance;
+    gtk_tree_model_get_pointer(model, &iter, 1, &instance);
+    Selectable *selectable = Instance_getSelectable(*instance);
+
+    if (node == 0) {
+        if (path_currently_selected != FALSE) {
+            getEntityList().m_selection_disabled = true;
+            GlobalSelectionSystem().setSelectedAll(false);
+            getEntityList().m_selection_disabled = false;
+        }
+    } else if (selectable != 0) {
+        getEntityList().m_selection_disabled = true;
+        selectable->setSelected(path_currently_selected == FALSE);
+        getEntityList().m_selection_disabled = false;
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static gboolean entitylist_tree_select_null(ui::TreeSelection selection, ui::TreeModel model, ui::TreePath path,
+                                            gboolean path_currently_selected, gpointer data)
+{
+    return TRUE;
 }
 
-void EntityList_ConnectSignals( GtkTreeView* view ){
-	GtkTreeSelection* select = gtk_tree_view_get_selection( view );
-	gtk_tree_selection_set_select_function( select, entitylist_tree_select, NULL, 0 );
+void EntityList_ConnectSignals(ui::TreeView view)
+{
+    auto select = gtk_tree_view_get_selection(view);
+    gtk_tree_selection_set_select_function(select, reinterpret_cast<GtkTreeSelectionFunc>(entitylist_tree_select), NULL,
+                                           0);
 }
 
-void EntityList_DisconnectSignals( GtkTreeView* view ){
-	GtkTreeSelection* select = gtk_tree_view_get_selection( view );
-	gtk_tree_selection_set_select_function( select, entitylist_tree_select_null, 0, 0 );
+void EntityList_DisconnectSignals(ui::TreeView view)
+{
+    auto select = gtk_tree_view_get_selection(view);
+    gtk_tree_selection_set_select_function(select, reinterpret_cast<GtkTreeSelectionFunc>(entitylist_tree_select_null),
+                                           0, 0);
 }
 
 
+gboolean treemodel_update_selection(ui::TreeModel model, ui::TreePath path, GtkTreeIter *iter, gpointer data)
+{
+    auto view = ui::TreeView::from(data);
 
-gboolean treemodel_update_selection( GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data ){
-	GtkTreeView* view = reinterpret_cast<GtkTreeView*>( data );
-
-	scene::Instance* instance;
-	gtk_tree_model_get_pointer( model, iter, 1, &instance );
-	Selectable* selectable = Instance_getSelectable( *instance );
+    scene::Instance *instance;
+    gtk_tree_model_get_pointer(model, iter, 1, &instance);
+    Selectable *selectable = Instance_getSelectable(*instance);
 
-	if ( selectable != 0 ) {
-		GtkTreeSelection* selection = gtk_tree_view_get_selection( view );
-		if ( selectable->isSelected() ) {
-			gtk_tree_selection_select_path( selection, path );
-		}
-		else
-		{
-			gtk_tree_selection_unselect_path( selection, path );
-		}
-	}
+    if (selectable != 0) {
+        auto selection = gtk_tree_view_get_selection(view);
+        if (selectable->isSelected()) {
+            gtk_tree_selection_select_path(selection, path);
+        } else {
+            gtk_tree_selection_unselect_path(selection, path);
+        }
+    }
 
-	return FALSE;
+    return FALSE;
 }
 
-void EntityList_UpdateSelection( GtkTreeModel* model, GtkTreeView* view ){
-	EntityList_DisconnectSignals( view );
-	gtk_tree_model_foreach( model, treemodel_update_selection, view );
-	EntityList_ConnectSignals( view );
+void EntityList_UpdateSelection(ui::TreeModel model, ui::TreeView view)
+{
+    EntityList_DisconnectSignals(view);
+    gtk_tree_model_foreach(model, reinterpret_cast<GtkTreeModelForeachFunc>(treemodel_update_selection), view._handle);
+    EntityList_ConnectSignals(view);
 }
 
 
-void RedrawEntityList(){
-	switch ( getEntityList().m_dirty )
-	{
-	case EntityList::eInsertRemove:
-	case EntityList::eSelection:
-		EntityList_UpdateSelection( GTK_TREE_MODEL( getEntityList().m_tree_model ), getEntityList().m_tree_view );
-	default:
-		break;
-	}
-	getEntityList().m_dirty = EntityList::eDefault;
+void RedrawEntityList()
+{
+    switch (getEntityList().m_dirty) {
+        case EntityList::eInsertRemove:
+        case EntityList::eSelection:
+            EntityList_UpdateSelection(getEntityList().m_tree_model, getEntityList().m_tree_view);
+        default:
+            break;
+    }
+    getEntityList().m_dirty = EntityList::eDefault;
 }
 
-void entitylist_queue_draw(){
-	getEntityList().m_idleDraw.queueDraw();
+void entitylist_queue_draw()
+{
+    getEntityList().m_idleDraw.queueDraw();
 }
 
-void EntityList_SelectionUpdate(){
-	if ( getEntityList().m_selection_disabled ) {
-		return;
-	}
+void EntityList_SelectionUpdate()
+{
+    if (getEntityList().m_selection_disabled) {
+        return;
+    }
 
-	if ( getEntityList().m_dirty < EntityList::eSelection ) {
-		getEntityList().m_dirty = EntityList::eSelection;
-	}
-	entitylist_queue_draw();
+    if (getEntityList().m_dirty < EntityList::eSelection) {
+        getEntityList().m_dirty = EntityList::eSelection;
+    }
+    entitylist_queue_draw();
 }
 
-void EntityList_SelectionChanged( const Selectable& selectable ){
-	EntityList_SelectionUpdate();
+void EntityList_SelectionChanged(const Selectable &selectable)
+{
+    EntityList_SelectionUpdate();
 }
 
-void entitylist_treeview_rowcollapsed( GtkTreeView* view, GtkTreeIter* iter, GtkTreePath* path, gpointer user_data ){
+void entitylist_treeview_rowcollapsed(ui::TreeView view, GtkTreeIter *iter, ui::TreePath path, gpointer user_data)
+{
 }
 
-void entitylist_treeview_row_expanded( GtkTreeView* view, GtkTreeIter* iter, GtkTreePath* path, gpointer user_data ){
-	EntityList_SelectionUpdate();
+void entitylist_treeview_row_expanded(ui::TreeView view, GtkTreeIter *iter, ui::TreePath path, gpointer user_data)
+{
+    EntityList_SelectionUpdate();
 }
 
 
-void EntityList_SetShown( bool shown ){
-	widget_set_visible( getEntityList().m_window, shown );
-}
-
-void EntityList_toggleShown(){
-	EntityList_SetShown( !getEntityList().visible() );
+void EntityList_SetShown(bool shown)
+{
+    getEntityList().m_window.visible(shown);
 }
 
-gint graph_tree_model_compare_name( GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data ){
-	scene::Node* first;
-	gtk_tree_model_get( model, a, 0, (gpointer*)&first, -1 );
-	scene::Node* second;
-	gtk_tree_model_get( model, b, 0, (gpointer*)&second, -1 );
-	int result = 0;
-	if ( first != 0 && second != 0 ) {
-		result = string_compare( node_get_name( *first ), node_get_name( *second ) );
-	}
-	if ( result == 0 ) {
-		return ( first < second ) ? -1 : ( second < first ) ? 1 : 0;
-	}
-	return result;
+void EntityList_toggleShown()
+{
+    EntityList_SetShown(!getEntityList().visible());
 }
 
-extern GraphTreeModel* scene_graph_get_tree_model();
-void AttachEntityTreeModel(){
-	getEntityList().m_tree_model = scene_graph_get_tree_model();
+gint graph_tree_model_compare_name(ui::TreeModel model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
+{
+    scene::Node *first;
+    gtk_tree_model_get(model, a, 0, (gpointer *) &first, -1);
+    scene::Node *second;
+    gtk_tree_model_get(model, b, 0, (gpointer *) &second, -1);
+    int result = 0;
+    if (first != 0 && second != 0) {
+        result = string_compare(node_get_name(*first), node_get_name(*second));
+    }
+    if (result == 0) {
+        return (first < second) ? -1 : (second < first) ? 1 : 0;
+    }
+    return result;
+}
+
+extern GraphTreeModel *scene_graph_get_tree_model();
+
+void AttachEntityTreeModel()
+{
+    getEntityList().m_tree_model = ui::TreeModel::from(scene_graph_get_tree_model());
 
-	gtk_tree_view_set_model( getEntityList().m_tree_view, GTK_TREE_MODEL( getEntityList().m_tree_model ) );
+    gtk_tree_view_set_model(getEntityList().m_tree_view, getEntityList().m_tree_model);
 }
 
-void DetachEntityTreeModel(){
-	getEntityList().m_tree_model = 0;
+void DetachEntityTreeModel()
+{
+    getEntityList().m_tree_model = ui::TreeModel(ui::null);
 
-	gtk_tree_view_set_model( getEntityList().m_tree_view, 0 );
+    gtk_tree_view_set_model(getEntityList().m_tree_view, 0);
 }
 
-void EntityList_constructWindow( ui::Window main_window ){
-	ASSERT_TRUE( !getEntityList().m_window );
+void EntityList_constructWindow(ui::Window main_window)
+{
+    ASSERT_TRUE(!getEntityList().m_window);
 
-	auto window = ui::Window(create_persistent_floating_window( "Entity List", main_window ));
+    auto window = ui::Window(create_persistent_floating_window("Entity List", main_window));
 
-	window.add_accel_group(global_accel);
+    window.add_accel_group(global_accel);
 
-	getEntityList().m_positionTracker.connect( window );
+    getEntityList().m_positionTracker.connect(window);
 
 
-	getEntityList().m_window = window;
+    getEntityList().m_window = window;
 
-	{
-		auto scr = create_scrolled_window( ui::Policy::AUTOMATIC, ui::Policy::AUTOMATIC );
-		window.add(scr);
+    {
+        auto scr = create_scrolled_window(ui::Policy::AUTOMATIC, ui::Policy::AUTOMATIC);
+        window.add(scr);
 
-		{
-			ui::Widget view = ui::TreeView();
-			gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
+        {
+            auto view = ui::TreeView(ui::New);
+            gtk_tree_view_set_headers_visible(view, FALSE);
 
-			auto renderer = ui::CellRendererText();
-			GtkTreeViewColumn* column = gtk_tree_view_column_new();
-			gtk_tree_view_column_pack_start( column, renderer, TRUE );
-			gtk_tree_view_column_set_cell_data_func( column, renderer, entitylist_treeviewcolumn_celldatafunc, 0, 0 );
+            auto renderer = ui::CellRendererText(ui::New);
+            auto column = gtk_tree_view_column_new();
+            gtk_tree_view_column_pack_start(column, renderer, TRUE);
+            gtk_tree_view_column_set_cell_data_func(column, renderer,
+                                                    reinterpret_cast<GtkTreeCellDataFunc>(entitylist_treeviewcolumn_celldatafunc),
+                                                    0, 0);
 
-			GtkTreeSelection* select = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) );
-			gtk_tree_selection_set_mode( select, GTK_SELECTION_MULTIPLE );
+            auto select = gtk_tree_view_get_selection(view);
+            gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
 
-			view.connect( "row_expanded", G_CALLBACK( entitylist_treeview_row_expanded ), 0 );
-			view.connect( "row_collapsed", G_CALLBACK( entitylist_treeview_rowcollapsed ), 0 );
+            view.connect("row_expanded", G_CALLBACK(entitylist_treeview_row_expanded), 0);
+            view.connect("row_collapsed", G_CALLBACK(entitylist_treeview_rowcollapsed), 0);
 
-			gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
+            gtk_tree_view_append_column(view, column);
 
-			view.show();
-			scr.add(view);
-			getEntityList().m_tree_view = GTK_TREE_VIEW( view );
-		}
-	}
+            view.show();
+            scr.add(view);
+            getEntityList().m_tree_view = view;
+        }
+    }
 
-	EntityList_ConnectSignals( getEntityList().m_tree_view );
-	AttachEntityTreeModel();
+    EntityList_ConnectSignals(getEntityList().m_tree_view);
+    AttachEntityTreeModel();
 }
 
-void EntityList_destroyWindow(){
-	DetachEntityTreeModel();
-	EntityList_DisconnectSignals( getEntityList().m_tree_view );
-	destroy_floating_window( getEntityList().m_window );
+void EntityList_destroyWindow()
+{
+    DetachEntityTreeModel();
+    EntityList_DisconnectSignals(getEntityList().m_tree_view);
+    destroy_floating_window(getEntityList().m_window);
 }
 
 #include "preferencesystem.h"
 
 #include "iselection.h"
 
-namespace
-{
-scene::Node* nullNode = 0;
+namespace {
+    scene::Node *nullNode = 0;
 }
 
-class NullSelectedInstance : public scene::Instance, public Selectable
-{
-class TypeCasts
-{
-InstanceTypeCastTable m_casts;
-public:
-TypeCasts(){
-	InstanceStaticCast<NullSelectedInstance, Selectable>::install( m_casts );
-}
-InstanceTypeCastTable& get(){
-	return m_casts;
-}
-};
+class NullSelectedInstance : public scene::Instance, public Selectable {
+    class TypeCasts {
+        InstanceTypeCastTable m_casts;
+    public:
+        TypeCasts()
+        {
+            InstanceStaticCast<NullSelectedInstance, Selectable>::install(m_casts);
+        }
+
+        InstanceTypeCastTable &get()
+        {
+            return m_casts;
+        }
+    };
 
 public:
-typedef LazyStatic<TypeCasts> StaticTypeCasts;
+    typedef LazyStatic<TypeCasts> StaticTypeCasts;
 
-NullSelectedInstance() : Instance( scene::Path( makeReference( *nullNode ) ), 0, this, StaticTypeCasts::instance().get() ){
-}
+    NullSelectedInstance() : Instance(scene::Path(makeReference(*nullNode)), 0, this, StaticTypeCasts::instance().get())
+    {
+    }
 
-void setSelected( bool select ){
-	ERROR_MESSAGE( "error" );
-}
-bool isSelected() const {
-	return true;
-}
+    void setSelected(bool select)
+    {
+        ERROR_MESSAGE("error");
+    }
+
+    bool isSelected() const
+    {
+        return true;
+    }
 };
 
 typedef LazyStatic<NullSelectedInstance> StaticNullSelectedInstance;
 
 
-void EntityList_Construct(){
-	graph_tree_model_insert( scene_graph_get_tree_model(), StaticNullSelectedInstance::instance() );
+void EntityList_Construct()
+{
+    graph_tree_model_insert(scene_graph_get_tree_model(), StaticNullSelectedInstance::instance());
 
-	g_EntityList = new EntityList;
+    g_EntityList = new EntityList;
 
-	getEntityList().m_positionTracker.setPosition( c_default_window_pos );
+    getEntityList().m_positionTracker.setPosition(c_default_window_pos);
 
-	GlobalPreferenceSystem().registerPreference( "EntityInfoDlg", WindowPositionTrackerImportStringCaller( getEntityList().m_positionTracker ), WindowPositionTrackerExportStringCaller( getEntityList().m_positionTracker ) );
+    GlobalPreferenceSystem().registerPreference("EntityInfoDlg", make_property<WindowPositionTracker_String>(
+            getEntityList().m_positionTracker));
 
-	typedef FreeCaller1<const Selectable&, EntityList_SelectionChanged> EntityListSelectionChangedCaller;
-	GlobalSelectionSystem().addSelectionChangeCallback( EntityListSelectionChangedCaller() );
+    typedef FreeCaller<void(const Selectable &), EntityList_SelectionChanged> EntityListSelectionChangedCaller;
+    GlobalSelectionSystem().addSelectionChangeCallback(EntityListSelectionChangedCaller());
 }
-void EntityList_Destroy(){
-	delete g_EntityList;
 
-	graph_tree_model_erase( scene_graph_get_tree_model(), StaticNullSelectedInstance::instance() );
+void EntityList_Destroy()
+{
+    delete g_EntityList;
+
+    graph_tree_model_erase(scene_graph_get_tree_model(), StaticNullSelectedInstance::instance());
 }