/*
* 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 <cupnpmultiselectionui.rsg>
#include "upnpmultiselectionutility.h"
#include "upnpfilesharingengine.h"

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


//CONSTANTS

// Format string for listbox items
_LIT( KItemFormatString, "1\t%S" );

const TInt KShareNoneIndex = 0; // listbox index of "do not share"
const TInt KShareAllIndex = 1;  // listbox index of "share all"
const TInt KPredefinedSelections = 2; // Share none and share all

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

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::CUpnpMultiselectionUtility
// C++ default constructor can NOT contain any code, that
// might leave.
// --------------------------------------------------------------------------
//
CUpnpMultiselectionUtility::CUpnpMultiselectionUtility()
    {
    __LOG("CUpnpMultiselectionUtility::CUpnpMultiselectionUtility");
    iShareNoneSelected = EFalse;
    iShareAllSelected = EFalse;
    }

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

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::CollectSelectedItemsL()
// Collects selected items to member variable for later use
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::CollectSelectedItemsL( 
    CEikListBox* aListBox, TBool aFirstRun )
    {
    __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL begin");

    const CArrayFix<TInt>* indexes = NULL;

    //get the true indexes of marked items
    CAknListBoxFilterItems* filter 
            = static_cast < CAknFilteredTextListBoxModel* >     
                            ( aListBox->Model() )->Filter();
    if ( filter )
        {
        // Filter knows all.
        filter->UpdateSelectionIndexesL();
        indexes = filter->SelectionIndexes();
        }
    else
        {
        // No filter.
        indexes = aListBox->View()->SelectionIndexes();
        }
    
    if ( indexes->Count() > 0 )
        {
        // obtain selection state  
        TShareSelectionState selectionState = 
            ShareSelectionStateFromArray( *indexes );

        // make some decisions based on the tabs selected
        DoSelectionLogicL( aListBox, aFirstRun,
            indexes, filter, selectionState );

        }
    else // no items selected
        {
        __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
No items selected");

        filter->ResetFilteringL();
        aListBox->View()->SelectItemL( KShareNoneIndex );
        }

    // update iShareNoneSelected and iShareAllSelected member variables
    iShareNoneSelected = EFalse;
    iShareAllSelected = EFalse;

    const CArrayFix<TInt>* indexesAfter = NULL;

    if ( filter )
        {
        // Filter knows all.
        filter->UpdateSelectionIndexesL();
        indexesAfter = filter->SelectionIndexes();
        }
    else
        {
        // No filter.
        indexesAfter = aListBox->View()->SelectionIndexes();
        }

    for ( TInt i = 0 ; i < indexesAfter->Count() ; i++ ) 
        {
        if ( indexesAfter->At( i ) == KShareNoneIndex ) 
            {
            iShareNoneSelected = ETrue;
            }
        else if ( indexesAfter->At( i ) == KShareAllIndex ) 
            {
            iShareAllSelected = ETrue;
            }
        }

    __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL end");
    }

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::DoSelectionLogicL
// Do some decisions based on the selection state
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::DoSelectionLogicL( 
    CEikListBox* aListBox,
    TBool aFirstRun,
    const CArrayFix<TInt>* aIndexes,
    CAknListBoxFilterItems* aFilter,
    TShareSelectionState aSelectionState )
    {
    const TInt arrayGranularity( aIndexes->Count() + 1 );

    // If "do not share" was not selected before and it is now, unselect
    // all except "do not share".
    if ( ( aSelectionState == EShareNoneSelected ||
           aSelectionState == EShareNoneAndShareAllSelected ) && 
         !iShareNoneSelected )
        {
        // Create new selectionindexarray with only "do not share" 
        // selected and assign it to the listbox.
        __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL:\
Do not share selected");
        CListBoxView::CSelectionIndexArray* noneArr = 
            new (ELeave) CArrayFixFlat<TInt>( arrayGranularity );
        CleanupStack::PushL( noneArr );
        noneArr->AppendL( KShareNoneIndex );
        aListBox->SetSelectionIndexesL( noneArr );
        CleanupStack::PopAndDestroy( noneArr );
        }
    // if "share all" was not selected before and it is now, select all
    // except "do not share". 
    // OR if this method is executed first time (from PostLayoutDynInitL)
    // and share all is selected, then we trust that all items should be 
    // selected.  
    else if ( ( ( aSelectionState == EShareAllSelected || 
                  aSelectionState == EShareNoneAndShareAllSelected ) &&
                  !iShareAllSelected ) 
              || aSelectionState == EShareAllSelected && aFirstRun )
        {
        // Create new selectionindexarray with "share all" and all other
        // items except "do not share" selected and assign it to the 
        // listbox.
        __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
All files selected");
        TInt itemCount = aFilter->NonFilteredNumberOfItems();

        CListBoxView::CSelectionIndexArray* allArr = 
            new (ELeave) CArrayFixFlat<TInt>( arrayGranularity );
        CleanupStack::PushL( allArr );
        allArr->AppendL( KShareAllIndex );
        for ( TInt i( KPredefinedSelections ); i < itemCount; i++ )
            {
            allArr->AppendL( i );
            }
        aFilter->ResetFilteringL();
        aListBox->SetSelectionIndexesL( allArr );
        CleanupStack::PopAndDestroy( allArr );
        }
    // if share all selection is removed
    else if ( aSelectionState == EItemsSelected && 
              iShareAllSelected ) 
        {
        // Create new selectionindexarray with only "do not share" 
        // selected and assign it to the listbox.
        __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
Do not share selected");
        CListBoxView::CSelectionIndexArray* noneArr = 
            new (ELeave) CArrayFixFlat<TInt>( arrayGranularity );
        CleanupStack::PushL( noneArr );
        noneArr->AppendL( KShareNoneIndex );
        aListBox->SetSelectionIndexesL( noneArr );
        CleanupStack::PopAndDestroy( noneArr );
        }
    // if only some individual items have been modified
    else if ( aSelectionState == EItemsSelected && 
              !iShareAllSelected &&
              !iShareNoneSelected ) 
        {
        // do nothing. selections are kept as they are
        }
    // if share none is selected with some individual item, 
    // unselect share none
    else if ( aSelectionState == EShareNoneSelected && aIndexes->Count() > 1 ) 
        {
        // Create similar selectionindexarray without "do not share" 
        // selected and assign it to the listbox.
        __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
Do not share selected");

        for( TInt y=0; y < aIndexes->Count(); y++ )
            {
            TInt itemIndex = aIndexes->At(y);
            if ( itemIndex == 0 || itemIndex == 1 )
                {
                aListBox->View()->DeselectItem( 
                    aFilter->VisibleItemIndex(itemIndex) );
                }
            }
        }
    else if ( aSelectionState == EShareAllSelected &&
              aIndexes->Count() < aFilter->NonFilteredNumberOfItems() - 1 ) 
        {
        if ( aIndexes->Count() > 0 ) 
            {
            // all items were selected and some item (not share all) has 
            // been unselected -> remove selection also from share all.
            __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
Do not share selected");

            for( TInt y=0; y < aIndexes->Count(); y++ )
                {
                TInt itemIndex = aIndexes->At(y);
                if ( itemIndex == KShareAllIndex )
                    {
                    aListBox->View()->DeselectItem( 
                        aFilter->VisibleItemIndex( itemIndex ) );
                    }
                }
            
            if ( !aListBox->View()->SelectionIndexes()->Count() ) 
                {
                // Last individual item has been unselected.
                // Create new selectionindexarray with only 
                // "do not share" selected and assign it to the listbox.
                __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
Do not share selected");
                CListBoxView::CSelectionIndexArray* noneArr = 
                    new (ELeave) CArrayFixFlat<TInt>( arrayGranularity );
                CleanupStack::PushL( noneArr );
                noneArr->AppendL( KShareNoneIndex );
                aListBox->SetSelectionIndexesL( noneArr );
                CleanupStack::PopAndDestroy( noneArr );
                }
            }
        else 
            {
            // some item unselected and no other items left except 
            // "share all"

            // Create new selectionindexarray with only "do not share" 
            // selected and assign it to the listbox.
            __LOG("CUpnpMultiselectionUtility::CollectSelectedItemsL: \
Do not share selected");
            CListBoxView::CSelectionIndexArray* noneArr = 
                new (ELeave) CArrayFixFlat<TInt>( arrayGranularity );
            CleanupStack::PushL( noneArr );
            noneArr->AppendL( KShareNoneIndex );
            aListBox->SetSelectionIndexesL( noneArr );
            CleanupStack::PopAndDestroy( noneArr );
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::ConvertSelectionsForEngineL
// Convert the selections from UI to engine as "old style selections"
// Has effect only if "Share All" is selected
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::ConvertSelectionsForEngineL( 
    CArrayFix<TInt>& aSelections ) const
    {
    __LOG("CUpnpMultiselectionUtility::ConvertSelectionsForEngineL begin");

    for ( TInt i(0); i < aSelections.Count(); i++ )
        {
        if ( aSelections.At( i ) == KShareAllIndex )
            {
            aSelections.Reset();
            aSelections.AppendL( KShareAllIndex );
            i = aSelections.Count();
            }
        }
    
    __LOG("CUpnpMultiselectionUtility::ConvertSelectionsForEngineL end");
    }


// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::AppendIconToArray
// Load a possibly skinned icon (with mask) and append it to an
// icon array.
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::AppendIconToArrayL(CAknIconArray* aArray,
                                               MAknsSkinInstance* aSkin,
                                               const TDesC& aMbmFile,
                                               const TAknsItemID& aID,
                                               TInt aBitmapId,
                                               TInt aMaskId) const
    {
    __LOG("CUpnpMultiselectionUtility::AppendIconToArrayL begin");

    __ASSERT_DEBUG(aArray != NULL, User::Leave(KErrArgument));

    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;

    AknsUtils::CreateIconLC( aSkin, aID,
        bitmap, mask, aMbmFile, aBitmapId, aMaskId );

    CGulIcon* icon = CGulIcon::NewL( bitmap, mask );
    icon->SetBitmapsOwnedExternally( EFalse );

    // icon now owns the bitmaps, no need to keep on cleanup stack.
    CleanupStack::Pop(2); // mask, bitmap
    bitmap = NULL;
    mask = NULL;

    CleanupStack::PushL( icon );

    aArray->AppendL( icon );

    // aArray now owns the icon, no need to delete.
    CleanupStack::Pop(icon);
    __LOG("CUpnpMultiselectionUtility::AppendIconToArrayL end");

    }

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::AppendShareAllSelectionL
// Appends "share all files" item to the listbox
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::AppendShareAllSelectionL(
                                    CDesCArray* aListBoxArray ) const
    {
    __LOG("CUpnpMultiselectionUtility::AppendShareAllSelectionL begin");
    HBufC* item = HBufC::NewL( KMaxFileName );
    CleanupStack::PushL( item );
    HBufC* item2 = HBufC::NewL( KMaxFileName );
    CleanupStack::PushL( item2 );
    HBufC* itemText1 = StringLoader::LoadLC( 
        R_UPNP_MULTISELECTION_SHARE_ALL_TEXT );
    HBufC* itemText2 = StringLoader::LoadLC(
        R_UPNP_MULTISELECTION_DO_NOT_SHARE_TEXT );
    // create item string for the listbox (icon + album name)
    item->Des().Format( KItemFormatString, itemText1 );
    item2->Des().Format( KItemFormatString, itemText2 );
    // append "share all files" -selection to the listbox
    aListBoxArray->AppendL( item2->Des() );
    aListBoxArray->AppendL( item->Des() );

    CleanupStack::PopAndDestroy(2); // stringloader
    CleanupStack::PopAndDestroy(2); // item item2
    __LOG( "CUpnpMultiselectionUtility::AppendShareAllSelectionL end" );
    }
    
// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::SetShareSelectionState
// (Commented in the header)
// --------------------------------------------------------------------------
//
void CUpnpMultiselectionUtility::SetShareSelectionState( 
    TShareSelectionState aSelectionState ) 
    {
    switch ( aSelectionState )
        {
        case EShareNoneSelected:
            {
            iShareNoneSelected = ETrue;
            iShareAllSelected = EFalse;
            break;
            }
        case EShareAllSelected:
            {
            iShareNoneSelected = EFalse;
            iShareAllSelected = ETrue;
            break;
            }
        case ENoShareNoneOrShareAllSelected:
            {
            iShareNoneSelected = EFalse;
            iShareAllSelected = EFalse;
            break;
            }
        default:
            {
            // Should not be reached.
            break;
            }
        }
    }

// --------------------------------------------------------------------------
// CUpnpMultiselectionUtility::ShareSelectionStateFromArray
// (Commented in the header)
// --------------------------------------------------------------------------
//
TShareSelectionState 
    CUpnpMultiselectionUtility::ShareSelectionStateFromArray( 
    const CArrayFix<TInt>& aIndexes ) const
    {
    TShareSelectionState retval = EUndefined;
    TBool shareNoneFound = EFalse;
    TBool shareAllFound = EFalse;
    TBool itemsSelected = EFalse;
        
    // Check if the indexes array contains do not share or share all.
    for ( TInt i = 0 ; i < aIndexes.Count() ; i++ ) 
        {
        if ( aIndexes.At( i ) == KShareNoneIndex ) 
            {
            shareNoneFound = ETrue;
            }
        else if ( aIndexes.At( i ) == KShareAllIndex )  
            {
            shareAllFound = ETrue;
            }
        }

    // 
    if ( !shareAllFound && !shareNoneFound ) 
        {
        // "do not share" or "share all" are not selected. Check if there are
        // other items selected.
        if ( aIndexes.Count() ) 
            {
            itemsSelected = ETrue;
            }
        }

    // set retval
    if ( itemsSelected ) 
        {
        retval = EItemsSelected;
        }    
    else if ( shareNoneFound && !shareAllFound ) 
        {
        retval = EShareNoneSelected;
        }
    else if ( !shareNoneFound && shareAllFound ) 
        {
        retval = EShareAllSelected;
        }    
    else if ( shareNoneFound && shareAllFound ) 
        {
        retval = EShareNoneAndShareAllSelected;
        }
    else if ( !shareNoneFound && !shareAllFound ) 
        {
        retval = ENoShareNoneOrShareAllSelected;
        }
    
    return retval;
    }


// End of file