/*

* Copyright (c) 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:    Recording graphics context used to cache drawing commands

*

*/

#include <bitdev.h>

#include <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

#include <e32err.h>

#include "cmrrecordinggc.h"

#include "emailtrace.h"

namespace

{

#ifdef _DEBUG

_LIT( KPanicCategory, "CMRRecordingGc" );

enum TPanic

    {

    EBadArgument = 0,

    ENotSupported

    };

void Panic( TPanic aPanic )

    {

    User::Panic( KPanicCategory, aPanic );

    }

#endif // _DEBUG

}

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

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

// CMRRecordingGc::CMRRecordingGc

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

//

CMRRecordingGc::CMRRecordingGc( CWindowGc& aRealGc )

    : CWindowGc( static_cast<CWsScreenDevice*>( aRealGc.Device() ) ),

      iRealGc( aRealGc )

    {

    FUNC_LOG;

    }

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

// CMRRecordingGc::~CMRRecordingGc

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

//

CMRRecordingGc::~CMRRecordingGc()

    {

    FUNC_LOG;

    iItems.ResetAndDestroy();

    }

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

// CMRRecordingGc::FlushBuffer

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

//

void CMRRecordingGc::FlushBuffer( const TRect& aRect )

    {

    FUNC_LOG;

    if ( iItems.Count() == 0 )

        {

        return;

        }

    CBufferItem* item = NULL;

    // Use real  graphics context

    CBitmapContext* gc = &iRealGc;

    // Set graphics context origin relative to the drawing position

    gc->SetOrigin( aRect.iTl );

    for ( TInt i = 0; i < iItems.Count(); ++i )

        {

        item = iItems[i];

        switch ( item->iType )

            {

            case CBufferItem::EShortText:

                gc->DrawText( *item->iText, item->iPosition );

                break;

            case CBufferItem::ELongText:

                gc->DrawText(

                        *item->iText,

                        item->iBox,

                        item->iBaseLineOffset,

                        TTextAlign( item->iValue ), //iHorizontal,

                        item->iLeftMargin );

                break;

            case CBufferItem::ESetPenColor:

                gc->SetPenColor( item->iColor );

                break;

            case CBufferItem::EBitBltMasked1:

                gc->BitBltMasked(

                        item->iPosition,

                        item->iBitmap,

                        item->iBox,

                        item->iMask,

                        item->iInvertMask );

                break;

            case CBufferItem::EUseFont:

                gc->UseFont( item->iFont );

                break;

            case CBufferItem::EDiscardFont:

                gc->DiscardFont();

                break;

            case CBufferItem::ESetDrawMode:

                gc->SetDrawMode( TDrawMode( item->iValue ) );

                break;

            case CBufferItem::ESetClippingRect:

                gc->SetClippingRect( item->iBox );

                break;

            case CBufferItem::ECancelClippingRect:

                gc->CancelClippingRect();

                break;

            case CBufferItem::ESetBrushColor:

                gc->SetBrushColor( item->iColor );

                break;

            case CBufferItem::ESetBrushStyle:

                gc->SetBrushStyle( TBrushStyle( item->iValue ) );//iBrushStyle );

                break;

            case CBufferItem::EDrawRect:

                gc->DrawRect( item->iRect );

                break;

            case CBufferItem::EClear:

                gc->Clear( item->iRect );

                break;

            case CBufferItem::EDrawLine:

                gc->DrawLine( item->iRect.iTl, item->iRect.iBr );

                break;

            case CBufferItem::ESetUnderlineStyle:

                gc->SetUnderlineStyle( TFontUnderline( item->iValue ) );

                break;

            case CBufferItem::ESetStrikethroughStyle:

                gc->SetStrikethroughStyle( TFontStrikethrough( item->iValue ) );

                break;

            default:

                break;

            }

        }

    // Reset gc

    gc->Reset();

    }

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

// CMRRecordingGc::PurgeBuffer

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

//

void CMRRecordingGc::PurgeBuffer()

    {

    FUNC_LOG;

    iItems.ResetAndDestroy();

    }

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

// CMRRecordingGc::CBufferItem::~CBufferItem

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

//

CMRRecordingGc::CBufferItem::~CBufferItem()

    {

    FUNC_LOG;

    delete iText;

    delete iBitmap;

    delete iMask;

    }

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

// CMRRecordingGc::CBufferItem::Translate

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

//

void CMRRecordingGc::CBufferItem::Translate( const TPoint& aPoint )

    {

    FUNC_LOG;

    iBox.Move( aPoint );

    iPosition += aPoint;

    iRect.Move( aPoint );

    }

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

// CMRRecordingGc::BufferItem

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

//

CMRRecordingGc::CBufferItem* CMRRecordingGc::BufferItem()

    {

    FUNC_LOG;

    CBufferItem* buffer = NULL;

    TRAP_IGNORE(

            {

            buffer = new ( ELeave ) CBufferItem ;

            CleanupStack::PushL( buffer );

            iItems.AppendL( buffer );

            CleanupStack::Pop( buffer );

            buffer->iPosition.SetXY( -1, -1 );

            } );

    return buffer;

    }

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

// CMRRecordingGc::Activate

// From class CWindowGc

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

//

void CMRRecordingGc::Activate( RDrawableWindow& /*aDevice*/ )

    {

    FUNC_LOG;

    }

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

// CMRRecordingGc::Deactivate

// From class CWindowGc

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

//

void CMRRecordingGc::Deactivate()

    {

    FUNC_LOG;

    }

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

// CMRRecordingGc::Device

// From class CWindowGc

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

//

CGraphicsDevice* CMRRecordingGc::Device() const

    {

    FUNC_LOG;

    return NULL;

    }

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

// CMRRecordingGc::SetOrigin

// From class CWindowGc

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

//

void CMRRecordingGc::SetOrigin( const TPoint& aPoint )

    {

    FUNC_LOG;

    iOrigin = aPoint;

    }

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

// CMRRecordingGc::SetDrawMode

// From class CWindowGc

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

//

void CMRRecordingGc::SetDrawMode( TDrawMode aDrawingMode )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ESetDrawMode;

        buffer->iValue = aDrawingMode;

        }

    }

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

// CMRRecordingGc::SetClippingRect

// From class CWindowGc

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

//

void CMRRecordingGc::SetClippingRect( const TRect& aRect )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ESetClippingRect;

        buffer->iBox = aRect;

        buffer->iPosition = aRect.iTl;

        buffer->Translate( iOrigin );

        }

    }

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

// CMRRecordingGc::CancelClippingRect

// From class CWindowGc

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

//

void CMRRecordingGc::CancelClippingRect()

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ECancelClippingRect;

        }

    }

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

// CMRRecordingGc::SetClippingRegion

// From class CWindowGc

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

//

TInt CMRRecordingGc::SetClippingRegion( const TRegion& /*aRegion*/ )

    {

    FUNC_LOG;

    return 0;

    }

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

// void CMRRecordingGc::Reset

// From class CWindowGc

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

//

void CMRRecordingGc::Reset()

    {

    FUNC_LOG;

    }

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

// CMRRecordingGc::UseFont

// From class CWindowGc

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

//

void CMRRecordingGc::UseFont( const CFont* aFont )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::EUseFont;

        buffer->iFont = aFont;

        }

    }

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

// CMRRecordingGc::DiscardFont

// From class CWindowGc

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

//

void CMRRecordingGc::DiscardFont()

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::EDiscardFont;

        }

    }

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

// CMRRecordingGc::SetUnderlineStyle

// From class CWindowGc

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

//

void CMRRecordingGc::SetUnderlineStyle( TFontUnderline aUnderlineStyle )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ESetUnderlineStyle;

        buffer->iValue = aUnderlineStyle;

        }

    }

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

// CMRRecordingGc::SetStrikethroughStyle

// From class CWindowGc

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

//

void CMRRecordingGc::SetStrikethroughStyle(

        TFontStrikethrough aStrikethroughStyle )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ESetStrikethroughStyle;

        buffer->iValue = aStrikethroughStyle;

        }

    }

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

// CMRRecordingGc::SetWordJustification

// From class CWindowGc

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

//

void CMRRecordingGc::SetWordJustification(

        TInt /*aExcessWidth*/, 

        TInt /*aNumGaps*/ )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( EFalse, Panic( ENotSupported ) );

    }

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

// CMRRecordingGc::SetCharJustification

// From class CWindowGc

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

//

void CMRRecordingGc::SetCharJustification(

        TInt /*aExcessWidth*/, 

        TInt /*aNumChars*/ )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( EFalse, Panic( ENotSupported ) );

    }

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

// CMRRecordingGc::SetPenColor

// From class CWindowGc

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

//

void CMRRecordingGc::SetPenColor( const TRgb& aColor )

    {

    FUNC_LOG;

    CBufferItem* buffer = BufferItem();

    if ( buffer )

        {

        buffer->iType = CBufferItem::ESetPenColor;

        buffer->iColor = aColor;

        }

    }

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

// CMRRecordingGc::SetPenStyle

// From class CWindowGc

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

//

void CMRRecordingGc::SetPenStyle( TPenStyle /*aPenStyle*/ )

    {

    FUNC_LOG;

    }

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

// CMRRecordingGc::SetPenSize

// From class CWindowGc

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

//

void CMRRecordingGc::SetPenSize( const TSize& /*aSize*/ )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( EFalse, Panic( ENotSupported ) );

    }

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

// CMRRecordingGc::SetBrushColor

// From class CWindowGc

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

//

void CMRRecordingGc::SetBrushColor( const TRgb& aColor )

    {