examples/SFExamples/SkeletonS60/src/SkeletonAppView.cpp

// 
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:  Application view implementation
// 
// 


// INCLUDE FILES
#include <coemain.h>
#include "SkeletonAppView.h"

const TInt KOneSecondInMicroSeconds = 1000000;
const TInt KFramesPerSecond = KOneSecondInMicroSeconds/30; // 30 fps
const TTimeIntervalSeconds KInactivityTimeout = 10; // 10 seconds user inactivity timeout

// Key identifiers
const TUint KControllerUp       = 0x00000001;
const TUint KControllerDown     = 0x00000002;
const TUint KControllerRight    = 0x00000004;
const TUint KControllerLeft     = 0x00000008;
const TUint KControllerCentre   = 0x00000010;
const TUint KKey0                       = 0x00000020;
const TUint KKey1                       = 0x00000040;
const TUint KKey2                       = 0x00000080;
const TUint KKey3                       = 0x00000100;
const TUint KKey4                       = 0x00000200;
const TUint KKey5                       = 0x00000400;
const TUint KKey6                       = 0x00000800;
const TUint KKey7                       = 0x00001000;
const TUint KKey8                       = 0x00002000;
const TUint KKey9                       = 0x00004000;

_LIT(K1, "1");
_LIT(K2, "2");
_LIT(K3, "3");
_LIT(K4, "4");
_LIT(K5, "5");
_LIT(K6, "6");
_LIT(K7, "7");
_LIT(K8, "8");
_LIT(K9, "9");
_LIT(K0, "0");

_LIT(KUp, "U");
_LIT(KDown, "D");
_LIT(KLeft, "L");
_LIT(KRight, "R");
_LIT(KCentre, "*");
_LIT(KFired, "Fired!");

class CInactivityTimer : public CTimer
        {
public:
        static CInactivityTimer* NewL(CSkeletonAppView& aAppView);
        void StartInactivityMonitor(TTimeIntervalSeconds aSeconds);
protected:
        CInactivityTimer(CSkeletonAppView& aAppView);
        virtual void RunL();
private:
        CSkeletonAppView& iAppView;
        TTimeIntervalSeconds iTimeout;
        };
        
CInactivityTimer::CInactivityTimer(CSkeletonAppView& aAppView)
: CTimer(EPriorityLow), iAppView(aAppView)
        {
        CActiveScheduler::Add(this);
        }

CInactivityTimer* CInactivityTimer::NewL(CSkeletonAppView& aAppView)
        {
        CInactivityTimer* me = new (ELeave) CInactivityTimer(aAppView);
        CleanupStack::PushL(me);
        me->ConstructL();
        CleanupStack::Pop(me);
        return (me);
        }

void CInactivityTimer::StartInactivityMonitor(TTimeIntervalSeconds aSeconds)
        {
        if (!IsActive())
                {
                iTimeout = aSeconds;
                Inactivity(iTimeout);
                }
        }

void CInactivityTimer::RunL()
        {// Game has been inactive - no user input for iTimeout seconds
        iAppView.SetPausedDisplay(ETrue); // Displays the pause screen
        iAppView.StopHeartbeat(); // Stops the game loop
        }

// -----------------------------------------------------------------------------
// CSkeletonAppView::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSkeletonAppView* CSkeletonAppView::NewL( const TRect& aRect )
        {
        CSkeletonAppView* self = CSkeletonAppView::NewLC( aRect );
        CleanupStack::Pop( self );
        return self;
        }

// -----------------------------------------------------------------------------
// CSkeletonAppView::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSkeletonAppView* CSkeletonAppView::NewLC( const TRect& aRect )
        {
        CSkeletonAppView* self = new ( ELeave ) CSkeletonAppView;
        CleanupStack::PushL( self );
        self->ConstructL( aRect );
        return self;
        }

// -----------------------------------------------------------------------------
// CSkeletonAppView::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSkeletonAppView::ConstructL( const TRect& aRect )
        {
        // Create a window for this application view
        CreateWindowL();

        // Set the windows size
        SetRect( aRect );
        
        // Creates timer for game loop.
        iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard);
        iInactivity = CInactivityTimer::NewL(*this);

        // Activate the window, which makes it ready to be drawn and starts the heartbeat
        ActivateL();
        
        iStart.HomeTime();
        }

void CSkeletonAppView::StartHeartbeat()
        {
        SetPausedDisplay(EFalse);
        
        if (!iPeriodicTimer->IsActive())
                iPeriodicTimer->Start(KFramesPerSecond, KFramesPerSecond, TCallBack(CSkeletonAppView::Tick, this));             
                
        iInactivity->StartInactivityMonitor(KInactivityTimeout); // Notify if inactive for 30 seconds   
        }

void CSkeletonAppView::StopHeartbeat()
        {
        iPeriodicTimer->Cancel();
        }


void CSkeletonAppView::SetPausedDisplay(TBool aPaused) 
        {
        iPauseDisplay = aPaused;
        DrawNow();
        }
// -----------------------------------------------------------------------------
// CSkeletonAppView::CSkeletonAppView()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CSkeletonAppView::CSkeletonAppView()
        {
        // No implementation required
        }


// -----------------------------------------------------------------------------
// CSkeletonAppView::~CSkeletonAppView()
// Destructor.
// -----------------------------------------------------------------------------
CSkeletonAppView::~CSkeletonAppView()
        {
        StopHeartbeat();
        delete iPeriodicTimer;
        
        iInactivity->Cancel();
        delete iInactivity;
        }

// --------------------------------------------------------------------------
// FocusChanged
// --------------------------------------------------------------------------
void CSkeletonAppView::FocusChanged(TDrawNow aDrawNow)
        {
        if (IsFocused())
                {// Focus gained
                StartHeartbeat();
                }
        else
                {// Focus lost
                if (iPeriodicTimer->IsActive())
                        {
                        StopHeartbeat();
                        }
                //      Save game data here if necessary
                }
        
        if(aDrawNow)
                DrawNow();
        }

// --------------------------------------------------------------------------
// Tick(TAny *aPtr)
// --------------------------------------------------------------------------
TInt CSkeletonAppView::Tick(TAny* aCallback)
        {
        ASSERT(aCallback);
        static_cast<CSkeletonAppView*>(aCallback)->GameLoop();

        // Returning a value of ETrue indicates the callback should be done again.
        return ETrue;
        }

// --------------------------------------------------------------------------
// GameLoop()
// --------------------------------------------------------------------------
void CSkeletonAppView::GameLoop()
        {
        // Update frame measurement.
        iStop.HomeTime();
        iDuration = iStop.Int64() - iStart.Int64();
        ++iFrames;

        if(iDuration >= KOneSecondInMicroSeconds) // if Duration exceeds one second
                { 
                _LIT(KFramesPerSecond, "%d fps");
                iFpsMessage.Format(KFramesPerSecond, iFrames);
                iFrames = 0;
                iStart = iStop;
                }
        
                DrawNow();
                
        if (iFired)
                {// Centre key was pressed, or is held down and firing events are occurring repeatedly
                //  Peform action on firing, e.g. play a sound, flash the screen, here, print to debug for illustration
                RDebug::Print(KFired);
                iFired = EFalse;
                }
        }

TKeyResponse CSkeletonAppView::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)
        {
        TKeyResponse response = EKeyWasConsumed;
        TUint input = 0x00000000;

        switch (aKeyEvent.iScanCode)
                {
                case EStdKeyUpArrow:    
                        input = KControllerUp;
                        break;
                case EStdKeyDownArrow: 
                        input = KControllerDown;
                        break;
                case EStdKeyLeftArrow: 
                        input = KControllerLeft;
                        break;
                case EStdKeyRightArrow: 
                        input = KControllerRight;
                        break;
                case EStdKeyDevice3:  // This is the "firing" key
                        input = KControllerCentre;
                        if (EEventKey == aType)
                                {
                                iFired = ETrue;
                                }
                        break;
                case '0': 
                        input = KKey0;
                        break;
                case '1': 
                        input = KKey1;
                        break;
                case '2': 
                        input = KKey2;
                        break;
                case '3': 
                        input = KKey3;
                        break;
                case '4': 
                        input = KKey4;
                        break;
                case '5': 
                        input = KKey5;
                        break;
                case '6': 
                        input = KKey6;
                        break;
                case '7': 
                        input = KKey7;
                        break;
                case '8': 
                        input = KKey8;
                        break;
                case '9': 
                        input = KKey9;
                        break;

                default:
                        response = EKeyWasNotConsumed;// Keypress was not handled
                        break;
                }
        
        if (EEventKeyDown == aType)
                {
                iKeyState |= input; // set bitmask
                }
        else if (EEventKeyUp == aType)
                {
                iKeyState &= ~input; // clear bitmask
                }
        
    return (response);
        }

// -----------------------------------------------------------------------------
// CSkeletonAppView::Draw()
// Draws the display.
// -----------------------------------------------------------------------------
//
void CSkeletonAppView::Draw( const TRect& /*aRect*/ ) const
        {
        // Get the standard graphics context
        CWindowGc& gc = SystemGc();

        gc.SetPenStyle(CGraphicsContext::ENullPen);     
        gc.UseFont(iCoeEnv->NormalFont());
        gc.SetPenColor(KRgbGray);
        
        // Gets the control's extent
        TRect drawRect( Rect());        
        TInt width = drawRect.Width();
        TInt height = drawRect.Height();
        
        gc.Clear( drawRect );
        
        if (!iPauseDisplay)
                {               
                gc.DrawText(iFpsMessage, TPoint(0, 20));
                
                gc.DrawText(KUp, TPoint(width/2, height/8));
                gc.DrawText(KLeft, TPoint(width/4, height/4));
                gc.DrawText(KCentre, TPoint(width/2, height/4));
                gc.DrawText(KRight, TPoint(3*width/4, height/4));
                gc.DrawText(KDown, TPoint(width/2, 3*height/8));
                
                gc.DrawText(K1, TPoint(width/4, height/2));
                gc.DrawText(K2, TPoint(width/2, height/2));
                gc.DrawText(K3, TPoint(3*width/4, height/2));
                gc.DrawText(K4, TPoint(width/4, 5*height/8));
                gc.DrawText(K5, TPoint(width/2, 5*height/8));
                gc.DrawText(K6, TPoint(3*width/4, 5*height/8));
                gc.DrawText(K7, TPoint(width/4, 3*height/4));
                gc.DrawText(K8, TPoint(width/2, 3*height/4));
                gc.DrawText(K9, TPoint(3*width/4, 3*height/4));
                gc.DrawText(K0, TPoint(width/2, 7*height/8));
                
                
                gc.SetPenColor(KRgbRed);
                
                if (iKeyState & KControllerUp)
                        gc.DrawText(KUp, TPoint(width/2, height/8));
                
                if (iKeyState & KControllerLeft)
                        gc.DrawText(KLeft, TPoint(width/4, height/4));
                
                if (iKeyState & KControllerCentre)
                                gc.DrawText(KCentre, TPoint(width/2, height/4));
                
                if (iKeyState & KControllerRight)
                        gc.DrawText(KRight, TPoint(3*width/4, height/4));
                
                if (iKeyState & KControllerDown)
                        gc.DrawText(KDown, TPoint(width/2, 3*height/8));
                
                if (iKeyState & KKey1)
                        gc.DrawText(K1, TPoint(width/4, height/2));
                
                if (iKeyState & KKey2)
                        gc.DrawText(K2, TPoint(width/2, height/2));
                
                if (iKeyState & KKey3)
                        gc.DrawText(K3, TPoint(3*width/4, height/2));
                
                if (iKeyState & KKey4)
                        gc.DrawText(K4, TPoint(width/4, 5*height/8));
                
                if (iKeyState & KKey5)
                        gc.DrawText(K5, TPoint(width/2, 5*height/8));
        
                if (iKeyState & KKey6)
                        gc.DrawText(K6, TPoint(3*width/4, 5*height/8));
                
                if (iKeyState & KKey7)
                        gc.DrawText(K7, TPoint(width/4, 3*height/4));
                
                if (iKeyState & KKey8)
                        gc.DrawText(K8, TPoint(width/2, 3*height/4));
                
                if (iKeyState & KKey9)
                        gc.DrawText(K9, TPoint(3*width/4, 3*height/4));
                
                if (iKeyState & KKey0)
                        gc.DrawText(K0, TPoint(width/2, 7*height/8));
                }
        else
                {//Game is paused
                _LIT(KPaused, "G A M E  P A U S E D");
                gc.DrawText(KPaused, TPoint(10, height/2));
                
                }
        }

// -----------------------------------------------------------------------------
// CSkeletonAppView::SizeChanged()
// Called by framework when the view size is changed.
// -----------------------------------------------------------------------------
//
void CSkeletonAppView::SizeChanged()
        {  
        DrawNow();
        }
// End of File

---