/*

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

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <graphics/gdi/gdiconsts.h>

#include <graphics/gdi/gdistructs.h>

#endif // SYMBIAN_ENABLE_SPLIT_HEADERS

#include <e32err.h>

#include "aknrecordinggc.h"

#ifdef _DEBUG

_LIT( KOverFlow, "Array overflow" );

_LIT( KBadArgument, "Bad argument");

#endif // _DEBUG

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

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

// CAknRecordingGc::CAknRecordingGc

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

//

CAknRecordingGc::CAknRecordingGc( CWindowGc* aRealGc ) : 

    CWindowGc( static_cast<CWsScreenDevice*>( aRealGc->Device() ) )

    {

    iRealGc = aRealGc;

    iCurrentLine = -1;

    }

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

// CAknRecordingGc::ConstructL

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

//

void CAknRecordingGc::ConstructL( const TSize& /*aSize*/ )

    {

//    iOffScreenBmp = new ( ELeave ) CFbsBitmap;

//    User::LeaveIfError( iOffScreenBmp->Create( TSize( 360, 640 ) /*aSize*/, EColor64K ) );

//    iBitmapDevice = CFbsBitmapDevice::NewL( iOffScreenBmp );

//    User::LeaveIfError( iBitmapDevice->CreateContext( iBitGc ) );

    }

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

// CAknRecordingGc::~CAknRecordingGc

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

//

CAknRecordingGc::~CAknRecordingGc()

    {

    iLines.ResetAndDestroy();

    delete iOffScreenBmp;

    delete iBitGc;

    delete iBitmapDevice;

    }

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

// CAknRecordingGc::FlushBuffer

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

//

void CAknRecordingGc::FlushBuffer( const TRect& aRect, TInt aLineToSkip )

    {

    if ( iLines.Count() == 0 )

        {

        return;

        }

    CBufferItem* item = NULL;

    CLineData* line = NULL;

    CBitmapContext* gc = iRealGc;

    // modify target rectangle to match recorded coordinates

    TInt topY = iLines[0]->iRect.iTl.iY;

    TRect rect( aRect );

    rect.iTl.iY += topY;

    rect.iBr.iY += topY;

    // move out-of-screen rectangle to match real screen coordinates

    rect.Move( 1000, 0 );

    if ( iUseBitGc )

        {

        gc = iBitGc;

        }

    TRect realRect( TPoint( 1000, 0 ), iLines[0]->iRect.Size() );

    TRect includeNextLine( realRect );

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

        {

        line = iLines[i];

        if ( rect.Intersects( includeNextLine ) && i != aLineToSkip )

            {

            gc->SetOrigin( TPoint( aRect.iTl.iX-line->iRect.iTl.iX, -rect.iTl.iY + realRect.iTl.iY ) );

            for ( TInt ii = 0; ii < line->iItems.Count(); ++ii )

                {

                item = line->iItems[ii];

                switch ( item->iType )

                    {

                    case CBufferItem::EShortText:

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

                        break;

                    case CBufferItem::ELongText:

                        gc->DrawText( *item->iText, item->iBox, item->iBaseLineOffset, item->iHorizontal, item->iLeftMargin );

                        break;

                    case CBufferItem::ESetPenColor:

                        gc->SetPenColor( item->iColor );

                        break;

/*                    case CBufferItem::EBitBlt2:

                        iRealGc->BitBlt( item->iPosition, item->iBitmap, item->iBox );

                        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( item->iDrawMode );

                        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( item->iBrushStyle );

                        break;

                    case CBufferItem::EDrawRect:

                        gc->DrawRect( item->iRect );

                        break;

                    case CBufferItem::EClear:

                        gc->Clear( item->iRect );

                        break;

                    }

                }

            gc->CancelClippingRect();

            }

        else if ( realRect.iTl.iY > aRect.iBr.iY )

            {

            break;

            }

        realRect.Move( 0, line->iRect.Height() );

        includeNextLine = realRect;

        if( i < iLines.Count()-1 )

        	includeNextLine.iBr.iY += iLines[i+1]->iRect.Height();

        }

    gc->SetOrigin( TPoint( 0, 0 ) );

    if ( iUseBitGc )

        {

        iRealGc->BitBlt( TPoint( 0, 0 ), iOffScreenBmp, TRect( 0, 0, 360, 500 ) );

        }

    }

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

// CAknRecordingGc::PurgeBuffer

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

//

void CAknRecordingGc::PurgeBuffer()

    {

    iLines.ResetAndDestroy();

    iCurrentLine = -1;

    }

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

// CAknRecordingGc::PrepareForNewLineL

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

//

void CAknRecordingGc::PrepareForNewLineL( const TRect& aRect )

    {

    CLineData* newLine = new ( ELeave ) CLineData;

    newLine->iRect = aRect;

    iLines.AppendL( newLine );

    iCurrentLine = iLines.Count() - 1;

    }

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

// CAknRecordingGc::ReplaceLineL

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

//

void CAknRecordingGc::ReplaceLineL( TInt aLine )

    {

    if (  aLine < iLines.Count() )

        {

        TRect rect( iLines[aLine]->iRect );

        delete iLines[aLine];

        iLines[aLine] = NULL;

        iLines[aLine] = new ( ELeave ) CLineData;

        iLines[aLine]->iRect = rect;

        }

    iCurrentLine = aLine;

    }

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

// CAknRecordingGc::UseBitGc

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

//

void CAknRecordingGc::UseBitGc( TBool aUseBitGc )

    {

    iUseBitGc = aUseBitGc;

    }

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

// CAknRecordingGc::InsertLineL

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

//

void CAknRecordingGc::InsertLineL( TInt aLine, const TRect& aRect )

    {

    CLineData* newLine = new ( ELeave ) CLineData;

    newLine->iRect = aRect;

    iLines.Insert( newLine, aLine );

    iCurrentLine = aLine;

    }

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

// CAknRecordingGc::InsertLineL

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

//

void CAknRecordingGc::InsertLineL( TInt aLine )

    {

    InsertLineL( aLine, TRect( 0, 0, 0, 0 ) );

    }

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

// CAknRecordingGc::AppendLineL

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

//

void CAknRecordingGc::AppendLineL()

    {

    PrepareForNewLineL( TRect( 0, 0, 0, 0 ) );

    }

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

// CAknRecordingGc::PurgeLine

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

//

void CAknRecordingGc::PurgeLine( TInt aLine )

    {

    if ( aLine < iLines.Count() )

        {

        iLines[aLine]->iItems.ResetAndDestroy();

        iCurrentLine = aLine;

        }

    }

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

// CAknRecordingGc::SetLineRect

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

//

void CAknRecordingGc::SetLineRect( TInt aLine, const TRect& aRect )

    {

    __ASSERT_DEBUG( aLine < iLines.Count(), User::Panic( KOverFlow, KErrOverflow ) );

    iLines[aLine]->iRect = aRect;

    }

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

// CAknRecordingGc::DeleteLine

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

//

void CAknRecordingGc::DeleteLine( TInt aLine )

    {

    if ( aLine != -1 && aLine < iLines.Count() )

        {

        delete iLines[aLine];

        iLines.Remove( aLine );

        }

    }

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

// CAknRecordingGc::CBufferItem::~CBufferItem()

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

//

CAknRecordingGc::CBufferItem::~CBufferItem()

    {

    delete iText;

    delete iBitmap;

    delete iMask;

    }

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

// CAknRecordingGc::CLineData::~CLineData()

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

//

CAknRecordingGc::CLineData::~CLineData()

    {

    iItems.ResetAndDestroy();

    }

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

// CAknRecordingGc::BufferItem

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

//

CAknRecordingGc::CBufferItem* CAknRecordingGc::BufferItem()

    {

    CBufferItem* buffer ( NULL );

    TRAP_IGNORE( buffer = new ( ELeave ) CBufferItem );

    TRAP_IGNORE( iLines[iCurrentLine]->iItems.AppendL( buffer ) );

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

    return buffer;

    }

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

// From class CWindowGc

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

//

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

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::Deactivate()

    {

    }

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

// From class CWindowGc

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

//

CGraphicsDevice* CAknRecordingGc::Device() const

    {

    return NULL;

    }

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

// From class CWindowGc

// 

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

//

void CAknRecordingGc::SetOrigin( const TPoint& /*aPoint*/ )

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetDrawMode( TDrawMode aDrawingMode )

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::ESetDrawMode;

    buffer->iDrawMode = aDrawingMode;

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetClippingRect( const TRect& aRect )

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::ESetClippingRect;

    buffer->iBox = aRect;

    buffer->iPosition = aRect.iTl;

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::CancelClippingRect()

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::ECancelClippingRect;

    }

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

// From class CWindowGc

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

//

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

    {

    return 0;

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::Reset()

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::UseFont( const CFont* aFont )

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::EUseFont;

    buffer->iFont = aFont;

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::DiscardFont()

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::EDiscardFont;

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetUnderlineStyle( TFontUnderline /*aUnderlineStyle*/ )

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetStrikethroughStyle( 

    TFontStrikethrough /*aStrikethroughStyle*/ )

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetWordJustification( TInt /*aExcessWidth*/, 

    TInt /*aNumGaps*/ )

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetCharJustification( TInt /*aExcessWidth*/, 

    TInt /*aNumChars*/ )

    {

    }

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

// From class CWindowGc

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

//

void CAknRecordingGc::SetPenColor( const TRgb& aColor )

    {

    CBufferItem* buffer = BufferItem();

    buffer->iType = CBufferItem::ESetPenColor;

    buffer->iColor = aColor;

    }