filebrowser/ui/src/enginewrapper.cpp
changeset 17 4f2773374eff
child 19 4b22a598b890
child 24 6053b7ae82ab
equal deleted inserted replaced
15:e11368ed4880 17:4f2773374eff
       
     1 /*
       
     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 
       
    18 #include "enginewrapper.h"
       
    19 #include "engine.h"
       
    20 #include "FBFileUtils.h"
       
    21 #include "notifications.h"
       
    22 #include "filebrowserview.h"
       
    23 #include "searchview.h"
       
    24 #include "filebrowsersettings.h"
       
    25 #include "settingsview.h"
       
    26 
       
    27 #include <QString>
       
    28 #include <QFileInfo>
       
    29 #include <QModelIndex>
       
    30 
       
    31 // ---------------------------------------------------------------------------
       
    32 
       
    33 EngineWrapper::EngineWrapper()
       
    34     : mEngine(0),
       
    35     mFilesFound(),
       
    36     mSettings(0)
       
    37 {
       
    38 }
       
    39 
       
    40 // ---------------------------------------------------------------------------
       
    41 
       
    42 EngineWrapper::~EngineWrapper()
       
    43 {
       
    44     if(mEngine != NULL) {
       
    45         TRAP_IGNORE(mEngine->DeActivateEngineL());
       
    46         delete mEngine;
       
    47     } 
       
    48 }
       
    49 
       
    50 // ---------------------------------------------------------------------------
       
    51 
       
    52 bool EngineWrapper::init()
       
    53 {
       
    54     TRAPD(err, mEngine = CEngine::NewL(this));
       
    55     if (err != KErrNone) {
       
    56         return false;
       
    57     } else {
       
    58         TRAP_IGNORE(mEngine->ActivateEngineL());
       
    59         mSettings = FileBrowserSettings(&mEngine->Settings());
       
    60         return true;
       
    61     }
       
    62 }
       
    63 
       
    64 // ---------------------------------------------------------------------------
       
    65 // Functions that are called from UI
       
    66 // ---------------------------------------------------------------------------
       
    67 bool EngineWrapper::searchFiles()
       
    68 {
       
    69     TRAPD(err, mEngine->SearchL() );
       
    70     if(err != KErrNone) {
       
    71         return false;
       
    72     }
       
    73     else {
       
    74         return true;
       
    75     }
       
    76 }
       
    77 
       
    78 // ---------------------------------------------------------------------------
       
    79 SearchAttributes EngineWrapper::getFileSearchAttributes()
       
    80 {
       
    81     TSearchAttributes tAttributes = mEngine->GetSearchAttributes();
       
    82     SearchAttributes attributes;
       
    83 
       
    84     // Convert TSearchAttributes to SearchAttributes 
       
    85     attributes.mSearchDir  = QString((QChar*)tAttributes.iSearchDir.Ptr(),tAttributes.iSearchDir.Length());
       
    86     attributes.mWildCards  = QString((QChar*)tAttributes.iWildCards.Ptr(),tAttributes.iWildCards.Length()); 
       
    87     attributes.mTextInFile = QString((QChar*)tAttributes.iTextInFile.Ptr(),tAttributes.iTextInFile.Length()); 
       
    88     attributes.mMinSize    = tAttributes.iMinSize;
       
    89     attributes.mMaxSize    = tAttributes.iMaxSize;
       
    90     attributes.mRecurse    = tAttributes.iRecurse;
       
    91     
       
    92     // TTime to QDate
       
    93     TBuf<20> timeString;
       
    94     _LIT(KDateString,"%D%M%Y%/0%1%/1%2%/2%3%/3");
       
    95     TRAP_IGNORE( tAttributes.iMinDate.FormatL(timeString, KDateString) );
       
    96     QString temp = QString::fromUtf16(timeString.Ptr(), timeString.Length());
       
    97     temp.replace(QChar('/'), QChar('-'));
       
    98     attributes.mMinDate = QDate::fromString(temp, "dd-MM-yyyy");
       
    99     
       
   100     
       
   101     TRAP_IGNORE( tAttributes.iMaxDate.FormatL(timeString, KDateString) );
       
   102     temp = QString::fromUtf16(timeString.Ptr(), timeString.Length());
       
   103     temp.replace(QChar('/'), QChar('-'));
       
   104     attributes.mMaxDate = QDate::fromString(temp, "dd-MM-yyyy");
       
   105     
       
   106     return attributes;
       
   107 
       
   108 }
       
   109 
       
   110 // ---------------------------------------------------------------------------
       
   111 int EngineWrapper::setFileSearchAttributes(SearchAttributes attributes)
       
   112 {
       
   113     TSearchAttributes tAttributes;
       
   114     // Convert SearchAttributes to TSearchAttributes 
       
   115     
       
   116     //convert QString to TFilename:
       
   117     tAttributes.iSearchDir = TFileName(attributes.mSearchDir.utf16());
       
   118     tAttributes.iWildCards = TFileName(attributes.mWildCards.utf16());
       
   119     tAttributes.iTextInFile = TFileName(attributes.mTextInFile.utf16());
       
   120     
       
   121     tAttributes.iMinSize    = attributes.mMinSize;
       
   122     tAttributes.iMaxSize    = attributes.mMaxSize;    
       
   123     tAttributes.iRecurse    = attributes.mRecurse;
       
   124     
       
   125     // QDate to TTime for both min- and max Date
       
   126     QString temp = attributes.mMinDate.toString("yyyy-MM-dd");
       
   127     QStringList dateList = temp.split("-");
       
   128     int month = dateList[1].toInt() - 1;
       
   129     int day = dateList[2].toInt() - 1;
       
   130     temp = dateList[0];
       
   131     if (month == 0) {
       
   132         temp.append("00");
       
   133     }
       
   134     else {
       
   135         temp.append(QString::number(month));
       
   136     }
       
   137     if (day == 0) {
       
   138         temp.append("00");
       
   139     }
       
   140     else { 
       
   141         temp.append(QString::number(day));
       
   142     }
       
   143     temp.append(":");
       
   144         
       
   145     TBuf<24> dateString(temp.utf16());
       
   146     tAttributes.iMinDate.Set(dateString);
       
   147     
       
   148     temp = attributes.mMaxDate.toString("yyyy-MM-dd");
       
   149     dateList = temp.split("-");
       
   150     month = dateList[1].toInt() - 1;
       
   151     day = dateList[2].toInt() - 1;
       
   152     temp = dateList[0];
       
   153     if (month == 0) {
       
   154         temp.append("00");
       
   155     }
       
   156     else {
       
   157         temp.append(QString::number(month));
       
   158     }
       
   159     if (day == 0) {
       
   160         temp.append("00");
       
   161     }
       
   162     else { 
       
   163         temp.append(QString::number(day));
       
   164     }
       
   165     temp.append(":");
       
   166     dateString.Copy(temp.utf16());
       
   167     tAttributes.iMaxDate.Set(dateString);
       
   168     
       
   169     mEngine->ChangeAttributes(tAttributes);
       
   170     return KErrNone;
       
   171 }
       
   172 
       
   173 
       
   174 // ---------------------------------------------------------------------------
       
   175 SearchResults EngineWrapper::getSearchResults()
       
   176 {
       
   177     TSearchResults tResults = mEngine->SearchResults();
       
   178     SearchResults results;
       
   179     results.mNumberOfFoundFiles = tResults.iNumberOfFoundFiles;
       
   180     CFileEntryList* foundFilesResult = mEngine->FoundFiles();
       
   181     if (!mFilesFound.isEmpty()) {
       
   182         mFilesFound.clear();
       
   183         }
       
   184     // copy file names and convert them from TFileName format to QStringList items type
       
   185     for (int i = 0; i < foundFilesResult->Count(); i++) {
       
   186             mFilesFound.append(
       
   187                     QString((QChar*)foundFilesResult->At(i).iFullName.Ptr(), 
       
   188                     foundFilesResult->At(i).iFullName.Length()) 
       
   189                     );
       
   190         }
       
   191     results.mFoundFilesList = &mFilesFound;
       
   192     return results;
       
   193 }
       
   194 
       
   195 // ---------------------------------------------------------------------------
       
   196 
       
   197 void EngineWrapper::saveSettings(bool aNotifyModules)
       
   198 {
       
   199     return mEngine->SaveSettingsL(aNotifyModules);;
       
   200 }
       
   201 
       
   202 // ---------------------------------------------------------------------------
       
   203 
       
   204 bool EngineWrapper::isDriveListViewActive()
       
   205 {
       
   206     // TODO check return value
       
   207     if (mEngine->FileUtils() && mEngine->FileUtils()->IsDriveListViewActive()) {
       
   208         return true;
       
   209     } else {
       
   210         return false;
       
   211     }
       
   212 }
       
   213 
       
   214 bool EngineWrapper::isCurrentDriveReadOnly()
       
   215 {
       
   216     // TODO check return value
       
   217     if (mEngine->FileUtils() && mEngine->FileUtils()->IsCurrentDriveReadOnly()) {
       
   218         return true;
       
   219     } else {
       
   220         return false;
       
   221     }
       
   222 }
       
   223 
       
   224 bool EngineWrapper::isClipBoardListInUse()
       
   225 {
       
   226     if (mEngine->FileUtils() && mEngine->FileUtils()->ClipBoardList() && mEngine->FileUtils()->ClipBoardList()->Count() != 0)
       
   227         return true;
       
   228     else
       
   229         return false;
       
   230 }
       
   231 
       
   232 // ---------------------------------------------------------------------------
       
   233 void EngineWrapper::startExecutingCommands(const QString &aCommandsExecutionMessage)
       
   234 {
       
   235     TPtrC commandsExecutionMessage(reinterpret_cast<const TText*>(aCommandsExecutionMessage.constData()));
       
   236     TRAPD(err, mEngine->FileUtils()->StartExecutingCommandsL(commandsExecutionMessage) );
       
   237     Q_UNUSED(err); //TODO
       
   238 }
       
   239 
       
   240 // ---------------------------------------------------------------------------
       
   241 
       
   242 void EngineWrapper::refreshView()
       
   243 {
       
   244     if (mEngine->FileUtils()) {
       
   245         TRAPD(err, mEngine->FileUtils()->RefreshViewL() );
       
   246         Q_UNUSED(err); //TODO
       
   247     }
       
   248 }
       
   249 
       
   250 void EngineWrapper::moveUpOneLevel()
       
   251 {
       
   252     if (mEngine->FileUtils()) {
       
   253         TRAPD(err, mEngine->FileUtils()->MoveUpOneLevelL() );
       
   254         Q_UNUSED(err); //TODO
       
   255     }
       
   256 }
       
   257 
       
   258 // ---------------------------------------------------------------------------
       
   259 
       
   260 void EngineWrapper::moveDownToDirectory(const QModelIndex& aIndex)
       
   261 {
       
   262     if (mEngine->FileUtils()) {
       
   263         TRAPD(err, mEngine->FileUtils()->MoveDownToDirectoryL(aIndex.row()) );
       
   264         Q_UNUSED(err); //TODO
       
   265     }
       
   266 }
       
   267 
       
   268 // ---------------------------------------------------------------------------
       
   269 
       
   270 int EngineWrapper::clipboardCut(const QModelIndexList& aSelectionIndices)
       
   271 {
       
   272     TInt operations = 0;
       
   273     const CArrayFix<TInt> *selectionIndexes = convertSelectionList(aSelectionIndices);
       
   274     if (mEngine->FileUtils()) {
       
   275         TRAPD(err, operations = mEngine->FileUtils()->ClipboardCutL(selectionIndexes) );
       
   276         Q_UNUSED(err); //TODO
       
   277     }
       
   278     delete selectionIndexes;
       
   279     return operations;
       
   280 }
       
   281 
       
   282 // ---------------------------------------------------------------------------
       
   283 int EngineWrapper::clipboardCopy(const QModelIndexList& aSelectionIndices)
       
   284 {
       
   285     TInt operations = 0;
       
   286     const CArrayFix<TInt> *selectionIndexes = convertSelectionList(aSelectionIndices);
       
   287 
       
   288     if (mEngine->FileUtils()) {
       
   289         TRAPD(err, operations = mEngine->FileUtils()->ClipboardCopyL(selectionIndexes));
       
   290         Q_UNUSED(err); //TODO
       
   291     }
       
   292     delete selectionIndexes;
       
   293     return operations;
       
   294 }
       
   295 
       
   296 // ---------------------------------------------------------------------------
       
   297 
       
   298 void EngineWrapper::clipboardPaste(const OverwriteOptions &aOverwriteOptions)
       
   299 {
       
   300     TOverwriteOptions tOverwriteOptions = convertOverwriteOptions(aOverwriteOptions);
       
   301     if (mEngine->FileUtils()) {
       
   302         TRAPD(err, mEngine->FileUtils()->ClipboardPasteL(tOverwriteOptions));
       
   303         Q_UNUSED(err); //TODO
       
   304     }
       
   305 }
       
   306 
       
   307 // ---------------------------------------------------------------------------
       
   308 
       
   309 void EngineWrapper::copyToFolder(const QString &aTargetDir, const OverwriteOptions &aOverwriteOptions, bool aMove)
       
   310 {
       
   311     TFileName targetDir = TFileName(aTargetDir.utf16());
       
   312     TOverwriteOptions tOverwriteOptions = convertOverwriteOptions(aOverwriteOptions);
       
   313 
       
   314 
       
   315     TRAPD(err, mEngine->FileUtils()->CopyToFolderL(targetDir, tOverwriteOptions, aMove ? ETrue : EFalse) );
       
   316     Q_UNUSED(err); //TODO
       
   317 }
       
   318 
       
   319 // ---------------------------------------------------------------------------
       
   320 
       
   321 void EngineWrapper::createNewFile(const QString &aNewFileName)
       
   322 {
       
   323     TFileName fileName = TFileName(aNewFileName.utf16());
       
   324     TRAPD(err, mEngine->FileUtils()->NewFileL(fileName) );
       
   325     Q_UNUSED(err); //TODO
       
   326 }
       
   327 
       
   328 // ---------------------------------------------------------------------------
       
   329 
       
   330 void EngineWrapper::createNewDirectory(const QString &aNewDirectoryName)
       
   331 {
       
   332     TFileName newDirectoryName = TFileName(aNewDirectoryName.utf16());
       
   333     TRAPD(err, mEngine->FileUtils()->NewDirectoryL(newDirectoryName) );
       
   334     Q_UNUSED(err); //TODO
       
   335 }
       
   336 
       
   337 // ---------------------------------------------------------------------------
       
   338 
       
   339 void EngineWrapper::deleteItems(const QModelIndexList& aSelectionIndices)
       
   340 {
       
   341     setCurrentSelection(aSelectionIndices);
       
   342     TRAPD(err, mEngine->FileUtils()->DeleteL() );
       
   343     Q_UNUSED(err); //TODO
       
   344 }
       
   345 
       
   346 // ---------------------------------------------------------------------------
       
   347 bool EngineWrapper::selectionHasDirs()
       
   348 {
       
   349     return mEngine->FileUtils()->SelectionHasDirs();
       
   350 }
       
   351 
       
   352 // ---------------------------------------------------------------------------
       
   353 
       
   354 void EngineWrapper::rename(const QModelIndex& aIndex, const QString aNewName)
       
   355 {
       
   356     if (mEngine->FileUtils()) {
       
   357         const TFileName newName = TFileName(aNewName.utf16());
       
   358         TRAPD(err, mEngine->FileUtils()->RenameL(aIndex.row(), newName) );
       
   359         Q_UNUSED(err); //TODO
       
   360     }
       
   361 }
       
   362 
       
   363 // ---------------------------------------------------------------------------
       
   364 
       
   365 void EngineWrapper::touch(bool aRecurse)
       
   366 {
       
   367     if (mEngine->FileUtils()) {
       
   368         TRAPD(err, mEngine->FileUtils()->TouchL(aRecurse) );
       
   369         Q_UNUSED(err); //TODO
       
   370     }
       
   371 }
       
   372 
       
   373 // ---------------------------------------------------------------------------
       
   374 
       
   375 void EngineWrapper::properties(const QModelIndex &aCurrentItemIndex, QStringList &aPropertyList, QString &aTitleText)
       
   376 {
       
   377     if (mEngine->FileUtils()) {
       
   378 
       
   379         // create an array for the items
       
   380         CDesCArray* entryLines = new(ELeave) CDesCArrayFlat(16);
       
   381 //        CleanupStack::PushL(entryLines);
       
   382         TFileName titleText;
       
   383 
       
   384         TRAPD(err, mEngine->FileUtils()->PropertiesL(aCurrentItemIndex.row(), entryLines, titleText));
       
   385         Q_UNUSED(err); //TODO
       
   386 
       
   387         aTitleText = QString::fromUtf16(titleText.Ptr(), titleText.Length());
       
   388         QString textItem;
       
   389         for (TInt i = 0; i < entryLines->Count(); ++i) {
       
   390             textItem = QString::fromUtf16((*entryLines)[i].Ptr(), (*entryLines)[i].Length());
       
   391             aPropertyList.append(textItem);
       
   392         }
       
   393 //        CleanupStack::PopAndDestroy(); //entryLines
       
   394         delete entryLines;
       
   395     }
       
   396 }
       
   397 // ---------------------------------------------------------------------------
       
   398 
       
   399 bool EngineWrapper::openAppArc(QString fileName)
       
   400 {
       
   401 
       
   402     //convert QString to TFilename:
       
   403     fileName.replace("/", "\\");
       
   404     TFileName fileToOpen = TFileName(fileName.utf16());
       
   405 
       
   406     TRAPD(err, mEngine->OpenWithApparcL(fileToOpen) );
       
   407     if(err != KErrNone) {
       
   408         return false;
       
   409     } else {
       
   410         return true;
       
   411     }
       
   412 }
       
   413 
       
   414 // ---------------------------------------------------------------------------
       
   415 
       
   416 bool EngineWrapper::openDocHandler(QString fileName, bool embeddedVal)
       
   417 {
       
   418     //convert QString to TFilename:
       
   419     fileName.replace("/", "\\");
       
   420     TFileName fileToOpen = TFileName(fileName.utf16());
       
   421 
       
   422     TRAPD(err, mEngine->OpenWithDocHandlerL(fileToOpen, embeddedVal) );
       
   423     if(err != KErrNone) {
       
   424         return false;
       
   425     } else {
       
   426         return true;
       
   427     }
       
   428 }
       
   429 
       
   430 // ---------------------------------------------------------------------------
       
   431 
       
   432 int EngineWrapper::itemCount() const
       
   433 {
       
   434     if (mEngine->FileUtils()->IsDriveListViewActive()) {
       
   435         return mEngine->FileUtils()->DriveEntries()->Count();
       
   436     } else {
       
   437         return mEngine->FileUtils()->FileEntries()->Count();
       
   438     }
       
   439 }
       
   440 
       
   441 // ---------------------------------------------------------------------------
       
   442 
       
   443 DriveEntry EngineWrapper::getDriveEntry(const QModelIndex& aIndex) const
       
   444 {
       
   445     TDriveEntry driveEntry;
       
   446     if (mEngine->FileUtils()->DriveEntries()->Count() > aIndex.row() && aIndex.row() >= 0) {
       
   447         driveEntry = mEngine->FileUtils()->DriveEntries()->At(aIndex.row());
       
   448     }
       
   449     return DriveEntry(driveEntry);
       
   450 }
       
   451 
       
   452 // ---------------------------------------------------------------------------
       
   453 
       
   454 FileEntry EngineWrapper::getFileEntry(const QModelIndex& aIndex) const
       
   455 {
       
   456     TFileEntry fileEntry;
       
   457     if (mEngine->FileUtils()->FileEntries()->Count() > aIndex.row() && aIndex.row() >= 0) {
       
   458         fileEntry = mEngine->FileUtils()->FileEntries()->At(aIndex.row());
       
   459     }
       
   460     return FileEntry(fileEntry);
       
   461 }
       
   462 
       
   463 // ---------------------------------------------------------------------------
       
   464 
       
   465 const CArrayFix<TInt> *EngineWrapper::convertSelectionList(const QModelIndexList &aSelectionIndices)
       
   466 {
       
   467     CArrayFixFlat<TInt>* selectionIndexes = 0;
       
   468     TRAPD(err, selectionIndexes = new(ELeave)CArrayFixFlat<TInt>(4));
       
   469     if (err != KErrNone) {
       
   470         return 0;
       
   471     }
       
   472 
       
   473     for (int i=0; i< aSelectionIndices.count(); ++i) {
       
   474         TRAPD(err, selectionIndexes->AppendL(aSelectionIndices.at(i).row()) );
       
   475         Q_UNUSED(err); //TODO
       
   476     }
       
   477     return selectionIndexes;
       
   478 }
       
   479 
       
   480 
       
   481 // ---------------------------------------------------------------------------
       
   482 
       
   483 void EngineWrapper::setCurrentSelection(const QModelIndexList &aSelectionIndices)
       
   484 {
       
   485     const CArrayFix<TInt> *selectionIndexes = convertSelectionList(aSelectionIndices);
       
   486     mEngine->FileUtils()->SetCurrentSelection(selectionIndexes);
       
   487     delete selectionIndexes;
       
   488 }
       
   489 
       
   490 // ---------------------------------------------------------------------------
       
   491 
       
   492 bool EngineWrapper::isDestinationEntriesExists(const QModelIndexList &aSelectionIndices, QString aTargetDir)
       
   493 {
       
   494     TFileName targetDir = TFileName(aTargetDir.utf16());
       
   495     setCurrentSelection(aSelectionIndices);
       
   496 
       
   497     TBool someEntryExists = mEngine->FileUtils()->IsDestinationEntriesExists(targetDir);
       
   498     return someEntryExists;
       
   499 }
       
   500 
       
   501 // ---------------------------------------------------------------------------
       
   502 bool EngineWrapper::targetExists(const QModelIndex& aIndex, const QString aNewName)
       
   503 {
       
   504     const TFileName newName = TFileName(aNewName.utf16());
       
   505     return mEngine->FileUtils()->TargetExists(aIndex.row(), newName);
       
   506 }
       
   507 
       
   508 // ---------------------------------------------------------------------------
       
   509 
       
   510 QString EngineWrapper::currentPath() const
       
   511 {
       
   512     return QString::fromUtf16(mEngine->FileUtils()->CurrentPath().Ptr(),
       
   513                               mEngine->FileUtils()->CurrentPath().Length());
       
   514 }
       
   515 
       
   516 TOverwriteOptions EngineWrapper::convertOverwriteOptions(const OverwriteOptions &aOverwriteOptions)
       
   517 {
       
   518     TOverwriteOptions tOverwriteOptions;
       
   519     tOverwriteOptions.iDoFileOperations = aOverwriteOptions.doFileOperations;
       
   520     tOverwriteOptions.iQueryIndex = aOverwriteOptions.queryIndex;
       
   521     tOverwriteOptions.iPostFix = TFileName(aOverwriteOptions.postFix.utf16());
       
   522     tOverwriteOptions.iOverWriteFlags = aOverwriteOptions.overWriteFlags;
       
   523     return tOverwriteOptions;
       
   524 }
       
   525 
       
   526 bool EngineWrapper::hasDrivePassword(const QModelIndex &aIndex)
       
   527 {
       
   528     bool hasPassword = false;
       
   529     if (mEngine->FileUtils()->DriveEntries()->Count() > aIndex.row() && aIndex.row() >= 0)
       
   530     {
       
   531         TDriveEntry driveEntry = mEngine->FileUtils()->DriveEntries()->At(aIndex.row());
       
   532         hasPassword = driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttHasPassword;
       
   533     }
       
   534     return hasPassword;
       
   535 }
       
   536 
       
   537 bool EngineWrapper::isDriveRemovable(const QModelIndex &aIndex)
       
   538 {
       
   539     bool isRemovable = false;
       
   540     if (mEngine->FileUtils()->DriveEntries()->Count() > aIndex.row() && aIndex.row() >= 0)
       
   541     {
       
   542         TDriveEntry driveEntry = mEngine->FileUtils()->DriveEntries()->At(aIndex.row());
       
   543         isRemovable = driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRemovable;
       
   544     }
       
   545     return isRemovable;
       
   546 }
       
   547 
       
   548 bool EngineWrapper::isDriveLocked(const QModelIndex &aIndex)
       
   549 {
       
   550     bool isRemovable = false;
       
   551     if (mEngine->FileUtils()->DriveEntries()->Count() > aIndex.row() && aIndex.row() >= 0)
       
   552     {
       
   553         TDriveEntry driveEntry = mEngine->FileUtils()->DriveEntries()->At(aIndex.row());
       
   554         isRemovable = driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttLocked;
       
   555     }
       
   556     return isRemovable;
       
   557 }
       
   558 
       
   559 void EngineWrapper::GetDriveName(const QModelIndex &aIndex, QString &aDriveName)
       
   560 {
       
   561     TFileName driveName;
       
   562     mEngine->FileUtils()->GetDriveName(aIndex.row(), driveName);
       
   563     aDriveName = QString::fromUtf16(driveName.Ptr(), driveName.Length());
       
   564 }
       
   565 
       
   566 
       
   567 void EngineWrapper::GetDriveVolumeLabel(const QModelIndex &aIndex, QString &aVolumeLabel)
       
   568 {
       
   569     TFileName volumeLabel;
       
   570     mEngine->FileUtils()->GetDriveName(aIndex.row(), volumeLabel);
       
   571     aVolumeLabel = QString::fromUtf16(volumeLabel.Ptr(), volumeLabel.Length());
       
   572 }
       
   573 
       
   574 void EngineWrapper::DiskAdminSetDrivePassword(const QModelIndex &aIndex,
       
   575                                               const QString &aOldPassword,
       
   576                                               const QString &aNewPassword)
       
   577 {
       
   578     TFileName oldPassword = TFileName(aOldPassword.utf16());
       
   579     TFileName newPassword = TFileName(aNewPassword.utf16());
       
   580     TRAP_IGNORE(mEngine->FileUtils()->SetDrivePasswordL(aIndex.row(), oldPassword, newPassword));
       
   581 }
       
   582 
       
   583 void EngineWrapper::DiskAdminUnlockDrive(const QModelIndex &aIndex, const QString &aOldPassword)
       
   584 {
       
   585     TFileName oldPassword = TFileName(aOldPassword.utf16());
       
   586     TRAP_IGNORE(mEngine->FileUtils()->UnlockDriveL(aIndex.row(), oldPassword));
       
   587 }
       
   588 
       
   589 void EngineWrapper::DiskAdminClearDrivePassword(const QModelIndex &aIndex, const QString &aOldPassword)
       
   590 {
       
   591     TFileName oldPassword = TFileName(aOldPassword.utf16());
       
   592     TRAP_IGNORE(mEngine->FileUtils()->ClearDrivePasswordL(aIndex.row(), oldPassword));
       
   593 }
       
   594 
       
   595 void EngineWrapper::DiskAdminEraseDrivePassword(const QModelIndex &aIndex)
       
   596 {
       
   597     TRAP_IGNORE(mEngine->FileUtils()->EraseDrivePasswordL(aIndex.row()));
       
   598 }
       
   599 
       
   600 void EngineWrapper::DiskAdminFormatDrive(const QModelIndex &aIndex, bool aQuickFormat)
       
   601 {
       
   602     TRAP_IGNORE(mEngine->FileUtils()->FormatDriveL(aIndex.row(), aQuickFormat));
       
   603 }
       
   604 
       
   605 void EngineWrapper::DiskAdminQuickFormatDrive(const QModelIndex &aIndex, bool aQuickFormat)
       
   606 {
       
   607     TRAP_IGNORE(mEngine->FileUtils()->FormatDriveL(aIndex.row(), aQuickFormat));
       
   608 }
       
   609 
       
   610 void EngineWrapper::DiskAdminCheckDisk(const QModelIndex &aIndex)
       
   611 {
       
   612     TRAP_IGNORE(mEngine->FileUtils()->CheckDiskL(aIndex.row()));
       
   613 }
       
   614 
       
   615 void EngineWrapper::DiskAdminScanDrive(const QModelIndex &aIndex)
       
   616 {
       
   617     TRAP_IGNORE(mEngine->FileUtils()->ScanDriveL(aIndex.row()));
       
   618 }
       
   619 
       
   620 void EngineWrapper::DiskAdminSetDriveName(const QModelIndex &aIndex, const QString &aDriveName)
       
   621 {
       
   622     TFileName driveName = TFileName(aDriveName.utf16());
       
   623     TRAP_IGNORE(mEngine->FileUtils()->SetDriveNameL(aIndex.row(), driveName));
       
   624 }
       
   625 
       
   626 void EngineWrapper::DiskAdminSetDriveVolumeLabel(const QModelIndex &aIndex, const QString &aVolumeLabel)
       
   627 {
       
   628     TFileName volumeLabel = TFileName(aVolumeLabel.utf16());
       
   629     TRAP_IGNORE(mEngine->FileUtils()->SetDriveNameL(aIndex.row(), volumeLabel));
       
   630 }
       
   631 
       
   632 void EngineWrapper::DiskAdminEjectDrive(const QModelIndex &aIndex)
       
   633 {
       
   634     TRAP_IGNORE(mEngine->FileUtils()->EjectDriveL(aIndex.row()));
       
   635 }
       
   636 
       
   637 void EngineWrapper::DiskAdminDismountDrive(const QModelIndex &aIndex)
       
   638 {
       
   639     TRAP_IGNORE(mEngine->FileUtils()->DismountFileSystemL(aIndex.row()));
       
   640 }
       
   641 
       
   642 void EngineWrapper::DiskAdminEraseMBR(const QModelIndex &aIndex)
       
   643 {
       
   644     TRAP_IGNORE(mEngine->FileUtils()->EraseMBRL(aIndex.row()));
       
   645 }
       
   646 
       
   647 void EngineWrapper::DiskAdminPartitionDrive(const QModelIndex &aIndex, bool aEraseMBR, int aAmountOfPartitions)
       
   648 {
       
   649     TRAP_IGNORE(mEngine->FileUtils()->PartitionDriveL(aIndex.row(), aEraseMBR, aAmountOfPartitions));
       
   650 }
       
   651 
       
   652 void EngineWrapper::ToolsSetErrRd(bool aEnable)
       
   653 {
       
   654     TRAP_IGNORE(mEngine->FileUtils()->SetErrRdL(aEnable));
       
   655 }
       
   656 
       
   657 bool EngineWrapper::ErrRdFileExists()
       
   658 {
       
   659     return mEngine->FileUtils()->FileExists(KErrRdPath);
       
   660 }
       
   661 
       
   662 void EngineWrapper::ToolsErrorSimulateLeave(int aLeaveCode)
       
   663 {
       
   664     mEngine->FileUtils()->SimulateLeaveL(aLeaveCode);
       
   665 }
       
   666 
       
   667 void EngineWrapper::ToolsErrorSimulatePanic(QString aPanicCategory, int aPanicCode)
       
   668 {
       
   669     TBuf<128> panicCategory;
       
   670     panicCategory.Copy(aPanicCategory.utf16());
       
   671     mEngine->FileUtils()->SimulatePanicL(panicCategory, aPanicCode);
       
   672 }
       
   673 
       
   674 void EngineWrapper::ToolsErrorSimulateException(int aExceptionCode)
       
   675 {
       
   676     mEngine->FileUtils()->SimulateExceptionL(aExceptionCode);
       
   677 }
       
   678 
       
   679 quint32 EngineWrapper::getDebugMask()
       
   680 {
       
   681     return mEngine->FileUtils()->GetDebugMask();
       
   682 }
       
   683 
       
   684 void EngineWrapper::toolsSetDebugMask(quint32 aDbgMask)
       
   685 {
       
   686     mEngine->FileUtils()->SetDebugMaskL(aDbgMask);
       
   687 }
       
   688 
       
   689 void EngineWrapper::showFileCheckSums(const QModelIndex &aIndex, TFileBrowserCmdFileChecksums checksumType)
       
   690 {
       
   691     mEngine->FileUtils()->ShowFileCheckSumsL(aIndex.row(), checksumType);
       
   692 }
       
   693 
       
   694 // ---------------------------------------------------------------------------
       
   695 // Functions that are called from engine
       
   696 // ---------------------------------------------------------------------------
       
   697 
       
   698 // ---------------------------------------------------------------------------
       
   699 
       
   700 void EngineWrapper::ShowErrorNote(const TDesC& aDescText, TBool aNoTimeout /*= EFalse*/)
       
   701 {
       
   702     QString qStringText = QString::fromUtf16(aDescText.Ptr(), aDescText.Length());
       
   703     Notifications::showErrorNote(qStringText, aNoTimeout);
       
   704 }
       
   705 
       
   706 // ---------------------------------------------------------------------------
       
   707 
       
   708 void EngineWrapper::ShowInformationNote(const TDesC &aDescText, const TDesC &aDescTitle)
       
   709 {
       
   710     QString qText = QString::fromUtf16(aDescText.Ptr(), aDescText.Length());
       
   711     QString qTitle = QString::fromUtf16(aDescTitle.Ptr(), aDescTitle.Length());
       
   712     Notifications::showInformationNote(qText, qTitle);
       
   713 }
       
   714 
       
   715 // ---------------------------------------------------------------------------
       
   716 
       
   717 void EngineWrapper::ShowConfirmationNote(const TDesC& aDescText, TBool aNoTimeout /*= EFalse*/)
       
   718 {
       
   719     QString qStringText = QString::fromUtf16(aDescText.Ptr(), aDescText.Length());
       
   720     Notifications::showConfirmationNote(qStringText, aNoTimeout);
       
   721 }
       
   722 
       
   723 TBool EngineWrapper::ShowConfirmationQuery(const TDesC& aDescText)
       
   724 {
       
   725     QString qStringText = QString::fromUtf16(aDescText.Ptr(), aDescText.Length());
       
   726     return Notifications::showConfirmationQuery(qStringText);
       
   727 }
       
   728 
       
   729 // ---------------------------------------------------------------------------