/*

* 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:  Base class for all camera application containers*

*/

// INCLUDE FILES

#include <eikmenub.h>

#include <aknview.h>

#include <avkon.hrh>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

// System includes for changing the orientation.

#include <eikenv.h>

#include <eikappui.h>

#include <activepalette2ui.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <StringLoader.h>

#include "CamContainerBase.h"

#include "CamAppController.h"

#include "CamLogger.h"

#include "CamUtility.h"

#include "CamAppUi.h"

#include "CamNaviCounterControl.h"

#include "CamNaviProgressBarControl.h"

#include "CamZoomPane.h"

#include "camactivepalettehandler.h"

#include "CameraUiConfigManager.h"

#include "CamViewBase.h"

#include "cambackupcontainer.h"

  static const TInt KCamBurstCounterLength = 2;

  _LIT(KCamBurstCounterFormat, "%02d");

// ================= STATIC MEMBER VARIABLES ================

MActivePalette2UI* CCamContainerBase::iActivePalette = NULL;

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

// Destructor

CCamContainerBase::~CCamContainerBase()

  {

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

  delete iBgContext;

  iPrimaryZoomInKeys.Close();

  iPrimaryZoomOutKeys.Close();

  iSecondaryZoomInKeys.Close();

  iSecondaryZoomOutKeys.Close();

  iPrimaryCameraCaptureKeys.Close();

  iSecondaryCameraCaptureKeys.Close();

  iPrimaryCameraAFKeys.Close();

  delete iProcessingText;

    delete iBurstProcessingText;

  if(iBackupContainer)

      {

      delete iBackupContainer;

      iBackupContainer = NULL;

      }

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

  }

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

// CCamContainerBase::CCamContainerBase

// C++ constructor

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

//

CCamContainerBase::CCamContainerBase( CCamAppController& aController,

                                      CAknView&          aView       )

  : iView( aView ), 

    iController( aController )

  {

  }

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

// CCamContainerBase::BaseConstructL

// Symbian OS 2nd phase constructor

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

//

void CCamContainerBase::BaseConstructL( const TRect& aRect )

  {

  CreateWindowL();

  Window().SetBackgroundColor( KRgbBlack );

  SetRect( aRect );

  EnableDragEvents(); 

  CCamAppUiBase* appUi =  static_cast<CCamAppUiBase*>( iEikonEnv->EikAppUi() );

  iCamOrientation = appUi->CamOrientation();

  // set up the skin background context

  CreateBackgroundContextL();

  iBackupContainer = CCamBackupContainer::NewL(iController,iView,*this);

  // zoom keys

  iPrimaryZoomInKeys.Reset();

  iPrimaryZoomOutKeys.Reset();

  iSecondaryZoomInKeys.Reset();

  iSecondaryZoomOutKeys.Reset();

  // capture keys

  iPrimaryCameraCaptureKeys.Reset();

  iSecondaryCameraCaptureKeys.Reset();

  // AF keys

  iPrimaryCameraAFKeys.Reset();

  if ( iController.UiConfigManagerPtr() )

      {

      // Reading the zoom keys for primary and secondary camera

      iController.UiConfigManagerPtr()->

          SupportedPrimaryCameraZoomInKeysL( iPrimaryZoomInKeys );

      iController.UiConfigManagerPtr()->

                SupportedPrimaryCameraZoomOutKeysL( iPrimaryZoomOutKeys );

      // secondary camera zoom-in/out keys

      iController.UiConfigManagerPtr()->

                SupportedSecondaryCameraZoomInKeysL( iSecondaryZoomInKeys );

      iController.UiConfigManagerPtr()->

                SupportedSecondaryCameraZoomOutKeysL( iSecondaryZoomOutKeys );

      // Reading the capture keys for primary and secondary camera

      iController.UiConfigManagerPtr()->

                SupportedPrimaryCameraCaptureKeyL( iPrimaryCameraCaptureKeys );

      iController.UiConfigManagerPtr()->

                      SupportedSecondaryCameraCaptureKeyL( iSecondaryCameraCaptureKeys );

      // Reading AF or half capture key press  Keys

      iController.UiConfigManagerPtr()->SupportedPrimaryCameraAutoFocusKeyL(

                                                       iPrimaryCameraAFKeys );

      }

  if ( iPrimaryZoomInKeys.Count() <= 0 || iPrimaryZoomOutKeys.Count() <= 0 ||

       iSecondaryZoomInKeys.Count() <= 0 || iSecondaryZoomOutKeys.Count() <= 0 ||

       iPrimaryCameraCaptureKeys.Count() <= 0 || iSecondaryCameraCaptureKeys.Count() <= 0 ||       

       iPrimaryCameraAFKeys.Count() <= 0

      )

      {

      // Leave here, if there are no configured items so that we dont panic 

      //in any container classes derived from this base class

      User::Leave( KErrNotSupported );

      }

    }

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

// CCamContainerBase::IsCaptureKeyL

// Whether or not this key is considered to be a capture key

// in the current context

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

//

TBool CCamContainerBase::IsCaptureKeyL( const TKeyEvent& aKeyEvent,

                                       TEventCode aType ) 

  {

  PRINT1( _L( "Camera => CCamContainerBase::IsCaptureKey event type (%d)" ),  aType ); 

  // Find out if this key is a capture key

  TBool isCaptureKey( EFalse) ;

  // Repeat events are not classed as capture keys

  if ( aKeyEvent.iRepeats != 0 )

    {

    PRINT( _L( "IsCaptureKey returning false (repeat)" ) );

    return isCaptureKey;

    }

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

  if ( appUi && appUi->AppInBackground( ETrue ) )

      {

      PRINT( _L("IsCaptureKey returning false (AppInBackground() = true") );

      return isCaptureKey;

      }

  if ( ECamActiveCameraPrimary == iController.ActiveCamera() )

      {

      isCaptureKey = IsPrimaryCameraCaptureKey( aKeyEvent );

      }

  else // secondary camera

      {

      isCaptureKey = IsSecondaryCameraCaptureKey( aKeyEvent );

      }  

  // Each product defines which key/s are treated as capture keys.

  // Different keys can be mapped for each active camera.

  // Look for capture event or key up event (note that capture

  // event is on the EEventKey for navi-key select press)

  if ( isCaptureKey )

      {

      if ( aType == EEventKeyDown || aType == EEventKey || aType == EEventKeyUp || aType == EEventKeyUp )

        {

        if ( isCaptureKey &&

             ( iController.UiConfigManagerPtr()->IsKeyLockWatcherSupported() && iController.IsKeyLockOn() ) )

            {

            isCaptureKey = !iController.IsKeyLockOn();

            }

        }

      else

        {

        // key types doesnt match so dont consider as capture key press.

        isCaptureKey = EFalse;

        }  

      }

  PRINT1( _L( "IsCaptureKey returning %d" ), isCaptureKey );

  return isCaptureKey;

  }

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

// CCamContainerBase::IsShutterKeyL

// Whether or not this key is considered to be a shutter key

// in the current context

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

//

TBool CCamContainerBase::IsShutterKeyL( const TKeyEvent& aKeyEvent, TEventCode /* aType */ )

    {

    PRINT1( _L( "Camera => CCamContainerBase::IsShutterKeyL scancode (%d)" ),  aKeyEvent.iScanCode ); 

    if ( iController.UiConfigManagerPtr()

        && iController.UiConfigManagerPtr()->IsAutoFocusSupported() )

        {

#ifndef __WINS__

        if ( aKeyEvent.iScanCode == iPrimaryCameraAFKeys[0] )

#else

        if ( aKeyEvent.iScanCode == EProductKeyCaptureHalf )

#endif 

            {

            return ETrue;

            }

        }

    return EFalse;

    }

//

// CCamZoomPane::CheckForZoomKey

//

TBool CCamContainerBase::CheckForZoomKey( const TKeyEvent& aKeyEvent )

    {

    return CheckInZoomKeyArray( aKeyEvent );

    }

//

//

//

TBool CCamContainerBase::CheckInZoomKeyArray( const TKeyEvent& aKeyEvent )

    {

    TCamActiveCamera camera = iController.ActiveCamera();

    TBool zoomKeyFound ( EFalse );

    if ( camera == ECamActiveCameraPrimary )

        {

        zoomKeyFound = ( KErrNotFound != 

                         iPrimaryZoomInKeys.Find( aKeyEvent.iScanCode ) );

        if ( !zoomKeyFound )

            {

            // Its not zoom-in key, check if its zoom out key

            zoomKeyFound = ( KErrNotFound != 

                             iPrimaryZoomOutKeys.Find( aKeyEvent.iScanCode ) );

            }

        }

    else if ( camera == ECamActiveCameraSecondary )

        {

        zoomKeyFound = ( KErrNotFound != 

                         iSecondaryZoomInKeys.Find( aKeyEvent.iScanCode ) );

        if ( !zoomKeyFound )

            {

            // Its not zoom-in key, check if its zoom out key

            zoomKeyFound = ( KErrNotFound != 

                             iSecondaryZoomOutKeys.Find( aKeyEvent.iScanCode ) );

            }        

        }

    else

        {

        // when we reach here, it means we have no zoom keys set, we return back.

        }

    return zoomKeyFound;

    }

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

// CCamContainerBase::IsZoomKeyL

// Whether or not this key is considered to be a shutter key

// in the current context

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

//

TBool CCamContainerBase::IsZoomKeyL( const TKeyEvent& aKeyEvent,

                                        TEventCode aType ) 

    {

    PRINT1( _L( "Camera => CCamContainerBase::IsZoomKeyL event type (%d)" ),  aType );  

    CCamZoomPane* zoom = static_cast<CCamAppUiBase*>( iEikonEnv->EikAppUi() )->ZoomPane();    	

    // 

    if( !ZoomAvailable() )

    	{

    	return EFalse;

    	}

  	PRINT( _L( "Camera => CCamContainerBase::IsZoomKeyL " ) );  

    // It's a possible zoom key if it's an up OR down event, OR

    // if it's a key event AND we're currently zooming 

    if ( aType == EEventKeyUp || aType == EEventKeyDown || aType == EEventUser ||

         ( aType == EEventKey && 

           zoom &&

           zoom->IsCurrentlyZooming() ) )

        {

        PRINT( _L( "Camera => CCamContainerBase::IsZoomKeyL A" ) )

        return CheckForZoomKey( aKeyEvent );

        }

	PRINT( _L( "Camera => CCamContainerBase::IsZoomKeyL no" ) )

    return EFalse;

    }

//

// CCamContainerBase::ZoomAvailable()

//

TBool CCamContainerBase::ZoomAvailable()

	{

	PRINT( _L("Camera => CCamContainerBase::ZoomAvailable"))

	// Ignore any zoom keys that come when either capturing a burst or still

  if ( iController.SequenceCaptureInProgress() 

    || ( ECamControllerImage == iController.CurrentMode()

      && ECamCapturing       == iController.CurrentOperation() ) 

    || ECamCompleting == iController.CurrentOperation()  )

    {

    PRINT( _L("Camera => CCamContainerBase::ZoomAvailable A false"))

    return EFalse;

    }

	PRINT( _L("Camera => CCamContainerBase::ZoomAvailable yes"))

	return ETrue;

	}

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

// Window

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

//

RWindow& 

CCamContainerBase::Window() const

  {

  return CCoeControl::Window();

  }

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

// CCamContainerBase::OfferKeyEventL

// Handles this application view's command keys. Forwards other

// keys to child control(s).

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

//

TKeyResponse 

CCamContainerBase::OfferKeyEventL( const TKeyEvent& aKeyEvent,

                                         TEventCode aType )

  {

  PRINT1( _L("Camera => CCamContainerBase::OfferKeyEventL scan code (%d)"), aKeyEvent.iScanCode )

  // if the cancel softkey is pressed

  if ( aKeyEvent.iScanCode == EStdKeyDevice1 )

    {        

    iView.HandleCommandL( EAknSoftkeyCancel );

    }

  // or if the select (OK) key is pressed

  //

  // (Note: intentionally ignoring repeat key presses here - this is a

  // work-around as the framework is passing navi-key select repeats

  // which we have to ignore)

  else if ( aType == EEventKey && 

            aKeyEvent.iCode == EKeyOK && 

            aKeyEvent.iRepeats == 0 )

    {

    return EKeyWasConsumed; // indicate key press was processed

    }

    // stop video or sequence if get applications key press (short or long)

    // in touch also send key stops

  else if( aKeyEvent.iCode == EKeyApplication ||

         ( iController.IsTouchScreenSupported() && 

           aKeyEvent.iScanCode == EStdKeyYes ) ) 

  	{

    if ( ECamControllerVideo == iController.CurrentMode() )

      {

      TCamCaptureOperation operation = iController.CurrentOperation();

      if( ECamCapturing == operation

       || ECamPaused    == operation )

        {

        // Stop video 

        iController.StopVideoRecording();

        }

      }

    else if ( iController.SequenceCaptureInProgress() )

      {

      // Stop sequence capture

      iController.StopSequenceCaptureL();

      }

    else

    	{

    	// empty statement to remove Lint error, MISRA required rule 60

    	}

  	}

  else

    {

    // empty statement to remove Lint error, MISRA required rule 60

    }

  return EKeyWasNotConsumed;  // indicate key press was not processed

  }

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

// CCamContainerBase::HandleForegroundEventL

// Called to notify of change of app fore/background state

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

//

void CCamContainerBase::HandleForegroundEventL( TBool /*aForeground*/ )

    {

    }

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

// CCamContainerBase::MopSupplyObject

// Gets an object whose type is encapsulated by the specified TTypeUid object

// Supplies the skin context to child controls using the MObjectProvider chain

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

//

TTypeUid::Ptr CCamContainerBase::MopSupplyObject( TTypeUid aId )

    {

    if ( aId.iUid == MAknsControlContext::ETypeId )

        {

        return MAknsControlContext::SupplyMopObject( aId, iBgContext );

        }

    return CCoeControl::MopSupplyObject( aId );

    }

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

// CCamContainerBase::HandleResourceChange

// Change Client Rect and redraw when resolution changes

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

//

void CCamContainerBase::HandleResourceChange( TInt aType )

    {

    PRINT( _L("Camera => CCamContainerBase::HandleResourceChange" ))

    CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->EikAppUi() );

    if ( KEikDynamicLayoutVariantSwitch == aType )

        {

	    TCamOrientation orientation = appUi->CamOrientation();

        if( iCamOrientation != orientation )

            {

            iCamOrientation = orientation;

            if( orientation == ECamOrientationCamcorder || orientation == ECamOrientationCamcorderLeft )

                {

                PRINT( _L("Camera => CCamContainerBase::HandleResourceChange camcorder" ))

                SetRect( appUi->ApplicationRect() );

                }

            else

                {

                PRINT( _L("Camera => CCamContainerBase::HandleResourceChange not camcorder" ))

                SetRect( appUi->ClientRect() );

                }

            }

        }

    CCoeControl::HandleResourceChange( aType );

    if ( iController.IsTouchScreenSupported() ) 

        {

        // Update toolbar because HandleResourceChange might reload the default version

        // Only update toolbaricons if in precaptureview.

        if( appUi->CurrentViewState() != ECamViewStatePostCapture )

            {

            TRAP_IGNORE( static_cast<CCamViewBase&>( iView ).UpdateToolbarIconsL() );

            }

        }  

    }

// virtual 

void 

CCamContainerBase::HandleAppEvent( const TCamAppEvent& /*aEvent*/ )

  {

  // No action

  }

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

// CCamContainerBase::SetPreviousViewId

// Sets the ID of the previous view

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

//

void CCamContainerBase::SetPreviousViewId( TCamAppViewIds aId )

    {

    iPrevViewId = aId;

    }

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

// CCamContainerBase::SetupNaviPanesL

// Set up navi-pane and progress bar if required

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

//    

void CCamContainerBase::SetupNaviPanesL( TCamActiveNaviPane aNaviPane )

	{

	PRINT( _L("Camera => CCamContainerBase::SetupNaviPanesL" ))

	TRect rect( Rect() );