S60 3rd Edition SDK for Symbian OS Example Applications Guide

PickSelectContainer.cpp

/*
* ==============================================================================
*  Name        : PickSelectContainer.cpp
*  Part of     : OpenGLEx / PickSelect
*  Interface   : 
*  Description : 
*  Version     : 
*
*  Copyright (c) 2004-2006 Nokia Corporation.
*  This material, including documentation and any related 
*  computer programs, is protected by copyright controlled by 
*  Nokia Corporation.
* ==============================================================================
*/

// INCLUDE FILES
#include "PickSelectContainer.h"


// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------
// CPickSelectContainer::ConstructL(const TRect& aRect)
// EPOC two phased constructor
// ---------------------------------------------------------
//
void CPickSelectContainer::ConstructL(const TRect& /*aRect*/)
    {
    iOpenGlInitialized = EFalse;

    CreateWindowL();

    SetExtentToWholeScreen();                // Take the whole screen into use
    ActivateL();

    iFrame = 0;                              // Frame counter
    
    EGLConfig Config;                        // Describes the format, type and 
                                             // size of the color buffers and
                                             // ancillary buffers for EGLSurface

    // Get the display for drawing graphics
    iEglDisplay = eglGetDisplay( EGL_DEFAULT_DISPLAY );
    if ( iEglDisplay == NULL )
        {
        _LIT(KGetDisplayFailed, "eglGetDisplay failed");
        User::Panic( KGetDisplayFailed, 0 );
        }
    
    // Initialize display 
    if ( eglInitialize( iEglDisplay, NULL, NULL ) == EGL_FALSE )
        {
        _LIT(KGetDisplayFailed, "eglGetDisplay failed");
        User::Panic( KGetDisplayFailed, 0 );
        }
    
    EGLConfig *configList = NULL;            // Pointer for EGLConfigs
    EGLint numOfConfigs = 0; 
    EGLint configSize   = 0;

    // Get the number of possible EGLConfigs 
    if ( eglGetConfigs( iEglDisplay, configList, configSize, &numOfConfigs ) 
        == EGL_FALSE )
        {
        _LIT(KGetConfigsFailed, "eglGetConfigs failed");
        User::Panic( KGetConfigsFailed, 0 );
        }
    
    configSize = numOfConfigs;

    // Allocate memory for the configList 
    configList = (EGLConfig*) User::Alloc( sizeof(EGLConfig)*configSize );
    if ( configList == NULL )
        {
        _LIT(KConfigAllocFailed, "config alloc failed");
        User::Panic( KConfigAllocFailed, 0 );
        }
    
    /* Define properties for the wanted EGLSurface.
       We need to choose a 32-bit framebuffer, since the picking
       method needs an 8-bit alpha channel.
     */
 
    // Define properties for the wanted EGLSurface 
    const EGLint attrib_list[] = { EGL_BUFFER_SIZE,32,   // 32-bit framebuffer
                                   EGL_DEPTH_SIZE,16,    // 16-bit depthbuffer
                                   EGL_NONE };

    // Choose an EGLConfig that best matches to the properties in attrib_list 
    if ( eglChooseConfig( iEglDisplay, attrib_list, configList, 
                         configSize, &numOfConfigs ) == EGL_FALSE )
        {
        _LIT(KChooseConfigFailed, "eglChooseConfig failed");
        User::Panic( KChooseConfigFailed, 0 );
        }
    
    Config = configList[0];  // Choose the best EGLConfig. EGLConfigs 
                              // returned by eglChooseConfig are sorted so 
                              // that the best matching EGLConfig is first in
                              // the list.
    User::Free( configList ); // Free configList, not used anymore.

    // Create a window where the graphics are blitted 
    iEglSurface = eglCreateWindowSurface( iEglDisplay, Config, &Window(), NULL );
    if ( iEglSurface == NULL )
        {
        _LIT(KCreateWindowSurfaceFailed, "eglCreateWindowSurface failed");
        User::Panic( KCreateWindowSurfaceFailed, 0 );
        }
    
    // Create a rendering context 
    iEglContext = eglCreateContext( iEglDisplay, Config, EGL_NO_CONTEXT, NULL );
    if ( iEglContext == NULL )
        {
        _LIT(KCreateContextFailed, "eglCreateContext failed");
        User::Panic( KCreateContextFailed, 0 );
        }
    
    /* Make the context current. Binds context to the current rendering thread
       and surface.*/
    if ( eglMakeCurrent( iEglDisplay, iEglSurface, iEglSurface, iEglContext ) 
        == EGL_FALSE )
        {
        _LIT(KMakeCurrentFailed, "eglMakeCurrent failed");
        User::Panic( KMakeCurrentFailed, 0 );
        }
    
    TSize size;
    size = this->Size();

    iPickSelect = CPickSelect::NewL( size.iWidth, size.iHeight ); // Create an instance of PickSelect
    iPickSelect->AppInit();                                // Initialize OpenGL ES

    iOpenGlInitialized = ETrue;
    
    iPeriodic = CPeriodic::NewL( CActive::EPriorityIdle ); // Create an active object for
                                                           // animating the scene
    iPeriodic->Start( 100, 100, 
                      TCallBack( CPickSelectContainer::DrawCallBack, this ) );
}

// Destructor
CPickSelectContainer::~CPickSelectContainer()
    {
    delete iPeriodic;

    if ( iPickSelect )
        {
        /* AppExit call is made to release 
           any allocations made in AppInit. */
        iPickSelect->AppExit();
        delete iPickSelect;
        }
    
    eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
    eglDestroySurface( iEglDisplay, iEglSurface ); 
    eglDestroyContext( iEglDisplay, iEglContext );
    eglTerminate( iEglDisplay );                   // Release resources associated
                                                   // with EGL and OpenGL ES
    }

// ---------------------------------------------------------
// CPickSelectContainer::SizeChanged
// Called by framework when the view size is changed
// ---------------------------------------------------------
//
void CPickSelectContainer::SizeChanged()
    {
    if( iOpenGlInitialized && iPickSelect )
        {
        TSize size;
        size = this->Size();
        
        iPickSelect->SetScreenSize( size.iWidth, size.iHeight );
        }
    }


// ---------------------------------------------------------
// CPickSelectContainer::HandleResourceChange(
//     TInt aType)
// Dynamic screen resize changes by calling the
// SetExtentToWholeScreen() method again.
// ---------------------------------------------------------
//
 void CPickSelectContainer::HandleResourceChange(TInt aType)
    {
        switch( aType )
        {
            case KEikDynamicLayoutVariantSwitch:
                    SetExtentToWholeScreen();
                    break;
            }
    }

// ---------------------------------------------------------
// CPickSelectContainer::CountComponentControls
// ---------------------------------------------------------
//
TInt CPickSelectContainer::CountComponentControls() const
    {
    return 0;
    }

// ---------------------------------------------------------
// CPickSelectContainer::ComponentControl
// ---------------------------------------------------------
//
CCoeControl* CPickSelectContainer::ComponentControl(TInt /*aIndex*/ ) const
    {
    return NULL;
    }

// ---------------------------------------------------------
// CPickSelectContainer::Draw
// ---------------------------------------------------------
//
void CPickSelectContainer::Draw(const TRect& /*aRect*/ ) const
    {
    CWindowGc& gc = SystemGc();
    gc.Clear( Rect() );
    }

// ---------------------------------------------------------
// CPickSelectContainer::DrawCallBack
// Called by the CPeriodic in order to draw the graphics 
// ---------------------------------------------------------
//
TInt CPickSelectContainer::DrawCallBack( TAny* aInstance )
    {
    CPickSelectContainer* instance = (CPickSelectContainer*) aInstance;
    instance->iFrame++;
    
    // Call the main OpenGL ES Symbian rendering 'loop' 
    instance->iPickSelect->AppCycle( instance->iFrame );
    
    // Call eglSwapBuffers, which blit the graphics to the window 
    eglSwapBuffers( instance->iEglDisplay, instance->iEglSurface );

    // To keep the background light on 
    if ( !(instance->iFrame%100) )
        {
        User::ResetInactivityTime();
        }
    
    /* Suspend the current thread for a short while. Give some time 
       to other threads and AOs, avoids the ViewSrv error in ARMI and
       THUMB release builds. One may try to decrease the callback 
       function instead of this. */ 
    if ( !(instance->iFrame%50) ) 
        {
        User::After(0);
        }
    
    return 0;
    }

// ---------------------------------------------------------
// CPickSelectContainer::HandleControlEventL
// ---------------------------------------------------------
//
void CPickSelectContainer::HandleControlEventL(
    CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)
    {
    }

// End of File  

---

© Nokia 2006