开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
Flu_Tree_Browser.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：84k
源码类别：

生物技术

开发平台：

C/C++

Flu_Tree_Browser.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Flu_Tree_Browser.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 21:06:08  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*
  11.  * These files were imported into NCBI's CVS directly from FLU version 2.9.1.
  12.  * Modifications to the source are listed below.
  13.  *
  14.  * ==========================================================================
  15.  * $Log: Flu_Tree_Browser.cpp,v $
  16.  * Revision 1000.1  2004/06/01 21:06:08  gouriano
  17.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  18.  *
  19.  * Revision 1.6  2004/05/21 22:27:51  gorelenk
  20.  * Added PCH ncbi_pch.hpp
  21.  *
  22.  * Revision 1.5  2004/03/11 14:10:10  dicuccio
  23.  * Fixes for 64-bit compilation.  Cast away const from strchr() where needed
  24.  *
  25.  * Revision 1.4  2004/03/11 13:51:40  dicuccio
  26.  * Imported FLU version 2.9.1.  Altered export specifiers to match NCBI layout.
  27.  * Altered include paths to match NCBI toolkit layout.
  28.  *
  29.  * ==========================================================================
  30.  */
  31. // $Id: Flu_Tree_Browser.cpp,v 1000.1 2004/06/01 21:06:08 gouriano Exp $
  33. /***************************************************************
  34.  *                FLU - FLTK Utility Widgets 
  35.  *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
  36.  *
  37.  * This file and its content is protected by a software license.
  38.  * You should have received a copy of this license with this file.
  39.  * If not, please contact the Ohio Supercomputer Center immediately:
  40.  * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
  41.  * 
  42.  ***************************************************************/
  46. #include <ncbi_pch.hpp>
  47. #include <FL/Fl.H>
  48. #include <FL/fl_draw.H>
  49. #include <FL/math.h>
  50. #include <stdlib.h>
  52. #include <gui/widgets/FLU/Flu_Tree_Browser.h>
  53. #include <gui/widgets/FLU/flu_pixmaps.h>
  55. #define MAX( x, y ) ( (x)>(y) ? (x) : (y) )
  56. #define MIN( x, y ) ( (x)<(y) ? (x) : (y) )
  57. #define ABS( x ) ( (x)>0 ? (x) : -(x) )
  58. #define LERP( t, x0, x1 ) ( (x0) + (t)*( (x1) - (x0) ) )
  60. #ifdef USE_FLU_DND
  61. Flu_Tree_Browser :: DND_Object :: DND_Object() : Flu_DND( "DND_Object" )
  62. {
  63. }
  64. #endif
  66. Flu_Tree_Browser :: IntStack :: IntStack()
  67. {
  68.   _list = NULL;
  69.   _size = _bufferSize = 0;
  70. }
  72. Flu_Tree_Browser :: IntStack :: IntStack( const Flu_Tree_Browser::IntStack& s )
  73. {
  74.   _list = NULL;
  75.   _size = _bufferSize = 0;
  76.   *this = s;
  77. }
  79. Flu_Tree_Browser :: IntStack :: ~IntStack()
  80. {
  81.   clear();
  82. }
  84. Flu_Tree_Browser::IntStack& Flu_Tree_Browser :: IntStack :: operator =( const Flu_Tree_Browser::IntStack& s )
  85. {
  86.   clear();
  87.   if( s._size )
  88.     {
  89.       _list = (int*)malloc( s._size*sizeof(int) );
  90.       memcpy( _list, s._list, s._size*sizeof(int) );
  91.       _size = _bufferSize = s._size;
  92.     }
  93.   return *this;
  94. }
  96. void Flu_Tree_Browser :: IntStack :: push( int i )
  97. {
  98.   if( _size == _bufferSize )
  99.     {
  100.       // allocate a new list
  101.       _bufferSize += 4;
  102.       int *newList = (int*)malloc( _bufferSize*sizeof(int) );
  103.       // copy the old list
  104.       if( _size > 0 )
  105. memcpy( newList, _list, _size*sizeof(int) );
  106.       if( _list )
  107. free( _list );
  108.       _list = newList;
  109.     }
  110.   // add the new item
  111.   _list[_size] = i;
  112.   _size++;
  113. }
  115. int Flu_Tree_Browser :: IntStack :: pop()
  116. {
  117.   if( _size == 0 )
  118.     return 0;
  119.   int val = _list[_size];
  120.   _size--;
  121.   return val;
  122. }
  124. void Flu_Tree_Browser :: IntStack :: clear()
  125. {
  126.   if( _list )
  127.     free( _list );
  128.   _list = NULL;
  129.   _size = _bufferSize = 0;
  130. }
  132. Flu_Tree_Browser :: NodeList :: NodeList()
  133. {
  134.   _nodes = NULL;
  135.   _nNodes = _size = 0;
  136. }
  138. Flu_Tree_Browser :: NodeList :: ~NodeList()
  139. {
  140.   clear();
  141. }
  143. typedef Flu_Tree_Browser::Node* NodeP;
  145. bool Flu_Tree_Browser :: NodeList :: search( const char *n, int &index )
  146. {
  147.   index = _nNodes;
  148.   if( _nNodes == 0 )
  149.     return false;
  151.   // we know we have at least one node. so use it to get the RData struct to find out what
  152.   // the insertion mode is
  153.   int iMode = _nodes[0]->tree->insertion_mode();
  155.   if( iMode == FLU_INSERT_SORTED || iMode == FLU_INSERT_SORTED_REVERSE )
  156.     return( binSearch( n, index ) );
  157.   else
  158.     return( linSearch( n, index ) );
  159. }
  161. bool Flu_Tree_Browser :: NodeList :: search( Node *n, int &index )
  162. {
  163.   index = _nNodes;
  164.   if( _nNodes == 0 )
  165.     return false;
  167.   // we know we have at least one node. so use it to get the RData struct to find out what
  168.   // the insertion mode is
  169.   int iMode = _nodes[0]->tree->insertion_mode();
  171.   if( iMode == FLU_INSERT_SORTED || iMode == FLU_INSERT_SORTED_REVERSE )
  172.     return( binSearch( n, index ) );
  173.   else
  174.     return( linSearch( n, index ) );
  175. }
  177. bool Flu_Tree_Browser :: NodeList :: linSearch( const char *n, int &index )
  178. {
  179.   index = _nNodes;
  180.   for( int i = 0; i < _nNodes; i++ )
  181.     {
  182.       if( strcmp( n, _nodes[i]->label() ) == 0 )
  183. {
  184.   index = i;
  185.   return true;
  186. }
  187.     }
  188.   return false;
  189. }
  191. bool Flu_Tree_Browser :: NodeList :: linSearch( Node *n, int &index )
  192. {
  193.   index = _nNodes;
  194.   for( int i = 0; i < _nNodes; i++ )
  195.     {
  196.       if( n == _nodes[i] )
  197. {
  198.   index = i;
  199.   return true;
  200. }
  201.     }
  202.   return false;
  203. }
  205. bool Flu_Tree_Browser :: NodeList :: binSearch( Node *n, int &index )
  206. {
  207.   if( binSearch( n->label(), index ) )
  208.     {
  209.       // the search found the first node with the label. since there are identical entries
  210.       // allowed, it may not be the actual node we want. therefore search forward until we find it
  211.       for( ; index < _nNodes; index++ )
  212. if( _nodes[index] == n )
  213.   return true;
  214.       return false;
  215.     }
  216.   else
  217.     return false;
  218. }
  220. bool Flu_Tree_Browser :: NodeList :: binSearch( const char *n, int &index )
  221. {
  222.   // do a binary search for a child with name == "n"
  223.   // return true if the child is found, and store its index in "index"
  224.   // return false if the child is not found, and store the index it would
  225.   // be in in "index"
  227.   // special case: no nodes
  228.   if( _nNodes == 0 )
  229.     {
  230.       index = 0;
  231.       return false;
  232.     }
  234.   // we know we have at least one node. so use it to get the RData struct to find out what
  235.   // the insertion mode is
  236.   int iMode = _nodes[0]->tree->insertion_mode();
  238.   // special case: 1 node
  239.   if( _nNodes == 1 )
  240.     {
  241.       int val = strcmp( n, _nodes[0]->label() );
  242.       if( iMode == FLU_INSERT_SORTED_REVERSE )
  243. val *= -1;
  244.       if( val == 0 )
  245. {
  246.   index = 0;
  247.   return true;
  248. }
  249.       else if( val < 0 )
  250. index = 0;
  251.       else
  252. index = 1;
  253.       return false;
  254.     }
  256.   int first = 0, last = _nNodes - 1;
  257.   int val1, val2, mVal;
  258.   for(;;)
  259.     {
  260.       // the range is down to 2 nodes
  261.       if( last == first + 1 )
  262. {
  263.   val1 = strcmp( n, _nodes[first]->label() );
  264.   if( iMode == FLU_INSERT_SORTED_REVERSE )
  265.     val1 = -val1;
  266.   if( val1 < 0 )
  267.     {
  268.       index = first;
  269.       return false;
  270.     }
  271.   else if( val1 == 0 )
  272.     {
  273.       index = first;
  274.       break;
  275.     }
  276.   val2 = strcmp( n, _nodes[last]->label() );
  277.   if( iMode == FLU_INSERT_SORTED_REVERSE )
  278.     val2 = -val2;
  279.   if( val2 < 0 )
  280.     {
  281.       index = last;
  282.       return false;
  283.     }
  284.   else if( val2 == 0 )
  285.     {
  286.       index = last;
  287.       break;
  288.     }
  289.   else
  290.     {
  291.       index = last+1;
  292.       return false;
  293.     }
  294. }
  296.       // pick which half of the array to search next
  297.       int midpoint = first + ((last-first)>>1);
  298.       mVal = strcmp( n, _nodes[midpoint]->label() );
  299.       if( iMode == FLU_INSERT_SORTED_REVERSE )
  300. mVal = -mVal;
  301.       if( mVal < 0 )
  302. last = midpoint;
  303.       else if( mVal > 0 )
  304. first = midpoint;
  305.       else
  306. {
  307.   index = midpoint;
  308.   break;
  309. }
  310.     }
  312.   // we found *a* node equal to "n", now find the first node equal to "n"
  313.   // by searching until we hit a node not equal to "n"
  314.   for( first = index; first > 0; first-- )
  315.     if( strcmp( n, _nodes[first-1]->label() ) != 0 )
  316.       break;
  317.   index = first;
  319.   return true;
  320. }
  322. int Flu_Tree_Browser :: NodeList :: compareNodes( const void *arg1, const void* arg2 )
  323. {
  324.   Flu_Tree_Browser::Node *n1 = *((Flu_Tree_Browser::Node**)arg1), *n2 = *((Flu_Tree_Browser::Node**)arg2);
  325.   return strcmp( n1->text.c_str(), n2->text.c_str() );
  326. }
  328. int Flu_Tree_Browser :: NodeList :: reverseCompareNodes( const void *arg1, const void* arg2 )
  329. {
  330.   Flu_Tree_Browser::Node *n1 = *((Flu_Tree_Browser::Node**)arg1), *n2 = *((Flu_Tree_Browser::Node**)arg2);
  331.   return( -strcmp( n1->text.c_str(), n2->text.c_str() ) );
  332. }
  334. void Flu_Tree_Browser :: NodeList :: sort()
  335. {
  336.   if( _nNodes )
  337.     {
  338.       // we know we have at least one node. so use it to get the RData struct to find out what
  339.       // the insertion mode is
  340.       int iMode = _nodes[0]->tree->insertion_mode();
  341.       if( iMode == FLU_INSERT_SORTED )
  342. qsort( _nodes, _nNodes, sizeof(Node*), compareNodes );
  343.       else if( iMode == FLU_INSERT_SORTED_REVERSE )
  344. qsort( _nodes, _nNodes, sizeof(Node*), reverseCompareNodes );
  345.     }
  346. }
  348. bool Flu_Tree_Browser :: Node :: move( Node* n1, int where, Node* n2 )
  349. {
  350.   if( isMoveValid( n1, where, n2 ) )
  351.     return( NodeList::move( n1, where, n2 ) );
  352.   else
  353.     return false;
  354. }
  356. void Flu_Tree_Browser :: Node :: sort()
  357. {
  358.   _children.sort();
  359.   for( int i = 0; i < _children.size(); i++ )
  360.     _children.child(i)->sort();
  361. }
  363. bool Flu_Tree_Browser :: Node :: is_ancestor( Node* n )
  364. {
  365.   Node *p = parent();
  366.   while( p )
  367.     {
  368.       if( p == n )
  369. return true;
  370.       else
  371. p = p->parent();
  372.     }
  373.   return false;
  374. }
  376. bool Flu_Tree_Browser :: Node :: is_descendent( Node* n )
  377. {
  378.   return n->is_ancestor( this );
  379. }
  381. bool Flu_Tree_Browser :: NodeList :: move( Node* n1, int where, Node* n2 )
  382. {
  383.   if( !n1 || !n2 )
  384.     return false;
  386.   if( n1->tree )
  387.     n1->tree->redraw();
  388.   if( n2->tree )
  389.     n2->tree->redraw();
  391.   // try to move n1 to the first child position of n2
  392.   if( where == MOVE_INSIDE )
  393.     {
  394.       if( !n2->is_branch() )
  395. return false;
  396.       // get the parent of n1
  397.       Node* p1 = n1->parent();
  398.       if( p1 )
  399. // remove n1 from its parent's list
  400. p1->_children.erase( n1 );
  401.       // insert into n2
  402.       int iMode = n1->tree->insertion_mode();
  403.       if( iMode == FLU_INSERT_SORTED || iMode == FLU_INSERT_SORTED_REVERSE )
  404. n2->_children.add( n1 );
  405.       else
  406. n2->_children.add( n1, 0 );
  407.       // update the parent of n1
  408.       n1->_parent = n2;
  409.       return true;
  410.     }
  412.   // find the position of n2 in its parent's list
  413.   Node* p2 = n2->parent();
  414.   if( !p2 )
  415.     return false;
  416.   int index = 0, removed = -1;
  417.   if( p2->_children.search( n2, index ) )
  418.     {
  419.       // get the parent of n1
  420.       Node* p1 = n1->parent();
  421.       if( p1 )
  422. // remove n1 from its parent's list. remember the position it was removed from
  423. removed = p1->_children.erase( n1 );
  425.       // if n1 and n2 have the same parent, and if n1 came before the spot where
  426.       // n2 will be inserted, then our indexing is off by one because n1 has been removed
  427.       if( p1 == p2 && removed <= index )
  428. index--;
  430.       if( where == MOVE_AFTER )
  431.        index++;
  433.       // insert n1 at the proper position
  434.       p2->_children.add( n1, index );
  436.       // update the parent of n1
  437.       n1->_parent = p2;
  438.     }
  440.   return true;
  441. }
  443. void Flu_Tree_Browser :: NodeList :: add( Node* n, int position )
  444. {
  445.   int i, index;
  446.   int mode = n->tree->insertion_mode();
  448.   // if the list is out of room, allocate a new one that's bigger
  449.   if( _nNodes == _size )
  450.     {
  451.       int newSize = ( _size == 0 ) ? 1 : _size*2; // double the size of the old list (same behavior as STL vector)
  452.       // allocate the new list
  453.       Node** newNodes = new NodeP[ newSize ];
  454.       // copy the old list to the new list
  455.       memcpy( newNodes, _nodes, _nNodes*sizeof(Node*) );
  456.       // delete the old list and replace it with the new list
  457.       delete[] _nodes;
  458.       //n->tree->rdata.cbNode = NULL;
  459.       _nodes = newNodes;
  460.       _size = newSize;
  461.     }
  463.   if( position >= 0 )
  464.     {
  465.       if( position > _nNodes )
  466. index = _nNodes;
  467.       else
  468. index = position;
  469.     }
  470.   else if( mode == FLU_INSERT_SORTED || mode == FLU_INSERT_SORTED_REVERSE )
  471.     {
  472.       // search through the list until we find where to insert the node
  473.       binSearch( n->label(), index );
  474.     }
  475.   else if( mode == FLU_INSERT_FRONT )
  476.     {
  477.       index = 0;
  478.     }
  479.   else if( mode == FLU_INSERT_BACK )
  480.     {
  481.       index = _nNodes;
  482.     }
  483.   else
  484.     return;
  486.   // shift all entries from the new insertion point down one spot
  487.   // to make room for the new node
  488.   for( i = _nNodes - 1; i >= index; i-- )
  489.     _nodes[i+1] = _nodes[i];
  491.   // add the new node
  492.   _nodes[index] = n;
  494.   _nNodes++;
  495. }
  497. int Flu_Tree_Browser :: NodeList :: erase( Node *n )
  498. {
  499.   if( n == NULL )
  500.     return -1;
  502.   int index;
  503.   if( search( n, index ) )
  504.     {
  505.       // move all the others down one spot to remove the node
  506.       for( int i = index; i < _nNodes-1; i++ )
  507. _nodes[i] = _nodes[i+1];
  508.       _nNodes--;
  510.       return index;
  511.     }
  512.   return -1;
  513. }
  515. int Flu_Tree_Browser :: NodeList :: erase( const char* n )
  516. {
  517.   if( _nNodes == 0 )
  518.     return -1;
  520.   int index;
  521.   if( search( n, index ) )
  522.     {
  523.       // move all the others down one spot to remove the node
  524.       for( int i = index; i < _nNodes-1; i++ )
  525. _nodes[i] = _nodes[i+1];
  526.       _nNodes--;
  527.       return index;
  528.     }
  529.   return -1;
  530. }
  532. void Flu_Tree_Browser :: NodeList :: erase( int n )
  533. {
  534.   // make sure n is in range
  535.   if( ( n < 0 ) || ( n >= _nNodes ) )
  536.     return;
  538.   // move all the others down one spot to remove the node
  539.   for( int i = n; i < _nNodes-1; i++ )
  540.     _nodes[i] = _nodes[i+1];
  542.   _nNodes--;
  543. }
  545. void Flu_Tree_Browser :: NodeList :: clear()
  546. {
  547.   if( _nodes )
  548.     {
  549.       //if( _nNodes )
  550.       //if( _nodes[0] )
  551.       //  _nodes[0]->tree->rdata.cbNode = NULL;
  552.       delete[] _nodes;
  553.     }
  554.   _nodes = NULL;
  555.   _nNodes = _size = 0;
  556. }
  558. int Flu_Tree_Browser :: NodeList :: findNum( const char *n )
  559. {
  560.   if( ( _nNodes == 0 ) || ( n == 0 ) )
  561.     return 0;
  563.   // see if there is a first node equal to "n"
  564.   int index, last;
  565.   if( !search( n, index ) )
  566.     return 0;
  568.   // now search forward until we hit a node not equal to "n"
  569.   for( last = index; last < _nNodes-1; last++ )
  570.     if( strcmp( n, _nodes[last+1]->label() ) != 0 )
  571.       break;
  573.   return last - index + 1;
  574. }
  576. Flu_Tree_Browser::Node* Flu_Tree_Browser :: NodeList :: find( const char* n, int which )
  577. {
  578.   if( ( _nNodes == 0 ) || ( n == 0 ) || ( which == 0 ) )
  579.     return NULL;
  581.   // see if there is a first node equal to "n"
  582.   int index, first;
  583.   if( !search( n, first ) )
  584.     return NULL;
  586.   // now search forward and try to find the which'th node named "n"
  587.   int total = 0;
  588.   for( index = first; index < _nNodes; index++ )
  589.     {
  590.       if( strcmp( n, _nodes[index]->label() ) == 0 )
  591. {
  592.   total++;
  593.   if( total == which )
  594.     break;
  595. }
  596.       else
  597. break;
  598.     }
  599.   if( total != which )
  600.     return NULL;
  602.   return _nodes[index];
  603. }
  605. #define SCROLL_SIZE 15
  607. Flu_Tree_Browser :: Flu_Tree_Browser( int x, int y, int w, int h, const char *l )
  608.   : Fl_Group( x, y, w, h )
  609. #ifdef USE_FLU_DND
  610.   , Flu_DND( "Flu_Tree_Browser" )
  611. #endif
  612. {
  613.   lastEvent = -1;
  614.   autoScrollX = autoScrollY = 0.0f;
  615. #ifdef USE_FLU_DND
  616.   dnd_allow_type( "Flu_Tree_Browser" );
  617.   dnd_allow_type( "DND_Object" );
  618.   dnd_allow_text( true );
  619. #endif
  621.   // add some widgets
  622.   _box = new Fl_Group( x, y, w-SCROLL_SIZE, h-SCROLL_SIZE );
  623.   _box->resizable( NULL );
  624.   _box->end();
  625.   scrollV = new Fl_Scrollbar( x+w-SCROLL_SIZE, y, SCROLL_SIZE, h-SCROLL_SIZE );
  626.   scrollV->type( FL_VERTICAL );
  627.   scrollV->callback( _scrollCB, this );
  628.   scrollV->value( 0, 1, 0, 0 );
  629.   scrollH = new Fl_Scrollbar( x, y+h-SCROLL_SIZE, w-SCROLL_SIZE, SCROLL_SIZE );
  630.   scrollH->type( FL_HORIZONTAL );
  631.   scrollH->callback( _scrollCB, this );
  632.   scrollH->value( 0, 1, 0, 0 );
  633.   scrollBox = new Fl_Group( x+w-SCROLL_SIZE, y+h-SCROLL_SIZE, SCROLL_SIZE, SCROLL_SIZE );
  634.   scrollBox->box( FL_UP_BOX );
  635.   scrollBox->end();
  636.   resizable( _box );
  638.   // set up the recursive data structure
  639.   memset( &rdata, 0, sizeof(rdata) );
  640.   rdata.root = &root;
  641.   root.tree = this;
  642.   rdata.tree = this;
  643.   rdata.dragging = false;
  644.   rdata.forceResize = true;
  645.   rdata.shiftSelect = false;
  646.   rdata.shiftSelectAll = false;
  647.   rdata.nextId = 1;
  648.   rdata.searchIndex = 1;
  649.   rdata.defaultCollapseIcons[0] = new Fl_Pixmap( (char*const*)plus_xpm );
  650.   rdata.defaultCollapseIcons[1] = new Fl_Pixmap( (char*const*)minus_xpm );
  651.   rdata.defaultBranchIcons[0] = new Fl_Pixmap( (char*const*)folder_closed_xpm );
  652.   rdata.defaultBranchIcons[1] = new Fl_Pixmap( (char*const*)folder_open_xpm );
  654.   end();
  656.   // set the default values for the tree
  657.   auto_branches( false );
  658.   animate( false );
  659.   collapse_time( 0.1f );
  660.   double_click_opens( true );
  661.   move_only_same_group( false );
  662.   frame_rate( 100.0f );
  663.   allow_leaf_duplication( true );
  664.   shaded_entry_colors( FL_WHITE, FL_WHITE );
  665.   collapse_icons( NULL, NULL );
  666.   //branch_icons( NULL, NULL );
  667.   rdata.branchIcons[0] = rdata.defaultBranchIcons[0];
  668.   rdata.branchIcons[1] = rdata.defaultBranchIcons[1];
  669.   leaf_icon( NULL );
  670.   branch_text( FL_BLACK, FL_HELVETICA_BOLD, 12 );
  671.   leaf_text( FL_BLACK, FL_HELVETICA, 12 );
  672.   callback( NULL );
  673.   when( FL_WHEN_CHANGED );
  674.   color( FL_WHITE );
  675.   selection_color( FL_SELECTION_COLOR );
  676.   box( FL_NO_BOX );
  677.   connector_style( FL_DARK2, FL_DOT );
  678.   selection_mode( FLU_MULTI_SELECT );
  679.   selection_drag_mode( FLU_DRAG_TO_SELECT );
  680.   insertion_mode( FLU_INSERT_SORTED );
  681.   show_connectors( true );
  682.   show_root( true );
  683.   show_leaves( true );
  684.   show_branches( true );
  685.   open_on_select( false );
  686.   //root_always_open( false );
  687.   horizontal_gap( 2 );
  688.   vertical_gap( 0 );
  689.   widget_gap( 2 );
  690.   set_root( l );
  691. }
  693. Flu_Tree_Browser :: ~Flu_Tree_Browser()
  694. {
  695.   Fl::remove_timeout( _timerRedrawCB, this );
  696.   Fl::remove_timeout( _timerScrollCB, this );
  698.   delete rdata.defaultCollapseIcons[0];
  699.   delete rdata.defaultCollapseIcons[1];
  701.   delete rdata.defaultBranchIcons[0];
  702.   delete rdata.defaultBranchIcons[1];
  703. }
  705. void Flu_Tree_Browser :: auto_branches( bool b )
  706. {
  707.   rdata.autoBranches = b;
  708. }
  710. void Flu_Tree_Browser :: collapse_icons( Fl_Image *closed, Fl_Image *open )
  711. {
  712.   if( closed )
  713.     rdata.collapseIcons[0] = closed;
  714.   else
  715.     rdata.collapseIcons[0] = rdata.defaultCollapseIcons[0];
  717.   if( open )
  718.     rdata.collapseIcons[1] = open;
  719.   else
  720.     rdata.collapseIcons[1] = rdata.defaultCollapseIcons[1];
  721. }
  723. void Flu_Tree_Browser :: branch_icons( Fl_Image *closed, Fl_Image *open )
  724. {
  725.   if( closed )
  726.     rdata.branchIcons[0] = closed;
  727.   //else
  728.   //rdata.branchIcons[0] = rdata.defaultBranchIcons[0];
  730.   if( open )
  731.     rdata.branchIcons[1] = open;
  732.   //else
  733.   //rdata.branchIcons[1] = rdata.defaultBranchIcons[1];
  734. }
  736. void Flu_Tree_Browser :: leaf_icon( Fl_Image *icon )
  737. {
  738.   rdata.leafIcon = icon;
  739. }
  741. void Flu_Tree_Browser :: resize( int X, int Y, int W, int H )
  742. {
  743.   Fl_Group::resize( X, Y, W, H );
  745.   int dx = Fl::box_dx(box()), dy = Fl::box_dy(box()), dw = Fl::box_dw(box()), dh = Fl::box_dh(box());
  747.   rdata.x = X+dx; rdata.y = Y+dy; rdata.totalW = rdata.x;
  748.   root.recurse( rdata, Node::MEASURE );
  749.   rdata.totalW -= X-dx;
  750.   rdata.totalH = rdata.y - Y-dy;
  752.   // if the size of the tree is bigger than the window, turn on the scrollbars
  753.   bool hOn = false, vOn = false;
  754.   if( rdata.totalW > W-dw )
  755.     hOn = true;
  756.   if( rdata.totalH > H-dh )
  757.     vOn = true;
  759.   // check if turning on one scrollbar actually forces the other to turn on
  760.   if( hOn && ( rdata.totalH > H-SCROLL_SIZE ) )
  761.     vOn = true;
  762.   if( vOn && ( rdata.totalW > W-SCROLL_SIZE ) )
  763.     hOn = true;
  765.   // now resize the other kids depending on the state of the scrollbars
  767.   _box->resize( X, Y, W, H );
  768.   if( hOn && vOn )  // both scrollbars on
  769.     {
  770.       scrollH->resize( X+dx, Y+H-SCROLL_SIZE-dy, W-SCROLL_SIZE-dw, SCROLL_SIZE );
  771.       scrollH->show();
  772.       scrollV->resize( X+W-SCROLL_SIZE-dx, Y+dy, SCROLL_SIZE, H-SCROLL_SIZE-dh );
  773.       scrollV->show();
  774.       scrollBox->resize( X+W-SCROLL_SIZE-dx, Y+H-SCROLL_SIZE-dy, SCROLL_SIZE, SCROLL_SIZE );
  775.       scrollBox->show();
  777.       // set the scrollbar sizes and values
  778.       int hDelta = rdata.totalW - W+dw + SCROLL_SIZE, scrollHW = scrollH->w()-SCROLL_SIZE-SCROLL_SIZE;
  779.       hDelta = MAX( hDelta, 0 );
  780.       scrollH->value( MIN( scrollH->value(), hDelta ), 1, 0, hDelta );
  781.       scrollH->slider_size( MAX( (float)SCROLL_SIZE/float(scrollHW), float(scrollHW-hDelta)/float(scrollHW) ) );
  783.       int vDelta = rdata.totalH - H+dh + SCROLL_SIZE, scrollVH = scrollV->h()-SCROLL_SIZE-SCROLL_SIZE;
  784.       vDelta = MAX( vDelta, 0 );
  785.       scrollV->value( MIN( scrollV->value(), vDelta ), 1, 0, vDelta );
  786.       scrollV->slider_size( MAX( (float)SCROLL_SIZE/float(scrollVH), float(scrollVH-vDelta)/float(scrollVH) ) );
  787.     }
  788.   else if( !hOn && !vOn )  // neither on
  789.     {
  790.       scrollH->hide();
  791.       scrollV->hide();
  792.       scrollBox->hide();
  793.     }
  794.   else if( hOn )  // just horizontal on
  795.     {
  796.       scrollH->resize( X+dx, Y+H-SCROLL_SIZE-dy, W-dw, SCROLL_SIZE );
  797.       scrollH->show();
  798.       scrollV->hide();
  799.       scrollBox->hide();
  801.       // set the scrollbar size and value
  802.       int hDelta = rdata.totalW - W+dw, scrollHW = scrollH->w()-SCROLL_SIZE-SCROLL_SIZE;
  803.       hDelta = MAX( hDelta, 0 );
  804.       scrollH->value( MIN( scrollH->value(), hDelta ), 1, 0, hDelta );
  805.       scrollH->slider_size( MAX( (float)SCROLL_SIZE/float(scrollHW), float(scrollHW-hDelta)/float(scrollHW) ) );
  806.     }
  807.   else if( vOn )  // just vertical on
  808.     {
  809.       scrollH->hide();
  810.       scrollV->resize( X+W-SCROLL_SIZE-dx, Y+dy, SCROLL_SIZE, H-dh );
  811.       scrollV->show();
  812.       scrollBox->hide();
  814.       // set the scrollbar size and value
  815.       int vDelta = rdata.totalH - H+dh, scrollVH = scrollV->h()-SCROLL_SIZE-SCROLL_SIZE;
  816.       vDelta = MAX( vDelta, 0 );
  817.       scrollV->value( MIN( scrollV->value(), vDelta ), 1, 0, vDelta );
  818.       scrollV->slider_size( MAX( (float)SCROLL_SIZE/float(scrollVH), float(scrollVH-vDelta)/float(scrollVH) ) );
  819.     }
  821.   rdata.browserX = _box->x() + dx;
  822.   rdata.browserY = _box->y() + dy;
  823.   rdata.browserW = _box->w() - dw;
  824.   rdata.browserH = _box->h() - dh;
  826.   redraw();
  828.   rdata.forceResize = true;  // weird hack to get the scrollbars to turn on right the first time
  829. }
  831. void Flu_Tree_Browser :: on_dnd_leave()
  832. {
  833. #ifdef USE_FLU_DND
  834.   rdata.isMoveValid = false;
  835.   redraw();
  837.   // X
  838.   if( scrollH->visible() )
  839.     {
  840.       float max = 0.01f * (scrollH->maximum() - scrollH->minimum());
  841.       if( max < 10.0f ) max = 10.0f;
  842.       if( autoScrollX > 0.0f )
  843. autoScrollX = max;
  844.       else
  845. autoScrollX = -max;
  846.     }
  848.   // Y
  849.   if( scrollV->visible() )
  850.     {
  851.       float max = 0.01f * (scrollV->maximum() - scrollV->minimum());
  852.       if( max < 10.0f ) max = 10.0f;
  853.       if( autoScrollY > 0.0f )
  854. autoScrollY = max;
  855.       else
  856. autoScrollY = -max;
  857.     }
  858. #endif
  859. }
  861. bool Flu_Tree_Browser :: on_dnd_drag( int X, int Y )
  862. {
  863. #ifdef USE_FLU_DND
  864.   rdata.dragging = true;
  866.   autoScrollX = autoScrollY = 0.0f;
  868.   if( scrollH->visible() )
  869.     {
  870.       // auto-scroll the horizontal scrollbars based on how close to the left or right of the browser the mouse is
  871.       float min = 1.0f, max = 0.01f * (scrollH->maximum() - scrollH->minimum());
  872.       if( max < 10.0f ) max = 10.0f;
  873.       if( X < (x()+30) ) // left
  874. {
  875.   float t = float((x()+30) - X) / 30.0f;
  876.   autoScrollX = -LERP( t*t, min, max );
  877.   if( !scrolledTimerOn )
  878.     Fl::add_timeout( 0.0, _timerScrollCB, this );
  879. }
  880.       else if( X > (x()+w()-30) ) // right
  881. {
  882.   float t = float(X - (x()+w()-30)) / 30.0f;
  883.   autoScrollX = LERP( t*t, min, max );
  884.   if( !scrolledTimerOn )
  885.     Fl::add_timeout( 0.0, _timerScrollCB, this );
  886. }
  887.     }
  889.   if( scrollV->visible() )
  890.     {
  891.       // auto-scroll the vertical scrollbars based on how close to the top or bottom of the browser the mouse is
  892.       float min = 1.0f, max = 0.01f * (scrollV->maximum() - scrollV->minimum());
  893.       if( max < 10.0f ) max = 10.0f;
  894.       if( Y < (y()+30) ) // top
  895. {
  896.   float t = float((y()+30) - Y) / 30.0f;
  897.   autoScrollY = -LERP( t*t, min, max );
  898.   if( !scrolledTimerOn )
  899.     Fl::add_timeout( 0.0, _timerScrollCB, this );
  900. }
  901.       else if( Y > (y()+h()-30) ) // bottom
  902. {
  903.   float t = float(Y - (y()+h()-30)) / 30.0f;
  904.   autoScrollY = LERP( t*t, min, max );
  905.   if( !scrolledTimerOn )
  906.     Fl::add_timeout( 0.0, _timerScrollCB, this );
  907. }
  908.     }
  910.   if( autoScrollX == 0.0f && autoScrollY == 0.0f )
  911.     {
  912.       Fl::remove_timeout( _timerScrollCB, this );
  913.       scrolledTimerOn = false;
  914.     }
  916.   int dx = Fl::box_dx(box()), dy = Fl::box_dy(box());
  917.   rdata.x = x()+dx; rdata.y = y()+dy;
  918.   if( scrollH->visible() )
  919.     rdata.x -= scrollH->value();
  920.   if( scrollV->visible() )
  921.     rdata.y -= scrollV->value();
  922.   rdata.delta = 0;
  923.   root.recurse( rdata, Node::HANDLE, FL_DND_DRAG );
  924.   rdata.isMoveValid = Fl::event_inside( this ) && Node::isMoveValid( rdata.grabbed, rdata.dragWhere, rdata.dragNode );
  926.   redraw();
  927.   Fl::flush();
  929.   if( rdata.isMoveValid )
  930.     return true;
  931.   else
  932. #endif
  933.     return false;
  934. }
  936. void Flu_Tree_Browser :: on_dnd_release()
  937. {
  938. #ifdef USE_FLU_DND
  939.   Fl::remove_timeout( _timerScrollCB, this );
  940.   scrolledTimerOn = false;
  941.   redraw();
  942.   Fl::flush();
  943. #endif
  944. }
  946. void Flu_Tree_Browser :: on_dnd_drop( const Flu_DND_Event *e )
  947. {
  948. #ifdef USE_FLU_DND
  949.   bool newNode = false;
  951.   if( !rdata.isMoveValid )
  952.     rdata.grabbed = 0;
  954.   else if( e->event_is_text() && rdata.dnd )
  955.     {
  956.       // create a new node with the text as the name and make it the grabbed node
  957.       rdata.grabbed = new Node( true, e->text(), NULL, rdata, NULL, true );
  958.       if( rdata.grabbed )
  959. newNode = true;
  960.     }
  962.   else
  963.     {
  964.       if( e->is_data_type( "Flu_Tree_Browser" ) )
  965. {
  966.   if( rdata.moveOnlySameGroup && ( rdata.grabbed->parent() != rdata.dragNode->parent() ) )
  967.     rdata.grabbed = NULL;
  968. }
  969.       else if( e->is_data_type( "DND_Object" ) && rdata.dnd )
  970. {
  971.   // create a new node with the text as the name and make it the grabbed node
  972.   DND_Object *o = (DND_Object*)e->data();
  973.   rdata.grabbed = new Node( true, o->name(), NULL, rdata, NULL, true );
  974.   if( rdata.grabbed )
  975.     {
  976.       rdata.grabbed->user_data( e->data() );
  977.       newNode = true;
  978.     }
  979. }
  980.       else
  981. rdata.grabbed = NULL;
  982.     }
  984.   // select only the new/moved node
  985.   root.unselect_all( rdata.grabbed );
  986.   set_hilighted( rdata.grabbed );
  987.   if( rdata.grabbed )
  988.     {
  989.       rdata.grabbed->select( true );
  990.   
  991.       // move the node
  992.       if( NodeList::move( rdata.grabbed, rdata.dragWhere, rdata.dragNode ) )
  993. {
  994.   if( newNode )
  995.     rdata.grabbed->do_callback( FLU_NEW_NODE );
  996.   else
  997.     rdata.grabbed->do_callback( FLU_MOVED_NODE );
  998. }
  999.       rdata.forceResize = true;
  1000.     }
  1001.   Fl::focus(this);
  1003.   rdata.dragging = false;
  1004.   rdata.grabbed = 0;
  1005.   rdata.dragNode = 0;
  1006.   Fl::remove_timeout( _timerScrollCB, this );
  1007.   scrolledTimerOn = false;
  1009.   redraw();
  1010. #endif
  1011. }
  1013. int Flu_Tree_Browser :: handle( int event )
  1014. {
  1015. #ifdef USE_FLU_DND
  1016.   if( dnd_handle( event ) )
  1017.     return 1;
  1018. #endif
  1020.   //if( event == FL_NO_EVENT || event == FL_MOVE )
  1021.   //return 0;
  1023.   if( event == FL_FOCUS && rdata.lastHilighted )
  1024.     {
  1025.       set_hilighted( rdata.lastHilighted );
  1026.       lastEvent = event;
  1027.       Fl_Group::handle( event );
  1028.       redraw();
  1029.       return 1;
  1030.     }
  1032.   if( event == FL_UNFOCUS )
  1033.     {
  1034.       if( lastEvent != FL_LEAVE )
  1035. {
  1036.   rdata.lastHilighted = rdata.hilighted;
  1037. }
  1038.       set_hilighted( NULL );
  1039.       lastEvent = event;
  1040.       Fl_Group::handle( event );
  1041.       redraw();
  1042.       return 1;
  1043.     }
  1045.   if( !rdata.dragging )
  1046.     {
  1047.       if( ! (event == FL_MOVE || event == FL_ENTER || event == FL_LEAVE ) )
  1048. _box->redraw();
  1049.       if( Fl_Group::handle( event ) )
  1050. {
  1051.   //if( event == FL_KEYDOWN || event == FL_KEYUP )
  1052.     // redraw();
  1053.   return 1;
  1054. }
  1055.     }
  1057.   if( event == FL_RELEASE )
  1058.     {
  1059.       Fl::focus(this);
  1060.       rdata.dragging = false;
  1061.       rdata.grabbed = 0;
  1062.       rdata.dragNode = 0;
  1063.       redraw();
  1064.     }
  1066.   int dx = Fl::box_dx(box()), dy = Fl::box_dy(box());
  1068.   // set some initial values for the recursive data structure
  1069.   // account for the scrollbar positions
  1070.   rdata.x = x()+dx; rdata.y = y()+dy;
  1071.   if( scrollH->visible() )
  1072.     rdata.x -= scrollH->value();
  1073.   if( scrollV->visible() )
  1074.     rdata.y -= scrollV->value();
  1076.   rdata.previous = NULL;
  1077.   rdata.delta = 0;
  1078.   rdata.visibilityChanged = false;
  1080.   // catch cursor keys for moving the hilighted entry or selecting all entries
  1081.   if( event == FL_KEYDOWN )
  1082.     {
  1083.       // move hilighted entry up
  1084.       if( Fl::event_key() == FL_Up )
  1085. {
  1086.   rdata.delta = -1;
  1087.   Fl::focus(this);
  1088.   redraw();
  1089. }
  1091.       // move hilighted entry down
  1092.       else if( Fl::event_key() == FL_Down )
  1093. {
  1094.   rdata.delta = 1;
  1095.   Fl::focus(this);
  1096.   redraw();
  1097. }
  1099.       // select all
  1100.       else if( Fl::event_state(FL_CTRL) && Fl::event_key() == 'a' )
  1101. {
  1102.   select_all();
  1103.   Fl::focus(this);
  1104.   redraw();
  1105.   return 1;
  1106. }
  1108.       // check for the Home key
  1109.       else if( Fl::event_key() == FL_Home )
  1110. {
  1111.   // set the hilighted entry to be the first entry
  1112.   if( rdata.showRoot || ( rdata.root->_children.size() == 0 ) )
  1113.     set_hilighted( rdata.root );
  1114.   else if( rdata.root->_children.size() > 0 )
  1115.     set_hilighted( rdata.root->_children.child(0) );
  1116.   redraw();
  1117. }
  1119.       // check for the End key
  1120.       else if( Fl::event_key() == FL_End )
  1121. {
  1122.   // set the hilighted entry to be the last visible entry
  1123.   if( rdata.showRoot && ( rdata.root->_children.size() == 0 ) )
  1124.     set_hilighted( rdata.root );
  1125.   else
  1126.     {
  1127.       // find the last node by repeatedly looking for the last child until there are no more branches
  1128.       Node *n = &root;
  1129.       while( n->_children.size() && n->open() )
  1130. n = n->_children.child( n->_children.size()-1 );
  1131.       set_hilighted( n );
  1132.     }
  1133.   redraw();
  1134. }
  1135.     }
  1137.   // pass the event down the tree
  1138.   int val = root.recurse( rdata, Node::HANDLE, event );
  1139.   if( val )
  1140.     {
  1141.       redraw();
  1142.       if( rdata.visibilityChanged )
  1143. root.determineVisibility();
  1144.       if( val == 1 )
  1145. return 1;
  1146.     }
  1147.   // special case: if multi-select or single-select and user clicks on no items, unselect all items
  1148.   else if( (rdata.selectionMode != FLU_NO_SELECT) && (event == FL_PUSH) && (!Fl::event_state(FL_CTRL)) )
  1149.     {
  1150.       unselect_all();
  1151.       set_hilighted( NULL );
  1152.       rdata.forceResize = true;
  1153.       redraw();
  1155.       return 1;
  1156.     }
  1158.   if( event == FL_SHOW || event == FL_HIDE )
  1159.     root.determineVisibility();
  1161.   return Fl_Group::handle( event );
  1162.   //return 0;
  1163. }
  1165. void Flu_Tree_Browser :: insertion_mode( int m )
  1166. {
  1167.   rdata.insertionMode = m;
  1168.   root.sort();
  1169. }
  1171. void Flu_Tree_Browser :: set_hilighted( Flu_Tree_Browser::Node* n )
  1172. {
  1173.   if( rdata.hilighted == n  &&  rdata.when != FL_WHEN_NOT_CHANGED )
  1174.     return;
  1176.   if( rdata.hilighted )
  1177.     rdata.hilighted->do_callback( FLU_UNHILIGHTED );
  1178.   rdata.hilighted = n;
  1179.   if( rdata.hilighted )
  1180.     rdata.hilighted->do_callback( FLU_HILIGHTED );
  1182.   if( rdata.hilighted )
  1183.     {
  1184.       int extraH = scrollH->visible() ? scrollH->h() : 0;
  1186.       // if the hilighted entry is below the visible bounds of the browser, move the vertical scrollbar
  1187.       // so the hilighted entry is the last visible entry
  1188.       if( rdata.hilighted->currentY-y()+rdata.hilighted->currentH > scrollV->value()+h()-extraH )
  1189. ((Fl_Valuator*)scrollV)->value( rdata.hilighted->currentY-y() - h()+extraH + rdata.hilighted->currentH );
  1191.       // if the hilighted entry is above the visible bounds of the browser, move the vertical scrollbar
  1192.       // so the hilighted entry is the first visible entry
  1193.       if( rdata.hilighted->currentY-y() < scrollV->value() )
  1194. ((Fl_Valuator*)scrollV)->value( rdata.hilighted->currentY-y() );
  1195.     }
  1196.   redraw();
  1197. }
  1199. int Flu_Tree_Browser :: num_selected()
  1200. {
  1201.   return root.recurse( rdata, Node::COUNT_SELECTED );
  1202. }
  1204. Flu_Tree_Browser::Node* Flu_Tree_Browser :: get_selected( int index )
  1205. {
  1206.   rdata.counter = 0;
  1207.   rdata.searchIndex = index;
  1208.   Node *n = root.modify( 0, Node::GET_SELECTED, rdata );
  1209.   rdata.searchIndex = 1;
  1210.   return n;
  1211. }
  1213. Flu_Tree_Browser :: Node :: Node( const char *lbl )
  1214. {
  1215.   flags = 0;
  1216.   userData = 0;
  1217.   _parent = 0;
  1218.   _widget = 0;
  1219.   SET(ACTIVE);
  1220.   CLEAR(LEAF);
  1221.   _id = 0;
  1222.   CLEAR(ALWAYS_OPEN);
  1223.   SET(COLLAPSED);
  1224.   SET(MOVABLE);
  1225.   SET(DROPPABLE);
  1226.   currentY = currentH = 0;
  1227.   totalChildH = 0;
  1228.   CLEAR(SELECTED);
  1229.   CLEAR(EXPAND_TO_WIDTH);
  1230.   SET(SHOW_LABEL);
  1231.   if( lbl == 0 )
  1232.     text = "";
  1233.   else
  1234.     text = lbl;
  1236.   cIcon[0] = cIcon[1] = bIcon[0] = bIcon[1] = lIcon = 0;
  1237. }
  1239. Flu_Tree_Browser :: Node :: Node( bool l, const char* n, Node *p, RData &rdata, Fl_Widget *w, bool showLbl )
  1240. {
  1241.   flags = 0;
  1242.   userData = 0;
  1243.   SET(LEAF,l);
  1244.   text = n;
  1245.   _id = 0;
  1246.   SET(ACTIVE);
  1247.   _parent = p;
  1248.   CLEAR(ALWAYS_OPEN);
  1249.   SET(COLLAPSED);
  1250.   CLEAR(SELECTED);
  1251.   CLEAR(EXPAND_TO_WIDTH);
  1252.   SET(MOVABLE);
  1253.   SET(DROPPABLE);
  1254.   _widget = 0;
  1255.   totalChildH = 0;
  1256.   currentY = currentH = 0;
  1257.   cIcon[0] = cIcon[1] = bIcon[0] = bIcon[1] = lIcon = 0;
  1258.   SET( SHOW_LABEL, showLbl );
  1259.   tree = rdata.tree;
  1261.   initType();
  1263.   _id = rdata.nextId++;
  1264.   widget( w );
  1265. }
  1267. void Flu_Tree_Browser :: Node :: initType()
  1268. {
  1269.   if( is_leaf() )
  1270.     {
  1271.       lIcon = tree->rdata.leafIcon;
  1272.       textColor = tree->rdata.defLeafColor;
  1273.       textFont = tree->rdata.defLeafFont;
  1274.       textSize = tree->rdata.defLeafSize;
  1275.     }
  1276.   else
  1277.     {
  1278.       cIcon[0] = tree->rdata.collapseIcons[0];
  1279.       cIcon[1] = tree->rdata.collapseIcons[1];
  1280.       bIcon[0] = tree->rdata.branchIcons[0];
  1281.       bIcon[1] = tree->rdata.branchIcons[1];
  1282.       textColor = tree->rdata.defBranchColor;
  1283.       textFont = tree->rdata.defBranchFont;
  1284.       textSize = tree->rdata.defBranchSize;
  1285.     }
  1286. }
  1288. Flu_Tree_Browser :: Node :: ~Node()
  1289. {
  1290.   // if this node is in a tree, make sure it isn't holding a reference to us
  1291.   if( tree )
  1292.     {
  1293.       if( tree->rdata.hilighted == this ) tree->rdata.hilighted = NULL;
  1294.       if( tree->rdata.lastHilighted == this ) tree->rdata.lastHilighted = NULL;
  1295.       if( tree->rdata.grabbed == this ) tree->rdata.grabbed = NULL;
  1296.       if( tree->rdata.dragNode == this ) tree->rdata.dragNode = NULL;
  1297.     }
  1298.   clear();
  1299. }
  1301. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: first()
  1302. {
  1303.   return this;
  1304. }
  1306. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: first_branch()
  1307. {
  1308.   Node *n = first();
  1309.   while( n )
  1310.     {
  1311.       if( n->is_branch() )
  1312. return n;
  1313.       else
  1314. n = n->next();
  1315.     }
  1316.   return NULL;
  1317. }
  1319. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: first_leaf()
  1320. {
  1321.   Node *n = first();
  1322.   while( n )
  1323.     {
  1324.       if( n->is_leaf() )
  1325. return n;
  1326.       else
  1327. n = n->next();
  1328.     }
  1329.   return NULL;
  1330. }
  1332. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: last()
  1333. {
  1334.   if( children() == 0 )
  1335.     return this;
  1336.   else
  1337.     return( child( children() - 1 )->last() );
  1338. }
  1340. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: last_branch()
  1341. {
  1342.   Node *n = last();
  1343.   while( n )
  1344.     {
  1345.       if( n->is_branch() )
  1346. return n;
  1347.       else
  1348. n = n->previous();
  1349.     }
  1350.   return NULL;
  1351. }
  1353. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: last_leaf()
  1354. {
  1355.   Node *n = last();
  1356.   while( n )
  1357.     {
  1358.       if( n->is_leaf() )
  1359. return n;
  1360.       else
  1361. n = n->previous();
  1362.     }
  1363.   return NULL;
  1364. }
  1366. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: next_sibling()
  1367. {
  1368.   if( is_root() )
  1369.     return NULL;
  1370.   int index;
  1371.   for( index = 0; index < _parent->children(); index++ )
  1372.     if( _parent->child(index) == this )
  1373.       break;
  1374.   // if we are the last child of our parent, then we have no next sibling
  1375.   if( index == _parent->children()-1 )
  1376.     return NULL;
  1377.   // otherwise return our next sibling
  1378.   else
  1379.     return( _parent->child(index+1) );
  1380. }
  1382. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: previous_sibling()
  1383. {
  1384.   if( is_root() )
  1385.     return NULL;
  1386.   int index;
  1387.   for( index = 0; index < _parent->children(); index++ )
  1388.     if( _parent->child(index) == this )
  1389.       break;
  1390.   // if we are the first child of our parent, then we have no previous sibling
  1391.   if( index == 0 )
  1392.     return NULL;
  1393.   // otherwise return our previous sibling
  1394.   else
  1395.     return( _parent->child(index-1) );
  1396. }
  1398. int Flu_Tree_Browser :: Node :: index() const
  1399. {
  1400.   if( is_root() )
  1401.     return -1;
  1402.   int index;
  1403.   for( index = 0; index < _parent->children(); index++ )
  1404.     if( _parent->child(index) == this )
  1405.       return index;
  1406.   return -1;
  1407. }
  1409. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: next()
  1410. {
  1411.   // take care of the root node as a special case
  1412.   if( is_root() )
  1413.     {
  1414.       if( children() )
  1415. return child(0);
  1416.       else
  1417. return NULL;
  1418.     }
  1420.   // if we are a branch, then the next node is our first child, unless we don't have any children
  1421.   if( is_branch() && _children.size() )
  1422.     return _children.child(0);
  1423.   else
  1424.     {
  1425.       // otherwise, the next node is our next sibling. if there is no next sibling (because we
  1426.       // are the last child of our parent), then the next node is the next sibling of our parent (and so on...)
  1427.       Node *p = parent(), *n = next_sibling();
  1428.       while( p )
  1429. {
  1430.   if( n )
  1431.     return n;
  1432.   else
  1433.     {
  1434.       n = p->next_sibling();
  1435.       p = p->parent();
  1436.     }
  1437. }
  1438.       return NULL;
  1439.     }
  1440. }
  1442. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: next_branch()
  1443. {
  1444.   Node *n = next();
  1445.   while( n )
  1446.     {
  1447.       if( n->is_branch() )
  1448. return n;
  1449.       else
  1450. n = n->next();
  1451.     }
  1452.   return NULL;
  1453. }
  1455. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: next_leaf()
  1456. {
  1457.   Node *n = next();
  1458.   while( n )
  1459.     {
  1460.       if( n->is_leaf() )
  1461. return n;
  1462.       else
  1463. n = n->next();
  1464.     }
  1465.   return NULL;
  1466. }
  1468. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: previous()
  1469. {
  1470.   // take care of the root node as a special case
  1471.   if( is_root() )
  1472.     return NULL;
  1474.   // the previous node is either our parent's
  1475.   // previous sibling (if that sibling exists and is a leaf or a branch with no children),
  1476.   // or the last child of our parent's previous sibling (if that sibling exists and is
  1477.   // a branch with children). if there is no previous sibling, then the previous node
  1478.   // is our parent
  1479.   Node *n = previous_sibling();
  1480.   if( !n )
  1481.     return _parent;
  1482.   else
  1483.     {
  1484.       if( n->is_leaf() )  // is leaf, so that is the previous node
  1485. return n;
  1486.       else if( n->children() )  // is branch with some children, so previous node is last child
  1487. return( n->last() );
  1488.       else  // is branch with no children, so that is the previous node
  1489. return n;
  1490.     }
  1491. }
  1493. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: previous_branch()
  1494. {
  1495.   Node *n = previous();
  1496.   while( n )
  1497.     {
  1498.       if( n->is_branch() )
  1499. return n;
  1500.       else
  1501. n = n->previous();
  1502.     }
  1503.   return NULL;
  1504. }
  1506. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: previous_leaf()
  1507. {
  1508.   Node *n = previous();
  1509.   while( n )
  1510.     {
  1511.       if( n->is_leaf() )
  1512. return n;
  1513.       else
  1514. n = n->previous();
  1515.     }
  1516.   return NULL;
  1517. }
  1519. void Flu_Tree_Browser :: Node :: determineVisibility( bool parentVisible )
  1520. {
  1521.   if( _widget )
  1522.     {
  1523.       if( parentVisible )
  1524. _widget->w->show();
  1525.       else
  1526. _widget->w->hide();
  1527.     }
  1528.   for( int i = 0; i < _children.size(); i++ )
  1529.     _children.child(i)->determineVisibility( parentVisible && open() );
  1530. }
  1532. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: child( int i ) const
  1533. {
  1534.   if( i < 0 || i >= _children.size() )
  1535.     return 0;
  1536.   else
  1537.     return _children.child(i);
  1538. }
  1540. void Flu_Tree_Browser :: Node :: clear()
  1541. {
  1542.   widget(NULL);
  1543.   for( int i = 0; i < _children.size(); i++ )
  1544.     {
  1545.       //if( tree->rdata.cbNode == _children.child(i) )
  1546.       //tree->rdata.cbNode = NULL;
  1547.       delete _children.child(i);
  1548.     }
  1549.   _children.clear();
  1550. }
  1552. void Flu_Tree_Browser :: Node :: print( int spaces )
  1553. {
  1554.   for( int s = 0; s < spaces; s++ )
  1555.     printf( " " );
  1556.   if( is_leaf() )
  1557.     printf( "  %sn", text.c_str() );
  1558.   else
  1559.     printf( "[%s]n", text.c_str() );
  1561.   for( int i = 0; i < _children.size(); i++ )
  1562.     _children.child(i)->print( spaces+2 );
  1563. }
  1565. void Flu_Tree_Browser :: draw()
  1566. {
  1567.   if( rdata.forceResize )
  1568.     {
  1569.       resize( x(), y(), w(), h() );
  1570.       rdata.forceResize = false;
  1571.     }
  1573.   // draw the background color
  1574.   fl_draw_box( FL_FLAT_BOX, _box->x(), _box->y(), _box->w(), _box->h(), _box->color() );
  1576.   int dx = Fl::box_dx(box()), dy = Fl::box_dy(box());
  1578.   // set up the recursive data structure
  1579.   rdata.x = x()+dx; rdata.y = y()+dy;
  1580.   // account for the positions of the scrollbars
  1581.   if( scrollH->visible() )
  1582.     rdata.x -= scrollH->value();
  1583.   if( scrollV->visible() )
  1584.     rdata.y -= scrollV->value();
  1585.   rdata.first = true;
  1586.   rdata.last = true;
  1587.   rdata.bgColor = _box->color();
  1588.   rdata.shadedIndex = 0;
  1590.   // pick the connector line and selection colors depending on the active state
  1591.   if( active() )
  1592.     {
  1593.       rdata.lineColor = rdata.defLineColor;
  1594.       rdata.selectionColor = rdata.defSelectionColor;
  1595.     }
  1596.   else
  1597.     {
  1598.       rdata.lineColor = fl_inactive( rdata.defLineColor );
  1599.       rdata.selectionColor = fl_inactive( rdata.defSelectionColor );
  1600.     }
  1602.   // draw the tree
  1603.   fl_push_clip( _box->x(), _box->y(), _box->w(), _box->h() );
  1604.   root.recurse( rdata, Node::DRAW );
  1606.   // if dragging to move, draw a bar showing where the dragged node will be inserted
  1607. #ifdef USE_FLU_DND
  1608.   if( dnd_is_dragging() && rdata.isMoveValid && rdata.dragging )
  1609.     {
  1610.       bool drawLine = false;
  1611.       if( dnd_event_is_text() )
  1612. drawLine = true;
  1613.       else if( dnd_is_data_type( "Flu_Tree_Browser" ) )
  1614. {
  1615.   if( !rdata.moveOnlySameGroup || ( rdata.grabbed->parent() == rdata.dragNode->parent() ) )
  1616.     drawLine = true;
  1617. }
  1618.       else if( dnd_is_data_type( "DND_Object" ) )
  1619. drawLine = true;
  1620.       if( drawLine && rdata.dragWhere != MOVE_INSIDE )
  1621. {
  1622.   fl_color( FL_RED );
  1623.   fl_line_style( FL_SOLID, 2 );
  1624.   fl_line( _box->x(), rdata.dragPos, _box->x()+_box->w(), rdata.dragPos );
  1625.   fl_line_style( 0 );
  1626. }
  1627.     }
  1628. #endif
  1630.   fl_pop_clip();
  1632.   // draw the kids
  1633.   draw_child( *scrollBox );
  1634.   draw_child( *scrollH );
  1635.   draw_child( *scrollV );
  1637.   // draw the box last so it's on top
  1638.   fl_draw_box( _box->box(), _box->x(), _box->y(), _box->w(), _box->h(), _box->color() );
  1639. }
  1641. inline void draw_T( int x, int y, int w, int h )
  1642. {
  1643.   int w2 = w >> 1;
  1644.   int h2 = h >> 1;
  1645.   fl_line( x+w2, y, x+w2, y+h );
  1646.   fl_line( x+w2, y+h2, x+w, y+h2 );
  1647. }
  1649. inline void draw_L( int x, int y, int w, int h )
  1650. {
  1651.   int w2 = w >> 1;
  1652.   int h2 = h >> 1;
  1653.   fl_line( x+w2, y, x+w2, y+h2 );
  1654.   fl_line( x+w2, y+h2, x+w, y+h2 );
  1655. }
  1657. inline void draw_Lflip( int x, int y, int w, int h )
  1658. {
  1659.   int w2 = w >> 1;
  1660.   int h2 = h >> 1;
  1661.   fl_line( x+w2, y+h, x+w2, y+h2 );
  1662.   fl_line( x+w2, y+h2, x, y+h2 );
  1663. }
  1665. inline void draw_Ldash( int x, int y, int w, int h )
  1666. {
  1667.   w = w >> 1;
  1668.   h = h >> 1;
  1669.   fl_line( x, y+h, x+w, y+h );
  1670. }
  1672. inline void draw_vert_dash( int x, int y, int w, int h )
  1673. {
  1674.   w = w >> 1;
  1675.   fl_line( x+w, y+(h>>1), x+w, y+h );
  1676. }
  1678. inline void draw_Rdash( int x, int y, int w, int h )
  1679. {
  1680.   h = h >> 1;
  1681.   fl_line( x+w, y+h, x+(w>>1), y+h );
  1682. }
  1684. void Flu_Tree_Browser :: Node :: draw( RData &rdata, bool measure )
  1685. {
  1686.   int which = open(); // i.e. which icon: open or closed?
  1687.   bool skipCollapser = is_root() && rdata.showRoot && ( CHECK(ALWAYS_OPEN) || rdata.allBranchesAlwaysOpen );
  1688.   int halfHGap = rdata.hGap >> 1, halfVGap = rdata.vGap >> 1;
  1689.   bool doDraw = !measure;
  1691.   int X = rdata.x;
  1692.   int Y = rdata.y;
  1694.   Fl_Color bgColor = rdata.shadedColors[rdata.shadedIndex], tColor = textColor, hilightColor = rdata.selectionColor;
  1696.   // pick the text color depending on the active state
  1697.   if( !rdata.tree->active() || !CHECK(ACTIVE))
  1698.     tColor = fl_inactive( tColor );
  1700.   if( doDraw )
  1701.     {
  1702.       // draw the background for the entry using the entry background color
  1703.       fl_draw_box( FL_FLAT_BOX, rdata.browserX, Y, rdata.browserW, currentH, bgColor );
  1705.       // if dragging to the inside of a branch, hilight that branch
  1706. #ifdef USE_FLU_DND
  1707.       if( tree->dnd_is_dragging() && rdata.isMoveValid && rdata.dragWhere == MOVE_INSIDE && rdata.dragNode == this )
  1708. {
  1709.   bgColor = FL_RED;
  1710.   tColor = fl_contrast( tColor, bgColor );
  1711.   hilightColor = rdata.bgColor;
  1712.   fl_draw_box( FL_FLAT_BOX, rdata.browserX, Y, rdata.browserW, currentH, bgColor );
  1713. }
  1714.       // if selected, draw a filled selection box and reverse the normal draw colors
  1715.       else if( CHECK(SELECTED) )
  1716. #else
  1717.       if( CHECK(SELECTED) )
  1718. #endif
  1719. {
  1720.   bgColor = rdata.selectionColor;
  1721.   tColor = fl_contrast( tColor, bgColor );
  1722.   hilightColor = rdata.bgColor;
  1723.   fl_draw_box( FL_FLAT_BOX, rdata.browserX, Y, rdata.browserW, currentH, bgColor );
  1724. }
  1726.       fl_color( rdata.lineColor );
  1727.       fl_line_style( rdata.lineStyle, rdata.lineWidth );
  1728.     }
  1730.   if( is_leaf() ) // draw leaves one way...
  1731.     {
  1732.       // draw the connectors
  1733.       if( doDraw && rdata.showConnectors && rdata.showBranches )
  1734. {
  1735.   if( rdata.last )
  1736.     draw_L( X-halfHGap, Y-halfVGap, rdata.branchIconW+rdata.hGap, currentH+rdata.vGap );
  1737.   else
  1738.     draw_T( X-halfHGap, Y-halfVGap, rdata.branchIconW+rdata.hGap, currentH+rdata.vGap );
  1739. }
  1741.       // account for leaf icon spacing
  1742.       if( rdata.showBranches )
  1743. {
  1744.   if( lIcon )
  1745.     X += rdata.collapseIcons[which]->w() + rdata.hGap;
  1746.   else
  1747.     X += rdata.collapseIcons[which]->w() + rdata.wGap;
  1748. }
  1749.       else 
  1750. X += rdata.wGap;
  1752.       // draw some more connectors
  1753.       if( doDraw && rdata.showConnectors && lIcon && rdata.showBranches )
  1754. draw_Ldash( X-halfHGap, Y-halfVGap, lIcon->w()+rdata.hGap, currentH+rdata.vGap );
  1756.       // draw the leaf icon
  1757.       if( lIcon )
  1758. {
  1759.   if( doDraw )
  1760.     lIcon->draw( X, Y+(currentH>>1)-(lIcon->h()>>1) );
  1761.   X += lIcon->w() + rdata.wGap;
  1762. }
  1763.     }
  1764.   else // ...and branches another
  1765.     {
  1766.       // force the root to the left if it has no visible children
  1767.       if( _parent == 0 && !CHECK(SOME_VISIBLE_CHILDREN) )
  1768. {
  1769.   skipCollapser = true;
  1770.   which = 0;
  1771. }
  1773.       if( !CHECK(SOME_VISIBLE_CHILDREN) && !rdata.showLeaves )
  1774. which = 0;
  1776.       // draw the connectors
  1777.       if( doDraw && !skipCollapser && rdata.showConnectors && rdata.showBranches )
  1778. {
  1779.   if( _parent==0 )
  1780.     {
  1781.       if( CHECK(SOME_VISIBLE_CHILDREN) )
  1782. draw_Rdash( X-halfHGap, Y-halfVGap, rdata.collapseIcons[which]->w()+4+rdata.hGap, currentH+rdata.vGap );
  1783.     }
  1784.   else if( rdata.last )
  1785.     draw_L( X-halfHGap, Y-halfVGap, rdata.branchIconW+rdata.hGap, currentH+rdata.vGap );
  1786.   else
  1787.     draw_T( X-halfHGap, Y-halfVGap, rdata.branchIconW+rdata.hGap, currentH+rdata.vGap );
  1788. }
  1790.       // draw the collapsed icons
  1791.       if( doDraw && !skipCollapser && !CHECK(ALWAYS_OPEN) && !rdata.allBranchesAlwaysOpen )
  1792. {
  1793.   if( CHECK(SOME_VISIBLE_CHILDREN) || rdata.showLeaves )
  1794.     {
  1795.       if( _parent==0 )
  1796. cIcon[which]->draw( X, Y+(currentH>>1)-(cIcon[which]->h()>>1) );
  1797.       else
  1798. cIcon[which]->draw( X+(rdata.branchIconW>>1)-(cIcon[which]->w()>>1), Y+(currentH>>1)-(cIcon[which]->h()>>1) );
  1799.     }
  1800. }
  1802.       if( !skipCollapser )
  1803. {
  1804.   X += cIcon[which]->w();
  1805.   if( bIcon[which] )
  1806.     X += rdata.hGap;
  1807.   else
  1808.     X += rdata.wGap;
  1809. }
  1811.       // draw some more connectors
  1812.       if( doDraw && rdata.showConnectors && rdata.showBranches )
  1813. {
  1814.   int hGap = rdata.hGap;
  1815.   if( bIcon[which] )
  1816.     hGap += bIcon[which]->w();
  1817.   if( skipCollapser && CHECK(SOME_VISIBLE_CHILDREN) )
  1818.     draw_vert_dash( X-halfHGap, Y-halfVGap, hGap, currentH+rdata.vGap );
  1819.   else if( !which || !CHECK(SOME_VISIBLE_CHILDREN) )
  1820.     draw_Ldash( X-halfHGap, Y-halfVGap, hGap, currentH+rdata.vGap );
  1821.   else
  1822.     draw_Lflip( X-halfHGap, Y-halfVGap, hGap, currentH+rdata.vGap );
  1823. }
  1825.       // draw the branch icon
  1826.       if( bIcon[which] )
  1827. {
  1828.   if( doDraw )
  1829.     bIcon[which]->draw( X, Y+(currentH>>1)-(bIcon[which]->h()>>1) );
  1830.   X += bIcon[which]->w() + rdata.wGap;
  1831. }
  1832.     }
  1834.   if( doDraw )
  1835.     fl_line_style( 0 );
  1837.   // draw the entry
  1838.   if( CHECK(SHOW_LABEL) )
  1839.     {
  1840.       if( doDraw )
  1841. {
  1842.   fl_draw_box( FL_FLAT_BOX, X, Y+(currentH>>1)-(textH>>1), textW, textH, bgColor );
  1843.   fl_color( tColor );
  1844.   fl_font( textFont, textSize );
  1845.   fl_draw( text.c_str(), X, Y+(currentH>>1)-(textH>>1), textW, textH, FL_ALIGN_LEFT );
  1846. }
  1847.       X += textW;
  1848.     }
  1849.   if( _widget )
  1850.     {
  1851.       int widgetW = _widget->w->w();
  1852.       int widgetH = _widget->w->h();
  1853.       if( doDraw )
  1854. {
  1855.   _widget->w->redraw();
  1856.   _widget->w->position( X, Y+(currentH>>1)-(widgetH>>1) );
  1857.   if( CHECK(EXPAND_TO_WIDTH) )
  1858.     _widget->w->size( MAX( _widget->defaultW, rdata.browserW - (X-rdata.browserX) ), _widget->w->h() );
  1859.   _widget->w->draw();
  1860. }
  1861.       if( CHECK(EXPAND_TO_WIDTH) )
  1862. {
  1863.   if( _widget->w->w() == _widget->defaultW )
  1864.     X += _widget->defaultW;
  1865. }
  1866.       else
  1867. X += widgetW;
  1868.     }
  1870.   // if hilighted, draw a box outlining the entry
  1871.   if( rdata.hilighted == this && doDraw )
  1872.     {
  1873.       fl_color( hilightColor );
  1874.       fl_line_style( FL_DOT, 1 );
  1875.       fl_rect( rdata.browserX, Y, rdata.browserW, currentH, hilightColor );
  1876.       fl_line_style( 0 );
  1877.     }
  1879.   rdata.totalW = MAX( rdata.totalW, X );
  1880. }
  1882. void Flu_Tree_Browser :: Node :: select( bool b )
  1883. {
  1884.   if( (CHECK(SELECTED)==b) && (tree->rdata.when != FL_WHEN_NOT_CHANGED) )
  1885.     return;
  1886.   SET(SELECTED,b);
  1887.   tree->redraw();
  1888.   if( tree->rdata.when == FL_WHEN_RELEASE )
  1889.     return;
  1890.   if( b )
  1891.     do_callback( FLU_SELECTED );
  1892.   else
  1893.     do_callback( FLU_UNSELECTED );
  1894. }
  1896. void Flu_Tree_Browser :: timerScrollCB()
  1897. {
  1898.   bool doRedraw = false;
  1900.   float val = scrollV->value() + autoScrollY;
  1901.   if( val < 0.0f )
  1902.     val = 0.0f;
  1903.   if( val > scrollV->maximum() )
  1904.     val = scrollV->maximum();
  1905.   doRedraw |= ( val != scrollV->value() );
  1906.   ((Fl_Valuator*)scrollV)->value( val );
  1908.   val = scrollH->value() + autoScrollX;
  1909.   if( val < 0.0f )
  1910.     val = 0.0f;
  1911.   if( val > scrollH->maximum() )
  1912.     val = scrollH->maximum();
  1913.   doRedraw |= ( val != scrollH->value() );
  1914.   ((Fl_Valuator*)scrollH)->value( val );
  1916.   Fl::repeat_timeout( 0.02, _timerScrollCB, this );
  1917.   scrolledTimerOn = true;
  1918.   if( doRedraw )
  1919.     redraw();
  1920. }
  1922. void Flu_Tree_Browser :: timerRedrawCB()
  1923. {
  1924.   if( rdata.animating )
  1925.     Fl::repeat_timeout( 1.0f/rdata.fps, _timerRedrawCB, this );
  1926.   redraw();
  1927. }
  1929. void Flu_Tree_Browser :: Node :: open( bool b )
  1930. {
  1931.   if( is_leaf() )
  1932.     return;
  1934.   if( CHECK(ALWAYS_OPEN) || tree->rdata.allBranchesAlwaysOpen )
  1935.     return;
  1937.   if( (open() == b) && (tree->rdata.when != FL_WHEN_NOT_CHANGED) )
  1938.     return;
  1940.   tree->rdata.justOpenedClosed = true;
  1942.   SET(COLLAPSED,!b);
  1944.   if( tree->rdata.animate )
  1945.     {
  1946.       // if we aren't yet animating a node, animate it!
  1947.       if( !tree->rdata.animating && !tree->rdata.animatedNode )
  1948. {
  1949.   // if we don't know how high all the children are, find out
  1950.   // (this only happens once per node, the first time it is opened)
  1951.   if( totalChildH == 0 )
  1952.     {
  1953.       RData r = tree->rdata;
  1954.       r.x = r.y = r.totalW = 0;
  1955.       recurse( r, Node::MEASURE_THIS_OPEN );
  1956.     }
  1957.   // set the initial offset based on whether the branch is open or closed
  1958.   tree->rdata.animationOffset = b ? -totalChildH : -1;
  1959.   // the delta is how much to change the offset each frame
  1960.   tree->rdata.animationDelta = totalChildH / ( tree->rdata.collapseTime * tree->rdata.fps );
  1961.   tree->rdata.animationDelta = b ? tree->rdata.animationDelta : -tree->rdata.animationDelta;
  1962.   tree->rdata.animating = true;
  1963.   tree->rdata.animatedNode = this;
  1964.   Fl::add_timeout( 1.0f/tree->rdata.fps, _timerRedrawCB, tree );
  1965. }
  1966.       // otherwise reverse the direction of the animation, only if we are animating this node
  1967.       else if( tree->rdata.animating && tree->rdata.animatedNode==this )
  1968. {
  1969.   if( b ^ (tree->rdata.animationDelta>0) )
  1970.     tree->rdata.animationDelta = -tree->rdata.animationDelta;
  1971. }
  1972.     }
  1974.   if( open() && (_parent != 0) ) // root node doesn't count as a single open branch
  1975.     {
  1976.       if( ( tree->rdata.lastOpenBranch != this ) && tree->rdata.singleBranchOpen )
  1977. tree->rdata.lastOpenBranch->close();
  1978.       tree->rdata.lastOpenBranch = this;
  1979.     }
  1981.   tree->rdata.forceResize = true;
  1982.   tree->rdata.visibilityChanged = true;
  1983.   if( b )
  1984.     do_callback( FLU_OPENED );
  1985.   else
  1986.     do_callback( FLU_CLOSED );
  1987. }
  1989. void Flu_Tree_Browser :: Node :: active( bool b )
  1990. {
  1991.   if( CHECK(ACTIVE) == b  &&  tree->rdata.when != FL_WHEN_NOT_CHANGED )
  1992.     return;
  1993.   SET( ACTIVE, b );
  1994.   if( _widget )
  1995.     {
  1996.       if( b )
  1997. _widget->w->activate();
  1998.       else
  1999. _widget->w->deactivate();
  2000.     }
  2001.   if( !CHECK(ACTIVE) )
  2002.     {
  2003.       if( tree->rdata.hilighted == this )
  2004. tree->set_hilighted( NULL );
  2005.       select( false );
  2006.       open( false );
  2007.     }
  2008. }
  2010. void Flu_Tree_Browser :: Node :: unselect_all( Node* except )
  2011. {
  2012.   if( this != except )
  2013.     select( false );
  2014.   for( int i = 0; i < _children.size(); i++ )
  2015.     _children.child(i)->unselect_all( except );
  2016. }
  2018. void Flu_Tree_Browser :: Node :: select_all()
  2019. {
  2020.   select( true );
  2021.   for( int i = 0; i < _children.size(); i++ )
  2022.     _children.child(i)->select_all();
  2023. }
  2025. bool Flu_Tree_Browser :: Node :: isMoveValid( Node* &n1, int &where, Node* &n2 )
  2026. {
  2027.   // if n1 is NULL, then check it as if it were a node being moved from another tree
  2029.   if( n2 == NULL )
  2030.     return false;
  2032.   // check the validity of the move:
  2033.   // 1) the source and destination nodes can't be the same
  2034.   // 2) you can't move before the root node
  2035.   // 3) you can't move an unmovable node or move a branch node such that it would become a descendent of itself
  2036.   // 4) if moving only within the same group, check that the parents are the same
  2037.   // 5) if moving into a sorted tree, the destination node MUST be a branch
  2038.   // 6) a move AFTER an OPEN branch is a move BEFORE its first child
  2039.   // 7) you can't move a node into a non-droppable branch node
  2041.   if( n1 == n2 )
  2042.     return false;
  2044.   if( where==MOVE_BEFORE && n2->is_root() )
  2045.     return false;
  2047.   if( n1 )
  2048.     {
  2049.       if( !n1->movable() )
  2050. return false;
  2051.       if( n1->is_branch() )
  2052. if( n1->is_descendent( n2 ) )
  2053.   return false;
  2054.     }
  2056.   bool sameGroup = n2->tree->move_only_same_group();
  2057.   if( sameGroup && n1 )
  2058.     {
  2059.       if( n1->parent() != n2->parent() || where==MOVE_INSIDE )
  2060. return false;
  2061.     }
  2063.   int iMode = n2->tree->insertion_mode();
  2064.   if( iMode == FLU_INSERT_SORTED || iMode == FLU_INSERT_SORTED_REVERSE )
  2065.     {
  2066.       if( n2->is_branch() )
  2067. {
  2068.   where = MOVE_INSIDE;
  2069.   return true;
  2070. }
  2071.       else
  2072. return false;
  2073.     }
  2075.   if( where==MOVE_AFTER && n2->is_branch() && n2->open() )
  2076.     {
  2077.       // can't move inside a branch if within the same group, unless the first node is dragged 
  2078.       // from outside the tree (in which case n1 is NULL)
  2079.       if( sameGroup && n1 )
  2080. {
  2081.   if( n2->_children.size() > 0 )
  2082.     return false;
  2083. }
  2084.       else if( n2->_children.size() > 0 )
  2085. {
  2086.   where = MOVE_BEFORE;
  2087.   n2 = n2->_children.child(0);
  2088. }
  2089.       else
  2090. where = MOVE_INSIDE;
  2091.     }
  2093.   if( where==MOVE_INSIDE )
  2094.     {
  2095.       if( !n2->droppable() )
  2096. return false;
  2097.     }
  2098.   else if( n2->parent() )
  2099.     if( !n2->parent()->droppable() )
  2100.       return false;
  2102.   return true;
  2103. }
  2105. int Flu_Tree_Browser :: Node :: recurse( RData &rdata, int type, int event )
  2106. {
  2107.   int i;
  2109.   if( type == COUNT_SELECTED )
  2110.     {
  2111.       if( is_leaf() )
  2112. return (int)CHECK(SELECTED);
  2113.       else
  2114. {
  2115.   int total = (int)CHECK(SELECTED);
  2116.   for( i = 0; i < _children.size(); i++ )
  2117.     total += _children.child(i)->recurse( rdata, type, event );
  2118.   return total;
  2119. }
  2120.     }
  2122.   // see if this entry is even visible
  2123.   if( rdata.y > rdata.browserY+rdata.browserH )
  2124.     {
  2125.       if( type == DRAW )
  2126. return 1;
  2127.       else if( type == HANDLE )
  2128. return 0;
  2129.     }
  2131.   int which = open();
  2132.   bool skipEntry = ( is_root() && !rdata.showRoot ) || ( is_leaf() && !rdata.showLeaves ) || ( is_branch() && !rdata.showBranches );
  2133.   bool skipCollapser = is_root() && rdata.showRoot && ( CHECK(ALWAYS_OPEN) || rdata.allBranchesAlwaysOpen );
  2135.   // find the size of the entry label
  2136.   if( (type == MEASURE) || (type == MEASURE_THIS_OPEN) )
  2137.     {
  2138.       if( CHECK(SHOW_LABEL) )
  2139. {
  2140.   int W = 0, H;
  2141.   fl_font( textFont, textSize );
  2142.   fl_measure( text.c_str(), W, H );
  2143.   W += 4; H += 4;  // hack - it looks better
  2144.   textW = W;
  2145.   textH = H;
  2146. }
  2147.       else
  2148. {
  2149.   textW = textH = 0;
  2150. }
  2152.       // remember vertically where this node is w.r.t the browser
  2153.       currentY = rdata.y;
  2155.       currentH = textH;
  2157.       // find the total size of the entry, depending on if there's a widget
  2158.       if( _widget )
  2159. currentH = MAX( _widget->w->h(), currentH );
  2161.       // find the total height of this entry by taking the max height of the entry and icons
  2162.       if( is_leaf() )
  2163. {
  2164.   if( lIcon )
  2165.     currentH = MAX( currentH, lIcon->h() );
  2166. }
  2167.       else
  2168. {
  2169.   currentH = MAX( currentH, cIcon[which]->h() );
  2170.   if( bIcon[which] )
  2171.     currentH = MAX( currentH, bIcon[which]->h() );
  2172. }
  2173.     }
  2175.   bool skipAhead = (rdata.y + currentH) < rdata.browserY;
  2177.   // process the entry
  2178.   switch( type )
  2179.     {
  2180.     case DRAW:
  2181.       {
  2182. if( skipEntry || skipAhead ) break;
  2184. draw( rdata, false );
  2186. // draw any vertical connectors connecting our aunts, great aunts, etc.,
  2187. if( rdata.showBranches )
  2188.   {
  2189.     int d = depth()-1;
  2190.     for( i = 0; i < rdata.branchConnectors.size(); i++ )
  2191.       {
  2192. if( i != d )
  2193.   {
  2194.     fl_color( rdata.lineColor );
  2195.     fl_line_style( rdata.lineStyle, rdata.lineWidth );
  2196.     fl_line( rdata.branchConnectors[i], rdata.y, rdata.branchConnectors[i], rdata.y+currentH );
  2197.     fl_line_style( 0 );
  2198.   }
  2199.       }
  2200.   }
  2202. rdata.shadedIndex = 1 - rdata.shadedIndex;  // toggle the even/odd entry for shading
  2203.       }
  2204.       break;
  2206.     case MEASURE:
  2207.       if( is_leaf() )
  2208. CLEAR( SOME_VISIBLE_CHILDREN );
  2209.       else
  2210. {
  2211.   // find out whether the branch has any children that could be visible
  2212.   bool someVisibleChildren = rdata.showLeaves && ( _children.size() > 0 );
  2213.   for( i = 0; i < _children.size(); i++ )
  2214.     {
  2215.       if( _children.child(i)->is_branch() )
  2216. {
  2217.   someVisibleChildren = true;
  2218.   break;
  2219. }
  2220.     }
  2221.   SET( SOME_VISIBLE_CHILDREN, someVisibleChildren );
  2222. }
  2223.     case MEASURE_THIS_OPEN:
  2224.       if( skipEntry ) break;
  2225.       draw( rdata, true );
  2226.       break;
  2228.     case HANDLE:
  2229.       {
  2230. if( skipEntry || skipAhead || !CHECK(ACTIVE) ) break;
  2232. if( event != FL_DRAG && event != FL_NO_EVENT )
  2233.   rdata.justOpenedClosed = false;
  2235. // if we are trying to select all entries between 2 widgets due to a shift-select...
  2236. if( rdata.shiftSelect )
  2237.   {
  2238.     if( (rdata.hilighted == this) || (rdata.grabbed == this) )
  2239.       {
  2240. if( !rdata.shiftSelectAll )
  2241.   {
  2242.     rdata.shiftSelectAll = true;
  2243.     select( true );
  2244.     if( is_branch() && rdata.openOnSelect )
  2245.       {
  2246. open( true );
  2247.       }
  2248.   }
  2249. else
  2250.   {
  2251.     rdata.shiftSelect = false;
  2252.     rdata.shiftSelectAll = false;
  2253.     rdata.grabbed = 0;
  2254.     select( true );
  2255.     if( is_branch() && rdata.openOnSelect )
  2256.       {
  2257. open( true );
  2258.       }
  2259.   }
  2260.       }
  2261.     else if( rdata.shiftSelectAll )
  2262.       {
  2263. select( true );
  2264. if( is_branch() && rdata.openOnSelect )
  2265.   {
  2266.     open( true );
  2267.   }
  2268.       }
  2269.     break;
  2270.   }
  2272. // check for the keyboard event
  2273. if( event == FL_KEYDOWN )
  2274.   {
  2275.     // check for the spacebar selecting this entry
  2276.     if( Fl::event_key() == ' ' && rdata.hilighted == this )
  2277.       {
  2278. if( Fl::event_state(FL_CTRL) )
  2279.   select( !CHECK(SELECTED) );
  2280. else
  2281.   {
  2282.     rdata.root->unselect_all( this );
  2283.     select( true );
  2284.   }
  2285. if( is_branch() && rdata.openOnSelect )
  2286.   {
  2287.     open( true );
  2288.   }
  2289. return 1;
  2290.       }
  2292.     // check for the enter key opening/closing this entry
  2293.     else if( (Fl::event_key() == FL_Enter) && (rdata.hilighted == this) )
  2294.       {
  2295. open( !open() );
  2296. return 1;
  2297.       }
  2299.     // check for the left/right cursor keys opening/closing this entry
  2300.     else if( (Fl::event_key() == FL_Left) && (rdata.hilighted == this) )
  2301.       {
  2302. open( false );
  2303. return 1;
  2304.       }
  2305.     else if( (Fl::event_key() == FL_Right) && (rdata.hilighted == this) )
  2306.       {
  2307. open( true );
  2308. return 1;
  2309.       }
  2310.   }
  2312. // check for the "up" cursor key moving the hilighted entry
  2313. if( rdata.delta == -1 && rdata.hilighted == this && rdata.previous != NULL )
  2314.   {
  2315.     tree->set_hilighted( rdata.previous );
  2316.     rdata.delta = 0;
  2317.     return 1;
  2318.   }
  2320. // check for the "down" cursor key moving the hilighted entry
  2321. if( rdata.delta == 1 && rdata.hilighted == rdata.previous )
  2322.   {
  2323.     tree->set_hilighted( this );
  2324.     rdata.delta = 0;
  2325.     return 1;
  2326.   }
  2328. rdata.previous = this;
  2330. // the event is not ours to use
  2331. //if( _widget && !rdata.dragging )
  2332. //if( Fl::event_inside( _widget->w ) )
  2333. //  return 2;
  2335. bool inExpander = false;
  2336. if( is_branch() )
  2337.   {
  2338.     int which = open();
  2339.     if( _parent==0 )
  2340.       inExpander = Fl::event_inside( rdata.x, rdata.y+(currentH>>1)-(cIcon[which]->h()>>1),
  2341.      cIcon[which]->w(), cIcon[which]->h() );
  2342.     else
  2343.       inExpander = Fl::event_inside( rdata.x+(rdata.branchIconW>>1)-(cIcon[which]->w()>>1),
  2344.      rdata.y+(currentH>>1)-(cIcon[which]->h()>>1),
  2345.      cIcon[which]->w(), cIcon[which]->h() );
  2346.   }
  2348. if( event == FL_PUSH )
  2349.   {
  2350.     // check for expand/collapse
  2351.     if( Fl::event_button() == FL_LEFT_MOUSE && inExpander )
  2352.       {
  2353. /*
  2354. if( is_branch() )
  2355.   {
  2356.     bool c = false;
  2357.     int which = open();
  2358.     if( _parent==0 )
  2359.       {
  2360. c = Fl::event_inside( rdata.x, rdata.y+(currentH>>1)-(cIcon[which]->h()>>1),
  2361.       cIcon[which]->w(), cIcon[which]->h() );
  2362.       }
  2363.     else
  2364.       c = Fl::event_inside( rdata.x+(rdata.branchIconW>>1)-(cIcon[which]->w()>>1),
  2365.     rdata.y+(currentH>>1)-(cIcon[which]->h()>>1),
  2366.     cIcon[which]->w(), cIcon[which]->h() );
  2367.     if( inExpander )
  2368.     {*/
  2369. open( !open() );
  2370. rdata.dragging = false;
  2371. rdata.dragNode = 0;
  2372. return 1;
  2373. //}
  2374. //}
  2375.       }
  2376.   }
  2378. if( event == FL_DRAG && rdata.justOpenedClosed )
  2379.   return 0;
  2381. // if no selections, return
  2382. if( rdata.selectionMode == FLU_NO_SELECT )
  2383.   break;
  2385. // if the event is not inside us, return
  2386. if( !Fl::event_inside( rdata.browserX, rdata.y, rdata.browserW, currentH ) )
  2387.   break;
  2389. #ifdef USE_FLU_DND
  2390. // check for grabbing of a node for DND
  2391. if( event == FL_DRAG && rdata.selectionDragMode == FLU_DRAG_TO_MOVE && !is_root() && rdata.grabbed &&
  2392.     //rdata.insertionMode!=FLU_INSERT_SORTED && rdata.insertionMode!=FLU_INSERT_SORTED_REVERSE &&
  2393.     !tree->dnd_is_dragging() && !rdata.justOpenedClosed && CHECK(MOVABLE) )
  2394.   {
  2395.     tree->dnd_grab( this, "Flu_Tree_Browser" );
  2396.     return 1;
  2397.   }
  2399. // dragging to move a node
  2400. if( event == FL_DND_DRAG )
  2401.   {
  2402.     rdata.dragNode = this; // remember which node to move the grabbed node before/after
  2403.     if( is_root() )
  2404.       {
  2405. rdata.dragWhere = MOVE_AFTER;
  2406. rdata.dragPos = rdata.y + currentH;
  2407.       }
  2408.     else
  2409.       {
  2410. // if this is a leaf or an open branch, then can only move before or after
  2411. // otherwise can move inside
  2412. if( is_branch() && !open() )
  2413.   {
  2414.     int t = MAX( currentH / 3, 1 );
  2415.     if( (Fl::event_y()-rdata.y) <= t )
  2416.       rdata.dragWhere = MOVE_BEFORE;
  2417.     else if( (Fl::event_y()-rdata.y) <= (t<<1) )
  2418.       rdata.dragWhere = MOVE_INSIDE;
  2419.     else
  2420.       rdata.dragWhere = MOVE_AFTER;
  2421.   }
  2422. else
  2423.   {
  2424.     if( (Fl::event_y()-rdata.y) <= (currentH>>1) )
  2425.       rdata.dragWhere = MOVE_BEFORE;
  2426.     else
  2427.       rdata.dragWhere = MOVE_AFTER;
  2428.   }
  2430. // where to draw the insertion position?
  2431. if( rdata.dragWhere == MOVE_BEFORE || rdata.dragWhere == MOVE_INSIDE )
  2432.   rdata.dragPos = rdata.y;
  2433. else
  2434.   rdata.dragPos = rdata.y + currentH;
  2435.       }
  2436.     return 1;
  2437.   }
  2438. #endif
  2440. // single selection
  2441. if( rdata.selectionMode == FLU_SINGLE_SELECT )
  2442.   {
  2443.     if( event == FL_PUSH )
  2444.       {
  2445. //rdata.dragging = true;
  2446. rdata.grabbed = this;
  2448. rdata.root->unselect_all( this );
  2449. tree->set_hilighted( this );
  2450. if( Fl::event_state(FL_CTRL) )
  2451.   select( !CHECK(SELECTED) );
  2452. else
  2453.   select( true );
  2455. if( is_leaf() )
  2456.   {
  2457.     if( Fl::event_clicks() > 0 )
  2458.       {
  2459. Fl::event_clicks(0);
  2460. do_callback( FLU_DOUBLE_CLICK );
  2461.       }
  2462.   }
  2463. else
  2464.   {
  2465.     if( Fl::event_clicks() > 0 )
  2466.       {
  2467. Fl::event_clicks(0);
  2468. if( rdata.doubleClickToOpen )
  2469.   open( !open() );
  2470. else
  2471.   do_callback( FLU_DOUBLE_CLICK );
  2472.       }
  2473.     else if( rdata.openOnSelect )
  2474.       {
  2475. open( true );
  2476.       }
  2477.   }
  2478. return 1;
  2479.       }
  2480.     else if( event == FL_DRAG )
  2481.       {
  2482. rdata.dragging = true;
  2483. //if( ( rdata.selectionDragMode == FLU_DRAG_IGNORE || rdata.selectionDragMode == FLU_DRAG_TO_MOVE) && ( tree->insertion_mode() == FLU_INSERT_FRONT || tree->insertion_mode() == FLU_INSERT_BACK ) )
  2484. //return 1;
  2485. rdata.root->unselect_all( this );
  2486. tree->set_hilighted( this );
  2487. select( true );
  2488. return 1;
  2489.       }
  2490.     else if( event == FL_RELEASE && rdata.when == FL_WHEN_RELEASE && selected() && !inExpander )
  2491.       {
  2492. do_callback( FLU_SELECTED );
  2493. return 1;
  2494.       }
  2495.   }
  2497. // multiple selection
  2498. else if( rdata.selectionMode == FLU_MULTI_SELECT )
  2499.   {
  2500.     if( event == FL_PUSH )
  2501.       {
  2502. //rdata.dragging = true;
  2503. rdata.grabbed = this;
  2505. if( Fl::event_state(FL_CTRL) )
  2506.   {
  2507.     select( !CHECK(SELECTED) );
  2508.     tree->set_hilighted( this );
  2509.   }
  2510. else if( Fl::event_state(FL_SHIFT) )
  2511.   {
  2512.     // select everything from the last selected entry to this one
  2513.     if( rdata.hilighted == this )
  2514.       {
  2515. select( true );
  2516. if( is_branch() )
  2517.   {
  2518.     if( Fl::event_clicks() > 0 )
  2519.       {
  2520. Fl::event_clicks(0);
  2521. if( rdata.doubleClickToOpen )
  2522.   open( !open() );
  2523. else
  2524.   do_callback( FLU_DOUBLE_CLICK );
  2525.       }
  2526.     else if( rdata.openOnSelect )
  2527.       {
  2528. open( !open() );
  2529.       }
  2530.   }
  2531.       }
  2532.     else
  2533.       {
  2534. rdata.shiftSelectAll = false;
  2535. rdata.shiftSelect = true;
  2536. rdata.grabbed = this;
  2537. rdata.root->recurse( rdata, HANDLE, 0 );
  2538. tree->set_hilighted( this );
  2539.       }
  2540.   }
  2541. else
  2542.   {
  2543.     rdata.root->unselect_all( this );
  2544.     select( true );
  2545.     if( is_leaf() )
  2546.       {
  2547. if( Fl::event_clicks() > 0 )
  2548.   {
  2549.     Fl::event_clicks(0);
  2550.     do_callback( FLU_DOUBLE_CLICK );
  2551.   }
  2552.       }
  2553.     else
  2554.       {
  2555. if( Fl::event_clicks() > 0 )
  2556.   {
  2557.     Fl::event_clicks(0);
  2558.     if( rdata.doubleClickToOpen )
  2559.       open( !open() );
  2560.     else
  2561.       do_callback( FLU_DOUBLE_CLICK );
  2562.   }
  2563. else if( rdata.openOnSelect )
  2564.   {
  2565.     open( true );
  2566.   }
  2567.       }
  2568.     tree->set_hilighted( this );
  2569.   }
  2570. return 1;
  2571.       }
  2572.     else if( event == FL_DRAG )
  2573.       {
  2574. rdata.dragging = true;
  2575. //if( ( rdata.selectionDragMode == FLU_DRAG_IGNORE || rdata.selectionDragMode == FLU_DRAG_TO_MOVE) && ( tree->insertion_mode() == FLU_INSERT_FRONT || tree->insertion_mode() == FLU_INSERT_BACK ) )
  2576. //return 1;
  2577. select( true );
  2578. tree->set_hilighted( this );
  2579. return 1;
  2580.       }
  2581.     else if( event == FL_RELEASE && rdata.when == FL_WHEN_RELEASE && selected() && !inExpander )
  2582.       {
  2583. do_callback( FLU_SELECTED );
  2584. return 1;
  2585.       }
  2586.   }
  2587.       }
  2588.       break;
  2589.     }
  2591.   // advance the counters vertically to the next entry
  2592.   if( !skipEntry )
  2593.     rdata.y += currentH + rdata.vGap;
  2595.   // if we're a leaf, no need to process further
  2596.   if( is_leaf() )
  2597.     return 0;
  2599.   // should we bail out already if we're done processing?
  2600.   if( closed() && !skipEntry && !skipCollapser && tree->rdata.animatedNode!=this && ( type != MEASURE_THIS_OPEN ) )
  2601.     return 0;
  2603.   if( !CHECK(SOME_VISIBLE_CHILDREN) )
  2604.     return 0;
  2606.   // advance the counters horizontally to the next entry
  2607.   if( rdata.showBranches )
  2608.     {
  2609.       if( !skipEntry && !skipCollapser )
  2610. rdata.x += cIcon[which]->w() + rdata.hGap;
  2611.     }
  2612.   rdata.totalW = MAX( rdata.totalW, rdata.x );
  2614.   // the branchIconW is the width of the branch icon at this level
  2615.   // it is used to center all children icons under the branch icon
  2616.   int lastBranchIconW = rdata.branchIconW;
  2617.   if( rdata.showBranches )
  2618.     {
  2619.       if( bIcon[which] )
  2620. rdata.branchIconW = bIcon[which]->w();
  2621.       else
  2622. rdata.branchIconW = cIcon[which]->w();
  2623.     }
  2624.   else
  2625.     rdata.branchIconW = 0;
  2627.   // update the animation
  2628.   if( tree->rdata.animatedNode==this && ( type == DRAW ) )
  2629.     {
  2630.       // check for termination (if opening)
  2631.       if( (rdata.animationOffset+rdata.animationDelta) >= 0.0f )
  2632. {
  2633.   tree->rdata.animatedNode = NULL;
  2634.   rdata.animating = false;
  2635.   tree->rdata.forceResize = true;
  2636.   Fl::remove_timeout( _timerRedrawCB, tree );
  2637. }
  2638.       else
  2639. {
  2640.   // update the offset
  2641.   rdata.animationOffset += rdata.animationDelta;
  2642.   fl_push_clip( rdata.browserX, rdata.y, rdata.browserW, rdata.browserH );
  2643.   rdata.y += (int)rdata.animationOffset;
  2644. }
  2645.     }
  2647.   if( ( type == MEASURE ) || ( type == MEASURE_THIS_OPEN ) )
  2648.     totalChildH = rdata.y;
  2650.   // process all children
  2651.   int val;
  2652.   int tempW = rdata.branchIconW >> 1;
  2653.   for( i = 0; i < _children.size(); i++ )
  2654.     {
  2655.       // prepare the recursive data structure for the next level
  2656.       if( !skipEntry )
  2657. rdata.first = false;
  2658.       rdata.last = (i == _children.size()-1 );
  2660.       // if child "i" is not the last child,
  2661.       // then there is a long connector that needs drawn between this node and the last child.
  2662.       // push the horizontal position of the connector onto the stack
  2663.       if( (type == DRAW) && rdata.showConnectors && ( i < _children.size()-1 ) )
  2664. {
  2665.   rdata.branchConnectors.push( rdata.x+tempW );
  2666.   val = _children.child(i)->recurse( rdata, type, event );
  2667.   rdata.branchConnectors.pop();
  2668. }
  2669.       else
  2670. val = _children.child(i)->recurse( rdata, type, event );
  2672.       if( val )
  2673. return val;
  2674.     }
  2676.   // set the branch icon width back to what it was before we changed it
  2677.   rdata.branchIconW = lastBranchIconW;
  2679.   if( ( type == MEASURE ) || ( type == MEASURE_THIS_OPEN ) )
  2680.     totalChildH = rdata.y - totalChildH;
  2682.   // update the animation
  2683.   if( tree->rdata.animatedNode==this && ( type == DRAW ) )
  2684.     {
  2685.       fl_pop_clip();
  2686.       // check for termination (if closing)
  2687.       if( rdata.animationOffset <= (float)(-totalChildH) )
  2688. {
  2689.   tree->rdata.animatedNode = NULL;
  2690.   rdata.animating = false;
  2691.   tree->rdata.forceResize = true;
  2692.   Fl::remove_timeout( _timerRedrawCB, tree );
  2693. }
  2694.     }
  2696.   // move back horizontally from the last entry
  2697.   if( rdata.showBranches )
  2698.     {
  2699.       if( !skipEntry && !skipCollapser )
  2700. rdata.x -= cIcon[which]->w() + rdata.hGap;
  2701.     }
  2703.   return 0;
  2704. }
  2706. void Flu_Tree_Browser :: print()
  2707. {
  2708.   root.print();
  2709. }
  2711. void Flu_Tree_Browser :: clear()
  2712. {
  2713.   root.clear();
  2714.   root.text = "";
  2716.   rdata.hilighted = NULL;
  2717.   rdata.dragging = false;
  2718.   rdata.forceResize = true;
  2719.   rdata.lastOpenBranch = NULL;
  2720.   rdata.shiftSelect = false;
  2721.   rdata.shiftSelectAll = false;
  2722.   rdata.nextId = 1;
  2723.   rdata.searchIndex = 1;
  2724. }
  2726. Flu_Tree_Browser::Node* Flu_Tree_Browser :: set_root( const char *label, Fl_Widget *w, bool showLabel )
  2727. {
  2728.   if( label == 0 )
  2729.     label = "";
  2730.   root.text = label;
  2731.   root.widget( w );
  2732.   root.SET(Node::SHOW_LABEL,showLabel);
  2733.   root.cIcon[0] = rdata.collapseIcons[0];
  2734.   root.cIcon[1] = rdata.collapseIcons[1];
  2735.   root.bIcon[0] = rdata.branchIcons[0];
  2736.   root.bIcon[1] = rdata.branchIcons[1];
  2737.   root.textColor = rdata.defBranchColor;
  2738.   root.textFont = rdata.defBranchFont;
  2739.   root.textSize = rdata.defBranchSize;
  2740.   rdata.forceResize = true;
  2742.   return &root;
  2743. }
  2745. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add( const char* fullpath, Fl_Widget *w, bool showLabel )
  2746. {
  2747.   return( root.modify( fullpath, Node::ADD, rdata, w, showLabel ) );
  2748. }
  2750. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add( const char* path, const char* text, Fl_Widget *w, bool showLabel )
  2751. {
  2752.   // if the path does not end in '/', add it
  2753.   FluSimpleString s = path;
  2754.   if( path[strlen(path)-1] != '/' )
  2755.     s += "/";
  2756.   s += text;
  2758.   return add( s.c_str(), w, showLabel );
  2759. }
  2761. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add_branch( const char* fullpath, Fl_Widget *w, bool showLabel )
  2762. {
  2763.   FluSimpleString p( fullpath );
  2764.   if( p.size() && p[p.size()-1] != '/' && p[p.size()-1] != '\' ) p += "/";
  2765.   return add( p.c_str(), w, showLabel );
  2766. }
  2768. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add_branch( const char* path, const char* name, Fl_Widget *w, bool showLabel )
  2769. {
  2770.   FluSimpleString p( name );
  2771.   if( p.size() && p[p.size()-1] != '/' && p[p.size()-1] != '\' ) p += "/";
  2772.   return add( path, p.c_str(), w, showLabel );
  2773. }
  2775. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add_leaf( const char* fullpath, Fl_Widget *w, bool showLabel )
  2776. {
  2777.   FluSimpleString p( fullpath );
  2778.   if( p.size() && ( p[p.size()-1] == '/' || p[p.size()-1] == '\' ) ) p[p.size()-1] = '';
  2779.   return add( p.c_str(), w, showLabel );
  2780. }
  2782. Flu_Tree_Browser::Node* Flu_Tree_Browser :: add_leaf( const char* path, const char* name, Fl_Widget *w, bool showLabel )
  2783. {
  2784.   FluSimpleString p( name );
  2785.   if( p.size() && ( p[p.size()-1] == '/' || p[p.size()-1] == '\' ) ) p[p.size()-1] = '';
  2786.   return add( path, p.c_str(), w, showLabel );
  2787. }
  2789. unsigned int Flu_Tree_Browser :: remove( const char *fullpath )
  2790. {
  2791.   return( reinterpret_cast<long>(root.modify( fullpath, Node::REMOVE, rdata ) ));
  2792. }
  2794. unsigned int Flu_Tree_Browser :: remove( const char *path, const char *text )
  2795. {
  2796.   // if the path does not end in '/', add it
  2797.   FluSimpleString s = path;
  2798.   if( path[strlen(path)-1] != '/' )
  2799.     s += "/";
  2800.   s += text;
  2801.   return remove( s.c_str() );
  2802. }
  2804. unsigned int Flu_Tree_Browser :: remove( unsigned int id )
  2805. {
  2806.   return root.remove( id );
  2807. }
  2809. unsigned int Flu_Tree_Browser :: Node :: remove( unsigned int id )
  2810. {
  2811.   if( id == 0 )
  2812.     return 0;
  2814.   for( int i = 0; i < _children.size(); i++ )
  2815.     {
  2816.       Node *n = _children.child(i);
  2817.       if( n->id() == id )
  2818. {
  2819.   _children.erase( i );
  2820.   tree->rdata.forceResize = true;
  2821.   //if( tree->rdata.cbNode == n )
  2822.   //tree->rdata.cbNode = NULL;
  2823.   delete n;
  2824.   if( tree->rdata.autoBranches )
  2825.     initType();
  2826.   return id;
  2827. }
  2828.       else if( n->remove( id ) )
  2829. return id;
  2830.     }
  2832.   return 0;
  2833. }
  2835. unsigned int Flu_Tree_Browser :: remove( Fl_Widget *w )
  2836. {
  2837.   return root.remove( w );
  2838. }
  2840. unsigned int Flu_Tree_Browser :: Node :: remove( Fl_Widget *w )
  2841. {
  2842.   if( !w )
  2843.     return 0;
  2844.   for( int i = 0; i < _children.size(); i++ )
  2845.     {
  2846.       Node *n = _children.child(i);
  2847.       if( n->_widget )
  2848. {
  2849.   if( n->_widget->w == w )
  2850.     {
  2851.       int id = n->id();
  2852.       _children.erase( i );
  2853.       tree->rdata.forceResize = true;
  2854.       //if( tree->rdata.cbNode == n )
  2855.       //tree->rdata.cbNode = NULL;
  2856.       delete n;
  2857.       if( tree->rdata.autoBranches )
  2858. initType();
  2859.       return id;
  2860.     }
  2861. }
  2863.       int id = n->remove( w );
  2864.       if( id )
  2865. return id;
  2866.     }
  2868.   return 0;
  2869. }
  2871. int Flu_Tree_Browser :: find_number( const char *fullpath )
  2872. {
  2873.   rdata.counter = 0;
  2874.   root.modify( fullpath, Node::FIND_NUMBER, rdata );
  2875.   return rdata.counter;
  2876. }
  2878. int Flu_Tree_Browser :: find_number( const char *path, const char *text )
  2879. {
  2880.   // if the path does not end in '/', add it
  2881.   FluSimpleString s = path;
  2882.   if( path[strlen(path)-1] != '/' )
  2883.     s += "/";
  2884.   s += text;
  2885.   return find_number( s.c_str() );
  2886. }
  2888. Flu_Tree_Browser::Node* Flu_Tree_Browser :: find_next( const char *fullpath, Node* startNode )
  2889. {
  2890.   // degenerate case: root node
  2891.   if( strcmp( fullpath, "/" ) == 0 )
  2892.     return &root;
  2893.   rdata.previous = startNode;
  2894.   return( root.modify( fullpath, Node::FIND, rdata ) );
  2895. }
  2897. Flu_Tree_Browser::Node* Flu_Tree_Browser :: find_next( const char *path, const char *text )
  2898. {
  2899.   // if the path does not end in '/', add it
  2900.   FluSimpleString s = path;
  2901.   if( path[strlen(path)-1] != '/' )
  2902.     s += "/";
  2903.   s += text;
  2904.   return find_next( s.c_str() );
  2905. }
  2907. Flu_Tree_Browser::Node* Flu_Tree_Browser :: find( const char *path, const char *text )
  2908. {
  2909.   // if the path does not end in '/', add it
  2910.   FluSimpleString s = path;
  2911.   if( path[strlen(path)-1] != '/' )
  2912.     s += "/";
  2913.   s += text;
  2914.   return find( s.c_str() );
  2915. }
  2917. Flu_Tree_Browser::Node* Flu_Tree_Browser :: find( unsigned int id )
  2918. {
  2919.   return root.find( id );
  2920. }
  2922. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: find( unsigned int id )
  2923. {
  2924.   if( id == 0 )
  2925.     return NULL;
  2927.   if( _id == id )
  2928.     return this;
  2930.   for( int i = 0; i < _children.size(); i++ )
  2931.     {
  2932.       Node *n = _children.child(i)->find( id );
  2933.       if( n )
  2934. return n;
  2935.     }
  2937.   return NULL;
  2938. }
  2940. Flu_Tree_Browser::Node* Flu_Tree_Browser :: find( Fl_Widget *w )
  2941. {
  2942.   return root.find( w );
  2943. }
  2945. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: find( Fl_Widget *w )
  2946. {
  2947.   if( _widget )
  2948.     if( _widget->w == w )
  2949.       return this;
  2951.   for( int i = 0; i < _children.size(); i++ )
  2952.     {
  2953.       Node *n = _children.child(i)->find( w );
  2954.       if( n )
  2955. return n;
  2956.     }
  2958.   return NULL;
  2959. }
  2962. bool Flu_Tree_Browser :: Node :: findPath( unsigned int id, RData &rdata )
  2963. {
  2964.   if( _id == id )
  2965.     {
  2966.       if( is_leaf() )
  2967. rdata.path += text;
  2968.       else
  2969. {
  2970.   rdata.path += text;
  2971.   rdata.path += "/";
  2972. }
  2973.       return true;
  2974.     }
  2976.   if( is_leaf() )
  2977.     return false;
  2979.   char *oldPath = strdup( rdata.path.c_str() );
  2980.   if( _parent != 0 )
  2981.     {
  2982.       rdata.path += text;
  2983.       rdata.path += "/";
  2984.     }
  2986.   for( int i = 0; i < _children.size(); i++ )
  2987.     {
  2988.       if( _children.child(i)->findPath( id, rdata ) )
  2989. {
  2990.   free( oldPath );
  2991.   return true;
  2992. }
  2993.     }
  2995.   rdata.path = oldPath;
  2996.   free( oldPath );
  2998.   return false;
  2999. }
  3001. bool Flu_Tree_Browser :: Node :: findPath( Fl_Widget *w, RData &rdata )
  3002. {
  3003.   if( _widget )
  3004.     if( _widget->w == w )
  3005.       {
  3006. if( is_leaf() )
  3007.   rdata.path += text;
  3008. else
  3009.   {
  3010.     rdata.path += text;
  3011.     rdata.path += "/";
  3012.   }
  3013. return true;
  3014.       }
  3016.   if( is_leaf() )
  3017.     return false;
  3019.   char *oldPath = strdup( rdata.path.c_str() );
  3020.   if( _parent != 0 )
  3021.     {
  3022.       rdata.path += text;
  3023.       rdata.path += "/";
  3024.     }
  3026.   for( int i = 0; i < _children.size(); i++ )
  3027.     {
  3028.       if( _children.child(i)->findPath( w, rdata ) )
  3029. {
  3030.   free( oldPath );
  3031.   return true;
  3032. }
  3033.     }
  3035.   rdata.path = oldPath;
  3036.   free( oldPath );
  3038.   return false;
  3039. }
  3041. const char* Flu_Tree_Browser :: find_path( unsigned int id )
  3042. {
  3043.   // degenerate case: the root is always id==0
  3044.   if( id == 0 )
  3045.     return "/";
  3046.   rdata.path = "/";
  3047.   if( root.findPath( id, rdata ) )
  3048.     return rdata.path.c_str();
  3049.   else
  3050.     return "";
  3051. }
  3053. const char* Flu_Tree_Browser :: find_path( Fl_Widget *w )
  3054. {
  3055.   rdata.path = "/";
  3056.   if( root.findPath( w, rdata ) )
  3057.     return rdata.path.c_str();
  3058.   else
  3059.     return "";
  3060. }
  3062. static char* remove_escape_chars( const char *str )
  3063. {
  3064.   // remove any escape characters
  3065.   char *text = strdup( str );
  3066.   int tIndex = 0;
  3067.   for( int pIndex = 0; pIndex < (int)strlen( str ); pIndex++ )
  3068.     {
  3069.       if( str[pIndex] != '\' )
  3070. text[tIndex++] = str[pIndex];
  3071.     }
  3072.   text[tIndex] = '';
  3074.   return text;
  3075. }
  3077. void Flu_Tree_Browser :: Node :: do_callback( int reason )
  3078. {
  3079.   if( tree->rdata.when == FL_WHEN_NEVER )
  3080.     return;
  3081.   if( tree->rdata.cb )
  3082.     {
  3083.       tree->rdata.cbReason = reason;
  3084.       tree->rdata.cbNode = this;
  3085.       tree->rdata.cb( tree, tree->rdata.cbd );
  3086.     }
  3087. }
  3089. unsigned short Flu_Tree_Browser :: Node :: depth() const
  3090. {
  3091.   int d = 0;
  3092.   Node *p = _parent;
  3093.   while( p )
  3094.     {
  3095.       d++;
  3096.       p = p->_parent;
  3097.     }
  3098.   return d;
  3099. }
  3101. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: add_branch( const char* fullpath, Fl_Widget *w, bool showLabel )
  3102. {
  3103.   FluSimpleString p( fullpath );
  3104.   if( p.size() && p[p.size()-1] != '/' && p[p.size()-1] != '\' ) p += "/";
  3105.   return add( p.c_str(), w, showLabel );
  3106. }
  3108. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: add_leaf( const char* fullpath, Fl_Widget *w, bool showLabel )
  3109. {
  3110.   FluSimpleString p( fullpath );
  3111.   if( p.size() && ( p[p.size()-1] == '/' || p[p.size()-1] == '\' ) ) p[p.size()-1] = '';
  3112.   return add( p.c_str(), w, showLabel );
  3113. }
  3115. Flu_Tree_Browser::Node* Flu_Tree_Browser :: Node :: modify( const char* path, int what, RData &rdata, Fl_Widget *w, bool showLabel )
  3116. {
  3117.   // find the selected entry at rdata.searchIndex among all selected entries
  3118.   if( what == GET_SELECTED )
  3119.     {
  3120.       if( CHECK(SELECTED) )
  3121. {
  3122.   rdata.counter++;
  3123.   if( rdata.counter == rdata.searchIndex )
  3124.     return this;
  3125. }
  3126.       for( int i = 0; i < _children.size(); i++ )
  3127. {
  3128.   Node *n = _children.child(i)->modify( path, what, rdata, w );
  3129.   if( n )
  3130.     return n;
  3131. }
  3132.       return NULL;
  3133.     }
  3135.   // trivial test for a bogus empty path
  3136.   if( path == 0 )
  3137.     return NULL;
  3139.   // if the path starts with '/', skip the '/'
  3140.   if( path[0] == '/' )
  3141.     path++;
  3143.   // trivial test for a bogus empty path
  3144.   if( path[0] == '' )
  3145.     return NULL;
  3147.   const char *remainingPath;
  3148.   char *nodeName;
  3149.   bool lastNode, branchNode;
  3150.   Node *retNode = NULL;
  3152.   ///////////// extract the next node name from the path ///////////////////
  3154.   // find the next '/' that is not preceded by the escape character ''
  3155.   const char *slash = strchr( path, '/' );
  3156.   for(;;)
  3157.     {
  3158.       // find the next '/'
  3159.       if( slash == NULL ) // there isn't one, so we're done
  3160. break;
  3161.       // test for escape character
  3162.       else if( slash[-1] == '\' ) // path[0] can never be '/', so this is a safe test
  3163. slash = strchr( slash+1, '/' );
  3164.       // we have it
  3165.       else
  3166. break;
  3167.     }
  3169.   // if there is no slash, then the node name is the path and it is a leaf and the last node in the path
  3170.   if( slash == NULL )
  3171.     {
  3172.       branchNode = false;
  3173.       char *name = strdup( path ); // copy the path
  3174.       nodeName = remove_escape_chars( name ); // remove the escape characters
  3175.       free( name );
  3176.       lastNode = true;
  3177.       remainingPath = NULL;
  3178.     }
  3179.   // otherwise the node name is the path up to the slash, it is also a branch and may not be the last node in the path
  3180.   else
  3181.     {
  3182.       branchNode = true;
  3183.       char *name = (char*)malloc( slash-path+1 );
  3184.       strncpy( name, path, slash-path );
  3185.       name[slash-path] = '';
  3186.       nodeName = remove_escape_chars( name ); // remove the escape characters
  3187.       free( name );
  3188.       lastNode = ( slash[1] == '' ); // this is the last node if there is nothing after the slash
  3189.       if( lastNode )
  3190. {
  3191.   //if( rdata.autoBranches )
  3192.   //branchNode = false;
  3193.   remainingPath = NULL;
  3194. }
  3195.       else
  3196. remainingPath = slash+1;
  3197.     }
  3199.   ///////////// process the node ///////////////////
  3201.   switch( what )
  3202.     {
  3203.     case ADD:
  3204.       {
  3205. // if the new node is a leaf node, add the string as a leaf and return
  3206. if( !branchNode )
  3207.   {
  3208.     // is there already a node with this name?
  3209.     Node *n = _children.find( nodeName );
  3210.     if( n )
  3211.       {
  3212. // if that node is a branch node, we can't add a new one with the same name
  3213. if( n->is_branch() )
  3214.   break;
  3216. // if we are not allowed to add multiple nodes with the same name,
  3217. // then just return
  3218. if( !rdata.allowDuplication )
  3219.   break;
  3220.       }
  3222.     // add a new node
  3223.     retNode = new Node( true, nodeName, this, rdata, w, showLabel );
  3224.     _children.add( retNode );
  3225.     rdata.forceResize = true;
  3226.     rdata.visibilityChanged = true;
  3228.     if( tree->rdata.autoBranches )
  3229.       initType();
  3230.   }
  3231. // otherwise make sure the node name exists as a branch and recurse on it
  3232. else
  3233.   {
  3234.     // if there is already a node with this name, just use it
  3235.     Node *n = NULL;
  3236.     n = _children.find( nodeName );
  3237.     if( n )
  3238.       {
  3239. // make sure it is a branch
  3240. if( n->is_leaf() )
  3241.   break;
  3242.       }
  3244.     // else add a new node
  3245.     if( n == NULL )
  3246.       {
  3247. // only add the widget for the last node
  3248. n = new Node( false, nodeName, this, rdata, lastNode?w:NULL, lastNode?showLabel:true );
  3249. _children.add( n );
  3250. rdata.forceResize = true;
  3251. rdata.visibilityChanged = true;
  3252.       }
  3254.     if( tree->rdata.autoBranches )
  3255.       initType();
  3257.     // recurse on the remainder of the path, if not the last node
  3258.     if( lastNode )
  3259.       retNode = n;
  3260.     else
  3261.       retNode = n->modify( remainingPath, what, rdata, w, showLabel );
  3262.   }
  3263.       }
  3264.       break;
  3266.     case REMOVE:
  3267.       {
  3268. // try to find the indicated node. if we can't find it, just return
  3269. Node *n = _children.find( nodeName );
  3270. if( !n )
  3271.   break;
  3273. // if this is the last node, remove it.
  3274. if( lastNode )
  3275.   {
  3276.     int ID = n->id();
  3277.     _children.erase( n );
  3278.     //if( tree->rdata.cbNode == n )
  3279.     //tree->rdata.cbNode = NULL;
  3280.     delete n;
  3281.     retNode = (Node*)ID; // non-null return value means remove was successful
  3282.     rdata.forceResize = true;
  3283.     rdata.visibilityChanged = true;
  3285.     if( tree->rdata.autoBranches )
  3286.       initType();
  3287.   }
  3288. // otherwise recurse on the remainder of the path
  3289. else
  3290.   retNode = n->modify( remainingPath, what, rdata, w, showLabel );
  3291.       }
  3292.       break;
  3294.     case FIND:
  3295.       {
  3296. // if this node equals the starting node for a find_next,
  3297. // then by clearing rdata.previous we flag that we are allowed to return the next match
  3298. if( rdata.previous == this )
  3299.   rdata.previous = NULL;
  3301. Node *n = NULL;
  3303. if( !lastNode )
  3304.   {
  3305.     // if, according to the path, this is not the last node, then just recursively
  3306.     // search for the named node
  3307.     n = _children.find( nodeName );
  3308.     if( !n )
  3309.       break;
  3310.     retNode = n->modify( remainingPath, what, rdata, w, showLabel );
  3311.   }
  3312. else
  3313.   {
  3314.     // otherwise, according to the path, this is the last node (i.e. a leaf).
  3315.     // since only leaves can have multiple identical entries,
  3316.     // try to find the indicated node, accounting for the possibility
  3317.     // that it may not be the one we're after
  3318.     int next = 1;
  3319.     for(;;)
  3320.       {
  3321. // look for the named node
  3322. n = _children.find( nodeName, next++ );
  3324. // if we can't find it, just return, because it's not here
  3325. if( !n )
  3326.   break;
  3328. // we are only allowed to return a match if the previous node is NULL,
  3329. // indicating we have passed the starting node for a find_next
  3330. if( rdata.previous == NULL )
  3331.   {
  3332.     retNode = n;
  3333.     break;
  3334.   }
  3336. // if the found node equals the starting node for a find_next,
  3337. // then by clearing rdata.previous we flag that we are allowed to return the next match
  3338. if( rdata.previous == n )
  3339.   rdata.previous = NULL;
  3340.       }
  3341.   }
  3342.       }
  3343.       break;
  3345.     case FIND_NUMBER:
  3346.       {
  3347. if( lastNode )  // can only match multiple leaves if the path says this is the last node
  3348.   {
  3349.     rdata.counter += _children.findNum( nodeName );
  3350.   }
  3351. else  // otherwise recurse down the remaining path
  3352.   {
  3353.     Node *n = _children.find( nodeName );
  3354.     n->modify( remainingPath, what, rdata, w, showLabel );
  3355.   }
  3356.       }
  3357.       break;
  3358.     }
  3360.   free( nodeName );
  3362.   return retNode;
  3363. }
  3365. void Flu_Tree_Browser :: Node :: widgetCB()
  3366. {
  3367.   if( _widget )
  3368.     {
  3369.       if( _widget->CB )
  3370. _widget->CB( _widget->w, _widget->CBData );
  3371.     }
  3372.   do_callback( FLU_WIDGET_CALLBACK );
  3373. }
  3375. void Flu_Tree_Browser :: Node :: widget( Fl_Widget *w )
  3376. {
  3377.   tree->rdata.forceResize = true;
  3379.   if( _widget )
  3380.     {
  3381.       Fl_Group *p = _widget->w->parent();
  3382.       if( p )
  3383. p->remove( *(_widget->w) );
  3384.       delete _widget->w;
  3385.       delete _widget;
  3386.       _widget = NULL;
  3387.     }
  3389.   if( !w )
  3390.     return;
  3392.   _widget = new WidgetInfo;
  3393.   _widget->w = w;
  3394.   _widget->defaultW = _widget->w->w();
  3395.   _widget->CB = _widget->w->callback();
  3396.   _widget->CBData = _widget->w->user_data();
  3397.   _widget->w->callback( _widgetCB, this );
  3399.   Fl_Group *parent = w->parent();
  3400.   if( parent )
  3401.     parent->remove( *w );
  3402.   tree->_box->add( w );
  3403. }
  3405. void Flu_Tree_Browser :: Node :: branch_icons( Fl_Image *closed, Fl_Image *open )
  3406. {
  3407.   if( is_branch() )
  3408.     {
  3409.       bIcon[0] = closed;
  3410.       bIcon[1] = open;
  3411.       tree->rdata.forceResize = true;
  3412.     }
  3413. }
  3415. void Flu_Tree_Browser :: Node :: collapse_icons( Fl_Image *closed, Fl_Image *open )
  3416. {
  3417.   if( is_branch() )
  3418.     {
  3419.       if( !closed || !open )
  3420. {
  3421.   cIcon[0] = tree->rdata.defaultCollapseIcons[0];
  3422.   cIcon[1] = tree->rdata.defaultCollapseIcons[1];
  3423. }
  3424.       else
  3425. {
  3426.   cIcon[0] = closed;
  3427.   cIcon[1] = open;
  3428. }
  3429.       tree->rdata.forceResize = true;
  3430.     }
  3431. }
  3433. void Flu_Tree_Browser :: Node :: leaf_icon( Fl_Image *icon )
  3434. {
  3435.   if( is_leaf() )
  3436.     {
  3437.       lIcon = icon;
  3438.       tree->rdata.forceResize = true;
  3439.     }
  3440. }
  3442. bool Flu_Tree_Browser :: Node :: is_branch() const
  3443. {
  3444.   if( tree->rdata.autoBranches )
  3445.     return( _children.size() != 0 );
  3446.   else
  3447.     return !CHECK(LEAF);
  3448. }
  3450. bool Flu_Tree_Browser :: Node :: is_leaf() const
  3451. {
  3452.   if( tree->rdata.autoBranches )
  3453.     return( _children.size() == 0 && !is_root() );
  3454.   else
  3455.     return CHECK(LEAF);
  3456. }