/*

* 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:  Base class for all views used in the Camera application*

*/

// INCLUDE FILES

#include "CamAppUi.h"

#include "CamViewBase.h"

#include "CamContainerBase.h"

#include "CamStandbyContainer.h"

#include "CamUtility.h"

#include "CamPanic.h"

#include <eikmenub.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <akntoolbar.h>

#include "CamUtility.h"

#include <AknWaitDialog.h>

#include "CamWaitDialog.h"

#include "CamCommandHandlerAo.h"

#include "CameraUiConfigManager.h"

static const TRect KCamCbaHiddenRect = TRect(640,640,640,640);

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

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

// CCamViewBase destructor

// 

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

//

CCamViewBase::~CCamViewBase()

  {

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

  if ( iStandbyContainer )

    {

    CAknViewAppUi* appUi = AppUi();

    if ( appUi )

      {

      appUi->RemoveFromStack( iStandbyContainer );

      }

    delete iStandbyContainer;

    iStandbyContainer = NULL;

    }

  delete iContainer;

  iContainer = NULL;

  delete iCommandHandlerAo;

  iCommandHandlerAo = NULL;

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

  }

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

// CCamViewBase::HandleFocusLossL

// Handle focus loss

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

//

void CCamViewBase::HandleFocusLossL()

    {

    // intentionally doing nothing

    }

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

// HandleAppEvent <<virtual>>

//

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

//

void 

CCamViewBase::HandleAppEvent( const TCamAppEvent& aEvent )

  {

  PRINT1( _L("Camera => CCamViewBase::HandleAppEvent, event:%d"), aEvent );

  if( iContainer )

    {

    iContainer->HandleAppEvent( aEvent );

    }

  PRINT( _L("Camera <= CCamViewBase::HandleAppEvent") );

  }

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

// CCamViewBase::PrepareForModeChange

// Prepare for mode change

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

//

void CCamViewBase::PrepareForModeChange()   

    {

    // intentionally doing nothing

    }

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

// CCamViewBase::HandleCommandL

// Handle commands

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

//

void CCamViewBase::HandleCommandL( TInt aCommand )

    {

    PRINT( _L("Camera => CCamViewBase::HandleCommandL"))

    switch(aCommand)

        {

        case ECamCmdInternalExit:

            {   

            TInt standbyError = KErrNone;        

            if ( iStandbyModeActive && iStandbyContainer )

                {

                standbyError = iStandbyContainer->GetStandbyError();

                ExitStandbyModeL();

                }

            if ( standbyError != KErrNone )

                {

                AppUi()->HandleCommandL( EEikCmdExit );

                }

            else

                {

                AppUi()->HandleCommandL( aCommand );

                }

            // dismiss menu - if open

            StopDisplayingMenuBar();

            }

            break;

        case ECamCmdRedrawScreen:

            {

            if( iContainer )

            	{

            	iContainer->DrawDeferred();

            	}           

            }

            break;

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    }

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

// CCamViewBase::HandleForegroundEventL

// Handle foreground event

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

//

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

    {

    PRINT( _L("CCamViewBase::HandleForegroundEventL") );

    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );  

    iEmbedded = appUi->IsEmbedded();

    PRINT1( _L("CCamViewBase::HandleForegroundEventL embedded %d"), iEmbedded );    

    }

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

// CCamViewBase::DoActivateL

// Activate this view

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

//

void 

CCamViewBase::DoActivateL( const TVwsViewId& /*aPostvViewId*/, 

                                 TUid        aCustomMessageId, 

                           const TDesC8&     /*aCustomMessage*/ )

  {

  PRINT( _L("Camera => CCamViewBase::DoActivateL"));    

  CCamContainerBase::DestroyActivePalette();     

  if(ECamViewMessageDeactivateFirst == aCustomMessageId.iUid)

    {

    PRINT( _L("CCamViewBase::DoActivateL call deactivate"));    

    TBool wasCameraUser = IsCameraUser();    

    DoDeactivate();

    // since we still use it

    if( wasCameraUser )

      {

      IncrementCameraUsers();

      }

    }

  CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );  

  iEmbedded = appUi->IsEmbedded();

  PRINT1( _L("CCamViewBase::DoActivateL Embedded %d"), iEmbedded);    

  if ( !iContainer )

    {

    CreateContainerL();

    AppUi()->AddToStackL( *this, iContainer );

    iContainer->ActivateL();

    }

  SetTitlePaneTextL();

  TInt orientation;

  TCamPsiKey queryValue = ECamPsiOrientation;

  CCameraUiConfigManager* configManager = iController.UiConfigManagerPtr(); 

  if ( configManager && configManager->IsSecondaryCameraSupported() )

      {

      if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() ) // if front camera is active         

          {

          queryValue = ECamPsiSecondaryCameraOrientation;

          }

      else // back camera is active

          {

          queryValue = ECamPsiPrimaryCameraOrientation;

          }

      }

  CamUtility::GetPsiInt( queryValue, orientation );

  AppUi()->SetOrientationL( ( CAknAppUiBase::TAppUiOrientation ) orientation );

  TCamOrientation camOrientation = appUi->CamOrientation();

  // if in camcorder mode need to show navi-ctr

  if( camOrientation == ECamOrientationCamcorder ||  

      camOrientation == ECamOrientationCamcorderLeft || 

      camOrientation == ECamOrientationPortrait )

    {

		iContainer->SetupNaviPanesL( CCamContainerBase::ECamPaneCounter );

		}

  PRINT( _L("Camera <= CCamViewBase::DoActivateL"));    

  }

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

// CCamViewBase::DoDeactivate

// Deactivate this view

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

//

void CCamViewBase::DoDeactivate()

  {

  PRINT( _L("Camera => CCamViewBase::DoDeactivate" ))

	// Both standard container and standby container should be deactivated

    if ( iStandbyContainer ) // implies IsInStandbyMode

        {

        AppUi()->RemoveFromStack( iStandbyContainer );

        delete iStandbyContainer;

        iStandbyContainer = NULL;

        SetStandbyModeActive( EFalse );

        }

	if ( iContainer )

		{

  		AppUi()->RemoveFromStack( iContainer );

    	delete iContainer;

    	iContainer = NULL;

    	}

	PRINT( _L("Camera <= CCamViewBase::DoDeactivate" ))

	}

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

// CCamViewBase::CCamViewBase

// C++ constructor

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

//

CCamViewBase::CCamViewBase( CCamAppController& aController )

    : iController( aController )

    {

    }

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

// CCamViewBase::UpdateCbaL

// Update softkeys to reflect current state

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

//

void CCamViewBase::UpdateCbaL()

    {

    }

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

// CCamViewBase::BlankSoftKeysL

// Blank the softkeys

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

//

void CCamViewBase::BlankSoftkeysL()

    {

    // blank the cba 

    SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

    }

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

// CCamViewBase::SwitchToStandbyModeL

// Switches to standby mode

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

//

void CCamViewBase::SwitchToStandbyModeL( TCamAppViewIds aViewId, TInt aError )

    {

    PRINT( _L("Camera => CCamViewBase::SwitchToStandbyModeL") );

    // check if already in standby mode

    if( iStandbyModeActive )

    	{

    	PRINT( _L("Camera <= CCamViewBase::SwitchToStandbyModeL: already in standby") );

    	return;

    	}

    StatusPane()->MakeVisible( ETrue );

    delete iStandbyContainer;

    iStandbyContainer = NULL;

    iStandbyContainer = CCamStandbyContainer::NewL( AppUi()->ClientRect(),

                                                    *this, iController, aError );

    // dismiss menu - if open

    StopDisplayingMenuBar();

    // save options menu id for reactivation

    if ( aViewId == ECamViewIdStillPreCapture )

        {

        if ( iEmbedded )

            {

            iPreviousMenuResourceId = ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);

            }

        else

            {

            iPreviousMenuResourceId = ROID(R_CAM_STILL_PRE_CAPTURE_MENUBAR_ID);

            }

        }

    else if ( aViewId == ECamViewIdVideoPreCapture )

        {

        if ( iEmbedded )

            {

            iPreviousMenuResourceId = ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID);

            }

        else

            {

            iPreviousMenuResourceId = ROID(R_CAM_VIDEO_PRE_CAPTURE_MENUBAR_ID);

            }

        }

    else if ( aViewId == ECamViewIdVideoSettings )

        {

        iPreviousMenuResourceId = ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID);

        }

    else if ( aViewId == ECamViewIdPhotoSettings )

        {

        iPreviousMenuResourceId = ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID);

        }

    else

        {

        // remove Lint error

        }

    // activate standby container and deactivate current container

    iStandbyContainer->SetMopParent( this );   

    CCamAppUi* appUi =  static_cast<CCamAppUi*>( AppUi() );

    appUi->AddToStackL( *this, iStandbyContainer );

    iStandbyContainer->ActivateL();

    appUi->RemoveFromStack( iContainer );

    iContainer->MakeVisible( EFalse );   

    iStandbyContainer->MakeVisible( ETrue );

    iStandbyContainer->DrawNow();

    UnsetCourtesySoftKeysL();

    // update softkeys

    if ( !appUi->IsConstructionComplete() )

    	{

    	BlankSoftkeysL();

    	}

    else if ( appUi->StandbyStatus() == KErrInUse ||

              appUi->StandbyStatus() == KErrPermissionDenied ||

              appUi->StandbyStatus() == KErrAccessDenied )

        {

        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );	

        }	

    else if ( iEmbedded )

        {

        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK__CONTINUE );

        }

    else

        {

        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT__CONTINUE );

        }

    // change options menu

    CEikMenuBar* menuBar = MenuBar();

    if ( menuBar )

        {

        menuBar->SetMenuTitleResourceId( R_CAM_STANDBY_MENUBAR );

        }

//    if ( iStandbyError != KErrNone )

        {

        // stop idle timer - non recoverable error

        iController.StopIdleTimer();

        }

    SetStandbyModeActive(ETrue);

    // Release the camera hardware

    iController.ReleaseCamera();

    // cancel self timer mode if active

    if ( appUi->SelfTimerEnabled() )

        {

        appUi->SelfTimerEnableL( ECamSelfTimerDisabled );

        }

  	PRINT( _L("Camera <= CCamViewBase::SwitchToStandbyModeL") );

    }

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

// CCamViewBase::ExitStandbyModeL

// Exits standby mode

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

//

void CCamViewBase::ExitStandbyModeL()

    {

    PRINT( _L("Camera => CCamViewBase::ExitStandbyModeL") );    

    if ( !iStandbyModeActive )

        {

        return;

        }

    // delete standby container and reactivate previous container

    TRAPD( err, AppUi()->AddToStackL( *this, iContainer ) )

    iStandbyContainer->MakeVisible( EFalse );

    AppUi()->RemoveFromStack( iStandbyContainer );

    delete iStandbyContainer;

    iStandbyContainer = NULL;

    User::LeaveIfError( err );

    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

    iContainer->MakeVisible( ETrue );   

    SetStandbyModeActive( EFalse );

    if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() ) 

        {

        StatusPane()->MakeVisible( ETrue );

        }

    else

        {

        StatusPane()->MakeVisible( EFalse );

        }

    CCameraUiConfigManager* configManager = iController.UiConfigManagerPtr();

    if ( !( configManager && configManager->IsUIOrientationOverrideSupported() ) ) 

        {

        appUi->RaisePreCaptureCourtesyUI(ETrue);

        }

    if ( iPreviousMenuResourceId == ROID(R_CAM_SETTINGS_LIST_MENUBAR_ID)

            || iPreviousMenuResourceId == ROID(R_CAM_STILL_EMBEDDED_PRE_CAPTURE_MENUBAR_ID)

            || iPreviousMenuResourceId == ROID(R_CAM_VIDEO_EMBEDDED_PRE_CAPTURE_MENUBAR_ID))

        {

        if ( iController.CaptureModeTransitionInProgress() )

            {

            SetSoftKeysL( R_AVKON_SOFTKEYS_BACK ); 

            }

        else

            {

            SetSoftKeysL( R_AVKON_SOFTKEYS_OPTIONS_BACK );

            }

        }

    else

        {

        SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_EXIT );

        }

    // restore options menu

    CEikMenuBar* menuBar = MenuBar();

    if ( menuBar )

        {

        menuBar->SetMenuTitleResourceId( iPreviousMenuResourceId );

        }

    //SetStandbyModeActive(EFalse);

    SetTitlePaneTextL();    

    // restart idle timer

    iController.StartIdleTimer();

    PRINT( _L("Camera <= CCamViewBase::ExitStandbyModeL") );    

    }

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

// ExitAllModesL <<virtual>>

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

//

void 

CCamViewBase::ExitAllModesL()

  {

  // Empty default implementation.

  }

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

// CCamViewBase::GetHelpContext

// Called to identify the help context for this view

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