/*

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

*       SMIL Player media renderer for displaying text files

*

*/

#include "SmilTextRenderer.h"

#include <txtrich.h>

#include <frmtview.h>

#include <eikenv.h>

#include <fbs.h>

#include <gdi.h>

// LAF

#include <aknlayout.cdl.h>

#include <applayout.cdl.h> 

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknUtils.h>               // AknLayoutUtils

#include <AknsUtils.h>              // AknsUtils

#include <AknStatuspaneUtils.h>

#include <AknLayoutFont.h>

// pictograph support

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <msgtextutils.h>

#include <smiltransitionfilter.h>

#include <smilmediainterface.h>

#include <smilparser.h>

#ifdef TEXT_DEBUG

    #include "SmilMediaLogging.h"

#endif

//These are from LAF:

const TInt KMarginSize = KFocusSize + 1;

_LIT( KParamColor1, "foreground-color" );

_LIT( KParamColor2, "color" );

_LIT( KParamColor3, "ForegroundColor" );

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

// CSmilTextRenderer::CSmilTextRenderer

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

//

CSmilTextRenderer::CSmilTextRenderer( MSmilMedia* aMedia,

                                      DRMCommon& aDrmCommon,

                                      CDRMHelper& aDrmHelper,

                                      TUint aCharset,

                                      TMsgMediaType aMediaType 

                                      ) :

    CSmilMediaRendererBase( aMediaType, aMedia, aDrmCommon, aDrmHelper ),                                     

    iCharset( aCharset ),

#ifdef RD_SCALABLE_UI_V2 

    iNotYetDrawn( ETrue )

#endif

    {

    }

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

// CSmilTextRenderer::ConstructL

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

//

void CSmilTextRenderer::ConstructL( RFile& aFileHandle, CGraphicsContext& aGc )

    {

    iCustomDraw = CSmilTextRendererCustomDraw::NewL( *this, aGc );

#ifdef RD_MSG_XHTML_SUPPORT

    if ( iMediaType == EMsgMediaXhtml )

    	{

	    iXhtmlParser = CXhtmlParser::NewL( this );	

       	iXhtmlParser->SetMode( EFalse, ETrue );

    	}

#endif

    CreateLayoutL();

    OpenTextL( aFileHandle );

    FormatTextL( aGc );

#ifdef RD_SCALABLE_UI_V2    

    CCoeControl* parentControl = iMedia->Presentation()->GetPlayer()->GetControl( iMedia->Presentation() );

    SetContainerWindowL( *parentControl );

    TRect controlRect = iMedia->GetRegion()->GetRectangle();

    controlRect.Move( parentControl->Position() );

    SetRect( controlRect );

#endif    

    }

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

// CSmilTextRenderer::NewL

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

//

CSmilTextRenderer* CSmilTextRenderer::NewL( RFile& aFileHandle,

                                            MSmilMedia* aMedia,

                                            DRMCommon& aDrmCommon,

                                            CDRMHelper& aDrmHelper,

                                            TUint aCharset,

                                            CGraphicsContext& aGc,

                                            TMsgMediaType aMediaType 

											)

    {

    CSmilTextRenderer* renderer = new(ELeave) CSmilTextRenderer( aMedia, 

                                                                 aDrmCommon,

                                                                 aDrmHelper,

                                                                 aCharset,

                                                                 aMediaType 

                                                                 );

    CleanupStack::PushL( renderer );

    renderer->ConstructL( aFileHandle, aGc );

    CleanupStack::Pop( renderer );

    return renderer;

    }

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

// CSmilTextRenderer::~CSmilTextRenderer

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

//

CSmilTextRenderer::~CSmilTextRenderer()

    {

    delete iLayout; // text layout

    delete iRichText; // contained text object

    delete iCharFormatLayer; // char format layer

    delete iParaFormatLayer; // para format layer

    delete iCustomDraw;

    delete iBufferDevice;

    delete iBufferBitmap;

    delete iMaskDevice;

    delete iMaskBitmap;

#ifdef RD_SCALABLE_UI_V2    

    delete iSBFrame;

#endif    

#ifdef RD_MSG_XHTML_SUPPORT

	delete iXhtmlParser;

#endif    

    iMedia = NULL; // For LINT

    }

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

// CSmilTextRenderer::CreateLayoutL

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

//

void CSmilTextRenderer::CreateLayoutL()

    {

    TRect appWindowRect;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow, appWindowRect );

    TAknLayoutRect mainPane;

    if ( AknStatuspaneUtils::StaconPaneActive() )

        {

        mainPane.LayoutRect( appWindowRect, AknLayoutScalable_Avkon::main_pane( 4 ) );   

        }

    else

        {

        mainPane.LayoutRect( appWindowRect, AknLayoutScalable_Avkon::main_pane( 0 ) );   

        }

    TAknLayoutRect mainSmilPane;

    mainSmilPane.LayoutRect( mainPane.Rect(), AknLayoutScalable_Apps::main_smil_pane() );

    TAknLayoutRect smilTextPane;

    smilTextPane.LayoutRect( mainSmilPane.Rect(), AknLayoutScalable_Apps::smil_text_pane() );

    TAknLayoutRect smilListTextPane;

    smilListTextPane.LayoutRect( smilTextPane.Rect(), AknLayoutScalable_Apps::list_smil_text_pane() );

    TAknLayoutText smiltextPane;    

    smiltextPane.LayoutText( smilListTextPane.Rect(), 

                             AknLayoutScalable_Apps::smil_text_list_pane_t1( 0, 0 ) );

#ifdef RD_MSG_XHTML_SUPPORT

    if ( iMediaType == EMsgMediaXhtml )

    	{

    	TRgb textColor = smiltextPane.Color();

    	// Set default textColor for xhtml text

    	iXhtmlParser->SetDefaultTextColor( textColor );

    	TAknLayoutText smilSmalltextPane;    

        smilSmalltextPane.LayoutText( smilListTextPane.Rect(), 

                                      AknLayoutScalable_Apps::smil_text_list_pane_t1( 0, 1 ) );

        TAknLayoutText smilLargetextPane;    

        smilLargetextPane.LayoutText( smilListTextPane.Rect(), 

                                      AknLayoutScalable_Apps::smil_text_list_pane_t1( 0, 2 ) );

    	iXhtmlParser->SetFonts( smilLargetextPane.Font(),

	                            smiltextPane.Font(),

	                            smilSmalltextPane.Font(),

	                            smiltextPane.Font() );   

    	}          

#endif

    CParaFormat::TAlignment alignment( CParaFormat::ELeftAlign );

    switch ( smiltextPane.Align() )

        {

        case CGraphicsContext::ELeft:

            {

            alignment = CParaFormat::ELeftAlign;

            break;

            }

        case CGraphicsContext::ECenter:

            {

            alignment = CParaFormat::ECenterAlign;

            break;

            }

        case CGraphicsContext::ERight:

            {

            alignment = CParaFormat::ERightAlign;

            break;

            }

        default:

            {

            break;

            }

        }

    iLineHeight = smiltextPane.TextRect().Height();

    // Creates paragraph formatting parameter container.

    CParaFormat paraFormat;

    TParaFormatMask paraFormatMask;

    // Set up correct line spacing control parameters.

    paraFormatMask.SetAttrib( EAttLineSpacingControl );

    paraFormat.iLineSpacingControl = CParaFormat::ELineSpacingExactlyInPixels;

    paraFormatMask.SetAttrib( EAttLineSpacing );

    paraFormat.iLineSpacingInTwips = iLineHeight;

    // Set up correct horizontal alignment parameters.

    paraFormatMask.SetAttrib( EAttAlignment );

    paraFormat.iHorizontalAlignment = alignment;

    // Creates character formatting parameter container.

    TCharFormat charFormat;

    TCharFormatMask formatMask;

    // Set up correct character font.

    formatMask.SetAttrib( EAttFontTypeface );

    formatMask.SetAttrib( EAttFontHeight );

    formatMask.SetAttrib( EAttFontPosture );

    formatMask.SetAttrib( EAttFontStrokeWeight );

    charFormat.iFontSpec = smiltextPane.Font()->FontSpecInTwips();

    // Set up correct character color.

    formatMask.SetAttrib( EAttColor );

    charFormat.iFontPresentation.iTextColor = ResolveTextColorL( smiltextPane.Color() );

    iParaFormatLayer = CParaFormatLayer::NewL( &paraFormat, paraFormatMask );

    iCharFormatLayer = CCharFormatLayer::NewL( charFormat, formatMask );

    iRichText = CRichText::NewL( iParaFormatLayer, iCharFormatLayer );

    iLayout = CTextLayout::NewL( iRichText, iMedia->GetRectangle().Width() );

    iLayout->SetCustomDraw( iCustomDraw );

    // Do not automatically inflate the ascents inside Form 

    iLayout->SetFontHeightIncreaseFactor( 0 ); 

    // Allow minimum descent of 0

    iLayout->SetMinimumLineDescent( 0 );

    const CAknLayoutFont* layoutFont = CAknLayoutFont::AsCAknLayoutFontOrNull( smiltextPane.Font() );

    // Font must always be an CAknLayoutFont otherwise we cannot continue.

    if ( !layoutFont )

        {

        return;

        }

    const CFbsFont* fbsFont = NULL;

    if ( layoutFont->TypeUid() == KCFbsFontUid )

        {

        fbsFont = static_cast<const CFbsFont*>( layoutFont );

        }

    // Font maximum height & width.

    TInt maxHeight( 0 );

    if ( fbsFont && fbsFont->IsOpenFont() )

        {

        // FORM itself uses an OpenFont MaxHeight it if can get it. Account for this:

        TOpenFontMetrics metrics;

        fbsFont->GetFontMetrics( metrics );

        maxHeight = metrics.MaxHeight();

        }

    else

        {

        maxHeight = layoutFont->AscentInPixels();

        }

    // This space around the glyph areas is for cursor and highlight extensions but it 

    // might also be used by font.

    TAknTextDecorationMetrics decorationMetrics( layoutFont );

    TInt topMargin( 0 );

    TInt bottomMargin( 0 );

    decorationMetrics.GetTopAndBottomMargins( topMargin, bottomMargin );

    // This is the difference between what "ascent" I need, and the prediction of what FORM will use:

    TInt extraRoomForHighGlyphs = layoutFont->TextPaneTopToBaseline() - maxHeight;

    // Need to create dummy textView object as SetExcessHeightRequired is not exported for

    // CTextLayout. CTextView will not take ownership of iLayout.

    TRect empty;

    CTextView* texView = CTextView::NewL( iLayout, 

                                          empty, 

                                          NULL, 

                                          NULL, 

                                          &Window(), 

                                          NULL,

                                          &iCoeEnv->WsSession() );

    // Have to convince Form to draw into the ascent area.

    TInt excessHeightRequired = extraRoomForHighGlyphs + topMargin;

    texView->SetExcessHeightRequired( excessHeightRequired );

    delete texView; // Will not delete layout.

    }

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

// CSmilTextRenderer::OpenTextL

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

//

void CSmilTextRenderer::OpenTextL( RFile& aFileHandle )

    {

    if ( iMediaType == EMsgMediaXhtml )

    	{

#ifdef RD_MSG_XHTML_SUPPORT

	    RFile tempHandle;

	    tempHandle.Duplicate( aFileHandle );

    	iXhtmlParser->CreateDomL( tempHandle );

    	iError = 0;

    	BeginActiveWait();

    	User::LeaveIfError( iError );

#endif    	

    	}

    else

    	{

	    CMsgTextUtils* textUtils = CMsgTextUtils::NewL( iCoeEnv->FsSession() );

	    CleanupStack::PushL( textUtils );

	    TUint charset = textUtils->MibIdToCharconvIdL( iCharset );

	    CleanupStack::PopAndDestroy( textUtils );

	    RFile tempHandle;

	    tempHandle.Duplicate( aFileHandle );

	    RFileReadStream inputStream( tempHandle ); // Owns tempHandle

	    CleanupClosePushL( inputStream );

	    CPlainText::TImportExportParam param;

	    param.iForeignEncoding = charset;

	    CPlainText::TImportExportResult result;

	    iRichText->ImportTextL( 0, inputStream, param, result );

	    CleanupStack::PopAndDestroy( &inputStream );

    	}

    }

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

// CSmilTextRenderer::ResolveTextColorL

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

//

TRgb CSmilTextRenderer::ResolveTextColorL( TRgb aDefaultColor ) const

    {

    TRgb textColor = aDefaultColor;

    TPtrC fgColor = iMedia->GetParam( KParamColor1 );

    if ( !fgColor.Length() )

        {

        fgColor.Set( iMedia->GetParam( KParamColor2 ) );

        }

    if ( !fgColor.Length() )

        {

        fgColor.Set( iMedia->GetParam( KParamColor3 ) );

        }

    if ( fgColor.Length() )

        {

        TBool transparent = EFalse;

        textColor = CSmilParser::ParseColor( fgColor, transparent );

        }

    return textColor;

    }

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

// CSmilTextRenderer::FormatTextL

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

//

void CSmilTextRenderer::FormatTextL( const CGraphicsContext& aGc )

    {

    iLayout->SetImageDeviceMap( aGc.Device() );

    iLayout->SetFormatMode( CLayoutData::EFScreenMode,

                            iMedia->GetRectangle().Width(),

                            NULL );

    MSmilRegion* region = iMedia->GetRegion();

    if ( region )

        {

        TInt maxWidth = region->GetRectangle().Width();

        maxWidth = Max( 0, maxWidth - ( 2 * KMarginSize ) );

        iLayout->SetBandHeight( CLayoutData::EFHeightForFormattingAllText );

        iLayout->SetWrapWidth( maxWidth );

        iLayout->FormatBandL();

        if ( iLayout->FormattedHeightInPixels() >

             region->GetRectangle().Height() - ( 2 * KMarginSize) )

            {

            //scrolling needed

            iScrollBar = ETrue;

            if ( !AknStatuspaneUtils::StaconPaneActive() )

                {

                // Calculates how much text is hidden under control pane and

                // adds so many line breaks to the end of the text as is neccesary

                // for all the text to become visible when it is scrolled.

                TRect invisibleRect( region->GetRectangle() );

                CCoeControl* parent = iMedia->Presentation()->GetPlayer()->GetControl( iMedia->Presentation() );

                invisibleRect.Move( parent->PositionRelativeToScreen() );

                TRect controlPaneRect;

                AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EControlPane, controlPaneRect );

                invisibleRect.Intersection( controlPaneRect );

                if ( invisibleRect.Height() > 0 && 

                     iLineHeight > 0 )

                    {

                    TInt linesToAdd = invisibleRect.Height() / iLineHeight;

                    linesToAdd++;

                    while ( linesToAdd > 0 )

                        {

                        iRichText->InsertL( iRichText->DocumentLength(), CEditableText::ELineBreak);

                        linesToAdd--;

                        }

                    }

                }

#ifdef RD_SCALABLE_UI_V2           

            TRect mainpaneRect;

            AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainpaneRect );

            TAknLayoutRect scrollBarRect;

            scrollBarRect.LayoutRect( mainpaneRect, AknLayoutScalable_Avkon::scroll_pane(0) );

            iLayout->SetWrapWidth( Max( 0, ( maxWidth - scrollBarRect.Rect().Width() ) ) );

#else

            iLayout->SetWrapWidth( Max( 0, ( maxWidth - KScrollBarSize ) ) );

#endif            

            iLayout->FormatBandL();

            }

        }

    else

        {

        iLayout->SetWrapWidth( IntrinsicWidth() );

        iLayout->FormatBandL();

        }

    }

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

// CSmilTextRenderer::IsVisual

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

//

TBool CSmilTextRenderer::IsVisual() const

    {

    return ETrue;

    }

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

// CSmilTextRenderer::IsScrollable

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

//

TBool CSmilTextRenderer::IsScrollable() const

    {

    return iScrollBar;

    }

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

// CSmilTextRenderer::IntrinsicWidth

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

//

TInt CSmilTextRenderer::IntrinsicWidth() const

    {

    return iMedia->GetRectangle().Width();

    }

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

// CSmilTextRenderer::IntrinsicHeight

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

//

TInt CSmilTextRenderer::IntrinsicHeight() const

    {

    return iMedia->GetRectangle().Height();

    }

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

// CSmilTextRenderer::SeekMediaL

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

//

void CSmilTextRenderer::SeekMediaL( const TSmilTime& /*aTime*/ )

    {

    }