/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description:  

* Draw filter for Draw UI plugin.

*

*/

#include <fbs.h>

#include <bitdev.h>

#include <e32math.h>

#include "cfilterdraw.h"

const TInt KDrawBitmapWidth(640);

const TInt KDrawBitmapHeight(480);

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

// Create

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

//

EXPORT_C TInt CFilterDraw::Create()

	{

	CFilterDraw* ptr = NULL;

	TRAP_IGNORE( ptr = NewL() );

	return (TInt)((MImageFilter*)ptr);

	}

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

// NewL

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

//

CFilterDraw* CFilterDraw::NewL()

	{

	return new( ELeave )CFilterDraw();

	}

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

// ~CFilterDraw

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

//

CFilterDraw::~CFilterDraw()

	{

	delete[] iData;

	iReadyToRender = EFalse;

	// Close all paths

	for( TInt i(0); i<iPaths.Count(); i++ )

		{

		iPaths[i].Close();

		}

	iPaths.Close();	

	}

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

// CFilterDraw

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

//

CFilterDraw::CFilterDraw():iData(NULL), 

    iBitmapSize(KDrawBitmapWidth, KDrawBitmapHeight)

	{

	}

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

// Rect

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

//

TRect CFilterDraw::Rect()

	{

	ASSERT(iChild);

	return iChild->Rect();

	}

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

// Scale

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

//

TReal CFilterDraw::Scale()

	{

	ASSERT(iChild);

	return iChild->Scale();

	}

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

// ViewPortSize

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

//

TSize CFilterDraw::ViewPortSize()

	{

	ASSERT(iChild);

    return iChild->ViewPortSize();

	}

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

// GetBlockL

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

//

TBlock* CFilterDraw::GetBlockL( const TRect& aRect )

	{

	ASSERT(iChild);	

    TBlock* pB = iChild->GetBlockL( aRect );

    if( !pB ) return NULL;

    TUint32* pD = pB->iData;

    if( iData && iReadyToRender )

           {

           // Factor between real and viewed image

           TReal realToViewedFactorWidth;

           TReal realToViewedFactorHeight;

           RealToViewedFactories(realToViewedFactorWidth, realToViewedFactorHeight);           

           const TInt width( iBitmapSize.iWidth ); // Data bitmap width

           for( TInt y(pB->iRect.iTl.iY); y<pB->iRect.iBr.iY; ++y )

               {

               TInt realY(y / Scale() + 0.5);

               TInt viewY(realY / realToViewedFactorHeight + 0.5);               

               for( TInt x(pB->iRect.iTl.iX); x<pB->iRect.iBr.iX; ++x )

                   {

                   TInt realX(x / Scale() + 0.5);

                   TInt viewX(realX / realToViewedFactorWidth + 0.5);

                   TUint32 color = iData[ width*viewY + viewX ];

                   if( (color & 0xff000000) )

                       {                           

                       *pD = color;

                       }

                   *pD++;

                   }                 

               }    

           }   

    return pB;

	}

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

// SetParent

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

//

void CFilterDraw::SetParent( MImageFilter* aParent )

	{

	ASSERT(aParent);

	iParent = aParent;

	}

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

// SetChild

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

//

void CFilterDraw::SetChild( MImageFilter* aChild )

	{

	ASSERT(aChild);

	iChild = aChild;

	}

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

// CmdL

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

//

TInt CFilterDraw::CmdL( const TDesC16& aCmd )

	{

	ASSERT(iChild);

	TLex lex (aCmd);

	TPoint position(0,0);	

    // Factor between real and viewed image

    TReal realToViewedFactorWidth;

    TReal realToViewedFactorHeight;

    RealToViewedFactories(realToViewedFactorWidth, realToViewedFactorHeight);

	//	Handle parameters

    while( !lex.Eos() )

		{

		TPtrC token = lex.NextToken();

		if( token.Compare( _L("x") ) == 0 )

			{

			iReadyToRender = EFalse;

            TReal relscale = Scale();

            TInt param = 0;

			lex.Inc ();

			lex.Val (param);

			// Coordinates on data bitmap

            position.iX = (TReal(param) / relscale) / realToViewedFactorWidth + 0.5;

			}

		else if( token.Compare( _L("y") ) == 0 )

			{

            TReal relscale = Scale();

            TInt param = 0;

			lex.Inc ();

			lex.Val (param);

            position.iY = (TReal(param) / relscale) / realToViewedFactorHeight + 0.5;	    			

            RDebug::Print(_L("CFilterDraw::CmdL x:%d y:%d Scale:%g Rw:%d Rh:%d Vpw:%d Vph:%d Rtvw:%g Rtvh:%g"), 

                   position.iX,

                   position.iY,

                   relscale,

                   Rect().Size().iWidth,

                   Rect().Size().iHeight,

                   ViewPortSize().iWidth,

                   ViewPortSize().iHeight,

                   realToViewedFactorWidth,

                   realToViewedFactorHeight);   			

			if(!iPaths.Count())

				{

				RDrawPath newPath;

				User::LeaveIfError( newPath.Append(position) );

				User::LeaveIfError( iPaths.Append( newPath ) );

				}

			else

				{	

				ASSERT(iPaths.Count());	

				RDrawPath& lastPath = iPaths[iPaths.Count()-1];

				User::LeaveIfError( lastPath.Append(position) );				

				}

			}

		else if( token.Compare( _L("color") ) == 0 )

			{

			TUint32 color(0);

			lex.Inc();

			lex.Val( color, EDecimal );

			TRgb rgb(color);

			TUint32 colorValue = 

			    ( rgb.Red() << 16 ) + ( rgb.Green() << 8 ) + rgb.Blue();

            ASSERT( iPaths.Count() );

			RDrawPath& lastPath = iPaths[iPaths.Count()-1];            

            lastPath.SetColor( TRgb(colorValue) );			

			}			

		else if( token.Compare( _L("size") ) == 0 )

			{

			TInt size(0);

			lex.Inc ();

			lex.Val(size);

			// Scale line size to match bitmap scale

			TInt sizew( (TReal(size) / realToViewedFactorWidth) + 0.5 );

			TInt sizeh( (TReal(size) / realToViewedFactorHeight) + 0.5 );

			if( !sizew )

			    {

			    sizew++;

			    }

            if( !sizeh )

                {

                sizeh++;

                }			

			if(iPaths.Count())	

				{

				RDrawPath& lastPath = iPaths[iPaths.Count()-1];

				lastPath.SetSize( TSize(sizew, sizeh) );			

				}

			}

        else if( token.Compare( _L("lastItem") ) == 0 )

            {

            ASSERT(iPaths.Count()); 

            RDrawPath& lastPath = iPaths[iPaths.Count()-1];

            RDebug::Print(_L("CFilterDraw::CmdL lastItem count:%d size:%d r:%d g:%d b:%d"), 

                    iPaths.Count(), lastPath.Size().iHeight,

                    lastPath.Color().Red(),

                    lastPath.Color().Green(),

                    lastPath.Color().Blue()

                    );

            RDrawPath newPath;

            User::LeaveIfError( iPaths.Append( newPath ) );             

            }   		

        else if( token.Compare( _L("done") ) == 0 )

            {

            LoadFrameL();

            iReadyToRender = ETrue;

            } 				

		}

    return KErrNone;

	}

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

// Type

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

//

const char* CFilterDraw::Type()

	{

	return "frame";

	}

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

// LoadFrameL

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

//

void CFilterDraw::LoadFrameL()

	{ 

    RDebug::Print(_L("CFilterDraw::LoadFrameL w:%d h:%d"), 

        iBitmapSize.iWidth,

        iBitmapSize.iHeight);  

    //  Create a bitmap big enough to hold the drawed lines

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

	CleanupStack::PushL( bitmap );

    User::LeaveIfError( bitmap->Create( iBitmapSize, EColor16MA ) );

	// create mask

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

	CleanupStack::PushL( mask );

	User::LeaveIfError( mask->Create(iBitmapSize,EColor16MA) );

	CFbsBitmapDevice* maskDevice = CFbsBitmapDevice::NewL( mask );

	CleanupStack::PushL( maskDevice );

    CFbsBitGc * maskContext(NULL);

    User::LeaveIfError( maskDevice->CreateContext(maskContext) );

    CleanupStack::PushL(maskContext);

    maskContext->SetPenStyle(CGraphicsContext::ESolidPen);

	maskContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	maskContext->SetBrushColor(KRgbBlack);

    //  Create bitmap device and context

    CFbsBitmapDevice * bitmapDevice = CFbsBitmapDevice::NewL (bitmap); 

    CleanupStack::PushL (bitmapDevice);

	//	Create bitmap graphics context

    CFbsBitGc * bitmapContext(NULL);

    User::LeaveIfError (bitmapDevice->CreateContext (bitmapContext));

    CleanupStack::PushL (bitmapContext);

	TDisplayMode dmode = bitmap->DisplayMode();

	for(TInt pathNumber(0); pathNumber<iPaths.Count(); pathNumber++)

   		{

   		RDrawPath path = iPaths[pathNumber];

		bitmapContext->SetPenStyle (CGraphicsContext::ESolidPen);

		bitmapContext->SetBrushStyle (CGraphicsContext::ESolidBrush);

		bitmapContext->SetPenColor(path.Color());

		bitmapContext->SetPenSize(path.Size());

		maskContext->SetPenSize(path.Size());   		

	    RDebug::Print(_L("CFilterDraw::LoadFrameL ps:%dx%d S:%g"), 

            path.Size().iWidth,

            path.Size().iHeight,

            Scale());  

		CArrayFix<TPoint>* pointArray = NULL;

		RDrawPath2PointArray(path, pointArray);

		bitmapContext->DrawPolyLine( pointArray );

		maskContext->DrawPolyLine( pointArray );

		delete pointArray;

   		}

	//	Create memory buffer to hold rendered image data

    if( !iData )

        {

        iData = new (ELeave) TUint32 [iBitmapSize.iWidth * iBitmapSize.iHeight];

        }

    Mem::FillZ(iData, 

            iBitmapSize.iWidth * iBitmapSize.iHeight * sizeof (TUint32));

    TBitmapUtil bm (bitmap);

    bm.Begin(TPoint(0,0));

    TBitmapUtil maskbm (mask);

    maskbm.Begin(TPoint(0,0));    

    TRgb rgb(0);

    // Find drawed lines from bitmap    

    for (TInt y(0); y < iBitmapSize.iHeight - 1; y++ )

    	{

    	for (TInt x(0); x < iBitmapSize.iWidth - 1; x++ )

    		{

    		// Check mask first

    		maskbm.SetPos(TPoint(x,y));

    		if( maskbm.GetPixel() == KRgbBlack.Internal() )

    			{     			

    			bm.SetPos(TPoint(x,y));

    			rgb = bm.GetPixel();

       			iData[(iBitmapSize.iWidth*y)+x] = 

       				( rgb.Red() << 16 ) + ( rgb.Green() << 8 ) + rgb.Blue() | 

       				0xff000000;

    			}

    		}

    	}

	bm.End();

	maskbm.End();

	// bitmapContext, bitmapDevice, maskContext, maskDevice, mask, bitmap

	CleanupStack::PopAndDestroy(6, bitmap); 

    RDebug::Print(_L("CFilterDraw::LoadFrameL - end"));  	

	}

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

// RDrawPath2PointArray

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

//

void CFilterDraw::RDrawPath2PointArray( 

	const RDrawPath& aPath, CArrayFix<TPoint>*& aArrayPtr) const

    {   

    // if allocation fails just do nothing. +1 if count is zero

    aArrayPtr = new CArrayFixFlat<TPoint> ( aPath.Count() + 1 );

    if (aArrayPtr)

    	{

    	for( TInt i(0); i<aPath.Count(); i++ )

    		{

    		TPoint item = aPath[i];

    		TRAP_IGNORE( aArrayPtr->AppendL( item ) );

    		}

    	}

    }

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

// RealToViewedFactories

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

//

void CFilterDraw::RealToViewedFactories(TReal& aWidth, TReal& aHeight)

    {

    // Factor between real and viewed image

    aWidth = TReal(ViewPortSize().iWidth) / 

        TReal(iBitmapSize.iWidth);

    aHeight = TReal(ViewPortSize().iHeight) / 

        TReal(iBitmapSize.iHeight);    

    }