Mercurial Mercurial > oss > FCL > sf > app > files / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
filemanager/src/fmbkupenginewrapper/src/fmbackupsettings.cpp
changeset 37 15bc28c9dd51
parent 16 ada7962b4308
child 46 d58987eac7e8
equal deleted inserted replaced
16:ada7962b4308 37:15bc28c9dd51 
    23 #include <QString>
 
    23 #include <QString>
 
    24 #include <QStringList>
 
    24 #include <QStringList>
 
    25 #include <QTime>
 
    25 #include <QTime>
 
    26 #include <QSettings>
 
    26 #include <QSettings>
 
    27 
    27 
       
    28 #include <hbglobal.h>
 
       
    29 
    28 FmBackupSettings::FmBackupSettings( FmBkupEngine *aFmBkupEngine ) : mBkupEngine( aFmBkupEngine )
 
    30 FmBackupSettings::FmBackupSettings( FmBkupEngine *aFmBkupEngine ) : mBkupEngine( aFmBkupEngine )
 
    29 {
 
    31 {
 
    30     
    32     
    31 }
 
    33 }
 
    32 
    34 
    86 }
 
    88 }
 
    87 
    89 
    88 QString FmBackupSettings::targetDrive() const
 
    90 QString FmBackupSettings::targetDrive() const
 
    89 {
 
    91 {
 
    90     return mTargetDrive;
 
    92     return mTargetDrive;
 
       
    93 }
 
       
    94 
       
    95 QString FmBackupSettings::availableTargetDrive() const
 
       
    96 {
 
       
    97     QString targetDrive;
 
       
    98     QStringList driveList;
 
       
    99     mBkupEngine->getBackupDriveList( driveList );
 
       
   100     if( !driveList.isEmpty() ) {
 
       
   101         if( driveList.contains( mTargetDrive ) ) {
 
       
   102             targetDrive =  mTargetDrive;
 
       
   103         } else {
 
       
   104             targetDrive = driveList.first();
 
       
   105         }
 
       
   106     }
 
       
   107     return targetDrive;
 
    91 }
 
   108 }
 
    92 
   109 
    93 int FmBackupSettings::contentsSelected() const
 
   110 int FmBackupSettings::contentsSelected() const
 
    94 {
 
   111 {
 
    95     int ret( 0 );
 
   112     int ret( 0 );
 
   113 FmBackupEntry* FmBackupSettings::createContentsEntry()
 
   130 FmBackupEntry* FmBackupSettings::createContentsEntry()
 
   114 {
 
   131 {
 
   115     QString title;
 
   132     QString title;
 
   116     QString tips;
 
   133     QString tips;
 
   117 
   134 
   118     title = constFileManagerBackupSettingsTitleContents;
 
   135     title = hbTrId( "Backup Contents" );
 
   119 
   136 
   120     int selected( contentsSelected() );
 
   137     int selected( contentsSelected() );
 
   121     if ( !( mContent & EFileManagerBackupContentAll ) && selected > 1 ){
 
   138     if ( !( mContent & EFileManagerBackupContentAll ) && selected > 1 ){
 
   122         // create text as " 5 selected"
 
   139         // create text as " 5 selected"
 
   123         tips = QString( QString::number(selected) + " selected" );
 
   140         tips = QString( QString::number(selected) + " selected" );
 
   134 FmBackupEntry* FmBackupSettings::createSchedulingEntry()
 
   151 FmBackupEntry* FmBackupSettings::createSchedulingEntry()
 
   135 {
 
   152 {
 
   136     QString title;
 
   153     QString title;
 
   137     QString tips;
 
   154     QString tips;
 
   138 
   155 
   139     title = constFileManagerBackupSettingsTitleScheduling;
 
   156     title = hbTrId( "Backup scheduling" );
 
   140     tips  = schedulingToString( mScheduling );
 
   157     tips  = schedulingToString( mScheduling );
 
   141 
   158 
   142     return CreateEntry( title, tips, FmBackupEntry::EScheduling );
 
   159     return CreateEntry( title, tips, FmBackupEntry::EScheduling );
 
   143 }
 
   160 }
 
   144 
   161 
   145 FmBackupEntry* FmBackupSettings::createWeekdayEntry()
 
   162 FmBackupEntry* FmBackupSettings::createWeekdayEntry()
 
   146 {
 
   163 {
 
   147     QString title;
 
   164     QString title;
 
   148     QString tips;
 
   165     QString tips;
 
   149 
   166 
   150     title = constFileManagerBackupSettingsTitleWeekday;
 
   167     title = hbTrId( "Weekday" );
 
   151     tips  = weekdayToString( mWeekday );
 
   168     tips  = weekdayToString( mWeekday );
 
   152 
   169 
   153     return CreateEntry( title, tips, FmBackupEntry::EWeekday );
 
   170     return CreateEntry( title, tips, FmBackupEntry::EWeekday );
 
   154 }
 
   171 }
 
   155 
   172 
   156 FmBackupEntry* FmBackupSettings::createTimeEntry()
 
   173 FmBackupEntry* FmBackupSettings::createTimeEntry()
 
   157 {
 
   174 {
 
   158     QString title;
 
   175     QString title;
 
   159     QString tips;
 
   176     QString tips;
 
   160 
   177 
   161     title = constFileManagerBackupSettingsTitleTime;
 
   178     title = hbTrId( "Time" );
 
   162     tips  = mTime.toString( "hh:mm" );
 
   179     tips  = mTime.toString( "hh:mm" );
 
   163 
   180 
   164     return CreateEntry( title, tips, FmBackupEntry::ETime );
 
   181     return CreateEntry( title, tips, FmBackupEntry::ETime );
 
   165 }
 
   182 }
 
   166 
   183 
   167 FmBackupEntry* FmBackupSettings::createTargetDriveEntry()
 
   184 FmBackupEntry* FmBackupSettings::createTargetDriveEntry()
 
   168 {
 
   185 {
 
   169     QString title;
 
   186     QString title;
 
   170     QString tips;
 
   187     QString tips;
 
   171 
   188 
   172     title = constFileManagerBackupSettingsTitleTargetDrive;
 
   189     title = hbTrId( "Backup destination" );
 
   173     tips  = targetDriveToString( mTargetDrive );
 
   190     tips  = targetDriveToString( mTargetDrive );
 
   174 
   191 
   175     return CreateEntry( title, tips, FmBackupEntry::ETarget );
 
   192     return CreateEntry( title, tips, FmBackupEntry::ETarget );
 
   176 }
 
   193 }
 
   177 
   194 
       
   195 FmBackupEntry* FmBackupSettings::createBackupDateEntry()
 
       
   196 {
 
       
   197     QString tips;
 
       
   198     if( mDate.isNull() )
 
       
   199         {
 
       
   200         tips =  hbTrId( "No previous backups created");
 
       
   201         }
 
       
   202     else
 
       
   203         {
 
       
   204         tips = hbTrId( "Backup Created " ) + mDate.toString( "dd.MM.yyyy" );
 
       
   205         }    
       
   206     return CreateEntry( QString(""), tips, FmBackupEntry::EBackupdate);
 
       
   207 }
 
   178 QString FmBackupSettings::contentToString( const quint32 content )
 
   208 QString FmBackupSettings::contentToString( const quint32 content )
 
   179 {
 
   209 {
 
   180     QString ret( constFileManagerBackupSettingsContentAll );
 
   210     QString ret( hbTrId( "All" ) );
 
   181 
   211 
   182     if ( content & EFileManagerBackupContentAll ){
 
   212     if ( content & EFileManagerBackupContentAll ){
 
   183         ret = constFileManagerBackupSettingsContentAll;
 
   213         ret = hbTrId( "All" );
 
   184     }
 
   214     }
 
   185     else if ( content & EFileManagerBackupContentSettings ){
 
   215     else if ( content & EFileManagerBackupContentSettings ){
 
   186         ret = constFileManagerBackupSettingsContentSettings;
 
   216         ret = hbTrId( "Settings" );
 
   187     }
 
   217     }
 
   188     else if ( content & EFileManagerBackupContentMessages ){
 
   218     else if ( content & EFileManagerBackupContentMessages ){
 
   189         ret = constFileManagerBackupSettingsContentMessages;
 
   219         ret = hbTrId( "Messages" );
 
   190     }
 
   220     }
 
   191     else if ( content & EFileManagerBackupContentContacts ){
 
   221     else if ( content & EFileManagerBackupContentContacts ){
 
   192         ret = constFileManagerBackupSettingsContentContacts;
 
   222         ret = hbTrId( "Contacts" );
 
   193     }
 
   223     }
 
   194     else if ( content & EFileManagerBackupContentCalendar ){
 
   224     else if ( content & EFileManagerBackupContentCalendar ){
 
   195         ret = constFileManagerBackupSettingsContentCalendar;
 
   225         ret = hbTrId( "Calendar" );
 
   196     }
 
   226     }
 
   197     else if ( content & EFileManagerBackupContentBookmarks ){
 
   227     else if ( content & EFileManagerBackupContentBookmarks ){
 
   198         ret = constFileManagerBackupSettingsContentBookmarks;
 
   228         ret = hbTrId( "Bookmarks" );
 
   199     }
 
   229     }
 
   200     else if ( content & EFileManagerBackupContentUserFiles ){
 
   230     else if ( content & EFileManagerBackupContentUserFiles ){
 
   201         ret = constFileManagerBackupSettingsContentUserFiles;
 
   231         ret = hbTrId( "Files" );
 
   202     }
 
   232     }
 
   203     return ret;
 
   233     return ret;
 
   204 }
 
   234 }
 
   205 
   235 
   206 QString FmBackupSettings::weekdayToString( const TFileManagerBackupWeekday weekday )
 
   236 QString FmBackupSettings::weekdayToString( const TFileManagerBackupWeekday weekday )
 
   207 {
 
   237 {
 
   208     QString ret = "";
 
   238     QString ret = "";
 
   209     switch (weekday)
 
   239     switch (weekday)
 
   210     {
 
   240     {
 
   211     case EFileManagerBackupWeekdayMonday:
 
   241     case EFileManagerBackupWeekdayMonday:
 
   212         ret = constFileManagerBackupWeekdayMonday;
 
   242         ret = hbTrId( "Monday" );
 
   213         break;
 
   243         break;
 
   214     case EFileManagerBackupWeekdayTuesday:
 
   244     case EFileManagerBackupWeekdayTuesday:
 
   215         ret = constFileManagerBackupWeekdayTuesday;
 
   245         ret = hbTrId( "Tuesday" );
 
   216         break;
 
   246         break;
 
   217     case EFileManagerBackupWeekdayWednesday:
 
   247     case EFileManagerBackupWeekdayWednesday:
 
   218         ret = constFileManagerBackupWeekdayWednesday;
 
   248         ret = hbTrId( "Wednesday" );
 
   219         break;
 
   249         break;
 
   220     case EFileManagerBackupWeekdayThursday:
 
   250     case EFileManagerBackupWeekdayThursday:
 
   221         ret = constFileManagerBackupWeekdayThursday;
 
   251         ret = hbTrId( "Thursday" );
 
   222         break;
 
   252         break;
 
   223     case EFileManagerBackupWeekdayFriday:
 
   253     case EFileManagerBackupWeekdayFriday:
 
   224         ret = constFileManagerBackupWeekdayFirday;
 
   254         ret = hbTrId( "Friday" );
 
   225         break;
 
   255         break;
 
   226     case EFileManagerBackupWeekdaySaturday:
 
   256     case EFileManagerBackupWeekdaySaturday:
 
   227         ret = constFileManagerBackupWeekdaySaturday;
 
   257         ret = hbTrId( "Saturday" );
 
   228         break;
 
   258         break;
 
   229     case EFileManagerBackupWeekdaySunday:
 
   259     case EFileManagerBackupWeekdaySunday:
 
   230         ret = constFileManagerBackupWeekdaySunday;
 
   260         ret = hbTrId( "Sunday" );
 
   231         break;
 
   261         break;
 
   232     }
 
   262     }
 
   233     return ret;
 
   263     return ret;
 
   234 }
 
   264 }
 
   235 
   265 
   238 {
 
   268 {
 
   239     QString ret = "";
 
   269     QString ret = "";
 
   240     switch (scheduling)
 
   270     switch (scheduling)
 
   241     {
 
   271     {
 
   242     case EFileManagerBackupScheduleNever:
 
   272     case EFileManagerBackupScheduleNever:
 
   243         ret = constFileManagerBackupScheduleNever;
 
   273         ret = hbTrId( "Never" );
 
   244         break;
 
   274         break;
 
   245     case EFileManagerBackupScheduleDaily:
 
   275     case EFileManagerBackupScheduleDaily:
 
   246         ret = constFileManagerBackupScheduleDaily;
 
   276         ret = hbTrId ("Daily" );
 
   247         break;
 
   277         break;
 
   248     case EFileManagerBackupScheduleWeekly:
 
   278     case EFileManagerBackupScheduleWeekly:
 
   249         ret = constFileManagerBackupScheduleWeekly;
 
   279         ret = hbTrId( "Weekly" );
 
   250         break;
 
   280         break;
 
   251     }
 
   281     }
 
   252     return ret;
 
   282     return ret;
 
   253 }
 
   283 }
 
   254 
   284 
   292 
   322 
   293     if( driveList.count() > 1 ) {
 
   323     if( driveList.count() > 1 ) {
 
   294         entry = createTargetDriveEntry();
 
   324         entry = createTargetDriveEntry();
 
   295         mBackupEntryList.push_back( entry );
 
   325         mBackupEntryList.push_back( entry );
 
   296     }
 
   326     }
 
       
   327     
       
   328     entry = createBackupDateEntry();
 
       
   329     mBackupEntryList.push_back( entry );
 
   297 }
 
   330 }
 
   298 
   331 
   299 void FmBackupSettings::resetAndDestoryBackupEntry()
 
   332 void FmBackupSettings::resetAndDestoryBackupEntry()
 
   300 {
 
   333 {
 
   301     for( QList< FmBackupEntry* >::iterator it = mBackupEntryList.begin(); 
   334     for( QList< FmBackupEntry* >::iterator it = mBackupEntryList.begin(); 
   314    
   347    
   315     QStringList driveList;
 
   348     QStringList driveList;
 
   316     mBkupEngine->getBackupDriveList( driveList );
 
   349     mBkupEngine->getBackupDriveList( driveList );
 
   317     QString defaultDrive( driveList.first() );
 
   350     QString defaultDrive( driveList.first() );
 
   318    
   351    
   319     
   352     QDate date;
 
   320     QSettings settings("Nokia", "FileManager");
 
   353     QSettings settings("Nokia", "FileManager");
 
   321 
   354 
   322     settings.beginGroup("BackupConfigure");
 
   355     settings.beginGroup("BackupConfigure");
 
   323 
   356 
   324     mContent  = (settings.value("content", 1).toUInt()); // All for default value
 
   357     mContent  = (settings.value("content", 1).toUInt()); // All for default value
 
   325     mScheduling = (TFileManagerBackupSchedule)(settings.value("scheduling", EFileManagerBackupScheduleNever ).toInt()); // Never schedule for default value
 
   358     mScheduling = (TFileManagerBackupSchedule)(settings.value("scheduling", EFileManagerBackupScheduleNever ).toInt()); // Never schedule for default value
 
   326     mWeekday = (TFileManagerBackupWeekday)(settings.value("weekday", EFileManagerBackupWeekdayMonday ).toInt()); // monday for default value
 
   359     mWeekday = (TFileManagerBackupWeekday)(settings.value("weekday", EFileManagerBackupWeekdayMonday ).toInt()); // monday for default value
 
   327     mTime = (settings.value("time", QTime::currentTime() ).toTime()); // empty for default
 
   360     mTime = (settings.value("time", QTime::currentTime() ).toTime()); // empty for default
 
   328     mTargetDrive = (settings.value("targetDrive", defaultDrive ) ).toString();  // C for default
 
   361     mTargetDrive = (settings.value("targetDrive", defaultDrive ) ).toString();  // C for default
 
   329 
   362     mDate = (settings.value("backupDate", date)).toDate();
 
   330     settings.endGroup();
 
   363     settings.endGroup();
 
   331     refreshList();
 
   364     refreshList();
 
   332 }
 
   365 }
 
   333 
   366 
   334 
   367 
   341     settings.setValue( "content", mContent );
 
   374     settings.setValue( "content", mContent );
 
   342     settings.setValue( "scheduling", mScheduling );
 
   375     settings.setValue( "scheduling", mScheduling );
 
   343     settings.setValue( "weekday", mWeekday );
 
   376     settings.setValue( "weekday", mWeekday );
 
   344     settings.setValue( "time", mTime.toString() );
 
   377     settings.setValue( "time", mTime.toString() );
 
   345     settings.setValue( "targetDrive", mTargetDrive );
 
   378     settings.setValue( "targetDrive", mTargetDrive );
 
   346 
   379     settings.setValue( "backupDate", mDate.toString( Qt::ISODate ) );
 
   347     settings.endGroup();
 
   380     settings.endGroup();
 
   348 
   381 
   349     refreshList();
 
   382     refreshList();
 
   350 }
 
   383 }
 
       
   384 
       
   385 void FmBackupSettings::updateBackupDate()
 
       
   386 {
 
       
   387     mDate.setDate( QDate::currentDate().year(), QDate::currentDate().month(), QDate::currentDate().day() );
 
       
   388     save();
 
       
   389 }
FCL/sf/app/files