/*

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

*

*/

#include <mediaservant.rsg>

#include <StringLoader.h>

#include "cmmediaserverfull.h"

#include "cmstorerule.h"

#include "cmfillrule.h"

#include "msstoreserverssetting.h"

#include "msmultiselectionsettingpage.h"

#include "msconstants.h"

#include "msappui.h"

#include "msengine.h"

#include "msdebug.h"

#include "upnpstring.h"

// CONSTANTS

const TInt KItemArrayGranularity = 3;

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

// CMSStoreServersSetting::NewL

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

//

CMSStoreServersSetting* CMSStoreServersSetting::NewL(

                                TInt aIdentifier,

                                CCmStoreRule* aRule,

                                CMSAppUi& aAppUi,

                                TDes& aText )

    {

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

    CMSStoreServersSetting* self = CMSStoreServersSetting::NewLC(

                                             aIdentifier,

                                             aRule,

                                             aAppUi,

                                             aText );

    CleanupStack::Pop(self);

    return self;

    }

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

// CMSStoreServersSetting::NewLC

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

//

CMSStoreServersSetting* CMSStoreServersSetting::NewLC(

                                TInt aIdentifier,

                                CCmStoreRule* aRule,

                                CMSAppUi& aAppUi,

                                TDes& aText )

    {

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

    CMSStoreServersSetting* self = new (ELeave) CMSStoreServersSetting(

                                             aIdentifier,

                                             aRule,

                                             aAppUi,

                                             aText );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CMSStoreServersSetting::ConstructL

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

//

void CMSStoreServersSetting::ConstructL()

    {

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

    iSettingText = HBufC::NewL( KMaxFileName );

    // Get media server list

    iServers = iAppUi.MSEngine()->GetMediaServersL();

    // create item array

    CreateSelectionItemListL();

    SetSettingItemTextL();

    }

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

// CMSStoreServersSetting::CMSRuleServersSetting

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

//

CMSStoreServersSetting::CMSStoreServersSetting(

    TInt aIdentifier,

    CCmStoreRule* aRule,

    CMSAppUi& aAppUi,

    TDes& aText

     ) :

    CAknTextSettingItem( aIdentifier, aText ),

    iRule( aRule ),

    iAppUi( aAppUi )

    {

    }

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

// CMSStoreServersSetting::~CMSStoreServersSetting()

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

//

CMSStoreServersSetting::~CMSStoreServersSetting()

    {

    delete iSettingText;

    if ( iItemArray )

        {

        iItemArray->ResetAndDestroy();

        delete iItemArray;

        }

    if ( iServers )

        {

        iServers->ResetAndDestroy();

        iServers->Close();

        delete iServers;

        }

    }

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

// CMSStoreServersSetting::EditItemL( TBool aCalledFromMenu )

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

//

void CMSStoreServersSetting::EditItemL( TBool /*aCalledFromMenu*/ )

    {

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

    // Create setting page

    CAknSettingPage* dlg = CMSMultiselectionSettingPage::NewL(

            R_MS_STORE_SETTINGS_LOCATION_SETTING_PAGE,

            *iItemArray, EFalse );

    // launch setting page

    if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) )

        {

        DeleteAllServersFromRuleL();

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

                {

                CSelectableItem* item = iItemArray->At( index );

                TBool selected = item->SelectionStatus();

                CCmMediaServerFull* server = (*iServers)[index];

                // get server UDN

                TPtrC8 serverUDN = server->MediaServer();

                // add server

                if ( item->SelectionStatus() )

                    {

                    // set server for rule

                    iRule->AddMediaServerL( serverUDN );

                    }

                }

        SetSettingItemTextL();

        LoadL();

        // show value on screen

        UpdateListBoxTextL();

        }

    }

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

// CMSStoreServersSetting::CreateSelectionItemListL

// Creates selection item list

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

//

void CMSStoreServersSetting::CreateSelectionItemListL()

    {

    if ( iItemArray )

        {

        iItemArray->ResetAndDestroy();

        delete iItemArray;

        iItemArray = NULL;

        }

    iItemArray =

            new ( ELeave ) CSelectionItemList( KItemArrayGranularity );

    TBuf8<KMaxFileName> itemText;

    TInt serverCount(0);

    if ( iServers )

        {

        serverCount = iServers->Count();

        }

    // Cycle trough all servers

    for ( TInt idx = 0; idx < serverCount; idx++ )

        {

        // get server

        CCmMediaServerFull* server = (*iServers)[idx];

        // show only copy capable devices

        if ( server->StoreUsage() )

            {

            HBufC* devName =

                    UpnpString::ToUnicodeL( server->MediaServerName() );

            CleanupStack::PushL( devName );

            CSelectableItem* item = new ( ELeave ) CSelectableItem(

                                                    *devName, EFalse);

            CleanupStack::PushL( item );

            // item must be constructed

            item->ConstructL();

            // count of servers set to rule

            TInt ruleServerCount = iRule->MediaServerCount();

            // Cycle trough all servers

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

                {

                const TDesC8& ruleServerUDN = iRule->MediaServerL( index );

                if (ruleServerUDN == server->MediaServer()) // compare UDNs

                    {

                    // found - break this loop

                    index = ruleServerCount;

                    // found - mark selected

                    item->SetSelectionStatus( ETrue );

                    iSelectedItemCount++;

                    }

                }

            // append item to list

            iItemArray->AppendL(item);

            CleanupStack::Pop( item );

            CleanupStack::PopAndDestroy( devName );

            }

        else    // we don't need this kind of servers anymore so remove it

            {

            delete server;

            iServers->Remove( idx );

            idx--; // remove transfers next item to current index

            serverCount--; // servers on the list were reduced

            }

        }

    }

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

// CMSStoreServersSetting::DeleteAllServersFromRuleL

// Deletes all servers from rule

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

//

void CMSStoreServersSetting::DeleteAllServersFromRuleL()

    {

    LOG(_L("[MediaServant]\t CMSRuleServersSetting::\

    CMSStoreServersSetting"));

    // count of servers set to rule

    TInt ruleServerCount = iRule->MediaServerCount();

    for ( TInt index = ruleServerCount-1; index >= 0; index-- )

        {

        const TDesC8& ruleServerUDN = iRule->MediaServerL( index );

        iRule->DeleteMediaServer( ruleServerUDN );

        }

    }

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

// CMSStoreServersSetting::CountSelectedItems

// Counts selected items

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

//

TInt CMSStoreServersSetting::CountSelectedItems()

    {

    LOG(_L("[MediaServant]\t CMSRuleServersSetting::\

    CMSStoreServersSetting"));

    TInt count(0);

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

        {

        if ( (*iItemArray)[index]->SelectionStatus() )

            {

            count++;

            }

        }

    return count;

    }

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

// CMSStoreServersSetting::SetSettingItemTextL

// Sets setting item secondary text according to selected items

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

//

void CMSStoreServersSetting::SetSettingItemTextL()

    {

        TInt count = CountSelectedItems();

        HBufC* itemText = NULL;

        // no items selected

        if ( count == 0 )

            {

            itemText = StringLoader::LoadLC( R_MS_NO_SELECTED_ITEMS );

            iSettingText->Des().Copy( *itemText );

            }

        // just one item selected

        else if ( count == 1 )

            {

            TInt itemCount = iItemArray->Count();

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

                {

                CSelectableItem* item = (*iItemArray)[ index ];

                if ( item->SelectionStatus() )

                    {

                    iSettingText->Des().Copy( item->ItemText() );

                    index = itemCount; // break loop

                    }

                }

            }

        // more than one item selected

        else

            {

            itemText = StringLoader::LoadLC( R_MS_ITEM_DEVICES, count );

            // do number conversion

            TPtr ptr = itemText->Des();

            AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );

            iSettingText->Des().Copy( *itemText );

            }

        if ( itemText )

            {

            CleanupStack::PopAndDestroy( itemText );

            }

         // Set new value

         SetExternalText( *iSettingText );

    }

// End of File