/*

* 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 "mcedisplaysink.h"

#include "mcecomdisplaysink.h"

#include "mcesession.h"

#include "mce.h"

#include "mceitcsender.h"

#include "mcemediastream.h"

#include "mcemanager.h"

#include "mceavsink.h"

#include "mceclilogs.h"

#include <w32std.h>

#define _FLAT_DATA static_cast<CMceComDisplaySink*>( iFlatData )

#define FLAT_DATA( data ) _FLAT_DATA->data

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

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

// 

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

//

EXPORT_C CMceDisplaySink* CMceDisplaySink::NewL( CMceManager& aManager )

    {

    CMceDisplaySink* self = CMceDisplaySink::NewLC( aManager );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

EXPORT_C CMceDisplaySink* CMceDisplaySink::NewLC( CMceManager& aManager )

    {

    CMceDisplaySink* self = new (ELeave) CMceDisplaySink();

    CleanupStack::PushL( self );

    self->ConstructL( &aManager );

    return self;

    }

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

// 

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

//

EXPORT_C CMceDisplaySink::~CMceDisplaySink()

    {

    if ( iEndpointProxy )

        {

        CMceAvSink* endpointProxy = static_cast<CMceAvSink*>( iEndpointProxy );

        endpointProxy->RemoveProxyClient( *this );

        if ( endpointProxy->ReferenceCount() == 0 )

            {

            delete endpointProxy;

            }

        iEndpointProxy = NULL;

        }

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::EnableL()

    {

    MCECLI_DEBUG("CMceDisplaySink::EnableL, Entry");

    CMceMediaSink::DoEnableL();

    MCECLI_DEBUG("CMceDisplaySink::EnableL, Exit");

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::DisableL()

    {

    MCECLI_DEBUG("CMceDisplaySink::DisableL, Entry");

    CMceMediaSink::DoDisableL();

    MCECLI_DEBUG("CMceDisplaySink::DisableL, Exit");

    }

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

// 

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

//

EXPORT_C TInt CMceDisplaySink::DisplaysAvailable() const

    {

    return FLAT_DATA( iDisplaysAvailable );

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::SetDisplayIndexL( TInt aDisplayIndex )

    {

    MCECLI_DEBUG("CMceDisplaySink::SetDisplayIndexL, Entry");

    MCECLI_DEBUG_DVALUE("index", aDisplayIndex );

    __ASSERT_ALWAYS( aDisplayIndex >= 0 &&

                     aDisplayIndex < this->DisplaysAvailable(),

                     User::Leave( KErrArgument ) );

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        FLAT_DATA( iDisplayIndex ) = SetITCValueL( EMceItcSetDisplayIndex,

                                                   aDisplayIndex );

        }

    else

        {

    	FLAT_DATA( iDisplayIndex ) = aDisplayIndex;

        MCECLI_DEBUG("CMceDisplaySink::SetZoomFactorL, done locally");

        }      

    MCECLI_DEBUG("CMceDisplaySink::SetDisplayIndexL, Exit");

    }   

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

// 

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

//    

EXPORT_C void CMceDisplaySink::SetDisplay( RWindow& aWindow, CWindowGc& aGc )

    {

    iWindow = &aWindow;

    iGc = &aGc;

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::SetDisplayRectL( const TRect& aRect )

    {

    MCECLI_DEBUG("CMceDisplaySink::SetDisplayRectL, Entry");

    MCECLI_DEBUG_DVALUES("top left X", aRect.iTl.iX, "top left Y", aRect.iTl.iY );

    MCECLI_DEBUG_DVALUES("bottom right X", aRect.iBr.iX, "bottom right Y", aRect.iBr.iY );

    FLAT_DATA( iDisplayRectTlX ) = aRect.iTl.iX;

	FLAT_DATA( iDisplayRectTlY ) = aRect.iTl.iY;

	FLAT_DATA( iDisplayRectBrX ) = aRect.iBr.iX;

	FLAT_DATA( iDisplayRectBrY ) = aRect.iBr.iY;

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        CMceSession* session = iStream->Session();

    	TMceIds ids;

    	session->PrepareForITC( ids );

    	ids.iMediaID   = iStream->Id();

    	ids.iSinkID  = Id();

    	TMceItcArgTRect display( aRect );

        session->ITCSender().WriteL( ids, EMceItcSetDisplayRect, display );    

        }

    else

        {

        //NOP

        MCECLI_DEBUG("CMceDisplaySink::SetDisplayRectL, done locally");

        }      

    MCECLI_DEBUG("CMceDisplaySink::SetDisplayRectL, Exit");

    }

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

// 

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

//

EXPORT_C const TRect CMceDisplaySink::DisplayRectL()

    {

    MCECLI_DEBUG("CMceDisplaySink::DisplayRectL, Entry");

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {        

        CMceSession* session = iStream->Session();

        TRect displayRectangle;

        // Receive displayRect

        TPckgBuf<TRect> displayRect( displayRectangle );

        TMceIds ids;

    	session->PrepareForITC( ids );

    	ids.iMediaID  = iStream->Id();

    	ids.iSinkID = Id();

        session->ITCSender().ReadL( ids, EMceItcDisplayRect, displayRect );

        displayRectangle = displayRect();

        FLAT_DATA( iDisplayRectTlX ) = (TUint)(displayRectangle.iTl.iX);

        FLAT_DATA( iDisplayRectTlY ) = (TUint)(displayRectangle.iTl.iY);

        FLAT_DATA( iDisplayRectBrX ) = (TUint)(displayRectangle.iBr.iX);

        FLAT_DATA( iDisplayRectBrY ) = (TUint)(displayRectangle.iBr.iY);

        }

    else

        {

        //NOP

        MCECLI_DEBUG("CMceDisplaySink::DisplayRectL, done locally");

        }      

    MCECLI_DEBUG("CMceDisplaySink::DisplayRectL, Exit");

    return TRect( FLAT_DATA( iDisplayRectTlX ),

                  FLAT_DATA( iDisplayRectTlY ),

                  FLAT_DATA( iDisplayRectBrX ),

                  FLAT_DATA( iDisplayRectBrY ) );

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::SetPriorityL( TUint aPriority )

    {

    MCECLI_DEBUG("CMceDisplaySink::SetPriorityL, Entry");

    MCECLI_DEBUG_DVALUE("priority", aPriority );

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        FLAT_DATA( iPriority ) = SetITCValueL( EMceItcSetDisplayPriority,

                                               aPriority );

        }

    else

        {

    	FLAT_DATA( iPriority ) = aPriority;

        MCECLI_DEBUG("CMceDisplaySink::SetPriorityL, done locally");

        }

    MCECLI_DEBUG("CMceDisplaySink::SetPriorityL, Exit");

    }

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

// 

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

//

EXPORT_C TUint CMceDisplaySink::PriorityL()

    {

    MCECLI_DEBUG("CMceDisplaySink::PriorityL, Entry");

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        TInt value = GetITCValueL( EMceItcDisplayPriority );

        __ASSERT_ALWAYS( value >= 0, User::Leave( KErrNotFound ) );

        FLAT_DATA( iPriority ) = value;

        }

    else

        {

        MCECLI_DEBUG("CMceDisplaySink::PriorityL, done locally");

        }

    MCECLI_DEBUG("CMceDisplaySink::PriorityL, Exit");

    return FLAT_DATA( iPriority ); 

    }

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

// 

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

//

EXPORT_C void CMceDisplaySink::SetRotationL( TRotation aRotation )

    {

    MCECLI_DEBUG("CMceDisplaySink::SetRotationL, Entry");

    MCECLI_DEBUG_DVALUE("rotation", aRotation );

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        TInt value = SetITCValueL( EMceItcSetDisplayRotation,

                                      static_cast<TInt>( aRotation ) );

        FLAT_DATA( iRotation ) = static_cast<TRotation>( value );

        }

    else

        {

        FLAT_DATA( iRotation ) = aRotation;

        MCECLI_DEBUG("CMceDisplaySink::SetRotationL, done locally");

        }

    MCECLI_DEBUG("CMceDisplaySink::SetRotationL, Exit");   

    }

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

// 

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

//

EXPORT_C CMceDisplaySink::TRotation CMceDisplaySink::RotationL()

    {

    MCECLI_DEBUG("CMceDisplaySink::RotationL, Entry");

    if ( MCE_ENDPOINT_ITC_ALLOWED( *this ) )

        {

        TInt value = GetITCValueL( EMceItcDisplayRotation );

        __ASSERT_ALWAYS( value >= 0, User::Leave( KErrNotFound ) );

        FLAT_DATA( iRotation ) = static_cast<TRotation>( value );

        }

    else

        {

        MCECLI_DEBUG("CMceDisplaySink::RotationL, done locally");

        }

    MCECLI_DEBUG("CMceDisplaySink::RotationL, Exit");

    return FLAT_DATA( iRotation ); 

    }

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

//

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

//

void CMceDisplaySink::InitializeL( CMceManager* aManager )

    {

    __ASSERT_ALWAYS( aManager, User::Leave( KErrArgument ) );

    if ( !FLAT_DATA( iInitialInfoRetrieved ) )

        { 

        MCECLI_DEBUG("CMceDisplaySink::InitializeL, querying available displays");

        TMceIds ids;

        ids.iAppUID = aManager->AppUid().iUid;

        TMceItcArgTInt displays;

    	_FLAT_DATA->SenderL( 

            aManager->ServerSession() ).ReadL( ids, EMceItcDisplaysAvailable, displays );

        FLAT_DATA( iDisplaysAvailable ) = displays();

        FLAT_DATA( iInitialInfoRetrieved ) = ETrue;

        }

    }

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

// CMceDisplaySink::UsesEndpointProxy()

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

//

TBool CMceDisplaySink::UsesEndpointProxy() const

    {

    return ETrue;

    }

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

// CMceDisplaySink::UsesEndpointProxy()

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

//

MMceEndPointProxy* CMceDisplaySink::CreateEndpointProxyL() const

    {

    return CMceAvSink::NewL();

    }

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

// Factory method for inner usage

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

//

CMceDisplaySink* CMceDisplaySink::NewL()

    {

    CMceDisplaySink* self = CMceDisplaySink::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Factory method for inner usage

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

//

CMceDisplaySink* CMceDisplaySink::NewLC()

    {

    CMceDisplaySink* self = new (ELeave) CMceDisplaySink();

    CleanupStack::PushL( self );

    self->ConstructL( NULL );

    return self;

    }

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

// 

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

//

TInt CMceDisplaySink::GetITCValueL( TUint8 aITCFunction )

    {

    CMceSession* session = NULL;

    if ( iStream )

        {

        session = iStream->Session();

        }

    if ( !session )

        {

        User::Leave( KErrNotReady );

        }

    TMceIds ids;

	session->PrepareForITC( ids );

	ids.iMediaID  = iStream->Id();

	ids.iSinkID = Id();

    TMceItcArgTInt value;

	session->ITCSender().ReadL(

    	ids, static_cast<TMceItcFunctions>( aITCFunction ), value );

    return value();

    }

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

// 

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

//

TInt CMceDisplaySink::SetITCValueL( TUint8 aITCFunction, 

                                    TInt aValue )

    {

    CMceSession* session = NULL;

    if ( iStream )

        {

        session = iStream->Session();

        }

    if ( !session )

        {

        User::Leave( KErrNotReady );

        }

	TMceIds ids;

	session->PrepareForITC( ids );

	ids.iMediaID   = iStream->Id();

	ids.iSinkID  = Id();

    TMceItcArgTInt value( aValue );

    session->ITCSender().WriteL( 

        ids, static_cast<TMceItcFunctions>( aITCFunction ), value );

    return value();

    }

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

// 

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

//

CMceDisplaySink::CMceDisplaySink()

    :CMceMediaSink(),

     iWindow( NULL ),

     iGc( NULL )

    {

    }

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

// 

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

//

void CMceDisplaySink::ConstructL( CMceManager* aManager )

    {

    CMceComDisplaySink* sink = CMceComDisplaySink::NewLC();

    CMceMediaSink::ConstructL( sink );

    CleanupStack::Pop( sink );

    if ( aManager )

        {        

        InitializeL( aManager );

        }

    }