/*

* Copyright (c) 2002-2007 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 skinnable clock face.

*

*/

// SYSTEM INCLUDE FILES

#include <e32math.h>

#include <bitdev.h>

#include <AknsUtils.h>

#include <AknIconUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

// USER INCLUDE FILES

#include "AknUtils.h"

#include "AknSkinnableClockFace.h"

#include "AknStatuspaneUtils.h"

// LOCAL CONSTANTS AND MACROS

_LIT( KAmPm, "%B" );

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

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

// CAknSkinnableClockFaceDigital::CAknSkinnableClockFaceDigital

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknSkinnableClockFaceDigital::CAknSkinnableClockFaceDigital()

    {

    }

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

// CAknSkinnableClockFaceDigital::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknSkinnableClockFaceDigital::ConstructL()

    {

    }

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

// CAknSkinnableClockFaceDigital::NewL

// Two-phased constructor.

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

//

CAknSkinnableClockFaceDigital* CAknSkinnableClockFaceDigital::NewL()

    {

    CAknSkinnableClockFaceDigital* self =

        new ( ELeave ) CAknSkinnableClockFaceDigital;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknSkinnableClockFaceDigital::~CAknSkinnableClockFaceDigital()

    {

    }

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

// Helper method to check if latin digits should be used in the clock

// even if locale data defines otherwise.

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

//

inline TBool IsNonLatinDigitsUsed()

    {

    TLanguage uiLanguage = AknLangUtils::UserLanguage();

    TLocale locale;

    locale.Refresh();

    TDigitType digitType( locale.DigitType() );

    if ( uiLanguage == ELangUrdu )

        {

        return EFalse;

        }

    return ( AknTextUtils::DigitModeQuery() &&

             digitType != EDigitTypeDevanagari );

    }

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

// CAknSkinnableClockFaceDigital::DrawTimeToBitmap

// (other items were commented in a header).

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

//

void CAknSkinnableClockFaceDigital::DrawTimeToBitmapL( TRect& aRect,

                                          CBitmapContext& aBufferGc,

                                                        TTime& aTime )

    {

    TRect bufferRect( aRect );

    TAknWindowLineLayout smallClockPaneLayout(

        AknLayoutScalable_Apps::popup_clock_digital_window() );

    TBool smallClock( bufferRect.Width() <= smallClockPaneLayout.iW );

    TAknLayoutText amPmIndication;

    TBool isExtendedLayoutActive( AknStatuspaneUtils::ExtendedLayoutActive() );

    TBool isIdleLayoutActive( AknStatuspaneUtils::IdleLayoutActive() );

    if ( isExtendedLayoutActive &&

         isIdleLayoutActive )

        {

        amPmIndication.LayoutText(

            bufferRect,

            AknLayoutScalable_Avkon::popup_clock_digital_window_t1( 1 ) );

        }

    else if ( smallClock )

        {

        amPmIndication.LayoutText(

            bufferRect,

            AknLayoutScalable_Apps::popup_clock_digital_window_t1() );

        }

    else

        {    

        amPmIndication.LayoutText(

            bufferRect,

            AknLayoutScalable_Apps::popup_clock_digital_window_cp02_t1( 0 ) );

        }

    TAknLayoutRect qsnCpClockDigitalLine[4];

    if ( isExtendedLayoutActive &&

         isIdleLayoutActive )

            {

            qsnCpClockDigitalLine[0].LayoutRect(

                bufferRect,

                AknLayoutScalable_Avkon::clock_digital_number_pane( 2 ) );

            qsnCpClockDigitalLine[1].LayoutRect(

                bufferRect,

                AknLayoutScalable_Avkon::clock_digital_number_pane_cp03( 2 ) );

            qsnCpClockDigitalLine[2].LayoutRect(

                bufferRect,

                AknLayoutScalable_Avkon::clock_digital_number_pane_cp02( 2 ) );

            qsnCpClockDigitalLine[3].LayoutRect(

                bufferRect,

                AknLayoutScalable_Avkon::clock_digital_number_pane_cp04( 2 ) );

            }

    else if ( smallClock )

        {

        TAknWindowComponentLayout digitLayout(

            AknLayoutScalable_Apps::clock_digital_number_pane_g1() );

        qsnCpClockDigitalLine[0].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane( 0 ),

                digitLayout ) );

        qsnCpClockDigitalLine[1].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp03( 0 ),

                digitLayout ) );

        qsnCpClockDigitalLine[2].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp02( 0 ),

                    digitLayout ) );

        qsnCpClockDigitalLine[3].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp04( 0 ),

                digitLayout ) );

        }

    else

        {

        TAknWindowComponentLayout digitLayout(

            AknLayoutScalable_Apps::clock_digital_number_pane_cp10_g1(1) );

        qsnCpClockDigitalLine[0].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp10( 0 ),

                digitLayout ) );

        qsnCpClockDigitalLine[1].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp11( 0 ),

                digitLayout ) );

        qsnCpClockDigitalLine[2].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp12( 0 ),

                    digitLayout ) );

        qsnCpClockDigitalLine[3].LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_number_pane_cp13( 0 ),

                digitLayout ) );

        }

    TAknLayoutRect qsnCpClockDigitalSeparator;

    if ( isExtendedLayoutActive &&

         isIdleLayoutActive )

        {

        qsnCpClockDigitalSeparator.LayoutRect(

            bufferRect,

            AknLayoutScalable_Avkon::clock_digital_separator_pane( 2 ) );

        }

    else if ( smallClock )

        {

        qsnCpClockDigitalSeparator.LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_separator_pane( 0 ),

                AknLayoutScalable_Apps::clock_digital_separator_pane_g1() ) );

        }

    else

        {

        qsnCpClockDigitalSeparator.LayoutRect(

            bufferRect,

            TAknWindowComponentLayout::Compose(

                AknLayoutScalable_Apps::clock_digital_separator_pane_cp10( 0 ),

                AknLayoutScalable_Apps::clock_digital_separator_pane_cp10_g1(1) ) );

        }

    TDateTime dateTime( aTime.DateTime() );

    TInt hour   = dateTime.Hour();

    TInt minute = dateTime.Minute();

    TBool time24h = ETrue;

    if( TLocale().TimeFormat() == ETime12 )

        {

        time24h = EFalse;

        if ( hour < 1 )

            {

            hour = 12;

            }

        if ( hour > 12 )

            {

            hour -= 12;

            }

        }

    TInt digits[4];

    digits[0] = hour / 10;

    digits[1] = hour % 10;

    digits[2] = minute / 10;

    digits[3] = minute % 10;

    if( !digits[0] && !time24h )

        {

        digits[0] = -1;

        }

    TInt delimiterDigit =

        EAknsMinorQsnCpClockDigitalColon - EAknsMinorQsnCpClockDigitalZero;

    if( TLocale().TimeSeparator(1) == TChar('.') )

        {

        delimiterDigit =

            EAknsMinorQsnCpClockDigitalStop - EAknsMinorQsnCpClockDigitalZero;

        }

    // First, blit with soft masks (w/ halo)

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

        {

        if( digits[i] >= 0 )

            {

            BlendDigitL( 

                         aBufferGc,

                         qsnCpClockDigitalLine[i].Rect(),

                         digits[i],

                         EFalse );

            }

        }

    // Separator character

    BlendDigitL(

                 aBufferGc,

                 qsnCpClockDigitalSeparator.Rect(),

                 delimiterDigit,

                 EFalse );

    // Then, re-blit with hard masks.

    // This removes any halo bleeded to adjacent digits.

    BlendDigitL(  aBufferGc,

        qsnCpClockDigitalSeparator.Rect(), delimiterDigit, ETrue );

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

        {

        if( digits[i] >= 0 )

            {

            BlendDigitL(// bufferRect,

                         aBufferGc,

                         qsnCpClockDigitalLine[i].Rect(),

                         digits[i],

                         ETrue );

            }

        }

    if( !time24h )

        {

        TBuf<KMaxAmPmName + 1> amPmText;

        aTime.FormatL( amPmText, KAmPm );

        TRgb ampmColor = KRgbBlack;

        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

                                   ampmColor,

                                   KAknsIIDQsnIconColors,

                                   EAknsCIQsnIconColorsCG1 );

        amPmIndication.DrawText( aBufferGc, amPmText, ETrue, ampmColor);

        }

    }

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

// CAknSkinnableClockFaceDigital::BlendDigitL

// (other items were commented in a header).

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

//

void CAknSkinnableClockFaceDigital::BlendDigitL( CBitmapContext& aBufferGc,

                                                 const TRect& aRect,

                                                 const TInt aDigit,

                                                 const TBool aHardMask )

    {

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TInt baseID         = EAknsMinorQsnCpClockDigitalZero;

    TInt baseSoftMaskID = EAknsMinorQsnCpClockDigitalZeroMaskSoft; // Only for bitmaps

    TInt baseHardMaskID = EAknsMinorQsnCpClockDigitalZeroMaskHard; // Only for SVGs

    if( IsNonLatinDigitsUsed() )

        {

        // Arabic-Indic digits

        baseID         = EAknsMinorQsnCpClockDigitalAhZero;

        baseSoftMaskID = EAknsMinorQsnCpClockDigitalAhZeroMaskSoft;

        baseHardMaskID = EAknsMinorQsnCpClockDigitalAhZeroMaskHard;

        }

    TAknsItemID iid;

    CFbsBitmap* digitBitmap       = NULL;

    CFbsBitmap* digitDirectMask   = NULL;

    CFbsBitmap* digitSeparateMask = NULL;

    TBool separateMaskIsSoft( ETrue );

    TInt separateMaskID = baseSoftMaskID + aDigit;

    iid.Set( EAknsMajorSkin, baseID + aDigit );

    AknsUtils::GetCachedMaskedBitmap( skin, iid, digitBitmap, digitDirectMask );

    if( digitBitmap )

        {

        // Legacy digits

        if( AknIconUtils::IsMifIcon( digitBitmap ) )

            {

            separateMaskIsSoft = EFalse;

            separateMaskID     = baseHardMaskID + aDigit;

            }

        iid.Set( EAknsMajorSkin, separateMaskID );

        digitSeparateMask = AknsUtils::GetCachedBitmap( skin, iid );

        }

    else

        {

        // New digits

        baseID         = EAknsMinorQsnCpClockDigitalNewZero;

        baseHardMaskID = EAknsMinorQsnCpClockDigitalNewZeroShape;

        TLocale locale;

        locale.Refresh();

        TDigitType digitType( locale.DigitType() );

        if( IsNonLatinDigitsUsed() )

            {

            // Arabic-Indic digits

            baseID         = EAknsMinorQsnCpClockDigitalAhNewZero;

            baseHardMaskID = EAknsMinorQsnCpClockDigitalAhNewZeroShape;

            }

        iid.Set( EAknsMajorSkin, baseID + aDigit );

        AknsUtils::GetCachedMaskedBitmap( skin, iid, digitBitmap, digitDirectMask );

        if( !digitBitmap )

            {

            // No digit to render

            return;

            }

        separateMaskIsSoft = EFalse;

        separateMaskID     = baseHardMaskID + aDigit;

        iid.Set( EAknsMajorSkin, separateMaskID );

        digitSeparateMask = AknsUtils::GetCachedBitmap( skin, iid );

        }

    TScaleMode scalemode( EAspectRatioNotPreserved );

    User::LeaveIfError( AknIconUtils::SetSize(

        digitBitmap, aRect.Size(),

        scalemode ) );

    if( digitSeparateMask )

        {

        User::LeaveIfError( AknIconUtils::SetSize(

            digitSeparateMask, aRect.Size(),

            scalemode ) );

        }

    CFbsBitmap* digitHardMask = digitSeparateMask;

    CFbsBitmap* digitSoftMask = digitDirectMask;

    if( separateMaskIsSoft )

        {

        digitHardMask = digitDirectMask;

        digitSoftMask = digitSeparateMask;

        }

    // In case the mask sizes do not match (incorrect graphics),

    // select the smaller for rendering

    TSize digitRenderingSize = digitBitmap->SizeInPixels();

    if( digitSeparateMask )

        {

        TSize separateMaskSize = digitSeparateMask->SizeInPixels();

        if( separateMaskSize.iWidth < digitRenderingSize.iWidth )

            {

            digitRenderingSize.iWidth = separateMaskSize.iWidth;

            }

        if( separateMaskSize.iHeight < digitRenderingSize.iHeight )

            {

            digitRenderingSize.iHeight = separateMaskSize.iHeight;

            }

        }

    if( aHardMask && digitBitmap && digitHardMask &&

        // This check is needed because in some skins the

        // bitmap and hard mask might use the same display mode,

        // in which case the graphics become corrupted.

        digitHardMask->DisplayMode() < digitBitmap->DisplayMode() )

        {

        aBufferGc.BitBltMasked( aRect.iTl,

                                digitBitmap,

                                TRect( TPoint(0,0), digitRenderingSize ),

                                digitHardMask,

                                EFalse );

        }

    else if( !aHardMask && digitBitmap && digitSoftMask )

        {

        aBufferGc.BitBltMasked( aRect.iTl,

                                digitBitmap,

                                TRect( TPoint(0,0), digitRenderingSize ),

                                digitSoftMask,

                                ETrue );

        }

    }

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

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

// CAknSkinnableClockFaceAnalogue::CAknSkinnableClockFaceAnalogue

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknSkinnableClockFaceAnalogue::CAknSkinnableClockFaceAnalogue(

    const TBool aShowDate ) : iShowDate( aShowDate )

    {

    }

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

// CAknSkinnableClockFaceAnalogue::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknSkinnableClockFaceAnalogue::ConstructL()

    {

    }

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

// CAknSkinnableClockFaceAnalogue::NewL

// Two-phased constructor.

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

//

CAknSkinnableClockFaceAnalogue* CAknSkinnableClockFaceAnalogue::NewL(

    const TBool aShowDate )

    {

    CAknSkinnableClockFaceAnalogue* self =

        new( ELeave ) CAknSkinnableClockFaceAnalogue( aShowDate );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CAknSkinnableClockFaceAnalogue::~CAknSkinnableClockFaceAnalogue()

    {

    }

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

// CAknSkinnableClockFaceAnalogue::DrawTimeToBitmap

// (other items were commented in a header).

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