glui_treepanel.cpp
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:11k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. #include "GL/glui.h"
  2. /****************************** GLUI_TreePanel::GLUI_TreePanel() *********/
  3. GLUI_TreePanel::GLUI_TreePanel(GLUI_Node *parent, const char *name, 
  4.                                bool open, int inset)
  5. {
  6.   common_init();
  7.   set_name( name );
  8.   user_id    = -1;
  9.         
  10.   if ( !open ) {
  11.     is_open = false;
  12.     h = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
  13.   }
  14.   parent->add_control( this );
  15. }
  16. /****************************** GLUI_TreePanel::set_color() *********/
  17. void GLUI_TreePanel::set_color(float r, float g, float b) 
  18. {
  19.   red = r;
  20.   green = g;
  21.   blue = b;
  22.   redraw();
  23. }
  24. /************************ GLUI_TreePanel::set_level_color() *********/
  25. void GLUI_TreePanel::set_level_color(float r, float g, float b) 
  26. {
  27.   lred = r;
  28.   lgreen = g;
  29.   lblue = b;
  30.   redraw();
  31. }
  32. /****************************** GLUI_TreePanel::ab() *********/
  33. /* Adds branch to curr_root */
  34. GLUI_Tree *GLUI_TreePanel::ab(const char *name, GLUI_Tree *root) 
  35. {
  36.   GLUI_Tree *temp;
  37.   
  38.   if (root != NULL) {
  39.     resetToRoot(root);
  40.   }
  41.   temp = new GLUI_Tree(curr_root, name);
  42.   initNode(temp);
  43.   formatNode(temp);
  44.   curr_root = temp;
  45.   curr_branch = NULL; /* Currently at leaf */
  46.   if (dynamic_cast<GLUI_Tree*>(temp))
  47.     ((GLUI_Tree *)temp)->set_current(true);
  48.   //refresh();
  49.   //  glui->deactivate_current_control();
  50.   //glui->activate_control( temp, GLUI_ACTIVATE_TAB );
  51.   return temp;
  52. }
  53. /****************************** GLUI_TreePanel::fb() *********/
  54. /* Goes up one level, resets curr_root and curr_branch to parents*/
  55. void GLUI_TreePanel::fb(GLUI_Tree *branch) 
  56. {
  57.   if (((GLUI_Panel *)branch) == ((GLUI_Panel *)this))
  58.     return;
  59.   if (((GLUI_Panel *)curr_branch) == ((GLUI_Panel *)this)) {
  60.     resetToRoot();
  61.     return;
  62.   }
  63.   if (((GLUI_Panel *)curr_root) == ((GLUI_Panel *)this)) {
  64.     resetToRoot();
  65.     return;
  66.   }
  67.   if (branch != NULL) {
  68.     if ( dynamic_cast<GLUI_Tree*>(branch) )
  69.       ((GLUI_Tree *)branch)->set_current(false);
  70.     curr_branch = (GLUI_Tree *)branch->next();
  71.     curr_root = (GLUI_Panel *)branch->parent();
  72.     if (curr_branch == NULL && (curr_root->collapsed_node).first_child() != NULL)
  73.       curr_branch = (GLUI_Tree *)(curr_root->collapsed_node).first_child();
  74.     if ( dynamic_cast<GLUI_Tree*>(curr_root) )
  75.       ((GLUI_Tree *)curr_root)->set_current(true);
  76.   } else {
  77.     if (curr_root != NULL) { /* up one parent */
  78.       if (dynamic_cast<GLUI_Tree*>(curr_root))
  79. ((GLUI_Tree *)curr_root)->set_current(false);
  80.       curr_branch = (GLUI_Tree *) curr_root->next();
  81.       curr_root = (GLUI_Panel *) curr_root->parent();
  82.       if (curr_branch == NULL && (curr_root->collapsed_node).first_child() != NULL)
  83. curr_branch = (GLUI_Tree *)(curr_root->collapsed_node).first_child();
  84.       if (dynamic_cast<GLUI_Tree*>(curr_root))
  85. ((GLUI_Tree *)curr_root)->set_current(true);
  86.     }
  87.   }
  88.   //refresh();
  89. }
  90. /****************************** GLUI_TreePanel::refresh() *********/
  91. void GLUI_TreePanel::refresh() 
  92. {
  93.   glui->deactivate_current_control();
  94.   glui->activate_control( curr_root, GLUI_ACTIVATE_TAB );
  95.   redraw();
  96. }
  97. /****************************** GLUI_TreePanel::initNode() *********/
  98. void GLUI_TreePanel::initNode(GLUI_Tree *temp) 
  99. {
  100.   if (temp == NULL)
  101.     return;
  102.   int level = temp->get_level();
  103.   int child_number = 1;
  104.   GLUI_Tree *ptree = dynamic_cast<GLUI_Tree*>(temp->parent());
  105.   if (ptree) {
  106.     level = ptree->get_level() + 1;
  107.     GLUI_Tree *prevTree = dynamic_cast<GLUI_Tree*>(temp->prev());
  108.     if (prevTree) {
  109.       child_number = prevTree->get_child_number() + 1;
  110.     }
  111.   } else if (dynamic_cast<GLUI_Tree*>(temp) && 
  112.              dynamic_cast<GLUI_TreePanel*>(temp->parent())) {
  113.     child_number = ++root_children;
  114.   }
  115.   temp->set_id(uniqueID());     // -1 if unset
  116.   temp->set_level(level);
  117.   temp->set_child_number(child_number);
  118. }
  119. /****************************** GLUI_TreePanel::formatNode() *********/
  120. void GLUI_TreePanel::formatNode(GLUI_Tree *temp) 
  121. {
  122.   if (temp == NULL)
  123.     return;
  124.   int level = temp->get_level();
  125.   int child_number = temp->get_child_number();
  126.   GLUI_String level_name="";
  127.   GLUI_String full_name="";
  128.   temp->level_name == "";
  129.   if (format & GLUI_TREEPANEL_DISPLAY_HIERARCHY) {
  130.     if (format & GLUI_TREEPANEL_HIERARCHY_LEVEL_ONLY) {
  131.       glui_format_str(level_name, "%d", level);
  132.     }
  133.     if (format & GLUI_TREEPANEL_HIERARCHY_NUMERICDOT) {
  134.       if ( dynamic_cast<GLUI_Tree*>(temp->parent()) )
  135.         glui_format_str(level_name, "%s.%d", 
  136.                         ((GLUI_Tree *)(temp->parent()))->level_name.c_str(), 
  137.                         child_number);
  138.       else
  139.         glui_format_str(level_name, "%d", child_number);
  140.     }
  141.   }
  142.   temp->set_level_color(lred, lgreen, lblue);
  143.   temp->set_format(format);
  144.   temp->level_name = level_name;
  145.   if (format & GLUI_TREEPANEL_ALTERNATE_COLOR) {
  146.     switch (level%8) {
  147.     case (7): temp->set_color(.5,.5,.5); break;
  148.     case (6): temp->set_color(.3,.5,.5); break;
  149.     case (5): temp->set_color(.5,.3,.5); break;
  150.     case (4): temp->set_color(.3,.3,.5); break;
  151.     case (3): temp->set_color(.5,.5,.3); break;
  152.     case (2): temp->set_color(.3,.5,.3); break;
  153.     case (1): temp->set_color(.5,.3,.3); break;
  154.     default: temp->set_color(.3,.3,.3);
  155.     }
  156.   } else {
  157.     temp->set_color(red,green,blue);
  158.   }
  159.   if (format & GLUI_TREEPANEL_DISABLE_BAR) {
  160.     temp->disable_bar();
  161.   } else {
  162.     if (format & GLUI_TREEPANEL_DISABLE_DEEPEST_BAR) {
  163.       temp->disable_bar();
  164.       if ( dynamic_cast<GLUI_Tree*>(curr_root) )
  165.         ((GLUI_Tree *)curr_root)->enable_bar();
  166.     } else
  167.       if (format & GLUI_TREEPANEL_CONNECT_CHILDREN_ONLY) {
  168.         temp->disable_bar();
  169.         if (temp->prev() && dynamic_cast<GLUI_Tree*>(temp->prev()) ) 
  170.         {
  171.           ((GLUI_Tree *)temp->prev())->enable_bar();
  172.         }
  173.       }
  174.   }
  175. }
  176. /****************************** GLUI_TreePanel::update_all() *********/
  177. void GLUI_TreePanel::update_all() 
  178. {
  179.   printf("GLUI_TreePanel::update_all() doesn't work yet. - JVKn");
  180.   return;
  181.   GLUI_Panel *saved_root = curr_root;
  182.   GLUI_Tree *saved_branch = curr_branch;
  183.   root_children = 0;
  184.   resetToRoot(this);
  185.   if (curr_branch && dynamic_cast<GLUI_Tree*>(curr_branch))
  186.     formatNode((GLUI_Tree *)curr_branch);
  187.   next();
  188.   while (curr_root && curr_branch != this->first_child()) {
  189.     if (curr_branch && dynamic_cast<GLUI_Tree*>(curr_branch)) {
  190.       formatNode((GLUI_Tree *)curr_branch);
  191.     }
  192.     next();
  193.   } 
  194.   curr_root = saved_root;
  195.   curr_branch = saved_branch;
  196. }
  197. /****************************** GLUI_TreePanel::expand_all() *********/
  198. void            GLUI_TreePanel::expand_all() 
  199. {
  200.   GLUI_Panel *saved_root = curr_root;
  201.   GLUI_Tree *saved_branch = curr_branch;
  202.   resetToRoot(this);
  203.   if (dynamic_cast<GLUI_Tree*>(curr_root))
  204.     ((GLUI_Tree*)curr_root)->open();
  205.   next();
  206.   while (curr_root != NULL && curr_branch != this->first_child()) {
  207.     if (dynamic_cast<GLUI_Tree*>(curr_root))
  208.       ((GLUI_Tree*)curr_root)->open();
  209.     next();
  210.   }
  211.   curr_root = saved_root;
  212.   curr_branch = saved_branch;
  213. }
  214. /****************************** GLUI_TreePanel::collapse_all() *********/
  215. void            GLUI_TreePanel::collapse_all() 
  216. {
  217.   GLUI_Panel *saved_root = curr_root;
  218.   GLUI_Tree *saved_branch = curr_branch;
  219.   resetToRoot(this);
  220.   next();
  221.   while (curr_root != NULL && curr_branch != this->first_child()) {
  222.     if (dynamic_cast<GLUI_Tree*>(curr_root) && 
  223.       curr_branch == NULL) { /* we want to close everything leaf-first */
  224.       ((GLUI_Tree*)curr_root)->close();
  225.       /* Rather than simply next(), we need to manually move the
  226.          curr_root because this node has been moved to the 
  227.          collapsed_node list */
  228.       curr_branch = (GLUI_Tree *)curr_root->next();
  229.       curr_root = (GLUI_Panel *)curr_root->parent();
  230.     } else
  231.       next();
  232.   }
  233.   curr_root = saved_root;
  234.   curr_branch = saved_branch;
  235. }
  236. /****************************** GLUI_TreePanel::db() *********/
  237. /* Deletes the curr_root */
  238. void GLUI_TreePanel::db(GLUI_Tree *root) 
  239. {
  240.   GLUI_Tree  *temp_branch;
  241.   GLUI_Panel *temp_root;
  242.   if (((GLUI_Control *)root) == ((GLUI_Control *)this))
  243.     return;
  244.   if (root != NULL) {
  245.     curr_root = (GLUI_Tree *)root;
  246.     curr_branch = NULL;
  247.   }
  248.   if (curr_root == NULL || ((GLUI_Panel *)curr_root) == ((GLUI_Panel *)this)) {
  249.     resetToRoot();
  250.     return;
  251.   }
  252.   temp_branch = (GLUI_Tree *)curr_root->next();              /* Next branch, if any */
  253.   temp_root   = (GLUI_Panel *)curr_root->parent();      /* new root */
  254.   curr_root->unlink();
  255.   delete curr_root;
  256.   curr_branch = (GLUI_Tree *) temp_branch;
  257.   curr_root   = (GLUI_Panel *) temp_root;
  258.   if (dynamic_cast<GLUI_Tree*>(curr_root))
  259.     ((GLUI_Tree *)curr_root)->open();
  260.   if ((format & GLUI_TREEPANEL_DISABLE_DEEPEST_BAR) == GLUI_TREEPANEL_DISABLE_DEEPEST_BAR) {
  261.     if (dynamic_cast<GLUI_Tree*>(curr_root) && ((GLUI_Tree *)curr_root->next()) == NULL)
  262.       ((GLUI_Tree *)curr_root)->disable_bar();
  263.   }
  264.   //refresh();
  265. }
  266. /****************************** GLUI_TreePanel::descendBranch() *********/
  267. /* Finds the very last branch of curr_root, resets vars */
  268. void            GLUI_TreePanel::descendBranch(GLUI_Panel *root) {
  269.   if (root)
  270.     resetToRoot(root);
  271.   else
  272.     resetToRoot(curr_root);
  273.   if (curr_branch != NULL && curr_branch != ((GLUI_Panel *)this)) {
  274.     if (dynamic_cast<GLUI_Tree*>(curr_root))
  275.       ((GLUI_Tree *)curr_root)->set_current(false);
  276.     descendBranch(curr_branch); 
  277.   } 
  278. }
  279. /****************************** GLUI_TreePanel::next() *********/
  280. void GLUI_TreePanel::next() 
  281. {
  282.   if (curr_root == NULL)
  283.     resetToRoot(this);
  284.   if (curr_branch == NULL && (curr_root->collapsed_node).first_child() != NULL)
  285.     curr_branch = (GLUI_Tree *)(curr_root->collapsed_node).first_child();
  286.   if (curr_branch != NULL && curr_branch != ((GLUI_Panel *)this)) {     /* Descend into branch */
  287.     if (dynamic_cast<GLUI_Tree*>(curr_root))
  288.       ((GLUI_Tree *)curr_root)->set_current(false);
  289.     resetToRoot(curr_branch);
  290.   } else if (curr_branch == NULL) {
  291.     fb(NULL);  /* Backup and move on */
  292.   }
  293. }
  294. /****************************** GLUI_TreePanel::resetToRoot() *********/
  295. /* Resets curr_root and curr branch to TreePanel and lastChild */
  296. void GLUI_TreePanel::resetToRoot(GLUI_Panel *new_root) 
  297. {
  298.   GLUI_Panel *root = this;
  299.   if (new_root != NULL)
  300.     root = new_root;
  301.   curr_root = root;
  302.   if (dynamic_cast<GLUI_Tree*>(curr_root))
  303.     ((GLUI_Tree *)curr_root)->set_current(true);
  304.   curr_branch = (GLUI_Tree *)root->first_child();
  305.   /* since Trees are collapsable, we need to check the collapsed nodes
  306.      in case the curr_root is collapsed */
  307.   if (curr_branch == NULL && (root->collapsed_node).first_child() != NULL) {
  308.     curr_branch = (GLUI_Tree *)(root->collapsed_node).first_child();
  309.   }
  310.   while (curr_branch && dynamic_cast<GLUI_Tree*>(curr_branch)) {
  311.     curr_branch=(GLUI_Tree *)curr_branch->next();
  312.   }
  313. }