filemanager/src/inc/fmdrivemodel.cpp
changeset 37 15bc28c9dd51
parent 16 ada7962b4308
equal deleted inserted replaced
16:ada7962b4308 37:15bc28c9dd51
    20 #include "fmutils.h"
    20 #include "fmutils.h"
    21 
    21 
    22 #include <QDir>
    22 #include <QDir>
    23 #include <QFileInfo>
    23 #include <QFileInfo>
    24 
    24 
    25 FmDriveModel::FmDriveModel( QObject *parent, Options options ) :
    25 #include <hbglobal.h>
    26     QAbstractListModel( parent ), mOptions( options )
    26 
       
    27 FmDriveModel::FmDriveModel( QObject *parent, Options options,
       
    28         FmDriveListProvider *driveListProvider ) :
       
    29     QAbstractListModel( parent ), mOptions( options ), mDriveListProvider( driveListProvider )
    27 {
    30 {
    28     mIconProvider = new FmFileIconProvider();
    31     mIconProvider = new FmFileIconProvider();
    29     refresh();
    32     refresh();
    30 }
    33 }
    31 
    34 
    34     delete mIconProvider;
    37     delete mIconProvider;
    35 }
    38 }
    36 
    39 
    37 void FmDriveModel::refresh()
    40 void FmDriveModel::refresh()
    38 {
    41 {
    39     QFileInfoList infoList = QDir::drives();
    42     emit layoutAboutToBeChanged();
       
    43     mDriveList.clear();
       
    44     
       
    45     // if mDriveListProvider existed, use it to fetch drive list
       
    46     // otherwise use FmUtils::getDriveList to fetch drive list.
       
    47     if( mDriveListProvider ) {
       
    48         mDriveListProvider->getDriveList( mDriveList );
       
    49     } else {
       
    50         if( mOptions & HideUnAvailableDrive ) {
       
    51             FM_LOG( QString( "FmDriveModel::refresh HideUnAvailableDrive_true" ) );
       
    52             FmUtils::getDriveList( mDriveList, true );
       
    53         } else {
       
    54             FM_LOG( QString( "FmDriveModel::refresh HideUnAvailableDrive_false" ) );
       
    55             FmUtils::getDriveList( mDriveList, false );
       
    56         }
       
    57     }
    40 
    58 
    41     mDriveList.clear();
    59 	emit layoutChanged();
    42     if( mOptions & HideUnAvailableDrive ) {
    60 	for( int i=0; i<mDriveList.count(); i++ ) {
    43         FmLogger::log( QString( "FmDriveModel::refresh HideUnAvailableDrive_true" ) );
    61         emit dataChanged(index( i, 0 ), index( i, 0 ));
    44         FmUtils::getDriveList( mDriveList, true );
    62 	}
    45     } else {
       
    46         FmLogger::log( QString( "FmDriveModel::refresh HideUnAvailableDrive_false" ) );
       
    47         FmUtils::getDriveList( mDriveList, false );
       
    48     }
       
    49     emit layoutChanged();
       
    50 }
    63 }
    51 
    64 
    52 
    65 
    53 int FmDriveModel::rowCount( const QModelIndex &parent ) const
    66 int FmDriveModel::rowCount( const QModelIndex &parent ) const
    54 {
    67 {
    69     if (!indexValid( index ))
    82     if (!indexValid( index ))
    70         return QVariant();
    83         return QVariant();
    71 
    84 
    72     if (role == Qt::DisplayRole ) {
    85     if (role == Qt::DisplayRole ) {
    73        return displayString( index );
    86        return displayString( index );
    74     } else if (role == Qt::UserRole ) {
    87     } 
    75        return driveName( index );
       
    76     }
       
    77 
       
    78     if (index.column() == 0) {
    88     if (index.column() == 0) {
    79         if (role == Qt::DecorationRole ) {
    89         if (role == Qt::DecorationRole ) {
    80             QString path = driveName( index );
    90             QString path = driveName( index );
    81             return mIconProvider->icon( QFileInfo( path ) );
    91             return mIconProvider->icon( QFileInfo( path ) );
    82         }
    92         }
    95     if (orientation == Qt::Horizontal) {
   105     if (orientation == Qt::Horizontal) {
    96         if (role != Qt::DisplayRole)
   106         if (role != Qt::DisplayRole)
    97             return QVariant();
   107             return QVariant();
    98 
   108 
    99         switch (section) {
   109         switch (section) {
   100             case 0: return tr("Name");
   110             case 0: return hbTrId("Name");
   101             case 1: return tr("Size");
   111             case 1: return hbTrId("Size");
   102             case 2: return tr("Type");
   112             case 2: return hbTrId("Type");
   103             case 3: return tr("Date Modified");
   113             case 3: return hbTrId("Date Modified");
   104             default: return QVariant();
   114             default: return QVariant();
   105         }
   115         }
   106     }
   116     }
   107 
   117 
   108     return QAbstractItemModel::headerData( section, orientation, role );
   118     return QAbstractItemModel::headerData( section, orientation, role );
   124         data = diskName;
   134         data = diskName;
   125     }
   135     }
   126     return data;
   136     return data;
   127 }
   137 }
   128 
   138 
   129 QString FmDriveModel::displayString( const QModelIndex &index ) const
   139 QVariant FmDriveModel::displayString( const QModelIndex &index ) const
   130 {
   140 {
   131     QString data;
   141     QStringList data;
   132     if (index.row() >= 0 && index.row() < mDriveList.size()) {
   142     if (index.row() >= 0 && index.row() < mDriveList.size()) {
   133         int row = index.row();
   143         int row = index.row();
   134         QString diskName = mDriveList[ row ];
   144         QString diskName = mDriveList[ row ];
   135 
   145 
   136         if( mOptions & FillWithVolume ) {
   146         if( mOptions & FillWithVolume ) {
   137             data = FmUtils::fillDriveVolume( diskName, mOptions & FillWithDefaultVolume );
   147             data << FmUtils::fillDriveVolume( diskName, mOptions & FillWithDefaultVolume );
   138         } else {
   148         } else {
   139             data = FmUtils::removePathSplash( diskName );
   149             data << FmUtils::removePathSplash( diskName );
       
   150         }
       
   151         diskName = FmUtils::fillPathWithSplash( diskName );
       
   152         FmDriverInfo driverInfo = FmUtils::queryDriverInfo( diskName );
       
   153         if ( mOptions & FillWithTotalSize ) {                    
       
   154             if( driverInfo.driveState() & FmDriverInfo::EDriveAvailable ) {
       
   155                 data << QString( hbTrId ( "Size: " ) + FmUtils::formatStorageSize( driverInfo.size() ) );                
       
   156             } else if( driverInfo.driveState() & FmDriverInfo::EDriveLocked ) {
       
   157                 data << QString( hbTrId ( "Locked" ) );                
       
   158             } else if( driverInfo.driveState() & FmDriverInfo::EDriveCorrupted ) {
       
   159                 data << QString( hbTrId ( "Corrupted" ) );                
       
   160             } else if( driverInfo.driveState() & FmDriverInfo::EDriveNotPresent ) {
       
   161                 data << QString( hbTrId ( "Not Ready" ) );                
       
   162             }            
       
   163         }
       
   164         if ( mOptions & FillWithFreeSize ) {        
       
   165             if( driverInfo.driveState() & FmDriverInfo::EDriveAvailable ) {                
       
   166                 data << QString( hbTrId ( "Free: " ) + FmUtils::formatStorageSize( driverInfo.freeSize() ) );
       
   167             } else if( ( driverInfo.driveState() & FmDriverInfo::EDriveLocked ) ||
       
   168                     ( driverInfo.driveState() & FmDriverInfo::EDriveCorrupted ) ||
       
   169                     ( driverInfo.driveState() & FmDriverInfo::EDriveNotPresent )) {                
       
   170                 data << QString( QString(" ") );
       
   171             }            
   140         }
   172         }
   141     }
   173     }
   142     return data;
   174     return data;
   143 }
   175 }