home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / ADDON.PAK / PRJWIN.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  21.9 KB  |  787 lines
  1. /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  2.  
  3.   prjwin.cpp
  4.   Created: 11/28/95
  5.   Copyright (c) 1995, Borland International
  6.   $Revision:   1.16  $
  7.  
  8. :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
  9. #ifndef __AOEXPCH_H
  10.   #include "aoexpch.h"
  11. #endif
  12. #pragma hdrstop
  13.  
  14. #include <ideaddon\iproj.h>
  15. #include <ideaddon\iide.h>
  16. #include "tests.hrc"
  17. #include "prjview.h"
  18. #include "prjwin.h"
  19.  
  20. #define NUM_BITMAPS 3
  21. #define ID_TREEVIEW 1
  22. #define BITMAP_WIDTH   18
  23. #define BITMAP_HEIGHT 16
  24.  
  25. #define USE_QI 1
  26.  
  27. extern void CreateDetailView(ProjectNode* nodes, int nNodes);
  28.  
  29. /******************************************************************************
  30. * This file implements the addon project window. It has the following features:
  31. *
  32. *  Edit           Open the selected node into the text editor. It does not check
  33. *                  for file type.
  34. *
  35. *  New View       Create a new project window that has the same top node.
  36. *
  37. *  View from here Make the current selected node the top node in the addon
  38. *                  project view.
  39. *
  40. *  Refresh         Refresh the addon project view content. The addon project view
  41. *                  can not detect node change beside delete and add in the project.
  42. *
  43. *  Delete Node     Delete the selected node from the project
  44. *
  45. *  Add Node...     Add a node to the project.
  46. *
  47. *  Make           Make the selected node.
  48. *
  49. *  Build           Build the selected node.
  50. *
  51. *  Translate       Translate the selected node.
  52. *
  53. ******************************************************************************/
  54. class DependentCollector : public IProjectClient {
  55. public:
  56.   DependentCollector();
  57.   ~DependentCollector();
  58.  
  59.   //IUnknown members
  60.   STDMETHODIMP QueryInterface (THIS_ REFIID, LPVOID FAR *);
  61.   STDMETHODIMP_(ULONG) AddRef (THIS) { return m_RefCount++; }
  62.   STDMETHODIMP_(ULONG) Release (THIS)
  63.       {return --m_RefCount == 0 ? (delete this, 0) : m_RefCount; }
  64.  
  65.   //.... IProjectClient methods ....
  66.    virtual void OpenNotify( IPolyString * projectName );
  67.    virtual void CloseNotify();
  68.    virtual void NodeDeleteNotify( ProjectNode node );
  69.    virtual void NodeAddNotify( ProjectNode node );
  70.    virtual void NodeCopyNotify( ProjectNode, ProjectNode, BOOL ) {}
  71.    virtual void NodeMoveNotify( ProjectNode, ProjectNode ) {}
  72.    virtual void NodeChangeNotify( ProjectNode ) {}
  73.    virtual void DependencyQueryResponder( ProjectNode node, 
  74.                                           IPolyString * outputName );
  75.    virtual BOOL HandleAddNodeUI() { return FALSE; }
  76.  
  77.  
  78.    int  GetDependents(ProjectNode node, ProjectNode* nodes, int nNodes);
  79. protected:
  80.   // private variables
  81.   ULONG          m_RefCount;
  82.   IProjectServer* d_projectServer;
  83.  
  84.   ProjectNode*    d_nodes;
  85.   int            d_nNodes;
  86.   int            d_iNext;
  87. };
  88.  
  89. DependentCollector::DependentCollector() {
  90.   m_RefCount = 1;
  91.   d_projectServer = GET_INTERFACE( IProjectServer );
  92. };
  93.  
  94. DependentCollector::~DependentCollector() {
  95.   d_projectServer->Release();
  96. };
  97.  
  98.  
  99. STDMETHODIMP
  100. DependentCollector::QueryInterface (REFIID riid, LPVOID FAR* ppobj)
  101. {
  102.   if ((riid == IID_IUnknown)/* || (riid == IID_PUBLIC_)*/)
  103.   {
  104.     *ppobj = (LPVOID)this;
  105.     AddRef();
  106.    return NOERROR;
  107.   }
  108.  
  109.   *ppobj = NULL;
  110.   return ResultFromScode(E_NOINTERFACE);
  111. }
  112.  
  113. //
  114. // IProjectClient methods
  115. //
  116. void DependentCollector::OpenNotify( IPolyString * projectName ) {
  117.   projectName->Release();
  118. }
  119. //.............................................................................
  120. void DependentCollector::CloseNotify() {
  121. }
  122.  
  123. void DependentCollector::NodeDeleteNotify( ProjectNode ) {
  124. }
  125. //.............................................................................
  126. void DependentCollector::NodeAddNotify( ProjectNode ) {
  127. }
  128. //.............................................................................
  129. void DependentCollector::DependencyQueryResponder( ProjectNode node,
  130.                           IPolyString * outputName) {
  131.   outputName->Release();
  132.   if (d_iNext >= d_nNodes)
  133.    return;
  134.  
  135.   d_nodes[d_iNext] = node;
  136.   ++d_iNext;
  137. }
  138.  
  139. int DependentCollector::GetDependents(ProjectNode node, ProjectNode* nodes, int nNodes) {
  140.   d_nodes = nodes;
  141.   d_nNodes = nNodes;
  142.   d_iNext = 0;
  143.   d_projectServer->QueryDependencies(node, this);
  144.   return d_iNext;
  145. };
  146.  
  147. /******************************************************************************
  148. *
  149. * TreeController
  150. *
  151. ******************************************************************************/
  152.  
  153. TreeController::TreeController() {
  154.   d_projectServer = GET_INTERFACE(IProjectServer);
  155.   d_topNode = 0;
  156.  
  157. }
  158.  
  159. TreeController::~TreeController() {
  160.   d_projectServer->Release();
  161. }
  162.  
  163. HWND TreeController::InitWindow(HWND hwndParent) {
  164.  
  165.  
  166.   // Ensure that the common control DLL is loaded.
  167.   InitCommonControls();
  168.  
  169.   // get the size and position of the parent window
  170.   RECT rcl;          // rectangle for setting the size of the window
  171.   GetClientRect(hwndParent, &rcl);
  172.   HINSTANCE hInst = (HINSTANCE)GetWindowLong(hwndParent, GWL_HINSTANCE);
  173.  
  174.   // create the tree view window
  175.   d_hwnd = CreateWindowEx(  WS_EX_CLIENTEDGE,
  176.                             WC_TREEVIEW,                // tree view class
  177.                             TEXT(""),                  // no default text
  178.                             WS_VISIBLE | WS_CHILD
  179.                             | WS_BORDER | TVS_HASLINES
  180.                             | TVS_HASBUTTONS | TVS_LINESATROOT,
  181.                             0, 0,
  182.                             rcl.right - rcl.left, rcl.bottom - rcl.top - 15,
  183.                             hwndParent,
  184.                             (HMENU) ID_TREEVIEW,
  185.                             hInst,
  186.                             NULL );
  187.  
  188.   if (d_hwnd == NULL ) {
  189.     MessageBox (NULL, TEXT("Tree View not created!"), NULL, MB_OK );
  190.     return NULL;
  191.   }
  192.  
  193.   HIMAGELIST hIml;    // handle to the image list
  194.   // initialize the tree view window
  195.   // First, create the image list we will need
  196.   hIml = ImageList_Create( BITMAP_WIDTH,  // width
  197.                         BITMAP_HEIGHT,                      // height
  198.                         0,                                  // flags
  199.                         NUM_BITMAPS,                        // number of bitmaps
  200.                         0 );                                // amount to grow
  201.  
  202.   HBITMAP hBmp;      // handle to a bitmap
  203.   // load the bitmaps and add them to the image lists
  204.   hBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_CLOSED_FOLDER));
  205.   d_idxCloseFolder = ImageList_Add(hIml,        // handle to the imagelist
  206.                            hBmp,        // handle to the bitmap
  207.                            NULL);      // handle of the bitmap mask
  208.  
  209.   hBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_OPEN_FOLDER));
  210.   d_idxOpenFolder = ImageList_Add(hIml, hBmp, NULL);
  211.  
  212.   hBmp = LoadBitmap(hInst, MAKEINTRESOURCE(IDB_FILE));
  213.   d_idxFile = ImageList_Add(hIml, hBmp, NULL);
  214.  
  215.   // Associate the image list with the tree
  216.   TreeView_SetImageList(d_hwnd, hIml, TVSIL_NORMAL);
  217.  
  218.   return d_hwnd;
  219. }
  220.  
  221. void TreeController::GetItem(HTREEITEM  ti, TV_ITEM& item, unsigned mask) {
  222.   item.hItem = ti;
  223.   item.mask = mask;
  224.  
  225.   TreeView_GetItem(d_hwnd, &item);
  226. }
  227.  
  228. void TreeController::SetImage(HTREEITEM ti, unsigned idxImage) {
  229.   TV_ITEM item;
  230.   GetItem(ti, item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
  231.   item.iImage       = idxImage;
  232.   item.iSelectedImage= idxImage;
  233.   TreeView_SetItem(d_hwnd, &item);
  234. };
  235.  
  236. void TreeController::SetTopNode(ProjectNode topNode) {
  237.   d_topNode = topNode;
  238. };
  239.  
  240. //
  241. // initialize the treeview by adding project nodes
  242. //
  243. BOOL TreeController::AddTreeViewItems() {
  244.  
  245.   //
  246.   // by default, display from project's top node
  247.   //
  248.   if (!d_topNode)
  249.     d_topNode = d_projectServer->QueryTopNode();
  250.  
  251.   ProjectNode topNode = d_topNode;
  252.  
  253.   TreeView_DeleteAllItems(d_hwnd);
  254.  
  255.   IProjectNodeInfo* pni = d_projectServer->QueryNodeInfo( topNode );
  256.  
  257.   IPolyString* name = pni->GetInputLocation();
  258.   if (name) {
  259.     HTREEITEM hTRoot = AddOneItem((HTREEITEM)NULL
  260.                                  , name->GetCstr()
  261.                                  , (HTREEITEM)TVI_ROOT
  262.                                  , d_idxCloseFolder
  263.                                  , (LPARAM)topNode);
  264.     name->Release();
  265.     AddBranch(hTRoot, topNode);
  266.   }
  267.   return TRUE;
  268. }
  269.  
  270. //
  271. // get corresponding ProjectNode of a TREEITEM
  272. //
  273. ProjectNode TreeController::GetNodeFromItem(HTREEITEM ti) {
  274.   TV_ITEM item;
  275.  
  276.   GetItem(ti, item, TVIF_PARAM);
  277.   return (ProjectNode)item.lParam;
  278. }
  279.  
  280. HTREEITEM TreeController::FindItem(HTREEITEM hitem, ProjectNode node) {
  281.  
  282.   ProjectNode iNode = GetNodeFromItem(hitem);
  283.   if (node == iNode)
  284.     return hitem;
  285.  
  286.   hitem = TreeView_GetChild(d_hwnd, hitem);
  287.  
  288.   while (hitem) {
  289.     HTREEITEM itemFound = FindItem(hitem, node);
  290.     if (itemFound)
  291.       return itemFound;
  292.     hitem = TreeView_GetNextSibling(d_hwnd, hitem);
  293.   }
  294.   return 0;
  295. };
  296.  
  297. HTREEITEM TreeController::GetItemFromNode(ProjectNode node) {
  298.  
  299.   HTREEITEM root = TreeView_GetRoot(d_hwnd);
  300.   return FindItem(root, node);
  301. }
  302. //
  303. // add project nodes to the treeview
  304. //
  305. unsigned TreeController::AddBranch(HTREEITEM tiParent, ProjectNode node) {
  306.   IProjectNodeInfo* pni = d_projectServer->QueryNodeInfo( node );
  307.  
  308.   ProjectNode childNode = pni->GetFirstChild();
  309.   HTREEITEM tiPrevChild = TVI_FIRST;
  310.   unsigned counter = 0;
  311.  
  312.   //
  313.   // add all children of tiParent
  314.   //
  315.   while (childNode) {
  316.  
  317.     IProjectNodeInfo* childNodeInfo = d_projectServer->QueryNodeInfo( childNode );
  318.     IPolyString* name = childNodeInfo->GetInputLocation();
  319.     tiPrevChild = AddOneItem(tiParent, name->GetCstr(), tiPrevChild, d_idxFile, childNode);
  320.     name->Release();
  321.     //
  322.     // increment child counter
  323.     //
  324.     ++counter;
  325.     //
  326.     // add children for the child that is just added
  327.     //
  328.     counter += AddBranch(tiPrevChild, childNode);
  329.     //
  330.     // get sibling
  331.     //
  332.     childNode = childNodeInfo->GetNextSibling();
  333.     childNodeInfo->Release();
  334.   };
  335.   pni->Release();
  336.   //
  337.   // If tiParent has children, change parent's image to close folder
  338.   //
  339.   if (counter) {
  340.     SetImage(tiParent, d_idxCloseFolder);
  341.   }
  342.   return counter;
  343. }
  344.  
  345. //
  346. // change image when user expand/collapse a tree item
  347. //
  348. void TreeController::OnExpanded(LPNM_TREEVIEW lpNMTreeView) {
  349.   TV_ITEM      tviNew, tviChange, tviCurrent;
  350.  
  351.   tviNew = lpNMTreeView->itemNew;
  352.  
  353.   //
  354.   // get current assigned image
  355.   // 
  356.   tviCurrent.hItem = tviNew.hItem;
  357.   tviCurrent.mask = TVIF_IMAGE;
  358.   TreeView_GetItem (d_hwnd, &tviCurrent);
  359.  
  360.   //
  361.   // toggle image
  362.   //  if action == expand and image == close folder
  363.   //    image = open folder
  364.   //
  365.   tviChange.hItem = tviNew.hItem;
  366.   tviChange.mask  = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
  367.   if ((lpNMTreeView->action == TVE_EXPAND) &&
  368.       (tviCurrent.iImage == d_idxCloseFolder))  {       
  369.     tviChange.iImage        = d_idxOpenFolder;
  370.     tviChange.iSelectedImage= d_idxOpenFolder;
  371.   } else {        
  372.     tviChange.iImage        = d_idxCloseFolder;
  373.     tviChange.iSelectedImage= d_idxCloseFolder;
  374.   }
  375.   TreeView_SetItem(d_hwnd, &tviChange);
  376. }
  377.  
  378. void TreeController::AddNode(ProjectNode node) {
  379.   IProjectNodeInfo* nodeInfo =  d_projectServer->QueryNodeInfo(node);
  380.   if (nodeInfo) {
  381.     ProjectNode parentNode = nodeInfo->GetParent();
  382.     IPolyString* name = nodeInfo->GetInputLocation();
  383.  
  384.     HTREEITEM tiParent = GetItemFromNode(parentNode);
  385.     AddOneItem(tiParent, name->GetCstr(), TVI_FIRST, d_idxFile, node);
  386.  
  387.     TV_ITEM item;
  388.     item.hItem = tiParent;
  389.     item.mask = TVIF_IMAGE;
  390.  
  391.     if ( TreeView_GetItem(d_hwnd, &item) ) {
  392.       
  393.       //
  394.       // if it is a file, make it a folder
  395.       //
  396.       if ( item.iImage == d_idxFile )
  397.         SetImage(tiParent, d_idxCloseFolder);
  398.  
  399.       nodeInfo->Release();
  400.       name->Release();
  401.     }
  402.   }
  403. };
  404.  
  405. void TreeController::DeleteTreeItem(ProjectNode node) {
  406.   HTREEITEM hitem = GetItemFromNode(node);
  407.   if (hitem)
  408.     TreeView_DeleteItem(d_hwnd, hitem);
  409. };
  410.  
  411. void TreeController::RemoveNodeFromProject(ProjectNode node) {
  412.  
  413.   d_projectServer->NodeRemove(node);
  414. }
  415.  
  416. void TreeController::AddNodeToProject(ProjectNode node, char* name) {
  417.    d_projectServer->NodeAdd(node, MakePolyString(name));
  418. }
  419.  
  420. /****************************************************************************
  421. * 
  422. * TreeModel
  423. *
  424. ****************************************************************************/
  425.  
  426. TreeModel::TreeModel(HWND hwnd) {
  427.  
  428.   d_makeServer  = GET_INTERFACE(IMakeServer);
  429.   d_toolServer  = GET_INTERFACE(IToolServer);
  430.   d_hwnd = hwnd;
  431.   d_tc = 0;
  432.   d_selectedItem = 0;
  433.   d_client = 0;
  434. }
  435.  
  436. TreeModel::~TreeModel() {
  437.   d_makeServer->Release();
  438.   d_toolServer->Release();
  439.   if ( d_client ) {
  440.     d_client->Stop();
  441.     d_client->Release();
  442.   }
  443. };
  444.  
  445.  
  446. void TreeModel::SetProjectViewClient(IProjectViewClient* client) {
  447.   d_client = client;
  448. };
  449.  
  450.         
  451. void TreeModel::SetSelected(HTREEITEM item) {
  452.   d_selectedItem = item;
  453. }
  454.  
  455. ProjectNode TreeModel::GetSelectedNode() {
  456.   return d_tc->GetNodeFromItem(d_selectedItem);
  457. };
  458.  
  459. BOOL TreeModel::GetNewNodeName(char* buf, int bufSize) {
  460.   
  461.   OPENFILENAME ofn;      /* common dialog box structure  */
  462.  
  463.   memset(&ofn, 0, sizeof(ofn));
  464.   char szFilter[260] = "Files(*.*)\0*.*\0\0";    /* filter string                */
  465.   
  466.   /* Set the members of the OPENFILENAME structure. */
  467.  
  468.   ofn.lStructSize = sizeof(OPENFILENAME);
  469.   ofn.hwndOwner = d_hwnd;
  470.   ofn.lpstrFilter = szFilter;
  471.   ofn.nFilterIndex = 1;
  472.   ofn.lpstrFile = buf;
  473.   ofn.nMaxFile = bufSize;
  474.   ofn.lpstrTitle = "AddOn - add node";
  475.   ofn.Flags = OFN_EXPLORER;
  476.  
  477.   /* Display the Open dialog box. */
  478.  
  479.   return GetOpenFileName(&ofn);
  480.  
  481. }
  482.  
  483. void TreeModel::OnCommand(WORD wID, WORD /*wNotifyCode*/) {
  484.   switch (wID) {
  485.     case IDM_MAKE:
  486.     {
  487.       ProjectNode nodes[1];
  488.       nodes[0] = GetSelectedNode();
  489.       d_makeServer->MakeNodes(MM_Make, nodes, 1);
  490.     }
  491.     break;
  492.     case IDM_BUILD:
  493.     {
  494.       ProjectNode nodes[1];
  495.       nodes[0] = GetSelectedNode();
  496.       d_makeServer->MakeNodes(MM_Build, nodes, 1);
  497.     }
  498.     break;
  499.     case IDM_TRANSLATE:
  500.     {
  501.       ProjectNode nodes[1];
  502.       nodes[0] = GetSelectedNode();
  503.       d_makeServer->MakeNodes(MM_Translate, nodes, 1);
  504.     }
  505.     break;
  506.     case IDM_VIEW:
  507.     {
  508.       ToolObj toolObj = d_toolServer->ToolFind( ::MakePolyString ( "EditText" ) );
  509.       d_toolServer->ToolInvoke(toolObj, GetSelectedNode());
  510.     }
  511.     break;
  512.     case IDM_REFRESH:
  513.     {
  514.       d_tc->AddTreeViewItems();
  515.     }
  516.     break;
  517.     case IDM_CREATENEWVIEW:
  518.     {
  519.       CreateNewProjectView(d_tc->GetTopNode());
  520.     }
  521.     break;
  522.     case IDM_VIEWFROMHERE:
  523.     {
  524.       d_tc->SetTopNode(GetSelectedNode());
  525.       d_tc->AddTreeViewItems();
  526.     }
  527.     break;
  528.     case IDM_DELETENODE:
  529.     {
  530.       d_tc->RemoveNodeFromProject(GetSelectedNode());
  531.     }
  532.     break;
  533.     case IDM_ADDNODE:
  534.     {
  535.     char buf[MAX_PATH] = "";
  536.       if (GetNewNodeName(buf, sizeof(buf))) {
  537.       d_tc->AddNodeToProject(GetSelectedNode(), buf);
  538.     }
  539.    }
  540.    break;
  541.    case IDM_VIEWDEP:
  542.    {
  543.     ProjectNode nodes[100]; // only do up to 100 nodes
  544.     int nNodes = DependentCollector().GetDependents(GetSelectedNode()
  545.                                    , nodes
  546.                                    , sizeof(nodes)/sizeof(nodes[0]));
  547.     CreateDetailView(nodes, nNodes);
  548.    }
  549.     break;
  550.   };
  551. };
  552.  
  553. void TreeModel::Resize(int w, int h) {
  554.   MoveWindow(d_tc->d_hwnd, 0, 0, w, h, TRUE);
  555. }
  556.  
  557. void TreeModel::OnNodeDeleted(ProjectNode node) {
  558.   d_tc->DeleteTreeItem(node);
  559. };
  560.  
  561. void TreeModel::OnNodeAdd(ProjectNode node) {
  562.     d_tc->AddNode(node);
  563. };
  564.  
  565. /***************************************************************************
  566. * 
  567. *   FUNCTION: AddOneItem(HTREEITEM, LPSTR, HTREEITEM, int)
  568. *
  569. *   PURPOSE: Inserts a tree view item in the specified place. 
  570. *
  571. ****************************************************************************/
  572.  
  573. HTREEITEM TreeController::AddOneItem( HTREEITEM hParent
  574.                                     , LPCSTR szText
  575.                                     , HTREEITEM hInsAfter
  576.                                     , int iImage
  577.                                     , LPARAM lParam)
  578. {
  579.   HTREEITEM hItem;
  580.   TV_ITEM tvI;
  581.   TV_INSERTSTRUCT tvIns;
  582.  
  583.   tvI.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
  584.   tvI.pszText = (char*)szText;
  585.   tvI.cchTextMax = lstrlen(szText);
  586.   tvI.iImage = iImage;
  587.   tvI.iSelectedImage = iImage;
  588.   tvI.lParam = lParam;
  589.  
  590.   tvIns.item = tvI;
  591.   tvIns.hInsertAfter = hInsAfter;
  592.   tvIns.hParent = hParent;
  593.   
  594.   hItem = (HTREEITEM)SendMessage(d_hwnd, TVM_INSERTITEM, 0,
  595.     (LPARAM)(LPTV_INSERTSTRUCT)&tvIns);
  596.  
  597.   return (hItem);
  598. }
  599.  
  600. /****************************************************************************
  601. *
  602. *   Context Menu Processing
  603. *
  604. ****************************************************************************/
  605. VOID APIENTRY DisplayContextMenu(HWND hwnd, POINT pt)
  606. {
  607.   // Load the menu resource.
  608.  
  609.   HINSTANCE hInst = (HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE);
  610.   HMENU hmenu = LoadMenu(hInst, MAKEINTRESOURCE(IDR_ADDON_POPUP));  // top-level menu 
  611.   if (hmenu == NULL)
  612.       return;
  613.  
  614.   HMENU hmenuTrackPopup = GetSubMenu(hmenu, 0);  // pop-up menu
  615.  
  616.   // Display the floating pop-up menu. Track the right mouse
  617.   // button on the assumption that this function is called
  618.   // during WM_CONTEXTMENU processing.
  619.  
  620.   TrackPopupMenu(hmenuTrackPopup,
  621.           TPM_LEFTALIGN | TPM_RIGHTBUTTON,
  622.           pt.x, pt.y, 0, hwnd, NULL);
  623.  
  624.   // Destroy the menu.
  625.  
  626.   DestroyMenu(hmenu);
  627. }
  628.  
  629.  
  630. BOOL WINAPI OnContextMenu(HWND hwnd, int x, int y)
  631. {
  632.   RECT rc;                    // client area of window 
  633.   POINT pt = { x, y };        // location of mouse click 
  634.  
  635.   // Get the bounding rectangle of the client area. 
  636.  
  637.   GetClientRect(hwnd, &rc);
  638.  
  639.   // Convert the mouse position to client coordinates. 
  640.  
  641.   ScreenToClient(hwnd, &pt);
  642.  
  643.   // If the position is in the client area, display a floating 
  644.   // pop-up menu. 
  645.  
  646.   if (PtInRect(&rc, pt)) {
  647.       ClientToScreen(hwnd, &pt);
  648.       DisplayContextMenu(hwnd, pt);
  649.       return TRUE;
  650.   }
  651.   // Return FALSE if no menu is displayed. 
  652.   return FALSE;
  653. }
  654.  
  655.  
  656. LONG APIENTRY TreeViewWndProc(
  657.   HWND hWnd,                /* window handle                   */
  658.   UINT message,            /* type of message                */
  659.   UINT wParam,              /* additional information         */
  660.   LONG lParam)              /* additional information         */
  661. {
  662.   TreeModel* tm = GetTreeModelFromHWND(hWnd);
  663.   switch (message)
  664.   {
  665.  
  666.     case WM_CREATE:
  667.     {
  668.       // Create the tree view window and initialize its
  669.       // image list
  670.       TreeController* tc = new TreeController();
  671.       TreeModel* tm = new TreeModel(hWnd);
  672.       SetWindowLong(hWnd, GWL_USERDATA, (long)tm);
  673.  
  674.       tc->InitWindow(hWnd);
  675.       tm->Attach(tc);
  676.    }
  677.  
  678.       break;          
  679.     case WM_SIZE:
  680.     {
  681.       tm->Resize(LOWORD(lParam), HIWORD(lParam));
  682.     }
  683.       break;
  684.     case WM_CONTEXTMENU:
  685.      if (!OnContextMenu(hWnd, LOWORD(lParam), HIWORD(lParam)))
  686.        return DefWindowProc(hWnd, message, wParam, lParam);
  687.      break;
  688.     case WM_COMMAND:
  689.     {
  690.      tm->OnCommand(LOWORD(wParam), HIWORD(wParam)); 
  691.     }
  692.      break;
  693.  
  694.     case WM_NOTIFY:
  695.     {
  696.       LPNMHDR pnmh = (LPNMHDR) lParam;
  697.       switch (pnmh->code) {
  698.         case TVN_SELCHANGED:
  699.         {
  700.           LPNM_TREEVIEW ptv = (LPNM_TREEVIEW)lParam;
  701.           tm->SetSelected(ptv->itemNew.hItem);
  702.         };
  703.         break;
  704.         case TVN_ITEMEXPANDED:
  705.         {
  706.           tm->GetController()->OnExpanded((LPNM_TREEVIEW)lParam);
  707.         }
  708.         break;
  709.       };
  710.     }
  711.       break;
  712.     case UM_SETROOT:
  713.     {
  714.       TreeController* tc = tm->GetController();
  715.       tc->SetTopNode((ProjectNode)lParam);
  716.       tc->AddTreeViewItems();
  717.     }
  718.       break;
  719.     case WM_DESTROY:
  720.     {
  721.       TreeController* tc = tm->GetController();
  722.       delete tm;
  723.       delete tc;
  724.       SetWindowLong(hWnd, GWL_USERDATA, 0L);
  725.     }
  726.     default:
  727.       return (DefWindowProc(hWnd, message, wParam, lParam));
  728.   }
  729.   return (0);
  730. }
  731.  
  732. BOOL RegisterTreeViewClass(HINSTANCE hInstance)      /* current instance             */
  733. {
  734.   WNDCLASS  wcTreeView;
  735.  
  736.   if ( GetClassInfo(hInstance,              // handle of application instance
  737.                     TEXT("TreeViewWClass"), // address of class name string
  738.                     &wcTreeView)            // address of structure for class data
  739.       ) {
  740.     return TRUE;
  741.   }
  742.  
  743.   /* Fill in window class structure with parameters that describe the      */
  744.   /* main window.                                                          */
  745.  
  746.   wcTreeView.style = 0;                    
  747.   wcTreeView.lpfnWndProc = (WNDPROC)TreeViewWndProc; 
  748.   wcTreeView.cbClsExtra = 0;              
  749.   wcTreeView.cbWndExtra = 0;              
  750.   wcTreeView.hInstance = hInstance;
  751.   wcTreeView.hIcon = NULL;
  752.   wcTreeView.hCursor = LoadCursor(NULL, IDC_ARROW);
  753.   wcTreeView.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  754.   wcTreeView.lpszMenuName = NULL; 
  755.   wcTreeView.lpszClassName = TEXT("TreeViewWClass");
  756.  
  757.   return (RegisterClass(&wcTreeView));
  758. }
  759.  
  760. /****************************************************************************
  761. *
  762. *   FUNCTION: CreateTreeWindow(HINSTANCE hInstance, HWND hwndParent)
  763. *
  764. *   PURPOSE:  Creates a treeview window
  765. *
  766. ****************************************************************************/
  767.  
  768. HWND CreateTreeWindow(HINSTANCE hInstance, HWND hwndParent) {
  769.  
  770.   RegisterTreeViewClass(hInstance);
  771.   return CreateWindow(
  772.                         TEXT("TreeViewWClass"),          
  773.                         TEXT("TreeView Sample"), 
  774.                         WS_CHILD|WS_VISIBLE,
  775.                         CW_USEDEFAULT,
  776.                         CW_USEDEFAULT,
  777.                         CW_USEDEFAULT,
  778.                         CW_USEDEFAULT,
  779.                         hwndParent,              
  780.                         NULL,              
  781.                         hInstance,          
  782.                         NULL);
  783. };
  784.  
  785.  
  786. 
  787.