/*

* Copyright (c) 2007-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:  Content that is shown inside a universal status

*                indicator popup.

*

*/

// SYSTEM INCLUDE FILES

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsConstants.h>

#include <AknUtils.h>

#include "akndigitalclock.h"

#include <avkon.mbg>

#include <gulicon.h>

#include <barsread.h>

#include <AknIndicator.h>

#include <AknIndicatorPlugin.h>

#include <AknIndicatorPluginImplUIDs.hrh>

#include <AknIndicatorContainer.h>

#include <apgcli.h>

#include <aknconsts.h>

#include <aknglobalpopupprioritycontroller.h>

#include <AknTasHook.h> // for testability hooks

#include <touchfeedback.h>

// USER INCLUDE FILES

#include "aknindicatorpopupcontent.h"

#include "aknindicatorpopup.h"

#include "AknBatteryIcon.h"

#include "AknSignalIcon.h"

// CONSTANTS

/** Granularity of the indicator item array. */

const TInt KItemArrayGranularity = 8;

/** Path to the clock application, launched directly from the popup. */

_LIT( KClockApplication, "\\sys\\bin\\clock.exe" );

/** Internal state flags. */

enum TIndicatorPopupContentFlags

    {

    /** Pointer down event has happened inside this control. */

    EAknIndicatorPopupContentButton1Down        = 0x00000001,

    /** Clock application is being launched. */

    EAknIndicatorPopupContentClockBeingLaunched = 0x00000002

    };

const TInt KBatteryAreaIndex = 0;

const TInt KSignalAreaIndex  = 1;

// =============================================================================

// CAknIndicatorPopupItem

// Item class declaration & definition.

// =============================================================================

//

NONSHARABLE_CLASS( CAknIndicatorPopupItem ) : public CBase

    {

public:

    /**

    * Default constructor.

    *

    * @param  aUid       UID of the indicator.

    * @param  aPlugin    Pointer to the indicator's ECOM plugin,

    *                    can be NULL.

    * @param  aPriority  Display priority of the indicator.

    * @param  aTextType  Type of the item text.

    */

    CAknIndicatorPopupItem( TInt aUid,

                            CAknIndicatorPlugin* aPlugin,

                            TInt aPriority,

                            TInt aTextType );

    /**

    * Destructor.

    */

    ~CAknIndicatorPopupItem();

    /**

    * Second-phase constructor to be used with custom icon.

    *

    * @param  aText  Item text.

    * @param  aIcon  Indicator icon.

    */

    void ConstructL( const TDesC& aText,

                     const CGulIcon* aIcon );

    /**

    * Second-phase constructor to be used with the default

    * indicator icon.

    *

    * @param  aText    Item text.

    * @param  aIconID  Index of the indicator icon.

    * @param  aIconID  Index of the indicator icon mask.

    */

    void ConstructL( const TDesC& aText,

                     TInt aIconID,

                     TInt aIconMaskID );

    /**

    * Sets the area of this item in the popup.

    *

    * @param  aRect  Rectangle of this item, relative

    *                to the popup.

    */

    void SetRect( const TRect& aRect );

    /**

    * Changes the indicator icon of the item or updates

    * the color when skin changes.

    *

    * @param  aIcon  Pointer to the new icon if the icon

    *                is to be changed.

    */

    void UpdateIndicatorIconL( const CGulIcon* aIcon = NULL );

    /**

    * Updates the item text.

    *

    * @param  aText  Item text.

    */

    void UpdateTextL( const TDesC& aText, TInt aTextType );

    /**

    * Draws the item.

    *

    * @param  aGc  Reference to the window graphics context.

    */

    void DrawItem( CWindowGc& aGc );

public: // Member data

    /** UID of the indicator. */

    TInt                  iUid;

    /** Indicator priority. */

    TInt                  iPriority;

    /** Item text, owned. */

    HBufC*                iText;

    /** Type of the text. */

    TInt                  iTextType;

    /** Item area. */

    TRect                 iRect;

    /** Indicator icon area. */

    TRect                 iIconRect;

    /** Default indicator icon, owned. */

    CGulIcon*             iIcon;

    /** Custom indicator icon, not owned. */

    const CGulIcon*       iCustomIcon;

    /** Index of the default indicator icon. */

    TInt                  iIconID;

    /** Index of the default indicator icon mask. */

    TInt                  iIconMaskID;

    /** Pointer to the indicator plugin, not owned. */

    CAknIndicatorPlugin*  iPlugin;

    };

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

// CAknIndicatorPopupItem::CAknIndicatorPopupItem

// Default constructor

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

//

CAknIndicatorPopupItem::CAknIndicatorPopupItem( TInt aUid,

                                                CAknIndicatorPlugin* aPlugin,

                                                TInt aPriority,

                                                TInt aTextType )

    : iUid( aUid ),

      iPriority( aPriority ),

      iTextType( aTextType ),

      iPlugin( aPlugin )

    {

    }

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

// CAknIndicatorPopupItem::CAknIndicatorPopupItem

// Destructor

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

//

CAknIndicatorPopupItem::~CAknIndicatorPopupItem()

    {

    delete iText;

    delete iIcon;

    }

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

// CAknIndicatorPopupItem::ConstructL

// Second-phase constructor

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

//

void CAknIndicatorPopupItem::ConstructL( const TDesC& aText,

                                         const CGulIcon* aIcon )

    {

    delete iText;

    iText = NULL;

    iText = aText.AllocL();

    iCustomIcon = aIcon;

    }

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

// CAknIndicatorPopupItem::ConstructL

// Second-phase constructor

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

//

void CAknIndicatorPopupItem::ConstructL( const TDesC& aText,

                                         TInt aIconID,

                                         TInt aIconMaskID )

    {

    delete iText;

    iText = NULL;

    iText = aText.AllocL();

    iIconID     = aIconID;

    iIconMaskID = aIconMaskID;

    UpdateIndicatorIconL();

    }

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

// CAknIndicatorPopupItem::SetRect

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

//

void CAknIndicatorPopupItem::SetRect( const TRect& aRect )

    {

    iRect = aRect;

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(

        iRect,

        AknLayoutScalable_Avkon::list_single_uniindi_pane_g1() );

    iIconRect = layoutRect.Rect();

    CFbsBitmap* bitmap = NULL;

    if ( iCustomIcon )

        {

        bitmap = iCustomIcon->Bitmap();

        }

    else if ( iIcon )

        {

        bitmap = iIcon->Bitmap();

        }

    if ( bitmap )

        {

        AknIconUtils::SetSize( bitmap,

                               iIconRect.Size(),

                               EAspectRatioPreserved );

        }

    }

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

// CAknIndicatorPopupItem::UpdateIndicatorIconL

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

//

void CAknIndicatorPopupItem::UpdateIndicatorIconL( const CGulIcon* aIcon )

    {

    if ( iCustomIcon &&

         !aIcon )

        {

        // Custom icon in use

        if ( iPlugin )

            {

            iCustomIcon = NULL;

            TRAPD( err, iCustomIcon = iPlugin->IconL( iUid ) );

            if ( !err && iCustomIcon )

                {

                // Icon update succeeded.

                AknIconUtils::SetSize( iCustomIcon->Bitmap(),

                                       iIconRect.Size(),

                                       EAspectRatioPreserved );

                return;

                }

            // Else use the default icon.

            }

        }

    delete iIcon;

    iIcon = NULL;

    if ( aIcon )

        {

        iCustomIcon = aIcon;

        AknIconUtils::SetSize( iCustomIcon->Bitmap(),

                               iIconRect.Size(),

                               EAspectRatioPreserved );

        }

    else

        {

        CFbsBitmap* bitmap;

        CFbsBitmap* mask;

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        AknsUtils::CreateColorIconLC(

            skin,

            KAknsIIDDefault,

            KAknsIIDQsnIconColors,

            EAknsCIQsnIconColorsCG20,

            bitmap,

            mask,

            KAvkonBitmapFile,

            iIconID,

            iIconMaskID,

            KRgbGray );

        AknIconUtils::SetSize( bitmap,

                               iIconRect.Size(),

                               EAspectRatioPreserved );

        iIcon = CGulIcon::NewL( bitmap, mask );

        CleanupStack::Pop( 2, bitmap );

        }

    }

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

// CAknIndicatorPopupItem::UpdateTextL

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

//

void CAknIndicatorPopupItem::UpdateTextL( const TDesC& aText, TInt aTextType )

    {

    delete iText;

    iText = NULL;

    iText = aText.AllocL();

    iTextType = aTextType;

    }

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

// CAknIndicatorPopupItem::DrawItem

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

//

void CAknIndicatorPopupItem::DrawItem( CWindowGc& aGc )

    {

    // Use custom icon if it exists.

    const CGulIcon* icon = iCustomIcon;

    if ( !icon )

        {

        icon = iIcon;

        }

    if ( icon && icon->Bitmap() && icon->Mask() )

        {

        aGc.BitBltMasked( iIconRect.iTl,

                          icon->Bitmap(),

                          iIconRect.Size(),

                          icon->Mask(),

                          ETrue );

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TAknTextLineLayout textLayout(

        AknLayoutScalable_Avkon::list_single_uniindi_pane_t1().LayoutLine() );

    TRgb textColor;

    if ( iTextType == CAknIndicatorPlugin::EAknIndicatorPluginLinkText )

        {

        aGc.SetUnderlineStyle( EUnderlineOn );

        AknsUtils::GetCachedColor( skin,

                                   textColor,

                                   KAknsIIDQsnHighlightColors,

                                   EAknsCIQsnHighlightColorsCG3 );

        }

    else

        {

        AknsUtils::GetCachedColor( skin,

                                   textColor,

                                   KAknsIIDQsnTextColors,

                                   EAknsCIQsnTextColorsCG55 );

        }

    TAknLayoutText layoutText;

    layoutText.LayoutText( iRect, textLayout );

    layoutText.DrawText( aGc, *iText, ETrue, textColor );

    aGc.SetUnderlineStyle( EUnderlineOff );

    }

// =============================================================================

// CAknIndicatorPopupContent

// =============================================================================

//

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

// CAknIndicatorPopupContent::NewL

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

//

CAknIndicatorPopupContent* CAknIndicatorPopupContent::NewL()

    {

    CAknIndicatorPopupContent* self = CAknIndicatorPopupContent::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknIndicatorPopupContent::NewLC

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

//

CAknIndicatorPopupContent* CAknIndicatorPopupContent::NewLC()

    {

    CAknIndicatorPopupContent* self = new (ELeave) CAknIndicatorPopupContent;

    CleanupStack::PushL( self );

    self->ConstructL();

    AKNTASHOOK_ADDL( self, "CAknIndicatorPopupContent" );

    return self;

    }

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

// Destructor.

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

//

CAknIndicatorPopupContent::~CAknIndicatorPopupContent()

    {

    AKNTASHOOK_REMOVE();

    // Ensure here that this popup is removed from the global

    // popup priority stack.

    AknGlobalPopupPriorityController::RemovePopupPriority( *this );

    iItems.ResetAndDestroy();

    iItems.Close();

    delete iClock;

    delete iBattery;

    delete iSignal;

    if ( iBatteryPlugin || iSignalPlugin )

        {

        delete iBatteryPlugin;

        delete iSignalPlugin;

        REComSession::FinalClose();

        }

    MTouchFeedback* feedback = MTouchFeedback::Instance();

    if ( feedback )

        {

        feedback->RemoveFeedbackForControl( this );

        }

    delete iSeparatorIcon;

    }

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

// From class CCoeControl

// CAknIndicatorPopupContent::MinimumSize

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

//

TSize CAknIndicatorPopupContent::MinimumSize()

    {

    TInt items( iItems.Count() );

    // Get the maximum number of indicator items from layout data.

    TAknLayoutScalableParameterLimits limits(

        AknLayoutScalable_Avkon::list_single_uniindi_pane_ParamLimits() );

    TInt variety( limits.LastRow() + 1 ); // Last variety for no indicator items

    if ( items > 0 )

        {

        if ( items <= variety )

            {

            variety -= items;

            }

        else

            {

            variety = 0; // Maximum number of items.

            }

        }

    TRect applicationWindow;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,

                                       applicationWindow );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect(

        applicationWindow,

        AknLayoutScalable_Avkon::popup_uni_indicator_window( variety ) );

    return TSize( layoutRect.Rect().Size() );

    }

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

// From class CCoeControl

// CAknIndicatorPopupContent::HandleResourceChange

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