/*

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

*

*/

#include <bitstd.h>

#include <ecam.h>

#include <ecam/mcameradirectviewfinder.h>

#include "mccscreen.h"

#include "mcccontrollerlogs.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT(KMccWindowGroupName,"32MccVideoWindow");

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

// CMccScreen::NewL

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

//

CMccScreen* CMccScreen::NewL( CCamera* aCamera,

    TPoint aPos, 

    TSize aArea, 

    TInt aIndex, 

    TInt aWindowOrdinalPosition,

    TInt aWindowOrdinalPriority )

    {

    // Resolve screen type based on ecam capabilities, asssume direct vf

    // to be available if camera not present yet.

    CMccScreen* screen = NULL;

    TBool useDirectVf = ETrue; 

    if ( aCamera )

        {

        TCameraInfo info;

        aCamera->CameraInfo( info );

        useDirectVf = ( info.iOptionsSupported & TCameraInfo::EViewFinderDirectSupported );

        }

    if ( useDirectVf )

        {

        TRAPD( err, screen = CMccScreenDirect::NewL( 

                    aCamera, aPos, aArea, aIndex, 

                    aWindowOrdinalPosition, aWindowOrdinalPriority ) );

        // If creation failes for some reason, bitmap vf is tried to be

        // created as a fallback

        if ( err == KErrNoMemory )

            {

            User::Leave( err );

            }

        if ( err )

            {

            __CONTROLLER_INT1( "CMccScreen::NewL, direct screen creation failed:", err )  

            }

        }

    if ( !screen )

        {

        screen = CMccScreenBitmap::NewL( 

                    aCamera, aPos, aArea, aIndex, 

                    aWindowOrdinalPosition, aWindowOrdinalPriority );

        }

    return screen;

    }

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

// CMccScreen::~CMccScreen

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

//

CMccScreen::~CMccScreen()

    {

    __CONTROLLER( "CMccScreen::~CMccScreen" ) 

    StopCamera();

    delete iGraphicsContext;

    delete iDev;

    delete iRw;

    delete iRwGroup;

    iRwSession.Close();

    __CONTROLLER( "CMccScreen::~CMccScreen, exit" )

    }

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

// CMccScreen::StartL

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

//

void CMccScreen::StartL()

    {

    }

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

// CMccScreen::Stop

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

//

void CMccScreen::Stop()

    {

    }

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

// CMccScreen::Draw

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

//

void CMccScreen::Draw( CFbsBitmap& /*aFrame*/ )

    {

    }

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

// CMccScreen::SetCamera

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

//

TInt CMccScreen::SetCamera( CCamera* aCamera )

    {

    if ( !aCamera )

        {

        StopCamera();

        }

    iCamera = aCamera; 

    return KErrNone;

    }

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

// CMccScreen::StopCamera

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

//

void CMccScreen::StopCamera()

    {

    __CONTROLLER( "CMccScreen::StopCamera" )

    if ( iCamera )

        {

        iCamera->StopViewFinder();

        }

    __CONTROLLER( "CMccScreen::StopCamera, exit" )

    }

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

// CMccScreen::VfStartPossible

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

//

TBool CMccScreen::VfStartPossible()

    {

    return ( iCamera && !iCamera->ViewFinderActive() && 

             iArea.iWidth > 0 &&

             iArea.iHeight > 0 );

    }

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

// CMccScreen::ConstructL

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

//

void CMccScreen::ConstructL()

    {

    __CONTROLLER( "CMccScreen::ConstructL" )

    User::LeaveIfError( iRwSession.Connect() );

    // Create window group

    TInt groupId = iRwSession.GetFocusWindowGroup();

    iRwGroup = new (ELeave) RWindowGroup( iRwSession ) ;    

    __CONTROLLER_INT1( "CMccScreen::ConstructL, window ordinal pos", 

                       iWindowOrdinalPosition )

    __CONTROLLER_INT1( "CMccScreen::ConstructL, window ordinal priority", 

                       iWindowOrdinalPriority )

    User::LeaveIfError( iRwGroup->Construct( groupId, EFalse ) );

    iRwGroup->SetName( KMccWindowGroupName );

    iRwGroup->SetOrdinalPosition( iWindowOrdinalPosition, iWindowOrdinalPriority );

    iRwGroup->AutoForeground( EFalse );

    // Create screen device

    iDev = new (ELeave) CWsScreenDevice( iRwSession );

    iDev->Construct( iDeviceIndex ); 

    TInt currMode = iDev->CurrentScreenMode();

    __CONTROLLER_INT1( "CMccScreen::ConstructL, screen device mode", currMode )

    TPixelsTwipsAndRotation sizeAndRotation;

    iDev->GetScreenModeSizeAndRotation( currMode, sizeAndRotation );

    __CONTROLLER_INT2( "CMccScreen::ConstructL, screen device size", 

                       sizeAndRotation.iPixelSize.iWidth, 

                       sizeAndRotation.iPixelSize.iHeight )

    __CONTROLLER_INT1( "CMccScreen::ConstructL, screen device orientation", 

                       sizeAndRotation.iRotation )

    // Create window

    iRw = new (ELeave) RWindow( iRwSession );

    User::LeaveIfError( iRw->Construct( *iRwGroup, (TUint32)iRw ) );

    __CONTROLLER_INT2( "CMccScreen::ConstructL, window pos", iPosition.iX, iPosition.iY )

    __CONTROLLER_INT2( "CMccScreen::ConstructL, window size", iArea.iWidth, iArea.iHeight )

    iRw->SetPosition( iPosition );

    //iRw->SetBackgroundColor( KRgbBlack );

    iRw->SetSize( iArea );    

    iRw->SetOrdinalPosition( iWindowOrdinalPosition );

    __CONTROLLER( "CMccScreen: creating graphics context ..." )

    User::LeaveIfError( iDev->CreateContext( iGraphicsContext ) );

    __CONTROLLER( "CMccScreen: graphics context created!" )

    iRw->Activate();

    iRwSession.Flush();

    __CONTROLLER( "CMccScreen::ConstructL, exit" )

    }

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

// CMccScreen::CMccScreen

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

//

CMccScreen::CMccScreen( 

    TMccScreenType aScreenType,

    CCamera* aCamera,

    TPoint aPos, 

    TSize aArea, 

    TInt aIndex, 

    TInt aWindowOrdinalPosition,

    TInt aWindowOrdinalPriority ) : 

    iCamera( aCamera ),

    iDeviceIndex( aIndex ), 

    iPosition( aPos ), 

    iArea( aArea ),

    iWindowOrdinalPosition( aWindowOrdinalPosition ),

    iWindowOrdinalPriority( aWindowOrdinalPriority ),

    iScreenType( aScreenType )

    {

    }

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

// CMccScreenBitmap::CMccScreenBitmap

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

//

CMccScreenBitmap* CMccScreenBitmap::NewL( 

    CCamera* aCamera,

    TPoint aPos, 

    TSize aArea, 

    TInt aIndex, 

    TInt aWindowOrdinalPosition,

	TInt aWindowOrdinalPriority )

	{

	CMccScreenBitmap* self = new ( ELeave ) CMccScreenBitmap( aCamera,

                                                  aPos, 

	                                              aArea, 

	                                              aIndex,

	                                              aWindowOrdinalPosition,

	                                              aWindowOrdinalPriority );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );	

	return self;

	}

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

// CMccScreenBitmap::CMccScreenBitmap

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

//

CMccScreenBitmap::CMccScreenBitmap( 

    CCamera* aCamera,

    TPoint aPos, 

    TSize aArea, 

    TInt aIndex, 

    TInt aWindowOrdinalPosition,

	TInt aWindowOrdinalPriority ) :

	CMccScreen( EBitmapScreen, aCamera, aPos, aArea, aIndex,

                aWindowOrdinalPosition, aWindowOrdinalPriority ),

	iAborted( ETrue )

	{

	}

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

// CMccScreenBitmap::CMccScreenBitmap

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

//

CMccScreenBitmap::~CMccScreenBitmap()

	{

	__CONTROLLER( "CMccScreenBitmap::~CMccScreenBitmap" )

	DetachFrame(); // Must do bitmap detach before releasing window resources

	delete iDirectScreenAccess;

    delete iPausedFrameData;

	__CONTROLLER( "CMccScreenBitmap::~CMccScreenBitmap, exit" )

	}

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

// CMccScreenBitmap::ConstructL

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

//

void CMccScreenBitmap::ConstructL()

	{

	__CONTROLLER( "CMccScreenBitmap::ConstructL" )

	CMccScreen::ConstructL();

	// Create direct screen access                                	

	iDirectScreenAccess = CDirectScreenAccess::NewL( iRwSession, *iDev, *iRw, *this );   

	UpdateViewFinderArea( iArea );

	__CONTROLLER_INT2( "CMccScreenBitmap::ConstructL, viewfinder pos", 

	                   iViewFinderImageRect.iTl.iX, iViewFinderImageRect.iTl.iY )

	__CONTROLLER_INT2( "CMccScreenBitmap::ConstructL, viewfinder size", 

	                   iViewFinderImageRect.Width(), iViewFinderImageRect.Height() )

	__CONTROLLER( "CMccScreenBitmap::ConstructL, exit" )

	}

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

// CMccScreenBitmap::StartL

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

//

void CMccScreenBitmap::StartL()

	{

	iStopped = EFalse;

    if ( iCamera )

        {

        StartCameraL();

        }

    else if ( iPausedFrameData )

        {

        __CONTROLLER( "CMccScreenBitmap::StartL, using paused frame" )

        CFbsBitmap* frame = RestoreFrameLC();

        AttachFrameL( frame );

        CleanupStack::Pop( frame );

        }

    else

        {

        // NOP

        }

    StartDsaL();

	__CONTROLLER( "CMccScreenBitmap::StartL, exit" )

	}

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

// CMccScreenBitmap::StartCameraL

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

//

void CMccScreenBitmap::StartCameraL()

    {

    __CONTROLLER( "CMccScreenBitmap::StartCameraL" )    

    __ASSERT_ALWAYS( iCamera, User::Leave( KErrNotReady ) );

    // Camera may modify the size

    TSize vfBitmapSize = iArea;

    __CONTROLLER_INT2( "CMccScreenBitmap::StartL, size before",  

                       vfBitmapSize.iWidth,

                       vfBitmapSize.iHeight )

    if ( VfStartPossible() )

        {

        iCamera->StartViewFinderBitmapsL( vfBitmapSize );

        }

    __CONTROLLER_INT2( "CMccScreenBitmap::StartL, size after",  

                       vfBitmapSize.iWidth, 

                       vfBitmapSize.iHeight )

    UpdateViewFinderArea( vfBitmapSize );

    __CONTROLLER( "CMccScreenBitmap::StartCameraL, exit" )

    }

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

// CMccScreenBitmap::StartDsaL

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

//

void CMccScreenBitmap::StartDsaL()

    {

    __CONTROLLER( "CMccScreenBitmap::StartDsaL" )    

    iAborted = EFalse;

    iDirectScreenAccess->Cancel();

    iDirectScreenAccess->StartL();

    iGc = iDirectScreenAccess->Gc();    

    iFbsDev = iDirectScreenAccess->ScreenDevice();

    iRegion = iDirectScreenAccess->DrawingRegion();     

#ifdef __MCC_CONTROLLER 

    if ( iRegion && !iRegion->IsEmpty() )

        {

        for ( TInt i = 0; i < iRegion->Count(); i++ )

            {

            const TRect& regionRect = (*iRegion)[ i ];

            __CONTROLLER_INT2( "CMccScreenBitmap::StartDsaL, rect tl", 

                               regionRect.iTl.iX, regionRect.iTl.iY )

            __CONTROLLER_INT2( "CMccScreenBitmap::StartDsaL, rect br", 

                               regionRect.iBr.iX, regionRect.iBr.iY )

            }

        }

#endif          

    iGc->SetClippingRegion( iRegion );

    // Fill with black areas which are not covered by viewfinder image.

    // If viewfinder image has not been yet received and drawn, fill whole area.

    //

    if ( !iFirstImageDrawn )

        {

        // Whole area

        iGc->SetBrushColor( KRgbBlack );

        iGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

        TPoint pointTl( 0, 0 );

        TRect rect( pointTl, iArea );

        iGc->DrawRect( rect );

        }

    else

        {

        DrawBlackBorders();

        }

    if ( iAttachedFrame )

        {

        __CONTROLLER( "CMccScreenBitmap::StartDsaL, draw attached frame" )

        TSize viewFinderImageSize = iAttachedFrame->SizeInPixels();

        TPoint corner = UpdateViewFinderArea( viewFinderImageSize );

        iGc->BitBlt( corner, iAttachedFrame );

        }

    DoScreenDeviceUpdate();

    //iGc->SetBrushStyle( CGraphicsContext::ENullBrush );

	__CONTROLLER( "CMccScreen::StartL, exit" )

	}

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

// CMccScreenBitmap::Stop

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

//

void CMccScreenBitmap::Stop()

	{

	__CONTROLLER( "CMccScreenBitmap::Stop" )

	// Don't do anything yet, wait for next frame and then stop camera

	iStopped = ETrue;

	__CONTROLLER( "CMccScreenBitmap::Stop, exit" )	

	}

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

// CMccScreenBitmap::Restart

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

//

void CMccScreenBitmap::Restart( RDirectScreenAccess::TTerminationReasons /*aReason*/ )

	{

	__CONTROLLER( "CMccScreenBitmap::Restart" )	

	TRAP_IGNORE( StartDsaL() );

	}

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

// CMccScreenBitmap::AbortNow

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

//

void CMccScreenBitmap::AbortNow( RDirectScreenAccess::TTerminationReasons /*aReason*/ )

	{

	__CONTROLLER( "CMccScreenBitmap::AbortNow" )	

	iDirectScreenAccess->Cancel();

	iAborted = ETrue;

	}

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

// CMccScreenBitmap::Draw

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

//

void CMccScreenBitmap::Draw( CFbsBitmap& aFrame )

	{

	if ( iStopped )

	    {

	    __CONTROLLER( "CMccScreenBitmap::Draw, store last frame and stop camera" )   

	    // Screen was waiting for freeze frame from camera, inform observer

	    // that camera is not needed anymore

	    StoreFrameDataL( aFrame );

	    CFbsBitmap* frame = RestoreFrameLC();

	    AttachFrameL( frame );