#include "string/string.h"
#include "generic/reference.h"
-inline Nameable *Node_getNameable(scene::Node &node)
-{
- return NodeTypeCast<Nameable>::cast(node);
+inline Nameable* Node_getNameable( scene::Node& node ){
+ return NodeTypeCast<Nameable>::cast( node );
}
#if 0
template<typename value_type>
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 );
+ GValue value = GValue_default();
+ gtk_tree_model_get_value( model, iter, column, &value );
+ *pointer = (value_type*)g_value_get_pointer( &value );
}
typedef GtkTreeStore GraphTreeModel;
ui::TreeStore graph_tree_model_new( graph_type* graph ){
- return gtk_tree_store_new( 2, G_TYPE_POINTER, G_TYPE_POINTER );
+ return gtk_tree_store_new( 2, G_TYPE_POINTER, G_TYPE_POINTER );
}
void graph_tree_model_delete( GraphTreeModel* model ){
- g_object_unref( G_OBJECT( model ) );
+ g_object_unref( G_OBJECT( model ) );
}
bool graph_tree_model_subtree_find_node( GraphTreeModel* model, GtkTreeIter* parent, const scene::Node& node, GtkTreeIter* iter ){
- for ( gboolean success = gtk_tree_model_iter_children( model, iter, parent );
- success != FALSE;
- success = gtk_tree_model_iter_next( model, iter ) )
- {
- scene::Node* current;
- gtk_tree_model_get_pointer( model, iter, 0, ¤t );
- if ( current == node ) {
- return true;
- }
- }
- return false;
+ for ( gboolean success = gtk_tree_model_iter_children( model, iter, parent );
+ success != FALSE;
+ success = gtk_tree_model_iter_next( model, iter ) )
+ {
+ scene::Node* current;
+ gtk_tree_model_get_pointer( model, iter, 0, ¤t );
+ if ( current == node ) {
+ return true;
+ }
+ }
+ return false;
}
typedef GtkTreeIter DoubleGtkTreeIter[2];
bool graph_tree_model_find_top( GraphTreeModel* model, const scene::Path& path, GtkTreeIter& iter ){
- int swap = 0;
- GtkTreeIter* parent_pointer = NULL;
- GtkTreeIter parent;
- for ( scene::Path::const_iterator i = path.begin(); i != path.end(); ++i )
- {
- if ( !graph_tree_model_subtree_find_node( model, parent_pointer, *i, &iter ) ) {
- return false;
- }
- parent = iter;
- parent_pointer = &parent;
- }
- return true;
+ int swap = 0;
+ GtkTreeIter* parent_pointer = NULL;
+ GtkTreeIter parent;
+ for ( scene::Path::const_iterator i = path.begin(); i != path.end(); ++i )
+ {
+ if ( !graph_tree_model_subtree_find_node( model, parent_pointer, *i, &iter ) ) {
+ return false;
+ }
+ parent = iter;
+ parent_pointer = &parent;
+ }
+ return true;
}
bool graph_tree_model_find_parent( GraphTreeModel* model, const scene::Path& path, GtkTreeIter& iter ){
- int swap = 0;
- GtkTreeIter* parent_pointer = NULL;
- ASSERT_MESSAGE( path.size() > 1, "path too short" );
- for ( scene::Path::const_iterator i = path.begin(); i != path.end() - 1; ++i )
- {
- GtkTreeIter child;
- if ( !graph_tree_model_subtree_find_node( model, parent_pointer, *i, &child ) ) {
- return false;
- }
- iter = child;
- parent_pointer = &iter;
- }
- return true;
+ int swap = 0;
+ GtkTreeIter* parent_pointer = NULL;
+ ASSERT_MESSAGE( path.size() > 1, "path too short" );
+ for ( scene::Path::const_iterator i = path.begin(); i != path.end() - 1; ++i )
+ {
+ GtkTreeIter child;
+ if ( !graph_tree_model_subtree_find_node( model, parent_pointer, *i, &child ) ) {
+ return false;
+ }
+ iter = child;
+ parent_pointer = &iter;
+ }
+ return true;
}
void node_attach_name_changed_callback( scene::Node& node, const Callback<void()>& callback ){
- if ( node != 0 ) {
- Nameable* nameable = Node_getNameable( node );
- if ( nameable != 0 ) {
- nameable->attach( callback );
- }
- }
+ if ( node != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->attach( callback );
+ }
+ }
}
void node_detach_name_changed_callback( scene::Node& node, const Callback<void()>& callback ){
- if ( node != 0 ) {
- Nameable* nameable = Node_getNameable( node );
- if ( nameable != 0 ) {
- nameable->detach( callback );
- }
- }
+ if ( node != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->detach( callback );
+ }
+ }
}
GraphTreeModel* scene_graph_get_tree_model(); // temp hack
void graph_tree_model_row_changed( const scene::Instance& instance ){
- GraphTreeModel* model = scene_graph_get_tree_model();
+ GraphTreeModel* model = scene_graph_get_tree_model();
- GtkTreeIter child;
- ASSERT_MESSAGE( graph_tree_model_find_top( model, instance.path(), child ), "RUNTIME ERROR" );
+ GtkTreeIter child;
+ ASSERT_MESSAGE( graph_tree_model_find_top( model, instance.path(), child ), "RUNTIME ERROR" );
- gtk_tree_store_set( GTK_TREE_STORE( model ), &child, 0, instance.path().top(), -1 );
+ gtk_tree_store_set( GTK_TREE_STORE( model ), &child, 0, instance.path().top(), -1 );
}
void graph_tree_model_row_inserted( GraphTreeModel* model, const scene::Instance& instance ){
- GtkTreeIter parent;
- GtkTreeIter* parent_pointer = NULL;
- if ( instance.path().size() != 1 ) {
- ASSERT_MESSAGE( graph_tree_model_find_parent( model, instance.path(), parent ), "RUNTIME ERROR" );
- parent_pointer = &parent;
- }
+ GtkTreeIter parent;
+ GtkTreeIter* parent_pointer = NULL;
+ if ( instance.path().size() != 1 ) {
+ ASSERT_MESSAGE( graph_tree_model_find_parent( model, instance.path(), parent ), "RUNTIME ERROR" );
+ parent_pointer = &parent;
+ }
- gpointer node = instance.path().top();
- gconstpointer selectable = Instance_getSelectable( instance );
+ gpointer node = instance.path().top();
+ gconstpointer selectable = Instance_getSelectable( instance );
- GtkTreeIter child;
- gtk_tree_store_append( GTK_TREE_STORE( model ), &child, parent_pointer );
- gtk_tree_store_set( GTK_TREE_STORE( model ), &child, 0, node, 1, selectable, -1 );
+ GtkTreeIter child;
+ gtk_tree_store_append( GTK_TREE_STORE( model ), &child, parent_pointer );
+ gtk_tree_store_set( GTK_TREE_STORE( model ), &child, 0, node, 1, selectable, -1 );
- node_attach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(), graph_tree_model_row_changed>( instance ) );
+ node_attach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(), graph_tree_model_row_changed>( instance ) );
}
void graph_tree_model_row_deleted( GraphTreeModel* model, const scene::Instance& instance ){
- GtkTreeIter child;
- ASSERT_MESSAGE( graph_tree_model_find_top( model, instance.path(), child ), "RUNTIME ERROR" );
+ GtkTreeIter child;
+ ASSERT_MESSAGE( graph_tree_model_find_top( model, instance.path(), child ), "RUNTIME ERROR" );
- node_detach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(), graph_tree_model_row_changed>( instance ) );
+ node_detach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(), graph_tree_model_row_changed>( instance ) );
- gtk_tree_store_remove( GTK_TREE_STORE( model ), &child );
+ gtk_tree_store_remove( GTK_TREE_STORE( model ), &child );
}
#elif 0
{
public:
bool operator()( const NodePointer& self, const NodePointer& other ) const {
- if ( self == 0 ) {
- return true;
- }
- if ( other == 0 ) {
- return false;
- }
- int result = string_compare( node_get_name( self ), node_get_name( other ) );
- if ( result == 0 ) {
- return self < other;
- }
- return result < 0;
+ if ( self == 0 ) {
+ return true;
+ }
+ if ( other == 0 ) {
+ return false;
+ }
+ int result = string_compare( node_get_name( self ), node_get_name( other ) );
+ if ( result == 0 ) {
+ return self < other;
+ }
+ return result < 0;
}
};
{
public:
bool operator()( const PathConstReference& self, const PathConstReference& other ) const {
- return std::lexicographical_compare( self.get().begin(), self.get().end(), other.get().begin(), other.get().end(), NodeNameLess() );
+ return std::lexicographical_compare( self.get().begin(), self.get().end(), other.get().begin(), other.get().end(), NodeNameLess() );
}
};
struct GraphTreeModel
{
- GObject parent;
+ GObject parent;
- graph_type* graph;
+ graph_type* graph;
};
struct GraphTreeModelClass
{
- GObjectClass parent_class;
+ GObjectClass parent_class;
};
#define GRAPH_TREE_MODEL( p ) ( reinterpret_cast<GraphTreeModel*>( p ) )
static GtkTreeModelFlags graph_tree_model_get_flags( GtkTreeModel* tree_model ){
- return GTK_TREE_MODEL_ITERS_PERSIST;
+ return GTK_TREE_MODEL_ITERS_PERSIST;
}
static gint graph_tree_model_get_n_columns( ui::TreeModel tree_model ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- GraphTreeModel* graph_tree_model = (GraphTreeModel*) tree_model;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeModel* graph_tree_model = (GraphTreeModel*) tree_model;
- return 2;
+ return 2;
}
static const gint c_stamp = 0xabcdef;
inline graph_type::iterator graph_iterator_read_tree_iter( GtkTreeIter* iter ){
- ASSERT_MESSAGE( iter != 0, "tree model error" );
- ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
- ASSERT_MESSAGE( iter->stamp == c_stamp, "tree model error" );
- return *reinterpret_cast<graph_type::iterator*>( &iter->user_data );
+ ASSERT_MESSAGE( iter != 0, "tree model error" );
+ ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
+ ASSERT_MESSAGE( iter->stamp == c_stamp, "tree model error" );
+ return *reinterpret_cast<graph_type::iterator*>( &iter->user_data );
}
inline void graph_iterator_write_tree_iter( graph_type::iterator i, GtkTreeIter* iter ){
- ASSERT_MESSAGE( iter != 0, "tree model error" );
- iter->stamp = c_stamp;
- *reinterpret_cast<graph_type::iterator*>( &iter->user_data ) = i;
- ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
+ ASSERT_MESSAGE( iter != 0, "tree model error" );
+ iter->stamp = c_stamp;
+ *reinterpret_cast<graph_type::iterator*>( &iter->user_data ) = i;
+ ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
}
static GType graph_tree_model_get_column_type( ui::TreeModel tree_model, gint index ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- GraphTreeModel *graph_tree_model = (GraphTreeModel *) tree_model;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeModel *graph_tree_model = (GraphTreeModel *) tree_model;
- return G_TYPE_POINTER;
+ return G_TYPE_POINTER;
}
static gboolean graph_tree_model_get_iter( ui::TreeModel tree_model, GtkTreeIter* iter, ui::TreePath path ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- gint* indices = gtk_tree_path_get_indices( path );
- gint depth = gtk_tree_path_get_depth( path );
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ gint* indices = gtk_tree_path_get_indices( path );
+ gint depth = gtk_tree_path_get_depth( path );
- g_return_val_if_fail( depth > 0, FALSE );
+ g_return_val_if_fail( depth > 0, FALSE );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- if ( graph.empty() ) {
- return FALSE;
- }
+ if ( graph.empty() ) {
+ return FALSE;
+ }
- GtkTreeIter tmp;
- GtkTreeIter* parent = 0;
+ GtkTreeIter tmp;
+ GtkTreeIter* parent = 0;
- for ( gint i = 0; i < depth; i++ )
- {
- if ( !gtk_tree_model_iter_nth_child( tree_model, iter, parent, indices[i] ) ) {
- return FALSE;
- }
- tmp = *iter;
- parent = &tmp;
- }
+ for ( gint i = 0; i < depth; i++ )
+ {
+ if ( !gtk_tree_model_iter_nth_child( tree_model, iter, parent, indices[i] ) ) {
+ return FALSE;
+ }
+ tmp = *iter;
+ parent = &tmp;
+ }
- return TRUE;
+ return TRUE;
}
static ui::TreePath graph_tree_model_get_path( ui::TreeModel tree_model, GtkTreeIter* iter ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = graph_iterator_read_tree_iter( iter );
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = graph_iterator_read_tree_iter( iter );
- auto path = ui::TreePath();
+ auto path = ui::TreePath();
- for ( std::size_t depth = ( *i ).first.get().size(); depth != 0; --depth )
- {
- std::size_t index = 0;
+ for ( std::size_t depth = ( *i ).first.get().size(); depth != 0; --depth )
+ {
+ std::size_t index = 0;
- while ( i != graph.begin() && ( *i ).first.get().size() >= depth )
- {
- --i;
- if ( ( *i ).first.get().size() == depth ) {
- ++index;
- }
- }
+ while ( i != graph.begin() && ( *i ).first.get().size() >= depth )
+ {
+ --i;
+ if ( ( *i ).first.get().size() == depth ) {
+ ++index;
+ }
+ }
- gtk_tree_path_prepend_index( path, index );
- }
+ gtk_tree_path_prepend_index( path, index );
+ }
- return path;
+ return path;
}
static void graph_tree_model_get_value( ui::TreeModel tree_model, GtkTreeIter *iter, gint column, GValue *value ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- ASSERT_MESSAGE( column == 0 || column == 1, "tree model error" );
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ ASSERT_MESSAGE( column == 0 || column == 1, "tree model error" );
- graph_type::iterator i = graph_iterator_read_tree_iter( iter );
+ graph_type::iterator i = graph_iterator_read_tree_iter( iter );
- g_value_init( value, G_TYPE_POINTER );
+ g_value_init( value, G_TYPE_POINTER );
- if ( column == 0 ) {
- g_value_set_pointer( value, reinterpret_cast<gpointer>( ( *i ).first.get().top() ) );
- }
- else{
- g_value_set_pointer( value, reinterpret_cast<gpointer>( Instance_getSelectable( *( *i ).second ) ) );
- }
+ if ( column == 0 ) {
+ g_value_set_pointer( value, reinterpret_cast<gpointer>( ( *i ).first.get().top() ) );
+ }
+ else{
+ g_value_set_pointer( value, reinterpret_cast<gpointer>( Instance_getSelectable( *( *i ).second ) ) );
+ }
}
static gboolean graph_tree_model_iter_next( ui::TreeModel tree_model, GtkTreeIter *iter ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = graph_iterator_read_tree_iter( iter );
- std::size_t depth = ( *i ).first.get().size();
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = graph_iterator_read_tree_iter( iter );
+ std::size_t depth = ( *i ).first.get().size();
- ++i;
+ ++i;
- while ( i != graph.end() && ( *i ).first.get().size() > depth )
- {
- ++i;
- }
+ while ( i != graph.end() && ( *i ).first.get().size() > depth )
+ {
+ ++i;
+ }
- if ( i == graph.end() || ( *i ).first.get().size() != depth ) {
- return FALSE;
- }
+ if ( i == graph.end() || ( *i ).first.get().size() != depth ) {
+ return FALSE;
+ }
- graph_iterator_write_tree_iter( i, iter );
+ graph_iterator_write_tree_iter( i, iter );
- return TRUE;
+ return TRUE;
}
static gboolean graph_tree_model_iter_children( ui::TreeModel tree_model, GtkTreeIter *iter, GtkTreeIter *parent ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
- std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
+ std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
- if ( parent != 0 ) {
- ++i;
- }
+ if ( parent != 0 ) {
+ ++i;
+ }
- if ( i != graph.end() && ( *i ).first.get().size() == depth ) {
- graph_iterator_write_tree_iter( i, iter );
- return TRUE;
- }
+ if ( i != graph.end() && ( *i ).first.get().size() == depth ) {
+ graph_iterator_write_tree_iter( i, iter );
+ return TRUE;
+ }
- return FALSE;
+ return FALSE;
}
static gboolean graph_tree_model_iter_has_child( ui::TreeModel tree_model, GtkTreeIter *iter ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = graph_iterator_read_tree_iter( iter );
- std::size_t depth = ( *i ).first.get().size() + 1;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = graph_iterator_read_tree_iter( iter );
+ std::size_t depth = ( *i ).first.get().size() + 1;
- return ++i != graph.end() && ( *i ).first.get().size() == depth;
+ return ++i != graph.end() && ( *i ).first.get().size() == depth;
}
static gint graph_tree_model_iter_n_children( ui::TreeModel tree_model, GtkTreeIter *parent ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
- std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
+ std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
- if ( parent != 0 ) {
- ++i;
- }
+ if ( parent != 0 ) {
+ ++i;
+ }
- gint count = 0;
- while ( i != graph.end() && ( *i ).first.get().size() >= depth )
- {
- ++count;
- ++i;
- }
+ gint count = 0;
+ while ( i != graph.end() && ( *i ).first.get().size() >= depth )
+ {
+ ++count;
+ ++i;
+ }
- return count;
+ return count;
}
static gboolean graph_tree_model_iter_nth_child( ui::TreeModel tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
- std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = ( parent == 0 ) ? graph.begin() : graph_iterator_read_tree_iter( parent );
+ std::size_t depth = ( parent == 0 ) ? 1 : ( *i ).first.get().size() + 1;
- if ( parent != 0 ) {
- ++i;
- }
+ if ( parent != 0 ) {
+ ++i;
+ }
- while ( i != graph.end() && ( *i ).first.get().size() >= depth )
- {
- if ( ( *i ).first.get().size() == depth && n-- == 0 ) {
- graph_iterator_write_tree_iter( i, iter );
- return TRUE;
- }
- ++i;
- }
+ while ( i != graph.end() && ( *i ).first.get().size() >= depth )
+ {
+ if ( ( *i ).first.get().size() == depth && n-- == 0 ) {
+ graph_iterator_write_tree_iter( i, iter );
+ return TRUE;
+ }
+ ++i;
+ }
- return FALSE;
+ return FALSE;
}
static gboolean graph_tree_model_iter_parent( ui::TreeModel tree_model, GtkTreeIter *iter, GtkTreeIter *child ){
- ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
- graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
- graph_type::iterator i = graph_iterator_read_tree_iter( child );
- std::size_t depth = ( *i ).first.get().size();
- if ( depth == 1 ) {
- return FALSE;
- }
- else
- {
- do
- {
- --i;
- }
- while ( ( *i ).first.get().size() >= depth );
- graph_iterator_write_tree_iter( i, iter );
- return TRUE;
- }
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ graph_type& graph = *GRAPH_TREE_MODEL( tree_model )->graph;
+ graph_type::iterator i = graph_iterator_read_tree_iter( child );
+ std::size_t depth = ( *i ).first.get().size();
+ if ( depth == 1 ) {
+ return FALSE;
+ }
+ else
+ {
+ do
+ {
+ --i;
+ }
+ while ( ( *i ).first.get().size() >= depth );
+ graph_iterator_write_tree_iter( i, iter );
+ return TRUE;
+ }
}
static GObjectClass *g_parent_class = 0;
static void graph_tree_model_init( GraphTreeModel *graph_tree_model ){
- graph_tree_model->graph = 0;
+ graph_tree_model->graph = 0;
}
static void graph_tree_model_finalize( GObject* object ){
- GraphTreeModel* graph_tree_model = GRAPH_TREE_MODEL( object );
+ GraphTreeModel* graph_tree_model = GRAPH_TREE_MODEL( object );
- /* must chain up */
- ( *g_parent_class->finalize )( object );
+ /* must chain up */
+ ( *g_parent_class->finalize )( object );
}
static void graph_tree_model_class_init( GraphTreeModelClass *class_ ){
- GObjectClass *object_class;
+ GObjectClass *object_class;
- g_parent_class = (GObjectClass*)g_type_class_peek_parent( class_ );
- object_class = (GObjectClass *) class_;
+ g_parent_class = (GObjectClass*)g_type_class_peek_parent( class_ );
+ object_class = (GObjectClass *) class_;
- object_class->finalize = graph_tree_model_finalize;
+ object_class->finalize = graph_tree_model_finalize;
}
static void graph_tree_model_tree_model_init( GtkTreeModelIface *iface ){
- iface->get_flags = graph_tree_model_get_flags;
- iface->get_n_columns = graph_tree_model_get_n_columns;
- iface->get_column_type = graph_tree_model_get_column_type;
- iface->get_iter = graph_tree_model_get_iter;
- iface->get_path = graph_tree_model_get_path;
- iface->get_value = graph_tree_model_get_value;
- iface->iter_next = graph_tree_model_iter_next;
- iface->iter_children = graph_tree_model_iter_children;
- iface->iter_has_child = graph_tree_model_iter_has_child;
- iface->iter_n_children = graph_tree_model_iter_n_children;
- iface->iter_nth_child = graph_tree_model_iter_nth_child;
- iface->iter_parent = graph_tree_model_iter_parent;
+ iface->get_flags = graph_tree_model_get_flags;
+ iface->get_n_columns = graph_tree_model_get_n_columns;
+ iface->get_column_type = graph_tree_model_get_column_type;
+ iface->get_iter = graph_tree_model_get_iter;
+ iface->get_path = graph_tree_model_get_path;
+ iface->get_value = graph_tree_model_get_value;
+ iface->iter_next = graph_tree_model_iter_next;
+ iface->iter_children = graph_tree_model_iter_children;
+ iface->iter_has_child = graph_tree_model_iter_has_child;
+ iface->iter_n_children = graph_tree_model_iter_n_children;
+ iface->iter_nth_child = graph_tree_model_iter_nth_child;
+ iface->iter_parent = graph_tree_model_iter_parent;
}
static gboolean graph_tree_model_row_draggable( GtkTreeDragSource *drag_source, ui::TreePath path ){
#if GDEF_DEBUG
- gint depth = gtk_tree_path_get_depth( path );
+ gint depth = gtk_tree_path_get_depth( path );
#endif
- return gtk_tree_path_get_depth( path ) > 1;
+ return gtk_tree_path_get_depth( path ) > 1;
}
static gboolean graph_tree_model_drag_data_delete( GtkTreeDragSource *drag_source, ui::TreePath path ){
- GtkTreeIter iter;
+ GtkTreeIter iter;
- if ( gtk_tree_model_get_iter( drag_source, &iter, path ) ) {
- graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
- Path_deleteTop( ( *i ).first );
- return TRUE;
- }
- else
- {
- return FALSE;
- }
+ if ( gtk_tree_model_get_iter( drag_source, &iter, path ) ) {
+ graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
+ Path_deleteTop( ( *i ).first );
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
}
static gboolean graph_tree_model_drag_data_get( GtkTreeDragSource *drag_source, ui::TreePath path, GtkSelectionData *selection_data ){
- if ( gtk_tree_set_row_drag_data( selection_data, drag_source, path ) ) {
- return TRUE;
- }
- else
- {
- /* FIXME handle text targets at least. */
- }
+ if ( gtk_tree_set_row_drag_data( selection_data, drag_source, path ) ) {
+ return TRUE;
+ }
+ else
+ {
+ /* FIXME handle text targets at least. */
+ }
- return FALSE;
+ return FALSE;
}
static void graph_tree_model_drag_source_init( GtkTreeDragSourceIface *iface ){
- iface->row_draggable = graph_tree_model_row_draggable;
- iface->drag_data_delete = graph_tree_model_drag_data_delete;
- iface->drag_data_get = graph_tree_model_drag_data_get;
+ iface->row_draggable = graph_tree_model_row_draggable;
+ iface->drag_data_delete = graph_tree_model_drag_data_delete;
+ iface->drag_data_get = graph_tree_model_drag_data_get;
}
static gboolean graph_tree_model_drag_data_received( GtkTreeDragDest *drag_dest, ui::TreePath dest, GtkSelectionData *selection_data ){
- auto tree_model = drag_dest;
+ auto tree_model = drag_dest;
- GtkTreeModel *src_model = 0;
- GtkTreePath *src_path = 0;
- if ( gtk_tree_get_row_drag_data( selection_data, &src_model, &src_path )
- && src_model == tree_model ) {
- /* Copy the given row to a new position */
- GtkTreeIter iter;
+ GtkTreeModel *src_model = 0;
+ GtkTreePath *src_path = 0;
+ if ( gtk_tree_get_row_drag_data( selection_data, &src_model, &src_path )
+ && src_model == tree_model ) {
+ /* Copy the given row to a new position */
+ GtkTreeIter iter;
- if ( gtk_tree_model_get_iter( src_model, &iter, src_path ) ) {
- int bleh = 0;
- }
- }
- else
- {
- /* FIXME maybe add some data targets eventually, or handle text
- * targets in the simple case.
- */
- }
+ if ( gtk_tree_model_get_iter( src_model, &iter, src_path ) ) {
+ int bleh = 0;
+ }
+ }
+ else
+ {
+ /* FIXME maybe add some data targets eventually, or handle text
+ * targets in the simple case.
+ */
+ }
- return FALSE;
+ return FALSE;
}
static gboolean graph_tree_model_row_drop_possible( GtkTreeDragDest *drag_dest, ui::TreePath dest_path, GtkSelectionData *selection_data ){
- gboolean retval = FALSE;
+ gboolean retval = FALSE;
- GtkTreeModel *src_model = 0;
- GtkTreePath *src_path = 0;
- if ( gtk_tree_get_row_drag_data( selection_data, &src_model, &src_path ) != FALSE ) {
- /* can only drag to ourselves */
- if ( src_model == drag_dest ) {
- /* Can't drop into ourself. */
- if ( !gtk_tree_path_is_ancestor( src_path, dest_path ) ) {
- /* Can't drop if dest_path's parent doesn't exist */
- if ( gtk_tree_path_get_depth( dest_path ) > 1 ) {
- auto tmp = gtk_tree_path_copy( dest_path );
- gtk_tree_path_up( tmp );
+ GtkTreeModel *src_model = 0;
+ GtkTreePath *src_path = 0;
+ if ( gtk_tree_get_row_drag_data( selection_data, &src_model, &src_path ) != FALSE ) {
+ /* can only drag to ourselves */
+ if ( src_model == drag_dest ) {
+ /* Can't drop into ourself. */
+ if ( !gtk_tree_path_is_ancestor( src_path, dest_path ) ) {
+ /* Can't drop if dest_path's parent doesn't exist */
+ if ( gtk_tree_path_get_depth( dest_path ) > 1 ) {
+ auto tmp = gtk_tree_path_copy( dest_path );
+ gtk_tree_path_up( tmp );
- GtkTreeIter iter;
- retval = gtk_tree_model_get_iter( drag_dest, &iter, tmp );
+ GtkTreeIter iter;
+ retval = gtk_tree_model_get_iter( drag_dest, &iter, tmp );
- gtk_tree_path_free( tmp );
- }
- }
- }
+ gtk_tree_path_free( tmp );
+ }
+ }
+ }
- gtk_tree_path_free( src_path );
- }
+ gtk_tree_path_free( src_path );
+ }
- return retval;
+ return retval;
}
static void graph_tree_model_drag_dest_init( GtkTreeDragDestIface *iface ){
- iface->drag_data_received = graph_tree_model_drag_data_received;
- iface->row_drop_possible = graph_tree_model_row_drop_possible;
+ iface->drag_data_received = graph_tree_model_drag_data_received;
+ iface->row_drop_possible = graph_tree_model_row_drop_possible;
}
GType graph_tree_model_get_type( void ){
- static GType graph_tree_model_type = 0;
-
- if ( !graph_tree_model_type ) {
- static const GTypeInfo graph_tree_model_info =
- {
- sizeof( GraphTreeModelClass ),
- 0, /* base_init */
- 0, /* base_finalize */
- (GClassInitFunc) graph_tree_model_class_init,
- 0, /* class_finalize */
- 0, /* class_data */
- sizeof( GraphTreeModel ),
- 0, /* n_preallocs */
- (GInstanceInitFunc) graph_tree_model_init
- };
-
- static const GInterfaceInfo tree_model_info =
- {
- (GInterfaceInitFunc) graph_tree_model_tree_model_init,
- 0,
- 0
- };
-
- static const GInterfaceInfo drag_source_info =
- {
- (GInterfaceInitFunc) graph_tree_model_drag_source_init,
- 0,
- 0
- };
-
- static const GInterfaceInfo drag_dest_info =
- {
- (GInterfaceInitFunc) graph_tree_model_drag_dest_init,
- 0,
- 0
- };
-
- graph_tree_model_type = g_type_register_static( G_TYPE_OBJECT, "GraphTreeModel",
- &graph_tree_model_info, (GTypeFlags)0 );
-
- g_type_add_interface_static( graph_tree_model_type,
- GTK_TYPE_TREE_MODEL,
- &tree_model_info );
- g_type_add_interface_static( graph_tree_model_type,
- GTK_TYPE_TREE_DRAG_SOURCE,
- &drag_source_info );
- g_type_add_interface_static( graph_tree_model_type,
- GTK_TYPE_TREE_DRAG_DEST,
- &drag_dest_info );
- }
-
- return graph_tree_model_type;
+ static GType graph_tree_model_type = 0;
+
+ if ( !graph_tree_model_type ) {
+ static const GTypeInfo graph_tree_model_info =
+ {
+ sizeof( GraphTreeModelClass ),
+ 0, /* base_init */
+ 0, /* base_finalize */
+ (GClassInitFunc) graph_tree_model_class_init,
+ 0, /* class_finalize */
+ 0, /* class_data */
+ sizeof( GraphTreeModel ),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) graph_tree_model_init
+ };
+
+ static const GInterfaceInfo tree_model_info =
+ {
+ (GInterfaceInitFunc) graph_tree_model_tree_model_init,
+ 0,
+ 0
+ };
+
+ static const GInterfaceInfo drag_source_info =
+ {
+ (GInterfaceInitFunc) graph_tree_model_drag_source_init,
+ 0,
+ 0
+ };
+
+ static const GInterfaceInfo drag_dest_info =
+ {
+ (GInterfaceInitFunc) graph_tree_model_drag_dest_init,
+ 0,
+ 0
+ };
+
+ graph_tree_model_type = g_type_register_static( G_TYPE_OBJECT, "GraphTreeModel",
+ &graph_tree_model_info, (GTypeFlags)0 );
+
+ g_type_add_interface_static( graph_tree_model_type,
+ GTK_TYPE_TREE_MODEL,
+ &tree_model_info );
+ g_type_add_interface_static( graph_tree_model_type,
+ GTK_TYPE_TREE_DRAG_SOURCE,
+ &drag_source_info );
+ g_type_add_interface_static( graph_tree_model_type,
+ GTK_TYPE_TREE_DRAG_DEST,
+ &drag_dest_info );
+ }
+
+ return graph_tree_model_type;
}
GraphTreeModel* graph_tree_model_new(){
- GraphTreeModel* graph_tree_model = GRAPH_TREE_MODEL( g_object_new( graph_tree_model_get_type(), 0 ) );
+ GraphTreeModel* graph_tree_model = GRAPH_TREE_MODEL( g_object_new( graph_tree_model_get_type(), 0 ) );
- graph_tree_model->graph = new graph_type;
+ graph_tree_model->graph = new graph_type;
- return graph_tree_model;
+ return graph_tree_model;
}
void graph_tree_model_delete( GraphTreeModel* model ){
- delete model->graph;
- g_object_unref( G_OBJECT( model ) );
+ delete model->graph;
+ g_object_unref( G_OBJECT( model ) );
}
TempNameable( const char* name ) : m_name( name ){
}
const char* name() const {
- return m_name;
+ return m_name;
}
void attach( const NameCallback& callback ){
}
};
void node_attach_name_changed_callback( scene::Node& node, const NameCallback& callback ){
- // Reference cannot be bound to dereferenced null pointer in well-defined
- // C++ code, and Clang will assume that comparison below always evaluates
- // to true, resulting in a segmentation fault. Use a dirty hack to force
- // Clang to check those "bad" references for null nonetheless.
- volatile intptr_t n = (intptr_t)&node;
-
- if ( n != 0 ) {
- Nameable* nameable = Node_getNameable( node );
- if ( nameable != 0 ) {
- nameable->attach( callback );
- }
- }
+ // Reference cannot be bound to dereferenced null pointer in well-defined
+ // C++ code, and Clang will assume that comparison below always evaluates
+ // to true, resulting in a segmentation fault. Use a dirty hack to force
+ // Clang to check those "bad" references for null nonetheless.
+ volatile intptr_t n = (intptr_t)&node;
+
+ if ( n != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->attach( callback );
+ }
+ }
}
void node_detach_name_changed_callback( scene::Node& node, const NameCallback& callback ){
- volatile intptr_t n = (intptr_t)&node; // see the comment on line 650
+ volatile intptr_t n = (intptr_t)&node; // see the comment on line 650
- if ( n != 0 ) {
- Nameable* nameable = Node_getNameable( node );
- if ( nameable != 0 ) {
- nameable->detach( callback );
- }
- }
+ if ( n != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->detach( callback );
+ }
+ }
}
GraphTreeModel* scene_graph_get_tree_model(); // temp hack
void graph_tree_model_row_inserted( GraphTreeModel* model, graph_type::iterator i ){
- GtkTreeIter iter;
- graph_iterator_write_tree_iter( i, &iter );
+ GtkTreeIter iter;
+ graph_iterator_write_tree_iter( i, &iter );
- auto tree_path = graph_tree_model_get_path( model, &iter );
+ auto tree_path = graph_tree_model_get_path( model, &iter );
- gint depth = gtk_tree_path_get_depth( tree_path );
- gint* indices = gtk_tree_path_get_indices( tree_path );
+ gint depth = gtk_tree_path_get_depth( tree_path );
+ gint* indices = gtk_tree_path_get_indices( tree_path );
- gtk_tree_model_row_inserted( model, tree_path, &iter );
+ gtk_tree_model_row_inserted( model, tree_path, &iter );
- gtk_tree_path_free( tree_path );
+ gtk_tree_path_free( tree_path );
}
void graph_tree_model_row_deleted( GraphTreeModel* model, graph_type::iterator i ){
- GtkTreeIter iter;
- graph_iterator_write_tree_iter( i, &iter );
+ GtkTreeIter iter;
+ graph_iterator_write_tree_iter( i, &iter );
- auto tree_path = graph_tree_model_get_path( model, &iter );
+ auto tree_path = graph_tree_model_get_path( model, &iter );
- gtk_tree_model_row_deleted( model, tree_path );
+ gtk_tree_model_row_deleted( model, tree_path );
- gtk_tree_path_free( tree_path );
+ gtk_tree_path_free( tree_path );
}
#include "generic/referencecounted.h"
void graph_tree_model_set_name( const scene::Instance& instance, const char* name ){
- GraphTreeModel* model = scene_graph_get_tree_model();
+ GraphTreeModel* model = scene_graph_get_tree_model();
- if ( string_empty( name ) ) { // hack!
- graph_type::iterator i = model->graph->find( PathConstReference( instance.path() ) );
- ASSERT_MESSAGE( i != model->graph->end(), "ERROR" );
+ if ( string_empty( name ) ) { // hack!
+ graph_type::iterator i = model->graph->find( PathConstReference( instance.path() ) );
+ ASSERT_MESSAGE( i != model->graph->end(), "ERROR" );
- graph_tree_model_row_deleted( model, i );
+ graph_tree_model_row_deleted( model, i );
- model->graph->erase( i );
- }
- else
- {
- graph_type::iterator i = model->graph->insert( graph_type::value_type( PathConstReference( instance.path() ), &const_cast<scene::Instance&>( instance ) ) ).first;
+ model->graph->erase( i );
+ }
+ else
+ {
+ graph_type::iterator i = model->graph->insert( graph_type::value_type( PathConstReference( instance.path() ), &const_cast<scene::Instance&>( instance ) ) ).first;
- graph_tree_model_row_inserted( model, i );
- }
+ graph_tree_model_row_inserted( model, i );
+ }
}
void graph_tree_model_insert( GraphTreeModel* model, const scene::Instance& instance ){
- graph_type::iterator i = model->graph->insert( graph_type::value_type( PathConstReference( instance.path() ), &const_cast<scene::Instance&>( instance ) ) ).first;
+ graph_type::iterator i = model->graph->insert( graph_type::value_type( PathConstReference( instance.path() ), &const_cast<scene::Instance&>( instance ) ) ).first;
- graph_tree_model_row_inserted( model, i );
+ graph_tree_model_row_inserted( model, i );
- node_attach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
+ node_attach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
}
void graph_tree_model_erase( GraphTreeModel* model, const scene::Instance& instance ){
- node_detach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
+ node_detach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
- graph_type::iterator i = model->graph->find( PathConstReference( instance.path() ) );
- ASSERT_MESSAGE( i != model->graph->end(), "ERROR" );
+ graph_type::iterator i = model->graph->find( PathConstReference( instance.path() ) );
+ ASSERT_MESSAGE( i != model->graph->end(), "ERROR" );
- graph_tree_model_row_deleted( model, i );
+ graph_tree_model_row_deleted( model, i );
- model->graph->erase( i );
+ model->graph->erase( i );
}
#elif 1
class GraphTreeNode;
+void graph_tree_model_row_changed( GraphTreeNode& node );
-void graph_tree_model_row_changed(GraphTreeNode &node);
-
-class GraphTreeNode {
- typedef std::map<std::pair<CopiedString, scene::Node *>, GraphTreeNode *> ChildNodes;
- ChildNodes m_childnodes;
+class GraphTreeNode
+{
+typedef std::map<std::pair<CopiedString, scene::Node*>, GraphTreeNode*> ChildNodes;
+ChildNodes m_childnodes;
public:
- Reference<scene::Instance> m_instance;
- GraphTreeNode *m_parent;
-
- typedef ChildNodes::iterator iterator;
- typedef ChildNodes::key_type key_type;
- typedef ChildNodes::value_type value_type;
- typedef ChildNodes::size_type size_type;
-
- GraphTreeNode(scene::Instance &instance) : m_instance(instance), m_parent(0)
- {
- m_instance.get().setChildSelectedChangedCallback(RowChangedCaller(*this));
- }
-
- ~GraphTreeNode()
- {
- m_instance.get().setChildSelectedChangedCallback(Callback<void()>());
- ASSERT_MESSAGE(empty(), "GraphTreeNode::~GraphTreeNode: memory leak");
- }
-
- iterator begin()
- {
- return m_childnodes.begin();
- }
-
- iterator end()
- {
- return m_childnodes.end();
- }
-
- size_type size() const
- {
- return m_childnodes.size();
- }
-
- bool empty() const
- {
- return m_childnodes.empty();
- }
-
- iterator insert(const value_type &value)
- {
- iterator i = m_childnodes.insert(value).first;
- (*i).second->m_parent = this;
- return i;
- }
-
- void erase(iterator i)
- {
- m_childnodes.erase(i);
- }
-
- iterator find(const key_type &key)
- {
- return m_childnodes.find(key);
- }
-
- void swap(GraphTreeNode &other)
- {
- std::swap(m_parent, other.m_parent);
- std::swap(m_childnodes, other.m_childnodes);
- std::swap(m_instance, other.m_instance);
- }
-
- void rowChanged()
- {
- graph_tree_model_row_changed(*this);
- }
-
- typedef MemberCaller<GraphTreeNode, void(), &GraphTreeNode::rowChanged> RowChangedCaller;
-};
+Reference<scene::Instance> m_instance;
+GraphTreeNode* m_parent;
+
+typedef ChildNodes::iterator iterator;
+typedef ChildNodes::key_type key_type;
+typedef ChildNodes::value_type value_type;
+typedef ChildNodes::size_type size_type;
+
+GraphTreeNode( scene::Instance& instance ) : m_instance( instance ), m_parent( 0 ){
+ m_instance.get().setChildSelectedChangedCallback( RowChangedCaller( *this ) );
+}
+~GraphTreeNode(){
+ m_instance.get().setChildSelectedChangedCallback( Callback<void()>() );
+ ASSERT_MESSAGE( empty(), "GraphTreeNode::~GraphTreeNode: memory leak" );
+}
+
+iterator begin(){
+ return m_childnodes.begin();
+}
+iterator end(){
+ return m_childnodes.end();
+}
+
+size_type size() const {
+ return m_childnodes.size();
+}
+bool empty() const {
+ return m_childnodes.empty();
+}
+
+iterator insert( const value_type& value ){
+ iterator i = m_childnodes.insert( value ).first;
+ ( *i ).second->m_parent = this;
+ return i;
+}
+void erase( iterator i ){
+ m_childnodes.erase( i );
+}
+iterator find( const key_type& key ){
+ return m_childnodes.find( key );
+}
-struct GraphTreeModel {
- GObject parent;
+void swap( GraphTreeNode& other ){
+ std::swap( m_parent, other.m_parent );
+ std::swap( m_childnodes, other.m_childnodes );
+ std::swap( m_instance, other.m_instance );
+}
- GraphTreeNode *m_graph;
+void rowChanged(){
+ graph_tree_model_row_changed( *this );
+}
+typedef MemberCaller<GraphTreeNode, void(), &GraphTreeNode::rowChanged> RowChangedCaller;
};
-struct GraphTreeModelClass {
- GObjectClass parent_class;
+struct GraphTreeModel
+{
+ GObject parent;
+
+ GraphTreeNode* m_graph;
};
-static GtkTreeModelFlags graph_tree_model_get_flags(ui::TreeModel tree_model)
+struct GraphTreeModelClass
{
- return GTK_TREE_MODEL_ITERS_PERSIST;
+ GObjectClass parent_class;
+};
+
+static GtkTreeModelFlags graph_tree_model_get_flags( ui::TreeModel tree_model ){
+ return GTK_TREE_MODEL_ITERS_PERSIST;
}
-static gint graph_tree_model_get_n_columns(ui::TreeModel tree_model)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- //GraphTreeModel* graph_tree_model = (GraphTreeModel*) tree_model;
+static gint graph_tree_model_get_n_columns( ui::TreeModel tree_model ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ //GraphTreeModel* graph_tree_model = (GraphTreeModel*) tree_model;
- return 2;
+ return 2;
}
static const gint c_stamp = 0xabcdef;
-inline GraphTreeNode::iterator graph_iterator_read_tree_iter(GtkTreeIter *iter)
-{
- ASSERT_MESSAGE(iter != 0, "tree model error");
- ASSERT_MESSAGE(iter->user_data != 0, "tree model error");
- ASSERT_MESSAGE(iter->stamp == c_stamp, "tree model error");
- return *reinterpret_cast<GraphTreeNode::iterator *>( &iter->user_data );
+inline GraphTreeNode::iterator graph_iterator_read_tree_iter( GtkTreeIter* iter ){
+ ASSERT_MESSAGE( iter != 0, "tree model error" );
+ ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
+ ASSERT_MESSAGE( iter->stamp == c_stamp, "tree model error" );
+ return *reinterpret_cast<GraphTreeNode::iterator*>( &iter->user_data );
}
-inline void graph_iterator_write_tree_iter(GraphTreeNode::iterator i, GtkTreeIter *iter)
-{
- ASSERT_MESSAGE(iter != 0, "tree model error");
- iter->stamp = c_stamp;
- *reinterpret_cast<GraphTreeNode::iterator *>( &iter->user_data ) = i;
- ASSERT_MESSAGE(iter->user_data != 0, "tree model error");
+inline void graph_iterator_write_tree_iter( GraphTreeNode::iterator i, GtkTreeIter* iter ){
+ ASSERT_MESSAGE( iter != 0, "tree model error" );
+ iter->stamp = c_stamp;
+ *reinterpret_cast<GraphTreeNode::iterator*>( &iter->user_data ) = i;
+ ASSERT_MESSAGE( iter->user_data != 0, "tree model error" );
}
-static GType graph_tree_model_get_column_type(ui::TreeModel tree_model, gint index)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- //GraphTreeModel *graph_tree_model = (GraphTreeModel *) tree_model;
+static GType graph_tree_model_get_column_type( ui::TreeModel tree_model, gint index ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ //GraphTreeModel *graph_tree_model = (GraphTreeModel *) tree_model;
- return G_TYPE_POINTER;
+ return G_TYPE_POINTER;
}
-static gboolean graph_tree_model_get_iter(GraphTreeModel *tree_model, GtkTreeIter *iter, ui::TreePath path)
-{
- ASSERT_MESSAGE(tree_model != 0, "RUNTIME ERROR");
- gint *indices = gtk_tree_path_get_indices(path);
- gint depth = gtk_tree_path_get_depth(path);
+static gboolean graph_tree_model_get_iter( GraphTreeModel* tree_model, GtkTreeIter* iter, ui::TreePath path ){
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ gint* indices = gtk_tree_path_get_indices( path );
+ gint depth = gtk_tree_path_get_depth( path );
- g_return_val_if_fail(depth > 0, FALSE);
+ g_return_val_if_fail( depth > 0, FALSE );
- GraphTreeNode *graph = tree_model->m_graph;
+ GraphTreeNode *graph = tree_model->m_graph;
- if (graph->empty()) {
- return FALSE;
- }
+ if ( graph->empty() ) {
+ return FALSE;
+ }
- GtkTreeIter tmp;
- GtkTreeIter *parent = 0;
+ GtkTreeIter tmp;
+ GtkTreeIter* parent = 0;
- for (gint i = 0; i < depth; i++) {
- if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(tree_model), iter, parent, indices[i])) {
- return FALSE;
- }
- tmp = *iter;
- parent = &tmp;
- }
+ for ( gint i = 0; i < depth; i++ )
+ {
+ if ( !gtk_tree_model_iter_nth_child( GTK_TREE_MODEL(tree_model), iter, parent, indices[i] ) ) {
+ return FALSE;
+ }
+ tmp = *iter;
+ parent = &tmp;
+ }
- return TRUE;
+ return TRUE;
}
-static ui::TreePath graph_tree_model_get_path(GraphTreeModel *tree_model, GtkTreeIter *iter)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- GraphTreeNode *graph = tree_model->m_graph;
+static ui::TreePath graph_tree_model_get_path( GraphTreeModel *tree_model, GtkTreeIter* iter ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ GraphTreeNode* graph = tree_model->m_graph;
auto path = ui::TreePath(ui::New);
- for (GraphTreeNode *node = (*graph_iterator_read_tree_iter(iter)).second; node != graph; node = node->m_parent) {
- std::size_t index = 0;
- for (GraphTreeNode::iterator i = node->m_parent->begin(); i != node->m_parent->end(); ++i, ++index) {
- if ((*i).second == node) {
- gtk_tree_path_prepend_index(path, gint(index));
- break;
- }
- }
- ASSERT_MESSAGE(index != node->m_parent->size(), "error resolving tree path");
- }
+ for ( GraphTreeNode* node = ( *graph_iterator_read_tree_iter( iter ) ).second; node != graph; node = node->m_parent )
+ {
+ std::size_t index = 0;
+ for ( GraphTreeNode::iterator i = node->m_parent->begin(); i != node->m_parent->end(); ++i, ++index )
+ {
+ if ( ( *i ).second == node ) {
+ gtk_tree_path_prepend_index( path, gint( index ) );
+ break;
+ }
+ }
+ ASSERT_MESSAGE( index != node->m_parent->size(), "error resolving tree path" );
+ }
- return path;
+ return path;
}
-static void graph_tree_model_get_value(ui::TreeModel tree_model, GtkTreeIter *iter, gint column, GValue *value)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- ASSERT_MESSAGE(column == 0 || column == 1, "tree model error");
+static void graph_tree_model_get_value( ui::TreeModel tree_model, GtkTreeIter *iter, gint column, GValue *value ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ ASSERT_MESSAGE( column == 0 || column == 1, "tree model error" );
- GraphTreeNode::iterator i = graph_iterator_read_tree_iter(iter);
+ GraphTreeNode::iterator i = graph_iterator_read_tree_iter( iter );
- g_value_init(value, G_TYPE_POINTER);
+ g_value_init( value, G_TYPE_POINTER );
- if (column == 0) {
- g_value_set_pointer(value, reinterpret_cast<gpointer>((*i).first.second ));
- } else {
- g_value_set_pointer(value, reinterpret_cast<gpointer>( &(*i).second->m_instance.get()));
- }
+ if ( column == 0 ) {
+ g_value_set_pointer( value, reinterpret_cast<gpointer>( ( *i ).first.second ) );
+ }
+ else
+ {
+ g_value_set_pointer( value, reinterpret_cast<gpointer>( &( *i ).second->m_instance.get() ) );
+ }
}
-static gboolean graph_tree_model_iter_next(ui::TreeModel tree_model, GtkTreeIter *iter)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- GraphTreeNode::iterator i = graph_iterator_read_tree_iter(iter);
- GraphTreeNode &parent = *(*i).second->m_parent;
+static gboolean graph_tree_model_iter_next( ui::TreeModel tree_model, GtkTreeIter *iter ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ GraphTreeNode::iterator i = graph_iterator_read_tree_iter( iter );
+ GraphTreeNode& parent = *( *i ).second->m_parent;
- ASSERT_MESSAGE(i != parent.end(), "RUNTIME ERROR");
+ ASSERT_MESSAGE( i != parent.end(), "RUNTIME ERROR" );
- if (++i == parent.end()) {
- return FALSE;
- }
+ if ( ++i == parent.end() ) {
+ return FALSE;
+ }
- graph_iterator_write_tree_iter(i, iter);
+ graph_iterator_write_tree_iter( i, iter );
- return TRUE;
+ return TRUE;
}
-static gboolean graph_tree_model_iter_children(GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent)
-{
- ASSERT_MESSAGE(tree_model != 0, "RUNTIME ERROR");
- GraphTreeNode &node = (parent == 0) ? *tree_model->m_graph : *(*graph_iterator_read_tree_iter(parent)).second;
- if (!node.empty()) {
- graph_iterator_write_tree_iter(node.begin(), iter);
- return TRUE;
- }
+static gboolean graph_tree_model_iter_children( GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent ){
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeNode& node = ( parent == 0 ) ? *tree_model->m_graph : *( *graph_iterator_read_tree_iter( parent ) ).second;
+ if ( !node.empty() ) {
+ graph_iterator_write_tree_iter( node.begin(), iter );
+ return TRUE;
+ }
- return FALSE;
+ return FALSE;
}
-static gboolean graph_tree_model_iter_has_child(ui::TreeModel tree_model, GtkTreeIter *iter)
-{
- ASSERT_MESSAGE(tree_model, "RUNTIME ERROR");
- GraphTreeNode &node = *(*graph_iterator_read_tree_iter(iter)).second;
- return !node.empty();
+static gboolean graph_tree_model_iter_has_child( ui::TreeModel tree_model, GtkTreeIter *iter ){
+ ASSERT_MESSAGE( tree_model, "RUNTIME ERROR" );
+ GraphTreeNode& node = *( *graph_iterator_read_tree_iter( iter ) ).second;
+ return !node.empty();
}
-static gint graph_tree_model_iter_n_children(GraphTreeModel *tree_model, GtkTreeIter *parent)
-{
- ASSERT_MESSAGE(tree_model != 0, "RUNTIME ERROR");
- GraphTreeNode &node = (parent == 0) ? *tree_model->m_graph : *(*graph_iterator_read_tree_iter(parent)).second;
- return static_cast<gint>( node.size());
+static gint graph_tree_model_iter_n_children( GraphTreeModel *tree_model, GtkTreeIter *parent ){
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeNode& node = ( parent == 0 ) ? *tree_model->m_graph : *( *graph_iterator_read_tree_iter( parent ) ).second;
+ return static_cast<gint>( node.size() );
}
-static gboolean
-graph_tree_model_iter_nth_child(GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n)
-{
- ASSERT_MESSAGE(tree_model != 0, "RUNTIME ERROR");
- GraphTreeNode &node = (parent == 0) ? *tree_model->m_graph : *(*graph_iterator_read_tree_iter(parent)).second;
- if (static_cast<std::size_t>( n ) < node.size()) {
- GraphTreeNode::iterator i = node.begin();
- std::advance(i, n);
- graph_iterator_write_tree_iter(i, iter);
- return TRUE;
- }
+static gboolean graph_tree_model_iter_nth_child( GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n ){
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeNode& node = ( parent == 0 ) ? *tree_model->m_graph : *( *graph_iterator_read_tree_iter( parent ) ).second;
+ if ( static_cast<std::size_t>( n ) < node.size() ) {
+ GraphTreeNode::iterator i = node.begin();
+ std::advance( i, n );
+ graph_iterator_write_tree_iter( i, iter );
+ return TRUE;
+ }
- return FALSE;
+ return FALSE;
}
-static gboolean graph_tree_model_iter_parent(GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child)
-{
- ASSERT_MESSAGE(tree_model != 0, "RUNTIME ERROR");
- GraphTreeNode &node = *(*graph_iterator_read_tree_iter(child)).second;
- if (node.m_parent != tree_model->m_graph) {
- GraphTreeNode &parentParent = *node.m_parent->m_parent;
- for (GraphTreeNode::iterator i = parentParent.begin(); i != parentParent.end(); ++i) {
- if ((*i).second == node.m_parent) {
- graph_iterator_write_tree_iter(i, iter);
- return TRUE;
- }
- }
- }
- return FALSE;
+static gboolean graph_tree_model_iter_parent( GraphTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child ){
+ ASSERT_MESSAGE( tree_model != 0, "RUNTIME ERROR" );
+ GraphTreeNode& node = *( *graph_iterator_read_tree_iter( child ) ).second;
+ if ( node.m_parent != tree_model->m_graph ) {
+ GraphTreeNode& parentParent = *node.m_parent->m_parent;
+ for ( GraphTreeNode::iterator i = parentParent.begin(); i != parentParent.end(); ++i )
+ {
+ if ( ( *i ).second == node.m_parent ) {
+ graph_iterator_write_tree_iter( i, iter );
+ return TRUE;
+ }
+ }
+ }
+ return FALSE;
}
-static GObjectClass *g_parent_class = 0;
+static GObjectClass *g_parent_class = nullptr;
-namespace {
- scene::Node *g_null_node = 0;
+namespace
+{
+scene::Node* g_null_node = 0;
}
-class NullInstance : public scene::Instance {
+class NullInstance : public scene::Instance
+{
public:
- NullInstance() : scene::Instance(scene::Path(makeReference(*g_null_node)), 0, 0,
- Static<InstanceTypeCastTable>::instance())
- {
- }
+NullInstance() : scene::Instance( scene::Path( makeReference( *g_null_node ) ), 0, 0, Static<InstanceTypeCastTable>::instance() ){
+}
};
-namespace {
- NullInstance g_null_instance;
+namespace
+{
+NullInstance g_null_instance;
}
-static void graph_tree_model_init(GraphTreeModel *graph_tree_model)
-{
- graph_tree_model->m_graph = new GraphTreeNode(g_null_instance);
+static void graph_tree_model_init( GraphTreeModel *graph_tree_model ){
+ graph_tree_model->m_graph = new GraphTreeNode( g_null_instance );
}
-static void graph_tree_model_finalize(GObject *object)
-{
- auto graph_tree_model = reinterpret_cast<GraphTreeModel *>(object);
+static void graph_tree_model_finalize( GObject* object ){
+ auto graph_tree_model = reinterpret_cast<GraphTreeModel*>(object);
- delete graph_tree_model->m_graph;
+ delete graph_tree_model->m_graph;
- /* must chain up */
- (*g_parent_class->finalize)(object);
+ /* must chain up */
+ ( *g_parent_class->finalize )( object );
}
-static void graph_tree_model_class_init(GraphTreeModelClass *class_)
-{
- GObjectClass *object_class;
+static void graph_tree_model_class_init( GraphTreeModelClass *class_ ){
+ GObjectClass *object_class;
- g_parent_class = (GObjectClass *) g_type_class_peek_parent(class_);
- object_class = (GObjectClass *) class_;
+ g_parent_class = (GObjectClass*)g_type_class_peek_parent( class_ );
+ object_class = (GObjectClass *) class_;
- object_class->finalize = graph_tree_model_finalize;
+ object_class->finalize = graph_tree_model_finalize;
}
-static void graph_tree_model_tree_model_init(GtkTreeModelIface *iface)
-{
- iface->get_flags = reinterpret_cast<GtkTreeModelFlags (*)(GtkTreeModel *)>(graph_tree_model_get_flags);
- iface->get_n_columns = reinterpret_cast<gint (*)(GtkTreeModel *)>(graph_tree_model_get_n_columns);
- iface->get_column_type = reinterpret_cast<GType (*)(GtkTreeModel *, gint)>(graph_tree_model_get_column_type);
- iface->get_iter = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *,
- GtkTreePath *)>(graph_tree_model_get_iter);
- iface->get_path = reinterpret_cast<GtkTreePath *(*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_get_path);
- iface->get_value = reinterpret_cast<void (*)(GtkTreeModel *, GtkTreeIter *, gint,
- GValue *)>(graph_tree_model_get_value);
- iface->iter_next = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_iter_next);
- iface->iter_children = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *,
- GtkTreeIter *)>(graph_tree_model_iter_children);
- iface->iter_has_child = reinterpret_cast<gboolean (*)(GtkTreeModel *,
- GtkTreeIter *)>(graph_tree_model_iter_has_child);
- iface->iter_n_children = reinterpret_cast<gint (*)(GtkTreeModel *,
- GtkTreeIter *)>(graph_tree_model_iter_n_children);
- iface->iter_nth_child = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *,
- gint)>(graph_tree_model_iter_nth_child);
- iface->iter_parent = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *,
- GtkTreeIter *)>(graph_tree_model_iter_parent);
-}
-
-GType graph_tree_model_get_type(void)
-{
- static GType graph_tree_model_type = 0;
-
- if (!graph_tree_model_type) {
- static const GTypeInfo graph_tree_model_info =
- {
- sizeof(GraphTreeModelClass),
- 0, /* base_init */
- 0, /* base_finalize */
- (GClassInitFunc) graph_tree_model_class_init,
- 0, /* class_finalize */
- 0, /* class_data */
- sizeof(GraphTreeModel),
- 0, /* n_preallocs */
- (GInstanceInitFunc) graph_tree_model_init,
- 0
- };
-
- static const GInterfaceInfo tree_model_info =
- {
- (GInterfaceInitFunc) graph_tree_model_tree_model_init,
- 0,
- 0
- };
-
- graph_tree_model_type = g_type_register_static(G_TYPE_OBJECT, "GraphTreeModel",
- &graph_tree_model_info, (GTypeFlags) 0);
-
- g_type_add_interface_static(graph_tree_model_type,
- GTK_TYPE_TREE_MODEL,
- &tree_model_info);
- }
-
- return graph_tree_model_type;
-}
-
-GraphTreeModel *graph_tree_model_new()
-{
- auto graph_tree_model = reinterpret_cast<GraphTreeModel *>(g_object_new(graph_tree_model_get_type(), 0));
+static void graph_tree_model_tree_model_init( GtkTreeModelIface *iface ){
+ iface->get_flags = reinterpret_cast<GtkTreeModelFlags (*)(GtkTreeModel *)>(graph_tree_model_get_flags);
+ iface->get_n_columns = reinterpret_cast<gint (*)(GtkTreeModel *)>(graph_tree_model_get_n_columns);
+ iface->get_column_type = reinterpret_cast<GType (*)(GtkTreeModel *, gint)>(graph_tree_model_get_column_type);
+ iface->get_iter = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *, GtkTreePath *)>(graph_tree_model_get_iter);
+ iface->get_path = reinterpret_cast<GtkTreePath *(*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_get_path);
+ iface->get_value = reinterpret_cast<void (*)(GtkTreeModel *, GtkTreeIter *, gint, GValue *)>(graph_tree_model_get_value);
+ iface->iter_next = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_iter_next);
+ iface->iter_children = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *)>(graph_tree_model_iter_children);
+ iface->iter_has_child = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_iter_has_child);
+ iface->iter_n_children = reinterpret_cast<gint (*)(GtkTreeModel *, GtkTreeIter *)>(graph_tree_model_iter_n_children);
+ iface->iter_nth_child = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *, gint)>(graph_tree_model_iter_nth_child);
+ iface->iter_parent = reinterpret_cast<gboolean (*)(GtkTreeModel *, GtkTreeIter *, GtkTreeIter *)>(graph_tree_model_iter_parent);
+}
- return graph_tree_model;
+GType graph_tree_model_get_type( void ){
+ static GType graph_tree_model_type = 0;
+
+ if ( !graph_tree_model_type ) {
+ static const GTypeInfo graph_tree_model_info =
+ {
+ sizeof( GraphTreeModelClass ),
+ 0, /* base_init */
+ 0, /* base_finalize */
+ (GClassInitFunc) graph_tree_model_class_init,
+ 0, /* class_finalize */
+ 0, /* class_data */
+ sizeof( GraphTreeModel ),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) graph_tree_model_init,
+ 0
+ };
+
+ static const GInterfaceInfo tree_model_info =
+ {
+ (GInterfaceInitFunc) graph_tree_model_tree_model_init,
+ 0,
+ 0
+ };
+
+ graph_tree_model_type = g_type_register_static( G_TYPE_OBJECT, "GraphTreeModel",
+ &graph_tree_model_info, (GTypeFlags)0 );
+
+ g_type_add_interface_static( graph_tree_model_type,
+ GTK_TYPE_TREE_MODEL,
+ &tree_model_info );
+ }
+
+ return graph_tree_model_type;
}
-void graph_tree_model_delete(GraphTreeModel *model)
-{
- g_object_unref(G_OBJECT(model));
+GraphTreeModel* graph_tree_model_new(){
+ auto graph_tree_model = reinterpret_cast<GraphTreeModel*>(g_object_new( graph_tree_model_get_type(), 0 ));
+
+ return graph_tree_model;
}
-void graph_tree_model_row_changed(GraphTreeModel *model, GraphTreeNode::iterator i)
-{
- GtkTreeIter iter;
- graph_iterator_write_tree_iter(i, &iter);
+void graph_tree_model_delete( GraphTreeModel* model ){
+ g_object_unref( G_OBJECT( model ) );
+}
+
+void graph_tree_model_row_changed( GraphTreeModel* model, GraphTreeNode::iterator i ){
+ GtkTreeIter iter;
+ graph_iterator_write_tree_iter( i, &iter );
- auto tree_path = graph_tree_model_get_path(model, &iter);
+ auto tree_path = graph_tree_model_get_path(model, &iter );
- gtk_tree_model_row_changed(GTK_TREE_MODEL(model), tree_path, &iter);
+ gtk_tree_model_row_changed( GTK_TREE_MODEL( model ), tree_path, &iter );
- gtk_tree_path_free(tree_path);
+ gtk_tree_path_free( tree_path );
}
-void graph_tree_model_row_inserted(GraphTreeModel *model, GraphTreeNode::iterator i)
-{
- GtkTreeIter iter;
- graph_iterator_write_tree_iter(i, &iter);
+void graph_tree_model_row_inserted( GraphTreeModel* model, GraphTreeNode::iterator i ){
+ GtkTreeIter iter;
+ graph_iterator_write_tree_iter( i, &iter );
- auto tree_path = graph_tree_model_get_path(model, &iter);
+ auto tree_path = graph_tree_model_get_path(model, &iter );
- gtk_tree_model_row_inserted(GTK_TREE_MODEL(model), tree_path, &iter);
+ gtk_tree_model_row_inserted( GTK_TREE_MODEL( model ), tree_path, &iter );
- gtk_tree_path_free(tree_path);
+ gtk_tree_path_free( tree_path );
}
-void graph_tree_model_row_deleted(GraphTreeModel *model, GraphTreeNode::iterator i)
-{
- GtkTreeIter iter;
- graph_iterator_write_tree_iter(i, &iter);
+void graph_tree_model_row_deleted( GraphTreeModel* model, GraphTreeNode::iterator i ){
+ GtkTreeIter iter;
+ graph_iterator_write_tree_iter( i, &iter );
- auto tree_path = graph_tree_model_get_path(model, &iter);
+ auto tree_path = graph_tree_model_get_path(model, &iter );
- gtk_tree_model_row_deleted(GTK_TREE_MODEL(model), tree_path);
+ gtk_tree_model_row_deleted( GTK_TREE_MODEL( model ), tree_path );
- gtk_tree_path_free(tree_path);
+ gtk_tree_path_free( tree_path );
}
-void graph_tree_model_row_inserted(GraphTreeModel &model, GraphTreeNode::iterator i)
-{
- graph_tree_model_row_inserted(&model, i);
+void graph_tree_model_row_inserted( GraphTreeModel& model, GraphTreeNode::iterator i ){
+ graph_tree_model_row_inserted( &model, i );
}
-void graph_tree_model_row_deleted(GraphTreeModel &model, GraphTreeNode::iterator i)
-{
- graph_tree_model_row_deleted(&model, i);
+void graph_tree_model_row_deleted( GraphTreeModel& model, GraphTreeNode::iterator i ){
+ graph_tree_model_row_deleted( &model, i );
}
-const char *node_get_name(scene::Node &node);
+const char* node_get_name( scene::Node& node );
-const char *node_get_name_safe(scene::Node &node)
-{
- volatile intptr_t n = (intptr_t) &node; // see the comment on line 650
- if (n == 0) {
- return "";
- }
- return node_get_name(node);
+const char* node_get_name_safe( scene::Node& node ){
+ volatile intptr_t n = (intptr_t)&node; // see the comment on line 650
+ if ( n == 0 ) {
+ return "";
+ }
+ return node_get_name( node );
}
-GraphTreeNode *graph_tree_model_find_parent(GraphTreeModel *model, const scene::Path &path)
-{
- GraphTreeNode *parent = model->m_graph;
- for (scene::Path::const_iterator i = path.begin(); i != path.end() - 1; ++i) {
- GraphTreeNode::iterator child = parent->find(
- GraphTreeNode::key_type(node_get_name_safe((*i).get()), (*i).get_pointer()));
- ASSERT_MESSAGE(child != parent->end(), "ERROR");
- parent = (*child).second;
- }
- return parent;
+GraphTreeNode* graph_tree_model_find_parent( GraphTreeModel* model, const scene::Path& path ){
+ GraphTreeNode* parent = model->m_graph;
+ for ( scene::Path::const_iterator i = path.begin(); i != path.end() - 1; ++i )
+ {
+ GraphTreeNode::iterator child = parent->find( GraphTreeNode::key_type( node_get_name_safe( ( *i ).get() ), ( *i ).get_pointer() ) );
+ ASSERT_MESSAGE( child != parent->end(), "ERROR" );
+ parent = ( *child ).second;
+ }
+ return parent;
}
-void node_attach_name_changed_callback(scene::Node &node, const NameCallback &callback)
-{
- volatile intptr_t n = (intptr_t) &node; // see the comment on line 650
- if (n != 0) {
- Nameable *nameable = Node_getNameable(node);
- if (nameable != 0) {
- nameable->attach(callback);
- }
- }
+void node_attach_name_changed_callback( scene::Node& node, const NameCallback& callback ){
+ volatile intptr_t n = (intptr_t)&node; // see the comment on line 650
+ if ( n != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->attach( callback );
+ }
+ }
}
-
-void node_detach_name_changed_callback(scene::Node &node, const NameCallback &callback)
-{
- volatile intptr_t n = (intptr_t) &node; // see the comment on line 650
- if (n != 0) {
- Nameable *nameable = Node_getNameable(node);
- if (nameable != 0) {
- nameable->detach(callback);
- }
- }
+void node_detach_name_changed_callback( scene::Node& node, const NameCallback& callback ){
+ volatile intptr_t n = (intptr_t)&node; // see the comment on line 650
+ if ( n != 0 ) {
+ Nameable* nameable = Node_getNameable( node );
+ if ( nameable != 0 ) {
+ nameable->detach( callback );
+ }
+ }
}
-GraphTreeModel *scene_graph_get_tree_model(); // temp hack
+GraphTreeModel* scene_graph_get_tree_model(); // temp hack
-void graph_tree_node_foreach_pre(GraphTreeNode::iterator root, const Callback<void(GraphTreeNode::iterator)> &callback)
-{
- callback(root);
- for (GraphTreeNode::iterator i = (*root).second->begin(); i != (*root).second->end(); ++i) {
- graph_tree_node_foreach_pre(i, callback);
- }
+void graph_tree_node_foreach_pre( GraphTreeNode::iterator root, const Callback<void(GraphTreeNode::iterator)>& callback ){
+ callback( root );
+ for ( GraphTreeNode::iterator i = ( *root ).second->begin(); i != ( *root ).second->end(); ++i )
+ {
+ graph_tree_node_foreach_pre( i, callback );
+ }
}
-void graph_tree_node_foreach_post(GraphTreeNode::iterator root, const Callback<void(GraphTreeNode::iterator)> &callback)
-{
- for (GraphTreeNode::iterator i = (*root).second->begin(); i != (*root).second->end(); ++i) {
- graph_tree_node_foreach_post(i, callback);
- }
- callback(root);
+void graph_tree_node_foreach_post( GraphTreeNode::iterator root, const Callback<void(GraphTreeNode::iterator)>& callback ){
+ for ( GraphTreeNode::iterator i = ( *root ).second->begin(); i != ( *root ).second->end(); ++i )
+ {
+ graph_tree_node_foreach_post( i, callback );
+ }
+ callback( root );
}
-void graph_tree_model_row_changed(GraphTreeNode &node)
-{
- GraphTreeModel *model = scene_graph_get_tree_model();
- const scene::Instance &instance = node.m_instance.get();
+void graph_tree_model_row_changed( GraphTreeNode& node ){
+ GraphTreeModel* model = scene_graph_get_tree_model();
+ const scene::Instance& instance = node.m_instance.get();
- GraphTreeNode::iterator i = node.m_parent->find(
- GraphTreeNode::key_type(node_get_name_safe(instance.path().top().get()),
- instance.path().top().get_pointer()));
+ GraphTreeNode::iterator i = node.m_parent->find( GraphTreeNode::key_type( node_get_name_safe( instance.path().top().get() ), instance.path().top().get_pointer() ) );
- graph_tree_model_row_changed(model, i);
+ graph_tree_model_row_changed( model, i );
}
-void graph_tree_model_set_name(const scene::Instance &instance, const char *name)
-{
- GraphTreeModel *model = scene_graph_get_tree_model();
- GraphTreeNode *parent = graph_tree_model_find_parent(model, instance.path());
+void graph_tree_model_set_name( const scene::Instance& instance, const char* name ){
+ GraphTreeModel* model = scene_graph_get_tree_model();
+ GraphTreeNode* parent = graph_tree_model_find_parent( model, instance.path() );
- GraphTreeNode::iterator oldNode = parent->find(
- GraphTreeNode::key_type(node_get_name_safe(instance.path().top().get()),
- instance.path().top().get_pointer()));
- graph_tree_node_foreach_post(oldNode, ReferenceCaller<GraphTreeModel, void(
- GraphTreeNode::iterator), graph_tree_model_row_deleted>(*model));
- GraphTreeNode *node((*oldNode).second);
- parent->erase(oldNode);
+ GraphTreeNode::iterator oldNode = parent->find( GraphTreeNode::key_type( node_get_name_safe( instance.path().top().get() ), instance.path().top().get_pointer() ) );
+ graph_tree_node_foreach_post( oldNode, ReferenceCaller<GraphTreeModel, void(GraphTreeNode::iterator), graph_tree_model_row_deleted>( *model ) );
+ GraphTreeNode* node( ( *oldNode ).second );
+ parent->erase( oldNode );
- GraphTreeNode::iterator newNode = parent->insert(
- GraphTreeNode::value_type(GraphTreeNode::key_type(name, &instance.path().top().get()), node));
- graph_tree_node_foreach_pre(newNode, ReferenceCaller<GraphTreeModel, void(
- GraphTreeNode::iterator), graph_tree_model_row_inserted>(*model));
+ GraphTreeNode::iterator newNode = parent->insert( GraphTreeNode::value_type( GraphTreeNode::key_type( name, &instance.path().top().get() ), node ) );
+ graph_tree_node_foreach_pre( newNode, ReferenceCaller<GraphTreeModel, void(GraphTreeNode::iterator), graph_tree_model_row_inserted>( *model ) );
}
-void graph_tree_model_insert(GraphTreeModel *model, const scene::Instance &instance)
-{
- GraphTreeNode *parent = graph_tree_model_find_parent(model, instance.path());
+void graph_tree_model_insert( GraphTreeModel* model, const scene::Instance& instance ){
+ GraphTreeNode* parent = graph_tree_model_find_parent( model, instance.path() );
- GraphTreeNode::iterator i = parent->insert(GraphTreeNode::value_type(
- GraphTreeNode::key_type(node_get_name_safe(instance.path().top().get()),
- instance.path().top().get_pointer()),
- new GraphTreeNode(const_cast<scene::Instance &>( instance ))));
+ GraphTreeNode::iterator i = parent->insert( GraphTreeNode::value_type( GraphTreeNode::key_type( node_get_name_safe( instance.path().top().get() ), instance.path().top().get_pointer() ), new GraphTreeNode( const_cast<scene::Instance&>( instance ) ) ) );
- graph_tree_model_row_inserted(model, i);
+ graph_tree_model_row_inserted( model, i );
- node_attach_name_changed_callback(instance.path().top(), ConstReferenceCaller<scene::Instance, void(
- const char *), graph_tree_model_set_name>(instance));
+ node_attach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
}
-void graph_tree_model_erase(GraphTreeModel *model, const scene::Instance &instance)
-{
- node_detach_name_changed_callback(instance.path().top(), ConstReferenceCaller<scene::Instance, void(
- const char *), graph_tree_model_set_name>(instance));
+void graph_tree_model_erase( GraphTreeModel* model, const scene::Instance& instance ){
+ node_detach_name_changed_callback( instance.path().top(), ConstReferenceCaller<scene::Instance, void(const char*), graph_tree_model_set_name>( instance ) );
- GraphTreeNode *parent = graph_tree_model_find_parent(model, instance.path());
+ GraphTreeNode* parent = graph_tree_model_find_parent( model, instance.path() );
- GraphTreeNode::iterator i = parent->find(GraphTreeNode::key_type(node_get_name_safe(instance.path().top().get()),
- instance.path().top().get_pointer()));
+ GraphTreeNode::iterator i = parent->find( GraphTreeNode::key_type( node_get_name_safe( instance.path().top().get() ), instance.path().top().get_pointer() ) );
- graph_tree_model_row_deleted(model, i);
+ graph_tree_model_row_deleted( model, i );
- GraphTreeNode *node((*i).second);
- parent->erase(i);
- delete node;
+ GraphTreeNode* node( ( *i ).second );
+ parent->erase( i );
+ delete node;
}
+
#endif
+
+
#if 0
class TestGraphTreeModel
{
public:
TestGraphTreeModel(){
- gtk_init( 0, 0 );
+ gtk_init( 0, 0 );
- graph_type graph;
+ graph_type graph;
- scene::Node* root = *(scene::Node*)0xa0000000;
- scene::Node* node1 = (scene::Node*)0xa0000001;
- scene::Node* node2 = (scene::Node*)0xa0000002;
- scene::Node* node3 = (scene::Node*)0xa0000003;
- scene::Node* node4 = (scene::Node*)0xa0000004;
- scene::Instance* instance = (scene::Instance*)0xaaaaaaaa;
+ scene::Node* root = *(scene::Node*)0xa0000000;
+ scene::Node* node1 = (scene::Node*)0xa0000001;
+ scene::Node* node2 = (scene::Node*)0xa0000002;
+ scene::Node* node3 = (scene::Node*)0xa0000003;
+ scene::Node* node4 = (scene::Node*)0xa0000004;
+ scene::Instance* instance = (scene::Instance*)0xaaaaaaaa;
- scene::Path rootpath( root );
+ scene::Path rootpath( root );
- graph.insert( graph_type::value_type( rootpath, instance ) );
+ graph.insert( graph_type::value_type( rootpath, instance ) );
- rootpath.push( node1 );
- graph.insert( graph_type::value_type( rootpath, instance ) );
- rootpath.pop();
+ rootpath.push( node1 );
+ graph.insert( graph_type::value_type( rootpath, instance ) );
+ rootpath.pop();
- rootpath.push( node2 );
- graph.insert( graph_type::value_type( rootpath, instance ) );
- rootpath.push( node3 );
- graph.insert( graph_type::value_type( rootpath, instance ) );
- rootpath.pop();
- rootpath.push( node4 );
- graph.insert( graph_type::value_type( rootpath, instance ) );
- rootpath.pop();
- rootpath.pop();
+ rootpath.push( node2 );
+ graph.insert( graph_type::value_type( rootpath, instance ) );
+ rootpath.push( node3 );
+ graph.insert( graph_type::value_type( rootpath, instance ) );
+ rootpath.pop();
+ rootpath.push( node4 );
+ graph.insert( graph_type::value_type( rootpath, instance ) );
+ rootpath.pop();
+ rootpath.pop();
- auto model = graph_tree_model_new( &graph );
+ auto model = graph_tree_model_new( &graph );
- {
- gint n_columns = gtk_tree_model_get_n_columns( model );
- ASSERT_MESSAGE( n_columns == 2, "test failed!" );
- }
+ {
+ gint n_columns = gtk_tree_model_get_n_columns( model );
+ ASSERT_MESSAGE( n_columns == 2, "test failed!" );
+ }
- {
- GType type = gtk_tree_model_get_column_type( model, 0 );
- ASSERT_MESSAGE( type == G_TYPE_POINTER, "test failed!" );
- }
+ {
+ GType type = gtk_tree_model_get_column_type( model, 0 );
+ ASSERT_MESSAGE( type == G_TYPE_POINTER, "test failed!" );
+ }
- {
- GType type = gtk_tree_model_get_column_type( model, 1 );
- ASSERT_MESSAGE( type == G_TYPE_POINTER, "test failed!" );
- }
+ {
+ GType type = gtk_tree_model_get_column_type( model, 1 );
+ ASSERT_MESSAGE( type == G_TYPE_POINTER, "test failed!" );
+ }
- {
- GtkTreeIter iter;
- gtk_tree_model_get_iter_first( model, &iter );
+ {
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter_first( model, &iter );
- graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
- ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node1, "test failed!" );
- }
+ graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
+ ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node1, "test failed!" );
+ }
- {
- GtkTreeIter iter;
- gtk_tree_model_get_iter_first( model, &iter );
+ {
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter_first( model, &iter );
- ASSERT_MESSAGE( gtk_tree_model_iter_has_child( model, &iter ) == FALSE, "test failed!" );
+ ASSERT_MESSAGE( gtk_tree_model_iter_has_child( model, &iter ) == FALSE, "test failed!" );
- ASSERT_MESSAGE( gtk_tree_model_iter_n_children( model, &iter ) == 0, "test failed!" );
+ ASSERT_MESSAGE( gtk_tree_model_iter_n_children( model, &iter ) == 0, "test failed!" );
- gtk_tree_model_iter_next( model, &iter );
+ gtk_tree_model_iter_next( model, &iter );
- ASSERT_MESSAGE( gtk_tree_model_iter_has_child( model, &iter ) != FALSE, "test failed!" );
+ ASSERT_MESSAGE( gtk_tree_model_iter_has_child( model, &iter ) != FALSE, "test failed!" );
- ASSERT_MESSAGE( gtk_tree_model_iter_n_children( model, &iter ) == 2, "test failed!" );
+ ASSERT_MESSAGE( gtk_tree_model_iter_n_children( model, &iter ) == 2, "test failed!" );
- {
- GtkTreeIter child;
- gtk_tree_model_iter_nth_child( model, &child, &iter, 0 );
+ {
+ GtkTreeIter child;
+ gtk_tree_model_iter_nth_child( model, &child, &iter, 0 );
- scene::Node* test;
- gtk_tree_model_get_value( model, &child, 0, (GValue*)&test );
- ASSERT_MESSAGE( test == node3, "test failed!" );
+ scene::Node* test;
+ gtk_tree_model_get_value( model, &child, 0, (GValue*)&test );
+ ASSERT_MESSAGE( test == node3, "test failed!" );
- {
- GtkTreeIter parent;
- gtk_tree_model_iter_parent( model, &parent, &child );
+ {
+ GtkTreeIter parent;
+ gtk_tree_model_iter_parent( model, &parent, &child );
- scene::Node* test;
- gtk_tree_model_get_value( model, &parent, 0, (GValue*)&test );
- ASSERT_MESSAGE( test == node2, "test failed!" );
- }
- }
+ scene::Node* test;
+ gtk_tree_model_get_value( model, &parent, 0, (GValue*)&test );
+ ASSERT_MESSAGE( test == node2, "test failed!" );
+ }
+ }
- {
- GtkTreeIter child;
- gtk_tree_model_iter_nth_child( model, &child, &iter, 1 );
+ {
+ GtkTreeIter child;
+ gtk_tree_model_iter_nth_child( model, &child, &iter, 1 );
- scene::Node* test;
- gtk_tree_model_get_value( model, &child, 0, (GValue*)&test );
- ASSERT_MESSAGE( test == node4, "test failed!" );
- }
- }
+ scene::Node* test;
+ gtk_tree_model_get_value( model, &child, 0, (GValue*)&test );
+ ASSERT_MESSAGE( test == node4, "test failed!" );
+ }
+ }
- {
- GtkTreeIter iter;
- std::size_t count = 0;
- for ( gboolean good = gtk_tree_model_get_iter_first( model, &iter ); good; good = gtk_tree_model_iter_next( model, &iter ) )
- {
- scene::Node* test;
- gtk_tree_model_get_value( model, &iter, 0, (GValue*)&test );
+ {
+ GtkTreeIter iter;
+ std::size_t count = 0;
+ for ( gboolean good = gtk_tree_model_get_iter_first( model, &iter ); good; good = gtk_tree_model_iter_next( model, &iter ) )
+ {
+ scene::Node* test;
+ gtk_tree_model_get_value( model, &iter, 0, (GValue*)&test );
- ASSERT_MESSAGE( ( count == 0 && test == node1 ) || ( count == 1 && test == node2 ), "test failed!" );
- ++count;
- }
+ ASSERT_MESSAGE( ( count == 0 && test == node1 ) || ( count == 1 && test == node2 ), "test failed!" );
+ ++count;
+ }
- ASSERT_MESSAGE( count == 2, "test failed!" );
+ ASSERT_MESSAGE( count == 2, "test failed!" );
- }
+ }
- {
- GtkTreeIter iter;
- gtk_tree_model_get_iter_first( model, &iter );
+ {
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter_first( model, &iter );
- scene::Node* test;
- gtk_tree_model_get_value( model, &iter, 0, (GValue*)&test );
- ASSERT_MESSAGE( test == node1, "test failed!" );
- }
+ scene::Node* test;
+ gtk_tree_model_get_value( model, &iter, 0, (GValue*)&test );
+ ASSERT_MESSAGE( test == node1, "test failed!" );
+ }
- {
- GtkTreeIter iter;
- auto path = ui::TreePath( "0" );
- gtk_tree_model_get_iter( model, &iter, path );
- gtk_tree_path_free( path );
+ {
+ GtkTreeIter iter;
+ auto path = ui::TreePath( "0" );
+ gtk_tree_model_get_iter( model, &iter, path );
+ gtk_tree_path_free( path );
- graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
- ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node1, "test failed!" );
- }
+ graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
+ ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node1, "test failed!" );
+ }
- {
- GtkTreeIter iter;
- auto path = ui::TreePath( "1" );
- gtk_tree_model_get_iter( model, &iter, path );
- gtk_tree_path_free( path );
+ {
+ GtkTreeIter iter;
+ auto path = ui::TreePath( "1" );
+ gtk_tree_model_get_iter( model, &iter, path );
+ gtk_tree_path_free( path );
- graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
- ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node2, "test failed!" );
- }
+ graph_type::iterator i = graph_iterator_read_tree_iter( &iter );
+ ASSERT_MESSAGE( ( *i ).first.get().size() == 2 && ( *i ).first.get().top() == node2, "test failed!" );
+ }
- {
- GtkTreeIter iter;
- graph_type::iterator i = graph.begin();
- ++i;
- graph_iterator_write_tree_iter( i, &iter );
+ {
+ GtkTreeIter iter;
+ graph_type::iterator i = graph.begin();
+ ++i;
+ graph_iterator_write_tree_iter( i, &iter );
- auto path = gtk_tree_model_get_path( model, &iter );
+ auto path = gtk_tree_model_get_path( model, &iter );
- gint depth = gtk_tree_path_get_depth( path );
- gint* indices = gtk_tree_path_get_indices( path );
+ gint depth = gtk_tree_path_get_depth( path );
+ gint* indices = gtk_tree_path_get_indices( path );
- ASSERT_MESSAGE( depth == 1 && indices[0] == 0, "test failed!" );
+ ASSERT_MESSAGE( depth == 1 && indices[0] == 0, "test failed!" );
- gtk_tree_path_free( path );
- }
+ gtk_tree_path_free( path );
+ }
- {
- GtkTreeIter iter;
- graph_type::iterator i = graph.begin();
- ++i;
- ++i;
- graph_iterator_write_tree_iter( i, &iter );
+ {
+ GtkTreeIter iter;
+ graph_type::iterator i = graph.begin();
+ ++i;
+ ++i;
+ graph_iterator_write_tree_iter( i, &iter );
- auto path = gtk_tree_model_get_path( model, &iter );
+ auto path = gtk_tree_model_get_path( model, &iter );
- gint depth = gtk_tree_path_get_depth( path );
- gint* indices = gtk_tree_path_get_indices( path );
-
- ASSERT_MESSAGE( depth == 1 && indices[0] == 1, "test failed!" );
+ gint depth = gtk_tree_path_get_depth( path );
+ gint* indices = gtk_tree_path_get_indices( path );
+
+ ASSERT_MESSAGE( depth == 1 && indices[0] == 1, "test failed!" );
- gtk_tree_path_free( path );
- }
+ gtk_tree_path_free( path );
+ }
}
};
projects / xonotic / netradiant.git / blobdiff