home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / directx / bellhop / cgrptree.cpp < prev    next >
C/C++ Source or Header  |  1997-07-14  |  36KB  |  1,479 lines
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1997 Microsoft Corporation.  All Rights Reserved.
  4.  *
  5.  *  File:       cGrpTree.cpp
  6.  *  Content:    An abstracted Tree control that knows how to handle
  7.  *              DirectPlay system messages and enumerations.
  8.  *
  9.  ***************************************************************************/
  10.  
  11. #include "cgrptree.h"
  12.  
  13. WNDPROC            gwpOrigEditProc;
  14.  
  15. ///////////////////////////////////////////////////////////////////////////////////////
  16. long FAR PASCAL EditCtrlSubProc(HWND hWnd, WORD wMessage,WORD wParam,LONG lParam)
  17. {
  18.  
  19.     switch (wMessage)
  20.      {
  21.  
  22.           case WM_GETDLGCODE:
  23.             return (DLGC_WANTALLKEYS |
  24.                     CallWindowProc( gwpOrigEditProc, hWnd, wMessage,
  25.                                    wParam, lParam));
  26.  
  27.           case WM_CHAR:
  28.           //Process this message to avoid message beeps.
  29.                 if ((wParam == VK_RETURN) || (wParam == VK_TAB))
  30.                     return 0;
  31.             break ;
  32.  
  33.        default:
  34.             break;
  35.  
  36.      } /* end switch */
  37.  
  38.     return (CallWindowProc( gwpOrigEditProc, hWnd, wMessage,
  39.                                    wParam, lParam));
  40.  
  41. }
  42.  
  43. ///////////////////////////////////////////////////////////////////////////////////////
  44. BOOL FAR PASCAL TV_EnumPlayersCallback(    DPID dpId,
  45.                                         DWORD dwPlayerType, 
  46.                                         LPCDPNAME lpName,
  47.                                         DWORD dwFlags, 
  48.                                         LPVOID lpContext)
  49. {
  50.     LPENUMTREESTRUCT lp = (LPENUMTREESTRUCT) lpContext;
  51.  
  52.     if (DPPLAYERTYPE_GROUP == dwPlayerType)
  53.     {
  54.         if (DPENUMGROUPS_SHORTCUT & dwFlags)
  55.         {
  56.             lp->lpTree->AddGroupToGroup( lp->dpidParent, dpId, dwFlags );
  57.         }
  58.         else
  59.         {
  60.             HRESULT    hr;
  61.             ENUMTREESTRUCT    ets;
  62.  
  63.             ets.dpidParent = dpId;
  64.             ets.lpTree = lp->lpTree;
  65.             ets.bRecursive = lp->bRecursive;
  66.  
  67.             if (NULL == lp->dpidParent)
  68.             {
  69.                 lp->lpTree->CreateGroup( dpId, lpName->lpszShortNameA, dwFlags );
  70.             }
  71.             else
  72.             {
  73.                 lp->lpTree->CreateGroupInGroup( lp->dpidParent, dpId, lpName->lpszShortNameA, dwFlags );
  74.             }
  75.  
  76.             if (ets.bRecursive)
  77.             {
  78.                 hr = lp->lpTree->m_lpDP3A->EnumGroupsInGroup(    dpId, NULL, 
  79.                                                             TV_EnumPlayersCallback, 
  80.                                                             &ets, DPENUMPLAYERS_ALL );
  81.  
  82.                 hr = lp->lpTree->m_lpDP3A->EnumGroupPlayers(    dpId, NULL, 
  83.                                                             TV_EnumPlayersCallback, 
  84.                                                             &ets, DPENUMPLAYERS_ALL );
  85.             }
  86.  
  87.         }
  88.     }
  89.     else
  90.     {
  91.         if (lp->dpidParent)
  92.         {
  93.             lp->lpTree->AddPlayerToGroup( lp->dpidParent, dpId, dwFlags );
  94.         }
  95.         else
  96.         {
  97.             lp->lpTree->CreatePlayer( dpId, lpName->lpszShortNameA, dwFlags );
  98.         }
  99.     }
  100.  
  101.     return TRUE;
  102. }
  103.  
  104. ///////////////////////////////////////////////////////////////////////////////////////
  105. int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  106. {
  107.     LPBRANCHSTRUCT    lp1 = (LPBRANCHSTRUCT) lParam1,
  108.                     lp2 = (LPBRANCHSTRUCT) lParam2;
  109.  
  110.     if ( lp1->btType < lp2->btType )
  111.     {
  112.         return -1;
  113.     }
  114.  
  115.     if (lp1->btType > lp2->btType )
  116.     {
  117.         return 1;
  118.     }
  119.  
  120.     //if we got here, they are of the same type
  121.     //so sort alphabetically
  122.  
  123.     LPDPNAME        lpdpn1 = NULL,
  124.                     lpdpn2 = NULL;
  125.     int                iRes = 0;
  126.     HRESULT            hr = DPERR_GENERIC;
  127.     CGroupTree *    lpgt = (CGroupTree *) lParamSort;
  128.  
  129.     if ((lp1->btType == BT_PLAYER ) || (lp1->btType == BT_PLAYER_IN_GROUP ))
  130.     {
  131.         hr = lpgt->GetPlayerName( lp1->dpid, &lpdpn1 );
  132.     }
  133.     else
  134.     {
  135.         hr = lpgt->GetGroupName( lp1->dpid, &lpdpn1 );
  136.     }
  137.  
  138.     if FAILED(hr)
  139.     {
  140.         goto FAILURE;
  141.     }
  142.  
  143.     if ((lp2->btType == BT_PLAYER ) || (lp2->btType == BT_PLAYER_IN_GROUP ))
  144.     {
  145.         hr = lpgt->GetPlayerName( lp2->dpid, &lpdpn2 );
  146.     }
  147.     else
  148.     {
  149.         hr = lpgt->GetGroupName( lp2->dpid, &lpdpn2 );
  150.     }
  151.  
  152.     if FAILED(hr)
  153.     {
  154.         goto FAILURE;
  155.     }
  156.  
  157.  
  158.     iRes = strcmp( lpdpn1->lpszShortNameA, lpdpn2->lpszShortNameA );
  159.  
  160.     if ( 0 == iRes )
  161.     {
  162.         //The groups have the same name.
  163.         if ( lp1->dpid <  lp2->dpid )
  164.         {
  165.             iRes = -1;
  166.         }
  167.         else if ( lp1->dpid >  lp2->dpid )
  168.         {
  169.             iRes = 1;
  170.         }
  171.         else
  172.         {
  173.             iRes = -1;
  174.         }
  175.     }
  176.  
  177. FAILURE:
  178.     if (lpdpn1)
  179.         LocalFree(lpdpn1);
  180.  
  181.     if (lpdpn2)
  182.         LocalFree(lpdpn2);
  183.  
  184.  
  185.     return iRes;
  186. }
  187.  
  188. ///////////////////////////////////////////////////////////////////////////////////////
  189. CGroupTree::CGroupTree()
  190. {
  191.  
  192.     m_hInst = GetModuleHandle( NULL );
  193.     m_hwndTreeView = NULL;
  194.     m_hwndParent = NULL;
  195.     m_lpDP3A = NULL;
  196.     m_fDragging = FALSE;
  197.     m_dpidPlayer = 0;
  198.     m_dpidLastGroup = NULL;
  199.  
  200.     // Prepare popup menus
  201.     m_hMenu = LoadMenu( m_hInst, MAKEINTRESOURCE(IDM_MENU) );
  202.     m_hRootMenu = GetSubMenu( m_hMenu, 0 );
  203.     m_hGroupMenu = GetSubMenu( m_hMenu, 1 );
  204.     m_hPlayerMenu = GetSubMenu( m_hMenu, 2 );
  205.     m_hShortcutMenu = GetSubMenu( m_hMenu, 3 );
  206.     m_hPlayerInGroupMenu= GetSubMenu( m_hMenu, 4 );
  207.  
  208.     // Prepare tree icons
  209.     m_hImageList = ImageList_Create(32, 32, 0, 8, 8);
  210.     ImageList_SetBkColor(m_hImageList, GetSysColor(COLOR_WINDOW));
  211.     m_nGroupImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_CLOSEDDOOR)));
  212.     m_nInGroupImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_OPENDOOR)));
  213.     m_nPlayerImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_PLAYER)));
  214.     m_nShortcutInGroupImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_SHORTCUT)));
  215.     m_nStagingAreaImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_STAGINGAREA)));
  216.     m_nSpectatorImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_SPECTATOR)));
  217.     m_nSessionInProgressImg = ImageList_AddIcon(m_hImageList, LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_SESSIONINPROGRESS)));
  218.  
  219.     ZeroMemory( &m_bsDragging, sizeof( BRANCHSTRUCT ) );
  220.  
  221. }
  222.  
  223. ///////////////////////////////////////////////////////////////////////////////////////
  224. CGroupTree::~CGroupTree()
  225. {
  226.     if (m_hImageList)
  227.     {
  228.         ImageList_Destroy( m_hImageList );
  229.         m_hImageList = NULL;
  230.     }
  231.  
  232.     DestroyMenu( m_hPlayerInGroupMenu );
  233.     DestroyMenu( m_hShortcutMenu );
  234.     DestroyMenu( m_hPlayerMenu );
  235.     DestroyMenu( m_hGroupMenu );
  236.     DestroyMenu( m_hRootMenu );
  237.     DestroyMenu( m_hMenu );
  238. }
  239.  
  240. ///////////////////////////////////////////////////////////////////////////////////////
  241. BOOL CGroupTree::Init( HWND hWnd, LPDIRECTPLAY3A lpDP3A, DPID dpidPlayer )
  242. {
  243.     if ( (hWnd) && (lpDP3A) && (dpidPlayer) )
  244.     {
  245.         m_hwndTreeView = hWnd;
  246.         m_hwndParent = GetParent( m_hwndTreeView );
  247.         m_lpDP3A = lpDP3A;
  248.         m_dpidPlayer = dpidPlayer;
  249.  
  250.         TreeView_SetImageList(hWnd, m_hImageList, TVSIL_NORMAL);
  251.         return TRUE;
  252.     }
  253.     else
  254.         return FALSE;
  255. }
  256.  
  257. ///////////////////////////////////////////////////////////////////////////////////////
  258. HRESULT CGroupTree::GetPlayerName( DPID dpidPlayer, LPDPNAME * lplpn)
  259. {
  260.     HRESULT    hr        = DPERR_GENERIC;
  261.     LPVOID    lpData    = NULL;
  262.     DWORD    dwSize    = 0;
  263.  
  264.     hr = m_lpDP3A->GetPlayerName( dpidPlayer, NULL, &dwSize );
  265.  
  266.     if (DPERR_BUFFERTOOSMALL == hr )
  267.     {
  268.         lpData = LocalAlloc( LPTR, dwSize );
  269.  
  270.         if ( NULL != lpData )
  271.         {
  272.             hr = m_lpDP3A->GetPlayerName( dpidPlayer, lpData, &dwSize );
  273.  
  274.             if (FAILED(hr))
  275.             {
  276.                 LocalFree( lpData );
  277.                 lpData = NULL;
  278.             }
  279.         }
  280.         else
  281.         {
  282.             hr = DPERR_OUTOFMEMORY;
  283.         }
  284.     }
  285.  
  286.     *lplpn = (LPDPNAME) lpData;
  287.  
  288.     return hr;
  289. }
  290.  
  291. ///////////////////////////////////////////////////////////////////////////////////////
  292. HRESULT CGroupTree::GetGroupName( DPID dpidGroup, LPDPNAME * lplpn)
  293. {
  294.     HRESULT    hr        = DPERR_GENERIC;
  295.     LPVOID            lpData = NULL;
  296.  
  297.     DWORD    dwSize    = 0;
  298.  
  299.     hr = m_lpDP3A->GetGroupName( dpidGroup, lpData, &dwSize );
  300.  
  301.     if (DPERR_BUFFERTOOSMALL == hr )
  302.     {
  303.         lpData = LocalAlloc( LPTR,  dwSize );
  304.  
  305.         if ( NULL != lpData )
  306.         {
  307.             hr = m_lpDP3A->GetGroupName( dpidGroup, lpData, &dwSize );
  308.  
  309.             if (FAILED(hr))
  310.             {
  311.                 LocalFree( lpData );
  312.                 lpData = NULL;
  313.             }
  314.         }
  315.         else
  316.         {
  317.             hr = DPERR_OUTOFMEMORY;
  318.         }
  319.     }
  320.  
  321.  
  322.     *lplpn = (LPDPNAME) lpData;
  323.  
  324.     return hr;
  325. }
  326.  
  327.  
  328. ///////////////////////////////////////////////////////////////////////////////////////
  329. HTREEITEM CGroupTree::FindItem( HTREEITEM htiSearchRoot, 
  330.                                 DPID dpidTarget, 
  331.                                 BRANCH_TYPE bt, 
  332.                                 DWORD dwSearch )
  333. {
  334.     TV_ITEM tvi;
  335.     HTREEITEM    hItem,
  336.                 htiSubSearch;
  337.     LPBRANCHSTRUCT lpbs = NULL;
  338.  
  339.     if(TVI_ROOT == htiSearchRoot)
  340.     {
  341.         hItem = TreeView_GetRoot(m_hwndTreeView);
  342.     }
  343.     else
  344.     {
  345.         hItem = TreeView_GetChild( m_hwndTreeView, htiSearchRoot );
  346.     }
  347.  
  348.     while(hItem)
  349.     {
  350.         ZeroMemory( &tvi, sizeof(TV_ITEM));
  351.         
  352.         tvi.mask            = TVIF_PARAM;
  353.         tvi.hItem           = hItem;
  354.  
  355.         TreeView_GetItem(m_hwndTreeView, &tvi);
  356.         lpbs = (LPBRANCHSTRUCT) tvi.lParam;
  357.  
  358.         if ( (lpbs->dpid == dpidTarget) && ( bt == lpbs->btType))
  359.         {
  360.             return tvi.hItem;
  361.         }
  362.  
  363.         if ( (lpbs->btType == BT_GROUP) && (ST_SEARCH_SUBGROUPS & dwSearch) )
  364.         {
  365.             htiSubSearch = FindItem( hItem, dpidTarget, bt, dwSearch );
  366.             if (htiSubSearch)
  367.                 return (htiSubSearch);
  368.         }
  369.  
  370.         hItem = TreeView_GetNextSibling(m_hwndTreeView, hItem);
  371.     }
  372.  
  373.     return NULL;
  374. }
  375.  
  376. ///////////////////////////////////////////////////////////////////////////////////////
  377. HTREEITEM CGroupTree::Insert( HTREEITEM htiParent, DPID dpID, LPSTR lpszShortNameA, BRANCH_TYPE bt, DWORD dwFlags )
  378. {
  379.     LPBRANCHSTRUCT        lpbs    = NULL;
  380.     HTREEITEM            htrItem    = NULL;
  381.  
  382.     if ( lpbs = (LPBRANCHSTRUCT) LocalAlloc( LPTR,  sizeof(BRANCHSTRUCT) ) )
  383.     {
  384.         TV_INSERTSTRUCT        tvi;
  385.         TV_SORTCB            tvscb; 
  386.  
  387.         ZeroMemory(lpbs, sizeof( BRANCHSTRUCT ) );
  388.         ZeroMemory(&tvscb, sizeof(tvscb));
  389.         ZeroMemory(&tvi, sizeof(tvi));
  390.         tvi.hParent                = htiParent;
  391.         tvi.hInsertAfter        = TVI_LAST;
  392.  
  393.         tvi.item.mask            = TVIF_IMAGE | TVIF_PARAM | TVIF_SELECTEDIMAGE | TVIF_TEXT;
  394.         tvi.item.pszText        = lpszShortNameA;
  395.         tvi.item.cchTextMax        = strlen(lpszShortNameA)+1;
  396.  
  397.         switch( bt)
  398.         {
  399.             case BT_PLAYER:
  400.             case BT_PLAYER_IN_GROUP:
  401.                 tvi.item.iImage = (DPPLAYER_SPECTATOR & dwFlags) ?  m_nSpectatorImg: m_nPlayerImg;
  402.                 tvi.item.iSelectedImage    = tvi.item.iImage;
  403.             break;
  404.  
  405.             case BT_GROUP:
  406.                 if (DPGROUP_STAGINGAREA & dwFlags)
  407.                 {
  408.                     HRESULT hr;
  409.                     LPDPLCONNECTION lp = NULL;
  410.                     DWORD            dwSize = 0;
  411.                     BOOL            bSessionInProgress = FALSE;
  412.  
  413.                     // if it is a staging area, check to see if the session is in progress.
  414.                     hr = IDirectPlay3_GetGroupConnectionSettings( m_lpDP3A, 0, dpID, NULL, &dwSize );
  415.                     if (DPERR_BUFFERTOOSMALL == hr )
  416.                     {
  417.                         lp = (LPDPLCONNECTION) GlobalAllocPtr( GHND, dwSize );
  418.  
  419.                         if (lp)
  420.                         {
  421.                             hr = IDirectPlay3_GetGroupConnectionSettings( m_lpDP3A, 0, dpID, lp, &dwSize );
  422.  
  423.                             if (!IsEqualGUID(lp->lpSessionDesc->guidInstance, GUID_NULL))
  424.                             {
  425.                                 // If the server has assigned an instance guid 
  426.                                 // to our connection structure, the session 
  427.                                 // has already started.
  428.  
  429.                                 bSessionInProgress = TRUE;
  430.                             }
  431.                             GlobalFreePtr(lp);
  432.                         }
  433.                     }
  434.  
  435.  
  436.                     tvi.item.iImage = (bSessionInProgress)?m_nSessionInProgressImg:m_nStagingAreaImg;
  437.                     tvi.item.iSelectedImage = tvi.item.iImage;
  438.                 }
  439.                 else
  440.                 {
  441.                     tvi.item.iImage = m_nGroupImg;
  442.                     tvi.item.iSelectedImage = m_nInGroupImg;
  443.                 }
  444.                 break;
  445.  
  446.             case BT_SHORTCUT_IN_GROUP:
  447.                 tvi.item.iImage = m_nShortcutInGroupImg;
  448.                 tvi.item.iSelectedImage    = tvi.item.iImage;
  449.             break;
  450.  
  451.             default:
  452.                 //Invalid BranchType
  453.             break;
  454.         }
  455.         tvi.item.lParam            = (LPARAM) lpbs;
  456.  
  457.         lpbs->dpid        = dpID;
  458.         lpbs->btType    = bt;
  459.         lpbs->dwFlags    = dwFlags;
  460.  
  461.         htrItem = TreeView_InsertItem( m_hwndTreeView, &tvi );
  462.  
  463.         tvscb.hParent = htiParent; 
  464.         tvscb.lpfnCompare = CompareFunc; 
  465.         tvscb.lParam = (LPARAM) this; 
  466.  
  467.         TreeView_SortChildrenCB( m_hwndTreeView, &tvscb, 0 );
  468.  
  469.         if(TVI_ROOT != htiParent)
  470.         {
  471.             TreeView_Expand(m_hwndTreeView, htiParent, TVE_EXPAND);
  472.         }
  473.  
  474.         Redraw();
  475.     }
  476.  
  477.     return htrItem;
  478. }
  479.  
  480.  
  481. ///////////////////////////////////////////////////////////////////////////////////////
  482. HRESULT CGroupTree::CreatePlayer( DPID dpidPlayer, LPSTR lpszShortNameA, DWORD dwFlags )
  483. {
  484.     /*
  485.     // We currently support only one local player. This section of code would create a
  486.     // new player at the root for each create player message received.
  487.  
  488.     LPDPNAME lpn = NULL;
  489.  
  490.     if (NULL == lpszShortNameA)
  491.     {
  492.         GetPlayerName(dpidPlayer, &lpn );
  493.         lpszShortNameA = lpn->lpszShortNameA;
  494.     }
  495.  
  496.     if (lpszShortNameA)
  497.     {
  498.         Insert( TVI_ROOT, dpidPlayer, lpszShortNameA, BT_PLAYER, dwFlags );
  499.     }
  500.  
  501.     if (lpn)
  502.         LocalFree(lpn);
  503.     */
  504.  
  505.     return DP_OK;
  506. }
  507.  
  508. ///////////////////////////////////////////////////////////////////////////////////////
  509. HRESULT CGroupTree::CreateGroup( DPID dpidGroup, LPSTR lpszShortNameA, DWORD dwFlags  )
  510. {
  511.     LPDPNAME lpn = NULL;
  512.  
  513.     if (NULL == lpszShortNameA)
  514.     {
  515.         GetGroupName(dpidGroup, &lpn );
  516.         lpszShortNameA = lpn->lpszShortNameA;
  517.     }
  518.  
  519.     if (lpszShortNameA)
  520.     {
  521.         Insert( TVI_ROOT, dpidGroup, lpszShortNameA, BT_GROUP, dwFlags );
  522.     }
  523.  
  524.     if (lpn)
  525.         LocalFree(lpn);
  526.  
  527.  
  528.     return DP_OK;
  529. }
  530.  
  531. ///////////////////////////////////////////////////////////////////////////////////////
  532. HRESULT CGroupTree::CreateGroupInGroup( DPID dpidParentGroup, DPID dpidChildGroup, LPSTR lpszShortNameA, DWORD dwFlags   )
  533. {
  534.     HTREEITEM hParentItem = NULL;
  535.  
  536.     if ( hParentItem = FindItem( TVI_ROOT, dpidParentGroup, BT_GROUP, ST_SEARCH_SUBGROUPS ) )
  537.     {
  538.         LPDPNAME lpn = NULL;
  539.  
  540.         if (NULL == lpszShortNameA)
  541.         {
  542.             GetGroupName(dpidChildGroup, &lpn );
  543.             lpszShortNameA = lpn->lpszShortNameA;
  544.         }
  545.  
  546.         if (lpszShortNameA)
  547.         {
  548.             Insert( hParentItem, dpidChildGroup, lpszShortNameA, BT_GROUP, dwFlags );
  549.         }
  550.  
  551.         if (lpn)
  552.             LocalFree(lpn);
  553.  
  554.  
  555.     }
  556.  
  557.     return DP_OK;
  558. }
  559.  
  560. ///////////////////////////////////////////////////////////////////////////////////////
  561. HRESULT CGroupTree::AddPlayerToGroup( DPID dpidGroup, DPID dpidPlayer, DWORD dwFlags )
  562. {
  563.     HRESULT    hr = DPERR_GENERIC;
  564.     LPDPNAME lpPlayerName = NULL;
  565.  
  566.     hr = GetPlayerName( dpidPlayer, &lpPlayerName );
  567.  
  568.     if (SUCCEEDED(hr))
  569.     {
  570.         HTREEITEM hParentItem = NULL;
  571.  
  572.         if ( hParentItem = FindItem( TVI_ROOT, dpidGroup, BT_GROUP, ST_SEARCH_SUBGROUPS ) )
  573.         {
  574.             Insert( hParentItem, dpidPlayer, lpPlayerName->lpszShortNameA, BT_PLAYER_IN_GROUP, dwFlags );
  575.         }
  576.     }
  577.  
  578.     if (lpPlayerName)
  579.         LocalFree( lpPlayerName);
  580.  
  581.     return hr;
  582. }
  583.  
  584. ///////////////////////////////////////////////////////////////////////////////////////
  585. HRESULT CGroupTree::AddGroupToGroup( DPID dpidParentGroup, DPID dpidShortcut, DWORD dwFlags )
  586. {
  587.     HRESULT    hr = DPERR_GENERIC;
  588.     LPDPNAME lpGroupName = NULL;
  589.  
  590.     hr = GetGroupName( dpidShortcut, &lpGroupName );
  591.  
  592.     if (SUCCEEDED(hr))
  593.     {
  594.         HTREEITEM hParentItem = NULL;
  595.  
  596.         if ( hParentItem = FindItem( TVI_ROOT, dpidParentGroup, BT_GROUP, ST_SEARCH_SUBGROUPS ) )
  597.         {
  598.             Insert( hParentItem, dpidShortcut, lpGroupName->lpszShortNameA, BT_SHORTCUT_IN_GROUP, dwFlags );
  599.         }
  600.     }
  601.  
  602.     if (lpGroupName)
  603.         LocalFree( lpGroupName);
  604.  
  605.     return hr;
  606. }
  607.  
  608. ///////////////////////////////////////////////////////////////////////////////////////
  609. HRESULT CGroupTree::DestroyPlayer(DPID dpidPlayer)
  610. {
  611.     /*
  612.  
  613.     // We are not currently adding additional players to the tree view. The 
  614.     // Code below would add a player to the root of the tree control. If you
  615.     // want that functionality.
  616.  
  617.     HTREEITEM    htiPlayer = FindItem( TVI_ROOT, dpidPlayer, BT_PLAYER, ST_NO_SUBGROUPS );
  618.  
  619.     if ( htiPlayer )
  620.     {
  621.         TreeView_DeleteItem(m_hwndTreeView, htiPlayer);
  622.         Redraw();
  623.     }
  624.     */
  625.  
  626.     return DP_OK;
  627. }
  628.  
  629. ///////////////////////////////////////////////////////////////////////////////////////
  630. HRESULT CGroupTree::DestroyGroup(DPID dpidGroup)
  631. {
  632.     HTREEITEM    htiGroup = FindItem( TVI_ROOT, dpidGroup, BT_GROUP, ST_SEARCH_SUBGROUPS );
  633.  
  634.     if ( htiGroup )
  635.     {
  636.         TreeView_DeleteItem(m_hwndTreeView, htiGroup);
  637.         Redraw();
  638.     }
  639.  
  640.     return DP_OK;
  641. }
  642.  
  643. ///////////////////////////////////////////////////////////////////////////////////////
  644. HRESULT CGroupTree::DeletePlayerFromGroup( DPID dpidGroup, DPID dpidPlayer )
  645. {
  646.     HRESULT    hr = DPERR_GENERIC;
  647.     HTREEITEM    htiParent = NULL,
  648.                 htiPlayer = NULL;
  649.  
  650.     if ( htiParent = FindItem( TVI_ROOT, dpidGroup, BT_GROUP, ST_SEARCH_SUBGROUPS ) )
  651.     {
  652.         if ( htiPlayer = FindItem( htiParent, dpidPlayer, BT_PLAYER_IN_GROUP, ST_NO_SUBGROUPS ) )
  653.         {
  654.             TreeView_DeleteItem(m_hwndTreeView, htiPlayer);
  655.             hr = DP_OK;
  656.  
  657.             Redraw();
  658.         }
  659.     }
  660.  
  661.     return hr;
  662. }
  663.  
  664. ///////////////////////////////////////////////////////////////////////////////////////
  665. HRESULT CGroupTree::DeleteGroupFromGroup( DPID dpidParentGroup, DPID dpidShortcut )
  666. {
  667.     HRESULT    hr = DPERR_GENERIC;
  668.     HTREEITEM    htiParent = NULL,
  669.                 htiShortcut = NULL;
  670.  
  671.     if ( htiParent = FindItem( TVI_ROOT, dpidParentGroup, BT_GROUP, ST_SEARCH_SUBGROUPS ) )
  672.     {
  673.         if ( htiShortcut = FindItem( htiParent, dpidShortcut, BT_SHORTCUT_IN_GROUP, ST_NO_SUBGROUPS ) )
  674.         {
  675.             TreeView_DeleteItem(m_hwndTreeView, htiShortcut );
  676.             hr = DP_OK;
  677.  
  678.             Redraw();
  679.         }
  680.     }
  681.     return hr;
  682. }
  683.  
  684. ///////////////////////////////////////////////////////////////////////////////////////
  685. HRESULT CGroupTree::SetPlayerName( DPID dpidPlayer, LPSTR lpszShortName )
  686. {
  687.     HRESULT        hr        = DPERR_GENERIC;
  688.  
  689.     hr = RecursiveRename( TVI_ROOT, dpidPlayer, lpszShortName );
  690.  
  691.     return hr; 
  692. }
  693.  
  694. ///////////////////////////////////////////////////////////////////////////////////////
  695. HRESULT CGroupTree::SetGroupName( DPID dpidPlayer, LPSTR lpszShortName )
  696. {
  697.     HRESULT        hr        = DPERR_GENERIC;
  698.  
  699.     hr = RecursiveRename( TVI_ROOT, dpidPlayer, lpszShortName );
  700.  
  701.     return hr; 
  702.  
  703. }
  704.  
  705. ///////////////////////////////////////////////////////////////////////////////////////
  706. HRESULT CGroupTree::RecursiveRename(    HTREEITEM htiSearchRoot, 
  707.                                         DPID dpidTarget, 
  708.                                         LPSTR lpszName )
  709. {
  710.     TV_ITEM tvi;
  711.     HTREEITEM    hItem;
  712.     LPBRANCHSTRUCT lpbs = NULL;
  713.  
  714.     if(TVI_ROOT == htiSearchRoot)
  715.     {
  716.         hItem = TreeView_GetRoot(m_hwndTreeView);
  717.     }
  718.     else
  719.     {
  720.         hItem = TreeView_GetChild( m_hwndTreeView, htiSearchRoot );
  721.     }
  722.  
  723.     while(hItem)
  724.     {
  725.         ZeroMemory( &tvi, sizeof(TV_ITEM));
  726.         
  727.         tvi.mask            = TVIF_PARAM;
  728.         tvi.hItem           = hItem;
  729.  
  730.         TreeView_GetItem(m_hwndTreeView, &tvi);
  731.         lpbs = (LPBRANCHSTRUCT) tvi.lParam;
  732.  
  733.         if (lpbs->dpid == dpidTarget)
  734.         {
  735.             ZeroMemory( &tvi, sizeof(TV_ITEM));
  736.  
  737.             tvi.hItem = hItem;
  738.             tvi.mask = TVIF_TEXT;
  739.             tvi.pszText = lpszName;
  740.             tvi.cchTextMax = strlen(lpszName)+1;
  741.  
  742.             TreeView_SetItem( m_hwndTreeView, &tvi );
  743.         }
  744.  
  745.         if (lpbs->btType == BT_GROUP)
  746.         {
  747.             RecursiveRename( hItem, dpidTarget, lpszName );
  748.         }
  749.  
  750.         hItem = TreeView_GetNextSibling(m_hwndTreeView, hItem);
  751.     }
  752.  
  753.     return DP_OK;
  754.  
  755. }
  756.  
  757.  
  758. ///////////////////////////////////////////////////////////////////////////////////////
  759. HRESULT CGroupTree::Refresh( BOOL bRecursive )
  760. {
  761.     HRESULT            hr = DPERR_GENERIC;
  762.     ENUMTREESTRUCT    ets;
  763.  
  764.     ets.dpidParent = NULL;
  765.     ets.lpTree       = this;
  766.     ets.bRecursive = bRecursive;
  767.  
  768.     TreeView_DeleteAllItems( m_hwndTreeView );
  769.  
  770.     if (m_lpDP3A)
  771.     {
  772.  
  773.         //We don't see other root level players in the lobby world.
  774.  
  775.         //hr = m_lpDP3A->EnumPlayers( NULL, TV_EnumPlayersCallback, &ets, DPENUMPLAYERS_ALL );
  776.  
  777.         //if (SUCCEEDED( hr ))
  778.         //{
  779.             hr = m_lpDP3A->EnumGroups( NULL, TV_EnumPlayersCallback, &ets, DPENUMPLAYERS_ALL );
  780.         //}
  781.     }
  782.  
  783.     return hr;
  784. }
  785.  
  786.  
  787. ///////////////////////////////////////////////////////////////////////////////////////
  788. BOOL CGroupTree::Update(LPVOID lpvMsg)
  789. {
  790.  
  791.     DWORD    dwMsgType        = ((LPDPMSG_GENERIC)lpvMsg)->dwType;
  792.     LPSTR    lpszShortName    = NULL;
  793.     BOOL    bReturn            = TRUE;
  794.  
  795.     // Draws the tree based strictly on system messages.
  796.     // If you place a call to this method in the area where you process
  797.     // your system messages, it should give you a good representation
  798.     // of the DirectPlay group structure as it is created.
  799.  
  800.     switch(dwMsgType)
  801.     {
  802.     case DPSYS_CREATEPLAYERORGROUP:
  803.         {
  804.             LPDPMSG_CREATEPLAYERORGROUP lp = (LPDPMSG_CREATEPLAYERORGROUP)lpvMsg;
  805.  
  806.             lpszShortName = lp->dpnName.lpszShortNameA;
  807.             if (DPPLAYERTYPE_PLAYER == lp->dwPlayerType)
  808.             {
  809.                 CreatePlayer(lp->dpId, lpszShortName, lp->dwFlags );
  810.             }
  811.             else
  812.             {
  813.                 if (NULL == lp->dpIdParent)
  814.                 {
  815.                     CreateGroup(lp->dpId, lpszShortName, lp->dwFlags );
  816.                 }
  817.                 else
  818.                 {
  819.                     CreateGroupInGroup(lp->dpIdParent, lp->dpId, lpszShortName, lp->dwFlags );
  820.                 }
  821.  
  822.             }
  823.         }
  824.         break;
  825.  
  826.         case DPSYS_ADDPLAYERTOGROUP:
  827.         {
  828.             LPDPMSG_ADDPLAYERTOGROUP lp = (LPDPMSG_ADDPLAYERTOGROUP)lpvMsg;
  829.             DWORD    dwFlags;
  830.             HRESULT hr = IDirectPlay3_GetPlayerFlags( m_lpDP3A, lp->dpIdPlayer, &dwFlags );
  831.  
  832.             if (SUCCEEDED(hr))
  833.             {
  834.                 // If I can't get his flags, he must have deleted himself
  835.                 // by the time I got this message.
  836.                 AddPlayerToGroup(lp->dpIdGroup, lp->dpIdPlayer,    dwFlags );
  837.             }
  838.  
  839.         }
  840.         break;
  841.  
  842.         case DPSYS_ADDGROUPTOGROUP:
  843.         {
  844.             LPDPMSG_ADDGROUPTOGROUP lp = (LPDPMSG_ADDGROUPTOGROUP)lpvMsg;
  845.             DWORD    dwFlags;
  846.             HRESULT hr = IDirectPlay3_GetGroupFlags( m_lpDP3A, lp->dpIdGroup, &dwFlags );
  847.  
  848.             if (SUCCEEDED(hr))
  849.             {
  850.                 // If I can't get his flags, he must have deleted himself
  851.                 // by the time I got this message.
  852.                 AddGroupToGroup(lp->dpIdParentGroup, lp->dpIdGroup, dwFlags );
  853.             }
  854.         }
  855.         break;
  856.  
  857.         case DPSYS_DESTROYPLAYERORGROUP:
  858.         {
  859.             LPDPMSG_DESTROYPLAYERORGROUP lp = (LPDPMSG_DESTROYPLAYERORGROUP) lpvMsg;
  860.  
  861.             if ( DPPLAYERTYPE_PLAYER == lp->dwPlayerType )
  862.             {
  863.                 DestroyPlayer( lp->dpId );
  864.             }
  865.             else
  866.             {
  867.                 DestroyGroup( lp->dpId );
  868.             }
  869.    
  870.         }
  871.         break;
  872.  
  873.         case DPSYS_DELETEGROUPFROMGROUP:
  874.         {
  875.             LPDPMSG_DELETEGROUPFROMGROUP lp =(LPDPMSG_DELETEGROUPFROMGROUP)lpvMsg;
  876.  
  877.             DeleteGroupFromGroup( lp->dpIdParentGroup, lp->dpIdGroup );
  878.         }
  879.         break;
  880.  
  881.         case DPSYS_DELETEPLAYERFROMGROUP:
  882.         {
  883.             LPDPMSG_DELETEPLAYERFROMGROUP lp =(LPDPMSG_DELETEPLAYERFROMGROUP)lpvMsg;
  884.  
  885.             DeletePlayerFromGroup( lp->dpIdGroup, lp->dpIdPlayer );
  886.         }
  887.         break;
  888.  
  889.         case DPSYS_SETPLAYERORGROUPDATA:
  890.         //Nothing for right now.
  891.         break;
  892.  
  893.         case DPSYS_SETPLAYERORGROUPNAME:
  894.         {
  895.             LPDPMSG_SETPLAYERORGROUPNAME lp = (LPDPMSG_SETPLAYERORGROUPNAME)lpvMsg;
  896.  
  897.             lpszShortName = lp->dpnName.lpszShortNameA;
  898.             
  899.             if ( DPPLAYERTYPE_PLAYER == lp->dwPlayerType )
  900.             {
  901.                 SetPlayerName(lp->dpId, lpszShortName );
  902.             }
  903.             else
  904.             {
  905.                 SetGroupName(lp->dpId, lpszShortName );
  906.             }
  907.  
  908.         }
  909.         break;
  910.  
  911.         default:
  912.             //Code a new message...
  913.             bReturn = FALSE;
  914.             break;
  915.     }
  916.  
  917.     return bReturn;
  918. }
  919.  
  920. ///////////////////////////////////////////////////////////////////////////////////////
  921. DPID CGroupTree::GetDPIDOfCurrentSelection( LPBRANCHSTRUCT lpbt)
  922. {
  923.  
  924.     HTREEITEM    htItem;
  925.     TV_ITEM    tvi;
  926.  
  927.     ZeroMemory( &tvi, sizeof( TV_ITEM ) );
  928.  
  929.     htItem = TreeView_GetSelection(m_hwndTreeView);
  930.  
  931.     if (htItem)
  932.     {
  933.  
  934.         tvi.mask            = TVIF_PARAM;
  935.         tvi.hItem           = htItem;
  936.  
  937.         TreeView_GetItem(m_hwndTreeView, &tvi);
  938.  
  939.         if (lpbt)
  940.         {
  941.             lpbt->dpid = ((LPBRANCHSTRUCT)(tvi.lParam))->dpid;
  942.             lpbt->btType = ((LPBRANCHSTRUCT)(tvi.lParam))->btType;
  943.         }
  944.  
  945.         return ((LPBRANCHSTRUCT) (tvi.lParam))->dpid;
  946.     }
  947.  
  948.     return 0;
  949.  
  950. }
  951.  
  952. ///////////////////////////////////////////////////////////////////////////////////////
  953. DPID CGroupTree::GetDPIDOfCurrentSelectionParent( LPBRANCHSTRUCT lpbt)
  954. {
  955.  
  956.     HTREEITEM    htChildItem, htItem;
  957.     TV_ITEM    tvi;
  958.  
  959.     ZeroMemory( &tvi, sizeof( TV_ITEM ) );
  960.  
  961.     htChildItem = TreeView_GetSelection(m_hwndTreeView);
  962.  
  963.     htItem = TreeView_GetParent( m_hwndTreeView, htChildItem );
  964.  
  965.     if (htItem)
  966.     {
  967.  
  968.         tvi.mask            = TVIF_PARAM;
  969.         tvi.hItem           = htItem;
  970.  
  971.         TreeView_GetItem(m_hwndTreeView, &tvi);
  972.  
  973.         if (lpbt)
  974.         {
  975.             lpbt->dpid = ((LPBRANCHSTRUCT)(tvi.lParam))->dpid;
  976.             lpbt->btType = ((LPBRANCHSTRUCT)(tvi.lParam))->btType;
  977.         }
  978.  
  979.         return ((LPBRANCHSTRUCT) (tvi.lParam))->dpid;
  980.     }
  981.  
  982.     return 0;
  983.  
  984. }
  985.  
  986. ///////////////////////////////////////////////////////////////////////////////////////
  987. void CGroupTree::OnBeginDrag(NM_TREEVIEW *lpnmtv) 
  988. { 
  989.     HIMAGELIST himl;    // handle of image list 
  990.     LPBRANCHSTRUCT    lp = NULL;
  991.     int level = 0;
  992.     UINT    xIndent = 0;
  993.     HTREEITEM htItem = NULL;
  994.  
  995.      lp = (LPBRANCHSTRUCT)lpnmtv->itemNew.lParam;
  996.     m_bsDragging = *((LPBRANCHSTRUCT)(lpnmtv->itemNew.lParam));
  997.     GetBranchStructOfParent( lpnmtv->itemNew.hItem, &m_bsParentOfDragging );
  998.  
  999.    // Tell the tree-view control to create an image to use 
  1000.     // for dragging. 
  1001.     himl = TreeView_CreateDragImage(m_hwndTreeView, lpnmtv->itemNew.hItem); 
  1002.  
  1003.     // Start the drag operation. 
  1004.     RECT rcItem;
  1005.  
  1006.     TreeView_GetItemRect(m_hwndTreeView, lpnmtv->itemNew.hItem, &rcItem, FALSE);
  1007.  
  1008.     htItem = lpnmtv->itemNew.hItem;
  1009.  
  1010.     do
  1011.     {
  1012.         htItem = TreeView_GetParent( m_hwndTreeView, htItem );
  1013.         level++;
  1014.     }
  1015.     while (htItem); 
  1016.  
  1017.     xIndent = TreeView_GetIndent( m_hwndTreeView ) * level;
  1018.  
  1019.     BOOL b = ImageList_BeginDrag(    himl, 0, 
  1020.                                     lpnmtv->ptDrag.x-rcItem.left - xIndent, 
  1021.                                     lpnmtv->ptDrag.y-rcItem.top); 
  1022.   
  1023.     // Hide the mouse cursor, and direct mouse input to the 
  1024.     // parent window. 
  1025.  
  1026.     ShowCursor( FALSE );
  1027.     SetCapture(m_hwndParent); 
  1028.     m_fDragging = TRUE;
  1029.     
  1030.     ImageList_DragEnter( m_hwndTreeView, 
  1031.                         lpnmtv->ptDrag.x-rcItem.left - xIndent, 
  1032.                         lpnmtv->ptDrag.y);
  1033.     return; 
  1034. } 
  1035.  
  1036. ///////////////////////////////////////////////////////////////////////////////////////
  1037. void CGroupTree::OnMouseMove( LONG xCur, LONG yCur) 
  1038. { 
  1039.     HTREEITEM htiTarget;  // handle of target item 
  1040.     TV_HITTESTINFO tvht;  // hit test information 
  1041.  
  1042.     TV_ITEM    tvi;
  1043.  
  1044.     ZeroMemory(&tvi, sizeof(TV_ITEM ) );
  1045.  
  1046.     if (m_fDragging) 
  1047.     { 
  1048.  
  1049.         // Drag the item to the current position of the mouse cursor. 
  1050.         RECT rcTree, rcParent;
  1051.  
  1052.         GetWindowRect( m_hwndParent, &rcParent );
  1053.         GetWindowRect( m_hwndTreeView, &rcTree );
  1054.         ImageList_DragMove(xCur, yCur); 
  1055.  
  1056.         // Find out if the cursor is on the item. If it is, highlight 
  1057.         // the item as a drop target. 
  1058.         tvht.pt.x = xCur; 
  1059.         tvht.pt.y = yCur; 
  1060.         if ((htiTarget = TreeView_HitTest(m_hwndTreeView, &tvht)) != NULL) 
  1061.         { 
  1062.               ImageList_DragLeave( m_hwndTreeView );
  1063.             TreeView_SelectDropTarget(m_hwndTreeView, htiTarget);
  1064.             ImageList_DragEnter( m_hwndTreeView, xCur, yCur);
  1065.  
  1066.             tvi.mask            = TVIF_PARAM;
  1067.             tvi.hItem           = htiTarget;
  1068.  
  1069.             TreeView_GetItem(m_hwndTreeView, &tvi);
  1070.  
  1071.               memcpy( &m_bsDropTarget, (LPBRANCHSTRUCT)(tvi.lParam), sizeof(BRANCHSTRUCT) );
  1072.  
  1073.         }
  1074.         else
  1075.         {
  1076.             ZeroMemory( &m_bsDropTarget, sizeof(BRANCHSTRUCT) );
  1077.         }
  1078.     } 
  1079.     return; 
  1080. } 
  1081.  
  1082. ///////////////////////////////////////////////////////////////////////////////////////
  1083. void CGroupTree::OnLButtonUp(void) 
  1084. { 
  1085.     if (m_fDragging) 
  1086.     { 
  1087.         ImageList_EndDrag(); 
  1088.         ReleaseCapture(); 
  1089.         ShowCursor( TRUE );
  1090.         m_fDragging = FALSE;
  1091.           ImageList_DragLeave( m_hwndTreeView );
  1092.     
  1093.         if (m_bsDropTarget.dpid)
  1094.         {
  1095.             switch (m_bsDragging.btType )
  1096.             {
  1097.                 case BT_PLAYER:
  1098.                     m_lpDP3A->AddPlayerToGroup(m_bsDropTarget.dpid, m_bsDragging.dpid ); 
  1099.                     break;
  1100.  
  1101.                 case BT_GROUP:
  1102.                     m_lpDP3A->AddGroupToGroup(m_bsDropTarget.dpid, m_bsDragging.dpid );
  1103.                     break;
  1104.  
  1105.                 case BT_PLAYER_IN_GROUP:
  1106.                     if (m_bsDropTarget.dpid != m_bsParentOfDragging.dpid)
  1107.                     {
  1108.                         m_lpDP3A->AddPlayerToGroup(m_bsDropTarget.dpid, m_bsDragging.dpid );
  1109.                         m_lpDP3A->DeletePlayerFromGroup(m_bsParentOfDragging.dpid, m_bsDragging.dpid ); 
  1110.                     }
  1111.                     break;
  1112.  
  1113.                 case BT_SHORTCUT_IN_GROUP:
  1114.                     if (m_bsDropTarget.dpid != m_bsParentOfDragging.dpid)
  1115.                     {
  1116.                         m_lpDP3A->AddGroupToGroup(m_bsDropTarget.dpid, m_bsDragging.dpid ); 
  1117.                         m_lpDP3A->DeleteGroupFromGroup(m_bsParentOfDragging.dpid, m_bsDragging.dpid ); 
  1118.                     }
  1119.                     break;
  1120.             }
  1121.         }
  1122.  
  1123.         TreeView_SelectDropTarget( m_hwndTreeView, (HTREEITEM) NULL );
  1124.     } 
  1125.     return; 
  1126. } 
  1127.  
  1128.  
  1129. ///////////////////////////////////////////////////////////////////////////////////////
  1130. void CGroupTree::Redraw(void) 
  1131. {
  1132.     RECT r;
  1133.     
  1134.     GetWindowRect(m_hwndTreeView, &r );
  1135.     InvalidateRect(m_hwndTreeView, &r, TRUE);
  1136.     UpdateWindow(m_hwndParent);
  1137.  
  1138. }
  1139.  
  1140. ///////////////////////////////////////////////////////////////////////////////////////
  1141. void CGroupTree::OnRButtonDown( LONG xCur, LONG yCur) 
  1142. { 
  1143.     HTREEITEM htiTarget;  // handle of target item 
  1144.     TV_HITTESTINFO tvht;  // hit test information 
  1145.     LPBRANCHSTRUCT lpbs = NULL;
  1146.     HMENU hMenu = NULL;
  1147.  
  1148.     TV_ITEM    tvi;
  1149.  
  1150.     ZeroMemory(&tvi, sizeof(TV_ITEM ) );
  1151.     RECT rc;
  1152.  
  1153.     GetWindowRect( m_hwndTreeView, &rc );
  1154.  
  1155.     // Find out if the cursor is on the item. If it is, highlight 
  1156.     // the item as a drop target. 
  1157.     tvht.pt.x = xCur - rc.left; 
  1158.     tvht.pt.y = yCur - rc.top; 
  1159.     if ((htiTarget = TreeView_HitTest(m_hwndTreeView, &tvht)) != NULL) 
  1160.     { 
  1161.         TreeView_SelectItem(m_hwndTreeView, htiTarget);
  1162.  
  1163.         tvi.mask            = TVIF_PARAM;
  1164.         tvi.hItem           = htiTarget;
  1165.  
  1166.         TreeView_GetItem(m_hwndTreeView, &tvi);
  1167.  
  1168.         if (lpbs = (LPBRANCHSTRUCT)tvi.lParam)
  1169.         {
  1170.             m_dpidMenuTarget = lpbs->dpid;
  1171.  
  1172.             switch (lpbs->btType)
  1173.             {
  1174.             case BT_GROUP:
  1175.                 hMenu = m_hGroupMenu;
  1176.                 EnableMenuItem(    hMenu,    ID_GROUP_STARTSESSION,    
  1177.                     (DPGROUP_STAGINGAREA & lpbs->dwFlags)?MF_ENABLED:MF_GRAYED ); 
  1178.                 EnableMenuItem(    hMenu,    ID_GROUP_CONNECTIONSETTINGS,    
  1179.                     (DPGROUP_STAGINGAREA & lpbs->dwFlags)?MF_ENABLED:MF_GRAYED ); 
  1180.                 break;
  1181.  
  1182.             case BT_PLAYER:
  1183.                 hMenu = m_hPlayerMenu;
  1184.                 break;
  1185.  
  1186.             case BT_SHORTCUT_IN_GROUP:
  1187.                 hMenu = m_hShortcutMenu;
  1188.                 break;
  1189.  
  1190.             case BT_PLAYER_IN_GROUP:
  1191.                 hMenu = m_hPlayerInGroupMenu;
  1192.                 break;
  1193.  
  1194.             default:
  1195.                 hMenu = m_hRootMenu;
  1196.                 break;
  1197.             }
  1198.         }
  1199.     }
  1200.     else
  1201.     {
  1202.             hMenu = m_hRootMenu;
  1203.     }
  1204.  
  1205.     TrackPopupMenuEx(    hMenu,    
  1206.                         TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RIGHTBUTTON, 
  1207.                         xCur, yCur, m_hwndParent, NULL );    
  1208. } 
  1209.  
  1210. ///////////////////////////////////////////////////////////////////////////////////////
  1211. void CGroupTree::OnDblClk( LONG xCur, LONG yCur) 
  1212. { 
  1213.     HTREEITEM htiTarget;  // handle of target item 
  1214.     TV_HITTESTINFO tvht;  // hit test information 
  1215.     LPBRANCHSTRUCT lpbs = NULL;
  1216.     HMENU hMenu = NULL;
  1217.  
  1218.     TV_ITEM    tvi;
  1219.  
  1220.     ZeroMemory(&tvi, sizeof(TV_ITEM ) );
  1221.     RECT rc;
  1222.  
  1223.     GetWindowRect( m_hwndTreeView, &rc );
  1224.  
  1225.     // Find out if the cursor is on the item. If it is, highlight 
  1226.     // the item as a drop target. 
  1227.     tvht.pt.x = xCur - rc.left; 
  1228.     tvht.pt.y = yCur - rc.top; 
  1229.     if ((htiTarget = TreeView_HitTest(m_hwndTreeView, &tvht)) != NULL) 
  1230.     { 
  1231.         TreeView_SelectItem(m_hwndTreeView, htiTarget);
  1232.  
  1233.         tvi.mask            = TVIF_PARAM;
  1234.         tvi.hItem           = htiTarget;
  1235.  
  1236.         TreeView_GetItem(m_hwndTreeView, &tvi);
  1237.  
  1238.         if (lpbs = (LPBRANCHSTRUCT)tvi.lParam)
  1239.         {
  1240.             m_dpidMenuTarget = lpbs->dpid;
  1241.  
  1242.             switch (lpbs->btType)
  1243.             {
  1244.             case BT_SHORTCUT_IN_GROUP:
  1245.             case BT_GROUP:
  1246.                 if (m_dpidLastGroup != lpbs->dpid)
  1247.                 {
  1248.                     m_lpDP3A->AddPlayerToGroup(lpbs->dpid, m_dpidPlayer );
  1249.  
  1250.                     m_lpDP3A->DeletePlayerFromGroup(m_dpidLastGroup, m_dpidPlayer ); 
  1251.                     m_dpidLastGroup = lpbs->dpid;
  1252.                 }
  1253.                 break;
  1254.  
  1255.             default:
  1256.                 break;
  1257.             }
  1258.         }
  1259.     }
  1260. } 
  1261.  
  1262. ///////////////////////////////////////////////////////////////////////////////////////
  1263. HRESULT CGroupTree::BeginLabelEdit() 
  1264. {
  1265.     // Workaround for Windows tree control/dialog odd behavior
  1266.     // Retrieve the handle of the edit control. 
  1267.     m_hwndEditCtrl = TreeView_GetEditControl( m_hwndTreeView ); 
  1268.  
  1269.     // Subclass the edit control. 
  1270.     gwpOrigEditProc = (WNDPROC) SetWindowLong(m_hwndEditCtrl, GWL_WNDPROC, (LONG) EditCtrlSubProc );
  1271.  
  1272.     return DP_OK;
  1273. }
  1274.  
  1275. ///////////////////////////////////////////////////////////////////////////////////////
  1276. void CGroupTree::EndLabelEdit( TV_DISPINFO FAR * lpTVDisp ) 
  1277. {
  1278.     HRESULT hr;
  1279.  
  1280.     // Subclass the edit control. 
  1281.     SetWindowLong(m_hwndEditCtrl, GWL_WNDPROC, (LONG) gwpOrigEditProc);
  1282.  
  1283.     if (lpTVDisp->item.pszText)
  1284.     {
  1285.         LPBRANCHSTRUCT lpbs = (LPBRANCHSTRUCT) lpTVDisp->item.lParam;
  1286.  
  1287.         hr = CheckAccessRights(lpTVDisp);
  1288.  
  1289.         if (SUCCEEDED(hr))
  1290.         {    
  1291.             DPNAME dpn;
  1292.             dpn.dwSize = sizeof(DPNAME);
  1293.             dpn.lpszShortNameA = lpTVDisp->item.pszText;
  1294.             dpn.lpszLongNameA = lpTVDisp->item.pszText;
  1295.  
  1296.             switch (lpbs->btType)
  1297.             {
  1298.             case  BT_GROUP:
  1299.                 m_lpDP3A->SetGroupName(lpbs->dpid, &dpn, DPSET_REMOTE );
  1300.                 break;
  1301.  
  1302.             case BT_PLAYER_IN_GROUP:
  1303.             case BT_PLAYER:
  1304.                 m_lpDP3A->SetPlayerName(lpbs->dpid, &dpn,  DPSET_REMOTE );
  1305.                 break;
  1306.             }
  1307.         }
  1308.         else
  1309.         {
  1310.             MessageBox( m_hwndParent, "Cannot change the name of remote players or groups", "Error", MB_OK);
  1311.             return;
  1312.         }
  1313.     }
  1314. }
  1315.  
  1316. ///////////////////////////////////////////////////////////////////////////////////////
  1317. DPID CGroupTree::GetBranchStructOfParent( HTREEITEM htChildItem, LPBRANCHSTRUCT lpbt)
  1318. {
  1319.  
  1320.     HTREEITEM    htItem;
  1321.     TV_ITEM    tvi;
  1322.  
  1323.     ZeroMemory( &tvi, sizeof( TV_ITEM ) );
  1324.     ZeroMemory( lpbt, sizeof( BRANCHSTRUCT ) );
  1325.  
  1326.     htItem = TreeView_GetParent( m_hwndTreeView, htChildItem );
  1327.  
  1328.     if (htItem)
  1329.     {
  1330.  
  1331.         tvi.mask            = TVIF_PARAM;
  1332.         tvi.hItem           = htItem;
  1333.  
  1334.         TreeView_GetItem(m_hwndTreeView, &tvi);
  1335.  
  1336.         if (lpbt)
  1337.         {
  1338.             *lpbt = *((LPBRANCHSTRUCT)(tvi.lParam));
  1339.         }
  1340.  
  1341.         return ((LPBRANCHSTRUCT) (tvi.lParam))->dpid;
  1342.     }
  1343.  
  1344.     return 0;
  1345.  
  1346. }
  1347.  
  1348. ///////////////////////////////////////////////////////////////////////////////////////
  1349. BOOL CGroupTree::OnWM_NOTIFY( WPARAM wParam, LPARAM lParam )
  1350. {
  1351.     int idCtrl = (int) wParam;
  1352.     LPNMHDR pnmh = (LPNMHDR)lParam;
  1353.     if (NULL == pnmh)
  1354.         return FALSE;
  1355.       NM_TREEVIEW        *nmtv;
  1356.     TV_ITEM            *    pItemNew = NULL;
  1357.     TV_ITEM            *    pItemOld = NULL;
  1358.     LPBRANCHSTRUCT    lpBranch = NULL;
  1359.     HRESULT hr;
  1360.  
  1361.     switch(pnmh->code)
  1362.     {
  1363.         case NM_RCLICK:
  1364.         {
  1365.             POINT p;
  1366.             GetCursorPos(&p);
  1367.             OnRButtonDown(p.x, p.y );
  1368.         }
  1369.         break;
  1370.  
  1371.         case NM_DBLCLK:
  1372.         {
  1373.             POINT p;
  1374.             GetCursorPos(&p);
  1375.             OnDblClk(p.x, p.y );
  1376.         }
  1377.         break;
  1378.  
  1379.         case TVN_BEGINLABELEDIT:
  1380.             hr = BeginLabelEdit();
  1381.  
  1382.             if (FAILED(hr))
  1383.                 return TRUE;
  1384.         break;
  1385.  
  1386.         case TVN_ENDLABELEDIT:
  1387.             EndLabelEdit((TV_DISPINFO FAR *) lParam);
  1388.         break;
  1389.  
  1390.         case TVN_SELCHANGING:
  1391.         break;
  1392.  
  1393.         case TVN_DELETEITEM:
  1394.             nmtv    = (NM_TREEVIEW *)lParam;
  1395.             pItemOld    = &nmtv->itemOld;
  1396.             LocalFree( (LPVOID) pItemOld->lParam );
  1397.         break;
  1398.  
  1399.         case TVN_BEGINDRAG: 
  1400.             OnBeginDrag((NM_TREEVIEW *) lParam); 
  1401.             break; 
  1402.  
  1403.     }
  1404.  
  1405.     return 0;
  1406. }
  1407.  
  1408. HRESULT    CGroupTree::EditLabel()
  1409. {
  1410.     HRESULT hr; // Initialized by call to CheckAccessRights()
  1411.     HTREEITEM    htItem;
  1412.     TV_ITEM    tvi;
  1413.  
  1414.     ZeroMemory( &tvi, sizeof( TV_ITEM ) );
  1415.  
  1416.     htItem = TreeView_GetSelection(m_hwndTreeView);
  1417.  
  1418.     if (htItem)
  1419.     {
  1420.         HWND hwnd = NULL;
  1421.  
  1422.         hwnd = TreeView_EditLabel( m_hwndTreeView, htItem );
  1423.         hr = (hwnd ? DP_OK : DPERR_ACCESSDENIED); 
  1424.     }
  1425.     else
  1426.     {
  1427.         hr = DPERR_ACCESSDENIED;
  1428.     }
  1429.  
  1430.     return hr;
  1431. }
  1432.  
  1433.  
  1434. HRESULT CGroupTree::CheckAccessRights(TV_DISPINFO FAR * lpTVDisp)
  1435. {
  1436.     HRESULT hr = DPERR_GENERIC;
  1437.     DWORD    dwFlags = 0;
  1438.     BRANCHSTRUCT bsCurSel;
  1439.  
  1440.     if (NULL == lpTVDisp)
  1441.     {
  1442.         GetDPIDOfCurrentSelection( &bsCurSel );
  1443.     }
  1444.     else
  1445.     {    
  1446.         bsCurSel = *((LPBRANCHSTRUCT) lpTVDisp->item.lParam);
  1447.     }
  1448.  
  1449.     switch ( bsCurSel.btType )
  1450.     {
  1451.         case BT_PLAYER:
  1452.         case BT_PLAYER_IN_GROUP:
  1453.             hr = m_lpDP3A->GetPlayerFlags( bsCurSel.dpid, &dwFlags );
  1454.             break;
  1455.  
  1456.         case BT_GROUP:
  1457.             hr = m_lpDP3A->GetGroupFlags( bsCurSel.dpid, &dwFlags );
  1458.             break;
  1459.  
  1460.         default:
  1461.             break;
  1462.     }
  1463.  
  1464.     if (FAILED(hr))
  1465.         return hr;
  1466.  
  1467.     if (dwFlags & DPPLAYER_LOCAL )
  1468.     {
  1469.         hr = DP_OK;
  1470.     }
  1471.     else
  1472.     {
  1473.         hr = DPERR_ACCESSDENIED;
  1474.     }
  1475.  
  1476.     return hr;
  1477. }
  1478.  
  1479.