/*

* 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 "FBFileDlgs.h"

#include "FBFileUtils.h"

#include "FB.hrh"

#include "FBStd.h"

#include <filebrowser.rsg>

#include <aknlistquerydialog.h>

#include <AknIconArray.h>

#include <aknlists.h>

#include <eikbtgpc.h> 

#include <akntitle.h>

#include <AknPopupFieldText.h>

#include <aknnotewrappers.h> 

#include <eikfutil.h>

#include <eikclbd.h> 

const TInt KAttOn = 1;

const TInt KAttOff = 2;

const TInt KAttEnableRecursion = 0;

const TInt KAttDisableRecursion = 1;

const TInt64 KAlmostaDayInMicroSeconds = 86399999999;

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

CFileBrowserDestinationFolderSelectionDlg* CFileBrowserDestinationFolderSelectionDlg::NewL(

    TDes& aReturnPath, CDriveEntryList* aDriveEntryList, CAknIconArray* aIconArray)

    {

    CFileBrowserDestinationFolderSelectionDlg* self = new(ELeave) CFileBrowserDestinationFolderSelectionDlg(aReturnPath, aIconArray);

    CleanupStack::PushL(self);

    self->ConstructL(aDriveEntryList);

    CleanupStack::Pop(self);

    return self;    

    }

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

CFileBrowserDestinationFolderSelectionDlg::~CFileBrowserDestinationFolderSelectionDlg()

    {

    delete iFileEntryList;

    delete iDriveEntryList;

    iFs.Close();

    iEikonEnv->InfoMsgCancel();

    }

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

CFileBrowserDestinationFolderSelectionDlg::CFileBrowserDestinationFolderSelectionDlg(

    TDes& aReturnPath, CAknIconArray* aIconArray) : CAknListQueryDialog(&iSelectedIndex),

    iReturnPath(aReturnPath), iIconArray(aIconArray)

    {

    }

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

void CFileBrowserDestinationFolderSelectionDlg::ConstructL(CDriveEntryList* aDriveEntryList)

    {

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

    iDriveEntryList = new(ELeave) CDriveEntryList(8);

    iFileEntryList = new(ELeave) CFileEntryList(32);

    iCurrentPath = KNullDesC;

    //iIsDragging = EFalse;

    //EnableDragEvents();

    // get only writeable drives

    for (TInt i=0; i<aDriveEntryList->Count(); i++)

        {

        TDriveEntry driveEntry = aDriveEntryList->At(i);

        if (driveEntry.iVolumeInfo.iDrive.iMediaAtt != KMediaAttWriteProtected && driveEntry.iVolumeInfo.iDrive.iMediaAtt != KMediaAttLocked && driveEntry.iVolumeInfo.iDrive.iDriveAtt != KDriveAbsent)

            {

            iDriveEntryList->AppendL(driveEntry);

            }

        }

    }

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

/*

void CFileBrowserDestinationFolderSelectionDlg::HandlePointerEventL(const TPointerEvent &aPointerEvent)

    {

    // detect direction of dragging by comparing the start and finish points

    if (aPointerEvent.iType == TPointerEvent::EButton1Down)

        {

        iDragStartPoint = aPointerEvent.iPosition;

        iIsDragging = EFalse;

        }

    else if (aPointerEvent.iType == TPointerEvent::EDrag)

        {

        iIsDragging = ETrue;

        return;

        }

    else if (aPointerEvent.iType == TPointerEvent::EButton1Up)

        {

        if (iIsDragging)

            {

            const TInt KDelta = iDragStartPoint.iX - aPointerEvent.iPosition.iX;

            const TInt KThreshold = 30;

            if (KDelta < -KThreshold) // dragging to right

                {

                // "emulate" right key press

                TKeyEvent keyEvent;

                keyEvent.iCode = EKeyRightArrow;

                keyEvent.iModifiers = 0;

                TEventCode type = EEventKey;

                OfferKeyEventL(keyEvent, type);

                return;

                }

            else if (KDelta > KThreshold) // dragging to left

                {

                // "emulate" left key press

                TKeyEvent keyEvent;

                keyEvent.iCode = EKeyLeftArrow;

                keyEvent.iModifiers = 0;

                TEventCode type = EEventKey;

                OfferKeyEventL(keyEvent, type);

                return;

                }            

            }

        iIsDragging = EFalse;

        }

    else

        {

        iIsDragging = EFalse;        

        }

    CAknListQueryDialog::HandlePointerEventL(aPointerEvent);    

    }

*/

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

TKeyResponse CFileBrowserDestinationFolderSelectionDlg::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

    {

    if(aType != EEventKey)

        return EKeyWasNotConsumed;

    if (aKeyEvent.iCode == EKeyLeftArrow && !IsDriveListViewActive())

        {

        MoveUpOneLevelL(); 

        return EKeyWasConsumed;    

        }

    else if (aKeyEvent.iCode == EKeyRightArrow && ((ListBox()->CurrentItemIndex() > 0 && !IsDriveListViewActive()) || IsDriveListViewActive()))

        {

        MoveDownToDirectoryL();    

        return EKeyWasConsumed;    

        }

    else if (aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter)    

        {

        if (IsDriveListViewActive())

            {

            MoveDownToDirectoryL();    

            return EKeyWasConsumed;    

            }            

        else if (ListBox()->CurrentItemIndex() == 0)

            {

            TryExitL(EAknSoftkeyOk);    

            return EKeyWasConsumed;    

            }

        else if (ListBox()->CurrentItemIndex() > 0)

            {

            MoveDownToDirectoryL();    

            return EKeyWasConsumed;    

            }            

        }

    TKeyResponse result = CAknDialog::OfferKeyEventL(aKeyEvent, aType);

    // update LSK label

    if (!IsDriveListViewActive())

        {

        if (ListBox()->CurrentItemIndex() == 0)

            {

            ButtonGroupContainer().SetCommandL(0, EAknSoftkeyOk, iLSKActionText);

            ButtonGroupContainer().DrawNow();                

            }

        else

            {

            ButtonGroupContainer().SetCommandL(0, EAknSoftkeyOk, _L("Open dir"));

            ButtonGroupContainer().DrawNow();                

            }

        }

    return result;    

    }    

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

void CFileBrowserDestinationFolderSelectionDlg::PreLayoutDynInitL()

    {

    CAknListQueryDialog::PreLayoutDynInitL();

    static_cast<CEikFormattedCellListBox*>(ListBox())->ItemDrawer()->ColumnData()->EnableMarqueeL(ETrue);

    }

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

void CFileBrowserDestinationFolderSelectionDlg::PostLayoutDynInitL()

    {

    CAknListQueryDialog::PostLayoutDynInitL();

    SetIconArrayL(static_cast<CArrayPtr<CGulIcon>*>(iIconArray)); 

    RefreshViewL();

    }

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

TBool CFileBrowserDestinationFolderSelectionDlg::OkToExitL(TInt aButtonId)

    {

    if (aButtonId == GetLeftCBAShortKeyPress())

        {

        if (IsDriveListViewActive())

            {

            MoveDownToDirectoryL();    

            return EFalse;    

            }            

        else if (ListBox()->CurrentItemIndex() == 0)

            {

            // close the dialog

            iReturnPath = iCurrentPath;    

            return ETrue;    

            }

        else if (ListBox()->CurrentItemIndex() > 0)

            {

            MoveDownToDirectoryL();    

            return EFalse;    

            } 

        else

            return EFalse;

        }    

    else if (aButtonId == GetRightCBAShortKeyPress())

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

void CFileBrowserDestinationFolderSelectionDlg::MoveUpOneLevelL()

    {

    if (iCurrentPath.Length() <= 3)

        {

        // move to drive list view is the current path is already short enough

        iCurrentPath = KNullDesC;

        }

    else

        {

        // move one directory up

        TInt marker(iCurrentPath.Length());

        // find second last dir marker

        for (TInt i=iCurrentPath.Length()-2; i>=0; i--)

            {

            if (iCurrentPath[i] == '\\')

                {

                marker = i;

                break;

                }

            }

        iCurrentPath = iCurrentPath.LeftTPtr(marker+1);

        }    

    // update view

    RefreshViewL();        

    }

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

void CFileBrowserDestinationFolderSelectionDlg::MoveDownToDirectoryL()

    {

    TInt index = ListBox()->CurrentItemIndex();

    if (index >= 0)

        {

        if (IsDriveListViewActive())

            {

            // currently in a drive list view, move to root of selected drive

            if (iDriveEntryList->Count() > index)

                {

                TDriveEntry driveEntry = iDriveEntryList->At(index);

                iCurrentPath.Append(driveEntry.iLetter);    

                iCurrentPath.Append(_L(":\\"));

                }

            }

        else

            {

            // this needed because we have an extra item in the listbox

            index--;

            // append the new directory

            if (iFileEntryList->Count() > index)

                {

                TFileEntry fileEntry = iFileEntryList->At(index);

                if (fileEntry.iEntry.IsDir())

                    {

                    iCurrentPath.Append(fileEntry.iEntry.iName);

                    iCurrentPath.Append(_L("\\"));

                    }

                }

            }

        // update view

        RefreshViewL();

        }

    }

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

void CFileBrowserDestinationFolderSelectionDlg::RefreshViewL()

    {

    CDesCArray* textArray = new(ELeave) CDesCArrayFlat(16);

    if (IsDriveListViewActive())

        {

        _LIT(KSimpleDriveEntry, "%d\t%c: <%S>\t\t");

        for (TInt i=0; i<iDriveEntryList->Count(); i++)

            {

            TFileName textEntry;

            TDriveEntry driveEntry = iDriveEntryList->At(i);

            textEntry.Format(KSimpleDriveEntry, driveEntry.iIconId, TUint(driveEntry.iLetter), &driveEntry.iMediaTypeDesc);

            textArray->AppendL(textEntry);

            }

        // set default LSK label

        ButtonGroupContainer().SetCommandL(0, EAknSoftkeyOk, _L("Open drive"));

        ButtonGroupContainer().DrawNow();

        }

    else

        {

        // first get the directory list

        iFileEntryList->Reset();

        CDir* dir = NULL;

        if (iFs.GetDir(iCurrentPath, KEntryAttDir|KEntryAttMatchMask, ESortByName | EAscending | EDirsFirst, dir) == KErrNone)

            {

            CleanupStack::PushL(dir);

            for (TInt i=0; i<dir->Count(); i++)

                {

                TFileEntry fileEntry;

                fileEntry.iPath = iCurrentPath;

                fileEntry.iEntry = (*dir)[i];

                fileEntry.iDirEntries = KErrNotFound;

                fileEntry.iIconId = EFixedIconEmpty;

                // check for directory entries

                if (fileEntry.iEntry.IsDir())

                    {

                    fileEntry.iIconId = EFixedIconFolder;

                    TFileName subPath = fileEntry.iPath;

                    subPath.Append(fileEntry.iEntry.iName);

                    subPath.Append(_L("\\"));

                    // check if any sub directories                

                    CDir* subDir = NULL;

                    if (iFs.GetDir(subPath, KEntryAttDir|KEntryAttMatchMask, ESortNone | EDirsFirst, subDir) == KErrNone)

                        {

                        fileEntry.iDirEntries = subDir->Count();

                        for (TInt j=0; j<subDir->Count(); j++)

                            {

                            TEntry entry = (*subDir)[j];

                            if (entry.IsDir())

                                {

                                fileEntry.iIconId = EFixedIconFolderSub;

                                break;    

                                }

                            }

                        delete subDir;    

                        }

                    }

                iFileEntryList->AppendL(fileEntry);

                }

            CleanupStack::PopAndDestroy(); //dir    

            }        

        _LIT(KSimpleFileEntry, "%d\t%S\t\t");

        // append current folder item

        TParse nameParser;

        TInt err = nameParser.SetNoWild(iCurrentPath.LeftTPtr(iCurrentPath.Length()-1), NULL, NULL);

        TFileName currentFolderName = nameParser.Name();

        if (currentFolderName == KNullDesC)

            currentFolderName.Copy(_L("[root level]"));

        TFileName currentDirTextEntry;

        currentDirTextEntry.Format(KSimpleFileEntry, EFixedIconFolderCurrent, &currentFolderName);

        textArray->AppendL(currentDirTextEntry);

        for (TInt i=0; i<iFileEntryList->Count(); i++)

            {

            TFileName textEntry;

            TFileEntry fileEntry = iFileEntryList->At(i);

            textEntry.Format(KSimpleFileEntry, fileEntry.iIconId, &fileEntry.iEntry.iName);

            textArray->AppendL(textEntry);

            }

         // set default LSK label

        ButtonGroupContainer().SetCommandL(0, EAknSoftkeyOk, iLSKActionText);

        ButtonGroupContainer().DrawNow();

        }

    if (iCurrentPath == KNullDesC)

        iEikonEnv->InfoMsgWithDuration(_L("<- up dir  down dir ->"), TTimeIntervalMicroSeconds32(KMaxTInt));

    else

        iEikonEnv->InfoMsgWithDuration(iCurrentPath, TTimeIntervalMicroSeconds32(KMaxTInt));

    SetItemTextArray(textArray);

    SetOwnershipType(ELbmOwnsItemArray);

    ListBox()->HandleItemAdditionL();

    Layout();

    ListBox()->SetCurrentItemIndex(0);

    DrawDeferred();

    }

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

TBool CFileBrowserDestinationFolderSelectionDlg::RunCopyDlgLD()

    {

    iLSKActionText.Copy(_L("Copy"));

    return ExecuteLD(R_COPY_TO_FOLDER_SELECTION_QUERY); 

    }

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

TBool CFileBrowserDestinationFolderSelectionDlg::RunMoveDlgLD()

    {

    iLSKActionText.Copy(_L("Move"));

    return ExecuteLD(R_MOVE_TO_FOLDER_SELECTION_QUERY); 

    }

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

TInt CAknQueryDialog::GetLeftCBAShortKeyPress()

    {

    return TInt16(0xffff & TInt16(ButtonGroupContainer().ButtonGroup()->CommandId(0)));

    }

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

TInt CAknQueryDialog::GetRightCBAShortKeyPress()

    {

    return TInt16(0xffff & TInt16(ButtonGroupContainer().ButtonGroup()->CommandId(2)));

    }

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

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

CFileBrowserAttributeEditorDlg* CFileBrowserAttributeEditorDlg::NewL(TUint& aSetAttMask, TUint& aClearAttMask, TBool& aRecurse)

    {

    CFileBrowserAttributeEditorDlg* self = new(ELeave) CFileBrowserAttributeEditorDlg(aSetAttMask, aClearAttMask, aRecurse);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

CFileBrowserAttributeEditorDlg::~CFileBrowserAttributeEditorDlg()

    {

    }

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

CFileBrowserAttributeEditorDlg::CFileBrowserAttributeEditorDlg(TUint& aSetAttMask, TUint& aClearAttMask, TBool& aRecurse) :

    iSetAttMask(aSetAttMask), iClearAttMask(aClearAttMask), iRecurse(aRecurse)

    {

    }

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