grtree.h

Go to the documentation of this file.

/**
 * \file grtree.h <mi32/grtree.h>
 * \brief Definitions for GraphicTree functions
 *
 * \if NODOC
 * $Id: grtree.h_v 1.43 2004/02/16 15:31:24 mju Exp $
 *
 * $Log: grtree.h_v $
 * Revision 1.43  2004/02/16 15:31:24  mju
 * Don't include X stuff as need to build for MFC also.
 *
 * Revision 1.42  2004/02/12 22:15:24  dwilliss
 * Deprecate old MGD
 *
 * Revision 1.41  2003/12/01 20:55:02  dwilliss
 * Added new static event handler
 *
 * Revision 1.40  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.39  2002/09/12 22:30:45  dwilliss
 * Added a member to keep track of where tool tip popped up
 *
 * Revision 1.38  2002/08/28 20:59:16  scowan
 * Added private nested class.
 *
 * Revision 1.37  2002/02/08 15:42:03  mju
 * Make ScrollToItem() public.
 *
 * Revision 1.36  2002/02/08 14:59:29  mju
 * Add GetActiveItem method.
 *
 * Revision 1.35  2001/11/27 14:25:40  mju
 * Add ITEM::SetMayHaveChildren().
 *
 * Revision 1.34  2001/07/09 20:44:14  mju
 * n/c
 *
 * Revision 1.33  2001/05/09 16:47:08  mju
 * Allow access to ITEM pointer and add ITEM methods for navigation.
 * Make MSG nested in ITEM.
 * Add MSG::GetItem() and associated item member.
 *
 * Revision 1.32  2001/05/08 21:42:24  mju
 * Add single-selection mode.
 * Add ability to include expand/collapse icons.
 *
 * Revision 1.31  2000/09/19 19:34:39  dwilliss
 * doubleclick test not available in win32-native
 *
 * Revision 1.30  2000/09/19 17:54:19  dwilliss
 * Added double click support
 *
 * Revision 1.29  2000/09/15 19:10:02  dwilliss
 * Added Double click message
 *
 * Revision 1.28  2000/08/14 17:53:02  dwilliss
 * Evil default constructor for message struct
 *
 * Revision 1.27  2000/08/14 15:01:32  dwilliss
 * Why does it think I still have this checked out locked?  I just checked in
 * revision 1.26
 *
 * Revision 1.26  2000/08/14 14:58:34  dwilliss
 * Added Get/SetPrivData() to the tree
 * Added pointer to the tree to the message structure
 * Gave message structure a constructor which takes tree so you can't mess it up.
 *
 * Revision 1.25  2000/06/12 12:57:19  sparsons
 * Genitor documentation.
 *
 * Revision 1.24  2000/06/07 14:19:21  mju
 * Include xdefns.h.
 *
 * Revision 1.23  2000/01/14 23:13:00  mju
 * Add ItemExists.
 *
 * Revision 1.21  1999/10/19 20:52:01  mju
 * Use callbacks for scrolling.
 *
 * Revision 1.20  1999/10/14  22:09:29  mju
 * Use m_ for member vars.
 *
 * Revision 1.19  1999/10/13  20:39:01  mju
 * Include mg2x.h if not already.
 *
 * Revision 1.18  1999/08/23  15:48:44  dwilliss
 * Don't leave dangling commas on enums or the Macintosh will hate you
 *
 * Revision 1.17  1999/07/15 13:48:40  mju
 * Declare cb/eh removal methods.
 *
 * Revision 1.16  1999/04/30  16:54:00  mju
 * Use DEFINE_ENUM_OPERATORS for flags.
 *
 * Revision 1.15  1999/03/12  23:06:39  mju
 * Add autoscroll flag to DrawInsertionIndicator.
 *
 * Revision 1.14  1999/03/12  16:07:22  mju
 * Eliminate defaulting for all RefIndex parameters.
 *
 * Revision 1.13  1999/03/10  15:34:03  mju
 * Add "RefIndex" stuff so can reuse references.
 *
 * Revision 1.12  1999/03/09  18:20:41  mju
 * Add items needed for drag-and-drop reordering.
 *
 * Revision 1.11  1999/03/01  17:57:57  mju
 * Add control of children visibility.
 *
 * Revision 1.10  1999/02/26  18:21:15  mju
 * Fix popup menu support.
 *
 * Revision 1.9  1999/02/26  14:26:24  mju
 * Don't declare MSG.popupmenu if WIN32_NATIVE.
 *
 * Revision 1.7  1999/02/24  23:06:42  mju
 * Add ToolTip support.
 * Add methods to disable drawing.
 *
 * Revision 1.6  1999/02/19  23:08:48  mju
 * Eliminate callback system, add messages for selected/deselected/deleting.
 *
 * Revision 1.5  1999/01/29  22:18:08  mju
 * Don't define constructor using widget in win32-native mode.
 *
 * Revision 1.4  1999/01/29  22:13:58  mju
 * Redesign to be a class.
 *
 * Revision 1.1  1999/01/05  21:10:42  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_GRTREE_H
#define  INC_MI32_GRTREE_H

#if !defined(INC_MI32_XDEFNS_H) && defined(X_NATIVE)
   #include <mi32/xdefns.h>
#endif

#ifndef  INC_MI32_MCB_H
#include <mi32/mcb.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#if !defined(INC_MI32_MGD2_H)
#include <mi32/mgd2.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
const int GTREEHASHSIZE = 37;          //!< Size of hash table
#endif //!< GENERATING_DOXYGEN_OUTPUT


class GRAPHICTREE {
   public:

      //! Flags used in tree and item creation.
      enum FLAGS {
         FirstAtTop =            0x00000000,
         FirstAtBottom =         0x00000001,
         NoScrollHorizontal =    0x00000002, //!< Don't include horizontal scrollbar
         AllowChildSelection =   0x00000004,
         AllowChildReorder =     0x00000008,
         IncludeExpandIcons =    0x00000010, //!< Include expand/collapse icons
         ItemMayHaveChildren =   0x00000020, //!< Item may have children, determine when attempt to expand
         SingleSelectionOnly =   0x00000040, //!< Only single tree item may be selected at a time
         ChildrenHidden =        0x00000080  //!< Children initially hidden
         };

      //! Individual tree item.
      class ITEM {
         public:

            //! Message container to send to message handler.
            class MSG {
               public:

                  //! Message type.
                  enum MSGTYPE {
                     NoMessage = 0,
                     Draw,
                     PointerMotion,
                     ButtonPressed,
                     ButtonReleased,
                     ButtonMotion,
                     KeyPressed,
                     KeyReleased,
                     RequestSize,
                     Deselected,
                     Selected,                        //!< Item "selected"
                     PositionChanged,                 //!< Position changed
                     Deleting,                        //!< Item being deleted
                     RequestToolTip,                  //!< Requesting ToolTip
                     ButtonDoubleClick,               //!< User double-clicked
                     ShowChildren,                    //!< Children about to be shown
                     HideChildren                     //!< Children have been hidden
                     };

                  //! Processing done for Button/KeyPress messages.
                  enum MSGPROC {       
                     Ignored = 0,                     //!< Message was ignored, don't send Button/Key release message
                     Normal = 1,                      //!< Message handled, send Button/KeyRelease message
                     Reset = 2,                       //!< Message handled and Button/KeyRelease consumed also (grab)
                     PopupMenu                        //!< Message handler wants graphictree to popup menu
                     };

                  enum BTNKEY {
                     ButtonLeft =   0x01,
                     ButtonMiddle = 0x02,
                     ButtonRight =  0x04,
                     Shift =        0x10,
                     Control =      0x20
                     };

                  MSGTYPE type;                       //!< Message type
                  void *Reference;                    //!< Item reference
                  void *PrivPtr;                      //!< Item's private pointer if set
                  UINT32 RefIndex;                    //!< Item reference index
                  LPOINT2D origin;                    //!< Item origin in window coordinates
                  LPOINT2D pointer;                   //!< Pointer location where event occurred
                  MSGPROC proc;                       //!< What processing message handler did
                  BTNKEY state;                       //!< Button/Modifier key state
                  BTNKEY button;                      //!< Which button was pressed/released
                  UNICODE key;                        //!< Which key was pressed/released
                  LRECT2D drawrect;                   //!< Rectangle to draw
                  MGD::CONTEXT* gc;                   //!< Graphic context for drawing
                  UINT32 VisibleWidth;                //!< Visible width for SizeRequest
                  LPOINT2D size;                      //!< Item size for SizeRequest
                  UNICODE *tooltip;                   //!< ToolTip string returned (will be freed)
               #ifdef X_NATIVE
                  Widget popupmenu;                   //!< Menu to display when message handler requests
               #endif
                  GRAPHICTREE* tree;                  //!< The GRAPHICTREE that the message came from.

                  //! Default constructor.
                  MSG (
                     ) {
                     memset(this, 0, sizeof(MSG));
                     }

                  //! Get item message applies to.
                  ITEM* GetItem (
                     ) const { return (m_item); }

               private:
                  #ifndef GENERATING_DOXYGEN_OUTPUT
                  ITEM *m_item;
                  #endif // GENERATING_DOXYGEN_OUTPUT
               friend class ITEM;
               }; //! End of MSG class

            //! Get first child for this item.
            //! @return ITEM pointer or NULL if no children.
            ITEM* GetFirstChild (
               ) const { return (FirstChild); }

            //! Get next sibling for this item.
            //! @return ITEM pointer or NULL if end of list.
            ITEM* GetNextSibling (
               ) const { return (NextSibling); }

            //! Get parent for this item.
            //! @return ITEM pointer or NULL if this is root item.
            ITEM* GetParent (
               ) const { return (Parent); }

            //! Get 'private pointer' for this item.
            void* GetPrivPtr (
               ) const { return (m_PrivPtr); }

            //! Get 'reference index' for this item.
            UINT32 GetRefIndex (
               ) const { return (RefIndex); }

            //! Get 'reference pointer' used when item was created.
            void* GetRefPointer (
               ) const { return (Reference); }

            //! Get 'selected' child for this item.
            //! @return ITEM pointer or NULL if none selected.
            ITEM* GetSelectedChild (
               ) const { return (ActiveChild); }

            //! Get GRAPHICTREE associated with item.
            //! @return Reference to GRAPHICTREE.
            GRAPHICTREE& GetTree (
               ) const { return (m_tree); };

            //! Determine if this is the 'root' item.
            bool IsRoot (
               ) const { return (Parent == 0); }

            //! Set visibility for item's children.
            void SetChildrenVisible (
               bool visible = true,
               bool redraw = true
               );

            //! Set spacing between children.
            void SetChildSpacing (
               UINT8 p_Spacing
               ) { Spacing = p_Spacing; SetTotalSizeInvalid(); return; }

            //! Set whether item 'might' have children.
            //! This setting has no effect if item does have children.
            void SetMayHaveChildren (
               bool p_MayHaveChildren = true
               ) { MayHaveChildren = p_MayHaveChildren; }

            //! Set 'private pointer' for this item.
            void SetPrivPtr (
               void *PrivPtr
               ) { m_PrivPtr = PrivPtr; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            GRAPHICTREE& m_tree;       //!< Tree containing item
            void *Reference;
            void *m_PrivPtr;
            UINT32 RefIndex;
            void (*HandleMsg)(MSG*);   //! Message handler
            LPOINT2D TopLeft;          //!< Top-Left point for item relative to parent
            LPOINT2D ItemSize;         //!< Size of item in pixels
            LPOINT2D TotalSize;        //!< Size of item and all visible children including margins
            UINT8 Visible;             //!< Set if item is visible
            UINT8 ChildrenVisible;     //!< Set if children are visible
            UINT8 Hidden;              //!< Set if item is hidden based on visibility settings
            UINT8 ItemSizeValid;       //!< Set if Size for this item is valid
            UINT8 TotalSizeValid;      //!< Set if TotalSize is valid
            UINT8 FirstChildAtBottom;  //!< First child in list is at bottom
            UINT8 AllowChildSelection; //!< Allow child to be selected graphically
            UINT8 AllowChildReorder;   //!< Allow children to be reordered via drag-and-drop
            UINT8 MayHaveChildren;     //!< Item might have children, determine on expansion
            UINT8 MarginTop;           //!< Top margin for child list
            UINT8 MarginBottom;        //!< Bottom margin for child list
            UINT8 MarginLeft;          //!< Left margin for child list
            UINT8 MarginRight;         //!< Right margin for child list
            UINT8 Spacing;             //!< Spacing between children
            ITEM *Parent;              //!< Parent item, NULL if item is root
            ITEM *NextSibling;         //!< Next sibling item if any
            ITEM *FirstChild;          //!< First child item if any
            ITEM *ActiveChild;         //!< Active child item if any
            ITEM *NextHash;            //!< Next item in hash list

            ITEM (
               GRAPHICTREE& tree
               );

            ITEM (
               ITEM *parent, 
               void *ItemRef, 
               UINT32 RefIndex, 
               void (*HandleMsg)(MSG*),
               FLAGS flags
               );

            ~ITEM (
               );

            int GetPosition (
               );

            void Initialize (
               );

            void Insert (
               int
               );

            void Remove (
               );

            void SendMsg (
               MSG& msg, 
               MSG::MSGTYPE msgtype=MSG::NoMessage
               );

            void SendMsg (
               MSG::MSGTYPE msgtype
               );

            void SetTotalSizeInvalid (
               );

            friend class GRAPHICTREE;        //!< Give GRAPHICTREE access to ITEM
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

#ifdef X_NATIVE
      //! Constructor.
      GRAPHICTREE (                    
         Widget parent,
         const char *sizefield,
         Arg *arglist,
         int argcount,
         FLAGS flags = FirstAtTop
         );
#endif
      //! Destructor.
      ~GRAPHICTREE ();

      //! Delete all children of specified parent.
      void DeleteChildren (
         void *ParentReference,
         UINT32 ParentRefIndex,
         bool redraw = true
         );

      //! Find item matching specified reference pointer and index.
      //! @return Pointer to item or NULL if none found.
      ITEM* FindItemByRef (
         const void *RefPointer,
         UINT32 RefIndex
         ) const;

      //! Get "active" child for given parent if any.
      void *GetActiveChild (           
         void *ParentReference,
         UINT32 ParentRefIndex
         );

      //! get 'active' item in single-selection mode.
      //! @return Pointer to active item, NULL if none active.
      ITEM* GetActiveItem (
         ) const { return (m_ActiveItem); }

#ifdef X_NATIVE
      //! Get DrawingArea widget for GraphicTree.
      Widget GetDrawingArea (          
         ) const {
         return (m_da);
         }
#endif
      //! Get first child for given parent.                                         
      void *GetFirstItem (          
         void *ParentReference,
         UINT32 ParentRefIndex
         ) const;

      //! Get next "sibling" item.
      void *GetNextItem (              
         void *ItemReference,
         UINT32 ItemRefIndex
         ) const;

      void *GetParentItem (
         void *ItemReference,
         UINT32 ItemRefIndex
         ) const;

      void * GetPrivData (
         ) const {
         return (m_PrivPtr);
         }

      const ITEM* GetRootItem (
         ) const { return (&m_Root); }

#ifdef X_NATIVE
      //! Get widget.
      Widget GetWidget (
         ) const {
         return (XtParent(m_da));
         }
#endif
      //! Add item to GRAPHICTREE as child of specified item.
      //! @return Pointer to ITEM added.
      ITEM* ItemAdd (                     
         void *ParentReference,
         UINT32 ParentRefIndex,
         void *ItemReference,
         UINT32 ItemRefIndex,
         void (*MsgHandler)(ITEM::MSG*),
         int position,
         FLAGS flags = FirstAtTop
         );

      //! Add item to GRAPHICTREE as child of root.
      //! @return Pointer to ITEM added.
      ITEM* ItemAdd (                     
         void *ItemReference,
         UINT32 ItemRefIndex,
         void (*MsgHandler)(ITEM::MSG*),
         int position,
         FLAGS flags = FirstAtTop
         ) {
         return (ItemAdd(NULL,0,ItemReference,ItemRefIndex,MsgHandler,position,flags));
         }

      //! Determine if item's children are visible.
      bool ItemAreChildrenVisible (    
         void *ItemReference,
         UINT32 ItemRefIndex
         );

      //! Delete item and all children.
      bool ItemDelete (                
         void *ItemReference,
         UINT32 ItemRefIndex,
         bool redraw = true
         );

      //! Determine if specified item exists.
      bool ItemExists (                
         void *ItemReference,
         UINT32 ItemRefIndex
         ) {
         return (FindItemByRef(ItemReference,ItemRefIndex) != NULL);
         }

      //! Get position of item in parent's list of children.
      int ItemGetPosition (            
         void *ItemReference,
         UINT32 ItemRefIndex
         );

      //! Get private pointer for item.
      void* ItemGetPrivPtr (           
         void *ItemReference,
         UINT32 ItemRefIndex
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) return (item->GetPrivPtr());
         return (NULL);
         }

      //! Determine visibility for item.
      bool ItemIsVisible (             
         void *ItemReference,
         UINT32 ItemRefIndex
         );

      //! Notify GRAPHICTREE that item has changed so will update size.
      void ItemNotifyChanged (         
         void *ItemReference,
         UINT32 ItemRefIndex,
         bool redraw = true
         );

      //! Redraw specified item.
      void ItemRedraw (                
         void *ItemReference,
         UINT32 ItemRefIndex
         );

      //! Set bottom margin for child list.
      void ItemSetChildMarginBottom (  
         void *ItemReference,
         UINT32 ItemRefIndex,
         UINT8 Margin
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) {
            item->MarginBottom = Margin;
            item->SetTotalSizeInvalid();
            }
         return;
         }

      //! Set left margin for child list.
      void ItemSetChildMarginLeft (    
         void *ItemReference,
         UINT32 ItemRefIndex,
         UINT8 Margin
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) {
            item->MarginLeft = Margin;
            item->SetTotalSizeInvalid();
            }
         return;
         }

      //! Set right margin for child list.
      void ItemSetChildMarginRight (   
         void *ItemReference,
         UINT32 ItemRefIndex,
         UINT8 Margin
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) {
            item->MarginRight = Margin;
            item->SetTotalSizeInvalid();
            }
         return;
         }

      //! Set top margin for child list.
      void ItemSetChildMarginTop (     
         void *ItemReference,
         UINT32 ItemRefIndex,
         UINT8 Margin
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) {
            item->MarginTop = Margin;
            item->SetTotalSizeInvalid();
            }
         return;
         }

      //! Set spacing between children.
      void ItemSetChildSpacing (       
         void *ItemReference,
         UINT32 ItemRefIndex,
         UINT8 Spacing
         ) {
         if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) {
            item->SetChildSpacing(Spacing);
            }
         return;
         }

      //! Set visibility for children of item.
      void ItemSetChildrenVisible (    
         void *ItemReference,
         UINT32 ItemRefIndex,
         bool visible,
         bool redraw = true
         );

      //! Set item position in list.
      void ItemSetPosition (
         void *ItemReference,
         UINT32 ItemRefIndex,
         int position,
         bool redraw = true
         );

      //! Set private pointer for item.
      void ItemSetPrivPtr (            
         void *ItemReference,
         UINT32 ItemRefIndex,
         void *PrivPtr
         ) { if (ITEM *item = FindItemByRef(ItemReference,ItemRefIndex)) item->SetPrivPtr(PrivPtr); }

      //! Set visiblity for item.
      void ItemSetVisible (            
         void *ItemReference,
         UINT32 ItemRefIndex,
         bool visible,
         bool redraw = true
         );

      //! Notify GraphicTree that item has changed so can recompute size/position.
      void NotifyChanged (
         bool redraw = true
         ) { ItemNotifyChanged(NULL,0,redraw); }

      //! Redraw GRAPHICTREE.
      void Redraw (                    
         LRECT2D *rect=0
         );

      //! Disable redraw.
      void RedrawDisable (
         ) { m_DisableRedraw = 1; }

      //! Enable redraw.
      void RedrawEnable (
         bool redraw = true
         ) { m_DisableRedraw = 0; if (redraw) Redraw(); }

      //! Scroll to make specified item visible.
      void ScrollToItem (
         ITEM *item                    //!< Item to make visible
         );

      //! Set active child item.
      void SetActiveChild (
         void *ParentReference,
         UINT32 ParentRefIndex,
         void *ItemReference,          //!< Pass NULL to set to have no active item
         UINT32 ItemRefIndex
         );

      //! Set active child item.
      inline void SetActiveChild (
         void *ParentReference,
         void *ItemReference
         ) {
         SetActiveChild(ParentReference,0,ItemReference,0);
         return;
         };

      //! Set active item in single-selection mode.
      void SetActiveItem (
         ITEM* item
         );

      inline void SetPrivData (
         void *data
         ) {
         m_PrivPtr = data;
         return;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      mutable ITEM *m_TraversalItem;   //!< Last item returned by FindFirst/FindNext
      ITEM *m_HashItem[GTREEHASHSIZE]; //!< Hash table for searching by reference
      ITEM *m_CursorItem;           //!< Item mouse cursor was last in (grabbed for ButtonPress)
      ITEM *m_DragParent;           //!< Parent for drag-and-drop reordering
      ITEM *m_DragInsertItem;       //!< Item to insert after while dragging, NULL to put first
      ITEM *m_ActiveItem;           //!< Active item in single-selection mode
      LPOINT2D m_CursorPos;            //!< Pointer location where last event occurred (relative to CursorItem)
      LPOINT2D m_DrawSize;             //!< Size of DrawingArea
      LPOINT2D m_TopLeft;              //!< Current top-left visible coordinate (0,0 in DrawingArea)
      LRECT2D m_DrawClipRect;          //!< Current drawing clip rectangle
      UINT8 m_NeedRedraw;              //!< Set if need to do complete redraw
      UINT8 m_DoingRedraw;             //!< Set if doing redraw
      UINT8 m_DisableRedraw;           //!< Set if redraw is disabled
      UINT8 m_UpdateSB;                //!< Set if scrollbars need to be updated
      UINT8 m_ToolTipVisible;
      UINT8 m_DoingReorder;            //!< Set while dragging child
      bool m_IncludeExpandIcon;
      bool m_SingleSelection;
      MGD::DEVICE* m_sdisp;
      MGD::CONTEXT* m_sgc;
      MPIXEL m_BackgroundPixel;
      MPIXEL m_HighlightPixel;
#ifdef X_NATIVE
      Widget m_da;                     //!< DrawingArea
      Widget m_hsb;                    //!< Horizontal ScrollBar
      Widget m_vsb;                    //!< Vertical ScrollBar
      void *m_ToolTipHandle;
#endif
      ITEM m_Root;                     //!< Root item
      void *m_PrivPtr;                 //!< Private data which can be set/retrieved by the caller
#ifdef X_NATIVE
      DOUBLECLICKTEST m_DoubleClickTest;
      LPOINT2D m_ToolTipPos;
#endif

      //! Helper methods
      void BeginReorder ();
      void ComputeHiddenStatus (ITEM*);
      void ComputeItemSizePos (ITEM*, INT32, bool);
      void DeleteChildren (ITEM*);
      void DeleteItem (ITEM*);
      void DrawHighlight (ITEM*, bool);
      void DrawInsertionIndicator (bool show, bool autoscroll=false);
      void DrawItem (ITEM*, INT32, INT32);
      void EndReorder ();
      ITEM * FindItemByCoord (ITEM*, int, int) const;
      void NotifyChanged (ITEM*);
      void SetActiveChild (ITEM*);
      void UpdateSize ();

#ifdef X_NATIVE
      //! Callbacks & event handlers
      static void CB_Destroy (Widget, GRAPHICTREE*, void*);
      static void CB_Expose (Widget, GRAPHICTREE*, void*);
      static void CB_Resize (Widget, GRAPHICTREE*, void*);
      static void CB_ScrollH (Widget, GRAPHICTREE*, void*);
      static void CB_ScrollV (Widget, GRAPHICTREE*, void*);
      static void CBT_ToolTipPopup (GRAPHICTREE*, XtIntervalId*);
      static void EH_Input (Widget, GRAPHICTREE*, XEvent*, Boolean*);
      static void EH_GraphicsExpose (Widget, GRAPHICTREE*, XEvent*, Boolean*);
//!      static void EH_ScrollH (Widget, GRAPHICTREE*, XEvent*, Boolean*);
//!      static void EH_ScrollV (Widget, GRAPHICTREE*, XEvent*, Boolean*);
      XtIntervalId m_IntervalID;

      MXXTCB_ADD(GRAPHICTREE);
      MXXTEH_ADD(GRAPHICTREE);
      MXXTTO_ADD(GRAPHICTREE);
      MXXTCB_REMOVE(GRAPHICTREE);
      MXXTEH_REMOVE(GRAPHICTREE);
      
      class EVENTSENTRY;
      friend class EVENTSENTRY;
#endif

      friend class GRAPHICTREE::ITEM;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

DEFINE_ENUM_OPERATORS(GRAPHICTREE::FLAGS)

typedef GRAPHICTREE::ITEM::MSG GRAPHICTREEITEM_MSG;
typedef void (*GraphicTreeItemMsgHandler)(GRAPHICTREE::ITEM::MSG*);

#endif

---