Flu_Tree_Browser.h

// $Id: Flu_Tree_Browser.h,v 1.94 2005/02/04 21:21:09 jbryan Exp $

/***************************************************************
 *                FLU - FLTK Utility Widgets 
 *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
 *
 * This file and its content is protected by a software license.
 * You should have received a copy of this license with this file.
 * If not, please contact the Ohio Supercomputer Center immediately:
 * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
 * 
 ***************************************************************/



#ifndef _FLU_TREE_BROWSER_H
#define _FLU_TREE_BROWSER_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//#define USE_FLU_DND

/* fltk includes */
#include <FL/Fl.H>
#include <FL/Fl_Box.H>
#include <FL/Fl_Pixmap.H>
#include <FL/Fl_Image.H>
#include <FL/Fl_Scrollbar.H>
#include <FL/Fl_Group.H>
#include <FL/Fl_Menu_Button.H>

/* flu includes */
#include "FLU/Flu_Enumerations.h"
#include "FLU/FluSimpleString.h"
#ifdef USE_FLU_DND
#include "FLU/Flu_DND.h"
#else
typedef struct { bool dummy; } Flu_DND_Event;  // for compatibilty when not compiling DND support
#endif

#ifdef USE_FLU_DND
class FLU_EXPORT Flu_Tree_Browser : public Fl_Group, public Flu_DND
#else
class FLU_EXPORT Flu_Tree_Browser : public Fl_Group
#endif
{

  static bool USE_FLU_WIDGET_CALLBACK;

 public:

  class Node;
  friend class Node;

  Flu_Tree_Browser( int x, int y, int w, int h, const char *label = 0 );

  virtual ~Flu_Tree_Browser();


  Node* add( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true );

  Node* add( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );


  inline Node* add( Node* n, const char* name, Fl_Widget *w = 0, bool showLabel = true )
    { return n->add( name, w, showLabel ); }

  Node* add_branch( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true );

  Node* add_branch( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );

  inline Node* add_branch( Node* n, const char* name, Fl_Widget *w = 0, bool showLabel = true )
    { return n->add_branch( name, w, showLabel ); }

  Node* add_leaf( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true );

  Node* add_leaf( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );

  inline Node* add_leaf( Node* n, const char* name, Fl_Widget *w = 0, bool showLabel = true )
    { return n->add_leaf( name, w, showLabel ); }

  inline void all_branches_always_open( bool b )
    { rdata.allBranchesAlwaysOpen = b; }

  inline bool all_branches_always_open()
    { return rdata.allBranchesAlwaysOpen; }

  inline void allow_leaf_duplication( bool b )
    { rdata.allowLeafDuplication = b; }

  inline bool allow_leaf_duplication()
    { return rdata.allowLeafDuplication; }

  inline void allow_branch_duplication( bool b )
    { rdata.allowBranchDuplication = b; }

  inline bool allow_branch_duplication()
    { return rdata.allowBranchDuplication; }

  inline bool have_dnd()
    {
#ifdef USE_FLU_DND
      return true;
#else
      return false;
#endif
    }


  inline void allow_dnd( bool b )
    { rdata.dnd = b; }

  inline bool allow_dnd()
    { return rdata.dnd; }

  inline void always_open( bool b )
    { root.always_open( b ); }

  inline bool always_open()
    { return root.always_open(); }

  inline void animate( bool b )
    { rdata.animate = b; }

  inline bool animate()
    { return rdata.animate; }

  void auto_branches( bool b );

  inline bool auto_branches() const
    { return rdata.autoBranches; }

  inline Fl_Color branch_color() const
    { return rdata.defBranchColor; }

  inline Fl_Font branch_font() const
    { return rdata.defBranchFont; }

  inline int branch_size() const
    { return rdata.defBranchSize; }

  inline void branch_text( Fl_Color color, Fl_Font font, int size )
    { rdata.defBranchColor = color; rdata.defBranchFont = font; rdata.defBranchSize = size; }


  void branch_icons( Fl_Image *closed, Fl_Image *open );

  inline Fl_Boxtype box() const
    { return _box->box(); }

  inline void box( Fl_Boxtype b )
    { _box->box( b ); }

  //inline void callback( Fl_Callback *c, void *user_data = 0 )
  //{ rdata.cb = c; rdata.cbd = user_data; }

  inline int callback_reason() const
    { return rdata.cbReason; }


  inline Node* callback_node() const
    { return rdata.cbNode; }

  void clear();

  void collapse_icons( Fl_Image *closed, Fl_Image *open );

  inline float collapse_time() const
    { return rdata.collapseTime; }

  inline void collapse_time( float t )
    { rdata.collapseTime = t; }

  inline Fl_Color color() const
    { return _box->color(); }

  inline void color( Fl_Color c )
    { _box->color( c ); }

  inline void color( unsigned c )
    { _box->color( (Fl_Color)c ); }

  inline void connector_style( Fl_Color color, int style, int width = 1 )
    { rdata.defLineColor = color; rdata.lineStyle = style; rdata.lineWidth = width; }

  inline Fl_Color connector_color() const
    { return rdata.defLineColor; }

  inline int connector_style() const
    { return rdata.lineStyle; }

  inline int connector_width() const
    { return rdata.lineWidth; }

  inline void double_click_opens( bool b )
    { rdata.doubleClickToOpen = b; }

  inline bool double_click_opens()
    { return rdata.doubleClickToOpen; }

  inline Fl_Color even_shaded_entry_color() const 
    { return rdata.shadedColors[0]; }


  inline Node* find( const char *fullpath )
    { return find_next( fullpath ); }


  Node* find( const char *path, const char *name );


  Node* find( unsigned int id );


  inline Node* find( Node *n )
    { if( !n ) return NULL; else return find( n->id() ); }


  Node* find( Fl_Widget *w );


  Node* find_next( const char *fullpath, Node* startNode = NULL );


  Node* find_next( const char *path, const char *name );

  int find_number( const char *fullpath );

  int find_number( const char *path, const char *name );


  const char* find_path( unsigned int id );


  const char* find_path( Fl_Widget *w );


  inline const char* find_path( Node *n )
    { if( !n ) return ""; else return find_path( n->id() ); }

  inline Node* first() { return root.first(); }

  inline Node* first_branch() { return root.first_branch(); }

  inline Node* first_leaf() { return root.first_leaf(); }

  inline float frame_rate() const
    { return rdata.fps; }

  inline void frame_rate( float f )
    { if( f <= 0.0f ) rdata.fps = 0.001f; else rdata.fps = f; }

  inline Node* get_hilighted()
    { return rdata.hilighted; }

  inline Node *get_root() { return &root; }


  Node* get_selected( int index );

  int handle( int event );

  inline void horizontal_gap( int g )
    { rdata.hGap = g; rdata.forceResize = true; }

  inline int horizontal_gap() const
    { return rdata.hGap; }

  void insertion_mode( int m );

  inline int insertion_mode()
    { return rdata.insertionMode; }

  bool Flu_Tree_Browser :: inside_entry_area( int x, int y );

  inline void label( const char *l )
    { root.text = l; }

  inline const char* label() const
    { return root.text.c_str(); }

  inline Node* last() { return root.last(); }

  inline Node* last_branch() { return root.last_branch(); }

  inline Node* last_leaf() { return root.last_leaf(); }

  inline Fl_Color leaf_color() const
    { return rdata.defLeafColor; }

  inline Fl_Font leaf_font() const
    { return rdata.defLeafFont; }

  inline int leaf_size() const
    { return rdata.defLeafSize; }

  void leaf_icon( Fl_Image *icon );

  inline void leaf_text( Fl_Color color, Fl_Font font, int size )
    { rdata.defLeafColor = color; rdata.defLeafFont = font; rdata.defLeafSize = size; }

  inline void move_only_same_group( bool b )
    { rdata.moveOnlySameGroup = b; }

  inline bool move_only_same_group()
    { return rdata.moveOnlySameGroup; }

  int num_selected();

  inline Fl_Color odd_shaded_entry_color() const 
    { return rdata.shadedColors[1]; }

  inline void only_one_open_branch( bool b )
    { rdata.singleBranchOpen = b; }

  inline bool only_one_open_branch()
    { return rdata.singleBranchOpen; }

  inline void open( bool b )
    { root.open( b ); }

  inline bool open() const
    { return root.open(); }

  inline void open_without_children( bool b )
    { rdata.openWOChildren = b; }

  inline bool open_without_children() const
    { return rdata.openWOChildren; }

  inline void open_on_select( bool b )
    { rdata.openOnSelect = b; }

  inline bool open_on_select() const
    { return rdata.openOnSelect; }

  void print();


  unsigned int remove( const char *fullpath );


  unsigned int remove( const char *path, const char *name );


  unsigned int remove( unsigned int id );


  unsigned int remove( Fl_Widget *w );


  inline unsigned int remove( Node* n )
    { if( !n ) return 0; else return remove( n->id() ); }

  void resize( int X, int Y, int W, int H );

  inline void root_color( Fl_Color c )
    { get_root()->label_color( c ); }

  inline Fl_Color root_color()
    { return get_root()->label_color(); }

  inline void root_font( Fl_Font f )
    { get_root()->label_font( f ); }

  inline Fl_Font root_font()
    { return get_root()->label_font(); }

  inline void root_size( unsigned char s )
    { get_root()->label_size( s ); }

  inline unsigned char root_size()
    { return get_root()->label_size(); }

  inline void select_all()
    { root.select_all(); }

  inline Fl_Color selection_color() const
    { return rdata.defSelectionColor; }

  inline void selection_color( Fl_Color c )
    { rdata.defSelectionColor = c; }

  inline void selection_color( unsigned c )
    { selection_color( (Fl_Color)c ); }

  inline void selection_drag_mode( int m )
    { rdata.selectionDragMode = m; }

  inline int selection_drag_mode() const
    { return rdata.selectionDragMode; }

  inline void selection_follows_hilight( bool b )
    { rdata.selectionFollowsHilight = b; if( b && rdata.hilighted ) rdata.hilighted->select(true); }

  inline bool selection_follows_hilight()
    { return rdata.selectionFollowsHilight; }

  inline void selection_mode( int m )
    { rdata.selectionMode = m; root.unselect_all(); }

  inline int selection_mode() const
    { return rdata.selectionMode; }

  inline void select_under_mouse( bool b )
    { rdata.selectUnderMouse = b; }

  inline bool select_under_mouse() const
    { return rdata.selectUnderMouse; }

  void set_default_branch_icons();

  void set_hilighted( Node* n );


  Node* set_root( const char *label, Fl_Widget *w = 0, bool showLabel = true );

  inline void shaded_entry_colors( Fl_Color even, Fl_Color odd )
    { rdata.shadedColors[0] = even; rdata.shadedColors[1] = odd; }

  inline void show_branches( bool b )
    { rdata.showBranches = b; rdata.forceResize = true; }

  inline bool show_branches() const
    { return rdata.showBranches; }

  inline void show_connectors( bool b )
    { rdata.showConnectors = b; }

  inline bool show_connectors() const
    { return rdata.showConnectors; }

  inline void show_root( bool b )
    { rdata.showRoot = b; rdata.forceResize = true; }

  inline bool show_root() const
    { return rdata.showRoot; }

  inline void show_leaves( bool b )
    { rdata.showLeaves = b; rdata.forceResize = true; }

  inline bool show_leaves() const
    { return rdata.showLeaves; }

  inline void sort()
    { root.sort(); }

  inline void unselect_all()
    { root.unselect_all(); }

  inline static void use_FLU_WIDGET_CALLBACK( bool b )
    { USE_FLU_WIDGET_CALLBACK = b; }

  inline void vertical_gap( int g )
    { rdata.vGap = g; rdata.forceResize = true; }

  inline int vertical_gap() const
    { return rdata.vGap; }


  //inline void when( unsigned int w )
  //{ rdata.when = w; }

  //inline unsigned int when() const
  //{ return rdata.when; }

  inline void widget_gap( int g )
    { rdata.wGap = g; rdata.forceResize = true; }

  inline int widget_gap() const
    { return rdata.wGap; }

 protected:

  class RData;

  class FLU_EXPORT NodeList
    {
    public:
      NodeList();
      ~NodeList();
      void add( Node* n, int position = -1 );
      inline Node* child( int n ) const { return _nodes[n]; }
      int erase( Node* n );
      int erase( const char* n );
      void erase( int n );
      void clear();
      int findNum( const char *n );  // find the number of nodes in the list with name n
      Node* find( const char* n, int which = 1 );  // find the which'th node in the list with name n
      inline int size() const { return _nNodes; };
      void sort();
      static bool move( Node* n1, int where, Node* n2 );
    private:
      friend class Node;
      static int compareNodes( const void *arg1, const void* arg2 );
      static int reverseCompareNodes( const void *arg1, const void* arg2 );
      bool search( Node *n, int &index );
      bool search( const char *n, int &index );
      bool linSearch( Node *n, int &index );
      bool linSearch( const char *n, int &index );
      bool binSearch( Node *n, int &index );
      bool binSearch( const char *n, int &index );
      Node **_nodes;
      int _nNodes, _size;
    };

  class FLU_EXPORT IntStack
    {
    public:
      IntStack();
      IntStack( const IntStack& s );
      ~IntStack();
      void push( int i );
      int pop();
      void clear();
      inline int operator [](int i) { return _list[i]; }
      inline int size() { return _size; }
      IntStack& operator =( const IntStack& s );
    private:
      int *_list;
      int _size, _bufferSize;
    };

  public:
  enum { MOVE_BEFORE, MOVE_INSIDE, MOVE_AFTER }; // where to move a dragged node?
 protected:

  class FLU_EXPORT RData {
  public:
    // volatile objects (from the perspective of each node during a recursive descent)
    int x, y, totalW, totalH;
    bool first, last, dragging, shiftSelect, shiftSelectAll, visibilityChanged, selectionFollowsHilight;
    Node *hilighted,  *previous, *grabbed, *dragNode, *animatedNode;
    int delta, shadedIndex, counter, searchIndex, branchIconW, dragPos, dragWhere;
    Fl_Color lineColor, bgColor, selectionColor;
    bool forceResize;  // force the browser to resize on the next draw (which forces a recalculation of the tree layout)
    unsigned int nextId;  // monotonically increasing id of each entry
    FluSimpleString path;  // used to construct the full path during a findPath() operation
    IntStack branchConnectors;

    // static objects (from the perspective of each node during a recursive descent)
    int insertionMode;
    Fl_Image *defaultCollapseIcons[2], *defaultBranchIcons[2];
    Fl_Image *collapseIcons[2], *branchIcons[2], *leafIcon;
    int hGap, vGap, wGap;
    int lineStyle, lineWidth, selectionMode, selectionDragMode;
    bool showRoot, showConnectors, showLeaves, showBranches, openOnSelect,
      allowLeafDuplication, animate, animating, singleBranchOpen, moveOnlySameGroup, justOpenedClosed,
      isMoveValid, doubleClickToOpen, dnd, allBranchesAlwaysOpen, autoBranches, openWOChildren,
      selectUnderMouse, allowBranchDuplication;
    float collapseTime, fps, animationDelta, animationOffset;
    Fl_Color defLineColor, defSelectionColor, shadedColors[2];
    Fl_Color defLeafColor, defBranchColor;
    Fl_Font defLeafFont, defBranchFont;
    int defLeafSize, defBranchSize;
    int browserX, browserY, browserW, browserH;
    Node *root;
    Flu_Tree_Browser *tree;
    unsigned int cbReason;
    Node *cbNode, *lastOpenBranch;
  };

 public:

#ifdef USE_FLU_DND


  class FLU_EXPORT DND_Object : public Flu_DND
    {
    public:

      DND_Object();

      inline void grab()
        { dnd_grab( this, "DND_Object" ); }

      virtual const char* name() = 0;

    };
#endif

  class FLU_EXPORT Node
    {

    protected:

      enum { ADD, REMOVE, FIND, FIND_NUMBER, GET_SELECTED };  // parameters for modify()
      enum { DRAW, MEASURE, MEASURE_THIS_OPEN, HANDLE, COUNT_SELECTED };  // parameters for recurse()

      // flags
      enum { SELECTED = 0x0001, COLLAPSED = 0x0002, LEAF = 0x0004, SHOW_LABEL = 0x0008,
             ACTIVE = 0x0010, EXPAND_TO_WIDTH = 0x0020, ALWAYS_OPEN = 0x0040,
             SOME_VISIBLE_CHILDREN = 0x0080, MOVABLE = 0x0100, DROPPABLE = 0x0200,
             AUTO_LABEL_COLOR = 0x0400, AUTO_COLOR = 0x0800, AUTO_LABEL = 0x1000, 
             SWAP_LABEL_AND_WIDGET = 0x2000, ICON_AT_END = 0x4000 };

      // flag manipulator functions
      inline bool CHECK( unsigned short flag ) const { return flags & flag; }
      inline void SET( unsigned short flag ) { flags |= flag; }
      inline void SET( unsigned short flag, bool b ) { if(b) SET(flag); else CLEAR(flag); }
      inline void CLEAR( unsigned short flag ) { flags &= ~flag; }

    public:

      inline bool active() const
        { return CHECK(ACTIVE); }

      void active( bool b );

      inline void activate()
        { active(true); }


      inline Node* add( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true )
        { return( modify( fullpath, ADD, tree->rdata, w, showLabel ) ); }

      Node* add_branch( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true );

      Node* add_leaf( const char* fullpath, Fl_Widget *w = 0, bool showLabel = true );

      Node* add( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );

      Node* add_branch( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );

      Node* add_leaf( const char* path, const char* name, Fl_Widget *w = 0, bool showLabel = true );

      inline void always_open( bool b )
        { if( b ) open(true); SET(ALWAYS_OPEN,b); tree->rdata.forceResize = true; }

      inline bool always_open() const
        { return CHECK(ALWAYS_OPEN); }

      inline void auto_color( bool b )
        { SET(AUTO_COLOR,b); }

      inline bool auto_color()
        { return CHECK(AUTO_COLOR); }

      inline void auto_label( bool b )
        { SET(AUTO_LABEL,b); }

      inline bool auto_label()
        { return CHECK(AUTO_LABEL); }

      inline void auto_label_color( bool b )
        { SET(AUTO_LABEL_COLOR,b); }

      inline bool auto_label_color()
        { return CHECK(AUTO_LABEL_COLOR); }

      void branch_icons( Fl_Image *closed, Fl_Image *open );

      inline void branch_icon( Fl_Image *icon )
        { branch_icons( icon, icon ); }

      Node* child( int i ) const;

      inline int children() const
        { return _children.size(); }

      void clear();

      inline void close()
        { open( false ); }

      inline bool closed()
        { return !open(); }


      void collapse_icons( Fl_Image *closed, Fl_Image *open );

      inline void deactivate()
        { active(false); }

      unsigned short depth() const;

      void do_callback( int reason );

      inline void droppable( bool b )
        { SET(DROPPABLE,b); }

      inline bool droppable()
        { return CHECK(DROPPABLE); }

      inline void expand_to_width( bool b )
        { SET(EXPAND_TO_WIDTH,b); tree->rdata.forceResize = true; }

      inline bool expand_to_width() const
        { return CHECK(EXPAND_TO_WIDTH); }


      inline Node* find( const char *fullpath )
        { return( modify( fullpath, FIND, tree->rdata ) ); }


      Node* find( unsigned int id );


      Node* find( Fl_Widget *w );


      inline Node* find( Node *n )
        { if( !n ) return NULL; else return find( n->id() ); }


      inline const char* find_path()
        { return tree->find_path( this ); }

      Node* first();

      Node* first_branch();

      Node* first_leaf();

      inline void swap_label_and_widget( bool b )
        { SET(SWAP_LABEL_AND_WIDGET,b); }

      inline bool swap_label_and_widget()
        { return CHECK(SWAP_LABEL_AND_WIDGET); }      


      Node* get_selected( int index );

      inline void icon_at_end( bool b )
        { SET(ICON_AT_END,b); }

      inline bool icon_at_end()
        { return CHECK(ICON_AT_END); }

      inline unsigned int id() const
        { return _id; }


      int index() const;

      Node* insert( const char* fullpath, int pos );

      Node* insert_branch( const char* fullpath, int pos );

      Node* insert_leaf( const char* fullpath, int pos );

      bool is_ancestor( Node* n );

      bool is_branch() const;

      bool is_descendent( Node* n );

      bool is_leaf() const;

      inline bool is_root() const
        { return( _parent == 0 ); }

      inline void label( const char *l )
        { text = l; tree->redraw(); }

      inline const char* label() const
        { return text.c_str(); }

      inline void label_color( Fl_Color c )
        { textColor = c; }

      inline Fl_Color label_color() const
        { return textColor; }

      inline void label_font( Fl_Font f )
        { textFont = f; tree->rdata.forceResize = true; }

      inline Fl_Font label_font() const
        { return textFont; }

      inline void label_size( unsigned char s )
        { textSize = s; tree->rdata.forceResize = true; }

      inline unsigned char label_size() const
        { return textSize; }

      inline bool label_visible() const
        { return CHECK(SHOW_LABEL); }

      inline void label_visible( bool b )
        { SET(SHOW_LABEL,b); tree->rdata.forceResize = true; }

      Node* last();

      Node* last_branch();

      Node* last_leaf();

      void leaf_icon( Fl_Image *icon );

      inline void movable( bool b )
        { SET(MOVABLE,b); }

      inline bool movable()
        { return CHECK(MOVABLE); }


      bool move( int pos );


      inline bool move( int where, Node* n )
        { return( move( this, where, n ) ); }


      static bool move( Node* n1, int where, Node* n2 );

      Node* next();

      Node* next_branch();

      Node* next_leaf();

      Node* next_sibling();

      int num_selected();

      inline bool open() const
        { return( !CHECK(COLLAPSED) || tree->rdata.allBranchesAlwaysOpen ); }

      void open( bool b );

      inline Node* parent() const
        { return _parent; }

      Node* previous();

      Node* previous_branch();

      Node* previous_leaf();

      Node* previous_sibling();

      void print( int spaces = 0 );


      inline unsigned int remove( const char *fullpath )
        { return( (unsigned int)modify( fullpath, REMOVE, tree->rdata ) ); }


      unsigned int remove( unsigned int id );


      unsigned int remove( Fl_Widget *w );


      inline unsigned int remove( Node* n )
        { if( !n ) return 0; else return remove( n->id() ); }

      void select_all();

      inline bool selected() const
        { return CHECK(SELECTED); }

      void select( bool b );

      inline void select_only()
        { tree->unselect_all(); select(true); }

      inline void sort_children()
        { sort(); }

      void sort_widgets();


      inline bool swap( Node* n )
        { return swap( this, n ); }


      static bool swap( Node* n1, Node* n2 );

      void unselect_all( Node* except = NULL );

      inline void* user_data()
        { return userData; }

      inline void user_data( void *d )
        { userData = d; }

      inline Fl_Widget* widget() const
        { return( _widget ? _widget->w : NULL ); }

      void widget( Fl_Widget *w );

    protected:

      friend class Flu_Tree_Browser;
      friend class NodeList;

      // Root node constructor
      Node( const char *lbl = 0 );

      // Non-root constructor
      Node( bool l, const char* n, Node *p, RData &rdata, Fl_Widget *w, bool showLabel );

      ~Node();

      // add/remove/find/get
      Node* modify( const char* path, int what, RData &rdata, Fl_Widget *w = 0, bool showLabel = true );

      void initType();

      void sort();

      void determineVisibility( bool parentVisible = true );

      static bool isMoveValid( Node* &n1, int &where, Node* &n2 );

      // handle/draw/measure/count
      int recurse( RData &rdata, int type, int event = 0 );

      void draw( RData &rdata, bool measure );

      // recursively finding the full path of the node identified by id
      bool findPath( unsigned int id, RData &rdata );

      // recursively finding the full path of the node containing w
      bool findPath( Fl_Widget *w, RData &rdata );

      class FLU_EXPORT WidgetInfo
        {
        public:
          Fl_Widget *w;
          int defaultW;  // the initial width of the widget
          void (*CB)(Fl_Widget*,void*);
          void *CBData;
        };

      unsigned int _id; // the unique id of this node
      unsigned short flags;
      NodeList _children;
      Node *_parent;
      Flu_Tree_Browser *tree;
      FluSimpleString text;
      WidgetInfo *_widget;  // memory overhead deferred to WidgetInfo. present only if widget is
      Fl_Group *_group;
      void *userData;
      int totalChildH; // needed for animation
      Fl_Image *cIcon[2], *bIcon[2], *lIcon;
      Fl_Color textColor;
      Fl_Font textFont;
      unsigned char textSize;  // the font size of the entry label text
      unsigned short textW, textH;  // how big the entry label actually is (stored within the node for performance reasons)
      int currentY; // needed for animation
      unsigned short currentH;

      inline static void _widgetCB( Fl_Widget* w, void* arg )
        { ((Node*)arg)->widgetCB(); }
      void widgetCB();
     };

 protected:

  inline static void _scrollCB( Fl_Widget* w, void* arg )
    { ((Flu_Tree_Browser*)arg)->redraw(); }

  inline static void _timerRedrawCB( void *arg )
    { ((Flu_Tree_Browser*)arg)->timerRedrawCB(); }
  void timerRedrawCB();

  inline static void _timerScrollCB( void *arg )
    { ((Flu_Tree_Browser*)arg)->timerScrollCB(); }
  void timerScrollCB();

  void on_dnd_leave();

  void on_dnd_release();

  bool on_dnd_drag( int X, int Y );

  void on_dnd_drop( const Flu_DND_Event *e );

  /* override of Fl_Double_Window::draw() */
  void draw();

  Fl_Group *scrollBox;
  Fl_Scrollbar *scrollH, *scrollV;
  Fl_Group *_box;
  Node root;
  RData rdata;
  //int lastEvent;
  float autoScrollX, autoScrollY;
  bool scrolledTimerOn, clearing;

};

#endif

---