/*

* Copyright (c) 2002 - 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:  Test alfbrushhandlers.h

 *

*/

// [INCLUDE FILES]

#include "testalfext.h"

#include "testalfbrushhandlers.h"

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

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

// CTestAlfExt::TestBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfbrushhandlercalfbrushhandler, "In TestCAlfBrushHandlerCAlfBrushHandler");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlercalfbrushhandler);

    iLog->Log(Ktestcalfbrushhandlercalfbrushhandler);

    CTestCAlfBrushHandler* handler = new ( ELeave ) 

        CTestCAlfBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestBrushHandlerForMAlfExtensionL

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

//

TInt CTestAlfExt::TestBrushHandlerForMAlfExtensionL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfbrushhandlerrelease, "In TestCAlfBrushHandlerRelease");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlerrelease);

    iLog->Log(Ktestcalfbrushhandlerrelease);

    CTestCAlfBrushHandler* handler = new ( ELeave ) 

        CTestCAlfBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    handler->ConstructL();

    handler->TestBrushHandlerForMAlfExtensionL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestBrushHandlerForOthersL

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

//

TInt CTestAlfExt::TestBrushHandlerForOthersL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfbrushhandlergetinterface, "In TestCAlfBrushHandlerGetInterface");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlergetinterface);

    iLog->Log(Ktestcalfbrushhandlergetinterface);

    CTestCAlfBrushHandler* handler = new ( ELeave ) 

        CTestCAlfBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    handler->ConstructL();

    handler->SetOwnership( EFalse );

    handler->TestBrushHandlerForOthers( aItem );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestBorderBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestBorderBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfborderbrushhandlernewl1, "In TestCAlfBorderBrushHandlerNewL1");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfborderbrushhandlernewl1);

    iLog->Log(Ktestcalfborderbrushhandlernewl1);

    TAlfXYMetric thickness;

    TAlfXYMetric edgeOffset;

    MAlfExtension* temp = CAlfBorderBrushHandler::NewL( *iInterface, 

            thickness, edgeOffset );

    CAlfBorderBrushHandler* handler = static_cast<CAlfBorderBrushHandler*>

        ( temp );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, thickness, edgeOffset );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    handler = static_cast<CAlfBorderBrushHandler*>

        (CAlfBorderBrushHandler::NewL( *iInterface, 1, 1, 1, 1 ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush2 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush2 );

    handler->ConstructL( brush2, 1, 1, 1, 1 );

    CleanupStack::Pop( brush2 );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestBorderBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestBorderBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfborderbrushhandlernewl2, "In TestCAlfBorderBrushHandlerNewL2");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfborderbrushhandlernewl2);

    iLog->Log(Ktestcalfborderbrushhandlernewl2);

    CTestCAlfBorderBrushHandler* handler = new ( ELeave ) 

        CTestCAlfBorderBrushHandler ( *iInterface);

    CleanupStack::PushL( handler );

    TAlfXYMetric thickness;

    TAlfXYMetric edgeOffset;

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, thickness, edgeOffset );

    CleanupStack::Pop( brush );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestImageBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestImageBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlernewl, "In TestCAlfImageBrushHandlerNewL");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlernewl);

    iLog->Log(Ktestcalfimagebrushhandlernewl);

    THuiImage image;

    MAlfExtension* temp = CAlfImageBrushHandler::NewL( *iInterface, image );

    CAlfImageBrushHandler* handler = static_cast<CAlfImageBrushHandler*>

        ( temp );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, image );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestImageBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestImageBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlercalfimagebrushhandler, "In TestCAlfImageBrushHandlerCAlfImageBrushHandler");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlercalfimagebrushhandler);

    iLog->Log(Ktestcalfimagebrushhandlercalfimagebrushhandler);

    CTestCAlfImageBrushHandler* handler = new ( ELeave ) 

        CTestCAlfImageBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    THuiImage image;

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, image );

    CleanupStack::Pop( brush );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestShadowBorderBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestShadowBorderBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlerconstructl, "In TestCAlfImageBrushHandlerConstructL");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerconstructl);

    iLog->Log(Ktestcalfimagebrushhandlerconstructl);

    CAlfShadowBorderBrushHandler* handler = 

        static_cast<CAlfShadowBorderBrushHandler*>

        (CAlfShadowBorderBrushHandler::NewL( *iInterface, 1 ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, 1 );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    TAlfMetric metric;

    handler = static_cast<CAlfShadowBorderBrushHandler*>

            (CAlfShadowBorderBrushHandler::NewL( *iInterface, metric ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush1 );

    handler->ConstructL( brush1, metric );

    CleanupStack::Pop( brush1 );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    handler = new ( ELeave )CAlfShadowBorderBrushHandler( *iInterface);

    CleanupStack::PushL( handler );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestShadowBorderBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestShadowBorderBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlerrelease, "In TestCAlfImageBrushHandlerRelease");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerrelease);

    iLog->Log(Ktestcalfimagebrushhandlerrelease);

    CTestCAlfShadowBorderBrushHandler* handler = new ( ELeave ) 

        CTestCAlfShadowBorderBrushHandler ( *iInterface );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush1 );

    TAlfMetric metric;

    handler->ConstructL( brush1, metric );

    CleanupStack::Pop( brush1 );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestDropShadowBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestDropShadowBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlergetinterface, "In TestCAlfImageBrushHandlerGetInterface");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlergetinterface);

    iLog->Log(Ktestcalfimagebrushhandlergetinterface);

    CAlfDropShadowBrushHandler* handler = 

            static_cast<CAlfDropShadowBrushHandler*>

            (CAlfDropShadowBrushHandler::NewL( *iInterface, 1 ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, 1 );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    TAlfMetric metric;

    handler = static_cast<CAlfDropShadowBrushHandler*>

            (CAlfDropShadowBrushHandler::NewL( *iInterface, metric ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush1, metric );

    CleanupStack::Pop( brush1 );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestDropShadowBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestDropShadowBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlerhandlecmdl, "In TestCAlfImageBrushHandlerHandleCmdL");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerhandlecmdl);

    iLog->Log(Ktestcalfimagebrushhandlerhandlecmdl);

    CTestCAlfDropShadowBrushHandler* handler = new ( ELeave ) 

            CTestCAlfDropShadowBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    TAlfMetric metric;

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush1 );

    handler->ConstructL( brush1, metric );

    CleanupStack::Pop( brush1 );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestGradientBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestGradientBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfimagebrushhandlerbrushhandlerextension, "In TestCAlfImageBrushHandlerBrushHandlerExtension");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerbrushhandlerextension);

    iLog->Log(Ktestcalfimagebrushhandlerbrushhandlerextension);

    CAlfGradientBrushHandler* handler = static_cast<CAlfGradientBrushHandler*>

        ( CAlfGradientBrushHandler::NewL( *iInterface ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    handler = new ( ELeave ) CAlfGradientBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestGradientBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestGradientBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfshadowborderbrushhandlernewl1, "In TestCAlfShadowBorderBrushHandlerNewL1");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlernewl1);

    iLog->Log(Ktestcalfshadowborderbrushhandlernewl1);

    CTestCAlfGradientBrushHandler* handler = new ( ELeave ) 

            CTestCAlfGradientBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush );

    CleanupStack::Pop( brush );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestFrameBrushHandlerConstructL

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

//

TInt CTestAlfExt::TestFrameBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfshadowborderbrushhandlernewl2, "In TestCAlfShadowBorderBrushHandlerNewL2");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlernewl2);

    iLog->Log(Ktestcalfshadowborderbrushhandlernewl2);

    TAknsItemID id;

    TAlfXYMetric edgeOffset;

    CAlfFrameBrushHandler* handler = static_cast<CAlfFrameBrushHandler*>

        ( CAlfFrameBrushHandler::NewL( *iInterface, id, edgeOffset ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush );

    handler->ConstructL( brush, id, edgeOffset );

    CleanupStack::Pop( brush );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    handler = static_cast<CAlfFrameBrushHandler*>

            ( CAlfFrameBrushHandler::NewL( *iInterface, id, 1, 1 ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush1 );

    handler->ConstructL( brush1, id, 1, 1 );

    CleanupStack::Pop( brush1 );

    CleanupStack::PopAndDestroy( handler );

    handler = NULL;

    THuiImage image;

    handler = static_cast<CAlfFrameBrushHandler*>

            ( CAlfFrameBrushHandler::NewL( *iInterface, image, edgeOffset ) );

    CleanupStack::PushL( handler );

    CHuiBorderBrush* brush2 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush2 );

    handler->ConstructL( brush2, image, edgeOffset );

    CleanupStack::Pop( brush2 );

    CleanupStack::PopAndDestroy( handler );

    return KErrNone;

    }

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

// CTestAlfExt::TestFrameBrushHandlerProtectedL

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

//

TInt CTestAlfExt::TestFrameBrushHandlerProtectedL( CStifItemParser& aItem )

    {

    _LIT(Kctestalfext, "CTestAlfExt");

    _LIT(Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler, "In TestCAlfShadowBorderBrushHandlerCAlfShadowBorderBrushHandler");

    TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler);

    iLog->Log(Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler);

    CTestCAlfFrameBrushHandler* handler = new ( ELeave ) 

        CTestCAlfFrameBrushHandler( *iInterface );

    CleanupStack::PushL( handler );

    TAknsItemID id;

    CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

    CleanupStack::PushL( brush1 );

    handler->ConstructL( brush1, id, 1, 1 );

    CleanupStack::Pop( brush1 );

    handler->TestProtectedL( aItem );

    CleanupStack::Pop( handler );

    return KErrNone;

    }

// End of file