/*

* Copyright (c) 2007-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:  Side Pane control*

*/

// INCLUDE FILES

#include <aknview.h>

#include <eikenv.h>

#include <eikappui.h>   // For CCoeAppUiBase

#include <eikapp.h>     // For CEikApplication

#include <barsc.h>

#include <barsread.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include "CamAppUiBase.h"

#include "CamAppUi.h"

#include "CamAppController.h"

#include "CamSidePane.h"

#include "CamIndicator.h"

#include "CamIndicatorData.h"

#include "CamIndicatorResourceReader.h"

#include "CamTimer.h"

#include "CamSelfTimer.h"

#include "CamLogger.h"

#include "CamSettings.hrh"

#include "CamUtility.h"

#include "CameraUiConfigManager.h"

#include "Cam.hrh"

// CONSTANTS

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

// ---------------------------------------------------------------------------

// CCamSidePane::NewL

// Symbian OS two-phased constructor

// ---------------------------------------------------------------------------

//

CCamSidePane* CCamSidePane::NewL( CCamAppController& aController,

                                  TBool aOverlayViewFinder )

    {

    CCamSidePane* self = new( ELeave ) CCamSidePane( aController, 

                                                     aOverlayViewFinder );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

// Destructor

CCamSidePane::~CCamSidePane()

  {

  PRINT( _L("Camera => ~CCamSidePane") );

  RemoveObservers();

  CCamSidePane::UnloadResourceData();

  PRINT( _L("Camera <= ~CCamSidePane") );

  }

// ---------------------------------------------------------

// CCamSidePane::ConstructL

// Symbian OS 2nd phase constructor

// ---------------------------------------------------------

//

void CCamSidePane::ConstructL()

    {

    LoadResourceDataL();

    // side pane is a controller, self timer and burst mode observer

    RegisterObserversL();

    iVisible = ETrue;

    UpdateLayout();

    }

// -----------------------------------------------------------------------------

// CCamSidePane::LoadResourceDataL()

// Reads in all information needed from resources

// -----------------------------------------------------------------------------

//

void CCamSidePane::LoadResourceDataL()

    {

    TResourceReader reader;                                                                                     

    CEikonEnv* eikEnv = CEikonEnv::Static();

    eikEnv->CreateResourceReaderLC( reader, ROID(R_CAM_SIDEPANE_ID));

    // create reader

    CCamIndicatorResourceReader* resourceReader = 

        CCamIndicatorResourceReader::NewLC( reader );

    // get indicator data from reader   

    CArrayPtrFlat<CCamIndicatorData>& indArray = resourceReader->IndicatorData();

    // set up indicator data

    TInt numindicators = indArray.Count(); // number of indicators

    TInt numbitmaps = 0;

    CCamIndicator* indicator = NULL;

    TInt i = 0;

    for ( i = 0; i < ECamIndicatorTotal; i++ )

        {

        User::LeaveIfError( iIndicators.Append( static_cast<CCamIndicator*>(NULL) ) );

        }

    for ( i = 0; i < numindicators; i++ )

        {

        CCamIndicatorData& indData = *( indArray.At( i ) );

        indicator = CCamIndicator::NewL( indData.IndicatorRect() );

        CleanupStack::PushL( indicator );

        numbitmaps = indData.IndicatorBitmapCount(); // no of bitmaps for indicator

        TInt j;

        for ( j = 0; j < numbitmaps; j++ )

            {

            // side pane assumes that mask bitmap is defined after the

            // normal one in the resource file

            indicator->AddIconL( indData.IndicatorBitmapId( j ), // bitmap

                                 indData.IndicatorBitmapId( j + 1 )); // mask

            j++; // increment past the mask

            }

        iIndicators[indData.IndicatorId()] = indicator;

        CleanupStack::Pop( indicator );

        }

    CleanupStack::PopAndDestroy( resourceReader );

    CleanupStack::PopAndDestroy(); // reader

    }

// -----------------------------------------------------------------------------

// CCamSidePane::ReloadResourceDataL()

// Refreshes all resource-based information stored in the class

// -----------------------------------------------------------------------------

//

void CCamSidePane::ReloadResourceDataL()

    {

    UnloadResourceData();

    LoadResourceDataL();

    }

// -----------------------------------------------------------------------------

// CCamSidePane::UnloadResourceData()

// Frees all dynamic resources allocated in LoadResourceDataL

// -----------------------------------------------------------------------------

//

void CCamSidePane::UnloadResourceData()

    {

    iIndicators.ResetAndDestroy();

    iIndicators.Close();

    }

// ---------------------------------------------------------------------------

// CCamSidePane::CCamSidePane

// C++ constructor

// ---------------------------------------------------------------------------

//

CCamSidePane::CCamSidePane( CCamAppController& aController, 

                            TBool aOverlayViewFinder )

:   iController( aController ), 

    iOverlayViewFinder( aOverlayViewFinder )

    {

    }

// ---------------------------------------------------------

// CCamSidePane::HandleControllerEventL

// Handle an event from CCamAppController.

// ---------------------------------------------------------

//

void CCamSidePane::HandleControllerEventL(

    TCamControllerEvent aEvent, TInt /* aError */ )

    {

    switch ( aEvent )

        {        

        case ECamEventFlashStateChanged:

            {

            if ( iIndicators[ECamIndicatorFlash]

                && iMode != ECamControllerVideo 

                && !IsSecondaryCameraEnabled() 

                )

                {

                TCamFlashId flash = static_cast< TCamFlashId > 

                    ( iController.IntegerSettingValue( ECamSettingItemDynamicPhotoFlash ) );

                switch ( flash )

                    {

                    case ECamFlashAuto:

                        {

                        iIndicators[ECamIndicatorFlash]->SetIcon( 0 );

                        }

                        break;

                    case ECamFlashOff:

                        {

                        iIndicators[ECamIndicatorFlash]->SetIcon( 2 );

                        }

                        break;

                    case ECamFlashAntiRedEye:

                        {

                        iIndicators[ECamIndicatorFlash]->SetIcon( 4 );

                        }

                        break;

                    case ECamFlashForced:

                        {

                        iIndicators[ECamIndicatorFlash]->SetIcon( 6 );

                        }

                        break;

                    default:

                        break;

                    }

                iIndicators[ECamIndicatorFlash]->SetFlashing( EFalse );

                }

            else

                {

                // empty statement to remove Lint error.

                }

            if ( iController.UiConfigManagerPtr()->IsVideoLightSupported() )

                {

                if ( iIndicators[ECamIndicatorVideoFlash]

                    && iMode == ECamControllerVideo 

                    && !IsSecondaryCameraEnabled() 

                    )

                    {

                    TCamFlashId flash = static_cast< TCamFlashId > 

                        ( iController.IntegerSettingValue( ECamSettingItemDynamicVideoFlash ) );

                    switch ( flash )

                        {

                        case ECamFlashOff:

                            {

                            iIndicators[ECamIndicatorVideoFlash]->SetIcon( 0 );

                            }

                            break;

                        case ECamFlashForced:

                            {

                            iIndicators[ECamIndicatorVideoFlash]->SetIcon( 2 );

                            }

                            break;

                        default:

                            break;

                        }

                    iIndicators[ECamIndicatorVideoFlash]->SetFlashing( EFalse );

                    }

                else

                    {

                    // empty statement to remove Lint error.

                    }

                }

            } // end case statement

            break;

        case ECamEventSceneStateChanged:

            {

            if ( iMode == ECamControllerVideo )

                {

                SetVideoSceneIndicator();

                }

            else

                {

                SetPhotoSceneIndicator();

                }

            }

            break;          

        case ECamEventCameraChanged:

            {

            if ( !IsSecondaryCameraEnabled() )

                {

                if ( iMode == ECamControllerVideo )

                    {

                    SetVideoSceneIndicator();

                    if ( !iController.UiConfigManagerPtr()->IsVideoLightSupported() )

                        {

                        if ( iIndicators[ECamIndicatorFlash] )

                            {

                            iIndicators[ECamIndicatorFlash]->ClearIcon();

                            }                        

                        }

                    }

                else

                    {

                    SetPhotoSceneIndicator();

                    if ( !iController.UiConfigManagerPtr()->IsVideoLightSupported() )

                        {

                        if ( iIndicators[ECamIndicatorFlash] )

                            {

                            iIndicators[ECamIndicatorFlash]->DisplayIcon();

                            }                        

                        }

                    }

                }

            }

            break;

#ifdef PRODUCT_USES_GENERIC_SETUP_INDICATOR

#ifndef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR

        case ECamEventSetupStateChanged:

            {

            SetGenericSetupIndicator();

            }

            break;

#endif // !PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR

#endif // PRODUCT_USES_GENERIC_SETUP_INDICATOR

        case ECamEventVideoStabChanged:

            {

            if ( iController.UiConfigManagerPtr()->IsVideoStabilizationSupported() )

                {

                SetVideoStabilisationIndicator();                

                }

            break;

            }

        case ECamEventFaceTrackingStateChanged:

            {

            if ( iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )

                {

                SetFaceTrackingIndicator();

                }

            break;

            }

        default:

            break;

        }

    }

// -----------------------------------------------------------------------------

// CCamSidePane::IsVisible

// Is the side pane invisible

// -----------------------------------------------------------------------------

//

TBool CCamSidePane::IsVisible()

    {

    return iVisible;

    }

// -----------------------------------------------------------------------------

// CCamSidePane::MakeVisible

// Makes the side pane visible

// -----------------------------------------------------------------------------

//

void CCamSidePane::MakeVisible( TBool aVisible )

    {

    iVisible = aVisible;

    }

// ----------------------------------------------------

// CCamSidePane::Draw

// Draws side pane indicators

// ----------------------------------------------------

//

void CCamSidePane::Draw( CBitmapContext& aGc ) const

    {

    // if not overlaying the viewfinder then

    // just clear the side pane area

    if ( !iOverlayViewFinder )

        {

        aGc.Clear( iRect );

        }

    TInt numIndicators = iIndicators.Count();

    TInt i;

    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

    if ( appUi )

        {

        appUi->DrawPreCaptureCourtesyUI();

        }

    for ( i = 0; i < numIndicators; i++ )

        {

        if ( iIndicators[i] )

            {

            iIndicators[i]->Draw( aGc );

            }

        }

    }

// ----------------------------------------------------

// CCamSidePane::SetRect

// Sets rect to draw into

// ----------------------------------------------------

//

void 

CCamSidePane::SetRect( TRect& aRect ) 

  {

  iRect.SetRect( aRect.iTl, aRect.iBr );

  }

// ----------------------------------------------------

// CCamSidePane::SetCaptureMode

// Sets rect to draw into

// ----------------------------------------------------

//

void 

CCamSidePane::SetCaptureMode( TCamCameraMode aMode )

  {

  iMode = aMode;

  SetInitialState();

  }

// ----------------------------------------------------

// CCamSidePane::SetInitialState

// Notification that the burst mode has been activated/deactivated

// ----------------------------------------------------

//

void CCamSidePane::SetInitialState()

  {

  CCamAppUiBase* appUi = 

      static_cast<CCamAppUiBase*>( CEikonEnv::Static()->AppUi() );

  // set up indicator data

  TInt numindicators = iIndicators.Count(); // number of indicators

  // set initial state for each indicator

  for ( TInt i = 0; i < numindicators; i++ )

    {

    if ( iIndicators[i] )

      {

      switch( i )

        {

        // -------------------------------------------------

        // Scene indicator

        case ECamIndicatorScene:

          {

          if( ECamControllerVideo == iMode )

            SetVideoSceneIndicator();

          else

            SetPhotoSceneIndicator();

          break;

          }

        // -------------------------------------------------

        // Flash indicator

        case ECamIndicatorFlash:

          {

          // don't show the icon if in video mode or the second 

          // camera is active

          // second camera doesn't support flash

          if ( ECamControllerVideo == iMode 

            || IsSecondaryCameraEnabled() 

             )

            {

            iIndicators[ECamIndicatorFlash]->ClearIcon();

            }

          else

            {

            TInt iconIndex = GetFlashIconIndex( iMode );

            if( KErrNotFound != iconIndex )

              {

              iIndicators[ECamIndicatorFlash]->SetIcon( iconIndex );

              }

            }

          break;

          }

        // -------------------------------------------------

        // Video Flash indicator

        case ECamIndicatorVideoFlash:

          {

          // don't show the icon if in video mode or the second 

          // camera is active

          // second camera doesn't support flash

          if ( iController.UiConfigManagerPtr()->IsVideoLightSupported()  )

              {

              if ( ECamControllerVideo != iMode 

                || IsSecondaryCameraEnabled() 

                 )

                {

                iIndicators[ECamIndicatorVideoFlash]->ClearIcon();

                }

              else

                {

                TInt iconIndex = GetFlashIconIndex( iMode );

                if( KErrNotFound != iconIndex )

                  {

                  iIndicators[ECamIndicatorVideoFlash]->SetIcon( iconIndex );

                  }

                }              

              }

          break;

          }

        // -------------------------------------------------

        // Burst mode indicator

        case ECamIndicatorBurstMode:

          {

          if ( appUi && appUi->IsBurstEnabled() )

            {

            iIndicators[ECamIndicatorBurstMode]->SetIcon( 0 );

            }

          else

            {

            iIndicators[ECamIndicatorBurstMode]->ClearIcon();

            }

          break;

          }

        // -------------------------------------------------

        // Self timer indicator

        case ECamIndicatorSelfTimer:

          {

          iIndicators[ECamIndicatorSelfTimer]->ClearIcon();

          break;

          }            

        // -------------------------------------------------

        case ECamIndicatorVideoStabiliser:

          {

          if ( iController.UiConfigManagerPtr()->IsVideoStabilizationSupported() )

              {

              SetVideoStabilisationIndicator();              

              }

          else

              {

              iIndicators[ECamIndicatorVideoStabiliser]->ClearIcon(); 

              }