/*
* Copyright (c) 2008 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:      Multiselection dialog implementation
*
*/






// INCLUDE FILES
#include <StringLoader.h>
#include <avkon.mbg>
#include <eikclbd.h>
#include <aknlists.h>
#include <AknsUtils.h>
#include <eikcmbut.h>
#include "upnpappmultiselectiondialog.h"
#include "upnpfilesharingengine.h"

#include "cupnpmultiselectionui.hrh"
#include <cupnpmultiselectionui.rsg>

_LIT( KComponentLogfile, "multiselectionui.txt");
#include "upnplog.h"


//CONSTANTS
const TInt KOkSoftkeyCode = 63585;

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

// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::NewL
// Two-phased constructor.
// --------------------------------------------------------------------------
//
CUPnPAppMultiselectionDialog* CUPnPAppMultiselectionDialog::NewL(
                        THomeConnectMediaType aMediaType,
                        CUPnPFileSharingEngine* aFileSharingEngine,
                        CArrayFix<TInt>* aSelectionIndexArray )
    {
    __LOG("CUPnPAppMultiselectionDialog::NewL begin");

    CUPnPAppMultiselectionDialog* self =
                        new(ELeave) CUPnPAppMultiselectionDialog();

    CleanupStack::PushL(self);
    self->ConstructL( aMediaType, aFileSharingEngine, aSelectionIndexArray );
    CleanupStack::Pop(self);
    __LOG("CUPnPAppMultiselectionDialog::NewL end");
    return self;
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::ConstructL
// Symbian 2nd phase constructor can leave.
// --------------------------------------------------------------------------
//
void CUPnPAppMultiselectionDialog::ConstructL(
                        THomeConnectMediaType aMediaType,
                        CUPnPFileSharingEngine* aFileSharingEngine,
                        CArrayFix<TInt>* aSelectionIndexArray )
    {
    __LOG("CUPnPAppMultiselectionDialog::ConstructL begin");
    CAknSelectionListDialog::ConstructL( R_AVKON_SOFTKEYS_EMPTY );
    iMediaType = aMediaType;
    iFileSharingEngine = aFileSharingEngine;

    iMarkedItems = aSelectionIndexArray;
    iUtility = new (ELeave) CUpnpMultiselectionUtility();

    iMskSelectText = 
        StringLoader::LoadL( R_UPNP_MULTISELECTION_SELECT_TEXT );
    iMskUnselectText = 
        StringLoader::LoadL( R_UPNP_MULTISELECTION_UNSELECT_TEXT );

    __LOG("CUPnPAppMultiselectionDialog::ConstructL end");
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::CUPnPAppMultiselectionDialog
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUPnPAppMultiselectionDialog::CUPnPAppMultiselectionDialog()
: CAknSelectionListDialog(iSelectedItem, NULL, NULL), iSelectedItem(0)
    {
    __LOG("CUPnPAppMultiselectionDialog::CUPnPAppMultiselectionDialog");
    }

// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::CUPnPAppMultiselectionDialog
// C++ default destructor.
// --------------------------------------------------------------------------
//
CUPnPAppMultiselectionDialog::~CUPnPAppMultiselectionDialog()
    {
    __LOG("CUPnPAppMultiselectionDialog::~CUPnPAppMultiselectionDialog");

    iFileSharingEngine = NULL;

    delete iUtility;
    delete iMskSelectText;
    delete iMskUnselectText;

    __LOG("CUPnPAppMultiselectionDialog::~CUPnPAppMultiselectionDialog end");
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::OkToExitL(TInt aButtonId)
// called by framework when the softkey is pressed
// --------------------------------------------------------------------------
//
TBool CUPnPAppMultiselectionDialog::OkToExitL(TInt aButtonId)
    {
    __LOG("CUPnPAppMultiselectionDialog::OkToExitL begin");
    TBool ret( EFalse );
    if ( aButtonId == EAknSoftkeyOk )
        {
        TBool showWaitNote( ETrue );

        const CArrayFix<TInt>* selected;

        //get the true indexes of marked items
        CAknListBoxFilterItems* filter 
                = static_cast < CAknFilteredTextListBoxModel* >     
                                ( iListBox->Model() )->Filter();
        if ( filter )
            {
            // Filter knows all.
            filter->UpdateSelectionIndexesL();
            selected = filter->SelectionIndexes();
            }
        else
            {
            // No filter.
            selected = ListBox()->View()->SelectionIndexes();
            }
            
        // Show wait note if needed.
        CAknWaitNoteWrapper* waitNoteWrapper( NULL );
        if ( selected->Count() == 1 && selected->At( 0 ) == 0 )
            {
            showWaitNote = EFalse;
            }
        if ( showWaitNote )
            {
            waitNoteWrapper = CAknWaitNoteWrapper::NewL();
            CleanupStack::PushL(reinterpret_cast<CBase*>(waitNoteWrapper));
            waitNoteWrapper->ExecuteL(
                R_UPNP_MULTISELECTION_COLLECTING_FILES_NOTE,      // TInt aResId,
                *this,            // MAknBackgroundProcess& aBackgroundProcess
                ETrue);
            }

        // give the selection indexes to filesharing engine
        iMarkedItems->Reset();
        for( TInt i(0); i<selected->Count(); i++ )
            {
            iMarkedItems->AppendL( selected->At( i ) );
            }
        iUtility->ConvertSelectionsForEngineL( *iMarkedItems );

        if ( showWaitNote )
            {
            CleanupStack::PopAndDestroy(waitNoteWrapper);
            }
        ret = ETrue;
        }

   else if ( aButtonId == EAknSoftkeySelect )
       {
       // msk event    
       __LOG("CUPnPAppMultiselectionDialog::msk event");
       TKeyEvent tmpEvent;
       tmpEvent.iCode = EKeyOK;
       tmpEvent.iModifiers = 0;
       tmpEvent.iRepeats = 0;
       tmpEvent.iScanCode = 0;
       TEventCode eventType = EEventKey;
       OfferKeyEventL( tmpEvent, eventType );
       
       }
   else if ( aButtonId == EAknSoftkeyBack )
        {
        ret = ETrue;
        }

    __LOG("CUPnPAppMultiselectionDialog::OkToExitL end");
    return ret;
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::PreLayoutDynInitL();
// called by framework before dialog is shown
// --------------------------------------------------------------------------
//
void CUPnPAppMultiselectionDialog::PreLayoutDynInitL()
    {
    __LOG("CUPnPAppMultiselectionDialog::PreLayoutDynInitL begin");

    iListBox = static_cast<CAknSingleGraphicStyleListBox*>
        (Control(EMultiSelectionListBoxId));

    // display find box
    SetupFind( CAknSelectionListDialog::EAdaptiveFind );

    // get pointer to listbox data array
    iModel = STATIC_CAST(
        CAknFilteredTextListBoxModel*, iListBox->Model() );
    iSettingsTextArray = static_cast<CDesCArray*>(
        iModel->ItemTextArray() );

    iUtility->AppendShareAllSelectionL( iSettingsTextArray );

 
    iFileSharingEngine->RequestSelectionContentL( iMediaType );
    iState = ELoadContent;

    CAknWaitNoteWrapper* waitNoteWrapper = CAknWaitNoteWrapper::NewL();
    CleanupStack::PushL(reinterpret_cast<CBase*>(waitNoteWrapper));
    waitNoteWrapper->ExecuteL(
        R_UPNP_MULTISELECTION_SEARCHING_FILES_NOTE,      // TInt aResId,
        *this,           // MAknBackgroundProcess& aBackgroundProcess
        EFalse);   // ETrue = Show immediately

    CleanupStack::PopAndDestroy(waitNoteWrapper);

    CAknIconArray* icons = new (ELeave) CAknIconArray(2);
    CleanupStack::PushL( icons );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    TFileName iconsPath( AknIconUtils::AvkonIconFileName( ) );

    iUtility->AppendIconToArrayL( icons, skin,
                        iconsPath,
                        KAknsIIDQgnPropCheckboxOn,
                        EMbmAvkonQgn_prop_checkbox_on,
                        EMbmAvkonQgn_prop_checkbox_on_mask );

    iUtility->AppendIconToArrayL( icons, skin,
                        iconsPath,
                        KAknsIIDQgnPropCheckboxOff,
                        EMbmAvkonQgn_prop_checkbox_off,
                        EMbmAvkonQgn_prop_checkbox_off_mask );


    iListBox->ItemDrawer()->ColumnData()->SetIconArray( icons );
    CleanupStack::Pop( icons );

    iListBox->ActivateL();


    // set dialog title
    CEikStatusPane* statusPane =
                    (( CAknAppUi* )iEikonEnv->EikAppUi() )->StatusPane();
    iTitlePane = (CAknTitlePane*)statusPane->ControlL(
                    TUid::Uid(EEikStatusPaneUidTitle));

    if ( iMediaType == EImageAndVideo )
        {
        iTitlePane->SetTextL( *StringLoader::LoadLC(
                                R_UPNP_MULTISELECTION_SHARING_VISUAL_TITLE_TEXT) );
        }
    else
        {
        iTitlePane->SetTextL( *StringLoader::LoadLC(
                                R_UPNP_MULTISELECTION_SHARING_MUSIC_TITLE_TEXT) );
        }
    CleanupStack::PopAndDestroy();

    CAknSelectionListDialog::PreLayoutDynInitL();
    __LOG("CUPnPAppMultiselectionDialog::PreLayoutDynInitL end");
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::PostLayoutDynInitL()
// Called by framework before dialog is shown.
// Needed because filter is not active until PreLayoutDynInitL().
// --------------------------------------------------------------------------
//
void  CUPnPAppMultiselectionDialog::PostLayoutDynInitL()
    {
    __LOG("CUPnPAppMultiselectionDialog::PostLayoutDynInitL begin");

    // Get state of do not share and share all selections and set them 
    // to utility.
    TShareSelectionState selectionState = 
        iUtility->ShareSelectionStateFromArray( *iMarkedItems );
    iUtility->SetShareSelectionState( selectionState );
    
    // filter out the first character of the search string
    FindBox()->SetListColumnFilterFlags(0xFFFFFFFE);
    
    //mark selected albums
    if ( iMarkedItems )
        {
        if ( iMarkedItems->Count() )
            {
            //
            iListBox->SetSelectionIndexesL( iMarkedItems );
            }
        }
    iUtility->CollectSelectedItemsL( iListBox, ETrue );

    //set msk's label depending on is item selected or not
    HBufC* mskLabel( iMskSelectText );
    if( iListBox->View()->ItemIsSelected( iListBox->CurrentItemIndex() ) )
        {
        mskLabel = iMskUnselectText;
        }
    ButtonGroupContainer().SetCommandL( EAknSoftkeySelect, *mskLabel );

    __LOG("CUPnPAppMultiselectionDialog::PostLayoutDynInitL end");
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::OfferKeyEventL();
// called by framework when key is pressed
// --------------------------------------------------------------------------
//
TKeyResponse CUPnPAppMultiselectionDialog::OfferKeyEventL(
            const TKeyEvent &aKeyEvent,
            TEventCode aType)
    {
    __LOG("CUPnPAppMultiselectionDialog::OfferKeyEventL begin"); 
    
    TKeyResponse status( EKeyWasNotConsumed );
    if ( aType == EEventKey ) // Is not key event
        {
        if (aKeyEvent.iCode == EKeyOK)
            {
            status = iListBox->OfferKeyEventL( aKeyEvent, aType );
            iUtility->CollectSelectedItemsL( iListBox );
            }
        else if (aKeyEvent.iCode == KOkSoftkeyCode)
            {
            // disable draw
            iListBox->View()->SetDisableRedraw(ETrue);
            status = CAknSelectionListDialog::OfferKeyEventL(aKeyEvent,aType);
            }
        else
            {
            // Let the Akn dialog handle the key event.
            // EKeyEscape key event deletes this dialog.
            status = CAknSelectionListDialog::OfferKeyEventL(aKeyEvent,aType);
            }
        }

    //
    // Set msk's label depending on is item selected or not.
    //
    // In case of EKeyEscape we cannot access objects in heap any more.
    // Only local variables in stack. This is because CAknSelectionListDialog
    // ::OfferKeyEventL deletes this dialog. When call returns heap memory is cleared
    // and we cannot rely on values of member variables.
    //
    if ( status == EKeyWasConsumed &&
         aKeyEvent.iCode != EKeyEscape )
        {
        HBufC* mskLabel(iMskSelectText);
        if( iListBox->View()->ItemIsSelected( 
                iListBox->CurrentItemIndex() ) )
            {
            mskLabel = iMskUnselectText;
            }
        ButtonGroupContainer().SetCommandL( EAknSoftkeySelect, *mskLabel );
        ButtonGroupContainer().DrawDeferred();
        }

    __LOG("CUPnPAppMultiselectionDialog::OfferKeyEventL end");
    return status;
    }

    
// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::StepL
// Step done during wait note
// --------------------------------------------------------------------------
//
void CUPnPAppMultiselectionDialog::StepL(void)
    {
    switch ( iState )
        {
        case ELoadContent:
            {
            TRAPD( err, iFileSharingEngine->GetSelectionContentL( 
                *iSettingsTextArray ) );
            if ( err == KErrNone )
                {
                iState = ELoadIndexes;
                iFileSharingEngine->RequestSelectionIndexesL( iMediaType );
                }
            else if ( err == KErrInUse )
                {
                //do nothing, request is being proceeded
                }
            else
                {
                User::Leave( err );
                }
            break;
            }
        case ELoadIndexes:
            {
            TRAPD( err, iFileSharingEngine->GetSelectionIndexesL( 
                *iMarkedItems ) );
            if ( err == KErrNone )
                {
                iState = ELoadDone;
                iDone = ETrue;
                }
            else if ( err == KErrInUse )
                {
                //do nothing, request is being proceeded
                }
            else
                {
                User::Leave( err );
                }
            break;
            }
        case ELoadDone:
            {
            break;
            }
        default:
            {
            __PANICD( __FILE__, __LINE__ );
            break;
            }
        }
    }


// --------------------------------------------------------------------------
// CUPnPAppMultiselectionDialog::IsProcessDone
// Returns ETrue if process finished
// --------------------------------------------------------------------------
//
TBool CUPnPAppMultiselectionDialog::IsProcessDone(void) const
    {
    return iDone;
    }

// End of file