开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > Shell编程 > 查看源码
Folder.cpp
资源名称：adfview_src.zip　[点击查看]
上传用户：hy_wanghao
上传日期：2007-01-08
资源大小：279k
文件大小：21k
源码类别：

Shell编程

开发平台：

Visual C++

Folder.cpp：源码内容
  1. // Folder.cpp : Implementation of CFolder
  3. #include "stdafx.h"
  4. #include "Folder.h"
  5. #include "View.h"
  6. #include "Misc.h"
  8. #include "ExtractIcon.h"
  9. #include "DropTarget.h"
  10. #include "DataObject.h"
  11. #include "ContextMenu.h"
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CComCoClass<CFolder> - COM registration
  17. BOOL CFolder::_FindAmigaDrive(LPTSTR pstrDevice)
  18. {
  19.    const int MAX_PHYSICAL_DRIVES = 6;
  20.    ATLASSERT(pstrDevice);
  21.    // Scan harddrives for an Amiga disk
  22.    // (excludes drive0 because it's likely it's the C: disk)
  23.    for( int i=1; i<MAX_PHYSICAL_DRIVES; i++ ) {
  24.       ::wsprintf(pstrDevice, _T("|H%d"), i);
  25. #ifdef _DEBUG
  26.       // DEBUG: We fake an Amiga harddisk in DEBUG mode
  27.       if( i==3 ) {
  28.          _tcscpy( pstrDevice, _T("C:\Temp\drive.adf") );
  29.          return TRUE;
  30.       }
  31. #endif
  32.       CAdfDevice dev;
  33.       if( dev.Open(pstrDevice, TRUE) ) return TRUE;
  34.    }
  35.    return FALSE;
  36. }
  38. HRESULT CFolder::_RegisterObject(CLSID clsid, UINT id, BOOL bRegister, _ATL_REGMAP_ENTRY *rm, LPCTSTR pstrDeviceName)
  39. {
  40.    HRESULT Hr;
  41.    HR( _Module.UpdateRegistryFromResource(id, bRegister, rm) );
  42.    if( !bRegister ) return S_OK;
  44.    // Uh, need to write additional attribute data to registry...
  45.    CRegKey reg;
  46.    OLECHAR szCLSID[64];
  47.    ::StringFromGUID2(clsid, szCLSID, lengthof(szCLSID));
  48.    TCHAR szSubKey[128];
  49.    LONG lResult;
  50.    
  51.    // Write DeviceName and Partition for Drive
  52.    ::wsprintf( szSubKey, _T("CLSID\%ls"), szCLSID);
  53.    lResult = reg.Open(HKEY_CLASSES_ROOT, szSubKey);
  54.    if( lResult!=ERROR_SUCCESS ) return E_FAIL;
  55.    if( (clsid==CLSID_Drive) && (pstrDeviceName!=NULL) ) {
  56.       reg.SetValue(pstrDeviceName, _T("DeviceName"));
  57.       reg.SetValue((DWORD)0L, _T("Partition"));
  58.    }
  59.    
  60.    // Write EditFlags to prevent Download Security dialog
  61. #define FTA_OpenIsSafe 0x00010000
  62.    DWORD dwFlags = FTA_OpenIsSafe;
  63.    lResult = ::RegSetValueEx(reg,
  64.                   _T("EditFlags"),
  65.                   0,
  66.                   REG_BINARY,
  67.                   (LPBYTE)&dwFlags,
  68.                   sizeof(dwFlags));
  70.    // Write ShellFolder attributes
  71.    ::wsprintf(szSubKey, _T("CLSID\%ls\ShellFolder"), szCLSID);
  72.    lResult = reg.Open(HKEY_CLASSES_ROOT, szSubKey);
  73.    if( lResult!=ERROR_SUCCESS ) return E_FAIL;
  74.    reg.SetValue(m_dwShellAttributes, _T("Attributes"));
  76.    return S_OK;
  77. }
  79. HRESULT WINAPI CFolder::UpdateRegistry(BOOL bRegister)
  80. {
  81.    CComBSTR bstrDescription;
  82.    CComBSTR bstrDriveDescription;
  83.    CComBSTR bstrProject;
  84.    CComBSTR bstrInfoTip;
  85.    CComBSTR bstrCLSID(CLSID_Folder);
  86.    CComBSTR bstrDriveCLSID(CLSID_Drive);
  87.    bstrDescription.LoadString(IDS_DESCRIPTION);
  88.    bstrDriveDescription.LoadString(IDS_DRIVEDESCRIPTION);
  89.    bstrProject.LoadString(IDS_PROJNAME);
  90.    bstrInfoTip.LoadString(IDS_INFOTIP);
  91.    _ATL_REGMAP_ENTRY rm[] = { 
  92.       { OLESTR("DESCRIPTION"), bstrDescription },
  93.       { OLESTR("PROJECTNAME"), bstrProject },
  94.       { OLESTR("CLSID"), bstrCLSID },
  95.       { OLESTR("INFOTIP"), bstrInfoTip },
  96.       { OLESTR("DRIVECLSID"), bstrDriveCLSID },
  97.       { OLESTR("DRIVEDESCRIPTION"), bstrDriveDescription },
  98.       { NULL,NULL } };
  99.    HRESULT Hr;
  100.    HR( _RegisterObject(CLSID_Folder, IDR_FOLDER, bRegister, rm, NULL) );
  101.    
  102.    // Process the CLSID_Drive registry entries
  103.    OSVERSIONINFO vi;
  104.    vi.dwOSVersionInfoSize = sizeof(vi);
  105.    ::GetVersionEx(&vi);
  106.    if( bRegister && (vi.dwPlatformId==VER_PLATFORM_WIN32_NT) ) {
  107.       // Register on >= WinNT: we can add a native drive if found
  108.       TCHAR szDevice[MAX_PATH];
  109.       if( _FindAmigaDrive(szDevice) ) {
  110.          HR( _RegisterObject(CLSID_Drive, IDR_DRIVE, bRegister, rm, szDevice) );
  111.       }
  112.   }
  113.    else if( !bRegister ) {
  114.       // Unregister - straight ahead
  115.       HR( _RegisterObject(CLSID_Drive, IDR_DRIVE, bRegister, rm, NULL) );
  116.    }
  117.    return S_OK;
  118. }
  121. /////////////////////////////////////////////////////////////////////////////
  122. // CFolder
  124. HRESULT CFolder::FinalConstruct()
  125. {
  126.    ATLTRACE(_T("CFolder::FinalConstructn"));
  127.    
  128.    // Get a unique folder ID
  129.    SYSTEMTIME st;
  130.    ::GetSystemTime(&st);   
  131.    m_dwFolderID = (st.wMilliseconds<<16) | (st.wSecond<<8) | (st.wMinute); 
  132.    // BUG: This is not unique. And it doesn't reflect the actual path!
  134.    m_bErrorShown = false;
  135.    
  136.    return S_OK;
  137. }
  139. void CFolder::FinalRelease()
  140. {
  141.    ATLTRACE(_T("CFolder::FinalReleasen"));
  142. }
  145. /////////////////////////////////////////////////////////////////////////////
  146. // Implementation
  148. // This helper function creates the actual PIDL entry
  149. // from the supplied arguments.
  150. LPITEMIDLIST CFolder::_CreateItem(
  151.                          LPCTSTR pstrName, 
  152.                          LPCTSTR pstrComment,
  153.                          PIDLTYPE pidlType, 
  154.                          int DosType,
  155.                          DWORD dwSize, 
  156.                          SYSTEMTIME ftTime,
  157.                          DWORD dwAccess,
  158.                          DWORD dwEntryFlags)
  159. {
  160.    ATLTRACE(_T("CFolder::_CreateItem '%s'n"), pstrName);
  161.    ATLASSERT(pstrName);
  162.    ATLASSERT(pidlType==PT_FOLDER || pidlType==PT_FILE);
  164.    UINT TypeID;
  165.    switch(pidlType) {
  166.    case PT_FOLDER: TypeID = IDS_FOLDER; break;
  167.    case PT_FILE: TypeID = IDS_FILE; break;
  168.    default: TypeID = IDS_UNKNOWN; break;
  169.    }
  170.    if( CAdfFile::_IsLink(DosType) ) TypeID = IDS_LINK;
  171.    if( dwEntryFlags & EF_DELETED ) TypeID = IDS_DELETEDENTRY;
  173.    PIDLDATA data = { 0 };
  174.    _tcsncpy(data.szName, pstrName, lengthof(data.szName)-1);
  175.    _tcsncpy(data.szComment, pstrComment==NULL ? _T("") : pstrComment, lengthof(data.szComment)-1);
  176.    data.type = pidlType;
  177.    data.iDosType = DosType;
  178.    ::LoadString(_Module.GetResourceInstance(), TypeID, data.szType, lengthof(data.szType)-1);
  179.    data.ftTime = ftTime;
  180.    data.dwSize = dwSize;
  181.    data.dwAccess = dwAccess;
  182.    data.dwEntryFlags = dwEntryFlags;
  184.    // Add PIDL
  185.    BYTE buf[ sizeof(PIDLDATA) + sizeof(ITEMIDLIST) ]; 
  186.    LPPIDLDATA pci = reinterpret_cast<LPPIDLDATA>(buf);
  187.    ::CopyMemory(pci, &data, sizeof(PIDLDATA));   
  188.    pci->cb = (WORD)sizeof(PIDLDATA);
  189.    pci->tag = PIDL_TAG;
  190.    // Terminate the IDList 
  191.    *(WORD *)(((LPBYTE)pci)+pci->cb) = 0;  
  193.    return CPidl::_Copy( (LPITEMIDLIST)pci ); 
  194. }
  196. SYSTEMTIME CFolder::_ConvertEntryTime(Entry *p)
  197. {
  198.    ATLASSERT(p);
  199.    SYSTEMTIME st;
  200.    st.wYear = (WORD)p->year;
  201.    st.wMonth = (WORD)p->month;
  202.    st.wDay = (WORD)p->days;
  203.    st.wHour = (WORD)p->hour;
  204.    st.wMinute = (WORD)p->mins;
  205.    st.wSecond = (WORD)p->secs;
  206.    st.wMilliseconds = 0;
  207.    st.wDayOfWeek = 0;
  208.    return st;
  209. }
  211. HRESULT CFolder::_CreateShellFolderView(LPVOID *ppvObj)
  212. {
  213.    ATLTRACE(_T("CFolder::_CreateShellFolderViewn"));
  214.    VALIDATE_OUT_POINTER(ppvObj);
  215.    HRESULT Hr;
  216.    CComObject<CView> *obj;
  217.    HR( CComObject<CView>::CreateInstance(&obj) );
  218.    HR( obj->_Init(this) );
  219.    return obj->QueryInterface(IID_IShellView, ppvObj);
  220. }
  222. // Bind To Parent.
  223. // Actually the W2K Shell supplies the ::SHBindToParent() function,
  224. // but we need it for other platforms too.
  225. HRESULT CFolder::_BindToParent(CComObject<CFolder> **pFolder)
  226. {
  227.    VALIDATE_OUT_POINTER(pFolder);
  228.    // Create the PIDL for the parent
  229.    CPidl pidl;
  230.    pidl.Copy(m_pidlPath);
  231.    pidl.RemoveLast();
  232.    // Bind it.
  233.    return _BindToObject(pidl, pFolder);
  234. }
  236. // Internal version of IShellFolder::BindToObject().
  237. // It allows us to bind to any folder.
  238. // The 'pidl' argument is a full PIDL path relative to the root (not desktop)!
  239. // Because we return a CComObject<CFolder> take good care to check reference count.
  240. HRESULT CFolder::_BindToObject(LPCITEMIDLIST pidl, CComObject<CFolder> **pFolder)
  241. {
  242.    ATLTRACE(_T("CFolder::_BindToObject '%s'n"), DbgGetPidlPath(pidl));
  243.    ATLASSERT(pFolder);
  244.    HRESULT Hr;
  245.    HR( CComObject<CFolder>::CreateInstance(pFolder) );
  246.    (*pFolder)->Initialize(m_pidl);  
  247.    (*pFolder)->m_pidlPath.Copy(pidl);
  248.    return S_OK;
  249. }
  251. short CFolder::_CompareItems(short iColumn, LPCPIDLDATA pData1, LPCPIDLDATA pData2)
  252. {
  253. #define COMPARE_INT(a,b) if(a!=b) return a>b ? (short)1 : (short)-1
  255.    // If data missing, default...
  256.    BOOL bIsEmpty1 = CPidl::_IsEmpty((LPCITEMIDLIST)pData1);
  257.    BOOL bIsEmpty2 = CPidl::_IsEmpty((LPCITEMIDLIST)pData2);
  258.    if( bIsEmpty1 && bIsEmpty2 ) return 0;
  259.    if( bIsEmpty1 ) return -1;
  260.    if( bIsEmpty2 ) return 1;
  261.    // Validate
  262.    ATLASSERT(pData1->tag==pData2->tag);
  263.    // Folders always come before files
  264.    if( pData1->type==PT_FOLDER && pData2->type==PT_FILE ) return -1;
  265.    if( pData1->type==PT_FILE && pData2->type==PT_FOLDER ) return 1;
  267.    // Compare item data (if data is equal, use filename to determine sort
  268.    // order).
  269.    switch( iColumn ) {
  270.    case COL_SIZE:
  271.       COMPARE_INT(pData1->dwSize, pData2->dwSize);
  272.       break;
  273.    case COL_TYPE:
  274.       return (short)_tcscmp(pData1->szType, pData2->szType);
  275.    case COL_TIME:
  276.       COMPARE_INT(pData1->ftTime.wYear, pData2->ftTime.wYear);
  277.       COMPARE_INT(pData1->ftTime.wMonth, pData2->ftTime.wMonth);
  278.       COMPARE_INT(pData1->ftTime.wDay, pData2->ftTime.wDay);
  279.       COMPARE_INT(pData1->ftTime.wHour, pData2->ftTime.wHour);
  280.       COMPARE_INT(pData1->ftTime.wMinute, pData2->ftTime.wMinute);
  281.       COMPARE_INT(pData1->ftTime.wSecond, pData2->ftTime.wSecond);
  282.       break;
  283.    case COL_ATTRIBS:
  284.       COMPARE_INT(pData1->dwAccess, pData2->dwAccess);
  285.       break;
  286.    }
  287.    return (short)_tcsicmp(pData1->szName, pData2->szName);
  289. #undef COMPARE_INT
  290. }
  293. /////////////////////////////////////////////////////////////////////////////
  294. // IShellFolder
  296. STDMETHODIMP CFolder::CreateViewObject(HWND hWnd, REFIID riid, LPVOID* ppRetVal)
  297. {
  298.    ATLTRACE(_T("CFolder::CreateViewObject %sn"), DbgGetIID(riid));
  299.    VALIDATE_OUT_POINTER(ppRetVal);
  300.    HRESULT Hr;
  302.    if( riid == IID_IDropTarget ) {
  303.       CComObject<CDropTarget> *pDropTarget;
  304.       HR( CComObject<CDropTarget>::CreateInstance(&pDropTarget) );
  305.       HR( pDropTarget->_Init(this, hWnd) );
  306.       return pDropTarget->QueryInterface(IID_IDropTarget, ppRetVal);
  307.    }
  309.    if( riid == IID_IContextMenu ) {
  310.       CComObject<CContextMenu> *pContextMenu;
  311.       HR( CComObject<CContextMenu>::CreateInstance(&pContextMenu) );
  312.       HR( pContextMenu->_Init(this, hWnd, NULL) );
  313.       return pContextMenu->QueryInterface(IID_IContextMenu, ppRetVal);
  314.    }
  316.    if( riid == IID_IShellView ) {
  317.       return _CreateShellFolderView(ppRetVal);
  318.    }
  319.    
  320.    return E_NOINTERFACE;
  321. }
  323. // Adds entries in a directory list to the PIDL list.
  324. void CFolder::_AddFolderToEnum(CPidl &pidl, List *cell, DWORD dwFlags, DWORD dwEntryFlags)
  325. {
  326.    while( cell!=NULL ) {
  327.       Entry *entry = (Entry *)cell->content;
  328.       
  329.       PIDLTYPE pidlType = PT_UNKNOWN;
  330.       switch( entry->type ) {
  331.       case ST_DIR:
  332.       case ST_LDIR:
  333.          if( dwFlags & SHCONTF_FOLDERS ) pidlType = PT_FOLDER;
  334.          break;
  335.       case ST_FILE:
  336.       case ST_LFILE:
  337.          if( dwFlags & SHCONTF_NONFOLDERS ) pidlType = PT_FILE;
  338.          break;
  339.       }
  340.       if( pidlType!=PT_UNKNOWN ) {
  341.          SYSTEMTIME st = _ConvertEntryTime(entry);
  342.          pidl.Concatenate( _CreateItem(
  343.             A2CT(entry->name), 
  344.             A2CT(entry->comment), 
  345.             pidlType, 
  346.             entry->type, 
  347.             entry->size, 
  348.             st,
  349.             entry->access,
  350.             dwEntryFlags) );
  351.       }
  352.       cell = cell->next;
  353.    }
  354. }
  356. // Adds entries in a deleted files list to the PIDL list.
  357. void CFolder::_AddDeletedToEnum(CPidl &pidl, List *cell, SECTNUM nDirSector, DWORD dwFlags, DWORD dwEntryFlags)
  358. {
  359.    while( cell!=NULL ) {
  360.       GenBlock *entry = (GenBlock *)cell->content;
  361.       cell = cell->next;
  362.       if( entry->parent != nDirSector ) continue;
  364.       PIDLTYPE pidlType = PT_UNKNOWN;
  365.       switch( entry->secType ) {
  366.       case ST_DIR:
  367.          if( dwFlags & SHCONTF_FOLDERS ) pidlType = PT_FOLDER;
  368.          break;
  369.       case ST_FILE:
  370.          if( dwFlags & SHCONTF_NONFOLDERS ) pidlType = PT_FILE;
  371.          break;
  372.       }
  373.       if( pidlType!=PT_UNKNOWN ) {
  374.          SYSTEMTIME st;
  375.          ::GetSystemTime(&st);
  376.          pidl.Concatenate( _CreateItem(
  377.             A2CT(entry->name), 
  378.             NULL, 
  379.             pidlType, 
  380.             entry->type, 
  381.             0,  // don't know the size yet
  382.             st,
  383.             0,
  384.             dwEntryFlags) );
  385.       }
  386.    }
  387. }
  389. STDMETHODIMP CFolder::EnumObjects(HWND hWnd, DWORD dwFlags, LPENUMIDLIST* ppRetVal)
  390. {
  391.    ATLTRACE(_T("CFolder::EnumObjectsn"));
  392.    VALIDATE_OUT_POINTER(ppRetVal);
  394.    // Open Amiga device.
  395.    // This is actually the first time we attempt to open the volume
  396.    // if the folder was just created.
  397.    HRESULT Hr;
  398.    CAdfDevice dev;
  399.    CAdfVolume vol;
  400.    Hr = _OpenAmigaDevice(m_pidl, TRUE, m_pidlPath, dev, vol);
  401.    if( FAILED(Hr) ) {
  402.       CResString<200> sText(IDS_DISKERROR);
  403.       CResString<64> sCaption(IDS_ERROR);
  404.       if( !m_bErrorShown ) ::MessageBox(hWnd, sText, sCaption, MB_OK|MB_ICONWARNING|MB_TASKMODAL);
  405.       m_bErrorShown = true;
  406.       return Hr;
  407.    }
  409.    CPidl pidl;
  411.    // Gather files from current directory
  412.    CAdfDirList list;
  413.    if( vol.GetCurrentDirctory(list)==FALSE ) return E_FAIL;
  414.    _AddFolderToEnum(pidl, list, dwFlags, 0);
  415.    // Check if we need to display 'deleted' files too
  416.    if( dwFlags & SHCONTF_INCLUDEDELETED ) {
  417.       // So add 'deleted' files to the list
  418.       CAdfDelList list;
  419.       if( vol.GetDeletedEntries(list)==FALSE ) return E_FAIL;
  420.       _AddDeletedToEnum(pidl, list, vol.GetDirectoryPtr(), dwFlags, EF_DELETED);
  421.    }
  423.    CComObject<CPidlEnum> *pEnum;
  424.    HR( CComObject<CPidlEnum>::CreateInstance(&pEnum) );
  425.    HR( pEnum->_Init( pidl, pidl.GetCount() ) );
  426.    HR( pEnum->QueryInterface(IID_IEnumIDList, (LPVOID *)ppRetVal) );
  428.    return S_OK;
  429. }
  431. STDMETHODIMP CFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
  432. {
  433. #ifdef _DEBUG
  434.    TCHAR szName1[MAX_PATH];
  435.    TCHAR szName2[MAX_PATH];
  436.    _tcscpy( szName1, DbgGetPidlPath(pidl1) );
  437.    _tcscpy( szName2, DbgGetPidlPath(pidl2) );
  438.    ATLTRACE(_T("CFolder::CompareIDs (%d) '%s'<-->'%s'n"), lParam, szName1, szName2);
  439. #endif
  440.    // The lParam is used to determine whether to compare items or sub-items.
  441.    // We must compare the complete ITEMIDLIST.
  442.    while( pidl1!=NULL || pidl2!=NULL ) {
  443.       short lCmd = _CompareItems((short)lParam, (LPPIDLDATA)pidl1, (LPPIDLDATA)pidl2);
  444.       if( lCmd<0 ) return MAKE_HRESULT(SEVERITY_SUCCESS, 0, USHORT(-1));
  445.       if( lCmd>0 ) return MAKE_HRESULT(SEVERITY_SUCCESS, 0, USHORT(1));
  446.       pidl1 = CPidl::_GetNextItem(pidl1);
  447.       pidl2 = CPidl::_GetNextItem(pidl2);
  448.       if( CPidl::_IsEmpty(pidl1) ) pidl1=NULL;
  449.       if( CPidl::_IsEmpty(pidl2) ) pidl2=NULL;
  450.    }
  451.    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
  452. }
  454. STDMETHODIMP CFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET lpName)
  455. {
  456.    ATLTRACE(_T("CFolder::GetDisplayNameOf (%d) '%s'n"), uFlags, DbgGetPidlPath(pidl));
  457.    ATLASSERT(CPidl::_GetCount(pidl)==1);
  459.    LPCPIDLDATA pData = pidl_cast(pidl);
  460.    LPCTSTR pstrFileName = pData->szName;
  462. #ifdef _UNICODE
  463.    USES_CONVERSION;
  464.    // Allocate the wide character string 
  465.    int cchOleStr = ::lstrlen(pstrFileName) + 1;  
  466.    lpName->pOleStr = (LPWSTR)_Module.m_Allocator.Alloc(cchOleStr * sizeof(OLECHAR)); 
  467.    if( lpName->pOleStr==NULL ) return E_OUTOFMEMORY;  
  468.    lpName->uType = STRRET_WSTR;
  469.    ocscpy( lpName->pOleStr, T2CW(pstrFileName));
  470. #else
  471.    lpName->uType = STRRET_CSTR;
  472.    _tcscpy( lpName->cStr, pstrFileName);
  473. #endif
  475.    return S_OK;
  476. }
  478. STDMETHODIMP CFolder::GetAttributesOf(UINT nCount, LPCITEMIDLIST pidls[], LPDWORD rgfInOut)
  479. {
  480.    ATLTRACE(_T("CFolder::GetAttributesOf #%d, '%s'...n"), nCount, DbgGetPidlPath(pidls==NULL ? NULL : pidls[0]));
  481.    ATLASSERT(rgfInOut);
  482.    // Parse over all pidls and OR together attributes
  483.    DWORD dwAttr = 0;
  484.    if( nCount==0 ) {
  485.       // Can happen on Win95. Queries the view folder.
  486.      dwAttr |= SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_BROWSABLE | SFGAO_DROPTARGET;
  487.    }
  488.    for( UINT i=0; i<nCount; i++ ) {
  489.       LPCPIDLDATA pData = pidl_cast(pidls[i]);
  490.       switch( pData->type ) {
  491.       case PT_FOLDER:
  492.          dwAttr |= SFGAO_FOLDER;
  493.          if( pData->dwEntryFlags & EF_DELETED ) {
  494.             dwAttr |= SFGAO_GHOSTED;
  495.          }
  496.          else {
  497.             dwAttr |= SFGAO_HASSUBFOLDER | SFGAO_BROWSABLE | SFGAO_DROPTARGET | 
  498.                       SFGAO_HASPROPSHEET |
  499.                       SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME;
  500.             if( hasW(pData->dwAccess) ) dwAttr |= SFGAO_READONLY;
  501.             if( pData->iDosType==ST_LDIR ) dwAttr |= SFGAO_LINK;
  502.          }
  503.          break;
  504.       case PT_FILE:
  505.          if( pData->dwEntryFlags & EF_DELETED ) {
  506.             dwAttr |= SFGAO_GHOSTED;
  507.          }
  508.          else {
  509.             dwAttr |= SFGAO_HASPROPSHEET |
  510.                       SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_CANDELETE | SFGAO_CANRENAME;
  511.             if( hasW(pData->dwAccess) ) dwAttr |= SFGAO_READONLY;
  512.             if( pData->iDosType==ST_LFILE ) dwAttr |= SFGAO_LINK;
  513.          }
  514.          break;
  515.       }
  516.    }
  517.    *rgfInOut = dwAttr & (*rgfInOut);
  518.    return S_OK;
  519. }
  521. STDMETHODIMP CFolder::SetNameOf(HWND, LPCITEMIDLIST pidl, LPCOLESTR pstrName, DWORD, LPITEMIDLIST *ppidlOut)
  522. {
  523.    ATLTRACE(_T("CFolder::SetNameOf '%s'n"), DbgGetPidlPath(pidl));
  524.    ATLASSERT(pidl);
  525.    ATLASSERT(pstrName);
  527.    USES_CONVERSION;
  528.    if( ppidlOut!=NULL ) *ppidlOut=NULL;
  530.    DWORD dwAttr = SFGAO_CANRENAME;
  531.    GetAttributesOf(1, &pidl, &dwAttr);
  532.    if( (dwAttr & SFGAO_CANRENAME)==0 ) return E_FAIL;
  534.    TCHAR szNewName[MAXNAMELEN+1];
  535.    if( wcslen(pstrName)>MAXNAMELEN ) return E_FAIL;
  536.    _tcscpy( szNewName, OLE2CT(pstrName));
  537.  
  538.    LPCPIDLDATA pOldData = pidl_cast(pidl);
  539.    CPidl pidlNew;
  540.    pidlNew.Attach( _CreateItem(
  541.       szNewName, 
  542.       pOldData->szComment, 
  543.       pOldData->type, 
  544.       pOldData->iDosType, 
  545.       pOldData->dwSize,
  546.       pOldData->ftTime,
  547.       pOldData->dwAccess,
  548.       pOldData->dwEntryFlags) );
  550.    HRESULT Hr;
  551.    HR( _RenameFile(pidl, pidlNew) );
  553.    if( ppidlOut!=NULL ) *ppidlOut = pidlNew.Detach();
  555.    return S_OK;
  556. }
  558. STDMETHODIMP CFolder::BindToObject(LPCITEMIDLIST pidl, LPBC, REFIID riid, LPVOID* ppRetVal)
  559. {
  560.    ATLTRACE(_T("CFolder::BindToObject '%s' %sn"), DbgGetPidlPath(pidl), DbgGetIID(riid));
  561.    VALIDATE_OUT_POINTER(ppRetVal);
  562.    
  563.    if( riid != IID_IShellFolder ) return E_NOINTERFACE;
  565.    CPidl pidlFull;
  566.    pidlFull.Copy(m_pidlPath);
  567.    pidlFull.Concatenate(pidl);
  569.    HRESULT Hr;
  570.    CComObject<CFolder> *pObj;
  571.    HR( _BindToObject(pidlFull, &pObj) );
  572.    return pObj->QueryInterface(riid, ppRetVal);
  573. }
  575. STDMETHODIMP CFolder::GetUIObjectOf(HWND hWnd, UINT nCount, LPCITEMIDLIST* pidls, REFIID riid, LPUINT, LPVOID* ppRetVal)
  576. {
  577.    ATLTRACE(_T("CFolder::GetUIObjectOf %s, #%d, '%s'...n"), DbgGetIID(riid), nCount, DbgGetPidlPath(pidls==NULL ? NULL : pidls[0]));
  578.    VALIDATE_OUT_POINTER(ppRetVal);
  579.    ATLASSERT(nCount>0);
  580.    if( nCount==0 ) return E_INVALIDARG;
  581.    HRESULT Hr;
  583.    if( riid == IID_IExtractIcon ) {
  584.       CComObject< CExtractIcon<const PIDLDATA> > *pExtractIcon;
  585.       HR( CComObject< CExtractIcon<const PIDLDATA> >::CreateInstance(&pExtractIcon) );
  586.       HR( pExtractIcon->_Init(*pidls) );
  587.       return pExtractIcon->QueryInterface(IID_IExtractIcon, ppRetVal);
  588.    }
  590.    if( riid == IID_IDropTarget ) {
  591.       if( nCount!=1 ) return E_FAIL;
  592.       // Need to create a IShellFolder for the subfolder
  593.       CComObject<CFolder> *pFolder;
  594.       CPidl pidl;
  595.       pidl.Copy(m_pidlPath);
  596.       pidl.Concatenate(pidls[0]);
  597.       HR( _BindToObject(pidl, &pFolder) );
  598.       // Do the bungy
  599.       CComObject<CDropTarget> *pDropTarget;
  600.       HR( CComObject<CDropTarget>::CreateInstance(&pDropTarget) );
  601.       HR( pDropTarget->_Init(pFolder, hWnd) );
  602.       return pDropTarget->QueryInterface(IID_IDropTarget, ppRetVal);
  603.    }
  605.    if( riid == IID_IContextMenu ) {
  606.       if( nCount!=1 ) return E_FAIL;
  607.       CComObject<CContextMenu> *pContextMenu;
  608.       HR( CComObject<CContextMenu>::CreateInstance(&pContextMenu) );
  609.       HR( pContextMenu->_Init(this, hWnd, pidls[0]) );
  610.       return pContextMenu->QueryInterface(IID_IContextMenu, ppRetVal);
  611.    }
  613.    if( riid == IID_IDataObject ) {
  614.       CComObject<CDataObject> *pDataObject;
  615.       HR( CComObject<CDataObject>::CreateInstance(&pDataObject) );
  616.       HR( pDataObject->_Init(this, hWnd, pidls, nCount) );
  617.       return pDataObject->QueryInterface(IID_IDataObject, ppRetVal);
  618.    }
  620.    return E_NOINTERFACE;
  621. }
  624. /////////////////////////////////////////////////////////////////////////////
  625. // IQueryInfo
  627. STDMETHODIMP CFolder::GetInfoFlags(DWORD *pdwFlags)
  628. {
  629.    VALIDATE_OUT_POINTER(pdwFlags);
  630.    *pdwFlags = 0;
  631.    return S_OK;
  632. }
  634. STDMETHODIMP CFolder::GetInfoTip(DWORD, LPWSTR *ppwszTip)
  635. {
  636.    VALIDATE_OUT_POINTER(ppwszTip);
  637.    CComBSTR bstr;
  638.    bstr.LoadString(IDS_INFOTIP);
  639.    *ppwszTip = (LPWSTR)_Module.m_Allocator.Alloc((bstr.Length()+1) * sizeof(WCHAR)); 
  640.    if( *ppwszTip==NULL ) return E_OUTOFMEMORY;  
  641.    USES_CONVERSION;
  642.    wcscpy(*ppwszTip, bstr);
  643.    return S_OK;
  644. }