nodestreeview.cpp

3D仿真组实物机器人环境下的机器人模型的设计工具。可以查看和修改现有模型的详细参数

/*
*********************************************************************************
*                            In the name of Almighty                            *
*                                                                               *
*    NodesTreeView.cpp : Robocup Soccer Simulator Developement Team: Zigorat    *
*                                                                               *
*  Date: 07/08/2007                                                             *
*  Author: Mahdi Hamdarsi                                                       *
*  Research Coordinator: Amin Mohammadi                                         *
*  Comments: Node specific operations and view interface                        *
*                                                                               *
*********************************************************************************
*/

/*! \file NodesTreeView.cpp
<pre>
<b>File:</b>          NodesTreeView.cpp
<b>Project:</b>       Robocup Soccer Simulator Developement Team: Zigorat
<b>Authors:</b>       Mahdi Hamdarsi, Amin Mohammadi
<b>Created:</b>       12/02/2001
<b>Last Revision:</b> $ID$
<b>Contents:</b>      Node specific operations and view interface
<hr size=2>
<h2><b>Changes</b></h2>
<b>Date</b>             <b>Author</b>          <b>Comment</b>
07/08/2007       Mahdi Hamdarsi       Initial version created
</pre>
*/
#include <gtk/gtk.h>
#include <iostream>
#include <stdlib.h>

using namespace std;


#include "RubySceneGraph.h"
extern TRubySceneGraph * RubySceneGraph;

#include "Parse.h"
#include "Editor.h"
#include "support.h"

GtkWidget *m_Nodes_Treeview;
GtkTreeStore *m_Nodes_items_model;
extern GtkWidget *m_MainWindow;

enum
{
  COLUMN_ITEM_ID,
  COLUMN_ITEM_NAME,
  COLUMN_ITEM_SHAPE,
  NUM_ITEM_COLUMNS
};

gchar *getGtkString( TShape shape )
{
  if( shape == SHAPE_BOX )
    return g_strdup( "Box" );
  if( shape == SHAPE_SPHERE )
    return g_strdup( "Sphere" );
  if( shape == SHAPE_CAPSULE )
    return g_strdup( "CCylinder" );
  if( shape == SHAPE_CYLINDER )
    return g_strdup( "Not Implemented" );

  return g_strdup( "No Shape" );
}

gchar *getGtkString( TMaterial mat )
{
  if( mat == MAT_BLUE )
    return g_strdup( "matBlue" );
  else if( mat == MAT_DARKGREY )
    return g_strdup( "matDarkGrey" );
  else if( mat == MAT_GREEN )
    return g_strdup( "matGreen" );
  else if( mat == MAT_GREY )
    return g_strdup( "matGrey" );
  else if( mat == MAT_RED )
    return g_strdup( "matRed" );
  else if( mat == MAT_WHITE )
    return g_strdup( "matWhite" );
  else if( mat == MAT_YELLOW )
    return g_strdup( "matYellow" );

  return g_strdup( "matUnknown" );
}

void setNodeModelProps( TSceneNode * node, GtkTreeIter *iter )
{
  if( node == NULL )
  {
    cerr << "SetNodeModelProps: Node passed is null" << endl;
    return;
  }

  string par = node->getParrent() == NULL ? "TOP LEVEL" : node->getParrent()->getName();
  string name = node->getName() == "" ? node->getNodeName() : node->getName();
  gtk_tree_store_set( GTK_TREE_STORE(m_Nodes_items_model), iter,
                      COLUMN_ITEM_ID,       node->getID(),
                      COLUMN_ITEM_SHAPE,    getGtkString( node->getShape() ),
                      COLUMN_ITEM_NAME,     getGtkString( name ),
                      -1);
}

void AddNodeToTreeView( TSceneNode *node, GtkTreeIter iter )
{
  GtkTreeIter self_iter = iter;
  
  if( node == NULL )
  {
    cerr << "AddNodeToTree: Node passed is null" << endl;
    return;
  }
  
  setNodeModelProps( node, &self_iter );
  
  TNodeList children;
  node->queryNodes( children );

  if( children.size() == 0 )
    return;

  for( unsigned i = 0; i < children.size(); i++ )
    if( children[i]->getParrent() == node )
    {
      gtk_tree_store_append( GTK_TREE_STORE(m_Nodes_items_model), &iter, &self_iter );
      AddNodeToTreeView( children[i], iter );
    }
}

void UpdateNodesTree()
{
  if( !RubySceneGraph )
    return;

  GtkTreeIter iter;
  TSceneNode* node;
  while( gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_Nodes_items_model), &iter) == TRUE )
    gtk_tree_store_remove(GTK_TREE_STORE(m_Nodes_items_model), &iter);

  for( int i = 0; i < RubySceneGraph->getNodesCount(); i++)
  {
    node = RubySceneGraph->getNode( i );
    if( node == NULL )
    {
      cerr << "UpdateNodesTree: Node aqquired is null" << endl;
      return;
    }
  
    if( node->getParrent() != NULL )
      continue;
    
    gtk_tree_store_append( GTK_TREE_STORE(m_Nodes_items_model), &iter, NULL );
    AddNodeToTreeView( node, iter );
  }

  gtk_tree_view_expand_all(GTK_TREE_VIEW(m_Nodes_Treeview));
}

GtkTreeModel * CreateShapeMenu()
{
  const char *str[] = { "No Shape", "Box", "Sphere", "CCylinder" };
  GtkListStore *model;
  GtkTreeIter iter;

  model = gtk_list_store_new(1, G_TYPE_STRING);

  for( int i = 0; i < 4; i++)
    {
      gtk_list_store_append(model, &iter);
      gtk_list_store_set(model, &iter, 0, str[i], -1);
    }

  return GTK_TREE_MODEL(model);
}

GtkTreeModel * CreateMaterialMenu()
{
  const char *str[] = { "matRed", "matGreen", "matGrey", "matBlue", "matDarkGrey", "matWhite", "matYellow" };
  GtkListStore *model;
  GtkTreeIter iter;

  model = gtk_list_store_new(1, G_TYPE_STRING);

  for( int i = 0; i < 7; i++)
    {
      gtk_list_store_append (model, &iter);
      gtk_list_store_set (model, &iter, 0, str[i], -1);
    }

  return GTK_TREE_MODEL(model);
}

void AddNode(int shape)
{
  char str[20];
  int i = 0;
  do
  {
    sprintf( str, "not_named_yet_%d", i );
    i++;
  }while( RubySceneGraph->nodeExists( str ) );
  
  TMessage msg;
  msg.m_Name = str;                                                                             
  msg.m_Command = CMD_NODE_CREATE;
  msg.m_Shape = (TShape)shape;
  msg.m_Size = VecPosition(1,1,1);
  msg.m_Position = VecPosition(2,2,2);
  msg.m_Material = MAT_WHITE;
  msg.m_Mass = 1;
  msg.m_ParrentIndex = GetCurrentNodeIndex();

  UpdateLists( msg );
}

int GetCurrentNodeIndex()
{
  GtkTreeIter iter;
  GtkTreeView *tree = (GtkTreeView *)m_Nodes_Treeview;
  GtkTreeModel *model = gtk_tree_view_get_model(tree);
  GtkTreeSelection *selection = gtk_tree_view_get_selection(tree);
  guint ID = -1;

  if (gtk_tree_selection_get_selected(selection, NULL, &iter))
  {
    gint i;
    GtkTreePath *path;

    path = gtk_tree_model_get_path (model, &iter);
    i = gtk_tree_path_get_indices (path)[0];

    gtk_tree_model_get( model, &iter, COLUMN_ITEM_ID, &ID, -1 );
    gtk_tree_path_free (path);
  }
  
  return ID;
}

void RemoveCurrentNode()
{
  TMessage msg;
  msg.m_Command = CMD_NODE_DELETE;
  msg.m_Index = GetCurrentNodeIndex();
  UpdateLists( msg );
}

void InitializeNodesColoumns(GtkTreeView  *treeview, GtkTreeModel *items_model, GtkTreeModel *numbers_model, GtkTreeModel *materials_model)
{
  GtkCellRenderer *renderer;

  /* name column */
  renderer = gtk_cell_renderer_text_new ();
  g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_NAME));
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Node Name", renderer, "text", COLUMN_ITEM_NAME, NULL);
  
  /* shape column */
  renderer = gtk_cell_renderer_combo_new ();
  g_object_set (renderer, "model", numbers_model, "text-column", 0, "has-entry", FALSE, NULL);
  g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER(COLUMN_ITEM_SHAPE));
  gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Shape", renderer, "text", COLUMN_ITEM_SHAPE, NULL);
}

void LoadNodeProperties()
{
  int i = GetCurrentNodeIndex();
  if( i == -1 )
    return;

  const TSceneNode *node = RubySceneGraph->getNodeWithID( i );
  if( node == NULL )
    return;

  GtkWidget *temp;
  
  temp = lookup_widget(m_MainWindow, "txtNodeName");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getName()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeX");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getPosition().getX()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeY");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getPosition().getY()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeZ");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getPosition().getZ()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeLength");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getLength()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeWidth");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getWidth()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeHeight");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getHeight()) );
  
  temp = lookup_widget(m_MainWindow, "txtNodeParent");
  if( temp && node->getParrent() )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getParrent()->getName() ) );

  temp = lookup_widget(m_MainWindow, "txtNodeMass");
  if( temp )
    gtk_entry_set_text(GTK_ENTRY(temp), getGtkString(node->getMass()) );
}

void OnNodesCursorChange(GtkTreeView *treeview, gpointer user_data)
{
  LoadNodeProperties();
}

GtkWidget* InitNodesTreeView()
{
  GtkTreeModel *shape_menu;
  GtkTreeModel *materials_menu;
  GtkWidget *sw;

  /* create models */
  m_Nodes_items_model = gtk_tree_store_new(3, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
  shape_menu = CreateShapeMenu();
  materials_menu = CreateMaterialMenu();

  /* create tree view */
  m_Nodes_Treeview = gtk_tree_view_new_with_model( GTK_TREE_MODEL(m_Nodes_items_model));
  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (m_Nodes_Treeview), TRUE);
  gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_Nodes_Treeview)), GTK_SELECTION_SINGLE);

  InitializeNodesColoumns(GTK_TREE_VIEW(m_Nodes_Treeview), GTK_TREE_MODEL(m_Nodes_items_model), 
                            shape_menu, materials_menu);

  g_object_unref (shape_menu);
  g_object_unref (materials_menu);
  g_object_unref (m_Nodes_items_model);

  g_signal_connect ((gpointer) m_Nodes_Treeview, "cursor_changed", G_CALLBACK(OnNodesCursorChange), NULL);
  
  sw = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
  gtk_container_add(GTK_CONTAINER (sw), m_Nodes_Treeview);
  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW (m_Nodes_Treeview), TRUE);
  gtk_tree_selection_set_mode(gtk_tree_view_get_selection (GTK_TREE_VIEW (m_Nodes_Treeview)),
                              GTK_SELECTION_SINGLE);
  gtk_tree_view_expand_all(GTK_TREE_VIEW(m_Nodes_Treeview));
  return sw;
}