/*

* Copyright (c) 2002 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:

*

*/

// INCLUDE FILES

#include "aknedwincustomdrawbase.h"

#include <lafmain.h>

#include <AknsDrawUtils.h>

#include <frmtview.h>

#include <coecntrl.h>

#include <eikedwin.h>

#include <eikenv.h> // for AKN_LAF_COLOR macro

#include <AknUtils.h>

#include <gdi.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <aknenv.h>

#include <AknFontProvider.h>

#include <AknTextDecorationMetrics.h>

#include <AknsUtils.h>

// CONSTANTS

// This is the last character that will be treated as requiring higher underline

// const TText KMaxSpecialUnderliningChar = 0x0E5B;

const TInt KWsBufferSize = 16000;

// MEMBER FUNCTIONS

CAknEdwinCustomDrawBase::CAknEdwinCustomDrawBase(

    const MLafEnv& aEnv, const CEikEdwin& aEdwin ) :

        CLafEdwinCustomDrawBase( aEnv, aEdwin ), iEdwin( aEdwin )

    {

    // This value has to be stored as the meaning of the flag governs behaviour of controls

    // at the point of construction

    iAppSkinEnabled = AknsUtils::AvkonSkinEnabled();

    }

CAknEdwinCustomDrawBase::CAknEdwinCustomDrawBase(

    const MLafEnv& aEnv,

    const CEikEdwin& aEdwin,

    CTextView* aTextView,

    CWindowGc* aSystemGc ) :

        CLafEdwinCustomDrawBase( aEnv,aEdwin ),

        iEdwin( aEdwin ),

        iTextView( aTextView ),

        iSysGc( aSystemGc )

    {

    // This value has to be stored as the meaning of the flag governs behaviour of controls

    // at the point of construction

    iAppSkinEnabled = AknsUtils::AvkonSkinEnabled();

    }

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

// CAknEdwinCustomDrawBase::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknEdwinCustomDrawBase::ConstructL()

    {

    iWsBufferRequestId = CAknEnv::Static()->RequestWsBuffer( KWsBufferSize );

    // Returns NULL if feature not supported.

    iPictographDrawer = CAknPictographInterface::NewL(

        static_cast<CCoeControl&>( const_cast<CEikEdwin&>( iEdwin ) ),

        *static_cast<MAknPictographAnimatorCallBack*>( this ) );

    }

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

// CAknEdwinCustomDraw::NewL

// Two-phased constructor.

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

//

CAknEdwinCustomDrawBase* CAknEdwinCustomDrawBase::NewL(

    const MLafEnv& aEnv, const CEikEdwin& aControl )

    { // static

    CAknEdwinCustomDrawBase* self =

        new( ELeave ) CAknEdwinCustomDrawBase( aEnv, aControl );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CAknEdwinCustomDraw::NewL

// Two-phased constructor.

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

//

CAknEdwinCustomDrawBase* CAknEdwinCustomDrawBase::NewL(

    const MLafEnv& aEnv,

    const CEikEdwin& aControl,

    CTextView* aTextView,

    CWindowGc* aSystemGc )

    { // static

    CAknEdwinCustomDrawBase* self = new( ELeave ) CAknEdwinCustomDrawBase(

        aEnv, aControl, aTextView, aSystemGc );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAknEdwinCustomDrawBase::~CAknEdwinCustomDrawBase()

    {

    delete iPictographDrawer;

    CAknEnv::Static()->CancelWsBufferRequest( iWsBufferRequestId );

    }

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

// CAknEdwinCustomDrawBase::DrawPictographArea

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

//

void CAknEdwinCustomDrawBase::DrawPictographArea()

    {

    iEdwin.DrawTextView();

    // Mainly used for drawing form highlight frame

    const TCallBack& callback = iEdwin.PictographAnimationCallBack();

    if ( callback.iFunction )

        {

        callback.CallBack();

        }

    }

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

// CAknEdwinCustomDrawBase::DrawText

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

//

void CAknEdwinCustomDrawBase::DrawText( const TParam& aParam, 

    const TLineInfo& aLineInfo, const TCharFormat& aFormat, const TDesC& aText,

    const TPoint& aTextOrigin, TInt aExtraPixels ) const

    {

    TRect textLinesRect = iEdwin.GetTextLinesRect();

    if ( !textLinesRect.IsEmpty() )

        {

        if ( aLineInfo.iInnerRect.iTl.iY < textLinesRect.iTl.iY ||

             aLineInfo.iInnerRect.iBr.iY > textLinesRect.iBr.iY )

            {

            return;

            }

        }

    TCharFormat alteredFormat(aFormat);

    if( aFormat.iFontPresentation.iUnderline == EUnderlineOn )

        {

        // Inhibit all excess pixels

        aExtraPixels = 0;

        TInt underlinePos(0);

        (void)TextNeedsCustomUnderline( aText, aParam, aFormat, underlinePos ) ;

        // always perform custom underlining

        TRect underlineRect(aParam.iDrawRect);

        TAknTextDecorationMetrics decoration( 0 ); // Give dummy font id for default decoration

        // Note that underlinePos in scalable is a delta relative to normal baseline

        underlineRect.iBr.iY = aLineInfo.iBaseline - underlinePos + decoration.BaselineToUnderlineOffset();

        underlineRect.iTl.iY = underlineRect.iBr.iY - decoration.UnderlineHeight();

        TRAPD

            (

            err,

            DrawUnderlineL( underlineRect, aParam,aLineInfo,alteredFormat,aText,aTextOrigin,aExtraPixels)

            );

        if ( err != KErrNone )

            {

            // Just draw the underline solid

            aParam.iGc.DrawRect( underlineRect );

            }

        // we've handled the underline, so switch it off now

        alteredFormat.iFontPresentation.iUnderline = EUnderlineOff;

        aParam.iGc.SetUnderlineStyle( EUnderlineOff);  // and force it off in the GC

        }

    CFont* font = NULL;

    aParam.iMap.GetNearestFontInTwips( font, aFormat.iFontSpec );

    RRegion rgn;

        {

        rgn.AddRect( iEdwin.AdjustDrawRectForSmiley( aParam.iDrawRect ) );

        aParam.iGc.SetClippingRegion( rgn );

        }

    CLafEdwinCustomDrawBase::DrawText( aParam, aLineInfo, alteredFormat, 

        aText, aTextOrigin, aExtraPixels );

        {

        aParam.iGc.CancelClippingRegion();

        }

    rgn.Close();

    // Draw pictographs if the feature is supported.

    // Character justification is not supported.

    if ( ( iPictographDrawer && !aExtraPixels ) )

        {

        CBitmapContext* bitmapGc = NULL;

        // This is how we check the type of the graphics context

        // The gc should be one of these:

        if ( &aParam.iGc == static_cast<CGraphicsContext*>( iSysGc ) )

            {

            bitmapGc = iSysGc;

            }

        else if ( &aParam.iGc ==

            static_cast<CGraphicsContext*>( iTextView->BitmapContext() ) )

            {

            bitmapGc = iTextView->BitmapContext();

            }

        if ( bitmapGc )

            {

            const TText* text = aText.Ptr();

            TInt length( aText.Length() ); 

            TPoint point = aParam.iDrawRect.iTl;

            point.iY = aLineInfo.iBaseline;

            if ( iPictographDrawer && !aExtraPixels )

                {

                MAknPictographDrawer* drawer = 

                    iPictographDrawer->Interface();                

                if ( font )

                    {

                    drawer->DrawPictographsInText(

                        *bitmapGc,

                        *font,

                        aText,

                        point);                    

                    }

                }            

            }

        }

    aParam.iMap.ReleaseFont( font );

    // set brush back to original

    aParam.iGc.SetBrushColor(CEikonEnv::Static()->ControlColor(EColorControlBackground,iEdwin));

    }

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

// CAknEdwinCustomDrawBase::DrawText

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

//

void CAknEdwinCustomDrawBase::DrawText( const TParam& aParam, 

    const TLineInfo& aLineInfo, const TCharFormat& aFormat, const TDesC& aText, 

    const TInt aStart, const TInt aEnd, const TPoint& aTextOrigin, 

    TInt aExtraPixels ) const

    {

    DrawText( aParam, aLineInfo, aFormat, aText.Mid( aStart, aEnd - aStart ), 

        aTextOrigin, aExtraPixels );

    }

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

// CAknEdwinCustomDrawBase::DrawBackground

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

//

void CAknEdwinCustomDrawBase::DrawBackground(

    const TParam& aParam, const TRgb& aBackground, TRect& aDrawnRect ) const

    {

    if ( !iEdwin.IsBackgroundDrawingSuppressed() )

        {

        const MCoeControlBackground* drawer = iEdwin.FindBackground();

        if ( drawer )

            {

            if ( !iEdwin.SkipBackgroundDrawer() )

                {

                drawer->Draw( static_cast<CWindowGc&>( aParam.iGc ),

                              iEdwin,

                              aParam.iDrawRect );

                }

            }

        else

            {

            if ( !DrawRectWithSkin( aParam.iGc, aParam.iDrawRect, aDrawnRect ) )

                {

                aParam.iGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

                aParam.iGc.SetPenStyle( CGraphicsContext::ESolidPen );

                aParam.iGc.SetBrushColor( aBackground );

                aParam.iGc.SetPenColor( aBackground );

                aParam.iGc.DrawRect( aParam.iDrawRect );

                }

            }

        }

    aDrawnRect = aParam.iDrawRect;

    }

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

// CAknEdwinCustomDrawBase::DrawLineGraphics

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

//

void CAknEdwinCustomDrawBase::DrawLineGraphics(const TParam& aParam,const TLineInfo& aLineInfo ) const

    {

    CLafEdwinCustomDrawBase::DrawLineGraphics( aParam, aLineInfo ); // Base Call

    }

TRgb CAknEdwinCustomDrawBase::SystemColor(TUint aColorIndex,TRgb aDefaultColor) const

    {

    TRgb ret = aDefaultColor;

    if (aColorIndex==TLogicalRgb::ESystemForegroundIndex)

        {

            {

            }

        }

    else if (aColorIndex==TLogicalRgb::ESystemBackgroundIndex)

        {

        // Only override aDefaultColor if SetBackgroundColorL was called:

        (void)iEdwin.EditorBackgroundColor(ret);

        // Insist on opaque background

        ret.SetAlpha(0xFF);

        }

    else if (aColorIndex==TLogicalRgb::ESystemSelectionForegroundIndex)

        {

        ret = KRgbWhite;

            {

            if ( iEdwin.HighlightStyle() == EEikEdwinHighlightLink )

                {

                }

            else // default

                {

                }

            }

        }

    else if (aColorIndex==TLogicalRgb::ESystemSelectionBackgroundIndex)

        {

        ret = KRgbBlue;

            {

            if ( iEdwin.HighlightStyle() == EEikEdwinHighlightLink )

                {

                }

            else // default

                {

                }

            }

        }

    return ret;

    }

void CAknEdwinCustomDrawBase::CAknEdwinCustomDrawBase_Reserved_1()

    {

    }

/**

* Routine to group the common skin custom drawing

*

* @return TBool EFalse iff the drawing was not performed

*/

TBool CAknEdwinCustomDrawBase::DrawRectWithSkin( const CGraphicsContext& aGc, const TRect& aRect, TRect& aDrawnRect ) const

    {

    TBool drawn(EFalse);

    if ( iAppSkinEnabled && iTextView)

        {

        CBitmapContext* bitmapGc = NULL;

        // This is how we check the type of the graphics context

        // The gc should be one of these:

        if ( &aGc == static_cast<CGraphicsContext*>( iSysGc ) )

            bitmapGc = iSysGc;

        else if ( &aGc == static_cast<CGraphicsContext*>( iTextView->BitmapContext() ) )

            bitmapGc = iTextView->BitmapContext();

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

        else if( &aGc == static_cast<CGraphicsContext*>( &(iControl.SystemGc()) ) )

            bitmapGc = &(iControl.SystemGc());

#endif //RD_UI_TRANSITION_EFFECTS_POPUPS

        if ( bitmapGc && iEdwin.SkinEnabled() )

            {

                {

                aDrawnRect = aRect;

                drawn = ETrue;

                }

            }

        else

            {

            // perform unoptimized draw of skin using bitmap brushstyle?

            }

        }

    return drawn;

    }

TBool CAknEdwinCustomDrawBase::TextNeedsCustomUnderline( const TDesC& aText, const TParam& aParam, const TCharFormat& aFormat, TInt& underlinePos ) const

    {

    TBool needsCustomUnderline(EFalse);

    TInt fontProviderIndex = AknFontProvider::FontProviderIndexFromFontSpec( aFormat.iFontSpec );

    if ( fontProviderIndex > KErrNotFound )

        {

        needsCustomUnderline = AknFontProvider::HasBaselineCorrection( fontProviderIndex );

        if ( needsCustomUnderline )

            {

            TInt denominatorIfFractional(KAknFontProviderBaselineCorrectionIsAbsolute);

            TInt numInitialCharsTheSame(0); // not used

            TInt minimumBaselineLift(0);

            AknFontProvider::MinimumBaselineDeltaForDescriptor(

                fontProviderIndex,

                aText,

                minimumBaselineLift,

                denominatorIfFractional,

                EFalse, // Look at whole descriptor and take minimum baseline lift

                numInitialCharsTheSame);

            // Check for proportional baseline deltas:

            if ( denominatorIfFractional != KAknFontProviderBaselineCorrectionIsAbsolute )

                {

                underlinePos = minimumBaselineLift * aParam.iDrawRect.Height() / denominatorIfFractional;

                }

            else

                {

                underlinePos = minimumBaselineLift;

                }

            }

        }

    return needsCustomUnderline;

    }

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

// CAknEdwinCustomDrawBase::DrawUnderlineL

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

/*

This method has the responsibility for drawing a custom underline.

An offscreen bitmap with 8 bit greyscale is made the size of the underline. Using the same font as the editor, the text

is drawn onto this bitmap, with variable positioning, so that the text is smeared.

The "descenderBitmap" is passed to a routine that analyzes this bitmap and draws the underlines only in

between the descenders, leaving gaps.

*/

void CAknEdwinCustomDrawBase::DrawUnderlineL(

        const TRect& aUnderlineRect,

        const TParam& aParam,

        const TLineInfo& aLineInfo,

        const TCharFormat& aFormat,

        const TDesC& aText,

        const TPoint& /*aTextOrigin*/, // Not currently used

        TInt aExtraPixels) const

    {

    if (aUnderlineRect.Width() <= 0 || aUnderlineRect.Height() <= 0 )

        return;

    TRect localUnderlineRect(aUnderlineRect);

    // Create bitmap to draw the descenders to

    CFbsBitmap* descendersBitmap = new (ELeave) CFbsBitmap();

    CleanupStack::PushL( descendersBitmap);

    User::LeaveIfError( descendersBitmap->Create(TSize(localUnderlineRect.Width(),localUnderlineRect.Height()) , EGray256));

    CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(descendersBitmap);

    CleanupStack::PushL(device);

    CGraphicsContext* context=NULL;

    User::LeaveIfError(device->CreateContext(context));

    CleanupStack::PushL(context);

    CFont* font;

    // Fetch the font.  This font is already in use by the editor.  Since it is a request in twips, it will be in the

    // twips cache and the request should not go to the Fbserv server.  It should therefore be fast.

    User::LeaveIfError(aParam.iMap.GetNearestFontInTwips( font, aFormat.iFontSpec) );

    context->UseFont( font );

    DrawDescendersOntoBitmap( *context, aText, aParam, aLineInfo, localUnderlineRect, aExtraPixels );

    context->DiscardFont ();

    aParam.iMap.ReleaseFont( font );

    // Draw the line using aParam.iGc so as to pick up correct foreground color. Algo inside this method is used to avoid the descenders that are

    // already drawn onto descendersBitmap

    DrawLineWithGaps( aParam, *descendersBitmap, localUnderlineRect ) ;

    // Delete all the local objects

    CleanupStack::PopAndDestroy( context );

    CleanupStack::PopAndDestroy( device );

    CleanupStack::PopAndDestroy( descendersBitmap );

    }

/**

*  The descender parts of the text are drawn onto the bitmap context.