/*

* Copyright (c) 2003 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:   CScreensaverIndicatorNumberAndIcon implementation.

*

*/

#include <barsread.h>

#include <AknsUtils.h>

#include <AknLayoutFont.h>

#include "screensaverindicatornumberandicon.h"

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

// CScreensaverNumberAndIconIndicator::~CScreensaverNumberAndIconIndicator

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

//

CScreensaverIndicatorNumberAndIcon::~CScreensaverIndicatorNumberAndIcon()

    {

    delete iIcon;

    }

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

// CScreensaverNumberAndIconIndicator::Draw

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

//

void CScreensaverIndicatorNumberAndIcon::Draw( CWindowGc& aGc ) const

    {

    TBuf<10> nStr;

    nStr.AppendNum( iValue );

    aGc.SetPenColor( iTextColor );

    aGc.SetBrushColor( iBgColor );

    if ( iFont )

        {

        aGc.UseFont( iFont );

        }

    else

        {

        ASSERT( iFont != NULL );

        aGc.UseFont( CEikonEnv::Static()->AnnotationFont() );

        }

    if ( Visible() && iIcon )

        {

        // Convert number according to language

        AknTextUtils::DisplayTextLanguageSpecificNumberConversion( nStr );

        DrawIcon( aGc );

        // Draw number beside icon

        if ( ( iTextRect.IsEmpty() ) || ( !iFont ) )

            {

            // Draw using text position (old layout)

            aGc.DrawText( nStr, iTextPos );

            }

        else

            {

            // Use text rect

            ASSERT( iTextOffset> 0 );

            aGc.DrawText( nStr, iTextRect, iTextOffset );

            }

        }

    }

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

// CScreensaverNumberAndIconIndicator::ConstructL

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

//

void CScreensaverIndicatorNumberAndIcon::ConstructL( TResourceReader &aReader,

        TUint32 aBgColor, TUint aTextColor )

    {

    CScreensaverIndicator::ConstructL( aReader, aBgColor, aTextColor );

    iIconAlign = ( TScreensaverAlignment )aReader.ReadInt32();

    iFont = AknLayoutUtils::FontFromId( aReader.ReadInt32() );

    if ( !iFont )

        {

        iFont = LatinPlain12();

        }

    // create icon

    InitializeIconL( aReader );

    // Set desired size for SVG graphics (height from LAF, width 3 x height)

    InitializeLayout();

    }

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

// CScreensaverNumberAndIconIndicator::SetupDrawingParameters

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

//

void CScreensaverIndicatorNumberAndIcon::SetupDrawingParameters(

        const TPoint& aCorner, const TRect& aParentRect )

    {

    iVisible = EFalse;

    TBuf<10> nStr;

    if ( !iIcon )

        {

        return;

        }

    nStr.AppendNum( iValue );

    TSize bmsize = iIcon->Bitmap()->SizeInPixels();

    TInt textWidth = iFont ? iFont->TextWidthInPixels( nStr ) + 1 : nStr.Length()

            * 11; // Should be enough for APAC too

    iTopLeft.iX = aCorner.iX;

    if ( iAlignment == ESsAlignRight )

        {

        // Change topright to topleft.      

        iTopLeft.iX -= bmsize.iWidth + textWidth;

        }

    // Center bitmap in y direction.

    iTopLeft.iY = aCorner.iY + ( aParentRect.Size().iHeight / 2 ) - ( bmsize.iHeight / 2 ) - 2;

    // Calculate text corner

    if ( iIconAlign == ESsAlignLeft )

        {

        iTextPos.iX = iTopLeft.iX + bmsize.iWidth + 1;

        }

    else

        {

        iTextPos.iX = iTopLeft.iX;

        }

    iTextPos.iY = aCorner.iY + iRect.Size().iHeight / 2 + 4;

    iRect = TRect( 0, 0, bmsize.iWidth + textWidth, aParentRect.Size().iHeight );

    // Make sure text rect is not used

    iTextRect.SetRect( 0, 0, 0, 0 );

    iVisible = ETrue;

    }

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

// CScreensaverNumberAndIconIndicator::CheckVisibilityConditions

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

//

TBool CScreensaverIndicatorNumberAndIcon::CheckVisibilityConditions() const

    {

    if ( ( iIcon ) && ( iValue > 0 ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CScreensaverNumberAndIconIndicator::Payload

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

//

void CScreensaverIndicatorNumberAndIcon::Payload( TIndicatorPayload& aPayload ) const

    {

    aPayload.iType = EPayloadTypeInteger;

    aPayload.iInteger = iValue;

    aPayload.iText = KNullDesC;

    aPayload.iIsDisplayed = Visible();

    aPayload.iIcon = iIcon;

    }

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

// CScreensaverNumberAndIconIndicator::SetPayload

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

//

void CScreensaverIndicatorNumberAndIcon::SetPayload(

        const TIndicatorPayload& aPayload )

    {

    if ( aPayload.iType != EPayloadTypeInteger )

        {

        return;

        }

    iValue = aPayload.iInteger;

    }

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

// CScreensaverNumberAndIconIndicator::SetIconLayout

// Sets icon position and size

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

//

void CScreensaverIndicatorNumberAndIcon::SetIconLayout( TAknLayoutRect& aLayout,

        TInt aX )

    {

    if ( !iIcon )

        {

        ASSERT( iIcon );

        return;

        }

    // Resize icon according to layout

    TInt height = aLayout.Rect().Height();

    TSize iconSize(KMaxTInt, height);

    AknIconUtils::SetSize( iIcon->Bitmap(), iconSize,

            EAspectRatioPreservedAndUnusedSpaceRemoved );

    // Overrides vertical icon position set earlier

    iTopLeft.iY = aLayout.Rect().iTl.iY;

    // Set initial rect

    iRect = TRect( 0, 0, PreferredWidth(), height );

    // Set X-position

    SetXPos( aX );

#ifdef SS_LAYOUTTRACE

    SCRLOGGER_WRITEF( _L("SCR: NumberAndIcon indicator (%d):"), iId );

    SCRLOGGER_WRITEF( _L("SCR:   Icon rect: (%d,%d,%d,%d)"),

            iRect.iTl.iX,

            iRect.iTl.iY,

            iRect.iBr.iX,

            iRect.iBr.iY );

    TSize size = iIcon->Bitmap()->SizeInPixels();

    SCRLOGGER_WRITEF( _L("SCR:   Icon size: (%d,%d)"), size.iWidth, size.iHeight );

    SCRLOGGER_WRITEF( _L("SCR:   Icon pos:  (%d,%d)"), iTopLeft.iX, iTopLeft.iY );

#endif

    }

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

// CScreensaverNumberAndIconIndicator::SetTextLayout

// Sets text position and font

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

//

void CScreensaverIndicatorNumberAndIcon::SetTextLayout( TAknLayoutText& aLayout,

        TInt /* aX */ )

    {

    // Font from layout

    iFont = aLayout.Font();

    // Layout MUST have a font

    ASSERT( iFont != NULL );

    // Vertical dimension of text rect from layout

    // (x-dims will be set separately)

    iTextRect = aLayout.TextRect();

    // Calculate text offset from rect top

    const CAknLayoutFont* layoutFont =

            CAknLayoutFont::AsCAknLayoutFontOrNull( iFont );

    if ( layoutFont )

        {

        iTextOffset = layoutFont->TextPaneTopToBaseline();

        }

    else

        {

        iTextOffset = iFont->AscentInPixels();

        }

    }

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

// CScreensaverNumberAndIconIndicator::PreferredWidth

// Return width where the whole indicator can be drawn

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

//

TInt CScreensaverIndicatorNumberAndIcon::PreferredWidth()

    {

    // Preferred width = icon width + text width + a little gap in between

    TBuf<10> nStr;

    nStr.AppendNum( iValue );

    TInt width = iFont ? iFont->TextWidthInPixels( nStr ) : nStr.Length() * 11; // Should be enough for APAC too

    // Add icon width

    width += MinimumWidth();

    // Add a little gap between text and icon

    return width + 1;

    }

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

// CScreensaverNumberAndIconIndicator::MinimumWidth

// Get minimum width 

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

//

TInt CScreensaverIndicatorNumberAndIcon::MinimumWidth()

    {

    // Minimum width is icon width

    return ( iIcon ? ( iIcon->Bitmap()->SizeInPixels()).iWidth : 0 );

    }

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

// CScreensaverNumberAndIconIndicator::SetXPos

// Sets the x-position for the indicator

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

//

void CScreensaverIndicatorNumberAndIcon::SetXPos( TInt aX )

    {

    iVisible = EFalse;

    if ( !iIcon )

        {

        return;

        }

    TBuf<10> nStr;

    nStr.AppendNum( iValue );

    TSize bmsize = iIcon->Bitmap()->SizeInPixels();

    TInt textWidth = iFont ? iFont->TextWidthInPixels( nStr ) + 1 : nStr.Length()

            * 11; // Should be enough for APAC too

    iTopLeft.iX = aX;

    if ( iAlignment == ESsAlignRight )

        {

        // Change topright to topleft.      

        iTopLeft.iX -= bmsize.iWidth + textWidth;

        }

    // Calculate text corner

    if ( iIconAlign == ESsAlignLeft )

        {

        iTextRect.iTl.iX = iTopLeft.iX + bmsize.iWidth;

        }

    else

        {

        iTextRect.iTl.iX = iTopLeft.iX;

        }

    iTextRect.SetWidth( textWidth );

    iVisible = ETrue;

    }

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

// CScreensaverNumberAndIconIndicator::InitializeLayout

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

//

void CScreensaverIndicatorNumberAndIcon::InitializeLayout()

    {

    // Set desired size for SVG graphics (height from LAF, width 3 x height)

    TAknLayoutRect screenLayout;

    screenLayout.LayoutRect( TRect(0, 0, 0, 0), AknLayout::screen() );

    TRect screenRect = screenLayout.Rect();

    TAknLayoutRect powerSavePaneLayout;

    powerSavePaneLayout.LayoutRect( screenRect,

            AknLayout::Power_save_pane_descendants_Line_1() );

    TRect powerSavePaneRect = powerSavePaneLayout.Rect();

    TAknLayoutRect rect;

    rect.LayoutRect( powerSavePaneRect,

            AknLayout::Power_save_pane_descendants_Line_3() );

    TInt height = rect.Rect().Height();

    TSize iconSize( 2 * height, height );

    AknIconUtils::SetSize( iIcon->Bitmap(), iconSize );

    }

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

// CScreensaverNumberAndIconIndicator::InitializeIconL

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

//

void CScreensaverIndicatorNumberAndIcon::InitializeIconL( TResourceReader &aReader )

    {

    // Icon & mask ids

    TInt id = aReader.ReadInt32();

    TInt maskid = aReader.ReadInt32();

    // Icon & mask skin identifiers 

    TInt skinid = aReader.ReadInt32();

    TInt skinmask = aReader.ReadInt32();

    iIcon = CGulIcon::NewL();

    CFbsBitmap* bmp= NULL;

    CFbsBitmap* mask= NULL;

    // Load skinned bitmap

    AknsUtils::CreateColorIconLC( AknsUtils::SkinInstance(),

            MakeSkinItemId( skinid ),

            KAknsIIDNone, // Lie so that we get default color, not skin color

            0, // No color group

            bmp, mask, AknIconUtils::AvkonIconFileName(), id, maskid,

            iTextColor );

    CleanupStack::Pop( 2 );

    // Save the icon

    iIcon->SetBitmap( bmp );

    iIcon->SetMask( mask );

    }

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

// CScreensaverNumberAndIconIndicator::DrawIcon

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

//

void CScreensaverIndicatorNumberAndIcon::DrawIcon( CWindowGc& aGc ) const

    {

    if ( iIconAlign == ESsAlignLeft )

        {

        if ( !iIcon->Mask() )

            {

            aGc.BitBlt( iTopLeft, iIcon->Bitmap(), iRect );

            }

        else

            {

            aGc.BitBltMasked( iTopLeft, iIcon->Bitmap(), iRect,

                    iIcon->Mask(), ETrue );

            }

        }

    else

        {

        // Calculate icon left point (right edge - icon width)

        TPoint pTmp = TPoint( iTopLeft.iX + iRect.Size().iWidth - iIcon->Bitmap()->SizeInPixels().iWidth, iTopLeft.iY );

        if ( !iIcon->Mask() )

            {

            aGc.BitBlt( pTmp, iIcon->Bitmap(), iRect );

            }

        else

            {

            aGc.BitBltMasked( pTmp, iIcon->Bitmap(), iRect, iIcon->Mask(),

                    ETrue );

            }

        }

    }

// End of file