diff -r 790dbf92bc7e -r bbf967b65d9e egl/sfegltest/src/main.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/egl/sfegltest/src/main.cpp Thu Sep 30 18:43:06 2010 +0100 @@ -0,0 +1,351 @@ +// 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 +#include +#include +#include +#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; + }