filemanager/src/inc/fmfileiconprovider.cpp
changeset 25 b7bfdea70ca2
parent 16 ada7962b4308
child 33 328cf6fbe40c
equal deleted inserted replaced
16:ada7962b4308 25:b7bfdea70ca2
    14 * Description: filemanager file icon provider source file 
    14 * Description: filemanager file icon provider source file 
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include "fmfileiconprovider.h"
    18 #include "fmfileiconprovider.h"
       
    19 #include "fmfiletyperecognizer.h"
    19 #include "fmutils.h"
    20 #include "fmutils.h"
    20 
    21 
    21 #include <QDir>
    22 #include <QDir>
    22 #include <QFileInfo>
    23 #include <QFileInfo>
    23 
    24 
    24 #define mmcIcon         ":image/qgn_prop_mmc_memc.svg"
    25 #include "hbicon.h"
    25 #define mmcNoneIcon     ":image/qgn_prop_fmgr_mmc_no_sub.svg"
    26 
       
    27 //#define mmcIcon         ":image/qgn_prop_mmc_memc.svg"
       
    28 //#define mmcNoneIcon     ":image/qgn_prop_fmgr_mmc_no_sub.svg"
       
    29 //#define mmcLockedIcon   ":image/qgn_prop_mmc_locked.svg"
       
    30 //#define phoneMemoryIcon ":image/qgn_prop_phone_memc.svg"
       
    31 //#define usbMemoryIcon   ":image/qgn_prop_usb_memc.svg"
       
    32 //#define massMemoryIcon  ":image/qgn_prop_fmgr_ms.svg"
       
    33 
       
    34 #define phoneMemoryIcon "qtg_large_mobile"
       
    35 #define massMemoryIcon  "qtg_large_mass_storage"
       
    36 #define mmcIcon         "qtg_large_mmc"
       
    37 #define mmcNoneIcon     "qtg_large_mmc_removed"
       
    38 #define usbMemoryIcon   "qtg_large_usb_memory"
       
    39 
       
    40 //TODO: UI_Update: mmcl locked icon have not provided in icon spec
       
    41 // Just use orignal custom-defined icon
    26 #define mmcLockedIcon   ":image/qgn_prop_mmc_locked.svg"
    42 #define mmcLockedIcon   ":image/qgn_prop_mmc_locked.svg"
    27 #define phoneMemoryIcon ":image/qgn_prop_phone_memc.svg"
    43 
    28 #define usbMemoryIcon   ":image/qgn_prop_usb_memc.svg"
    44 
    29 #define massMemoryIcon  ":image/qgn_prop_fmgr_ms.svg"
    45 #define folderIcon      "qtg_large_folder"
       
    46 
       
    47 #define imageIcon       "qtg_large_photos" 
       
    48 #define videoIcon       "qtg_large_video" 
       
    49 #define toneIcon        "qtg_large_tone"
       
    50 #define playlistIcon    "qtg_large_playlist" 
       
    51 #define textIcon        "qtg_large_text" 
       
    52 #define sisxIcon        "qtg_large_sisx" 
       
    53 #define javaIcon        "qtg_large_java" 
       
    54 #define flashIcon       "qtg_large_flash" 
       
    55 #define widgetIcon      "qtg_large_widget" 
       
    56 #define weblinkIcon     "qtg_large_web_link" 
       
    57 #define queryIcon       "qtg_large_query"
    30 
    58 
    31 FmFileIconProvider::FmFileIconProvider()
    59 FmFileIconProvider::FmFileIconProvider()
    32 {
    60 {
    33 
    61     mFileTypeRecognizer = new FmFileTypeRecognizer();
    34 }
    62 }
    35 
    63 
    36 FmFileIconProvider::~FmFileIconProvider()
    64 FmFileIconProvider::~FmFileIconProvider()
    37 {
    65 {
       
    66     delete mFileTypeRecognizer;
    38 }
    67 }
    39 
    68         
    40 QIcon FmFileIconProvider::icon(const QFileInfo &info) const
    69 QIcon FmFileIconProvider::icon(const QFileInfo &info) const
    41 {
    70 {
    42     QString filePath( info.path() );
    71     QIcon retIcon;
    43     if( FmUtils::isDrive( filePath ) ) {
    72     
    44         FmDriverInfo::DriveState driveState = FmUtils::queryDriverInfo( filePath ).driveState();
    73     QString filePath( info.absoluteFilePath() );
    45         if( driveState & FmDriverInfo::EDriveAvailable ){
    74     FmFileTypeRecognizer::FileType fileType = mFileTypeRecognizer->getType( filePath );
    46             if( driveState & FmDriverInfo::EDriveRemovable ) {
    75     switch( fileType )
    47                 if( driveState & FmDriverInfo::EDriveMassStorage ) {
    76         {
    48                     // Mass Storage
    77         case FmFileTypeRecognizer::FileTypeDrive:
    49                     return QIcon( massMemoryIcon );
    78             {
       
    79             FmDriverInfo::DriveState driveState = FmUtils::queryDriverInfo( filePath ).driveState();
       
    80             if( driveState & FmDriverInfo::EDriveAvailable ){
       
    81                 if( driveState & FmDriverInfo::EDriveRemovable ) {
       
    82                     if( driveState & FmDriverInfo::EDriveMassStorage ) {
       
    83                         // Mass Storage
       
    84                         retIcon = HbIcon( massMemoryIcon ).qicon();
       
    85                         break;
       
    86                     } else if( driveState & FmDriverInfo::EDriveUsbMemory ) {
       
    87                         // Usb Memory
       
    88                         retIcon = HbIcon( usbMemoryIcon ).qicon();
       
    89                         break;
       
    90                     } else{
       
    91                         //Memory Card
       
    92                         retIcon = HbIcon( mmcIcon ).qicon();
       
    93                         break;
       
    94                     }
       
    95                 } else{
       
    96                     //Phone Memory
       
    97                     retIcon = HbIcon( phoneMemoryIcon ).qicon();
       
    98                     break;
    50                 }
    99                 }
    51                 else{
   100             } else if( driveState & FmDriverInfo::EDriveLocked ) {
    52                     //Memory Card
   101                 retIcon = HbIcon( mmcLockedIcon ).qicon();
    53                     return QIcon( mmcIcon );
   102                 break;
    54                 }
   103             } else if( driveState & FmDriverInfo::EDriveCorrupted ) {
    55             } else{
   104                 retIcon = HbIcon( mmcNoneIcon ).qicon();
    56                 //Phone Memory
   105                 break;
    57                 return QIcon( phoneMemoryIcon );
   106             } else if( driveState & FmDriverInfo::EDriveNotPresent ){
       
   107                 retIcon = HbIcon( mmcNoneIcon ).qicon();
       
   108                 break;
       
   109             } else {
       
   110                 retIcon = HbIcon( mmcNoneIcon ).qicon();
       
   111                 break;
    58             }
   112             }
    59         } else if( driveState & FmDriverInfo::EDriveLocked ) {
   113             }
    60             return QIcon( mmcLockedIcon );
   114         case FmFileTypeRecognizer::FileTypeFolder:
    61         } else if( driveState & FmDriverInfo::EDriveCorrupted ) {
   115             {
    62             return QIcon( mmcNoneIcon );
   116             retIcon = HbIcon( folderIcon ).qicon();
    63         } else if( driveState & FmDriverInfo::EDriveNotPresent ){
   117             break;
    64             return QIcon( mmcNoneIcon );
   118             }
    65         } else {
   119         case FmFileTypeRecognizer::FileTypeImage:
    66             return QIcon( mmcNoneIcon );
   120             {
       
   121             retIcon = HbIcon( imageIcon ).qicon();
       
   122             break;
       
   123             }
       
   124         case FmFileTypeRecognizer::FileTypeVideo:
       
   125             {
       
   126             retIcon = HbIcon( videoIcon ).qicon();
       
   127             break;
       
   128             }
       
   129         case FmFileTypeRecognizer::FileTypeTone:
       
   130             {
       
   131             retIcon = HbIcon( toneIcon ).qicon();
       
   132             break;
       
   133             }
       
   134         case FmFileTypeRecognizer::FileTypePlaylist:
       
   135             {
       
   136             retIcon = HbIcon( playlistIcon ).qicon();
       
   137             break;
       
   138             }
       
   139         case FmFileTypeRecognizer::FileTypeText:
       
   140             {
       
   141             retIcon = HbIcon( textIcon ).qicon();
       
   142             break;
       
   143             }
       
   144         case FmFileTypeRecognizer::FileTypeSisx:
       
   145             {
       
   146             retIcon = HbIcon( sisxIcon ).qicon();
       
   147             break;
       
   148             }
       
   149         case FmFileTypeRecognizer::FileTypeJava:
       
   150             {
       
   151             retIcon = HbIcon( javaIcon ).qicon();
       
   152             break;
       
   153             }
       
   154         case FmFileTypeRecognizer::FileTypeFlash:
       
   155             {
       
   156             retIcon = HbIcon( flashIcon ).qicon();
       
   157             break;
       
   158             }
       
   159         case FmFileTypeRecognizer::FileTypeWidget:
       
   160             {
       
   161             retIcon = HbIcon( widgetIcon ).qicon();
       
   162             break;
       
   163             }
       
   164         case FmFileTypeRecognizer::FileTypeWebLink:
       
   165             {
       
   166             retIcon = HbIcon( weblinkIcon ).qicon();
       
   167             break;
       
   168             }
       
   169         case FmFileTypeRecognizer::FileTypeUnKnown:
       
   170             {
       
   171             // currently filemanger icon doc is not unified with icon name.
       
   172             // for example, qtg_small_unknown  qtg_large_query both means for unknown type
       
   173 			// but the two icon name is not the same.
       
   174             retIcon = HbIcon( queryIcon ).qicon();
       
   175             break;
       
   176             }
    67         }
   177         }
    68     } else {
   178     
    69         return QFileIconProvider::icon( info );
   179     // if cannot get icon, return icon from QFileIconProvider
       
   180     // this will be mostly used in win32 platform,
       
   181     // because path for HbIcon only existed in hb theme of symbian 
       
   182     if( retIcon.isNull() ) {
       
   183         retIcon = QFileIconProvider::icon( info );
    70     }
   184     }
       
   185     return retIcon;
    71 }
   186 }