// Copyright (c) 1996-2009 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 classes derived from Wserv client side classes
// 
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/

#include "TDERIVED.H"

CTDerived::CTDerived(CTestStep* aStep) : CTWsGraphicsBase(aStep)
	{
	}

CTDerived::~CTDerived()
	{
	}

//
// CDerivedWindowGc //
//

CDerivedWindowGc::CDerivedWindowGc(CWsScreenDevice *aDevice) : CWindowGc(aDevice)
	{
	}

CDerivedWindowGc::~CDerivedWindowGc()
	{
	}

void CDerivedWindowGc::DrawLine(const TPoint &aPoint1,const TPoint &aPoint2)
	{
	CWindowGc::DrawLine(aPoint1+TPoint(10,10), aPoint2-TPoint(10,10));
	}

//
// RDerivedSession //
//

TInt RDerivedSession::ResourceCount()
	{
	return(RWsSession::ResourceCount()+1);
	}

void RDerivedSession::EnableAutoFlush()
	{
	SetAutoFlush(ETrue);
	}

//
// Derived windows //
//

RDerivedBlankWindow::RDerivedBlankWindow()
	{}
RDerivedBlankWindow::RDerivedBlankWindow(RWsSession &aWs) : RBlankWindow(aWs)
	{
	}

void RDerivedBlankWindow::SetColor(TRgb aColor)
	{
	RBlankWindow::SetColor(~aColor);
	}

void RDerivedBlankWindow::SetColorGray()
	{
	RBlankWindow::SetColor(TRgb::Gray16(8));
	}

RDerivedWindow::RDerivedWindow()
	{}
RDerivedWindow::RDerivedWindow(RWsSession &aWs) : RWindow(aWs)
	{
	}

void RDerivedWindow::SetBackgroundColor(TRgb aColor)
	{
	RWindow::SetBackgroundColor(~aColor);
	}

void RDerivedWindow::SetBackgroundColorGray()
	{
	RWindow::SetBackgroundColor(TRgb::Gray16(8));
	}

RDerivedBackedUpWindow::RDerivedBackedUpWindow()
	{}
RDerivedBackedUpWindow::RDerivedBackedUpWindow(RWsSession &aWs) : RBackedUpWindow(aWs)
	{
	}

TInt RDerivedBackedUpWindow::BitmapHandle()
	{
	MaintainBackup();
	return(RBackedUpWindow::BitmapHandle()+1);
	};

RDerivedWindowGroup::RDerivedWindowGroup()
	{}

RDerivedWindowGroup::RDerivedWindowGroup(RWsSession &aWs) : RWindowGroup(aWs)
	{
	}

TName RDerivedWindowGroup::Name() const
	{
	return(_L("Fred"));
	}

//
// CDerivedScreenDevice //
//

CDerivedScreenDevice::CDerivedScreenDevice()
	{}

CDerivedScreenDevice::CDerivedScreenDevice(RWsSession &aWs) : CWsScreenDevice(aWs)
	{}

TSize CDerivedScreenDevice::SizeInPixels() const
	{
	TSize size=CWsScreenDevice::SizeInPixels();
	return(TSize(size.iWidth*2,size.iHeight*2));
	}

//
// Derived Sprite/Pointer cursor //
//

RDerivedSprite::RDerivedSprite()
	{
	}

RDerivedSprite::RDerivedSprite(RWsSession &aWs) : RWsSprite(aWs)
	{
	}

RDerivedPointerCursor::RDerivedPointerCursor()
	{
	}

RDerivedPointerCursor::RDerivedPointerCursor(RWsSession &aWs) : RWsPointerCursor(aWs)
	{
	}

//

void CTDerived::ConstructL()
	{
	TheGc->Activate(*BaseWin->Win());
	TheGc->Clear();
	TheGc->SetBrushColor(TRgb::Gray16(12));
	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheGc->SetPenStyle(CGraphicsContext::ENullPen);
	TheGc->DrawRect(TRect(BaseWin->Win()->Size()));
	TheGc->Deactivate();
	TheGc->Activate(*TestWin->Win());
	TheGc->Clear();
	TheGc->SetBrushColor(TRgb::Gray16(4));
	TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TheGc->SetPenStyle(CGraphicsContext::ENullPen);
	TheGc->DrawRect(TRect(TestWin->Win()->Size()));
	TheGc->Deactivate();
	}

void CTDerived::DerivedWindowGcL()
	{
	CDerivedWindowGc *dgc=new(ELeave) CDerivedWindowGc(TheClient->iScreen);
	dgc->Construct();
	dgc->Activate(*TestWin->Win());
	dgc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	TestWin->Win()->BeginRedraw();
	dgc->DrawRect(TRect(TestWin->Win()->Size()));
	dgc->DrawLine(TPoint(0,0),TestWin->Win()->Size().AsPoint());
	TestWin->Win()->EndRedraw();
	dgc->Deactivate();
	delete dgc;
	dgc = NULL;
	CWindowGc *wgc=new(ELeave) CWindowGc(TheClient->iScreen);
	wgc->Construct();
	wgc->Activate(*BaseWin->Win());
	wgc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	BaseWin->Win()->BeginRedraw();
	wgc->DrawRect(TRect(TestWin->Win()->Size()));
	wgc->DrawLine(TPoint(10,10),TestWin->Win()->Size().AsPoint()-TPoint(10,10));
	BaseWin->Win()->EndRedraw();
	wgc->Deactivate();
	delete wgc;
	wgc = NULL;
	CompareWindows(_L("CTDerived::DerivedWindowGcL()"));
	}

void CTDerived::DerivedSession()
	{
	TInt err;
	err = iDSession.Connect();
	if (err!=KErrNone)
		return;
	
	// use the correct screen
	CWsScreenDevice* screen = NULL;
	TRAP(err, screen = new (ELeave) CWsScreenDevice(iDSession));
	if (err!=KErrNone)
		{
		iDSession.Close();
		return;
		}
	
	if ((err=screen->Construct(iTest->iScreenNumber))!=KErrNone)
		{
		delete screen;
		iDSession.Close();
		return;
		}

	delete screen;
	
	TInt retVal = iDSession.ResourceCount();	
	TEST(retVal==1);
	if (retVal!=1)
		INFO_PRINTF3(_L("iDSession.ResourceCount() return value - Expected: %d, Actual: %d"), 1, retVal);		
	
	iDSession.SetAutoFlush(EFalse);
	iDSession.EnableAutoFlush();
	
	TBool retBool = iDSession.SetAutoFlush(EFalse);	
	TEST(retBool);
	if (!retBool)
		INFO_PRINTF3(_L("iDSession.SetAutoFlush(EFalse) return value - Expected: %d, Actual: %d"), ETrue, retBool);		
	
	iDSession.Close();
	}

void CTDerived::DerivedWindows()
	{
//
// Window group
//
	iDGroup=RDerivedWindowGroup(TheClient->iWs);
	iDGroup.Construct(222);
	iDGroup.Name();
//
// Redraw up window
//
	iDRedraw=RDerivedWindow(TheClient->iWs);
	iDRedraw.Construct(iDGroup,12);
	iDRedraw.SetBackgroundColor(TRgb(1,2,3));
	iDRedraw.SetBackgroundColorGray();
	iDRedraw.Close();
//
// Blank up window
//
	iDBlank=RDerivedBlankWindow(TheClient->iWs);
	iDBlank.Construct(iDGroup,123);
	iDBlank.SetColor(TRgb(1,20,50));
	iDBlank.SetColorGray();
	iDBlank.Close();
//
// Backed up window
//
	iDBackedUp=RDerivedBackedUpWindow(TheClient->iWs);
	iDBackedUp.Construct(iDGroup,EGray4,1234);
	iDBackedUp.BitmapHandle();
	iDBackedUp.Close();
//
	iDGroup.Close();
	}

void CTDerived::DerivedScreenDeviceL()
	{
	CWsScreenDevice *wsd=new(ELeave) CWsScreenDevice(TheClient->iWs);
	User::LeaveIfError(wsd->Construct(iTest->iScreenNumber));
	TSize size1(wsd->SizeInPixels());
	delete wsd;
	CDerivedScreenDevice *dsd=new(ELeave) CDerivedScreenDevice(TheClient->iWs);
	User::LeaveIfError(dsd->Construct(iTest->iScreenNumber));
	TSize size2(dsd->SizeInPixels());
	delete dsd;
	TEST(size2.iWidth==size1.iWidth*2 && size2.iHeight==size1.iHeight*2);
	}

void CTDerived::DerivedSprite()
	{
	iDSprite=RDerivedSprite(TheClient->iWs);
	TSpriteMember spm;
	spm.iBitmap=NULL;
	spm.iMaskBitmap=NULL;
	spm.iInvertMask=EFalse;
	spm.iOffset=TPoint(0,0);				// Offset from sprites central position
	spm.iInterval=TTimeIntervalMicroSeconds32(1000000);
	iDSprite.Construct(*TestWin->Win(), TPoint(10,10), 0);
	iDSprite.Close();
//
	iDPCursor=RDerivedPointerCursor(TheClient->iWs);
	iDPCursor.Construct(0);
	iDPCursor.Close();
	};

void CTDerived::RunTestCaseL(TInt /*aCurTestCase*/)
	{
	((CTDerivedStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch(++iTest->iState)
		{
/**
@SYMTestCaseID		GRAPHICS-WSERV-0075

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test derived window graphics context

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Draw using a derived window gc and a normal
					window gc and check the dawing is the same

@SYMTestExpectedResults Drawing is the same with a derived window gc
*/
		case 1:
			((CTDerivedStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0075"));
			iTest->LogSubTest(_L("Derived Gc"));
			DerivedWindowGcL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0076

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test derived window server session

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Test that a derived window server session functions
					the same as a normal window server session

@SYMTestExpectedResults The derived window server session functions correctly
*/
		case 2:
			((CTDerivedStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0076"));
			iTest->LogSubTest(_L("Derived Session"));
			DerivedSession();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0077

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test derived windows and window groups function correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Test that a derived windows and window groups function
					the same as the classes they are derived from

@SYMTestExpectedResults The derived windows and window group functions correctly
*/
		case 3:
			((CTDerivedStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0077"));
			iTest->LogSubTest(_L("Derived Blank Window"));
			DerivedWindows();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0078

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test derived screen devices function correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Test that a derived screen device function
					the same as the class it is derived from

@SYMTestExpectedResults The derived screen device functions correctly
*/
		case 4:
			((CTDerivedStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0078"));
			iTest->LogSubTest(_L("Derived Screed Device"));
			DerivedScreenDeviceL();
			break;
/**
@SYMTestCaseID		GRAPHICS-WSERV-0079

@SYMDEF             DEF081259

@SYMTestCaseDesc    Test derived sprites and pointer cursors function
					correctly

@SYMTestPriority    High

@SYMTestStatus      Implemented

@SYMTestActions     Test that a derived sprite and pointer cursor
					function correctly

@SYMTestExpectedResults The derived sprite and pointer cursor function 
					correctly
*/
		case 5:
			((CTDerivedStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0079"));
			iTest->LogSubTest(_L("Derived Sprites"));
			DerivedSprite();
			break;
		case 6:
			((CTDerivedStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			((CTDerivedStep*)iStep)->CloseTMSGraphicsStep();
			TestComplete();	
			break;
		}
	((CTDerivedStep*)iStep)->RecordTestResultL();
	}
	
__WS_CONSTRUCT_STEP__(Derived)