/*

* Copyright (c) 2007 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:   All the built in brush handlers

*

*/

#include "alf/alfbrushhandlers.h"

#include "alf/alfconstants.h"

#include "alf/alfserverutils.h"

#include "alf/alfmetric.h"

#include <uiacceltk/HuiBrush.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiImageBrush.h>

#include <uiacceltk/HuiDropShadowBrush.h>

#include <uiacceltk/HuiShadowBorderBrush.h>

#include <uiacceltk/HuiGradientBrush.h>

#include <uiacceltk/huiframebrush.h>

#include <uiacceltk/HuiUtil.h>

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

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

// ?description_if_needed

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

//

EXPORT_C CAlfBrushHandler::CAlfBrushHandler(MAlfInterfaceProvider& aResolver)

 : iResolver( aResolver ), iOwnsBrush(ETrue)

    {

    }

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

// ?description_if_needed

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

//

EXPORT_C void CAlfBrushHandler::ConstructL( CHuiBrush* aBrush )

    {

    if (!aBrush)

        {

        // the child class needs to provide the brush instance.

        USER_INVARIANT();        

        }

    else 

        {

        iBrush = aBrush;    

        }

    }

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

// ?description_if_needed

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

//

EXPORT_C CAlfBrushHandler::~CAlfBrushHandler()

    {

    if ( iOwnsBrush )

        {

        delete iBrush;

        }

    iBrush = NULL;

    }

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

// From class ?base_class.

// ?implementation_description

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

//

EXPORT_C void CAlfBrushHandler::Release()

    {

    delete this;

    }

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

// From class ?base_class.

// ?implementation_description

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

//   

EXPORT_C TAny* CAlfBrushHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    switch ( aInterface ) 

        {

        case EHuiObjectTypeBrush:

            return iBrush;

        case EAlfBrushHandler:

            return this;

        default:

            return NULL;          

        }

    }

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

// From class ?base_class.

// ?implementation_description

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

// 

EXPORT_C void CAlfBrushHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& aResponse)

    {

    switch (aCommandId)

        {

        case EAlfBrushGetOpacity:

            {

            TAlfTimedValue opacity;

            AlfTimedValueUtility::CopyTimedValue(iBrush->iOpacity, opacity);

            TPckg<TAlfTimedValue> resultPckg(opacity);

            aResponse = resultPckg; // awkward   

            break;

            }

        case EAlfBrushSetOpacity:

            {

            TAlfTimedValue* opacity = (TAlfTimedValue*) aInputBuffer.Ptr() ;

            AlfTimedValueUtility::CopyTimedValue(*opacity, iBrush->iOpacity, iResolver);            

            break;

            }

        case EAlfBrushSetLayer:

            {

            THuiBrushLayer* layer = (THuiBrushLayer*) aInputBuffer.Ptr() ;

            iBrush->SetLayer( *layer );

            break;

            }

        case EAlfBrushClipToVisual:

            {

            TBool clip = iBrush->ClipToVisual();

            TPckg<TBool> resultPckg(clip);            

            aResponse = resultPckg; // awkward   

            break;

            }

        case EAlfBrushSetClipToVisual:

            {

            TBool* clip = (TBool*) aInputBuffer.Ptr() ;

            iBrush->SetClipToVisual(*clip);

            break;

            }

        default:

            User::Leave(KErrNotSupported);

        }

    }

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

// New method

// ?implementation_description

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

//     

EXPORT_C void CAlfBrushHandler::SetOwnership(TBool aHolderOwnsBrush)

    {

    iOwnsBrush = aHolderOwnsBrush;

    }

EXPORT_C void CAlfBrushHandler::BrushHandlerExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/)

    {

    }

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

// ?description_if_needed

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

//

EXPORT_C CAlfBorderBrushHandler::CAlfBorderBrushHandler(

    MAlfInterfaceProvider& aResolver)

: CAlfBrushHandler( aResolver ) 

    {

    }

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

// ?description_if_needed

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

//

EXPORT_C void CAlfBorderBrushHandler::ConstructL( 

    CHuiBrush* aBrush,

    TAlfXYMetric aThickness, 

    TAlfXYMetric aEdgeOffset)

    {

    if (!aBrush)

        {

        THuiXYMetric huiThickness;

        THuiXYMetric huiEdgeOffset;        

        AlfXYMetricUtility::CopyMetric(aThickness, huiThickness);

        AlfXYMetricUtility::CopyMetric(aEdgeOffset, huiEdgeOffset);

        CHuiBorderBrush* borderBrush = CHuiBorderBrush::NewLC( 

            huiThickness, huiEdgeOffset);

        CAlfBrushHandler::ConstructL( borderBrush );

        CleanupStack::Pop( borderBrush );

        }

    else 

        {

        CAlfBrushHandler::ConstructL( aBrush );

        }

    }

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

// ?description_if_needed

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

//

EXPORT_C MAlfExtension* CAlfBorderBrushHandler::NewL( 

    MAlfInterfaceProvider& aResolver,

    TAlfXYMetric aThickness, 

    TAlfXYMetric aEdgeOffset)

    {

    CAlfBorderBrushHandler* self = new( ELeave ) CAlfBorderBrushHandler( aResolver );

    CleanupStack::PushL( self );

    self->ConstructL(

        NULL,

        aThickness,

        aEdgeOffset );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

EXPORT_C void CAlfBorderBrushHandler::ConstructL( 

    CHuiBrush* aBrush,

    TInt aThicknessWidth, 

    TInt aThicknessHeight,

    TInt aEdgeOffsetX, 

    TInt aEdgeOffsetY )

    {

    if (!aBrush)

        {

        CHuiBorderBrush* borderBrush = CHuiBorderBrush::NewLC( 

            aThicknessWidth,

            aThicknessHeight,

            aEdgeOffsetX,

            aEdgeOffsetY);

        CAlfBrushHandler::ConstructL( borderBrush );

        CleanupStack::Pop( borderBrush );

        }

    else 

        {

        CAlfBrushHandler::ConstructL( aBrush );

        }

    }

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

// ?description_if_needed

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

//

EXPORT_C MAlfExtension* CAlfBorderBrushHandler::NewL( 

    MAlfInterfaceProvider& aResolver,

    TInt aThicknessWidth, 

    TInt aThicknessHeight,

    TInt aEdgeOffsetX, 

    TInt aEdgeOffsetY )

    {

    CAlfBorderBrushHandler* self = new( ELeave ) CAlfBorderBrushHandler( aResolver );

    CleanupStack::PushL( self );

    self->ConstructL(

        NULL,

        aThicknessWidth,

        aThicknessHeight,

        aEdgeOffsetX,

        aEdgeOffsetY );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

EXPORT_C CAlfBorderBrushHandler::~CAlfBorderBrushHandler()

    {

    }

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

// From class ?base_class.

// ?implementation_description

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

//

EXPORT_C void CAlfBorderBrushHandler::Release()

    {

    delete this;

    }

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

// From class ?base_class.

// ?implementation_description

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

//   

EXPORT_C TAny* CAlfBorderBrushHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    return CAlfBrushHandler::GetInterface(aInterface);   

    }

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

// From class ?base_class.

// ?implementation_description

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

// 

EXPORT_C void CAlfBorderBrushHandler::HandleCmdL(

    TInt aCommandId, 

    const TDesC8& aInputBuffer, 

    TDes8& aResponse)

    {

    CHuiBorderBrush* borderBrush = static_cast<CHuiBorderBrush*>(iBrush);

    switch (aCommandId)

        {

        case EAlfBorderBrushSetImage:

            {

            TAlfImageParams* params = (TAlfImageParams*) aInputBuffer.Ptr();

            // Todo: is is safe enough to handle textures as direct casts..

        	TInt handle = params->iTextureHandle;

        	MHuiTexture* texture = reinterpret_cast<MHuiTexture*>(handle);

   	        THuiImage huiImage;

   	        if (texture)

   	            {

   	            huiImage = THuiImage(*texture, 

	                params->iTl.iX.ValueNow(),

	                params->iTl.iY.ValueNow(),

	                params->iBr.iX.ValueNow(),

	                params->iBr.iY.ValueNow());    

    	        // We take transition time from one, assuming it is same for everyone.

    	        TInt transitionTime = params->iBr.iY.TimeToTargetinMilliSeconds();

    	        huiImage.SetTexCoords(params->iTl.iX.Target(),

    	            params->iTl.iY.Target(),

    	            params->iBr.iX.Target(),

    	            params->iBr.iY.Target(),

    	            transitionTime );

   	            }

	        borderBrush->SetImage( huiImage );

            break;

            }

        case EAlfBorderBrushSetColor:

            {

            TRgb* color = (TRgb*) aInputBuffer.Ptr();

            borderBrush->SetColor( *color );

            break;

            }

        case EAlfBorderBrushSetThickness:

            {

            TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr();

            AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iThickness, iResolver);            

            break;

            }

        case EAlfBorderBrushSetThicknessMetric:

            {

            TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr();

            THuiXYMetric huivalue;

            AlfXYMetricUtility::CopyMetric(*value, huivalue);            

            borderBrush->SetThickness(huivalue);

            break;

            }

        case EAlfBorderBrushGetThickness:

            {

            TAlfTimedPoint value;

            AlfTimedPointUtility::CopyTimedPoint(borderBrush->iThickness, value);

            TPckg<TAlfTimedPoint> resultPckg(value);            

            aResponse = resultPckg; 

            break;

            }

        case EAlfBorderBrushSetEdgeOffset:

            {

            TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr();

            AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iEdgeOffset, iResolver);            

            break;

            }

        case EAlfBorderBrushSetEdgeOffsetMetric:

            {

            TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr();

            THuiXYMetric huivalue;

            AlfXYMetricUtility::CopyMetric(*value, huivalue);            

            borderBrush->SetEdgeOffset(huivalue);

            break;

            }

        case EAlfBorderBrushGetEdgeOffset:

            {

            TAlfTimedPoint value;

            AlfTimedPointUtility::CopyTimedPoint(borderBrush->iEdgeOffset, value);

            TPckg<TAlfTimedPoint> resultPckg(value);            

            aResponse = resultPckg; 

            break;

            }

        case EAlfBorderBrushSetImageOffset:

            {

            TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr();

            AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iImageOffset, iResolver);            

            break;

            }

        case EAlfBorderBrushSetImageOffsetMetric:

            {

            TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr();

            THuiXYMetric huivalue;

            AlfXYMetricUtility::CopyMetric(*value, huivalue);            

            borderBrush->SetImageOffset(huivalue);

            break;

            }

        case EAlfBorderBrushGetImageOffset:

            {

            TAlfTimedPoint value;

            AlfTimedPointUtility::CopyTimedPoint(borderBrush->iImageOffset, value);

            TPckg<TAlfTimedPoint> resultPckg(value);            

            aResponse = resultPckg; 

            break;

            }

        default:

            CAlfBrushHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);

        }

    }

EXPORT_C void CAlfBorderBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

    {

    CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams);

    }

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

// ?description_if_needed

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

//

EXPORT_C CAlfImageBrushHandler::CAlfImageBrushHandler(

    MAlfInterfaceProvider& aResolver)

: CAlfBrushHandler( aResolver ) 

    {

    }

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

// ?description_if_needed

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

//

EXPORT_C void CAlfImageBrushHandler::ConstructL( 

    CHuiBrush* aBrush, THuiImage aImage)

    {

    if (!aBrush)

        {

        CHuiImageBrush* imageBrush = CHuiImageBrush::NewLC(aImage);

        CAlfBrushHandler::ConstructL( imageBrush );

        CleanupStack::Pop( imageBrush );

        }

    else 

        {

        CAlfBrushHandler::ConstructL( aBrush );

        }

    }

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

// ?description_if_needed

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

//

EXPORT_C MAlfExtension* CAlfImageBrushHandler::NewL( 

    MAlfInterfaceProvider& aResolver, THuiImage aImage )

    {

    CAlfImageBrushHandler* self = new( ELeave ) CAlfImageBrushHandler( aResolver );

    CleanupStack::PushL( self );

    self->ConstructL( NULL , aImage );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

EXPORT_C CAlfImageBrushHandler::~CAlfImageBrushHandler()

    {

    }

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

// From class ?base_class.

// ?implementation_description

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

//

EXPORT_C void CAlfImageBrushHandler::Release()

    {

    delete this;

    }

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

// From class ?base_class.

// ?implementation_description

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

//   

EXPORT_C TAny* CAlfImageBrushHandler::GetInterface(

    const THuiInterfaceSupport& aInterface)

    {

    return CAlfBrushHandler::GetInterface(aInterface);   

    }

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

// From class ?base_class.

// ?implementation_description