// 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

class CWsRedrawHandler;

class CWsCanvas: public CBase
{
public:
	static CWsCanvas* NewL(TInt, const TPoint&);
	~CWsCanvas();

	void DrawNow();
	void Redraw();
	void Draw(const TRect&);

	RWsSession& Session() {return iWs;}
	RWindow& Window() {return iWin;}
	RWindowGroup& Group() {return iGrp;}
	CWindowGc* Gc() {return iGc;}
	CWsScreenDevice* Screen() {return iScr;}
    inline TSize ScreenSize() const;
	
private:
	CWsCanvas(TInt, const TPoint&);
	void ConstructL();
	
private:
    TInt iScrId;
	TPoint iPos;
	TSize iSz;
	RWsSession iWs;
	RWindowGroup iGrp;
	RWindow iWin;
	CWsScreenDevice* iScr;
	CWindowGc* iGc;
	CWsRedrawHandler* iRedrawHandler;
};

class CWsRedrawHandler: public CActive
{
public:
	CWsRedrawHandler(CWsCanvas&);
	~CWsRedrawHandler();
	
	void RunL();
	void DoCancel();
	
private:
	CWsCanvas& iCanvas;	
};

class CWsApp: public CBase
    {
public:
	static CWsApp* NewL();
	~CWsApp();
	void Start();
	void Stop();

private:
	CWsApp();
    void ConstructL();
    
    CWsCanvas* iAppView;    
	CEGLRendering* iDemo;	
	TBool iCallWindow;	
	
    TPoint iQvgaPos;
    TPoint iQhdPos;
	TBool iQhd;
	TPoint iPos;
	TSize iSz;
	TInt iScrId;
    };

/**
 * 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* c = new(ELeave) CWsCanvas(aScrId, aPos);
	CleanupStack::PushL(c);
	c->ConstructL();
	CleanupStack::Pop(c);

	return c;
	}

CWsCanvas::CWsCanvas(TInt aScrId, const TPoint& aPos):
	iScrId(aScrId), iPos(aPos)
	{
	}

CWsCanvas::~CWsCanvas()
	{
	delete iGc;
	delete iScr;
	iGrp.Close();
	iWin.Close();
	delete iRedrawHandler;
	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.
 */
void CWsCanvas::ConstructL()	
	{
	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();

	iRedrawHandler = new(ELeave) CWsRedrawHandler(*this);
	iWs.SetFocusScreen(iScrId);
	}

void CWsCanvas::DrawNow()
	{
	iWin.Invalidate();
	Redraw();
	}

void CWsCanvas::Redraw()
	{
	iWin.BeginRedraw();
	iGc->Activate(iWin);
	Draw(TRect(TPoint(), iSz));
	iGc->Deactivate();
	iWin.EndRedraw();

	iWs.Flush();
	}

void CWsCanvas::Draw(const TRect& /*aRect*/)
	{
	}

inline TSize CWsCanvas::ScreenSize() const
    {
    return iSz;
    }

CWsRedrawHandler::CWsRedrawHandler(CWsCanvas& aCanvas):
        CActive(CActive::EPriorityStandard),
        iCanvas(aCanvas)
	{
	CActiveScheduler::Add(this);
	
	iStatus = KRequestPending;	
	iCanvas.Session().RedrawReady(&iStatus);
	SetActive();
	}

CWsRedrawHandler::~CWsRedrawHandler()
	{
	Cancel();
	}

void CWsRedrawHandler::RunL()
	{
	TWsRedrawEvent e;
	iCanvas.Session().GetRedraw(e);
	if (e.Handle() == (TInt) &iCanvas)
		{
		iCanvas.Redraw();		
		}

	iStatus = KRequestPending;
	iCanvas.Session().RedrawReady(&iStatus);
	SetActive();
	}

void CWsRedrawHandler::DoCancel()
	{
	iCanvas.Session().RedrawReadyCancel();
	}


CWsApp::CWsApp():
	iQvgaPos(160,60),
	iQhdPos(0,0),
	iQhd(ETrue)
	{
	}

CWsApp* CWsApp::NewL()
	{
	RDebug::Printf("CWsApp::NewL()");
	CWsApp* app = new(ELeave) CWsApp;
	CleanupStack::PushL(app);
	app->ConstructL();
	CleanupStack::Pop(app);
	
	return app;
	}

/**
 * Constructor for CWsApp
 * 
 * @note This constructor looks at the command line argument, if any, supplied when
 * 		 launching the application.  If specified, its used as the screen number to
 * 		 target the output of the program.  By default, screen 0 is used.
 */
void CWsApp::ConstructL()
    {
	RDebug::Printf("CWsApp::ConstructL()");
    iPos = iQhd? iQhdPos : iQvgaPos;

	iScrId = KDefaultScreenNo;
	if (User::CommandLineLength() > 0)
		{
		TBuf<1> arg;
		User::CommandLine(arg);
		iScrId = (TInt)(arg[0]-'0');
		}
	RDebug::Printf("CWsApp::ConstructL() 1");	    
	iAppView = CWsCanvas::NewL(iScrId, iPos);
	RDebug::Printf("CWsApp::ConstructL() 2");	    
	iDemo = CEGLRendering::NewL(iAppView->Window(), iQhd);
	RDebug::Printf("CWsApp::ConstructL() 3");	    
	iDemo->Start();
	RDebug::Printf("CWsApp::ConstructL() 4");	    

	iSz = iAppView->ScreenSize();
	RDebug::Printf("CWsApp::ConstructL() 5");	    

	//Connstruct dialog Box
	// Get a 212x76 pixel box in the centre of the window.
	TRect rcDialog(TRect(iPos, iSz));

#ifdef PORTRAIT_MODE
	rcDialog.Shrink((rcDialog.Width() - 76) / 2, (rcDialog.Height() - 212) / 2);
#else	
	rcDialog.Shrink((rcDialog.Width() - 212) / 2, (rcDialog.Height() - 76) / 2);
#endif

	iCallWindow = EFalse;
	}

void CWsApp::Start()
	{
	RDebug::Printf("CWsApp::Start");
	CActiveScheduler::Start();
	}

void CWsApp::Stop()
	{
	CActiveScheduler::Stop();
	}

CWsApp::~CWsApp()
	{	
	delete iDemo;
	delete iAppView;
	}

/**
 * Application second level entry point.
 * 
 * Launches the application specific class CWsApp and calls Start() on it.
 * 
 * @pre Active scheduler established.
 */
void MainL()
	{
	RDebug::Printf("ebt ::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()
    {
	RDebug::Printf("ebt ::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;
    }