}

                    }
                  if (lpsf2)
                    lpsf2->Release ();
                }
              return bRet;
            }

        }
      if (lpsf2)
        lpsf2->Release ();
    }
  return bRet;
}

/****************************************************************************
 *
 *  FUNCTION:   GetSelectedFolderPath(CString &szFolderPath)
 *
 *  PURPOSE:    Retrieves the path of the currently selected string.
 *              Pass a CString object that will hold the folder path.
 *              If the path is not in the filesystem(eg MyComputer)
 *              or none is selected it returns false.
 *
 *  MESSAGEMAP: NONE
 *
 ****************************************************************************/
BOOL CShellTree::
GetSelectedFolderPath (CString & szFolderPath)
{
  LPTVITEMDATA lptvid;          //Long pointer to TreeView item data

  LPSHELLFOLDER lpsf2 = NULL;
  static TCHAR szBuff[MAX_PATH];
  HTREEITEM hItem = GetSelectedItem ();
  HRESULT hr;
  BOOL bRet = false;

  if (hItem)
    {
      lptvid = (LPTVITEMDATA) GetItemData (hItem);

      if (lptvid && lptvid->lpsfParent && lptvid->lpi)
        {
          hr = lptvid->lpsfParent->BindToObject (lptvid->lpi,
                                                 0, IID_IShellFolder, (LPVOID *) & lpsf2);

          if (SUCCEEDED (hr))
            {
              ULONG ulAttrs = SFGAO_FILESYSTEM;

              // Determine what type of object we have.
              lptvid->lpsfParent->GetAttributesOf (1, (const struct _ITEMIDLIST **) &lptvid->lpi, &ulAttrs);

              if (ulAttrs & (SFGAO_FILESYSTEM))
                {
                  if (SHGetPathFromIDList (lptvid->lpifq, szBuff))
                    {
                      szFolderPath = szBuff;
                      bRet = true;
                    }
                }
            }
          else
            {
              if (lpsf2)
                lpsf2->Release ();
              HTREEITEM hItem2 = GetParentItem (hItem);

              if (hItem2)
                {
                  lptvid = (LPTVITEMDATA) GetItemData (hItem2);

                  if (lptvid && lptvid->lpsfParent && lptvid->lpi)
                    {
                      hr = lptvid->lpsfParent->BindToObject (lptvid->lpi,
                                                             0, IID_IShellFolder, (LPVOID *) & lpsf2);

                      if (SUCCEEDED (hr))
                        {
                          ULONG ulAttrs = SFGAO_FILESYSTEM;

                          // Determine what type of object we have.
                          lptvid->lpsfParent->GetAttributesOf (1, (const struct _ITEMIDLIST **) &lptvid->lpi, &ulAttrs);

                          if (ulAttrs & (SFGAO_FILESYSTEM))
                            {
                              if (SHGetPathFromIDList (lptvid->lpifq, szBuff))
                                {
                                  CString item = GetItemText (hItem);

                                  szFolderPath = szBuff[_tcslen (szBuff) - 1] == _T ('\\') ? szBuff + item : CString (szBuff) + _T ("\\") + item;
                                  bRet = true;
                                }
                            }
                        }

                    }
                  if (lpsf2)
                    lpsf2->Release ();
                }
              return bRet;
            }

        }
      if (lpsf2)
        lpsf2->Release ();
    }
  return bRet;
}

/****************************************************************************
 *
 *  FUNCTION:   GetParentShellFolder(HTREEITEM folderNode)
 *
 *  PURPOSE:    Retrieves the pointer to the ISHELLFOLDER interface
 *              of the tree node passed as the paramter.
 *
 *  MESSAGEMAP: NONE
 *
 ****************************************************************************/
LPSHELLFOLDER CShellTree::
GetParentShellFolder (HTREEITEM folderNode)
{
  LPTVITEMDATA lptvid;          //Long pointer to TreeView item data

  lptvid = (LPTVITEMDATA) GetItemData (folderNode);
  if (lptvid)
    return lptvid->lpsfParent;
  else
    return NULL;
}

/****************************************************************************
 *
 *  FUNCTION:   GetRelativeIDLIST(HTREEITEM folderNode)
 *
 *  PURPOSE:    Retrieves the Pointer to an ITEMIDLIST structure that
 *              identifies the subfolder relative to its parent folder.
 *              see GetParentShellFolder();
 *
 *  MESSAGEMAP: NONE
 *
 ****************************************************************************/
LPITEMIDLIST CShellTree::
GetRelativeIDLIST (HTREEITEM folderNode)
{
  LPTVITEMDATA lptvid;          //Long pointer to TreeView item data

  lptvid = (LPTVITEMDATA) GetItemData (folderNode);
  if (lptvid)
    return lptvid->lpifq;
  else
    return NULL;
}

/****************************************************************************
 *
 *  FUNCTION:   GetFullyQualifiedIDLIST(HTREEITEM folderNode)
 *
 *  PURPOSE:    Retrieves the Retrieves the Pointer to an ITEMIDLIST
 *              structure that identifies the subfolder relative to the
 *              desktop. This is a fully qualified Item Identifier
 *
 *  MESSAGEMAP: NONE
 *
 ****************************************************************************/
LPITEMIDLIST CShellTree::
GetFullyQualifiedID (HTREEITEM folderNode)
{
  LPTVITEMDATA lptvid;          //Long pointer to TreeView item data

  lptvid = (LPTVITEMDATA) GetItemData (folderNode);
  if (lptvid)
    return lptvid->lpifq;
  else
    return NULL;
}

/****************************************************************************
 *
 *  FUNCTION:   SearchTree( HTREEITEM treeNode,
 *                          CString szSearchName )
 *
 *  PURPOSE:    Too crude to explain, just use it
 *
 *  WARNING:    Only works if you use the default PopulateTree()
 *              Not guaranteed to work on any future or existing
 *              version of windows. Use with caution. Pretty much
 *              ok if you're using on local drives
 *
 ****************************************************************************/
bool CShellTree::
SearchTree (HTREEITEM treeNode,
            CString szSearchName,
            FindAttribs attr)
{
  LPTVITEMDATA lptvid;          //Long pointer to TreeView item data

  LPSHELLFOLDER lpsf2 = NULL;
  TCHAR drive[_MAX_DRIVE];
  TCHAR dir[_MAX_DIR];
  TCHAR fname[_MAX_FNAME];
  TCHAR ext[_MAX_EXT];
  bool bRet = false;
  HRESULT hr;
  CString szCompare;

  szSearchName.MakeUpper ();
  while (treeNode && bRet == false)
    {
      lptvid = (LPTVITEMDATA) GetItemData (treeNode);
      if (lptvid && lptvid->lpsfParent && lptvid->lpi)
        {
          hr = lptvid->lpsfParent->BindToObject (lptvid->lpi,
                                                 0, IID_IShellFolder, (LPVOID *) & lpsf2);
          if (SUCCEEDED (hr))
            {
              ULONG ulAttrs = SFGAO_FILESYSTEM;
              lptvid->lpsfParent->GetAttributesOf (1, (const struct _ITEMIDLIST **) &lptvid->lpi, &ulAttrs);
              if (ulAttrs & (SFGAO_FILESYSTEM))
                {
                  if (SHGetPathFromIDList (lptvid->lpifq, szCompare.GetBuffer (MAX_PATH)))
                    {
                      switch (attr)
                        {
                        case type_drive:
                          _tsplitpath (szCompare, drive, dir, fname, ext);
                          szCompare = drive;
                          break;
                        case type_folder:
                          szCompare = GetItemText (treeNode);
                          break;
                        }
                      szCompare.MakeUpper ();
                      if (szCompare == szSearchName)
                        {
                          EnsureVisible (treeNode);
                          SelectItem (treeNode);
                          bRet = true;
                        }
                    }
                }
              lpsf2->Release ();
            }
        }
      treeNode = GetNextSiblingItem (treeNode);
    }
  return bRet;
}

/****************************************************************************
 *
 *  FUNCTION:   TunnelTree(CString szFindPath)
 *
 *  PURPOSE:    Too crude to explain, just use it
 *
 *  WARNING:    Only works if you use the default PopulateTree()
 *              Not guaranteed to work on any future or existing
 *              version of windows. Use with caution. Pretty much
 *              ok if you're using on local drives
 *
 ****************************************************************************/
void CShellTree::
TunnelTree (CString szFindPath)
{
  HTREEITEM subNode = GetRootItem ();
  CString szPathHop;
  TCHAR drive[_MAX_DRIVE];
  TCHAR dir[_MAX_DIR];
  TCHAR fname[_MAX_FNAME];
  TCHAR ext[_MAX_EXT];
  TCHAR delimiter[] = _T ("\\");

  CSHFileInfo checkPath (szFindPath);
  if (!checkPath.Exist ())
    {
      MessageBox (szFindPath, _T ("Folder not found"), MB_ICONERROR);
      return;
    }

  if (szFindPath.ReverseFind (_T ('\\')) != szFindPath.GetLength () - 1)
    {
      szFindPath += _T ("\\");
    }

  _tsplitpath (szFindPath, drive, dir, fname, ext);

  //search the drive first
  szPathHop = drive;
  subNode = GetChildItem (subNode);
  if (subNode)
    {
      if (SearchTree (subNode, szPathHop, CShellTree::type_drive))
        {
          //break down subfolders and search
          LPTSTR p = _tcstok (dir, delimiter);
          while (p)
            {
              subNode = GetSelectedItem ();
              subNode = GetChildItem (subNode);
              if (SearchTree (subNode, p, CShellTree::type_folder))
                p = _tcstok (NULL, delimiter);
              else
                p = NULL;
            }
        }
    }
}

/****************************************************************************
 *
 *  FUNCTION:   PopulateTree(LPCTSTR lpPath)
 *
 *  PURPOSE:    Populates tree based upon path.
 *
 *  AUTHOR:     Takehiko Mizoguti [mizoguti@m2.sys.to.casio.co.jp]
 *
 ****************************************************************************/
void CShellTree::PopulateTree (LPCTSTR lpPath)
{

  LPSHELLFOLDER lpsf = NULL, lpsf2 = NULL;
  LPITEMIDLIST lpi = NULL;
  HRESULT hr;
  TV_SORTCB tvscb;
  LPTSTR lpFolder = (LPTSTR) lpPath;
  LPTSTR lpNextFolder;
  TCHAR strPath[_MAX_PATH];

  LPMALLOC pMalloc;
  if (::SHGetMalloc (&pMalloc) == NOERROR)
    {

      // Get a pointer to the desktop folder.
      hr = SHGetDesktopFolder (&lpsf);

      if (SUCCEEDED (hr))
        {
          USES_CONVERSION;

          // Initialize the tree view to be empty.
          DeleteAllItems ();

          do
            {

              // Get the Next Component
              lpNextFolder = PathFindNextComponent (lpFolder);
              if (lpNextFolder && *lpNextFolder)
                {
                  memcpy (strPath, lpFolder, (lpNextFolder - lpFolder));
                  strPath[lpNextFolder - lpFolder] = _T ('\0');
                }
              else
                {
                  _tcscpy (strPath, lpFolder);
                  lpNextFolder = NULL;
                }

              // Get ShellFolder Pidl
              ULONG eaten;
              hr = lpsf->ParseDisplayName (NULL, NULL, T2OLE (strPath), &eaten, &lpi, NULL);
              if (FAILED (hr))
                {
                  break;
                }
              hr = lpsf->BindToObject (lpi, 0, IID_IShellFolder, (LPVOID *) & lpsf2);
              if (FAILED (hr))
                {
                  break;
                }

              pMalloc->Free (lpi);

              // Release the Parent Folder pointer.
              lpsf->Release ();

              // Chenge Folder Info
              lpsf = lpsf2;
              lpFolder = lpNextFolder;
            }
          while (lpNextFolder);

          FillTreeView (lpsf, NULL, TVI_ROOT);

        }
    }
  tvscb.hParent = TVI_ROOT;
  tvscb.lParam = 0;
  tvscb.lpfnCompare = TreeViewCompareProc;

  // Sort the items in the tree view
  SortChildrenCB (&tvscb /*, FALSE */ );

  HTREEITEM hItem;
  hItem = GetRootItem ();
  Expand (hItem, TVE_EXPAND);
  Select (GetRootItem (), TVGN_CARET);
}

////////////////////////////////////////////////////////////////////////////////
#pragma warning ( default : 4711 )