/*

* 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:  Container class for still image pre-capture view*

*/

// INCLUDE FILES

#include <AknIconUtils.h>

#include <cameraapp.mbg>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <akntoolbar.h>

#include <aknlayoutscalable_apps.cdl.h>

#include "CamStillPreCaptureContainer.h"

#include "CamLogger.h"

#include "CamPreCaptureViewBase.h"

#include "CamAppUi.h"

#include "CamSidePane.h"

#include "CamSelfTimer.h"

#include "CamUtility.h"

#include "camactivepalettehandler.h"

#include "CameraUiConfigManager.h"

#include "OstTraceDefinitions.h"

#include "CamIndicator.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamStillPreCaptureContainerTraces.h"

#endif

#include "camvfgridinterface.h"

#include "camlinevfgriddrawer.h"

#include "campanic.h"

// Constants

const TUid KGridDrawerUid = { KCamLineDrawVfGridUid };

const TInt KGridHrzLines  = 2;

const TInt KGridVrtLines  = 2;

const TInt KGridThickness = 2;

const TRgb KGridColor     = KRgbGray;

const CGraphicsContext::TPenStyle KGridStyle = CGraphicsContext::ESolidPen;

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

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

// CCamStillPreCaptureContainer::NewL

// Symbian OS two-phased constructor

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

//

CCamStillPreCaptureContainer* CCamStillPreCaptureContainer::NewL(

        CCamAppController& aController,

        CAknView& aView,

        const TRect& aRect )

    {

    CCamStillPreCaptureContainer* self = new( ELeave ) CCamStillPreCaptureContainer(

        aController, aView );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    // Return newly created CCamStillPreCaptureContainer instance

    return self;

    }

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

// CCamStillPreCaptureContainer::~CCamStillPreCaptureContainer

// Destructor

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

//

CCamStillPreCaptureContainer::~CCamStillPreCaptureContainer()

  {

  PRINT( _L("Camera => ~CCamStillPreCaptureContainer" ))

  if ( iAPCreateAO )

      {

      iAPCreateAO->Cancel();

      delete iAPCreateAO;

      }

  if ( iXenonFlashSupported )

      {

      // Unsubscribe blink events

      if( CCamFlashStatus* flashStatus = iController.FlashStatus() )

        flashStatus->Subscribe( NULL );

      delete iFlashBitmap;

      delete iFlashBitmapMask;

      }

  PRINT( _L("Camera <= ~CCamStillPreCaptureContainer" ))

  }

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

// CCamStillPreCaptureContainer::ConstructL

// Symbian OS 2nd phase constructor

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

//

void CCamStillPreCaptureContainer::ConstructL( const TRect& aRect )

  {

  PRINT( _L("Camera => CCamStillPreCaptureContainer::ConstructL" ))

  BaseConstructL( aRect );

  if ( iController.UiConfigManagerPtr() &&

       iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

      {

      iAPCreateAO = CIdle::NewL(CActive::EPriorityStandard);

      }

  if ( iController.UiConfigManagerPtr() &&

       iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

      {

      if( iController.IntegerSettingValue( ECamSettingItemPhotoShowFocusPoint ) )

        {

        iShowReticule = EFalse;

        }

      else

        {

        iShowReticule = ETrue;

        }

    }

  iSidePane->SetCaptureMode( ECamControllerImage );

  iXenonFlashSupported = iController.UiConfigManagerPtr()->IsXenonFlashSupported();

  if ( iXenonFlashSupported )

      {

      InitFlashIconL();

      LayoutFlashIcon();

      }

  PrepareProcessingTextL( ETrue );

  if ( !( iController.UiConfigManagerPtr() &&

       iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) )

      {

      OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTURECONTAINER_CONSTRUCTL, "e_CAM_APP_AP_SETUP 1" );

      static_cast<CCamPreCaptureContainerBase*>( this )

          ->SetupActivePaletteL( static_cast<CCamViewBase*>(&iView) );

      OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTURECONTAINER_CONSTRUCTL, "e_CAM_APP_AP_SETUP 0" );

      }

  PRINT( _L("Camera <= CCamStillPreCaptureContainer::ConstructL" ))

  }

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

// CCamContainerBase::BaseConstructL

// Symbian OS 2nd phase constructor

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

//

void CCamStillPreCaptureContainer::BaseConstructL( const TRect& aRect )

    {

    CCamPreCaptureContainerBase::BaseConstructL( aRect );

    // Layout the reticule.

    if ( iController.UiConfigManagerPtr() &&

         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

        {

        SizeChanged(); // Init layout

        }

    }

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

// CCamStillPreCaptureContainer::CCamStillPreCaptureContainer

// C++ constructor

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

//

CCamStillPreCaptureContainer::CCamStillPreCaptureContainer(

        CCamAppController& aController,

        CAknView& aView )

: CCamPreCaptureContainerBase( aController, aView )

    {

    }

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

// CCamStillPreCaptureContainer::HandleControllerEventL

// Receives notifications about changes in recording state from the controller

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

//

void CCamStillPreCaptureContainer::HandleControllerEventL( TCamControllerEvent aEvent, TInt aError )

  {

  PRINT1( _L("Camera => CCamStillPreCaptureContainer::HandleControllerEventL aEvent:%d" ), aEvent )

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

  switch( aEvent )

    {

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

  	case ECamEventImageQualityChanged:

      {

      PRINT( _L("Camera <> CCamStillPreCaptureContainer - ECamEventImageQualityChanged") );

      // If our viewfinder area is already set and image quality changes,

      // do re-layout.

      if( !iRect.IsEmpty() )

        {

        const TRect r( ViewFinderFrameRect() );

        if( iRect != r )

          {

          PRINT( _L("Camera <> CCamStillPreCaptureContainer - doing re-layout..") );

          iRect = r;

          SizeChanged();

          }

        }

      SetResolutionIndicator();

      break;

      }

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

  	case ECamEventLocationSettingChanged:

      {

      // If the location setting was changed on, then the indicator should be visible

      SetLocationIndicatorVisibility();

      break;

      }

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

  	case ECamEventCameraChanged:

      {

      break;

      }

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

  	case ECamEventOperationStateChanged:

  	  {

      if( ECamCapturing == iController.CurrentOperation() )

        {

        // If capture has just begun, and it's burst capture,

        // will need to set the softkeys to Blank/Cancel (via UpdateCbaL call)

        if ( appUi->IsBurstEnabled() )

            {

            // Burst *is* enabled, so force the update of the CBA

            static_cast<CCamViewBase&>(iView).UpdateCbaL();

            }

        else // if burst is not enabled show the saving image wait note

       	    {

			Window().Invalidate();

       	    }

        }

      else

       	{

       	}

      break;

  	  }

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

    case ECamEventSetupStateChanged:

      {

      appUi->APHandler()->UpdateActivePaletteL();

      break;

      }

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

    case ECamEventEngineStateChanged:

        {

        if( iController.CurrentImageModeSetup() == ECamImageCaptureBurst &&

            !iController.SequenceCaptureInProgress() )

            {

            // Burst mode - processing text needed

            PrepareBurstProcessingTextL();

            }

         break;

         }

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

    case ECamEventInitReady:

        {

        // event only received if UIOrientationOverride feature is supported

        if( iAPCreateAO->IsActive() )

            {

            iAPCreateAO->Cancel();

            }

		iAPCreateAO->Start( TCallBack( BackgroundAPL,this ) );

        break;

        }

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

    default:

      {

      // otherwise, do nothing

      break;

      }

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

    }

    CCamPreCaptureContainerBase::HandleControllerEventL( aEvent, aError );

    PRINT( _L("Camera <= CCamStillPreCaptureContainer::HandleControllerEventL" ) )

    }

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

// BackgroundAPL

// Create AP ItemActive object Callback

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

TInt CCamStillPreCaptureContainer::BackgroundAPL( TAny *aparam )

    {

    CCamStillPreCaptureContainer* camStillCaptureContainer = reinterpret_cast<CCamStillPreCaptureContainer*> (aparam);

    return camStillCaptureContainer->SetupActivePaletteCallbackL();

    }

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

// SetupActivePaletteCallbackL

// Initializes ActivePalette

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

TInt CCamStillPreCaptureContainer::SetupActivePaletteCallbackL()

    {

    PRINT( _L("Camera => CCamStillPreCaptureContainer::SetupActivePaletteCallbackL" ) )

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

    if ( !iController.IsTouchScreenSupported() &&

         iController.CurrentMode()== ECamControllerImage )

        {

        if ( appUi )

            {

            appUi->SetActivePaletteVisibility( EFalse);

            if ( !appUi->ActivePalette() )

                {

                OstTrace0( CAMERAAPP_PERFORMANCE, CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 1" );

                static_cast<CCamPreCaptureContainerBase*>( this )

                    ->SetupActivePaletteL( static_cast<CCamViewBase*>(&iView) );

                OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_SETUP 0" );

                }

            else

                {

                OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 1" );

                appUi->APHandler()->UpdateActivePaletteL();

                OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMSTILLPRECAPTURECONTAINER_HANDLECONTROLLEREVENTL, "e_CAM_APP_AP_UPDATE 0" );

                }

            appUi->SetActivePaletteVisibility( ETrue );

            }

        else

            {

            }

        }

    PRINT( _L("Camera <= CCamStillPreCaptureContainer::SetupActivePaletteCallbackL" ) )

    return EFalse;

    }

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

// CCamStillPreCaptureContainer::OfferKeyEventL

// Handle key events

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

//

TKeyResponse

CCamStillPreCaptureContainer::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                                    TEventCode aType )

    {

    // if the cancel softkey is pressed

    // If currently capturing a burst

    if ( iController.SequenceCaptureInProgress() )

        {

        if ( aKeyEvent.iScanCode == EStdKeyDevice1 )

            {

            // Just return so the key press does not pass up to the base

            // class This will now be handled in HandleCommandL()

            return EKeyWasNotConsumed;

            }

        }

    return CCamPreCaptureContainerBase::OfferKeyEventL( aKeyEvent, aType );

    }

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

// CCamStillPreCaptureContainer::ViewFinderLayoutResourceIds

// Return the layout resource id for the viewfinder

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

//

void CCamStillPreCaptureContainer::ViewFinderLayoutResourceIds(

                                                TInt& aViewFinderLayoutId,

                                                TInt& aReticuleLayoutId ) const

    {

        {

        aViewFinderLayoutId = ROID(R_CAM_VIEWFINDER_RECT_STILL_ID);

        CCamAppUiBase* appui = static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() );

        if ( appui->IsSecondCameraEnabled() )

            {

            aViewFinderLayoutId = ROID(R_CAM_STILL_DISPLAYED_RECT_SECONDARY_ID);

            }

        }

    if ( iController.UiConfigManagerPtr() &&

         iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

        {

        // set the layouts for the still capture viewfinder and reticule

        aReticuleLayoutId = R_CAM_IMG_PRECAP_RETICULE;

        }

    else

        {

        aReticuleLayoutId = 0;

        }

    }

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

// CCamStillPreCaptureContainer::SetResolutionIndicator

// Sets the resolution indicator to the required icon

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

//

void CCamStillPreCaptureContainer::SetResolutionIndicator()

    {

    // The setting stored is an index into the array of supported qualities,

    // and since this matches the array of supported quality icons, we do

    // not need to do any further lookup on this value.

    iCurrentIndicator = iController.IntegerSettingValue( ECamSettingItemPhotoQuality );

    }

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

// CCamStillPreCaptureContainer::SetLocationIndicatorVisibility

// Sets the resolution indicator visibility, if it is set or not

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

//

void CCamStillPreCaptureContainer::SetLocationIndicatorVisibility()

    {

    // The setting stored is an index of whether the location setting is on or off

    iLocationIndicatorVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation ));

    }

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

// CCamStillPreCaptureContainer::IncreaseFlashSettingL

// Move up through the flash settings

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

//

void CCamStillPreCaptureContainer::IncreaseFlashSettingL()

    {

    if ( iZoomPane->IsVisible()

         || static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() )->IsSecondCameraEnabled()

        )

        {

        return;

        }

    // get current setting

    TInt setting =

            iController.IntegerSettingValue( ECamSettingItemDynamicPhotoFlash );

    // Max/Min settings are ECamFlashAuto/ECamFlashOff

    // and navi-key right moves down the list of settings

    if ( setting == ECamFlashOff )

        {

        setting = ECamFlashAuto;

        }

    else if ( setting >= ECamFlashAuto )

        {

        setting++;

        }

    else

        {

        // remove Lint warning

        }

    // only update if setting is invalid

    if ( setting >= ECamFlashAuto && setting <= ECamFlashOff )

        {

        iController.SetIntegerSettingValueL(

                                ECamSettingItemDynamicPhotoFlash, ( setting ) );

        }

    }

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

// CCamStillPreCaptureContainer::DecreaseFlashSettingL

// Move down through the flash settings

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

//

void CCamStillPreCaptureContainer::DecreaseFlashSettingL()

    {

    if ( iZoomPane->IsVisible()

         || static_cast<CCamAppUiBase*>( iEikonEnv->AppUi() )->IsSecondCameraEnabled()

        )

        {

        return;

        }

    // get current setting

    TInt setting =

            iController.IntegerSettingValue( ECamSettingItemDynamicPhotoFlash );

    // Max/Min settings are ECamFlashAuto/ECamFlashOff

    // and navi-key left moves up the list of settings

    if ( setting == ECamFlashAuto )

        {

        setting = ECamFlashOff;

        }

    else if ( setting > ECamFlashAuto )

        {

        setting--;

        }

    else

        {

        // remove Lint warning

        }

    // only update if setting is invalid

    if ( setting >= ECamFlashAuto && setting <= ECamFlashOff )

        {

        iController.SetIntegerSettingValueL(

                                ECamSettingItemDynamicPhotoFlash, ( setting ) );

        }

    }

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

// CCamStillPreCaptureContainer::HandleCaptureKeyEventL

// Change the current capture state

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

//

TKeyResponse

CCamStillPreCaptureContainer::HandleCaptureKeyEventL( const TKeyEvent& aKeyEvent )

  {

  PRINT( _L("Camera => CCamStillPreCaptureContainer::HandleCaptureKeyEventL"))

  TKeyResponse keyResponse = EKeyWasNotConsumed;

  CCamAppUi* appui = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );

  __ASSERT_DEBUG(appui, CamPanic(ECamPanicNullPointer));

  TBool MSKCapture(EFalse);

  // First handle middle softkey and enter key capture event

  if ( !appui->IsToolBarVisible()

       && ( aKeyEvent.iScanCode == EStdKeyDevice3

            || aKeyEvent.iScanCode == EStdKeyEnter ) )

    {

    if ( iController.UiConfigManagerPtr() )

        {

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

            {

            MSKCapture = ETrue;

            }

        else

            {

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

                {

                if ( iController.CheckFlash()

                       && static_cast<CCamPreCaptureViewBase*>( &iView )

                           ->StartMskCaptureL() )

                    {