/*

* 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:  Control for status pane's battery pane.

*

*/

// INCLUDE FILES

#include <coemain.h>

#include <barsread.h>

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <eikspane.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknSmallIndicator.h>

#include <touchfeedback.h>

#include <AknTasHook.h>

#include "AknUtils.h"

#include "aknconsts.h"

#include "AknBattery.h"

#include "AknStatuspaneUtils.h"

#include "AknBatteryIcon.h"

#include "AknBatteryStrength.h"

#include "aknappui.h"

#include "AknDef.h"

#include "aknbatterydataobserver.h"

// Flags for battery pane

enum TBatteryPaneControlFlags

    {

    EAknBatteryPaneButton1DownInBatteryRect = 0x00000001

    };

// Battery recharge animation frame interval.

const TInt KBatteryRechargeTick = 500000; // 0.5 seconds

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

// CAknBatteryPane::CAknBatteryPane

// Default constructor.

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

//

EXPORT_C CAknBatteryPane::CAknBatteryPane()

    {

    AKNTASHOOK_ADD( this, "CAknBatteryPane" );

    }

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

// CAknBatteryPane::~CAknBatteryPane

// Destructor.

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

//

EXPORT_C CAknBatteryPane::~CAknBatteryPane()

    {

    AKNTASHOOK_REMOVE();

    MTouchFeedback* feedback = MTouchFeedback::Instance();

    if ( feedback )

        {

        feedback->RemoveFeedbackForControl( this );

        }

    AknsUtils::DeregisterControlPosition( this );

    delete iBatteryIconControl;

    delete iBatteryStrengthControl;

    if ( iTicker )

        {

        iTicker->Cancel();

        }

    delete iTicker;

    delete iDataObserver;

    }

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

// CAknBatteryPane::ConstructL

// Second-phase constructor.

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

//

EXPORT_C void CAknBatteryPane::ConstructL()

    {

    iBatteryIconControl = CAknBatteryIcon::NewL();

    iBatteryIconControl->SetContainerWindowL( *this );

    iBatteryStrengthControl = CAknBatteryStrength::NewL();

    iBatteryStrengthControl->SetContainerWindowL( *this );

    iPrivateFlags = 0; // reset flags

    iDataObserver = new (ELeave) CAknBatteryDataObserver( this );

    iStatusPane = CEikStatusPaneBase::Current();

    MTouchFeedback* feedback = MTouchFeedback::Instance();

    if ( feedback )

        {

        CFeedbackSpec* fbSpec = CFeedbackSpec::New();

        if ( fbSpec )

            {

            fbSpec->AddFeedback( ETouchEventStylusDown,

                                 ETouchFeedbackSensitiveButton );

            fbSpec->AddFeedback( ETouchEventStylusUp,

                                 ETouchFeedbackSensitiveButton,

                                 ETouchFeedbackVibra );

            feedback->SetFeedbackArea( this,

                                       0,

                                       Rect(),

                                       fbSpec );

            delete fbSpec; 

            }        

        }

    }

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

// CAknBatteryPane::ConstructFromResourceL

// Resource constructor.

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

//

EXPORT_C void CAknBatteryPane::ConstructFromResourceL(

    TResourceReader& aReader )

    {

    ConstructL();

    SetBatteryLevel( aReader.ReadInt16() ); // Initial battery level.

    }

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

// CAknBatteryPane::SetBatteryLevel

// Sets the battery level.

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

//

EXPORT_C void CAknBatteryPane::SetBatteryLevel( TInt aLevel )

    {

    iBatteryLevel = aLevel;

    if ( !iBatteryStrengthControl->Recharging() )

        {

        iBatteryStrengthControl->SetBatteryLevel( aLevel );

        DrawDeferred();

        }

    }

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

// CAknBatteryPane::BatteryLevel

// Returns the current battery level.

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

//

TInt CAknBatteryPane::BatteryLevel()

    {

    return iBatteryLevel;

    }

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

// CAknBatteryPane::SetRecharge

// Sets the recharging state on/off.

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

//

void CAknBatteryPane::SetRecharge( TBool aRecharging )

    {

    if ( aRecharging )

        {

        if ( !iBatteryStrengthControl->Recharging() )

            {

            if ( !iTicker )

                {

                TRAP_IGNORE( iTicker = CPeriodic::NewL(

                                CActive::EPriorityLow ) );

                }

            else

                {

                iTicker->Cancel();

                }

            if ( iTicker )

                {

                iTicker->Start( KBatteryRechargeTick,

                                KBatteryRechargeTick,

                                TCallBack( TickerCallback, this ) );

                }

            }

        }

    iBatteryStrengthControl->SetRecharging( aRecharging );

    if ( !iBatteryStrengthControl->Recharging() )

        {

        SetBatteryLevel( iBatteryLevel ); // Set battery level to right value.

        }

    }

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

// CAknBatteryPane::Recharging

// Returns the current recharging state.

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

//

TBool CAknBatteryPane::Recharging()

    {

    if ( iBatteryStrengthControl )

        {

        return iBatteryStrengthControl->Recharging();

        }

    else

        {

        return EFalse;

        }

    }

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

// CAknBatteryPane::BatteryState

// Returns the current battery state.

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

//

TInt CAknBatteryPane::BatteryState()

    {

    if ( iBatteryIconControl )

        {

        return iBatteryIconControl->IconState();

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// CAknBatteryPane::SetBatteryStateL

// Sets the battery state.

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

//

void CAknBatteryPane::SetBatteryStateL( TInt aState )

    {

    // Change battery icon only if the new state is

    // different than the current one.

    if ( iBatteryIconControl &&

         iBatteryIconControl->IconState() != aState )

        {

        iBatteryIconControl->SetBatteryIconL( aState );

        }

    }

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

// CAknBatteryPane::TickerCallback

// Static callback function for recharge animation timer.

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

//

TInt CAknBatteryPane::TickerCallback( TAny* aThis )

    {

    return static_cast<CAknBatteryPane*>( aThis )->DoTick();

    }

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

// CAknBatteryPane::DoTick

// Callback function for recharge animation timer.

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

//

TInt CAknBatteryPane::DoTick()

    {

    if ( !iBatteryStrengthControl->Recharging() )

        {

        iTicker->Cancel();

        return EFalse;

        }

    TInt newLevel = iBatteryStrengthControl->BatteryLevel() + 1;

    if ( newLevel > KBatteryLevelMax )

        {

        newLevel = KBatteryLevelMin;

        }

    iBatteryStrengthControl->SetBatteryLevel( newLevel );

    DrawDeferred(); // Must be DrawDeferred (not DrawNow) so that we don't

                    // block application thread in high load situations

    return ETrue;

    }

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

// CAknBatteryPane::SizeChanged

// Handles size change events.

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

//

EXPORT_C void CAknBatteryPane::SizeChanged()

    {

    // No fading if staconpane is active.

    SetContainerWindowNonFading( AknStatuspaneUtils::StaconPaneActive() );

    TAknWindowComponentLayout batteryIconLayout;

    TAknWindowComponentLayout batteryStrenghtLayout;

    TRect parent( Rect() );

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        // Battery pane in STACONPANE layout

        // battery pane in status/controlpane layout used e.g. in landscape modes

        // layout 0.75 has new varieties

        TInt varietyIndex = AknStatuspaneUtils::StaconSoftKeysLeft() ? 1 : 0;

        batteryIconLayout =

            AknLayoutScalable_Avkon::battery_pane_stacon_g2( varietyIndex );

        batteryStrenghtLayout =

            AknLayoutScalable_Avkon::battery_pane_stacon_g1( varietyIndex );

        }

    else if ( AknStatuspaneUtils::FlatLayoutActive() )

        {

        batteryIconLayout = AknLayoutScalable_Avkon::battery_pane_g2( 1 );

        batteryStrenghtLayout = AknLayoutScalable_Avkon::battery_pane_g1( 1 );

        }

	 else if ((AknStatuspaneUtils::CurrentStatusPaneLayoutResId() 

                 == R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE ||

             AknStatuspaneUtils::CurrentStatusPaneLayoutResId() 

                 == R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE_MIRRORED) &&

			    Layout_Meta_Data::IsLandscapeOrientation())

		  {

        batteryIconLayout = AknLayoutScalable_Avkon::battery_pane_g2(1);

        batteryStrenghtLayout = AknLayoutScalable_Avkon::battery_pane_g1(1);

	     }

    else

        {

        // Battery pane in NORMAL of WIDESCREEN STATUS PANE layout.

        TBool hdLayout( AknStatuspaneUtils::HDLayoutActive() );

        batteryIconLayout =

            AknLayoutScalable_Avkon::battery_pane_g2( hdLayout ? 2 : 0 );

        batteryStrenghtLayout =

            AknLayoutScalable_Avkon::battery_pane_g1( hdLayout ? 2 : 0 );

        }

    AknLayoutUtils::LayoutControl(

        iBatteryIconControl, parent, batteryIconLayout );

    AknLayoutUtils::LayoutControl(

        iBatteryStrengthControl, parent, batteryStrenghtLayout );

    AknsUtils::RegisterControlPosition( this );

    MTouchFeedback* feedback = MTouchFeedback::Instance();

    if ( feedback )

        {

        if ( AknStatuspaneUtils::ExtendedFlatLayoutActive() )

            {

            // Disable tactile feedback in extended flat layout because

            // the battery pane isn't adjacent to the universal indicator

            // and small digital clock pane.

            feedback->EnableFeedbackForControl( this, EFalse );

            }

        else

            {

            feedback->EnableFeedbackForControl( this, ETrue );

            feedback->ChangeFeedbackArea( this,

                                          0,

                                          parent );

            }

        }

    }

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

// CAknBatteryPane::SizeChanged

// Handles position change events.

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

//

EXPORT_C void CAknBatteryPane::PositionChanged()

    {

    AknsUtils::RegisterControlPosition( this );

    }

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

// CAknBatteryPane::Draw

// Draws the battery pane.

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

//

EXPORT_C void CAknBatteryPane::Draw( const TRect& aRect ) const

    {

    if ( iStatusPane && 

         iStatusPane->IsTransparent() )

        {

        CWindowGc& gc = SystemGc();

        TRgb rgb(TRgb::Color16MA(0));

        gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

        gc.SetBrushStyle(CGraphicsContext::ESolidBrush);

        gc.SetBrushColor(rgb);

        gc.Clear(aRect);

        return;

        }

    // Don't allow normal background drawing if

    // background is already drawn with a background drawer.

    const MCoeControlBackground* backgroundDrawer = FindBackground();

    if ( !backgroundDrawer )

        {

        if ( AknStatuspaneUtils::StaconPaneActive() )

            {

            DrawInStaconPane( Rect() );

            }

        else if ( AknStatuspaneUtils::FlatLayoutActive() )

            {

            DrawInFlatStatusPane( Rect() );

            }

        else

            {

            DrawInNormalStatusPane( Rect() );

            }

        }

    }

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

// CAknBatteryPane::HandleResourceChange

// Handles resource change events.

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

//

EXPORT_C void CAknBatteryPane::HandleResourceChange( TInt aType )

    {

    CCoeControl::HandleResourceChange( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch ||

         aType == KAknsMessageSkinChange )

        {

        DrawDeferred();

        }

    }

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

// CAknBatteryPane::CountComponentControls

// Returns the amount of component controls.

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

//

EXPORT_C TInt CAknBatteryPane::CountComponentControls() const

    {

    return 2;

    }

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

// CAknBatteryPane::ComponentControl

// Returns a component control by a control index.

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

//

EXPORT_C CCoeControl* CAknBatteryPane::ComponentControl( TInt aIndex ) const

    {

    CCoeControl* control = NULL;

    switch ( aIndex )

        {

        case 0:

            {

            control = iBatteryStrengthControl;

            break;

            }

        case 1:

            {

            control = iBatteryIconControl;

            break;

            }

        }

    return control;

    }

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

// CAknBatteryPane::DrawInNormalStatusPane

// Draws the battery pane in normal status pane layout.

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

//

void CAknBatteryPane::DrawInNormalStatusPane( const TRect& /*aRect*/ ) const

    {

    CWindowGc& gc = SystemGc();

    TRect rect( Rect() );

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

    // Solid or wipe comes from background

    if ( !AknsDrawUtils::Background( skin, cc, this, gc, rect ) )

        {

        // Default drawing if skinning is not available

        gc.Clear( rect );

        gc.SetPenStyle( CGraphicsContext::ENullPen );

        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

        gc.SetBrushColor(

            AKN_LAF_COLOR( KStatusPaneBackgroundGraphicsColorUsual ) );

        gc.DrawRect( rect );

        }

    }

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

// CAknBatteryPane::DrawInStaconPane

// Draws the battery pane in stacon pane layout.

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

//

void CAknBatteryPane::DrawInStaconPane( const TRect& /*aRect*/ ) const

    {

    CWindowGc& gc = SystemGc();