/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

// INCLUDE FILES

#include "FBModel.h"

#include "FBApp.h"

#include "FB.hrh"

#include "FBSettingViewDlg.h"

#include "FBFileUtils.h"

#include "FBFileListContainer.h"

#include "FBStd.h"

#include <filebrowser.rsg>

#include <coeutils.h>

#include <bautils.h>

#include <apaid.h>

#include <AknGlobalConfirmationQuery.h>

#include <s32file.h>

// hash key selection related includes

#ifndef __SERIES60_30__

  #include <centralrepository.h>

  #include <AknFepInternalCRKeys.h>

  #include <AvkonInternalCRKeys.h>

  #include <e32property.h> 

#endif

const TInt KSettingsDrive = EDriveC;

_LIT(KSettingsFileName, "filebrowser_settings.ini");

// ===================================== MEMBER FUNCTIONS =====================================

CFileBrowserModel* CFileBrowserModel::NewL()

	{

	CFileBrowserModel* self = new(ELeave) CFileBrowserModel;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

// --------------------------------------------------------------------------------------------

CFileBrowserModel::CFileBrowserModel()

	{

	}

// --------------------------------------------------------------------------------------------

void CFileBrowserModel::ConstructL()

	{

    iEnv = CEikonEnv::Static();

    User::LeaveIfError(iLs.Connect());

	}

// --------------------------------------------------------------------------------------------

CFileBrowserModel::~CFileBrowserModel()

	{

	if (iFileUtils)

	    delete iFileUtils;

	iLs.Close();

    }

// ---------------------------------------------------------------------------

void CFileBrowserModel::ActivateModelL()

	{

    TRAP_IGNORE( LoadSettingsL() );

    iFileUtils = CFileBrowserFileUtils::NewL(this);

    // get hash key selection value

    GetHashKeySelectionStatus();

	}

// ---------------------------------------------------------------------------

void CFileBrowserModel::DeActivateModelL()

	{

	}

// --------------------------------------------------------------------------------------------

void CFileBrowserModel::SetFileListContainer(CFileBrowserFileListContainer* aFileListContainer)

    {

    iFileListContainer = aFileListContainer;

    }

// ---------------------------------------------------------------------------

void CFileBrowserModel::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TInt& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        aValue = in.ReadInt16L();

        CleanupStack::PopAndDestroy(); // in        

        }

    }

// ---------------------------------------------------------------------------

void CFileBrowserModel::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TDes& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        TInt bufLength = in.ReadInt16L();   // get length of descriptor

        in.ReadL(aValue, bufLength);        // get the descriptor itself

        CleanupStack::PopAndDestroy(); // in

        }

    }

// ---------------------------------------------------------------------------

void CFileBrowserModel::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TInt& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue);

    out.CommitL(); 	

    CleanupStack::PopAndDestroy(1);// out

    }

// ---------------------------------------------------------------------------

void CFileBrowserModel::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TDes& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue.Length());       // write length of the descriptor

    out.WriteL(aValue, aValue.Length());    // write the descriptor itself

    out.CommitL(); 	

    CleanupStack::PopAndDestroy(1);// out

    }

// --------------------------------------------------------------------------------------------

void CFileBrowserModel::LoadSettingsL()

    {

    const TSize screenSize = iEnv->ScreenDevice()->SizeInPixels();

    // set defaults

    iSettings.iDisplayMode = EDisplayModeFullScreen;

    iSettings.iFileViewMode = IsQHD(screenSize) ? EFileViewModeExtended : EFileViewModeSimple;

    iSettings.iShowSubDirectoryInfo = EFalse;

    iSettings.iShowAssociatedIcons = EFalse;

    iSettings.iRememberLastPath = EFalse;

    iSettings.iLastPath = KNullDesC;

    iSettings.iRememberFolderSelection = ETrue;

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__ && !defined __S60_32__)

    if ( AknLayoutUtils::PenEnabled() )

        {

        iSettings.iEnableToolbar = ETrue;

        }

    else

        {

        iSettings.iEnableToolbar = EFalse;

        }

#else

    iSettings.iEnableToolbar = EFalse;

#endif

    iSettings.iSupportNetworkDrives = EFalse;

    iSettings.iBypassPlatformSecurity = EFalse;

    iSettings.iRemoveFileLocks = ETrue;

    iSettings.iIgnoreProtectionsAtts = ETrue;

    iSettings.iRemoveROMWriteProrection = ETrue;

    // build specific defaults

#if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

    iSettings.iSupportNetworkDrives = ETrue;

#endif 

    // make sure that the private path of this app in c-drive exists

    iEnv->FsSession().CreatePrivatePath( KSettingsDrive ); // c:\\private\\102828d6\\

    // handle settings always in the private directory 

    if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // open or create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iEnv->FsSession(), KSettingsFileName, KUidFileBrowser);

        LoadDFSValueL(settingsStore, KFBSettingDisplayMode,                 iSettings.iDisplayMode);

        LoadDFSValueL(settingsStore, KFBSettingFileViewMode,                iSettings.iFileViewMode);

        LoadDFSValueL(settingsStore, KFBSettingShowSubDirectoryInfo,        iSettings.iShowSubDirectoryInfo);

        LoadDFSValueL(settingsStore, KFBSettingShowAssociatedIcons,         iSettings.iShowAssociatedIcons);

        LoadDFSValueL(settingsStore, KFBSettingRememberLastPath,            iSettings.iRememberLastPath);

        LoadDFSValueL(settingsStore, KFBSettingLastPath,                    iSettings.iLastPath);

        LoadDFSValueL(settingsStore, KFBSettingFolderSelection,             iSettings.iRememberFolderSelection);

        LoadDFSValueL(settingsStore, KFBSettingEnableToolbar,               iSettings.iEnableToolbar);

        LoadDFSValueL(settingsStore, KFBSettingSupportNetworkDrives,        iSettings.iSupportNetworkDrives);

        LoadDFSValueL(settingsStore, KFBSettingBypassPlatformSecurity,      iSettings.iBypassPlatformSecurity);

        LoadDFSValueL(settingsStore, KFBSettingRemoveFileLocks,             iSettings.iRemoveFileLocks);

        LoadDFSValueL(settingsStore, KFBSettingIgnoreProtectionsAtts,       iSettings.iIgnoreProtectionsAtts);

        LoadDFSValueL(settingsStore, KFBSettingRemoveROMWriteProtection,    iSettings.iRemoveROMWriteProrection);

        CleanupStack::PopAndDestroy(); // settingsStore         

        }

    }

// --------------------------------------------------------------------------------------------

void CFileBrowserModel::SaveSettingsL(TBool aNotifyModules)

    {

    // handle settings always in c:\\private\\102828d6\\

    if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // delete existing store to make sure that it is clean and not eg corrupted

        if (BaflUtils::FileExists(iEnv->FsSession(), KSettingsFileName))

            {

            iEnv->FsSession().Delete(KSettingsFileName);

            }

        // create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iEnv->FsSession(), KSettingsFileName, KUidFileBrowser);

        SaveDFSValueL(settingsStore, KFBSettingDisplayMode,                 iSettings.iDisplayMode);

        SaveDFSValueL(settingsStore, KFBSettingFileViewMode,                iSettings.iFileViewMode);

        SaveDFSValueL(settingsStore, KFBSettingShowSubDirectoryInfo,        iSettings.iShowSubDirectoryInfo);

        SaveDFSValueL(settingsStore, KFBSettingShowAssociatedIcons,         iSettings.iShowAssociatedIcons);

        SaveDFSValueL(settingsStore, KFBSettingRememberLastPath,            iSettings.iRememberLastPath);

        SaveDFSValueL(settingsStore, KFBSettingLastPath,                    iSettings.iLastPath);

        SaveDFSValueL(settingsStore, KFBSettingFolderSelection,             iSettings.iRememberFolderSelection);

        SaveDFSValueL(settingsStore, KFBSettingEnableToolbar,               iSettings.iEnableToolbar);

        SaveDFSValueL(settingsStore, KFBSettingSupportNetworkDrives,        iSettings.iSupportNetworkDrives);

        SaveDFSValueL(settingsStore, KFBSettingBypassPlatformSecurity,      iSettings.iBypassPlatformSecurity);

        SaveDFSValueL(settingsStore, KFBSettingRemoveFileLocks,             iSettings.iRemoveFileLocks);

        SaveDFSValueL(settingsStore, KFBSettingIgnoreProtectionsAtts,       iSettings.iIgnoreProtectionsAtts);

        SaveDFSValueL(settingsStore, KFBSettingRemoveROMWriteProtection,    iSettings.iRemoveROMWriteProrection);

        settingsStore->CommitL();

        CleanupStack::PopAndDestroy(); // settingsStore             

        }

    // update changes to modules

    if (aNotifyModules)

        {

        //iScreenCapture->HandleSettingsChangeL();

        iFileUtils->HandleSettingsChangeL();

        iFileListContainer->HandleSettingsChangeL();

        }

    }

// --------------------------------------------------------------------------------------------

void CFileBrowserModel::GetHashKeySelectionStatus()

    {

    TBool hashKeySelectionInUse(EFalse);

#ifndef __SERIES60_30__

    // get hash key selection value

    TRAP_IGNORE(

        CRepository* repository = CRepository::NewLC(KCRUidAknFep);

        repository->Get(KAknFepHashKeySelection, hashKeySelectionInUse);

        CleanupStack::PopAndDestroy();

    );

    // even if hash key selection is in use, ignore the value in qwerty mode

    if (hashKeySelectionInUse)

        {

        TBool qwertyMode(EFalse);

        RProperty qwertyModeStatusProperty;

        qwertyModeStatusProperty.Attach(KCRUidAvkon, KAknQwertyInputModeActive);

        qwertyModeStatusProperty.Get(qwertyMode);

        qwertyModeStatusProperty.Close();

        if (qwertyMode)

            hashKeySelectionInUse = EFalse;        

        }

#endif

    iIsHashKeySelectionInUse = hashKeySelectionInUse;

    }

// --------------------------------------------------------------------------------------------

TInt CFileBrowserModel::LaunchSettingsDialogL()

    {

    // set to normal mode

    iFileListContainer->SetScreenLayoutL(EDisplayModeNormal);

    iFileListContainer->DeleteNaviPane();

    iFileListContainer->HideToolbar();

    // launch the dialog and save settings

    CFileBrowserSettingViewDlg* dlg = CFileBrowserSettingViewDlg::NewL(iSettings);

    TInt retValue = dlg->ExecuteLD(R_FILEBROWSER_SETTINGS_DIALOG);        

    FileListContainer()->CreateEmptyNaviPaneLabelL();

    TRAP_IGNORE(SaveSettingsL());

    return retValue;

    }

// --------------------------------------------------------------------------------------------

// --------------------------------------------------------------------------------------------

CAsyncWaiter* CAsyncWaiter::NewL(TInt aPriority)

	{

	CAsyncWaiter* self = new(ELeave) CAsyncWaiter(aPriority);

	return self;

	}

CAsyncWaiter* CAsyncWaiter::NewLC(TInt aPriority)

	{

	CAsyncWaiter* self = new(ELeave) CAsyncWaiter(aPriority);

	CleanupStack::PushL(self);

	return self;

	}

CAsyncWaiter::CAsyncWaiter(TInt aPriority) : CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}	

CAsyncWaiter::~CAsyncWaiter()

	{

	Cancel();

	}

void CAsyncWaiter::StartAndWait()

	{

    iStatus = KRequestPending;

    SetActive();

    iWait.Start();

	}

TInt CAsyncWaiter::Result() const

	{

	return iError;

	}

void CAsyncWaiter::RunL()

	{

	iError = iStatus.Int();

	CAknEnv::StopSchedulerWaitWithBusyMessage( iWait );

	}

void CAsyncWaiter::DoCancel()

	{

	iError = KErrCancel;

    if( iStatus == KRequestPending )

        {

        TRequestStatus* s=&iStatus;

        User::RequestComplete( s, KErrCancel );

        }

    CAknEnv::StopSchedulerWaitWithBusyMessage( iWait );

	}

// --------------------------------------------------------------------------------------------

// End of File