Changeset 21639 for trunk/src


Ignore:
Timestamp:
Jun 20, 2011, 7:19:48 PM (14 years ago)
Author:
dmik
Message:

shell32: SHGetFileInfo(): Differentiate between different drive types (network, local, removable etc) when filling the type name field for paths like 'X:\'.

Location:
trunk/src/shell32
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/shell32/pidl.c

    r8614 r21639  
    5252{
    5353        BOOL bIsShellDebug;
    54        
     54
    5555        LPITEMIDLIST pidltemp = pidl;
    5656        if (!TRACE_ON(pidl))
     
    7070          MESSAGE ("PIDL: -------- pidl=%p\n", pidl);
    7171          if (pidltemp->mkid.cb)
    72           { 
     72          {
    7373            do
    7474            {
     
    189189          pidl = ODIN_ILGETNEXT(pidl);
    190190        }
    191         return pidlLast;               
     191        return pidlLast;
    192192}
    193193/*************************************************************************
     
    219219  if (!pidl)
    220220    return NULL;
    221    
     221
    222222  len = ILGetSize(pidl);
    223223  newpidl = (LPITEMIDLIST)SHAlloc(len);
     
    239239{       DWORD len;
    240240        LPITEMIDLIST pidlNew = NULL;
    241        
     241
    242242        TRACE("pidl=%p \n",pidl);
    243243        pdump(pidl);
    244        
     244
    245245        if (pidl)
    246246        {
    247           len = pidl->mkid.cb; 
     247          len = pidl->mkid.cb;
    248248          pidlNew = (LPITEMIDLIST) SHAlloc (len+2);
    249249          if (pidlNew)
     
    270270        DWORD           dwBytesRead;
    271271        HRESULT         ret = E_FAIL;
    272        
     272
    273273
    274274        TRACE_(shell)("%p %p\n", pStream ,  ppPidl);
     
    278278          *ppPidl = NULL;
    279279        }
    280        
     280
    281281        IStream_AddRef (pStream);
    282282
     
    291291          }
    292292        }
    293        
     293
    294294        /* we are not yet fully compatible */
    295295        if (!pcheck(*ppPidl))
     
    297297          *ppPidl = NULL;
    298298        }
    299        
     299
    300300
    301301        IStream_Release (pStream);
     
    315315        WORD            wLen = 0;
    316316        HRESULT         ret = E_FAIL;
    317        
     317
    318318        TRACE_(shell)("%p %p\n", pStream, pPidl);
    319319
     
    333333          }
    334334        }
    335        
     335
    336336
    337337        IStream_Release (pStream);
     
    346346 *   wraper for IShellFolder::ParseDisplayName()
    347347 */
    348 HRESULT WIN32API SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST *ppidl, 
     348HRESULT WIN32API SHILCreateFromPathA(LPCSTR path, LPITEMIDLIST *ppidl,
    349349                                     DWORD *attributes)
    350350{       LPSHELLFOLDER sf;
     
    352352        DWORD pchEaten;
    353353        HRESULT ret = E_FAIL;
    354        
     354
    355355        TRACE_(shell)("%s %p 0x%08lx\n",path,ppidl,attributes?*attributes:0);
    356356
     
    367367
    368368
    369 HRESULT WIN32API SHILCreateFromPathW(LPCWSTR path, 
    370               LPITEMIDLIST * ppidl, 
     369HRESULT WIN32API SHILCreateFromPathW(LPCWSTR path,
     370              LPITEMIDLIST * ppidl,
    371371              DWORD * attributes)
    372372{       LPSHELLFOLDER sf;
    373373        DWORD pchEaten;
    374374        HRESULT ret = E_FAIL;
    375        
     375
    376376        TRACE_(shell)("%s %p 0x%08lx\n",debugstr_w(path),ppidl,attributes?*attributes:0);
    377377
     
    392392/*************************************************************************
    393393 * SHCloneSpecialIDList [SHELL32.89]
    394  * 
     394 *
    395395 * PARAMETERS
    396  *  hwndOwner   [in] 
     396 *  hwndOwner   [in]
    397397 *  nFolder     [in]    CSIDL_xxxxx ??
    398398 *
     
    425425        if (!pidl)
    426426          return NULL;
    427    
     427
    428428        len = ILGetSize(pidl);
    429429        newpidl = (LPITEMIDLIST)pCOMCTL32_Alloc(len);
     
    459459
    460460        if ( (!pidl1) || (!pidl2) ) return FALSE;
    461        
     461
    462462        while (pidl1->mkid.cb && pidl2->mkid.cb)
    463463        {
     
    465465            if (pidl1->mkid.cb != pidl2->mkid.cb)
    466466              return FALSE;
    467          
     467
    468468//          _ILSimpleGetText(pidltemp1, szData1, MAX_PATH);
    469469//          _ILSimpleGetText(pidltemp2, szData2, MAX_PATH);
     
    476476            pidl2 = ODIN_ILGETNEXT(pidl2);
    477477        }
    478  
     478
    479479        if (!pidl1->mkid.cb && !pidl2->mkid.cb)
    480480        {
     
    499499        LPITEMIDLIST pParent = pidlParent;
    500500        LPITEMIDLIST pChild = pidlChild;
    501        
     501
    502502        TRACE("%p %p %x\n", pidlParent, pidlChild, bImmediate);
    503503
     
    513513          pParent = ODIN_ILGETNEXT(pParent);
    514514          pChild = ODIN_ILGETNEXT(pChild);
    515         }       
    516        
     515        }
     516
    517517        if ( pParent->mkid.cb || ! pChild->mkid.cb)     /* child shorter or has equal length to parent */
    518518          return FALSE;
    519        
     519
    520520        if ( ODIN_ILGETNEXT(pChild)->mkid.cb && bImmediate)     /* not immediate descent */
    521521          return FALSE;
    522        
     522
    523523        return TRUE;
    524524}
     
    572572            pidltemp1 = ODIN_ILGETNEXT(pidltemp1);
    573573            pidltemp2 = ODIN_ILGETNEXT(pidltemp2);
    574             ret = pidltemp2;   
     574            ret = pidltemp2;
    575575          }
    576576
     
    596596        DWORD    len1,len2;
    597597        LPITEMIDLIST  pidlNew;
    598        
     598
    599599
    600600        if(!pidl1 && !pidl2) return NULL;
     
    637637{
    638638  dprintf(("not yet implemented"));
    639  
     639
    640640        FIXME("sf=%p pidl=%p 0x%04lx\n",lpsf,pidl,z);
    641641
     
    654654{
    655655  dprintf(("not yet implemented"));
    656  
     656
    657657        FIXME("(pidl=%p)\n",pidl);
    658658
     
    679679  LPSHITEMID si = &(pidl->mkid);
    680680  DWORD  len=0;
    681  
     681
    682682  // @@@PH this cannot be correct: pidl==NULL would crash!
    683683  if (pidl)
    684   { 
     684  {
    685685    while (si->cb)
    686     { 
     686    {
    687687      len += si->cb;
    688688      si  = (LPSHITEMID)(((LPBYTE)si)+si->cb);
     
    740740        pdump (pidl);
    741741        pdump (item);
    742        
     742
    743743        if (_ILIsDesktop(pidl))
    744744        {
     
    771771DWORD ILFree(LPITEMIDLIST pidl)
    772772{
    773   if(!pidl) 
     773  if(!pidl)
    774774    return FALSE;
    775775  SHFree(pidl);
     
    815815        return FALSE;
    816816}
    817 LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path) 
     817LPITEMIDLIST WINAPI ILCreateFromPathAW (LPCVOID path)
    818818{
    819819        if ( SHELL_OsIsUnicode())
     
    875875 * gets the folder locations from the registry and creates a pidl
    876876 * creates missing reg keys and directorys
    877  * 
     877 *
    878878 * PARAMS
    879879 *   hwndOwner [I]
     
    966966{
    967967        TRACE_(shell)("sf=%p pidl=%p 0x%04x %p 0x%04x stub\n",psf,pidl,nFormat,dest,len);
    968        
     968
    969969        pdump(pidl);
    970970        if (!psf || !dest )  return E_INVALIDARG;
     
    10511051 *
    10521052 * PARAMETERS
    1053  *  pidl,   [IN] pidl 
     1053 *  pidl,   [IN] pidl
    10541054 *  pszPath [OUT] path
    10551055 *
    1056  * RETURNS 
     1056 * RETURNS
    10571057 *  path from a passed PIDL.
    10581058 *
     
    10791079        if(_ILIsDesktop(pidl))
    10801080        {
    1081            SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE); 
     1081           SHGetSpecialFolderPathA(0, pszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
    10821082        }
    10831083        else if (_ILIsSpecialFolder(ILFindLastID(pidl)))
     
    11291129        LPITEMIDLIST    pidlChild, pidlParent;
    11301130        HRESULT         hr=E_FAIL;
    1131        
     1131
    11321132        TRACE_(shell)("pidl=%p\n", pidl);
    11331133        pdump(pidl);
    1134        
     1134
    11351135        *ppv = NULL;
    11361136        if (ppidlLast) *ppidlLast = NULL;
     
    11391139        {
    11401140          /* we are on desktop level */
    1141           if (ppidlLast) 
     1141          if (ppidlLast)
    11421142            *ppidlLast = ILClone(pidl);
    11431143          hr = SHGetDesktopFolder((IShellFolder**)ppv);
     
    11921192 *  _ILCreateMyComputer()
    11931193 *  _ILCreateDrive()
    1194  *  _ILCreateFolder() 
     1194 *  _ILCreateFolder()
    11951195 *  _ILCreateValue()
    11961196 */
     
    12451245        ULONG   len, len1;
    12461246        LPITEMIDLIST pidl;
    1247        
     1247
    12481248        TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    12491249
     
    12651265
    12661266        pidl = _ILCreate(PT_FOLDER, (LPVOID)buff, len + len1);
    1267        
     1267
    12681268        /* set attributes */
    12691269        if (pidl)
     
    12851285        ULONG   len, len1;
    12861286        LPITEMIDLIST pidl;
    1287        
     1287
    12881288        TRACE("(%s, %s)\n",stffile->cAlternateFileName, stffile->cFileName);
    12891289
     
    13051305
    13061306        pidl = _ILCreate(PT_VALUE, (LPVOID)buff, len + len1);
    1307        
     1307
    13081308        /* set attributes */
    13091309        if (pidl)
     
    13441344        UINT           uSize = 0;
    13451345        LPSTR   pszDest;
    1346        
     1346
    13471347        TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
    13481348
     
    13601360            break;
    13611361          case PT_FOLDER:
    1362           case PT_VALUE:   
     1362          case PT_VALUE:
    13631363            uSize = 2 + 12 + uInSize;
    13641364            break;
    13651365          default:
    1366             FIXME("can't create type: 0x%08x\n",type); 
     1366            FIXME("can't create type: 0x%08x\n",type);
    13671367            return NULL;
    13681368        }
     
    13951395
    13961396          case PT_FOLDER:
    1397           case PT_VALUE:   
     1397          case PT_VALUE:
    13981398            pData =_ILGetDataPointer(pidlOut);
    13991399            pData->type = type;
     
    14031403            break;
    14041404        }
    1405        
     1405
    14061406        pidlTemp = ODIN_ILGETNEXT(pidlOut);
    14071407        if (pidlTemp)
     
    14651465        LPPIDLDATA lpPData = _ILGetDataPointer(pidl);
    14661466        TRACE("(%p)\n",pidl);
    1467         return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) || 
     1467        return (pidl && ( (lpPData && (PT_MYCOMP== lpPData->type || PT_SPECIAL== lpPData->type)) ||
    14681468                          (pidl && pidl->mkid.cb == 0x00)
    14691469                        ));
     
    15241524DWORD _ILSimpleGetText (LPCITEMIDLIST pidl, LPSTR szOut, UINT uOutSize)
    15251525{
    1526         DWORD           dwReturn=0; 
     1526        DWORD           dwReturn=0;
    15271527        LPSTR           szSrc;
    15281528        GUID const *    riid;
    15291529        char szTemp[MAX_PATH];
    1530        
     1530
    15311531        TRACE("(%p %p %x)\n",pidl,szOut,uOutSize);
    1532        
     1532
    15331533        if (!pidl) return 0;
    15341534
     
    15361536          *szOut = 0;
    15371537
    1538         if (_ILIsDesktop(pidl))                                 
     1538        if (_ILIsDesktop(pidl))
    15391539        {
    15401540         /* desktop */
     
    15881588  LPSTR lpText1;
    15891589  LPSTR lpText2;
    1590  
     1590
    15911591  char szTemp1[MAX_PATH];
    15921592  char szTemp2[MAX_PATH];
    15931593  GUID const *  riid;
    1594  
     1594
    15951595
    15961596  if (!pidl1 && !pidl2)
    15971597    return 0;
    1598  
     1598
    15991599  if (!pidl1 && pidl2)
    16001600    return -1;
    1601  
     1601
    16021602  if (pidl1 && !pidl2)
    16031603    return 1;
    1604  
    1605  
     1604
     1605
    16061606  // -------------
    16071607  // examine pidl1
     
    16261626      else
    16271627        lpText1 = "undetermined";
    1628  
     1628
    16291629  // -------------
    16301630  // examine pidl2
     
    16491649      else
    16501650        lpText2 = "undetermined";
    1651  
    1652  
     1651
     1652
    16531653  // now finally compare the texts
    16541654  return strcasecmp(lpText1, lpText2);
     
    17701770 *
    17711771 * NOTES
    1772  *     
     1772 *
    17731773 */
    17741774BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
     
    17791779
    17801780    switch (pdata->type)
    1781     { 
     1781    {
    17821782        case PT_FOLDER:
    17831783            DosDateTimeToFileTime(pdata->u.folder.uFileDate, pdata->u.folder.uFileTime, pFt);
    1784             break;         
     1784            break;
    17851785        case PT_VALUE:
    17861786            DosDateTimeToFileTime(pdata->u.file.uFileDate, pdata->u.file.uFileTime, pFt);
     
    17931793
    17941794BOOL _ILGetFileDate (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
    1795 {       
     1795{
    17961796        FILETIME ft,lft;
    17971797        SYSTEMTIME time;
    17981798
    17991799        if (! _ILGetFileDateTime( pidl, &ft )) return FALSE;
    1800        
     1800
    18011801        FileTimeToLocalFileTime(&ft, &lft);
    18021802        FileTimeToSystemTime (&lft, &time);
     
    18191819 * NOTES
    18201820 *      pOut can be null when no string is needed
    1821  *     
     1821 *
    18221822 */
    18231823DWORD _ILGetFileSize (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
     
    18251825        LPPIDLDATA pdata =_ILGetDataPointer(pidl);
    18261826        DWORD dwSize;
    1827        
     1827
    18281828        if(! pdata) return 0;
    18291829
     
    18441844        const char * pPoint;
    18451845        LPITEMIDLIST  pidlTemp=pidl;
    1846        
     1846
    18471847        TRACE("pidl=%p\n",pidl);
    18481848
    18491849        if (!pidl) return FALSE;
    1850        
     1850
    18511851        pidlTemp = ILFindLastID(pidl);
    1852        
     1852
    18531853        if (!_ILIsValue(pidlTemp)) return FALSE;
    18541854        if (!_ILSimpleGetText(pidlTemp, szTemp, MAX_PATH)) return FALSE;
     
    18791879 *
    18801880 * NOTES
    1881  *      This function copies as much as possible into the buffer. 
     1881 *      This function copies as much as possible into the buffer.
    18821882 */
    18831883void _ILGetFileType(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
     
    18851885        if(_ILIsValue(pidl))
    18861886        {
    1887           char sTemp[64];
    1888           if(uOutSize > 0)
    1889           {
    1890             pOut[0] = 0;
    1891           }
    1892           if (_ILGetExtension (pidl, sTemp, 64))
    1893           {
    1894             if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
    1895                 && HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
    1896             {
    1897               lstrcpynA (pOut, sTemp, uOutSize - 6);
    1898               strcat (pOut, "-file");
    1899             }
    1900           }
     1887                char sTemp[64];
     1888                if(uOutSize > 0)
     1889                {
     1890                        pOut[0] = 0;
     1891                }
     1892                if (_ILGetExtension (pidl, sTemp, 64))
     1893                {
     1894                        if (!( HCR_MapTypeToValue(sTemp, sTemp, 64, TRUE)
     1895                                   && HCR_MapTypeToValue(sTemp, pOut, uOutSize, FALSE )))
     1896                        {
     1897                                lstrcpynA (pOut, sTemp, uOutSize - 6);
     1898                                strupr (pOut);
     1899                                strcat (pOut, " File");
     1900                        }
     1901                }
    19011902        }
    19021903        else
    19031904        {
    1904           lstrcpynA(pOut, "Folder", uOutSize);
     1905                LPPIDLDATA pdata =_ILGetDataPointer(pidl);
     1906
     1907                if (pdata)
     1908                {
     1909                        switch (pdata->type)
     1910                        {
     1911                                case PT_DRIVE:
     1912                                case PT_DRIVE1:
     1913                                case PT_DRIVE2:
     1914                                case PT_DRIVE3:
     1915                                {
     1916                                        UINT type =
     1917                                                GetDriveTypeA((LPSTR)&(pdata->u.drive.szDriveName));
     1918                                                GetDriveTypeA(_ILGetTextPointer(pidl));
     1919                                        switch (type)
     1920                                        {
     1921                                                case DRIVE_REMOVABLE:
     1922                                                        lstrcpynA(pOut, "Removable Disk", uOutSize); return;
     1923                                                case DRIVE_FIXED:
     1924                                                        lstrcpynA(pOut, "Local Disk", uOutSize); return;
     1925                                                case DRIVE_REMOTE:
     1926                                                        lstrcpynA(pOut, "Network Drive", uOutSize); return;
     1927                                                case DRIVE_CDROM:
     1928                                                        lstrcpynA(pOut, "CD Disk", uOutSize); return;
     1929                                                default:
     1930                                                        break;
     1931                                        }
     1932                                }
     1933                                default:
     1934                                        break;
     1935                        }
     1936                }
     1937
     1938                lstrcpynA(pOut, "File Folder", uOutSize);
    19051939        }
    19061940}
     
    19211955 * FIXME
    19221956 *  return value 0 in case of error is a valid return value
    1923  *     
     1957 *
    19241958 */
    19251959DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize)
     
    19401974            break;
    19411975        }
    1942        
     1976
    19431977        if(uOutSize >= 6)
    19441978        {
  • trunk/src/shell32/shell32_main.c

    r21637 r21639  
    202202            {
    203203                lstrcpynA (psfi->szTypeName, sTemp, 80 - 6);
    204                 strcat (psfi->szTypeName, "-file");
     204                strupr (pOut);
     205                strcat (psfi->szTypeName, " File");
    205206            }
    206207        }
Note: See TracChangeset for help on using the changeset viewer.