/*

* Copyright (c) 2002-2010 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:  Implementation for default status indicator control.

*

*/

// INCLUDE FILES

#include <AknsDrawUtils.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <AknSmallIndicator.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <AknTasHook.h>

#include <touchfeedback.h>

#include "AknIndicatorObserver.h"

#include "aknindicatordataobserver.h"

#include "AknSgcc.h"

#include "AknIncallStatusBubble.h"

#include "AknUtils.h"

#include "aknconsts.h"

#include "AknIndicator.h"

#include "AknIndicatorContainer.h"

#include "aknenv.h"

#include "AknStatuspaneUtils.h"

#include "AknIndicatorFader.h"

#include "aknappui.h"

#include "AknDef.h"

#include "layoutmetadata.cdl.h"

// CONSTANTS

const TInt KAknIndicatorQueueGranularity       = 4;

const TInt KAknIndicatorAnimationInterval      = 500000; // micro seconds

const TInt KAknIndicatorAnimationShortDelay    = 400000; // micro seconds

// Indicator pane control flags.

enum TIndicatorPaneControlFlags

    {

    EAknIndicatorsButton1DownInIndicatorPaneRect = 0x00000001

    };

// ================= PRIVATE CLASS =======================

NONSHARABLE_CLASS( CAknIndicatorContainerExtension ) :

    public CBase,

    public MAknPictographAnimatorCallBack,

    public MCoeMessageMonitorObserver

    {

public:

    /**

    * Constructor.

    */

    static CAknIndicatorContainerExtension* NewL(

        CAknIndicatorContainer* aIndicatorContainer );

    /**

    * Destructor.

    */

    ~CAknIndicatorContainerExtension();

    TBool SmallStatusPaneLayout();

    void SetSmallStatusPaneLayout( TBool aIsActive );

    // From base class @c MCoeMessageMonitorObserver.

    /**

    * Used to receive event from window server

    * when the visibility of the window changes.

    *

    * @param  aEvent  The window server event.

    */

    void MonitorWsMessage( const TWsEvent &aEvent );

private:

    CAknIndicatorContainerExtension(

        CAknIndicatorContainer* aIndicatorContainer );

    void ConstructL();

    // From MAknPictographAnimatorCallBack

    void DrawPictographArea();

public:

    CAknIndicatorContainer*     iIndicatorContainer;

    CAknPictographInterface*    iPictoInterface;

    TBool                       iSmallStatusPaneLayout;

    TBool                       iSwitchLayoutInProgress;

    TBool                       iIncallBubbleAllowedInIdle;

    TBool                       iIncallBubbleAllowedInUsual;

    TPoint                      iPositionRelativeToScreen;

    CAknIndicatorDataObserver*  iDataObserver;

    TInt                        iFlags;

    TBool                       iIncallBubbleDisabled;

    TBool                       iIsForeground;

    TBool                       iIsActiveIdle;

    };

CAknIndicatorContainerExtension* CAknIndicatorContainerExtension::NewL(

    CAknIndicatorContainer* aIndicatorContainer )

    {

    CAknIndicatorContainerExtension* self = new( ELeave )

        CAknIndicatorContainerExtension( aIndicatorContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CAknIndicatorContainerExtension::ConstructL()

    {

    iPictoInterface = CAknPictographInterface::NewL( *iIndicatorContainer, *this );

    if ( iIndicatorContainer->IndicatorContext() ==

            CAknIndicatorContainer::EUniversalIndicators )

        {

        iDataObserver =

            new (ELeave) CAknIndicatorDataObserver( iIndicatorContainer );

        }

    TRAP_IGNORE( CCoeEnv::Static()->AddMessageMonitorObserverL( *this ) );

    }

CAknIndicatorContainerExtension::CAknIndicatorContainerExtension(

    CAknIndicatorContainer* aIndicatorContainer )

    : iIndicatorContainer( aIndicatorContainer )

    {

    iSmallStatusPaneLayout      = AknStatuspaneUtils::SmallLayoutActive();

    iIncallBubbleAllowedInUsual = ETrue;

    iIsForeground = static_cast<CAknAppUi*>( CEikonEnv::Static()->EikAppUi() )->IsForeground();

    iIsActiveIdle = AknStatuspaneUtils::IsActiveIdle();

    }

CAknIndicatorContainerExtension::~CAknIndicatorContainerExtension()

    {

    delete iPictoInterface;

    delete iDataObserver;

    CCoeEnv::Static()->RemoveMessageMonitorObserver( *this );

    }

void CAknIndicatorContainerExtension::DrawPictographArea()

    {

    iIndicatorContainer->DrawPictographArea();

    }

TBool CAknIndicatorContainerExtension::SmallStatusPaneLayout()

    {

    return iSmallStatusPaneLayout;

    }

void CAknIndicatorContainerExtension::SetSmallStatusPaneLayout(

    TBool aIsActive )

    {

    iSmallStatusPaneLayout = aIsActive;

    }

void CAknIndicatorContainerExtension::MonitorWsMessage( const TWsEvent& aEvent )

    {

    switch ( aEvent.Type() )

        {

        case KAknFullOrPartialForegroundGained:

            iIndicatorContainer->ResetAnimTicker( ETrue );

            break;

        case KAknFullOrPartialForegroundLost:

            iIndicatorContainer->ResetAnimTicker( EFalse );

            break;

        default:

            break;

        }

    }

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

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

// CAknIndicatorContainer::CAknIndicatorContainer

// Default constructor.

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

//

EXPORT_C CAknIndicatorContainer::CAknIndicatorContainer() :

    iLayoutOrientation( EVertical ),

    iPreviousLayoutOrientation( EVertical ),

    iAlignment( ERight ),

    iIndicatorContext( EUniversalIndicators ),

    iSynchronizingValue( 0 )

    {

    AKNTASHOOK_ADD( this, "CAknIndicatorContainer" );

    }

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

// CAknIndicatorContainer::CAknIndicatorContainer

// Constructor with context type parameter.

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

//

EXPORT_C CAknIndicatorContainer::CAknIndicatorContainer(

    TBool aIndicatorContext )

    : iLayoutOrientation( EVertical ),

      iPreviousLayoutOrientation( EVertical ),

      iAlignment( ERight ),

      iIndicatorContext( aIndicatorContext ),

      iSynchronizingValue( 0 )

    {

    AKNTASHOOK_ADD( this, "CAknIndicatorContainer" );

    }

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

// CAknIndicatorContainer::~CAknIndicatorContainer

// Destructor.

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

//

EXPORT_C CAknIndicatorContainer::~CAknIndicatorContainer()

    {

    AKNTASHOOK_REMOVE();

    AknsUtils::DeregisterControlPosition( this );

    if ( iIndicators )

        {

        TInt count = iIndicators->Count();

        for ( TInt ii = 0; ii < count; ii++)

            {

            delete iIndicators->At( ii );

            }

        delete iIndicators;

        }

    if ( iTicker )

        {

        iTicker->Cancel();

        delete iTicker;

        }

    delete iIncallBubble;

    delete iExtension;

    }

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

// CAknIndicatorContainer::ConstructL

// Second-phase constructor.

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

//

EXPORT_C void CAknIndicatorContainer::ConstructL()

    {

    iExtension = CAknIndicatorContainerExtension::NewL( this );

    if ( !iIndicators )

        {

        iIndicators =

            new (ELeave) CAknIndicatorQueue( KAknIndicatorQueueGranularity );

        }

    iTicker = CPeriodic::NewL( CActive::EPriorityLow );

    }

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

// CAknIndicatorContainer::ConstructFromResourceL

// Resource constructor.

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

//

EXPORT_C void CAknIndicatorContainer::ConstructFromResourceL(

    TResourceReader& aReader )

    {

    ConstructL();

    if ( iIndicatorContext != EUniversalIndicators &&

         iIndicatorContext != ENaviPaneEditorIndicators &&

         iIndicatorContext != EQueryEditorIndicators )

        {

        TInt count = aReader.ReadInt16();

        for ( TInt ii = 0; ii < count; ii++ )

            {

            CAknIndicator* indicator =

                new (ELeave) CAknIndicator ( iIndicatorContext );

            CleanupStack::PushL( indicator );

            indicator->SetContainerWindowL( *this );

            indicator->ConstructFromResourceL( aReader, this );

            iIndicators->AppendL( indicator );

            CleanupStack::Pop( indicator );

            indicator = NULL;

            }

        PrioritizeIndicatorsL();

        }

    }

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

// CAknIndicatorContainer::IndicatorContext

// Returns the indicator context of this container.

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

//

EXPORT_C TInt CAknIndicatorContainer::IndicatorContext() const

    {

    return iIndicatorContext;

    }

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

// CAknIndicatorContainer::SetIndicatorState

// Sets the state of an indicator in this container.

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

//

EXPORT_C void CAknIndicatorContainer::SetIndicatorState( TUid aIndicatorId,

                                                         TInt aState,

                                                         TBool aDrawNow )

    {

    if ( !IndicatorExists( aIndicatorId ) )

        {

        if ( iIndicatorContext == EUniversalIndicators )

            {

            TRAP_IGNORE( CreateIndicatorFromPaneResourceL(

                aIndicatorId, R_AVKON_STATUS_PANE_INDICATOR_DEFAULT, 0 ) );

            }

        else if ( iIndicatorContext == ENaviPaneEditorIndicators ||

                  iIndicatorContext == EQueryEditorIndicators )

            {

            TRAP_IGNORE( CreateIndicatorFromPaneResourceL(

                aIndicatorId, R_AVKON_NAVI_PANE_EDITOR_INDICATORS, 0 ) );

            }

        }

    TBool changed = EFalse;

    TInt  count   = iIndicators->Count();

    CAknIndicator* indicator = NULL;

    for ( TInt ii = 0; ii < count; ii++ )

        {

        indicator = iIndicators->At( ii );

        if ( indicator->Uid() == aIndicatorId )

            {

            if ( indicator->IndicatorState() != aState )

                {

                changed = ETrue;

                }

            indicator->SetIndicatorState( aState );

            if ( aState == MAknIndicator::EIndicatorAnimate )

                {

                // Synchronizes new animated indicator with previous ones

                indicator->SetAnimateState( iSynchronizingValue );

                }

            // In case of GPRS indicator in small status pane it is necessary

            // to check whether a correct status pane layout is used.

            if ( aIndicatorId == TUid::Uid( EAknNaviPaneEditorIndicatorGprs ) )

                {

                TBool layoutUpdated( EFalse );

                TRAPD( err, layoutUpdated = UpdateSmallLayoutL() );

                if ( layoutUpdated && err == KErrNone )

                    {

                    // Needed because this method is not called again.

                    iExtension->iSwitchLayoutInProgress = EFalse;

                    }

                }

            break;

            }

        }

    if ( changed )

        {

        TRAP_IGNORE( PrioritizeIndicatorsL() );

        SizeChanged(); // starts/stops also animation timers if needed

        }

    // Do not draw in case the indicator state has not changed and

    // the indicator is not visible, even if aDrawNow is defined,

    // otherwise flicker will occur.

    if ( aDrawNow && ( changed || aState ) )

        {

        DrawNow();

        }

    }

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

// CAknIndicatorContainer::IndicatorState

// Returns current state of a status indicator in this container.

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

//

EXPORT_C TInt CAknIndicatorContainer::IndicatorState( TUid aIndicatorId )

    {

    TInt indicatorState( MAknIndicator::EIndicatorOff );

    TInt count = iIndicators->Count();

    CAknIndicator* indicator = NULL;

    for ( TInt ii = 0; ii < count; ii++ )

        {

        indicator = iIndicators->At( ii );

        if ( indicator->Uid() == aIndicatorId )

            {

            indicatorState = indicator->IndicatorState();

            break;

            }

        }

    return indicatorState;

    }

EXPORT_C void CAknIndicatorContainer::SetIndicatorValueL( TUid aIndicatorId,

                                                          const TDesC& aString )

    {

    if ( ( iIndicatorContext == ENaviPaneEditorIndicators ||

           iIndicatorContext == EQueryEditorIndicators )  &&

         !IndicatorExists( aIndicatorId ) )

        {

        CreateIndicatorFromPaneResourceL( aIndicatorId, R_AVKON_NAVI_PANE_EDITOR_INDICATORS, 0);

        }

    TInt count = iIndicators->Count();

    for(TInt ii = 0; ii < count; ii++)

        {

        CAknIndicator* indicator = iIndicators->At(ii);

        if ( indicator->Uid() == aIndicatorId )

            {

            TInt indicatorWidthBefore = indicator->IconSize().iWidth;

            indicator->SetIndicatorValueL(aString);

            TInt indicatorWidthAfter = indicator->IconSize().iWidth;

            // Draw the message length indicator if it is visible.

            if (  indicator->IndicatorState() != EAknIndicatorStateOff )

                {

                if ( indicatorWidthBefore != indicatorWidthAfter )

                    {

                    // If indicator width was changed, reposition all indicators.

                    PrioritizeIndicatorsL();

                    SizeChanged();

                    }

                DrawNow();

                }

            break;

            }

        }

    }

void CAknIndicatorContainer::DrawPictographArea()

    {

    TInt count = iIndicators->Count();

    for ( TInt i = 0; i < count; i++ )

        {

        CAknIndicator* indicator = iIndicators->At( i );

        // Draw the indicator if it is visible and contains pictographs.

        if ( indicator->TextIndicator() &&

             indicator->IndicatorState() != EAknIndicatorStateOff &&

             indicator->IsVisible() &&

             iExtension->iPictoInterface->Interface()->ContainsPictographs(

                *( indicator->iIndicatorText ) ) )

            {

            indicator->DrawDeferred();

            }

        }

    }

CAknPictographInterface* CAknIndicatorContainer::PictographInterface() const

    {

    return iExtension->iPictoInterface;

    }

EXPORT_C void  CAknIndicatorContainer::SetIncallBubbleFlags( const TInt& aFlags )

    {

    if ( aFlags & CIncallStatusBubble::ESBVisible )

        {

        if ( !iIncallBubble )

            {

            TRAP_IGNORE( CreateIncallBubbleL() );

            }

        if ( iIncallBubble )

            {

            iIncallBubble->SetFlags( aFlags );

            }

        }

    else

        {

        // RAM optimization, delete if not shown.

        delete iIncallBubble;

        iIncallBubble = NULL;

        }

    HandleStatusPaneSizeChange();

    }

EXPORT_C void CAknIndicatorContainer::HandleStatusPaneSizeChange()

    {

    CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current();

    if ( statusPane && iIncallBubble )

        {

        // In CDMA, the Phone app is on foreground during incall lock state

        // In GSM/WCDMA the Autolock application is on foreground

        // Nowdays Autolock itself takes care of the visibility