/*

* 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:  CMSFillContainer class implementation

*

*/

#include <AknIconArray.h>

#include <aknlists.h>

#include <AknsUtils.h>

#include <eikclbd.h>

#include <mediaservant.rsg>

#include <mediaservant.mbg>

#include <StringLoader.h>

#include <avkon.mbg>

#include <aknlistquerydialog.h>

#include "upnpstring.h"

#include <e32math.h>

#include "cmdriveinfo.h"

#include "mserv.hlp.hrh"

#include "cmfillrule.h"

#include "msfillview.h"

#include "msappui.h"

#include "mediaservantuid.h"

#include "msengine.h"

#include "msfillcontainer.h"

#include "msconstants.h"

#include "msdebug.h"

// CONSTANTS

// Listbox granularity

const TInt KListGranularity = 5;

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

// CMSFillContainer::CMSFillContainer()

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

//

CMSFillContainer::CMSFillContainer( CMSAppUi& aAppUi, CMSFillView& aView ) :

    iMSAppUi( aAppUi ),

    iView( aView )

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::CMSFillContainer"));

    }

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

// CMSFillContainer::~CMSFillContainer()

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

//

CMSFillContainer::~CMSFillContainer()

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::~CMSFillContainer"));

    iSelectedLists.Close();

    iView.ClearCurrentNaviPaneText();

    delete iListBox; // Deletes listbox object.

    }

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

// CMSFillContainer::ConstructL()

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

//

void CMSFillContainer::ConstructL( TRect aRect )

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::ConstructL"));

    // fill quota size

    CalculateFillQuotaL();

    CreateWindowL();

    iListBox = new (ELeave) CAknSingleGraphicStyleListBox;

    // This is multiselection listbox but resource defines it as SELECTION

    // LIST because we don't want to let framework handle icon changes.

    // Framework toggles between two icons whereas we have to show multiple

    // icons.

    // Special icons are changed every time item selection or priority

    // changes. Calculations for icons are made in SetIcon()

    SetListBoxFromResourceL(iListBox, R_FILL_VIEW_LISTBOX);

    // Create icons

    CAknIconArray* icons = new (ELeave) CAknIconArray( EIconCount );

    CleanupStack::PushL( icons );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    // selected and fits icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_white_check,

                        EMbmMediaservantQgn_mserv_white_check_mask );

    // unselected and fits icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_white_uncheck,

                        EMbmMediaservantQgn_mserv_white_uncheck_mask );

    // selected and partially fits icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_yellow_check,

                        EMbmMediaservantQgn_mserv_yellow_check_mask );

    // unselected and partially fits icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_yellow_uncheck,

                        EMbmMediaservantQgn_mserv_yellow_uncheck_mask );

    // selected and doesn't fit icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_red_check,

                        EMbmMediaservantQgn_mserv_red_check_mask );

    // unselected and doesn't fit icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_red_uncheck,

                        EMbmMediaservantQgn_mserv_red_uncheck_mask );

    // video type -icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_video_list_small,

                        EMbmMediaservantQgn_mserv_video_list_small_mask );

    // image type -icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_image_list_small,

                        EMbmMediaservantQgn_mserv_image_list_small_mask );

    // music type -icon

    AppendIconToArrayL( icons, skin,

                        KMSMifFileName,

                        KAknsIIDDefault,

                        EMbmMediaservantQgn_mserv_music_list_small,

                        EMbmMediaservantQgn_mserv_music_list_small_mask );

    // mark icon for reordering mode -icon

    AppendIconToArrayL( icons, skin,

                        KAvkonMifFileName,

                        KAknsIIDDefault,

                        EMbmAvkonQgn_indi_marked_add,

                        EMbmAvkonQgn_indi_marked_add_mask );

    iListBox->ItemDrawer()->ColumnData()->SetIconArray( icons );

    CleanupStack::Pop(icons);

    // Create icon for context pane

    AknsUtils::CreateIconL( skin,

                            KAknsIIDDefault,

                            iIcon,

                            iIconMask,

                            KMSMifFileName,

                            EMbmMediaservantQgn_mserv_from_home,

                            EMbmMediaservantQgn_mserv_from_home_mask);

    // change context icon

    SetContextPaneIconL( iIcon, iIconMask );

    SetRect(aRect);

    // Get rule controller

    iFillRuleController = iMSAppUi.FillRuleController();

    // Update array

    iFillRuleController->UpdateArrayL();

    // get fill lists

    iFillListArray = iFillRuleController->FillListArray();

    // keep selections safe

    iSelectedIndexes = iListBox->SelectionIndexes();

    TInt64 capasity;

    TInt64 free;

    iMSAppUi.ReadMMCInfoL( capasity, free );

    iFreeMemory = Min( free, iQuota );

    if ( iFillListArray->Count() > 0 )

        {

        // Add data to listbox

        UpdateListBoxDataL();

        // Enable text scrolling

        iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

        // get item array

        CDesCArray* itemArray = static_cast<CDesCArray*>

                                (iListBox->Model()->ItemTextArray());

        iListBox->Model()->SetOwnershipType(ELbmOwnsItemArray);

        }

    // keep selections safe

    const CListBoxView::CSelectionIndexArray* selected =

                                            iListBox->SelectionIndexes();

    for ( TInt index = 0; index < selected->Count(); index++ )

        {

        iSelectedLists.AppendL( (*selected)[index] );

        }

    // Set highlighted item

    TInt currentItem = iMSAppUi.ParameterAgent()->FillViewFocusIndex();

    if ( currentItem >= 0 )

        {

        //Set current item

        iListBox->SetCurrentItemIndex( currentItem );

        }

    else

        {

        // first item

        // This is set when new list is created without existing lists

        iListBox->SetCurrentItemIndex( 0 );

        }

    UpdateNaviTextL();

	iPreviousItemIndex = 0;

	iDragItemIndex = 0;

    // Change middle softkey according to selection

    TBool listSelected = IsCurrentListItemActive();

    iView.SetCbaL( listSelected );

    ActivateL(); // Activates window. ( Ready to draw )

    }

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

// CMSFillContainer::CountComponentControls()

// Returns number of components.

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

//

TInt CMSFillContainer::CountComponentControls() const

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::CountComponentControls"));

    return 1; // return number of controls inside this container

    }

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

// CMSFillContainer::ComponentControl()

// Returns pointer to particular component.

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

//

CCoeControl* CMSFillContainer::ComponentControl(TInt /*aIndex*/) const

    {

    return iListBox; // return a pointer to the listbox

    }

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

// CMSFillContainer::OfferKeyEventL()

// Handles the key events.

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

//

TKeyResponse CMSFillContainer::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::OfferKeyEventL"));

    TKeyResponse response = EKeyWasNotConsumed;

    if ( aType != EEventKey )

        {

        response =  EKeyWasNotConsumed;

        }

    else if ( iListBox && iListBox->CurrentItemIndex() >= 0 )

        {

        // check if reordering mode is activated

        if ( iReorderState == EMSFillReorderActive ||

             aKeyEvent.iCode == EKeyLeftArrow ||

             aKeyEvent.iCode == EKeyRightArrow )

            {

            response = HandleReorderKeyEventL( aKeyEvent, aType );

            }

        // delete list

        else if ( aKeyEvent.iCode == EKeyBackspace )

            {

            DeleteRuleL();

            response = EKeyWasConsumed;

            }

        // activate/deactivate list

        else if ( aKeyEvent.iCode == EKeyOK )

            {

            CCmFillRule* rule =

                (*iFillListArray)[iListBox->CurrentItemIndex()]->List();

            if ( rule->Selected() == ECmSelected )

                {

                rule->SetSelected( ECmUnSelected );

                }

            else

                {

                rule->SetSelected( ECmSelected );

                }

            iView.SetListUnselected();

            UpdateListBoxDataL();

            response = EKeyWasConsumed;

            }

        // default

        else

            {

            response = iListBox->OfferKeyEventL( aKeyEvent, aType );

            }

        TCmServerState state;

        iMSAppUi.MSEngine()->ServerState( state );

        if ( ( aKeyEvent.iCode == EKeyUpArrow ||

             ( aKeyEvent.iCode == EKeyDownArrow )))

            {

            // change navi pane text to match highlighted list size

            UpdateNaviTextL();

            }

        }

#ifndef __SERIES60_31__

    if ( iReorderState == EMSFillNormal )

        {

        // Change middle softkey according to selection

        TBool listSelected = IsCurrentListItemActive();

        iView.SetCbaL( listSelected );

        }

#endif

    return response;

    }

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

// CMSFillContainer::HandleDragAndDropEventsL()

// Handles drag and drop events on touch screen

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

//

void CMSFillContainer::HandleDragAndDropEventsL( const TPointerEvent& aPointerEvent )

	{

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

	     iReorderState != EMSFillNormal )

		{

		iReorderState = EMSFillReorderActive;

	   	iDragItemIndex = iListBox->CurrentItemIndex();

		}

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

	     iReorderState == EMSFillReorderActive )

		{

		iView.HandleCommandL( EMSCmdDrop );

		TInt listBoxItem = iListBox->CurrentItemIndex();

		iListBox->SetCurrentItemIndex( iDragItemIndex );

		TKeyEvent keyEvent;

		// Move dragged item downwards

		if ( listBoxItem >= iDragItemIndex )

			{

			keyEvent.iCode = EKeyDownArrow;

        	for( TInt c = 0; listBoxItem > iDragItemIndex + c; c++ )

	        	{

	        	HandleReorderKeyEventL( keyEvent, EEventKey );

	        	}

			}

		// Move dragged item upwards

		else

			{

			keyEvent.iCode = EKeyUpArrow;

        	for( TInt c = 0; listBoxItem < iDragItemIndex - c; c++ )

	        	{

	        	HandleReorderKeyEventL( keyEvent, EEventKey );

	        	}

			}

		iListBox->SetCurrentItemIndex( listBoxItem );

		}

	}

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

// CMSFillContainer::UpdateListBoxDataL()

// Creates listbox items

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

//

void CMSFillContainer::UpdateListBoxDataL()

    {

    LOG(_L("[MediaServant]\t CMSFillContainer::UpdateListBoxDataL"));

    TInt64 freeSpace = iFreeMemory;

    TCmServerState state;

    iMSAppUi.MSEngine()->ServerState( state );

    // Keep item index safe for reordering mode because we reset the list

    TInt currentItemIndex = iListBox->CurrentItemIndex();

    // reset list size

    iSizeOfSelectedLists = 0;

    TBuf<KMaxFileName> item;

    HBufC* primary_text = HBufC::NewL( KMaxFileName );

    CleanupStack::PushL( primary_text );

    // Listbox items

    CDesCArray* itemArray = static_cast<CDesCArray*>

                                   (iListBox->Model()->ItemTextArray());

    itemArray->Reset();

    // Marked listbox item indexes

    CArrayFix<TInt>* selectionArray = new (ELeave )

                                   CArrayFixFlat<TInt>(KListGranularity);

    CleanupStack::PushL( selectionArray );

    TInt ruleCount = iFillListArray->Count();

    for ( TInt index = 0; index < ruleCount; index++ )

        {

        // Get fill rule name and put it to the listbox

        CCmFillRule* rule = (*iFillListArray)[index]->List();

        HBufC* listName = UpnpString::ToUnicodeL( rule->Name() );

        CleanupStack::PushL( listName );

        primary_text->Des().Copy( *listName );

        CleanupStack::PopAndDestroy( listName );

        // Check if rule is active and mark it in the list

        TCmFillRuleStatus status = rule->Selected();

        TInt64 listSize = (*iFillListArray)[index]->ListSize();

        if ( status == ECmSelected )

            {

            selectionArray->AppendL( index );

            TInt id = rule->ListId();

            TInt64 size = 0;

            iMSAppUi.GetFilledFilesSize( size, id );

            // list selected - add used memory size

            iSizeOfSelectedLists += ( listSize - size );

            }

        // calculate icon index

        TInt iconIndex = ListItemIconIndex( index,

                                            listSize,

                                            freeSpace );

        switch ( rule->MediaType() )

            {

            case ECmVideo:

                {

                item.Format( KSingleGraphicStyleFormatString,

                             iconIndex, primary_text, EVideoType );

                break;

                }

            case ECmImage:

                {

                item.Format( KSingleGraphicStyleFormatString,

                             iconIndex, primary_text, EImageType );

                break;

                }

            case ECmAudio:

                {

                item.Format( KSingleGraphicStyleFormatString,

                             iconIndex, primary_text, EAudioType );

                break;

                }

            default:

                {

                item.Format( KSingleGraphicStyleFormatStringNoTrailIcons,

                             iconIndex, primary_text);

                break;

                }

            }

        // Check if reorder mode is active and mark current item

        if ( iReorderState == EMSFillReorderActive &&

             index == currentItemIndex )

            {

            TBuf<2> markIconStr; // Magic: 2 characters reserverd for icon

            markIconStr.AppendNum( EMark );

            item.Append(markIconStr);

            }

        itemArray->AppendL( item );

        }

    iListBox->SetSelectionIndexesL( selectionArray );

    CleanupStack::PopAndDestroy( selectionArray );

    CleanupStack::PopAndDestroy( primary_text );

    UpdateNaviTextL();

    if( currentItemIndex > KErrNotFound && currentItemIndex < ruleCount )

        {

        iListBox->SetCurrentItemIndex( currentItemIndex );

        }

    iListBox->HandleItemAdditionL();

    }

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

// CMSFillContainer::SetFillRules()

// Sends fill rules to server

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

//

void CMSFillContainer::SetFillRules()

    {