filetreectrl.cpp

版本更新了一下

      if (bHasPlus && !bHasChildren)
        DoExpand(hItemFound);
      else
        Expand(hItemFound, TVE_EXPAND);
    }

    sSearch = sSearch.Right(sSearch.GetLength() - nFound - 1);
    nFound = sSearch.Find(_T('\\'));
  };

  //The last item 
  if (hItemFound)
  {
    if (sSearch.GetLength())
      hItemFound = FindSibling(hItemFound, sSearch);
    if (hItemFound)
      SelectItem(hItemFound);

    if (bExpanded)
    {
      //Working here
      BOOL bHasPlus = HasPlusButton(hItemFound);
      BOOL bHasChildren = (GetChildItem(hItemFound) != NULL);

      if (bHasPlus && !bHasChildren)
        DoExpand(hItemFound);
      else
        Expand(hItemFound, TVE_EXPAND);
    }
  }

  //Turn back on the redraw flag
  SetRedraw(TRUE);

  return hItemFound;
}

BOOL CTreeFileCtrl::Rename(HTREEITEM hItem)
{
  if (hItem)
  {
    CTreeFileCtrlItemInfo* pItem = (CTreeFileCtrlItemInfo*) GetItemData(hItem);
    ASSERT(pItem);
	  if (m_bAllowRename && !IsDrive(hItem) && !pItem->m_bNetworkNode)
      return (EditLabel(hItem) != NULL);
    else
      return FALSE;
  }
  else
    return FALSE;
}

BOOL CTreeFileCtrl::ShowProperties(HTREEITEM hItem)
{
  BOOL bSuccess = FALSE;
  if (m_bAllowProperties && hItem)
  {
    //Show the "properties" for the selected file
    CString sFile = ItemToPath(hItem);
    SHELLEXECUTEINFO sei;
    ZeroMemory(&sei,sizeof(sei));
    sei.cbSize = sizeof(sei);
    sei.hwnd = AfxGetMainWnd()->GetSafeHwnd();
    sei.nShow = SW_SHOW;
    sei.lpFile = sFile.GetBuffer(sFile.GetLength());
    sei.lpVerb = _T("properties");
    sei.fMask  = SEE_MASK_INVOKEIDLIST;
    bSuccess = ShellExecuteEx(&sei);
    sFile.ReleaseBuffer();
  }
  return bSuccess;
}

BOOL CTreeFileCtrl::Delete(HTREEITEM hItem)
{
  BOOL bSuccess = FALSE;

  if (hItem)
  {
    CTreeFileCtrlItemInfo* pItem = (CTreeFileCtrlItemInfo*) GetItemData(hItem);
    ASSERT(pItem);
    if (m_bAllowDelete && !IsDrive(hItem) && !pItem->m_bNetworkNode)
    {
      //Create a Multi SZ string with the filename to delete
      CString sFileToDelete = ItemToPath(hItem);
      int nChars = sFileToDelete.GetLength() + 1;
      nChars++;
      SHFILEOPSTRUCT shfo;
      ZeroMemory(&shfo, sizeof(SHFILEOPSTRUCT));
      shfo.hwnd = AfxGetMainWnd()->GetSafeHwnd();
      shfo.wFunc = FO_DELETE;

      //Undo is not allowed if the SHIFT key is held down
      if (!(GetKeyState(VK_SHIFT) & 0x8000))
        shfo.fFlags = FOF_ALLOWUNDO;

      TCHAR* pszFrom = new TCHAR[nChars];
      TCHAR* pszCur = pszFrom;
      _tcscpy(pszCur, sFileToDelete);
      pszCur[nChars-1] = _T('\0');
      shfo.pFrom = pszFrom;

      BOOL bOldAutoRefresh = m_bAutoRefresh;
      m_bAutoRefresh = FALSE; //Prevents us from getting thread notifications

      //Let the shell perform the actual deletion
      if (SHFileOperation(&shfo) == 0 && shfo.fAnyOperationsAborted == FALSE)
      {
        //Delete the item from the view
        bSuccess = DeleteItem(hItem);
      }

      m_bAutoRefresh = bOldAutoRefresh;

      //Free up the memory we had allocated
      delete [] pszFrom;
    }
  }
  return bSuccess;
}

BOOL CTreeFileCtrl::Open(HTREEITEM hItem)
{
  BOOL bSuccess = FALSE;
  if (m_bAllowOpen && hItem)
  {
    //Show the "properties" for the selected file
    CString sFile = ItemToPath(hItem);
    SHELLEXECUTEINFO sei;
    ZeroMemory(&sei,sizeof(sei));
    sei.cbSize = sizeof(sei);
    sei.hwnd = AfxGetMainWnd()->GetSafeHwnd();
    sei.nShow = SW_SHOW;
    sei.lpFile = sFile.GetBuffer(sFile.GetLength());
    sei.fMask  = SEE_MASK_INVOKEIDLIST;
    bSuccess = ShellExecuteEx(&sei);
    sFile.ReleaseBuffer();
  }
  return bSuccess;
}

void CTreeFileCtrl::SetFlags(DWORD dwFlags)
{
  SetShowFiles((dwFlags & TFC_SHOWFILES) != 0);
  SetAllowDragDrop((dwFlags & TFC_ALLOWDRAGDROP) != 0);
  SetAllowRename((dwFlags & TFC_ALLOWRENAME) != 0);  
  SetAllowOpen((dwFlags & TFC_ALLOWOPEN) != 0);    
  SetAllowProperties((dwFlags & TFC_ALLOWPROPERTIES) != 0);
  SetAllowDelete((dwFlags & TFC_ALLOWDELETE) != 0);
}

void CTreeFileCtrl::SetDriveHideFlags(DWORD dwDriveHideFlags)
{
  m_dwDriveHideFlags = dwDriveHideFlags;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetFileHideFlags(DWORD dwFileHideFlags)
{
  m_dwFileHideFlags = dwFileHideFlags;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetFileNameMask(const CString& sFileNameMask)
{
  m_sFileNameMask = sFileNameMask;

  //Force a refresh
  Refresh();
}


void CTreeFileCtrl::SetCompressedColor(COLORREF rgbCompressed)
{
  m_rgbCompressed = rgbCompressed;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetDisplayNetwork(BOOL bDisplayNetwork)
{
  m_bDisplayNetwork = bDisplayNetwork;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetUsingDifferentColorForCompressed(BOOL bShowCompressedUsingDifferentColor)
{
  m_bShowCompressedUsingDifferentColor = bShowCompressedUsingDifferentColor;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetUsingDifferentIconForSharedFolders(BOOL bShowSharedUsingDifferentIcon)
{
  m_bShowSharedUsingDifferentIcon = bShowSharedUsingDifferentIcon;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetUsingDifferentColorForEncrypted(BOOL bShowEncryptedUsingDifferentColor)
{
  m_bShowEncryptedUsingDifferentColor = bShowEncryptedUsingDifferentColor;

  //Force a refresh
  Refresh();
};

void CTreeFileCtrl::SetShowFileExtensions(HideFileExtension FileExtensions)
{
  m_FileExtensions = FileExtensions;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetNetworkItemTypes(DWORD dwTypes)
{
  m_dwNetworkItemTypes = dwTypes;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetShowDriveLabels(BOOL bShowDriveLabels)
{
  m_bShowDriveLabels = bShowDriveLabels;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetShowMyComputer(BOOL bShowMyComputer)
{
  m_bShowMyComputer = bShowMyComputer;

  //Force a refresh
  Refresh();
}

void CTreeFileCtrl::SetShowRootedFolder(BOOL bShowRootedFolder)
{
  m_bShowRootedFolder = bShowRootedFolder;

  //Force a refresh
  Refresh();
}

BOOL CTreeFileCtrl::CanDisplayFile(const CFileFind& find)
{
  //Derived classes can decide dynamically whether or not a 
  //certain file are to be displayed. CTreeFileCtrl by default
  //displays all files which do not have attributes as set in m_dwFileHideFlags

  return (m_bShowFiles && !find.IsDirectory() && !find.MatchesMask(m_dwFileHideFlags));
}

BOOL CTreeFileCtrl::CanDisplayFolder(const CFileFind& find)
{
  //Derived classes can decide dynamically whether or not a 
  //certain folder are to be displayed. CTreeFileCtrl by default
  //displays all folders excluding the ".." and "." entries

  return (find.IsDirectory() && !find.IsDots());
}

BOOL CTreeFileCtrl::CanDisplayNetworkItem(CTreeFileCtrlItemInfo* /*pItem*/)
{
  //Derived classes can decide dynamically whether or not a 
  //certain network items are to be displayed. CTreeFileCtrl by default
  //displays all network items

  return TRUE;
}

BOOL CTreeFileCtrl::CanHandleChangeNotifications(const CString& sPath)
{
  //check if this drive is one of the types which can issue notification changes
  CString sDrive(sPath);
  if (!IsDrive(sDrive))
    sDrive = sPath.Left(3);

  UINT nDrive = GetDriveType(sDrive);
  return ((nDrive != DRIVE_REMOVABLE) && nDrive != DRIVE_CDROM);
}

BOOL CTreeFileCtrl::CanDisplayDrive(const CString& sDrive)
{
  //Derived classes can decide dynamically whether or not a 
  //certain drive is to be displayed. CTreeFileCtrl by default
  //displays all drives which do not have attributes as set in
  //m_dwDriveHideFlags

  //check if this drive is one of the types to hide
  BOOL bDisplay = TRUE;
  UINT nDrive = GetDriveType(sDrive);
  switch (nDrive)
  {
    case DRIVE_REMOVABLE:
    {
      if (m_dwDriveHideFlags & DRIVE_ATTRIBUTE_REMOVABLE)
        bDisplay = FALSE;
      break;
    }
    case DRIVE_FIXED:
    {
      if (m_dwDriveHideFlags & DRIVE_ATTRIBUTE_FIXED)
        bDisplay = FALSE;
      break;
    }
    case DRIVE_REMOTE:
    {
      if (m_dwDriveHideFlags & DRIVE_ATTRIBUTE_REMOTE)
        bDisplay = FALSE;
      break;
    }
    case DRIVE_CDROM:
    {
      if (m_dwDriveHideFlags & DRIVE_ATTRIBUTE_CDROM)
        bDisplay = FALSE;
      break;
    }
    case DRIVE_RAMDISK:
    {
      if (m_dwDriveHideFlags & DRIVE_ATTRIBUTE_RAMDISK)
        bDisplay = FALSE;
      break;
    }
    default:
    {
      break;
    }
  }

  return bDisplay;
}

void CTreeFileCtrl::OnRename() 
{
  Rename(GetSelectedItem());
}

void CTreeFileCtrl::OnUpdateRename(CCmdUI* pCmdUI) 
{
  HTREEITEM hSelItem = GetSelectedItem();
  if (hSelItem)
  {
    CTreeFileCtrlItemInfo* pItem = (CTreeFileCtrlItemInfo*) GetItemData(hSelItem);
    ASSERT(pItem);
	  pCmdUI->Enable(m_bAllowRename && !IsDrive(hSelItem) && !pItem->m_bNetworkNode);
  }
  else
    pCmdUI->Enable(FALSE);
}

void CTreeFileCtrl::OnProperties() 
{
  ShowProperties(GetSelectedItem());
}

void CTreeFileCtrl::OnUpdateProperties(CCmdUI* pCmdUI) 
{
  HTREEITEM hSelItem = GetSelectedItem();
  if (hSelItem)
  {
    if (m_bAllowProperties)
    {
      CTreeFileCtrlItemInfo* pItem = (CTreeFileCtrlItemInfo*) GetItemData(hSelItem);
      ASSERT(pItem);
      if (pItem->m_bNetworkNode)
      { 
        if (pItem->m_pNetResource)
          pCmdUI->Enable(pItem->m_pNetResource->dwDisplayType == RESOURCEDISPLAYTYPE_SERVER ||
                         pItem->m_pNetResource->dwDisplayType == RESOURCEDISPLAYTYPE_SHARE);
        else
          pCmdUI->Enable(FALSE);
      }
      else
        pCmdUI->Enable(TRUE);
    }
    else
      pCmdUI->Enable(FALSE);
  }
  else
    pCmdUI->Enable(FALSE);
}

void CTreeFileCtrl::OnOpen() 
{
  Open(GetSelectedItem());