home *** CD-ROM | disk | FTP | other *** search
/ Mastering Visual Basic 6 / mastvb6.iso / numega / sc501.exe / data1.cab / Examples / BCTREE.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-11-25  |  7.4 KB  |  214 lines
  1. /*
  2.  * BCTree.cpp
  3.  * $Header: /bcsample/BUGBNCHX/MAINERR/BCTREE.CPP 1     5/28/96 1:11p Dave $
  4.  *
  5.  * Description:
  6.  *  Standard helper functions that mimic the support given by the MFC
  7.  *   CTreeCtrl class are implemented here.  Also included are 
  8.  *   additional functions to help with Expanding/Collapsing all nodes
  9.  *   under a specific tree item and getting the LPARAM info from the
  10.  *   selected item.  
  11.  *
  12.  * Notes:
  13.  *  <implementation notes go here>
  14.  *
  15.  ***********************************************************************
  16.  *
  17.  * Nu-Mega Technologies, Inc.
  18.  * P.O. Box 7780
  19.  * Nashua, NH 03060
  20.  *
  21.  * (c) Copyright 1994, 1995 Nu-Mega Technologies, Inc.
  22.  * ALL RIGHTS RESERVED.
  23.  *
  24.  ***********************************************************************
  25.  *
  26.  **********************************************************************/
  27. #include "stdafx.h"
  28. #include "BCTree.h"
  29.  
  30. ////////////////////////////////////////////////////////////////////////
  31. // Standard tree control helpers
  32. //
  33. // All of the following functions are of the flavor of sending a message
  34. //  to the specified HWND.
  35. HTREEITEM TreeCtrl_InsertItem ( HWND hWnd , LPTV_INSERTSTRUCT lpInsertStruct )
  36. { 
  37.    ASSERT ( IsWindow ( hWnd ) ) ;  
  38.    return ( HTREEITEM ) SendMessage ( hWnd                     , 
  39.                                       TVM_INSERTITEM           ,  
  40.                                       0                        , 
  41.                                       ( LPARAM ) lpInsertStruct ) ; 
  42. }
  43.  
  44. BOOL TreeCtrl_DeleteAllItems ( HWND hWnd ) 
  45. { 
  46.    ASSERT ( IsWindow ( hWnd ) ) ;  
  47.    return ( BOOL ) SendMessage( hWnd               ,
  48.                                 TVM_DELETEITEM     , 
  49.                                 0                  , 
  50.                                 ( LPARAM ) TVI_ROOT ) ; 
  51. }
  52.  
  53. BOOL TreeCtrl_GetItem ( HWND hWnd , TV_ITEM* pItem )
  54. { 
  55.    ASSERT ( IsWindow ( hWnd ) ) ; 
  56.    return ( BOOL ) SendMessage ( hWnd            , 
  57.                                  TVM_GETITEM     , 
  58.                                  0               , 
  59.                                  ( LPARAM ) pItem ) ; 
  60. }
  61.  
  62. HTREEITEM TreeCtrl_GetParentItem ( HWND hWnd , HTREEITEM hItem )
  63. { 
  64.    ASSERT ( IsWindow ( hWnd ) ) ; 
  65.    return ( HTREEITEM ) SendMessage ( hWnd            , 
  66.                                       TVM_GETNEXTITEM , 
  67.                                       TVGN_PARENT     , 
  68.                                       ( LPARAM ) hItem ); 
  69. }
  70.  
  71. HTREEITEM TreeCtrl_GetChildItem ( HWND hWnd , HTREEITEM hItem )
  72. {
  73.    ASSERT ( IsWindow ( hWnd ) ) ; 
  74.    return ( HTREEITEM ) SendMessage ( hWnd            , 
  75.                                       TVM_GETNEXTITEM , 
  76.                                       TVGN_CHILD      , 
  77.                                       ( LPARAM ) hItem ); 
  78. }
  79.  
  80. HTREEITEM TreeCtrl_GetSelectedItem ( HWND hWnd )
  81. { 
  82.    ASSERT ( IsWindow ( hWnd ) ) ; 
  83.    return ( HTREEITEM ) SendMessage ( hWnd            , 
  84.                                       TVM_GETNEXTITEM , 
  85.                                       TVGN_CARET      , 
  86.                                       0                ); 
  87. }
  88.  
  89. HTREEITEM TreeCtrl_GetNextItem ( HWND hWnd       , 
  90.                                  HTREEITEM hItem , 
  91.                                  UINT nCode       )
  92. {
  93.    ASSERT ( IsWindow ( hWnd ) ) ; 
  94.    return ( HTREEITEM ) SendMessage ( hWnd, 
  95.                                       TVM_GETNEXTITEM, 
  96.                                       nCode, 
  97.                                       ( LPARAM ) hItem ) ; 
  98. }
  99.  
  100. HTREEITEM TreeCtrl_Select ( HWND hWnd       , 
  101.                             HTREEITEM hItem , 
  102.                             UINT nCode       )
  103. { 
  104.    ASSERT ( IsWindow ( hWnd ) ) ; 
  105.    return ( HTREEITEM ) SendMessage ( hWnd            , 
  106.                                       TVM_SELECTITEM  , 
  107.                                       nCode           , 
  108.                                       ( LPARAM ) hItem ); 
  109. }
  110.  
  111. BOOL TreeCtrl_EnsureVisible ( HWND hWnd , HTREEITEM hItem )
  112. {
  113.    ASSERT ( IsWindow ( hWnd ) ) ; 
  114.    return ( BOOL ) SendMessage ( hWnd              , 
  115.                                  TVM_ENSUREVISIBLE , 
  116.                                  0                 , 
  117.                                  ( LPARAM ) hItem   ) ; 
  118. }
  119.  
  120. BOOL TreeCtrl_Expand ( HWND hWnd       , 
  121.                        HTREEITEM hItem , 
  122.                        UINT nCode       )
  123. {
  124.    ASSERT ( IsWindow ( hWnd ) ) ; 
  125.    return ( BOOL ) SendMessage ( hWnd            , 
  126.                                  TVM_EXPAND      , 
  127.                                  nCode           , 
  128.                                  ( LPARAM ) hItem ) ; 
  129. }
  130.  
  131. ////////////////////////////////////////////////////////////////////////
  132. // Tree Control Extensions
  133. //
  134. // Additional work is needed to get the tree control functionality 
  135. //  desired.
  136.  
  137. // Expand/Collapse all items in the tree.
  138. void TreeCtrl_ExpandAll ( HWND hWnd , UINT nCode )
  139. {
  140.    // In the NT 3.51 RC, the Tree control will not notify the
  141.    //  parent window that the selected item has changed when we collapse
  142.    //  the tree.  To work around this we will force all collapse all's
  143.    //  to select the first item.
  144.    HTREEITEM hFirstItem = TreeCtrl_GetNextItem ( hWnd , NULL , TVGN_CHILD ) ;
  145.    HTREEITEM hItem = hFirstItem ;
  146.    while ( NULL != hItem )
  147.    {
  148.       TreeCtrl_Expand ( hWnd , hItem , nCode ) ;
  149.       TreeCtrl_ExpandCollapseAllBelow ( hWnd , hItem , nCode ) ;
  150.       hItem = TreeCtrl_GetNextItem ( hWnd , hItem , TVGN_NEXT ) ;
  151.    }
  152.    if ( TVE_COLLAPSE == nCode )
  153.       TreeCtrl_Select ( hWnd , hFirstItem , TVGN_CARET ) ;
  154. }
  155.  
  156.  
  157. // Extends the Expand function to do the operation on all items below
  158. //  the specified node.
  159. void TreeCtrl_ExpandCollapseAllBelow ( HWND hWnd       ,
  160.                                        HTREEITEM hItem ,
  161.                                        UINT      nCode  )
  162. {
  163.    // The degenerative case.
  164.    if ( NULL == hItem )
  165.       return ;
  166.    else
  167.    {
  168.       // Get the first child of the node passed in.
  169.       HTREEITEM hChild = TreeCtrl_GetChildItem ( hWnd , hItem ) ;
  170.       while ( NULL != hChild )
  171.       {
  172.          // Expand the child.
  173.          TreeCtrl_Expand ( hWnd , hChild , nCode ) ;
  174.          // Go all the way diagonally, expanding each
  175.          //  node as we come to it.
  176.          HTREEITEM hChildTwo = TreeCtrl_GetChildItem ( hWnd , hChild ) ;
  177.          while ( NULL != hChildTwo )
  178.          {
  179.             // Expand the child.
  180.             TreeCtrl_Expand ( hWnd , hChildTwo , nCode ) ;
  181.             hChildTwo = TreeCtrl_GetChildItem ( hWnd , hChildTwo ) ;
  182.             // Do ALL the expansion on the child.  And I thought
  183.             //  I would never see recursion after college!
  184.             TreeCtrl_ExpandCollapseAllBelow ( hWnd , hChildTwo , nCode ) ;
  185.          }
  186.          // Get the next child sibling.
  187.          hChild = TreeCtrl_GetNextItem ( hWnd , hChild , TVGN_NEXT ) ;
  188.       }
  189.    }
  190. }
  191.  
  192. // Gets the data out of the selected item and returns it
  193. //  as LPVOID.
  194. LPVOID TreeCtrl_GetSelectedLParam ( HWND hWnd ) 
  195. {
  196.    ASSERT ( IsWindow ( hWnd ) ) ;
  197.  
  198.    // Get the currently selected item.
  199.    HTREEITEM hItem = TreeCtrl_GetSelectedItem ( hWnd ) ;
  200.    ASSERT ( NULL != hItem ) ;
  201.  
  202.    if ( NULL == hItem )
  203.       return ( NULL ) ;
  204.  
  205.    // Get the information out of the selected item.
  206.    TV_ITEM stTVI ;
  207.    memset ( &stTVI , NULL , sizeof ( TV_ITEM ) ) ;
  208.    stTVI.hItem = hItem ;
  209.    VERIFY ( TreeCtrl_GetItem ( hWnd , &stTVI ) ) ;
  210.    return ( (void*) stTVI.lParam ) ;
  211.  
  212. }
  213.  
  214.