/*
* Copyright (c) 2006 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:  Container for the sensor settings
*
*/



// INCLUDE FILES
#include "gssensorplugincontainer.h"
#include "gssensormskobserver.h"
#include "gssensorpluginmodel.h"
#include "gssensorplugin.hrh"
#include "gssensorplugin_debug.h"

#include <aknlists.h>
#include <csxhelp/cp.hlp.hrh>
#include <gsfwviewuids.h>     // for KUidGS
#include <gssensorpluginrsc.rsg>
#include <gslistbox.h>
#include <gsplugininterface.h>

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

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::ConstructL
// This constructL is not used
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::ConstructL( const TRect& /*aRect*/ )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ConstructL() - deprecated" );
    User::Leave( KErrArgument );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::ConstructL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::ConstructL( 
    const TRect& aRect,
    CAknViewAppUi* aAppUi,
    CArrayPtrFlat<CGSPluginInterface>* aPluginArray )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ConstructL()" );

    iAppUi = aAppUi;
    iPluginArray = aPluginArray;

    // Create list box and parent container
    iListBox = new ( ELeave ) CAknSettingStyleListBox;
    BaseConstructL( aRect, R_GS_SEN_VIEW_TITLE, R_GS_SEN_DOUBLE_LBX );

    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ConstructL() - return" );  
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::~CGSSensorPluginContainer
// ---------------------------------------------------------------------------
//
CGSSensorPluginContainer::~CGSSensorPluginContainer()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::~CGSSensorPluginContainer()" );

    if ( iListboxItemArray )
        {
        delete iListboxItemArray;
        }

     if ( iListBoxTextArray )
        {
        iListBoxTextArray->Reset();
        delete iListBoxTextArray;
        }
    
    if ( iSensorStatusText )
        {
        iSensorStatusText->Reset();
        delete iSensorStatusText;
        }

    if ( iListItems )
        {
        iListItems->Reset();
        delete iListItems;
        }

    iModel = NULL;
    iAppUi = NULL;
    iPluginArray = NULL;

    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::~CGSSensorPluginContainer() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::CGSSensorPluginContainer
// ---------------------------------------------------------------------------
//
CGSSensorPluginContainer::CGSSensorPluginContainer( 
    CGSSensorPluginModel* aModel,
    MGSSensorMskObserver& aMskObserver )
    : iModel ( aModel ),
      iMskObserver( aMskObserver )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::CGSSensorPluginContainer()" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::ConstructListBoxL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::ConstructListBoxL( TInt aResLbxId )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ConstructListBoxL()" );
    iListBox->ConstructL( this, EAknListBoxSelectionList );
    iListboxItemArray = CGSListBoxItemTextArray::NewL( aResLbxId, *iListBox, *iCoeEnv );
    iListBoxTextArray = static_cast<CDesCArray*>( iListBox->Model()->ItemTextArray() );
    iListBox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );

    // Get sensors activation status and set text 'On' or 'Off' to list view below 
    // Sensors list item
    iSensorStatusText = iCoeEnv->ReadDesC16ArrayResourceL( R_GS_SENSOR_ACTIVE_STATUS );
    iListItems = iCoeEnv->ReadDesC16ArrayResourceL( R_GS_SEN_DOUBLE_LBX_TEXT );
    // Create and make visible list box items
    CreateListBoxItemsL();

    iListBox->HandleItemAdditionL();
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ConstructListBoxL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::CreateListBoxItemsL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::CreateListBoxItemsL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::CreateListBoxItemsL()" );

    iGeneralItemCount = 0;

    const TUint32 tapVariation = iModel->VariationListL( EGSSenTapping );
    const TUint32 turnVariation = iModel->VariationListL( EGSSenTurning );

    if ( tapVariation ||turnVariation )
        {
        // Make Sensors active status visible if there is at least one enabled use case
        MakeSensorsItemL();
        iGeneralItemCount++;
        
        if ( !tapVariation )
            {
            iListboxItemArray->SetItemVisibilityL( EGSTapCtrlListItemId,
                CGSListBoxItemTextArray::EInvisible );
            }
        else
            {
            MakeTapCtrlItemL();
            iGeneralItemCount++;
            }
        
        if ( !turnVariation )
            {
            iListboxItemArray->SetItemVisibilityL( EGSTurnCtrlListItemId,
                CGSListBoxItemTextArray::EInvisible );
            }
        else
            {
            MakeTurnCtrlItemL();
            iGeneralItemCount++;
            }
        }

    if ( iPluginArray )
        {
        MakeExtendedPluginsItemL();
        }


    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::CreateListBoxItemsL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::UpdateListBoxL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::UpdateListBoxL( TInt aFeatureId )
    {
    TRACE_1( "[GSSensorPlugin] CGSSensorPluginContainer::UpdateListBoxL() - feature: %i", 
        aFeatureId );
    switch ( aFeatureId )
        {
        case EGSSensorsListItemId:
            {
            // Delete current text and then create new
            iListBoxTextArray->Delete( EGSSensorsListItemId );
            MakeSensorsItemL();
            break;
            }
        case EGSExtPluginsListItemId:
            MakeExtendedPluginsItemL();
            break;
        case EGSTapCtrlListItemId:
        case EGSTurnCtrlListItemId:
        case EGSOrientationListItemId:
        default:
            break;
        }

    // Draw listbox again
    iListBox->HandleItemAdditionL();
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::UpdateListBoxL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::MakeSensorsItemL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::MakeSensorsItemL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeSensorsItemL()" );
    const TInt sensorsStatus = iModel->SensorActiveStatusL();
    SetSensorStatusTextL( sensorsStatus );
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeSensorsItemL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::MakeTapCtrlItemL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::MakeTapCtrlItemL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeTapCtrlItemL()" );
    AppendListItemL( EGSTapCtrlListItemId, 
                     iListItems->operator[]( EGSTapCtrlListItemId ), 
                     KNullDesC16 );
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeTapCtrlItemL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::MakeTurnCntrItemL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::MakeTurnCtrlItemL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeTurnCtrlItemL()" );
    AppendListItemL( EGSTurnCtrlListItemId, 
                     iListItems->operator[]( EGSTurnCtrlListItemId ), 
                     KNullDesC16 );
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeTurnCtrlItemL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::MakeOrientationItemL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::MakeOrientationItemL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeOrientationItemL()" );
    User::Leave( KErrNotSupported );
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeOrientationItemL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::MakeExtendedPluginsItemL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::MakeExtendedPluginsItemL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeExtendedPluginsItemL()" );
    // Create list item for all child plug-ins
    const TInt pluginCount( iPluginArray->Count() );
    CGSPluginInterface* plugin = NULL;

    const TUint32 tapVariation = iModel->VariationListL( EGSSenTapping );
    const TUint32 turnVariation = iModel->VariationListL( EGSSenTurning );

    if ( ( pluginCount == 1 ) && ( !tapVariation && !turnVariation ) )
        {
        ActivateExtendedPluginL();
        }
    else
        {
        // 1) Read item descriptor from plugin:
        TBuf<KGSBufSize128> caption;

        for ( TInt i = 0; i < pluginCount; i++ )
            {
            plugin = iPluginArray->operator[]( i );
            plugin->GetCaptionL( caption );
            // Append text to list
            AppendListItemL( KErrNotFound, caption, KNullDesC16 );
            }
        }
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::MakeExtendedPluginsItemL() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::ActivateExtendedPluginL
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::ActivateExtendedPluginL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ActivateExtendedPluginL()" );
    // Not local view, try plugins
    if ( iPluginArray->Count() == 1)
        {
        CGSPluginInterface* selectedPlugin = iPluginArray->operator[]( 0 );
    
        switch( selectedPlugin->ItemType() )
            {
            // In these cases the plugin is a view:
            case EGSItemTypeSingleLarge:
            case EGSItemTypeSetting:
            case EGSItemTypeSettingIcon:
                {
                CleanupStack::PushL( selectedPlugin );
                iAppUi->ActivateLocalViewL( selectedPlugin->Id() );
                CleanupStack::Pop( selectedPlugin );
                break;
                }
                
            // In these cases the plugin is a dialog:
            case EGSItemTypeSettingDialog:
            case EGSItemTypeSingleLargeDialog:
                 selectedPlugin->HandleSelection( EGSSelectionByMenu );
                 break;
            default:
                break;
            }
        }
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::ActivateExtendedPluginL() - return" );
    }


// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::AppendListItem
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::AppendListItemL( 
    const TInt aPos,
    const TDesC16& aFirstLabel, 
    const TDesC16& aSecondLabel )
    {
    TBuf<KGSBufSize128> itemText;
    _LIT( KSpaceAndTab, " \t" );
    _LIT( KTab, "\t" );

    // The format is: " \tFirstLabel\tSecondLabel\t0\t0"
    // First, append space and tab
    itemText.Append( KSpaceAndTab );
    itemText.Append( aFirstLabel );
    itemText.Append( KTab );
    itemText.Append( KTab );
    // Currently this is used only to show sensors active status (on/off)
    itemText.Append( aSecondLabel ); 

    // No need to add last tabs
    if ( ( KErrNotFound != aPos ) && ( aPos <= iListBoxTextArray->Count() ) )
        {
        iListBoxTextArray->InsertL( aPos, itemText );
        }
    else
        {
        iListBoxTextArray->AppendL( itemText );
        }
    }

// -----------------------------------------------------------------------------
// CGSSensorPluginContainer::SelectedPlugin
// Returns pointer to selected plugin
// -----------------------------------------------------------------------------
//
CGSPluginInterface* CGSSensorPluginContainer::SelectedPluginL()
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::SelectedPlugin()" );
    CGSPluginInterface* plugin = NULL;

    // 1) Decrease index with the count
    TInt index = iListBox->CurrentItemIndex() - iGeneralItemCount;
    
    // 2) Check that new index is in range of plugins
    if ( index >= 0 && index < iPluginArray->Count() )
        {
        // 3) Get correct plugin
        plugin = iPluginArray->operator[]( index );
        }

    // Leave if not found
    if ( !plugin )
        {
        User::Leave( KErrNotFound );
        }

    TRACE_1( "[GSSensorPlugin] CGSSensorPluginContainer::SelectedPlugin() - return: 0x%x", plugin );
    return plugin;
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::CurrentFeatureId
// ---------------------------------------------------------------------------
//
TInt CGSSensorPluginContainer::CurrentFeatureId() const
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::CurrentFeatureId()" );
    return iListboxItemArray->CurrentFeature();
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::OfferKeyEventL
// ---------------------------------------------------------------------------
//
TKeyResponse CGSSensorPluginContainer::OfferKeyEventL( 
    const TKeyEvent& aKeyEvent, TEventCode aType )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::OfferKeyEventL()" );

    TKeyResponse returnValue( EKeyWasNotConsumed );

    switch ( aKeyEvent.iCode )
        {
        case EKeyUpArrow:
        case EKeyDownArrow:
            {
            // Send key event to Listbox
            returnValue = iListBox->OfferKeyEventL( aKeyEvent, aType );
            // Change MSK label if needs to changed
            iMskObserver.CheckMiddleSoftkeyLabelL();
            break;
            }
        case EKeyLeftArrow:
        case EKeyRightArrow:
            {
            // Listbox takes all events even if it doesn't use them.
            // Stick with the default return value
            break;
            }
        default:
            {
            // Forward key event to listbox
            returnValue = iListBox->OfferKeyEventL( aKeyEvent, aType );
            break;
            }
        }

    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::OfferKeyEventL() - return" );
    return returnValue;
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::GetHelpContext
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::GetHelpContext( TCoeHelpContext& aContext ) const
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::GetHelpContext()" );
    aContext.iMajor = KUidGS;
    aContext.iContext = KSSET_HLP_MAIN_VIEW;
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::GetHelpContext() - return" );
    }

// ---------------------------------------------------------------------------
// CGSSensorPluginContainer::SetSensorStatusTextL
// Setting Sensors status Text based on the value sent,
// '0' meams "Off" & '1' Means 'On'
// ---------------------------------------------------------------------------
//
void CGSSensorPluginContainer::SetSensorStatusTextL( TInt aValue )
    {
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::SetSensorStatusTextL()" );
    AppendListItemL( 
        EGSSensorsListItemId, 
        iListItems->operator[]( EGSSensorsListItemId ), 
        ( *iSensorStatusText )[aValue] );
    TRACE_( "[GSSensorPlugin] CGSSensorPluginContainer::SetSensorStatusTextL() - return" );
    }