1 /*

     2 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Container base class for pre-capture views*

    15 */

    16 

    17 

    18 

    19 // INCLUDE FILES

    20 #include <eikmenub.h>

    21 #include <aknview.h>

    22 #include <w32std.h>

    23 #include <gulutil.h>

    24 #include <AknIconUtils.h>

    25 #include <barsread.h>    // resource reader

    26 #include <AknsFrameBackgroundControlContext.h>

    27 #include <AknsDrawUtils.h>

    28 #include <eikenv.h>

    29 #include <eikappui.h> // For CCoeAppUiBase

    30 #include <eikapp.h>   // For CEikApplication

    31 #include <layoutmetadata.cdl.h>            

    32 #include <aknlayoutscalable_apps.cdl.h>    

    33 

    34 #include <cameraapp.mbg>

    35 #include <cameraapp.rsg>

    36 #include <vgacamsettings.rsg>

    37 #include <touchfeedback.h>

    38 #include <akntoolbar.h>

    39 #include <akntoolbarextension.h>

    40 

    41 #include "CamAppUiBase.h"

    42 #include "CamPreCaptureContainerBase.h"

    43 #include "CamLogger.h"

    44 #include "CamSidePane.h"

    45 #include "CamUtility.h"

    46 #include "CamPanic.h"

    47 #include "Cam.hrh"

    48 #include "CamAppUi.h"   

    49 #include "CamIndicator.h"

    50 #include "CamIndicatorResourceReader.h"

    51 #include "CamIndicatorData.h"

    52 #include "CamSelfTimer.h"

    53 #include "CamPreCaptureViewBase.h"

    54 #include "CamStillPreCaptureView.h"

    55 #include "CamSettings.hrh"

    56 #include "CamNaviCounterControl.h"

    57 #include "CamNaviProgressBarControl.h"

    58 #include "camuiconstants.h" // KCamDirectColorVal

    59 #include "camactivepalettehandler.h"

    60 #include "OstTraceDefinitions.h"

    61 #ifdef OST_TRACE_COMPILER_IN_USE

    62 #include "CamPreCaptureContainerBaseTraces.h"

    63 #endif

    64 #include "camconfiguration.h"

    65 #include "CameraUiConfigManager.h"

    66 #include "camstartuplogo.h"

    67 #include "camvfgridinterface.h"

    68 #include "camlinevfgriddrawer.h"

    69 #include "camcapturebuttoncontainer.h"

    70 

    71 // CONSTANTS

    72 const TInt KZoomPanelTimeout = 4000000;     // 4s 

    73 const TInt KReticuleFlashTimeout = 250000;  // Quarter of a second (in microseconds).

    74 const TInt KAFIconCorners = 4; // Hip to be square 

    75 

    76 const TInt KIndicatorBlinkDelay = 250 * 1000;

    77 const TInt KNumberOfBlinks = 3;

    78 const TInt KNumberOfBlinksVideo = 8;

    79 

    80 const TSize  KCaptureButtonSize( 50, 50 );

    81 const TSize  KAdditionalArea( 25, 11 );

    82 const TInt32 KCaptureButtonYDelta( 10 );

    83 

    84 // Snapshot data is needed in timelapse mode

    85 const TUint KCameraEventInterest = ( ECamCameraEventClassVfControl      

    86                                    | ECamCameraEventClassVfData 

    87                                    | ECamCameraEventClassSsData 

    88                                    );

    89 

    90 

    91 

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

    93 

    94 // ---------------------------------------------------------

    95 // CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase

    96 // Destructor

    97 // ---------------------------------------------------------

    98 //

    99 CCamPreCaptureContainerBase::~CCamPreCaptureContainerBase()

   100   {

   101   PRINT( _L("Camera => ~CCamPreCaptureContainerBase" ))

   102 

   103   if( iCaptureButtonContainer )

   104       {

   105       delete iCaptureButtonContainer;

   106       }

   107 

   108   iController.ViewfinderWindowDeleted( &Window() );

   109   

   110   iController.RemoveSettingsObserver  ( this );

   111   iController.RemoveCameraObserver    ( this );

   112   iController.RemoveControllerObserver( this );    

   113   

   114     if ( iZoomTimer && iZoomTimer->IsActive() )

   115     {    

   116     iZoomTimer->Cancel();

   117     }

   118   delete iZoomTimer;

   119   delete iVfGridDrawer;

   120 

   121   delete iStartupLogo;

   122 

   123   if ( iController.UiConfigManagerPtr() && 

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

   125       {

   126       iAfIcons.ResetAndDestroy();

   127       iLayouts.Close(); 

   128       if ( iReticuleTimer && iReticuleTimer->IsActive() )

   129         {    

   130         iReticuleTimer->Cancel();

   131         }

   132       delete iReticuleTimer;    

   133       }

   134 

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

   136 

   137   iResolutionIndicators.ResetAndDestroy();

   138   iResolutionIndicators.Close();

   139   if ( iController.UiConfigManagerPtr() && 

   140        iController.UiConfigManagerPtr()->IsLocationSupported() )

   141       {

   142       PRINT( _L("Camera => ~CCamPreCaptureContainerBase - delete iLocationIconController" ))

   143       delete iLocationIconController;

   144       }

   145 

   146   delete iOffScreenBitmap;

   147   delete iBitmapDevice;

   148   delete iBitmapGc;

   149   

   150   // if shutting down, observers are removed automatically  

   151   if ( 

   152       iController.IsAppUiAvailable() &&

   153       appUi && !iController.IsInShutdownMode() )

   154     {

   155     // Deregister as burst mode observer

   156     appUi->RemoveBurstModeObserver( this );

   157     }

   158 

   159   delete iBatteryPaneController;

   160   

   161   delete iViewFinderBackup;

   162   iViewFinderBackup = NULL;

   163   iReceivedVfFrame = EFalse;

   164   if( iIndBlinkTimer ) 

   165     {

   166     if( iIndBlinkTimer->IsActive() )

   167       {

   168       iIndBlinkTimer->Cancel();

   169       }

   170     delete iIndBlinkTimer;

   171     iIndBlinkTimer = NULL;

   172     }

   173   PRINT( _L("Camera <= ~CCamPreCaptureContainerBase" ))

   174   }

   175 

   176 // ---------------------------------------------------------

   177 // CCamPreCaptureContainerBase::BaseConstructL

   178 // Symbian OS 2nd phase constructor

   179 // ---------------------------------------------------------

   180 //

   181 void CCamPreCaptureContainerBase::BaseConstructL( const TRect& aRect )

   182   {

   183   PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL ") );

   184   

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

   186   iZoomPane = appUi->ZoomPane();

   187   

   188   CCamContainerBase::BaseConstructL( aRect );

   189   

   190   iViewFinderBackup = NULL;

   191   iReceivedVfFrame = EFalse;

   192   

   193   // Check whether zoom & side pane will be on the left or the right of the screen

   194   TInt handedInt;

   195   User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiSidePanePosition, handedInt ) );

   196   iHandedness = static_cast< TCamHandedness >( handedInt );

   197 

   198   TResourceReader reader;                                                                                     

   199   iEikonEnv->CreateResourceReaderLC( reader, ROID(R_CAM_ZOOM_PANE_WIDTH_ID));    

   200   iZoomPaneWidth = reader.ReadInt16();

   201   CleanupStack::PopAndDestroy(); // reader

   202   

   203   // Create Zoom Pane based on Rect passed in on creation

   204   TRect paneRect( Rect() );

   205 

   206   // if the side pane is on the left

   207   if ( iHandedness == ECamHandLeft ) 

   208     { 

   209     paneRect.iBr.iX = iZoomPaneWidth;

   210     }

   211   else // the side pane is on the right

   212     {

   213     paneRect.iTl.iX = paneRect.iBr.iX - iZoomPaneWidth;    

   214     }

   215   

   216   User::LeaveIfError( CamUtility::GetPsiInt( ECamPsiOverLaySidePane, iOverlayViewFinder ) );

   217 

   218   iController.AddControllerObserverL( this ); // For zoom state changes

   219   iController.AddCameraObserverL( this, KCameraEventInterest );

   220   iController.AddSettingsObserverL( this );

   221 

   222   iZoomPane->MakeVisible( EFalse, EFalse ); // On app startup, it's invisible

   223 

   224   if ( !appUi->IsSecondCameraEnabled() )

   225     {

   226     iZoomPane->SetZoomKeys( iPrimaryZoomInKeys, iPrimaryZoomOutKeys );

   227     }

   228   else

   229     {     

   230     iZoomPane->SetZoomKeys( iSecondaryZoomInKeys, iSecondaryZoomOutKeys );

   231     }

   232   

   233   iZoomTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

   234   

   235   if ( iController.UiConfigManagerPtr() && 

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

   237        !iController.UiConfigManagerPtr()->IsFaceTrackingSupported() )

   238       {

   239       iReticuleTimer = CPeriodic::NewL( CActive::EPriorityUserInput );

   240     

   241       // Layout the reticule.                                                                                           

   242       iAfReadyIcon = CreateAfIconL( KRgbWhite );

   243       iAfFocusIcon = CreateAfIconL( KRgbGreen );

   244       iAfErrIcon   = CreateAfIconL( KRgbRed );

   245       }

   246 

   247   iSidePane = appUi->SidePane();

   248   iSidePane->SetRect( paneRect );

   249 

   250   // Register as burst mode observer

   251   appUi->AddBurstModeObserverL( this );

   252   

   253   CreateResolutionIndicatorL();

   254   

   255   if ( iController.UiConfigManagerPtr() && 

   256        iController.UiConfigManagerPtr()->IsLocationSupported() )

   257       {

   258       TRect Locrect = Rect();

   259       PRINT( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL - create iLocationIconController") )

   260       iLocationIconController = CCamLocationIconController::NewL( iController, *this, ETrue, Locrect );

   261       SetLocationIndicatorVisibility();

   262       }

   263 

   264   TBool dsaAlways( EFalse ); // Offscreen bitmap is needed with the emulator

   265   #ifndef __WINS__

   266   dsaAlways = iController.IsDirectScreenVFSupported( ETrue ) && 

   267               iController.IsDirectScreenVFSupported( EFalse );

   268   #endif

   269                  

   270   if ( !dsaAlways )

   271       {

   272       // If bitmap VF is not possible in this configuration, 

   273       // offscreen bitmap is not needed

   274       TInt color;

   275       TInt gray;

   276   

   277       TDisplayMode displaymode =

   278           CEikonEnv::Static()->WsSession().GetDefModeMaxNumColors( color, gray );

   279   

   280       // set up the offscreen bitmap

   281       iOffScreenBitmap = new ( ELeave ) CFbsBitmap();  

   282   

   283       User::LeaveIfError( iOffScreenBitmap->Create( Rect().Size(), EColor16MU/*displaymode*/ ) );

   284   

   285       PRINT1( _L("Camera => CCamPreCaptureContainerBase::BaseConstructL disp mode (%d)"), displaymode )

   286       iBitmapDevice = CFbsBitmapDevice::NewL( iOffScreenBitmap );

   287       User::LeaveIfError( iBitmapDevice->CreateContext( iBitmapGc ) );

   288       }

   289 

   290   iRect = ViewFinderFrameRect();

   291   // if using direct viewfinding pass Rect to control

   292 

   293 

   294   if ( iController.UiConfigManagerPtr() && 

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

   296       {

   297       // Check whether we should be showing the reticule.

   298       // NOTE: This will only be showed in still, not video views

   299       iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   300       }

   301 

   302   // Setup viewfinder grid

   303   InitVfGridL( iRect );

   304 

   305   // Do not construct battery pane controller, if secondary camera is in use

   306   if ( iController.ActiveCamera() != ECamActiveCameraSecondary || 

   307        appUi->IsQwerty2ndCamera() ) 

   308     {

   309     iBatteryPaneController = CCamBatteryPaneController::NewL( 

   310                              *this, ETrue);  

   311     }

   312     // Make sure fixed toolbar is on top of this window

   313     DrawableWindow()->SetOrdinalPosition( KCamPreCaptureWindowOrdinalPos );

   314 

   315   iController.SetViewfinderWindowHandle( &Window() );

   316   appUi->SetViewFinderInTransit(EFalse);

   317   iController.StartIdleTimer();

   318 

   319   if (appUi->StartupLogoController())

   320     {

   321     TRAP_IGNORE(iStartupLogo = CCamStartupLogo::NewL(*appUi->StartupLogoController(), aRect));

   322     }

   323 

   324   // Capture button container  

   325   if ( iController.UiConfigManagerPtr()->IsCustomCaptureButtonSupported() &&

   326        iController.IsTouchScreenSupported() )

   327       {

   328       TRect rect = Rect();

   329       TPoint center( rect.Center() );

   330       TRect captureRect;

   331       captureRect.SetRect( center.iX   - KCaptureButtonSize.iWidth/2,

   332                            rect.iBr.iY - KCaptureButtonSize.iHeight - KCaptureButtonYDelta, 

   333                            center.iX   + KCaptureButtonSize.iWidth/2,

   334                            rect.iBr.iY - KCaptureButtonYDelta  );

   335       captureRect.Grow( KAdditionalArea );

   336 

   337       TCamCameraMode mode = ECamControllerImage;

   338       if ( iView.Id() == TUid::Uid( ECamViewIdVideoPreCapture ) )

   339           {

   340           mode = ECamControllerVideo;

   341           }

   342       iCaptureButtonContainer = CCamCaptureButtonContainer::NewL( iController, iView, 

   343                                                                   *this, captureRect, 

   344                                                                   mode );

   345       }

   346 

   347   PRINT( _L("Camera <= CCamPreCaptureContainerBase::BaseConstructL ") );

   348   }

   349 

   350 // ---------------------------------------------------------------------------

   351 // CCamPreCaptureContainerBase::CCamPreCaptureContainerBase

   352 // C++ constructor

   353 // ---------------------------------------------------------------------------

   354 //

   355 CCamPreCaptureContainerBase::CCamPreCaptureContainerBase(

   356         CCamAppController& aController,

   357         CAknView& aView )

   358   : CCamContainerBase( aController, aView ),   

   359     iDisableRedraws( EFalse )

   360   {

   361   }

   362 

   363 // ---------------------------------------------------------------------------

   364 // CCamPreCaptureContainerBase::ZoomTimerCallback

   365 // Callback for Zoom Pane timer

   366 // ---------------------------------------------------------------------------

   367 //

   368 TInt CCamPreCaptureContainerBase::ZoomTimerCallback( TAny* aObject )

   369     {

   370     CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

   371     cont->ZoomTimerTick();

   372     return KErrNone;

   373     }

   374 

   375 // ---------------------------------------------------------------------------

   376 // CCamPreCaptureContainerBase::ReticuleTimerCallback

   377 // Callback for flashing of the focus reticule

   378 // ---------------------------------------------------------------------------

   379 //

   380 TInt CCamPreCaptureContainerBase::ReticuleTimerCallback( TAny* aObject )

   381     {

   382     CCamPreCaptureContainerBase* cont = static_cast< CCamPreCaptureContainerBase* >( aObject );

   383     cont->iReticuleFlashOn = !cont->iReticuleFlashOn;

   384 

   385     // This is where we force a redraw of the reticule, if we are using

   386     // Direct Viewfinding.  However, if we are in burst mode, we must

   387     // use Bitmap Viewfinding, so only draw reticule if NOT in burst mode

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

   389     if ( appUi && appUi-> IsDirectViewfinderActive() )

   390         {

   391         cont->DrawDeferred();

   392         }

   393     return KErrNone;

   394     }

   395     

   396 

   397 // ---------------------------------------------------------------------------

   398 // CCamPreCaptureContainerBase::ShowZoomPaneWithTimer

   399 // Makes Zoom Pane visible for the period of the pane timer.

   400 // ---------------------------------------------------------------------------

   401 //

   402 void CCamPreCaptureContainerBase::ShowZoomPaneWithTimer()

   403     {

   404     __ASSERT_DEBUG( iZoomTimer, CamPanic( ECamPanicNullPointer ) );

   405     __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );  

   406     __ASSERT_DEBUG( iSidePane, CamPanic( ECamPanicNullPointer ) ); 

   407 

   408     PRINT(_L("Camera => CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

   409 

   410     // If already active, cancel the timer

   411     if ( iZoomTimer->IsActive() )

   412         {    

   413         iZoomTimer->Cancel();

   414         }

   415 

   416     iZoomTimer->Start( KZoomPanelTimeout, KZoomPanelTimeout, TCallBack( ZoomTimerCallback , this) );

   417     

   418     iZoomPane->MakeVisible( ETrue, ETrue );

   419 

   420     PRINT(_L("Camera <= CCamPreCaptureContainerBase::ShowZoomPaneWithTimer"));    

   421     }

   422 

   423 // ---------------------------------------------------------------------------

   424 // CCamPreCaptureContainerBase::ZoomTimerTick

   425 // Called as a result of the Zoom Pane timer expiring, switches side panes

   426 // to hide the Zoom pane.

   427 // ---------------------------------------------------------------------------

   428 //

   429 void CCamPreCaptureContainerBase::ZoomTimerTick()

   430     {

   431     PRINT(_L("Camera => CCamPreCaptureContainerBase::ZoomTimerTick")); 

   432     // Cancel the (potentially) recurring timer

   433     iZoomTimer->Cancel();

   434 

   435     // If zooming is still in progress (this happens if the zoom key has

   436     // been held down longer than the zoom pane timer), keep the pane

   437     // visible

   438     if ( iZoomPane->IsCurrentlyZooming() )

   439         {

   440         iZoomTimer->Start( KZoomPanelTimeout,

   441                            KZoomPanelTimeout, 

   442                            TCallBack( ZoomTimerCallback , this) );

   443         }

   444     else

   445         {

   446         // Make Indicator Pane visible again and hide the ZoomPane

   447         iZoomPane->MakeVisible( EFalse, ETrue );

   448         

   449         // background needs redrawing behind zoom pane

   450         iRedrawPaneBackground = ETrue;

   451         }

   452     PRINT(_L("Camera <= CCamPreCaptureContainerBase::ZoomTimerTick")); 

   453     }

   454 

   455 // ----------------------------------------------------

   456 // CCamPreCaptureContainerBase::OfferKeyEventL

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

   458 // keys to child control(s).

   459 // ----------------------------------------------------

   460 //

   461 TKeyResponse 

   462 CCamPreCaptureContainerBase::OfferKeyEventL( const TKeyEvent& aKeyEvent,

   463                                                    TEventCode aType )

   464     {         

   465     PRINT2( _L("Camera => CCamPreCaptureContainerBase::OfferKeyEventL type %d) scan code (%d)"), aType, aKeyEvent.iScanCode )

   466 

   467 #ifdef CAMERAAPP_PERFORMANCE_MEASUREMENT

   468     // Log event only if this is the first capture key press and we are in correct state

   469     TCamCaptureOperation operation = iController.CurrentOperation();

   470 

   471     TBool isCaptureKeyForUs  = (IsCaptureKeyL( aKeyEvent, aType )

   472             && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

   473 

   474     TBool isOperationStateOk = (ECamNoOperation == operation);

   475     if( isCaptureKeyForUs && isOperationStateOk )

   476         { 

   477         PERF_EVENT_START_L1( EPerfEventKeyToCapture );  

   478         }

   479 #endif      

   480 

   481     TBool isCaptureKeyForSymbTrace  = (IsCaptureKeyL( aKeyEvent, aType )

   482             && ( EEventKeyDown == aType && 0 == aKeyEvent.iRepeats ) );

   483     if( isCaptureKeyForSymbTrace )

   484         {

   485         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL Symbian Traces Active") );

   486         OstTrace0( CAMERAAPP_PERFORMANCE, DUP7_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHUTTER_RELEASE_LAG 1" );

   487         OstTrace0( CAMERAAPP_PERFORMANCE, DUP5_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_CAPTURE_START 1" ); //CCORAPP_CAPTURE_START_START

   488         if ( iFocusState != EFocusStateFocusing )

   489             {

   490             OstTrace0( CAMERAAPP_PERFORMANCE, CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_SNAPSHOT 1" );   //CCORAPP_SHOT_TO_SNAPSHOT_START

   491             OstTrace0( CAMERAAPP_PERFORMANCE, DUP1_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SNAPSHOT 1" );  //CCORAPP_PRI_SHOT_TO_SNAPSHOT_START

   492             OstTrace0( CAMERAAPP_PERFORMANCE, DUP2_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SAVE 1" );  //CCORAPP_PRI_SHOT_TO_SAVE_START

   493             OstTrace0( CAMERAAPP_PERFORMANCE, DUP3_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SHOT_TO_SHOT 1" );  //CCORAPP_PRI_SHOT_TO_SHOT_START

   494             OstTrace0( CAMERAAPP_PERFORMANCE, DUP4_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_APP_SHOT_TO_STILL 1" ); //CCORAPP_SHOT_TO_STILL_START

   495             OstTrace0( CAMERAAPP_PERFORMANCE, DUP6_CCAMPRECAPTURECONTAINERBASE_OFFERKEYEVENTL, "e_CAM_PRI_SERIAL_SHOOTING 1" );   //CCORAPP_PRI_SERIAL_SHOOTING_START

   496             }

   497         }

   498 

   499     iController.StartIdleTimer();

   500     if( aType == EEventKeyUp )

   501         {

   502         iController.SetDemandKeyRelease( EFalse ); 

   503         }

   504 

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

   506 	__ASSERT_DEBUG(appUi, CamPanic(ECamPanicNullPointer) );

   507     if ( appUi->CheckCourtesyKeyEventL( aKeyEvent, aType, ETrue ) == EKeyWasConsumed )

   508         {

   509         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL courtesy key") );

   510         return EKeyWasConsumed;

   511         }

   512 

   513     // If a control has the focus, give it the first opportunity to

   514     // process the key event

   515 

   516     if( iActivePalette 

   517             && iActivePalette->CoeControl()

   518             && iActivePalette->CoeControl()->OfferKeyEventL(aKeyEvent,aType) == EKeyWasConsumed )

   519         {

   520         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL AP consumed") );

   521         return EKeyWasConsumed;

   522         }

   523 

   524     // The key press has not been handled by a visible control

   525     // so will be processed by the container.

   526 

   527     // Handle Zoom in key if we are not saving video

   528     // and if toolbar extension is not visible

   529     PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL B") )

   530     if ( IsZoomKeyL( aKeyEvent, aType ) 

   531             && ECamCompleting != iController.CurrentOperation() 

   532             && !iController.CurrentlySavingVideo()

   533             && !appUi->IsSecondCameraEnabled()

   534             && !appUi->IsToolBarExtensionVisible() )

   535         {       

   536         // Offer the key event to the zoom pane/model

   537         TKeyResponse resp = iZoomPane->OfferKeyEventL( aKeyEvent, aType );

   538 

   539         // If it was consumed, we need to keep the zoom pane visible

   540         if ( resp == EKeyWasConsumed )

   541             {

   542             ShowZoomPaneWithTimer();

   543             }

   544         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Zoom key") );    

   545         return resp;

   546         }

   547 

   548     else if ( EEventKey == aType

   549             && EKeyOK    == aKeyEvent.iCode

   550             && 0         == aKeyEvent.iRepeats )

   551         {

   552         TBool MSKCapture(EFalse);

   553         if ( !appUi->IsToolBarVisible() && aKeyEvent.iScanCode == EStdKeyDevice3 )

   554             {

   555             MSKCapture = ETrue;

   556             }

   557         if( appUi->ActiveCamera() == ECamActiveCameraPrimary

   558                 && !MSKCapture )

   559             {

   560             // AP needs to handle this

   561             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL Ok key") );    

   562             return EKeyWasNotConsumed;

   563             }

   564         }

   565 

   566     // Handle right and left navi keys. 

   567     // Each product defines the behaviour that is mapped to these keys.        

   568     else if ( EEventKey == aType

   569             && ( EStdKeyRightArrow == aKeyEvent.iScanCode

   570                     || EStdKeyLeftArrow  == aKeyEvent.iScanCode ) )

   571         {

   572         if ( HandleLeftRightNaviKeyL( aKeyEvent, aType ) == EKeyWasConsumed )

   573             {

   574             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL left/right navi") );    

   575             return EKeyWasConsumed;

   576             }

   577         }

   578 

   579     else

   580         {

   581         // empty else statement to remove LINT error

   582         }

   583 

   584     TBool captureKey = IsCaptureKeyL( aKeyEvent, aType );

   585 

   586     // Stop any zooming activity if capture key detected

   587     if ( captureKey )

   588         {

   589         PrepareForCapture();

   590         }

   591     TBool viewFinderRunning = iReceivedVfFrame;

   592     if ( iController.UiConfigManagerPtr() &&

   593            ( iController.UiConfigManagerPtr()->

   594                IsDSAViewFinderSupported( ETrue ) &&

   595                !appUi->IsSecondCameraEnabled() ) ||

   596            ( iController.UiConfigManagerPtr()->

   597                IsDSAViewFinderSupported( EFalse ) &&

   598                appUi->IsSecondCameraEnabled() ) )

   599         {

   600         viewFinderRunning = appUi->IsDirectViewfinderActive();

   601         }

   602 

   603     TBool shutterKey = IsShutterKeyL( aKeyEvent, aType );

   604     TBool interruptKey = captureKey;

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

   606             iController.UiConfigManagerPtr() && 

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

   608         {

   609         interruptKey = shutterKey;

   610         }

   611 

   612     if(iController.IsProcessingCapture() 

   613             // && appUi->CurrentCaptureMode() == ECamCaptureModeStill 

   614             && ECamControllerImage == iController.CurrentMode()

   615             && EEventKeyDown == aType

   616             && interruptKey

   617             && appUi->ShowPostCaptureView()

   618             && !appUi->IsBurstEnabled() 

   619             && !appUi->SelfTimerEnabled()) 

   620         {

   621         iController.SetCaptureKeyPressedWhileImageSaving(ETrue);

   622         PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL 2nd press of capturekey") )

   623         return EKeyWasConsumed;

   624 

   625         }

   626     // Check if the key is a shutter key and...

   627     if ( shutterKey && viewFinderRunning )

   628         {

   629         if ( EKeyWasConsumed == HandleShutterKeyEventL( aKeyEvent, aType ) )

   630             {

   631             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL shutter key") );    

   632             return EKeyWasConsumed;

   633             }

   634         }

   635     else if ( captureKey             // Capture key event...

   636             && EEventKeyDown == aType // ...it's a key down event and

   637             && viewFinderRunning     // ...the viewfinder is running

   638             && !iController.Busy()    // CamCameraController is not busy.

   639             && !iController.IsDemandKeyRelease() ) // ...and no need to wait key up 

   640         {

   641         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key down") )

   642         if ( HandleCaptureKeyEventL( aKeyEvent ) == EKeyWasConsumed )

   643             {

   644             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL capture key handled") )

   645             return EKeyWasConsumed;

   646             }

   647         }         

   648     else if ( captureKey && aType == EEventKeyUp )

   649         {      

   650         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. [KEYS] capture key up") )

   651         if ( iController.SequenceCaptureInProgress()  // actively capturing or   

   652                 || appUi->IsBurstEnabled()                  // burst is enabled (for if focusing)

   653         )

   654             {

   655             if ( appUi->CurrentBurstMode() == ECamImageCaptureTimeLapse )

   656                 {

   657                 PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. timelapse mode, update CBA") )

   658                 // if this is a timelapse capture then set the softkeys to blank/cancel.

   659                 // The next shutter press will stop the capture.

   660                 TRAP_IGNORE( static_cast<CCamPreCaptureViewBase*>( &iView )->UpdateCbaL() );

   661                 }

   662             else

   663                 {

   664                 if ( !appUi->SelfTimerEnabled() )

   665                     {

   666 

   667                     if ( !iController.AllSnapshotsReceived() && (iController.CurrentCapturedCount() >= 1) )

   668                         {   		

   669                         PRINT( _L("Camera <> CCamPreCaptureContainerBase::OfferKeyEventL .. burst mode, soft stop burst..") )

   670                         // burst ongoing, still receiving snapshots, end it as soon as possible.

   671                         iController.SetKeyUp( ETrue );

   672                         iController.SoftStopBurstL();

   673                         }

   674                     else 

   675                         {

   676                         // ignore keypress, all snapshot received and processing image data

   677                         // processing only stopped from softkey

   678                         }

   679                     }

   680                 }

   681 

   682             PRINT( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL .. capture key up handled") )

   683             return EKeyWasConsumed;

   684             }

   685         else

   686             {

   687             UpdateCaptureButton();

   688             }

   689         iController.HandlePendingHdmiEvent();

   690         }

   691     else 

   692         {

   693         // remove Lint warning                

   694         }

   695 

   696     TKeyResponse response = CCamContainerBase::OfferKeyEventL( aKeyEvent, aType );

   697 

   698     PRINT1( _L("Camera <= CCamPreCaptureContainerBase::OfferKeyEventL, return %d"), response )

   699     return response;

   700     }

   701 

   702 

   703 // ---------------------------------------------------------

   704 // CCamPreCaptureContainerBase::HandleControllerEventL

   705 // Handles zoom events from the Controller

   706 // ---------------------------------------------------------

   707 //

   708 void 

   709 CCamPreCaptureContainerBase

   710 ::HandleControllerEventL( TCamControllerEvent aEvent, 

   711                           TInt                /*aError*/ )

   712   {

   713   PRINT1(_L("Camera => CCamPreCaptureContainerBase::HandleControllerEventL(%d)"), aEvent );

   714 

   715   __ASSERT_DEBUG( iZoomPane, CamPanic( ECamPanicNullPointer ) );

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

   717 

   718   switch( aEvent )

   719     {

   720     // ---------------------------------------------------

   721     case ECamEventSaveCancelled:

   722       {

   723       // clear the side pane after saving images dialog is dismissed

   724       ForceSideZoomPaneDraw();

   725       break;

   726       }

   727     // ---------------------------------------------------

   728     case ECamEventCameraChanged:

   729       {      

   730       SetResolutionIndicator();

   731       break;

   732       }

   733 

   734     // ---------------------------------------------------

   735     case ECamEventCounterUpdated:

   736       {

   737       if ( iController.UiConfigManagerPtr() &&

   738            iController.UiConfigManagerPtr()->IsDSAViewFinderSupported() )

   739           {

   740           if( iPaneInUse == ECamPaneProgress && appUi && appUi->IsDirectViewfinderActive() )

   741             {

   742             ActivateGc();

   743             CWindowGc& gc = SystemGc();

   744             iNaviProgressBarControl->DrawProgressBar( gc );

   745             DeactivateGc();

   746             }  

   747           else if ( iPaneInUse == ECamPaneCounter && iController.SequenceCaptureInProgress() )

   748             {

   749             DrawDeferred();

   750             }

   751           else

   752             {

   753             // Lint

   754             }

   755           }

   756       break;

   757       }

   758     // ---------------------------------------------------

   759     case ECamEventOperationStateChanged:

   760       {

   761 	  UpdateCaptureButton();

   762 

   763       if( iController.IsAppUiAvailable() && iController.UiConfigManagerPtr()

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

   765         {

   766         // ReCheck if we have to draw the reticule.

   767         if ( ECamControllerImage == iController.CurrentMode() )

   768             {

   769             iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   770             HandleOperationStateChangeEventL();

   771             }

   772         }

   773       break;

   774       }

   775     // ---------------------------------------------------

   776     case ECamEventEngineStateChanged:

   777         {

   778         UpdateCaptureButton();

   779         

   780         PRINT1( _L("Camera <> Start mode indi blinking, op:%d"), iController.CurrentOperation() );

   781 

   782         if ( !iController.UiConfigManagerPtr()->IsCustomCaptureButtonSupported() 

   783                 && !iController.EngineRequestsPending()

   784                 && iController.TargetMode() == iController.CurrentMode()

   785                 && iController.CurrentOperation() == ECamNoOperation 

   786                 && !iBlinkResolutionIndicator )

   787             {

   788             PRINT( _L("Camera <> mode indi blinking - starting timers") );

   789             if ( !iIndBlinkTimer )

   790                 {

   791                 iIndBlinkTimer = CPeriodic::NewL( EPriorityLess );

   792                 }

   793             else 

   794                 {

   795                 iIndBlinkTimer->Cancel();            

   796                 }

   797             

   798             iToggleCountdown = 2 * KNumberOfBlinks;

   799             iBlinkModeIndicator = ETrue;          

   800             iIndBlinkTimer->Start( KIndicatorBlinkDelay,

   801                                    KIndicatorBlinkDelay,

   802                                    TCallBack( IndicatorVisible, this) );

   803             

   804             iDrawIndicator = ETrue;

   805             }

   806         break;

   807         }

   808     // ---------------------------------------------------

   809     case ECamEventExitRequested:

   810       {

   811       iShuttingDown = ETrue;                        

   812       break;

   813       }

   814     // ---------------------------------------------------

   815     case ECamEventRecordComplete:

   816       {

   817       iResolutionIndicators[iCurrentIndicator]->CancelOverridePosition();

   818       break;

   819       }    

   820     // ---------------------------------------------------

   821     // Scene has changed

   822     case ECamEventSceneStateChanged:

   823       {

   824       PRINT(_L("Camera <> CCamPreCaptureContainerBase::HandleControllerEventL ECamEventSceneStateChanged"));

   825       if ( iController.UiConfigManagerPtr() && 

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

   827         {

   828         // Scene state has changed, re-check whether we should 

   829         // be showing the reticule

   830         iPhotoSceneUsesReticule = !iController.CurrentSceneHasForcedFocus();

   831         }

   832       ResetVFGridVisibility();

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

   834       break;

   835       }

   836     // ---------------------------------------------------

   837     case ECamEventImageData:

   838         {

   839         UpdateBurstProcessingTextL( iController.CapturedImages(), iController.CurrentCapturedCount() );

   840         break;

   841         }

   842     // ---------------------------------------------------  

   843     case ECamEventSliderClosed:

   844         {

   845         //Do nothing

   846         }

   847 		break;

   848     // ---------------------------------------------------

   849     case ECamEventCaptureComplete:

   850         {

   851         if ( !appUi->IsSecondCameraEnabled() 

   852               && iController.CurrentMode() == ECamControllerImage )

   853             {

   854             DrawNow();

   855             }

   856         break;

   857         }

   858     // ---------------------------------------------------

   859     case ECamEventFaceTrackingStateChanged:

   860         {

   861         if( iController.UiConfigManagerPtr()

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

   863             {

   864             // ReCheck if we have to draw the reticule.

   865             if ( ECamControllerImage == iController.CurrentMode() )

   866                 {

   867                 iPhotoSceneUsesReticule = 

   868                     !iController.CurrentSceneHasForcedFocus();

   869                 }

   870             }

   871         }

   872     // ---------------------------------------------------        

   873     case ECamEventImageQualityChanged:

   874     case ECamEventVideoQualityChanged:

   875         if ( iBlinkResolutionIndicator ) 

   876             {

   877             iBlinkModeIndicator = EFalse;

   878         

   879             // Force the first blink to occur right away 

   880             iDrawIndicator = EFalse;

   881             DrawResolutionIndicator();

   882 

   883             // Update the resolution indicator icon to be used.

   884             SetResolutionIndicator();

   885 

   886             // Start the blinking timer

   887             if ( !iIndBlinkTimer )

   888                 {

   889                 iIndBlinkTimer = CPeriodic::NewL( EPriorityLess );

   890                 }

   891             else 

   892                 {

   893                 iIndBlinkTimer->Cancel();

   894                 }

   895 

   896             iToggleCountdown = 2 * KNumberOfBlinks;

   897             if ( ECamEventVideoQualityChanged == aEvent )

   898                 {

   899                 iToggleCountdown = 2 * KNumberOfBlinksVideo;

   900                 }

   901             PRINT( _L("Camera <> start timer to blink indicator") );

   902             iIndBlinkTimer->Start( KIndicatorBlinkDelay,

   903                                    KIndicatorBlinkDelay,

   904                                    TCallBack( IndicatorVisible, this) );

   905 

   906             // Force the first blink to occur right away 

   907             iDrawIndicator = ETrue;

   908             DrawResolutionIndicator();

   909 

   910             // Quality level has changed through pinch gesture

   911             // Reinitialise the viewfinder grid 

   912             if ( iVfGridDrawer )

   913                 {

   914                 delete iVfGridDrawer;

   915                 iVfGridDrawer = NULL;

   916             

   917                 TRect rect = ViewFinderFrameRect();

   918                 InitVfGridL( rect );

   919                 }

   920             }

   921         else

   922             {

   923             if ( iIndBlinkTimer )

   924                 iIndBlinkTimer->Cancel();

   925             }

   926         break; 

   927     // ---------------------------------------------------

   928     default:

   929       {

   930       // Other events => no action.

   931       break;

   932       }

   933     // ---------------------------------------------------

   934     }

   935   PRINT(_L("Camera <= CCamPreCaptureContainerBase::HandleControllerEventL"));

   936   }

   937 

   938 // ---------------------------------------------------------

   939 // CCamPreCaptureContainerBase::HandleForegroundEvent

   940 // Handles change of app foreground state

   941 // ---------------------------------------------------------

   942 //

   943 void CCamPreCaptureContainerBase::HandleForegroundEventL( TBool aForeground )

   944     {

   945     PRINT1( _L( "Camera => CCamPreCaptureContainerBase::HandleForegroundEventL %d" ), aForeground );            

   946     if ( aForeground )

   947         {

   948 /*#ifndef __WINS__

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

   950         if( appUi->IsInCallSend() )

   951             {

   952             // force side pane to update

   953             appUi->SidePane()->SetInitialState();

   954             }

   955 #endif*/      

   956         // Check if we are on a non-standard zoom level.  Also checks if previous 

   957         // view was PostCapture or settings, if so, we dont want to show the zoom

   958         // pane either 

   959         if ( iZoomPane->ZoomValue() != 0  &&

   960              !iZoomPane->IsResetPending() &&

   961              iPrevViewId != ECamViewIdStillPostCapture &&

   962              iPrevViewId != ECamViewIdVideoPostCapture &&

   963              iPrevViewId != ECamViewIdPhotoSettings &&

   964              iPrevViewId != ECamViewIdVideoSettings )

   965             {

   966             // If we have moved to the foreground and need to show the zoom level.

   967             ShowZoomPaneWithTimer();

   968             }            

   969 

   970         ResetVFGridVisibility();

   971         }

   972     else    

   973         { // Background

   974         if ( iIndBlinkTimer )

   975             {

   976             iIndBlinkTimer->Cancel();

   977             iDrawIndicator = ETrue;

   978             }

   979         iReceivedVfFrame = EFalse;

   980 

   981         // Cancel timer if we're losing focus

   982         iZoomTimer->Cancel();  

   983         

   984         if ( iController.IsAppUiAvailable() && !iShuttingDown )

   985             {

   986             iSidePane->MakeVisible( ETrue );

   987             iZoomPane->MakeVisible( EFalse, EFalse );

   988             

   989             // Will stop any ongoing zoom

   990             iZoomPane->HandleForegroundEvent( aForeground );

   991             }

   992         

   993         // Update the view ID for when we come back.

   994         TCamAppViewIds viewId = static_cast<TCamAppViewIds>( iView.Id().iUid );

   995         SetPreviousViewId( viewId );

   996         }

   997     PRINT( _L( "Camera <= CCamPreCaptureContainerBase::HandleForegroundEventL" ) );        

   998     }

   999 

  1000 

  1001 // -----------------------------------------------------------------------------

  1002 // HandleAppEvent <<virtual>>

  1003 //

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 void 

  1007 CCamPreCaptureContainerBase::HandleAppEvent( const TCamAppEvent& aEvent )

  1008   {

  1009   PRINT( _L("Camera => CCamPreCaptureContainerBase::HandleAppEvent") );

  1010 

  1011   switch( aEvent )

  1012     {

  1013     case ECamAppEventFocusGained:

  1014       {

  1015       // Clear non-fading flag. It may have been set when showing a note

  1016       // in CCamAppUi::ShowErrorNoteL().

  1017 

  1018       CEikMenuBar* menuBar = iView.MenuBar();

  1019       TBool menuOpened( EFalse );

  1020       if ( menuBar )

  1021           {

  1022           menuOpened = menuBar->IsDisplayed();

  1023           }

  1024       

  1025       RDrawableWindow* window = DrawableWindow();

  1026       if ( window && !menuOpened )

  1027           {

  1028           window->SetNonFading( EFalse );

  1029           }

  1030 

  1031       if( iBatteryPaneController )

  1032         iBatteryPaneController->Pause( EFalse );

  1033       break;

  1034       }

  1035     case ECamAppEventFocusLost:

  1036       {

  1037       if( iBatteryPaneController )

  1038         iBatteryPaneController->Pause( ETrue );

  1039       

  1040 	  if ( iIndBlinkTimer )

  1041           {

  1042           iIndBlinkTimer->Cancel();

  1043           iDrawIndicator = ETrue;

  1044           }

  1045 		  

  1046       break;

  1047       }

  1048     default:

  1049       {

  1050       break;

  1051       }

  1052     }

  1053 

  1054   PRINT( _L("Camera <= CCamPreCaptureContainerBase::HandleAppEvent") );

  1055   }

  1056 

  1057 

  1058 // ----------------------------------------------------

  1059 // CCamPreCaptureContainerBase::MakeVisible

  1060 // Handles a change to the controls visibility

  1061 // ----------------------------------------------------

  1062 //

  1063 void CCamPreCaptureContainerBase::MakeVisible( TBool aVisible )

  1064   {

  1065   PRINT1( _L("Camera => CCamPreCaptureContainerBase::MakeVisible, visible:%d"), aVisible );

  1066 

  1067   CCamContainerBase::MakeVisible( aVisible );

  1068 

  1069   PRINT ( _L("Camera <= CCamPreCaptureContainerBase::MakeVisible") );

  1070   }

  1071 

  1072 // ---------------------------------------------------------

  1073 // CCamPreCaptureContainerBase::Draw

  1074 // Draw control

  1075 // ---------------------------------------------------------

  1076 //

  1077 void 

  1078 CCamPreCaptureContainerBase::Draw( const TRect& /*aRect*/ ) const

  1079    {

  1080    PRINT( _L( "Camera => CCamPreCaptureContainerBase::Draw" ) );    

  1081    

  1082    CWindowGc& gc = SystemGc(); 

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

  1084   

  1085    // Is direct viewfinding active

  1086     TBool directVf = appUi ? appUi->IsDirectViewfinderActive() : EFalse;

  1087                  

  1088    // Using bitmap viewfinding and a frame is available

  1089    TBool bitmapFrame = !directVf && iReceivedVfFrame && iViewFinderBackup;

  1090 

  1091    if( iCamOrientation != ECamOrientationCamcorder && 

  1092        iCamOrientation != ECamOrientationCamcorderLeft && 

  1093     !( iController.UiConfigManagerPtr() && 

  1094        iController.IsDirectScreenVFSupported( EFalse ) && 

  1095        iCamOrientation == ECamOrientationPortrait ) )

  1096       { 

  1097       // Using secondary camera 

  1098       }

  1099    else  if( !bitmapFrame )  

  1100        {  

  1101        // Using primary camera and direct viewfinding is active, there's no bitmap

  1102        // viewfinder frame available, or the frame doesn't cover whole screen

  1103        // => Paint the background with background color / color key

  1104                             

  1105        gc.SetPenStyle( CGraphicsContext::ENullPen );    

  1106     

  1107        if( iController.UiConfigManagerPtr() && directVf )

  1108            {    

  1109            gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

  1110            gc.SetBrushColor( TRgb::Color16MA( 0 ) );

  1111            }

  1112        else

  1113            {

  1114            // Use the background color

  1115            gc.SetBrushColor( TRgb( KCamPrecaptureBgColor ) );   

  1116            }

  1117             

  1118        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

  1119        gc.DrawRect( Rect() );          

  1120        }

  1121       else

  1122       	{

  1123       	}

  1124    if ( bitmapFrame )

  1125       {

  1126       // Draw the current bitmap viewfinder frame  

  1127       DrawFrameNow( gc, iViewFinderBackup );

  1128       }          

  1129 

  1130    gc.Reset();        

  1131    if( directVf 

  1132    && !iController.IsViewFinding() )

  1133        {

  1134        return;