// Copyright (c) 2010 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 <e32std.h>

#include <w32std.h>

#include <e32math.h>

#include <e32keys.h>

#include "eglrendering.h"

#define KDefaultScreenNo 0

// Amount of time for which to run the app

static const TInt KAppRunDuration = 5000000;

class CWsCanvas: public CBase

{

public:

	static CWsCanvas* NewL(TInt, const TPoint&);

	~CWsCanvas();

private:

	CWsCanvas(TInt, const TPoint&);

	void ConstructL();

private:

	TSize iSz;

	RWsSession iWs;

	RWindowGroup iGrp;

	RWindow iWin;

	CWsScreenDevice* iScr;

	CWindowGc* iGc;

};

/**

 * Create a canvas to draw to.

 * @param aScrId	Screen number to use

 * @param aPos		Position on screen to use

 */

CWsCanvas* CWsCanvas::NewL(TInt aScrId, const TPoint& aPos)

	{

	}

	{

	}

CWsCanvas::~CWsCanvas()

	{

	delete iGc;

	delete iScr;

	iGrp.Close();

	iWin.Close();

	iWs.Close();

	}

/**

 * Construct the application canvas.

 * Here we setup the collaboration with the Window Server.  We want to get a window

 * on the appropriate screen, and setup a redraw handler so we can re-paint our window

 * when the Window Server wants us to.

 */

	{

	TInt err = iWs.Connect();

	User::LeaveIfError(err);

	iScr = new(ELeave) CWsScreenDevice(iWs);

	err = iScr->Construct(iScrId);

	User::LeaveIfError(err);

	err = iScr->CreateContext(iGc);

	User::LeaveIfError(err);

	iGrp = RWindowGroup(iWs);

	err = iGrp.Construct(0xbadf00d, ETrue, iScr);

	User::LeaveIfError(err);

	iWin = RWindow(iWs);

	err = iWin.Construct(iGrp, (TUint32)this);

	User::LeaveIfError(err);

	iSz = iScr->SizeInPixels();

	iWin.SetExtent(iPos, iSz);

	iWin.SetBackgroundColor();

	iWin.Activate();

	iWs.Flush();

	}

	{

	}

CWsApp* CWsApp::NewL()

	{

	}

/**

 * Constructor for CWsApp

 * @note This constructor looks at the command line argument, if any, supplied when

 */

void CWsApp::ConstructL()

    {

	// Set a timer to stop the application after a short time

	iTimer = CPeriodic::NewL(CActive::EPriorityIdle);

	iTimer->Start(KAppRunDuration, KAppRunDuration, TCallBack(TimerCallBack,this));

	iScrId = KDefaultScreenNo;

	if (User::CommandLineLength() > 0)

		{

		TBuf<1> arg;

		User::CommandLine(arg);

		iScrId = (TInt)(arg[0]-'0');

		}

	iAppView = CWsCanvas::NewL(iScrId, iPos);

	iDemo->Start();

	iSz = iAppView->ScreenSize();

	}

TInt CWsApp::TimerCallBack(TAny* aApp)

    {

    reinterpret_cast<CWsApp*>(aApp)->Stop();

    return KErrNone;

    }

void CWsApp::Start()

	{

	CActiveScheduler::Start();

	}

void CWsApp::Stop()

	{

	}

CWsApp::~CWsApp()

	delete iDemo;

	delete iAppView;

	delete iTimer;

	}

/**

 * Application second level entry point.

 * Launches the application specific class CWsApp and calls Start() on it.

 * @pre Active scheduler established.

 */

void MainL()

	{

	CWsApp* app = CWsApp::NewL();

	CleanupStack::PushL(app);

    app->Start();

	CleanupStack::PopAndDestroy(1, app);

	}

/**

 * Application entry point.

 * This sets up the application environment active scheduler and runs MainL under a trap

 * harness.

 */

GLDEF_C TInt E32Main()

    {

	CTrapCleanup* tc = CTrapCleanup::New();

	if (!tc)

		{

		return KErrNoMemory;

		}

	CActiveScheduler* as = new CActiveScheduler;

	if (!as)

		{

		delete tc;

		return KErrNoMemory;

		}

	CActiveScheduler::Install(as);

	TRAPD(err, MainL());

	delete as;

	delete tc;

	return err;

    }