camerauis/cameraapp/generic/src/CamZoomPane.cpp
changeset 19 d9aefe59d544
parent 3 8b2d6d0384b0
child 21 fa6d9f75d6a6
child 28 3075d9b614e6
equal deleted inserted replaced
3:8b2d6d0384b0 19:d9aefe59d544
     1 /*
       
     2 * Copyright (c) 2007-2009 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:  Camera Zoom Pane; shows the zoom level graphically*
       
    15 */
       
    16 
       
    17 
       
    18 
       
    19 // INCLUDE FILES
       
    20 #include <e32base.h>
       
    21 #include <e32std.h>
       
    22 #include <coemain.h>
       
    23 #include <eikenv.h>
       
    24 #include <cameraapp.mbg>
       
    25 #include <eikappui.h>    // For CCoeAppUiBase
       
    26 #include <eikapp.h>      // For CEikApplication
       
    27 #include <barsread.h>    // resource reader
       
    28 #include <AknIconUtils.h>
       
    29 #include <centralrepository.h>
       
    30 #include <layoutmetadata.cdl.h>         
       
    31 #include <aknlayoutscalable_apps.cdl.h> 
       
    32 #include <touchfeedback.h> 
       
    33 #include <cameraapp.rsg>
       
    34 #include <vgacamsettings.rsg>
       
    35 #include "CameraUiConfigManager.h"
       
    36 #include "CamPanic.h"    // Panic codes
       
    37 #include "CamUtility.h"
       
    38 #include "CamZoomPane.h"
       
    39 #include "CamZoomModel.h"
       
    40 #include "CamAppUi.h"
       
    41 #include "CamBmpRotatorAo.h"
       
    42 #include "CameraappPrivateCRKeys.h"
       
    43 #include "CamTimer.h"
       
    44 
       
    45 
       
    46 // CONSTANTS
       
    47 const TInt KDivisorFactor = 10000;    // integer scaling factor to avoid the 
       
    48                                      // use of floating point arithmetic
       
    49 const TInt KTouchAreaExpansion = 35; // Pixels to grow touchable area                                    
       
    50 
       
    51 // ============================ MEMBER FUNCTIONS ===============================
       
    52 
       
    53 // -----------------------------------------------------------------------------
       
    54 // CCamZoomPane::CCamZoomPane
       
    55 // C++ default constructor can NOT contain any code, that
       
    56 // might leave.
       
    57 // -----------------------------------------------------------------------------
       
    58 //
       
    59 CCamZoomPane::CCamZoomPane( CCamAppController& aController, TBool aOverlayViewFinder )
       
    60     : iController( aController ),
       
    61       iOverlayViewFinder( aOverlayViewFinder )
       
    62     {
       
    63     }
       
    64 
       
    65 // -----------------------------------------------------------------------------
       
    66 // CCamZoomPane::ConstructL
       
    67 // Symbian 2nd phase constructor can leave.
       
    68 // -----------------------------------------------------------------------------
       
    69 //
       
    70 void CCamZoomPane::ConstructL()
       
    71     {
       
    72     PRINT( _L( "Camera => CCamZoomPane::ConstructL " ) );
       
    73     // Load the zoom pane orientation value from the Central Repository
       
    74  	CRepository* repository = CRepository::NewL( KCRUidCameraappSettings );        
       
    75  	TInt val = 0;
       
    76     TInt err = repository->Get( KCamCrZoomPaneOrientation, val );
       
    77 
       
    78     // If there is an error then assume standard (vertical) orientation
       
    79     if ( err != KErrNone )
       
    80         {
       
    81         iOrientation = EZPOrientationVertical;
       
    82         }
       
    83     else 
       
    84         {
       
    85         iOrientation = static_cast<TZPOrientation>( val );
       
    86         }
       
    87 #if !( defined(__WINS__) || defined(__WINSCW__) )
       
    88     // Get Central Repository key indicating if product uses volume keys for zoom
       
    89     err = repository->Get( KCamCrZoomUsingVolumeKeys, val );
       
    90 
       
    91     // If there is an error then assume volume keys not used
       
    92     if ( err != KErrNone )
       
    93         {
       
    94         iZoomUsingVolumeKeys = EFalse;
       
    95         }
       
    96     else 
       
    97         {
       
    98         iZoomUsingVolumeKeys = val;
       
    99         }
       
   100     
       
   101         iZoomUsingVolumeKeys = EFalse;
       
   102     
       
   103     // Get Central Repository key indicating if product uses navi-keys for zoom
       
   104     err = repository->Get( KCamCrZoomUsingNaviKeys, val );
       
   105 
       
   106     // If there is an error then assume navi-keys not used
       
   107     if ( err != KErrNone )
       
   108         {
       
   109         iZoomUsingNaviKeys = EFalse;
       
   110         }
       
   111     else 
       
   112         {
       
   113         iZoomUsingNaviKeys = val;
       
   114         }
       
   115 #else
       
   116     iZoomUsingVolumeKeys = EFalse;   
       
   117     iZoomUsingNaviKeys = ETrue;  
       
   118 #endif // !( defined(__WINS__) || defined(__WINSCW__) )       
       
   119         
       
   120     delete repository;
       
   121     repository = NULL;
       
   122         
       
   123     // Find the name and path of the MBM file for zoom pane bitmaps
       
   124     TFileName resFileName;
       
   125     CamUtility::ResourceFileName( resFileName );
       
   126     TPtrC resname = resFileName;
       
   127            
       
   128     // Create component bitmaps 
       
   129     AknIconUtils::CreateIconL( iIconZoomTop[0], 
       
   130                                iIconZoomTop[1], 
       
   131                                resname, 
       
   132                                EMbmCameraappQgn_indi_cam4_zoom_top, 
       
   133                                EMbmCameraappQgn_indi_cam4_zoom_top_mask );
       
   134 
       
   135     AknIconUtils::CreateIconL( iIconZoomMiddle[0], 
       
   136                                iIconZoomMiddle[1], 
       
   137                                resname, 
       
   138                                EMbmCameraappQgn_indi_cam4_zoom_middle, 
       
   139                                EMbmCameraappQgn_indi_cam4_zoom_middle_mask );
       
   140                             
       
   141     AknIconUtils::CreateIconL( iIconZoomBottom[0], 
       
   142                                iIconZoomBottom[1], 
       
   143                                resname, 
       
   144                                EMbmCameraappQgn_indi_cam4_zoom_bottom, 
       
   145                                EMbmCameraappQgn_indi_cam4_zoom_bottom_mask );   
       
   146         
       
   147     AknIconUtils::CreateIconL( iIconZoomMarker[0], 
       
   148                                iIconZoomMarker[1], 
       
   149                                resname, 
       
   150                                EMbmCameraappQgn_indi_cam4_zoom_marker, 
       
   151                                EMbmCameraappQgn_indi_cam4_zoom_marker_mask );
       
   152 
       
   153     AknIconUtils::CreateIconL( iIconZoomMarkerGray[0], 
       
   154                                iIconZoomMarkerGray[1], 
       
   155                                resname, 
       
   156                                EMbmCameraappQgn_indi_cam4_zoom_marker_selected, 
       
   157                                EMbmCameraappQgn_indi_cam4_zoom_marker_selected_mask );
       
   158 
       
   159     AknIconUtils::CreateIconL( iIconZoomMin[0], 
       
   160                                iIconZoomMin[1], 
       
   161                                resname, 
       
   162                                EMbmCameraappQgn_indi_cam4_zoom_min, 
       
   163                                EMbmCameraappQgn_indi_cam4_zoom_min_mask );
       
   164                                
       
   165     AknIconUtils::CreateIconL( iIconZoomMax[0], 
       
   166                                iIconZoomMax[1], 
       
   167                                resname, 
       
   168                                EMbmCameraappQgn_indi_cam4_zoom_max, 
       
   169                                EMbmCameraappQgn_indi_cam4_zoom_max_mask );   
       
   170 
       
   171     SizeChanged(); // Initialize layouts and set sizes   
       
   172     CamUtility::SetAlphaL( iIconZoomTop[0], iIconZoomTop[1] ); 
       
   173     CamUtility::SetAlphaL( iIconZoomMiddle[0], iIconZoomMiddle[1] ); 
       
   174     CamUtility::SetAlphaL( iIconZoomBottom[0], iIconZoomBottom[1] );  
       
   175     CamUtility::SetAlphaL( iIconZoomMarker[0], iIconZoomMarker[1] );  
       
   176     CamUtility::SetAlphaL( iIconZoomMarkerGray[0], iIconZoomMarkerGray[1] ); 
       
   177     CamUtility::SetAlphaL( iIconZoomMin[0], iIconZoomMin[1] ); 
       
   178     CamUtility::SetAlphaL( iIconZoomMax[0], iIconZoomMax[1] );  
       
   179     iIconZoomMarkerCurrent = iIconZoomMarker[0]; 
       
   180 
       
   181     // Retrieve product-specific information about zoom support
       
   182     CamUtility::GetPsiInt( ECamPsiVideoZoomSupport, iZoomSupport );
       
   183 
       
   184     // Retrieve the timing and step values for each of the zoom bar 
       
   185     // segments/modes eg Optical/Digital/Extended    
       
   186     TPckgBuf <TCamZoomLAF> pckg;
       
   187     CamUtility::GetPsiAnyL( ECamPsiZoomBarLAF, &pckg);
       
   188     iZoomLAF = pckg();
       
   189         
       
   190     // Register for notification of controller events
       
   191     iController.AddControllerObserverL( this );    
       
   192     
       
   193     iModel = CCamZoomModel::NewL( iController, this );
       
   194     iFeedback = MTouchFeedback::Instance();   
       
   195 
       
   196     PRINT( _L( "Camera <= CCamZoomPane::ConstructL " ) );
       
   197     }
       
   198 
       
   199 // -----------------------------------------------------------------------------
       
   200 // CCamZoomPane::LoadResourceDataL()
       
   201 // Reads in all information needed from resources
       
   202 // -----------------------------------------------------------------------------
       
   203 //
       
   204 void CCamZoomPane::LoadResourceDataL()
       
   205     {
       
   206     PRINT( _L( "Camera => CCamZoomPane::LoadResourceDataL " ) );
       
   207     ReadLayoutL();
       
   208     PRINT( _L( "Camera <= CCamZoomPane::LoadResourceDataL " ) );
       
   209     }
       
   210 
       
   211 // -----------------------------------------------------------------------------
       
   212 // CCamZoomPane::UnloadResourceData()
       
   213 // Frees all dynamic resources allocated in LoadResourceDataL
       
   214 // -----------------------------------------------------------------------------
       
   215 //
       
   216 void CCamZoomPane::UnloadResourceData()
       
   217     {
       
   218     PRINT( _L( "Camera => CCamZoomPane::UnloadResourceData " ) );
       
   219     PRINT( _L( "Camera <= CCamZoomPane::UnloadResourceData " ) );
       
   220     }
       
   221     
       
   222 // -----------------------------------------------------------------------------
       
   223 // CCamZoomPane::ReloadResourceDataL()
       
   224 // Refreshes all resource-based information stored in the class
       
   225 // -----------------------------------------------------------------------------
       
   226 //
       
   227 void CCamZoomPane::ReloadResourceDataL()
       
   228     {
       
   229     PRINT( _L( "Camera => CCamZoomPane::ReloadResourceDataL " ) );
       
   230     UnloadResourceData();
       
   231     LoadResourceDataL();
       
   232     PRINT( _L( "Camera <= CCamZoomPane::ReloadResourceDataL " ) );
       
   233     }
       
   234 
       
   235 // -----------------------------------------------------------------------------
       
   236 // CCamZoomPane::NewL
       
   237 // Two-phased constructor.
       
   238 // -----------------------------------------------------------------------------
       
   239 //
       
   240 CCamZoomPane* CCamZoomPane::NewL( CCamAppController& aController,
       
   241                                   TBool aOverlayViewFinder )
       
   242     {
       
   243     PRINT( _L( "Camera => CCamZoomPane::NewL " ) );
       
   244     CCamZoomPane* self = new( ELeave ) CCamZoomPane ( aController, aOverlayViewFinder );
       
   245     CleanupStack::PushL( self );
       
   246     self->ConstructL();
       
   247     CleanupStack::Pop( self );
       
   248     PRINT( _L( "Camera <= CCamZoomPane::NewL " ) );
       
   249     return self;
       
   250     }
       
   251     
       
   252 // -----------------------------------------------------------------------------
       
   253 // CCamZoomPane::~CCamZoomPane
       
   254 // Destructor.
       
   255 // -----------------------------------------------------------------------------
       
   256 //
       
   257 CCamZoomPane::~CCamZoomPane()
       
   258     {
       
   259     PRINT( _L("Camera => ~CCamZoomPane" ))  
       
   260     iController.RemoveControllerObserver( this );
       
   261 
       
   262     delete iIconZoomTop[0];  
       
   263     delete iIconZoomMiddle[0];
       
   264     delete iIconZoomBottom[0];
       
   265     delete iIconZoomMarker[0];
       
   266     delete iIconZoomMarkerGray[0]; 
       
   267     delete iIconZoomMin[0];
       
   268     delete iIconZoomMax[0];
       
   269     delete iIconZoomTop[1];  
       
   270     delete iIconZoomMiddle[1];
       
   271     delete iIconZoomBottom[1];
       
   272     delete iIconZoomMarker[1];
       
   273     delete iIconZoomMarkerGray[1]; 
       
   274     delete iIconZoomMin[1];
       
   275     delete iIconZoomMax[1];
       
   276  
       
   277     delete iModel;
       
   278   
       
   279     if ( iRotatorAo &&
       
   280          iRotatorAo->IsActive() )
       
   281         {
       
   282         iRotatorAo->Cancel();
       
   283         }
       
   284     delete iRotatorAo;
       
   285 
       
   286 
       
   287     iZoomInKeys.Close();
       
   288     iZoomOutKeys.Close();
       
   289 
       
   290     PRINT( _L("Camera <= ~CCamZoomPane" ))  
       
   291     }
       
   292 
       
   293 // -----------------------------------------------------------------------------
       
   294 // CCamZoomPane::Draw
       
   295 // Draws the zoom pane
       
   296 // -----------------------------------------------------------------------------
       
   297 //
       
   298 void CCamZoomPane::Draw( CBitmapContext& aGc ) const
       
   299     {
       
   300     PRINT( _L( "Camera => CCamZoomPane::Draw " ) );
       
   301     if ( !iMaxZoom )
       
   302         {        
       
   303         PRINT( _L( "Camera <= CCamZoomPane::Draw not set up yet" ) );
       
   304         return; // Not set up yet
       
   305         }
       
   306         
       
   307     if ( !iOverlayViewFinder )
       
   308         {
       
   309         aGc.Clear( iZoomPaneRect );
       
   310         }
       
   311     
       
   312     DrawPlusMinus( aGc );
       
   313     DrawShaft( aGc );
       
   314     DrawThumb( aGc );    
       
   315     PRINT( _L( "Camera <= CCamZoomPane::Draw " ) );
       
   316     }
       
   317     
       
   318 // -----------------------------------------------------------------------------
       
   319 // CCamZoomPane::DrawPlusMinus
       
   320 // Draws the plus and minus icons
       
   321 // -----------------------------------------------------------------------------
       
   322 //    
       
   323 void CCamZoomPane::DrawPlusMinus( CBitmapContext& aGc ) const
       
   324     {    
       
   325     PRINT( _L( "Camera => CCamZoomPane::DrawPlusMinus " ) );
       
   326     aGc.BitBlt( iPlusPoint,  iIconZoomMax[0] );    
       
   327     aGc.BitBlt( iMinusPoint, iIconZoomMin[0] );   
       
   328     PRINT( _L( "Camera <= CCamZoomPane::DrawPlusMinus " ) );                 
       
   329     }
       
   330     
       
   331 // -----------------------------------------------------------------------------
       
   332 // CCamZoomPane::DrawShaft
       
   333 // Draws the shaft of the zoom pane
       
   334 // -----------------------------------------------------------------------------
       
   335 //    
       
   336 void CCamZoomPane::DrawShaft( CBitmapContext& aGc ) const  
       
   337     {
       
   338     PRINT( _L( "Camera => CCamZoomPane::DrawShaft " ) );
       
   339     aGc.BitBlt( iTopPoint,    iIconZoomTop[0] );
       
   340     aGc.BitBlt( iMiddlePoint, iIconZoomMiddle[0] );
       
   341     aGc.BitBlt( iBottomPoint, iIconZoomBottom[0] );
       
   342     PRINT( _L( "Camera <= CCamZoomPane::DrawShaft " ) );
       
   343     }
       
   344    
       
   345 // -----------------------------------------------------------------------------
       
   346 // CCamZoomPane::SetPoint
       
   347 // Sets the value of a point based on another point and an (optional) modifier value.
       
   348 // This was added to simplify the bar drawing code, so the changes based on orientation 
       
   349 // are (as much as possible) contained in this function
       
   350 // -----------------------------------------------------------------------------
       
   351 //    
       
   352 void 
       
   353 CCamZoomPane::SetPoint(       TPoint& aPoint, 
       
   354                         const TPoint& aOffset, 
       
   355                               TInt    aAdditional ) const
       
   356     {
       
   357     PRINT( _L( "Camera => CCamZoomPane::SetPoint " ) );
       
   358     if ( PaneOrientation() == EZPOrientationVertical )
       
   359         {
       
   360         aPoint.iY = aOffset.iY + aAdditional;
       
   361         }
       
   362     else
       
   363         {
       
   364         aPoint.iX = aOffset.iX - aAdditional;
       
   365         }
       
   366     PRINT( _L( "Camera <= CCamZoomPane::SetPoint " ) );
       
   367     }
       
   368     
       
   369 // -----------------------------------------------------------------------------
       
   370 // CCamZoomPane::PaneOrientation
       
   371 // Returns the current zoom pane orientation (taking into account whether this
       
   372 // should be forced or not if on secondary camera)
       
   373 // -----------------------------------------------------------------------------
       
   374 //        
       
   375 CCamZoomPane::TZPOrientation CCamZoomPane::PaneOrientation() const
       
   376     {
       
   377     PRINT( _L( "Camera => CCamZoomPane::PaneOrientation " ) );
       
   378     if ( iController.ActiveCamera() == ECamActiveCameraSecondary )
       
   379         {
       
   380         PRINT( _L( "Camera <= CCamZoomPane::PaneOrientation EZPOrientationVertical" ) );
       
   381         return EZPOrientationVertical;
       
   382         }
       
   383     else 
       
   384         {
       
   385         PRINT( _L( "Camera <= CCamZoomPane::PaneOrientation iOrientation" ) );
       
   386         return iOrientation;
       
   387         }
       
   388     }
       
   389     
       
   390 // -----------------------------------------------------------------------------
       
   391 // CCamZoomPane::DrawThumb
       
   392 // Draws the thumb of the zoom pane
       
   393 // -----------------------------------------------------------------------------
       
   394 //       
       
   395 void CCamZoomPane::DrawThumb( CBitmapContext& aGc ) const
       
   396     {   
       
   397     PRINT( _L( "Camera => CCamZoomPane::DrawThumb " ) );
       
   398     TPoint newThumbPos;                            
       
   399     // Knob bitmap has an empty area on the edge, thus it starts upper than top
       
   400     // of zoom slider 
       
   401     // topPointY is iTl.iY of knob bitmap when maximum zoom is used. 
       
   402     newThumbPos.iX = iZoomPaneRect.iTl.iX;        
       
   403         
       
   404     TInt pixelsPerStep = ( iMaxOffset * KDivisorFactor ) / (iMaxZoom+1);
       
   405     TInt pixelsFromBase;
       
   406     pixelsFromBase = ( iTrgZoom * pixelsPerStep );
       
   407     newThumbPos.iY = iTopPoint.iY + iMaxOffset -
       
   408              (pixelsFromBase + pixelsPerStep/2 +
       
   409               iIconZoomMarker[0]->SizeInPixels().iHeight * 
       
   410               KDivisorFactor / 2) / KDivisorFactor;                                                        
       
   411         
       
   412     aGc.BitBlt( newThumbPos, iIconZoomMarkerCurrent ); 
       
   413     PRINT( _L( "Camera <= CCamZoomPane::DrawThumb " ) );                   
       
   414     }
       
   415 
       
   416 // -----------------------------------------------------------------------------
       
   417 // CCamZoomPane::SetRect
       
   418 // Sets the rect that zoom pane is drawn into
       
   419 // -----------------------------------------------------------------------------
       
   420 //
       
   421 void CCamZoomPane::SetRect( TRect aRect )
       
   422     {
       
   423     PRINT( _L( "Camera => CCamZoomPane::SetRect " ) );
       
   424     iZoomPaneRect = aRect;
       
   425     PRINT( _L( "Camera <= CCamZoomPane::SetRect " ) );
       
   426     }
       
   427 
       
   428 // -----------------------------------------------------------------------------
       
   429 // CCamZoomPane::SetZoomRange
       
   430 // Specifies the range of values zoom supports
       
   431 // aMax should always be more than aMin. 
       
   432 // -----------------------------------------------------------------------------
       
   433 //
       
   434 TInt CCamZoomPane::SetZoomRange( TInt aMin, TInt aMax )
       
   435     {        
       
   436     PRINT( _L( "Camera => CCamZoomPane::SetZoomRange " ) );
       
   437     // The minimum value should always be less than the max.
       
   438     if ( aMin >= aMax ||
       
   439          aMin < 0 )
       
   440         {    
       
   441         PRINT( _L( "Camera <= CCamZoomPane::SetZoomRange KErrArgument" ) );
       
   442         return KErrArgument;
       
   443         }
       
   444 
       
   445     iMinZoom = aMin;
       
   446     iMaxZoom = aMax;
       
   447     PRINT( _L( "Camera <= CCamZoomPane::SetZoomRange " ) );
       
   448     return KErrNone;
       
   449     } 
       
   450 
       
   451 // -----------------------------------------------------------------------------
       
   452 // CCamZoomPane::SetZoomSteps
       
   453 // Sets the number of steps allowed in each category
       
   454 // -----------------------------------------------------------------------------
       
   455 //
       
   456 void CCamZoomPane::SetZoomSteps( TInt aOptSteps, TInt aStdSteps, TInt aExtSteps )
       
   457     {  
       
   458     PRINT( _L( "Camera => CCamZoomPane::SetZoomSteps " ) );      
       
   459     ASSERT( aOptSteps >= 0 && aStdSteps >= 0 && aExtSteps >= 0 );
       
   460     
       
   461     iOptSteps = aOptSteps;
       
   462     iStdSteps = aStdSteps;    
       
   463     iExtSteps = aExtSteps;
       
   464     PRINT( _L( "Camera <= CCamZoomPane::SetZoomSteps " ) );        
       
   465     }
       
   466     
       
   467 // -----------------------------------------------------------------------------
       
   468 // CCamZoomPane::SetZoomValue
       
   469 // Specifies the current level of Zoom.
       
   470 // -----------------------------------------------------------------------------
       
   471 //
       
   472 TInt CCamZoomPane::SetZoomValue( TInt aZoom )
       
   473     { 
       
   474     PRINT1( _L( "Camera => CCamZoomPane::SetZoomValue aZoom=%d" ), aZoom );
       
   475     if ( iController.UiConfigManagerPtr()->IsExtendedDigitalZoomSupported() )
       
   476         {
       
   477         // this may happen if in the extended zoom range
       
   478         // and we switch the extended range off - the
       
   479         // zoom value in the engine will be greater than
       
   480         // the max value allowed
       
   481         if ( aZoom > iMaxZoom )
       
   482             {
       
   483             aZoom = iMaxZoom;
       
   484             }        
       
   485         }
       
   486 
       
   487     // Check supplied value is within valid range
       
   488     if ( aZoom < iMinZoom || aZoom > iMaxZoom )
       
   489         {
       
   490         PRINT( _L( "Camera <= CCamZoomPane::SetZoomValue KErrArgument" ) );
       
   491         return KErrArgument;
       
   492         }
       
   493 
       
   494     iCurZoom = aZoom;
       
   495     iTrgZoom = aZoom;
       
   496 
       
   497     if ( iVisible )
       
   498         {
       
   499         // force redraw of zoom pane
       
   500         MakeVisible( ETrue, ETrue );
       
   501         }
       
   502 
       
   503     PRINT( _L( "Camera <= CCamZoomPane::SetZoomValue " ) );
       
   504     return KErrNone;
       
   505     }
       
   506 
       
   507 // -----------------------------------------------------------------------------
       
   508 // CCamZoomPane::ZoomValue
       
   509 // Returns the current zoom value (as the ZoomPane knows it)
       
   510 // -----------------------------------------------------------------------------
       
   511 //
       
   512 TInt CCamZoomPane::ZoomValue() const
       
   513     {   
       
   514     PRINT( _L( "Camera => CCamZoomPane::ZoomValue " ) );
       
   515     PRINT1( _L( "Camera <= CCamZoomPane::ZoomValue iCurZoom=%d" ), iCurZoom );
       
   516     return iCurZoom;
       
   517     }
       
   518 
       
   519 // -----------------------------------------------------------------------------
       
   520 // CCamZoomPane::IsZoomAtMinimum
       
   521 // Returns whether the current zoom value is the minimum zoom
       
   522 // -----------------------------------------------------------------------------
       
   523 //
       
   524 TBool CCamZoomPane::IsZoomAtMinimum() const
       
   525     {
       
   526     PRINT2(_L("Camera =><= CCamZoomPane::IsZoomAtMinimum iCurZoom = %d, iMinZoom = %d"), iCurZoom, iMinZoom);
       
   527     return iCurZoom == iMinZoom;
       
   528     }
       
   529     
       
   530 // -----------------------------------------------------------------------------
       
   531 // CCamZoomPane::OkToShowPane
       
   532 // Returns whether or not the Zoom Pane can currently be shown.
       
   533 // -----------------------------------------------------------------------------
       
   534 //
       
   535 TBool CCamZoomPane::OkToShowPane() const
       
   536     {    
       
   537     PRINT( _L( "Camera => CCamZoomPane::OkToShowPane " ) );
       
   538     // Are we currently recording video?
       
   539     if ( iRecordingVideo )
       
   540         {   
       
   541         // Are we allowed to zoom when recording video?
       
   542         if ( ( iZoomSupport & ECamZoomWhenRecord ) )
       
   543             {
       
   544             PRINT( _L( "Camera <= CCamZoomPane::OkToShowPane ETrue" ) );
       
   545             return ETrue;
       
   546             }
       
   547         else // If not allowed, return false
       
   548             {
       
   549             PRINT( _L( "Camera <= CCamZoomPane::OkToShowPane EFalse" ) );
       
   550             return EFalse;
       
   551             }
       
   552         }
       
   553 
       
   554     // If a sequence capture is in progress
       
   555     if ( iController.SequenceCaptureInProgress() )
       
   556         {
       
   557         PRINT( _L( "Camera <= CCamZoomPane::OkToShowPane EFalse" ) );
       
   558         return EFalse;
       
   559         }
       
   560         
       
   561     PRINT( _L( "Camera <= CCamZoomPane::OkToShowPane ETrue" ) );
       
   562     return ETrue;
       
   563     }
       
   564 
       
   565 // -----------------------------------------------------------------------------
       
   566 // CCamZoomPane::HandleControllerEventL
       
   567 // Handle controller events, specifically to find out if video is currently
       
   568 // being recorded.  Only called if Zooming while recording is NOT allowed
       
   569 // -----------------------------------------------------------------------------
       
   570 //
       
   571 void CCamZoomPane::HandleControllerEventL( TCamControllerEvent aEvent, 
       
   572                                            TInt                /*aError*/ )
       
   573     {
       
   574     PRINT( _L( "Camera => CCamZoomPane::HandleControllerEventL " ) );
       
   575     switch ( aEvent )
       
   576         {
       
   577         case ECamEventOperationStateChanged:
       
   578             {
       
   579             iRecordingVideo = ECamControllerVideo == iController.CurrentMode()
       
   580                            && ECamCapturing == iController.CurrentOperation();
       
   581             break;
       
   582             }
       
   583         case ECamEventCameraChanged:
       
   584             {
       
   585             ReadLayoutL();
       
   586             break;
       
   587             }
       
   588         case ECamEventCaptureComplete:
       
   589             {
       
   590             // Release knob if image is captured with HW button while zooming.
       
   591             iIconZoomMarkerCurrent = iIconZoomMarker[0];
       
   592             break;
       
   593             }
       
   594         default:
       
   595             break;
       
   596         }
       
   597     PRINT( _L( "Camera <= CCamZoomPane::HandleControllerEventL " ) );
       
   598     }
       
   599 
       
   600 // -----------------------------------------------------------------------------
       
   601 // CCamZoomPane::Rect
       
   602 // Returns the zoom pane rect
       
   603 // -----------------------------------------------------------------------------
       
   604 //
       
   605 TRect CCamZoomPane::Rect() const
       
   606     {
       
   607     PRINT( _L( "Camera =><= CCamZoomPane::Rect " ) );
       
   608     return iZoomPaneRect;
       
   609     }
       
   610 
       
   611 // ---------------------------------------------------------
       
   612 // CCamZoomPane::ReadLayoutL
       
   613 // ---------------------------------------------------------
       
   614 //
       
   615 void CCamZoomPane::ReadLayoutL()
       
   616     {   
       
   617     PRINT( _L( "Camera =><= CCamZoomPane::ReadLayoutL " ) );
       
   618     
       
   619     if ( CamUtility::IsNhdDevice() ) 
       
   620         {
       
   621         TouchLayout();
       
   622         }
       
   623     else
       
   624         {
       
   625         NonTouchLayout();
       
   626         }
       
   627     }
       
   628 
       
   629 // -----------------------------------------------------------------------------
       
   630 // CCamZoomPane::IsVisible
       
   631 // Is the zoom pane invisible
       
   632 // -----------------------------------------------------------------------------
       
   633 //
       
   634 TBool CCamZoomPane::IsVisible() const
       
   635     {
       
   636     PRINT( _L( "Camera =><= CCamZoomPane::IsVisible " ) );
       
   637     return iVisible;
       
   638     }
       
   639 
       
   640 // -----------------------------------------------------------------------------
       
   641 // CCamZoomPane::MakeVisible
       
   642 // Makes the zoom pane visible
       
   643 // -----------------------------------------------------------------------------
       
   644 //
       
   645 void CCamZoomPane::MakeVisible( TBool aVisible, TBool aRedraw )
       
   646     {
       
   647     PRINT2( _L( "Camera => CCamZoomPane::MakeVisible aVisible=%d aRedraw=%d" ), aVisible, aRedraw );    
       
   648     iVisible = aVisible;
       
   649 
       
   650     CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );    
       
   651     
       
   652     // No zoom in secondary camera view
       
   653     if ( appUi && iController.ActiveCamera() == ECamActiveCameraPrimary )
       
   654         {
       
   655         if ( aVisible ) 
       
   656             {
       
   657             appUi->ShowZoomPane(aRedraw);
       
   658             }
       
   659         else
       
   660             {
       
   661             appUi->HideZoomPane(aRedraw);
       
   662             iVisible = EFalse;  
       
   663             }
       
   664         }
       
   665     PRINT( _L( "Camera <= CCamZoomPane::MakeVisible " ) );    
       
   666     }
       
   667 
       
   668 void CCamZoomPane::SetZoomKeys( const RArray<TInt>& aZoomIn,
       
   669                                 const RArray<TInt>& aZoomOut )
       
   670     {
       
   671     PRINT( _L( "Camera => CCamZoomPane::SetZoomKeys CAMERAAPP_MULTIPLE_ZOOM_KEYS" ) );    
       
   672     iZoomInKeys.Reset();
       
   673     ReadZoomKeys( aZoomIn, iZoomInKeys );
       
   674     iZoomOutKeys.Reset();
       
   675     ReadZoomKeys( aZoomOut, iZoomOutKeys );
       
   676     PRINT( _L( "Camera <= CCamZoomPane::SetZoomKeys " ) );    
       
   677     }
       
   678 
       
   679 // -----------------------------------------------------------------------------
       
   680 // CCamZoomPane::ReadZoomKeys
       
   681 // -----------------------------------------------------------------------------
       
   682 //
       
   683 void CCamZoomPane::ReadZoomKeys( const RArray<TInt>& aSource,
       
   684                                  RArray<TInt>& aTarget )
       
   685     {
       
   686     PRINT( _L( "Camera => CCamZoomPane::ReadZoomKeys " ) );
       
   687     for ( TInt i = 0; i < aSource.Count(); i++ )
       
   688         {
       
   689         // here we ignore the error 
       
   690         aTarget.Append( aSource[i] );
       
   691         }
       
   692     PRINT( _L( "Camera <= CCamZoomPane::ReadZoomKeys " ) );
       
   693     }
       
   694 
       
   695 // -----------------------------------------------------------------------------
       
   696 // CCamZoomPane::CheckForZoomKey
       
   697 // -----------------------------------------------------------------------------
       
   698 //
       
   699 TBool CCamZoomPane::CheckForZoomKey( const TKeyEvent& aKeyEvent,
       
   700                                      const RArray<TInt>& aKeys )
       
   701     {
       
   702     PRINT( _L( "Camera =><= CCamZoomPane::CheckForZoomKey " ) );
       
   703     return (KErrNotFound != aKeys.Find( aKeyEvent.iScanCode ));
       
   704     }
       
   705 
       
   706 
       
   707 // -----------------------------------------------------------------------------
       
   708 // CCamZoomPane::OfferKeyEventL
       
   709 // Handles key events for the zoom pane.
       
   710 // -----------------------------------------------------------------------------
       
   711 //
       
   712 TKeyResponse CCamZoomPane::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )
       
   713     {    
       
   714     PRINT2( _L("Camera => CCamZoomPane::OfferKeyEventL (%d) (%d)"),aKeyEvent.iScanCode, aType )
       
   715     TBool vertical = PaneOrientation() == EZPOrientationVertical;
       
   716 
       
   717  
       
   718     TBool foundZoomInKey =  CheckForZoomKey( aKeyEvent, iZoomInKeys  );
       
   719     TBool foundZoomOutKey = CheckForZoomKey( aKeyEvent, iZoomOutKeys );
       
   720 
       
   721     if ( foundZoomInKey && vertical ||
       
   722          foundZoomOutKey && !vertical )
       
   723         {
       
   724         // Block key events if touch is active
       
   725         if ( iTouchActive )
       
   726             {
       
   727             return EKeyWasConsumed;
       
   728             }
       
   729         // Handle a zoom-in key as a valid event, and start zoom
       
   730         else if ( aType == EEventKeyDown )
       
   731             {
       
   732             iModel->ZoomIn();      
       
   733             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyDown, zoom in"))
       
   734             return EKeyWasConsumed;      
       
   735             }
       
   736         // Handle an up zoom-in key as a valid event, only if currently
       
   737         // zooming.  Can get stray up events if user woke from standby
       
   738         // with zoom key.  This should filter these out.
       
   739         else if ( aType == EEventKeyUp &&
       
   740                   IsCurrentlyZooming() )
       
   741             {
       
   742             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyUp, stop zoom 1"))
       
   743             iModel->StopZoom();
       
   744             return EKeyWasConsumed;
       
   745             }
       
   746         // Handle special zoom-in once request
       
   747         else if ( aType == EEventUser &&
       
   748                   !IsCurrentlyZooming() )
       
   749             {
       
   750             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyUp, zoom in once"))
       
   751             iModel->ZoomIn( ETrue );
       
   752             return EKeyWasConsumed;
       
   753             }
       
   754         // Repeat "key" events are consumed (to keep the bar visible) but
       
   755         // no need to do anything with it as zooming is timer (not key event) based
       
   756         else if ( aType == EEventKey &&
       
   757                   aKeyEvent.iRepeats > 0 )
       
   758             {            
       
   759             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKey repeated 1"))
       
   760             // Do nothing with it, but consume it
       
   761             return EKeyWasConsumed;
       
   762             }
       
   763         else
       
   764             {
       
   765             // empty statement to remove Lint error.
       
   766             }
       
   767         
       
   768         }
       
   769     // If the orientation of the zoom pane changes, the keys to zoom in/out 
       
   770     // need to switch to move in the correct direction on the zoom pane.
       
   771     else if ( foundZoomOutKey && vertical ||
       
   772               foundZoomInKey && !vertical )
       
   773         {   
       
   774         // Handle a zoom-out key as a valid event, and start zoom
       
   775         if ( aType == EEventKeyDown )
       
   776             {
       
   777             iModel->ZoomOut();
       
   778             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyDown, zoom out"))
       
   779             return EKeyWasConsumed;
       
   780             }
       
   781         // Handle an up zoom-out key as a valid event, only if currently
       
   782         // zooming.  Can get stray up events if user woke from standby
       
   783         // with zoom key.  This should filter these out.            
       
   784         else if ( aType == EEventKeyUp &&
       
   785                   IsCurrentlyZooming() )
       
   786             {
       
   787             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyUp, calling StopZoom"))
       
   788             iModel->StopZoom();
       
   789             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyUp, stop zoom 2"))
       
   790             return EKeyWasConsumed;
       
   791             }
       
   792         // Handle special zoom-out once request
       
   793         else if ( aType == EEventUser &&
       
   794                   !IsCurrentlyZooming() )
       
   795             {
       
   796             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKeyUp, zoom out once"))
       
   797             iModel->ZoomOut( ETrue );
       
   798             return EKeyWasConsumed;
       
   799             }
       
   800         // Repeat "key" events are consumed (to keep the bar visible) but
       
   801         // no need to do anything with it as zooming is timer (not key event) based
       
   802         else if ( aType == EEventKey &&
       
   803                   aKeyEvent.iRepeats > 0 )
       
   804             {        
       
   805             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKey repeated 2"))
       
   806             // Do nothing with it, but consume it
       
   807             return EKeyWasConsumed;
       
   808             }
       
   809         else
       
   810             {    
       
   811             // empty statement to remove Lint error.   
       
   812             PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKey empty statement!"))
       
   813             }
       
   814         
       
   815         }
       
   816     // otherwise, do nothing
       
   817     else
       
   818         {
       
   819         // empty statement to remove Lint error.
       
   820         PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL EEventKey empty statement!!"))
       
   821         }
       
   822 	PRINT( _L("Camera <= CCamZoomPane::OfferKeyEventL not consumed"))
       
   823     return EKeyWasNotConsumed;
       
   824     }
       
   825 
       
   826 // -----------------------------------------------------------------------------
       
   827 // CCamZoomPane::HandleForegroundEvent
       
   828 // Performs required actions on gaining/losing foreground
       
   829 // -----------------------------------------------------------------------------
       
   830 //
       
   831 void CCamZoomPane::HandleForegroundEvent( TBool aForeground )
       
   832     {
       
   833     PRINT( _L( "Camera => CCamZoomPane::HandleForegroundEvent " ) );
       
   834     if ( !aForeground )
       
   835         {
       
   836         // Ensure any ongoing zoom is stopped
       
   837         PRINT( _L( "Camera <> CCamZoomPane::HandleForegroundEvent calling StopZoom" ) );
       
   838         iModel->StopZoom();            
       
   839         }
       
   840     PRINT( _L( "Camera <= CCamZoomPane::HandleForegroundEvent " ) );
       
   841     }
       
   842 
       
   843 // -----------------------------------------------------------------------------
       
   844 // CCamZoomPane::IsCurrentlyZooming
       
   845 // Returns ETrue if the zoom model is currently zooming in/out,
       
   846 // else returns EFalse
       
   847 // -----------------------------------------------------------------------------
       
   848 //
       
   849 TBool CCamZoomPane::IsCurrentlyZooming() const
       
   850     {
       
   851     PRINT( _L( "Camera =><= CCamZoomPane::IsCurrentlyZooming " ) );
       
   852     return iModel->IsCurrentlyZooming();
       
   853     }
       
   854 
       
   855 // -----------------------------------------------------------------------------
       
   856 // CCamZoomPane::ResetToDefaultAfterPrepare
       
   857 // Sets the zoompane to reset the zoom level to default values
       
   858 // next time the engine is prepared
       
   859 // -----------------------------------------------------------------------------
       
   860 //
       
   861 void CCamZoomPane::ResetToDefaultAfterPrepare( TBool aReset )
       
   862     {
       
   863     PRINT( _L( "Camera =><= CCamZoomPane::ResetToDefaultAfterPrepare " ) );
       
   864     iModel->ResetToDefaultAfterPrepare( aReset );
       
   865     }
       
   866     
       
   867 // -----------------------------------------------------------------------------
       
   868 // CCamZoomPane::IsResetPending
       
   869 // Whether or not the zoom level is waiting to be reset to default
       
   870 // -----------------------------------------------------------------------------
       
   871 //
       
   872 TBool CCamZoomPane::IsResetPending() const
       
   873     {
       
   874     PRINT( _L( "Camera =><= CCamZoomPane::IsResetPending " ) );
       
   875     return iModel->IsResetPending();
       
   876     }    
       
   877 
       
   878 // -----------------------------------------------------------------------------    
       
   879 // CCamZoomPane::StopZoom
       
   880 // Stops zoom actions
       
   881 // -----------------------------------------------------------------------------
       
   882 //
       
   883 void CCamZoomPane::StopZoom()
       
   884     {
       
   885     PRINT( _L( "Camera => CCamZoomPane::StopZoom " ) );
       
   886     iModel->StopZoom();
       
   887     PRINT( _L( "Camera <= CCamZoomPane::StopZoom " ) );
       
   888     }
       
   889 
       
   890 // -----------------------------------------------------------------------------
       
   891 // CCamZoomPane::ResetZoomTo1x
       
   892 // Resets the zoom level to 1x.
       
   893 // -----------------------------------------------------------------------------
       
   894 //
       
   895 void CCamZoomPane::ResetZoomTo1x()
       
   896     {
       
   897     PRINT( _L( "Camera => CCamZoomPane::ResetZoomTo1x " ) );
       
   898     iModel->ResetZoomTo1x();
       
   899     PRINT( _L( "Camera <= CCamZoomPane::ResetZoomTo1x " ) );
       
   900     }
       
   901 
       
   902 // -----------------------------------------------------------------------------
       
   903 // CCamZoomPane::StartTouchZoomL
       
   904 // -----------------------------------------------------------------------------
       
   905 //
       
   906 TBool CCamZoomPane::StartTouchZoomL( TInt aPointer )  
       
   907     {     
       
   908     PRINT( _L( "Camera => CCamZoomPane::StartTouchZoomL" ) );
       
   909     
       
   910     // Block key events
       
   911     iTouchActive = ETrue;
       
   912     if ( !iMaxZoom ) // Avoid division by zero 
       
   913         {
       
   914         return EFalse;
       
   915         }
       
   916     TInt pixelsPerStep = ( iMaxOffset * KDivisorFactor ) / (iMaxZoom+1);
       
   917 
       
   918     PRINT1( _L( "Camera <> CCamZoomPane::StartTouchZoomL (iMaxZoom) %d" ), iMaxZoom );
       
   919     PRINT1( _L( "Camera <> CCamZoomPane::StartTouchZoomL (iMinZoom) %d" ), iMinZoom );
       
   920     PRINT1( _L( "Camera <> CCamZoomPane::StartTouchZoomL (pixelsPerStep) %d" ), pixelsPerStep );
       
   921 
       
   922     // New zoom according to touched point                        
       
   923     TInt base = iSliderParentRect.iBr.iY - aPointer;
       
   924     PRINT1( _L( "Camera <> CCamZoomPane::StartTouchZoomL (base) %d" ), base );
       
   925 
       
   926     // Target zoom level 
       
   927     iTrgZoom = base * KDivisorFactor / pixelsPerStep;
       
   928     iTrgZoom = ( iTrgZoom < iMinZoom )? iMinZoom:iTrgZoom;
       
   929     iTrgZoom = ( iTrgZoom > iMaxZoom )? iMaxZoom:iTrgZoom;
       
   930     PRINT1( _L( "Camera <> CCamZoomPane::StartTouchZoomL (iTrgZoom) %d" ), iTrgZoom );
       
   931    
       
   932     // Only update zoom when necessary
       
   933     if ( Abs( aPointer - iPointerPrevi ) >= pixelsPerStep / KDivisorFactor &&
       
   934          iTrgZoom != iCurZoom )
       
   935         {
       
   936         PRINT( _L( "Camera <> CCamZoomPane::StartTouchZoomL ZoomTo" ) );
       
   937         iModel->ZoomTo( iTrgZoom );
       
   938         iPointerPrevi = aPointer;
       
   939         PRINT( _L( "Camera <= CCamZoomPane::StartTouchZoomL ETrue" ) );
       
   940         return ETrue;
       
   941         }       
       
   942         
       
   943     // Pointer didn't move, so we don't need to update anything
       
   944     PRINT( _L( "Camera <= CCamZoomPane::StartTouchZoomL EFalse" ) );
       
   945     return EFalse;
       
   946     }
       
   947     
       
   948 // -----------------------------------------------------------------------------
       
   949 // CCamZoomPane::HandlePointerEventL
       
   950 // -----------------------------------------------------------------------------
       
   951 //
       
   952 TBool CCamZoomPane::HandlePointerEventL( const TPointerEvent& aPointerEvent )
       
   953     {
       
   954     PRINT( _L( "Camera => CCamZoomPane::HandlePointerEventL" ) );
       
   955 
       
   956     if ( PaneOrientation() != EZPOrientationVertical )
       
   957         {
       
   958         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (orientation)" ) );
       
   959         return EFalse; // EZPOrientationHorizontal not supported               
       
   960         }
       
   961     
       
   962     TRect tchZoomArea = iSliderParentRect;
       
   963     tchZoomArea.Grow( KTouchAreaExpansion, KTouchAreaExpansion );
       
   964     TPointerEvent::TType type = aPointerEvent.iType;
       
   965     
       
   966     // Only make the pane appear on first touch
       
   967     if( !IsVisible() &&
       
   968         type == TPointerEvent::EButton1Down )
       
   969         {
       
   970         Touchfeedback(); 
       
   971         StopZoom();
       
   972         MakeVisible( ETrue, ETrue );
       
   973         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (first touch)" ) );
       
   974         return ETrue;
       
   975         }
       
   976 
       
   977     // At this point, the zoom pane should have already been visible
       
   978     // so we activate touch zoom if the pointer is on the zoom pane
       
   979     if ( IsVisible() &&
       
   980          tchZoomArea.Contains( aPointerEvent.iPosition ) &&
       
   981          type == TPointerEvent::EButton1Down )
       
   982         {
       
   983         Touchfeedback(); 
       
   984         // Change zoom thumb to non-dimmed
       
   985         iIconZoomMarkerCurrent = iIconZoomMarkerGray[0]; // Dimmed knob
       
   986         // Force redraw of zoom pane, so knob will be dimmed
       
   987         TBool ret = ETrue;
       
   988         // Update zoom position, if necessary
       
   989         StartTouchZoomL( aPointerEvent.iPosition.iY );
       
   990         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (touch active)" ) );
       
   991         return ret;
       
   992         }
       
   993         
       
   994     // If the zoom panel is visible, but the touch event is not in the
       
   995     // zoom area, then make the zoom pane disappear.
       
   996     if ( IsVisible() &&
       
   997          !tchZoomArea.Contains( aPointerEvent.iPosition ) &&
       
   998          type == TPointerEvent::EButton1Down )
       
   999         {
       
  1000         Touchfeedback();
       
  1001         // Cancel zoom if user is pushing the volume key
       
  1002         StopZoom(); 
       
  1003         // Hide zoom pane
       
  1004         MakeVisible( EFalse, ETrue );
       
  1005         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (make disappear)" ) );
       
  1006         // return EFalse so the calling component doesn't reactivate the zoom pane
       
  1007         return EFalse;
       
  1008         }
       
  1009         
       
  1010     // Only allow drag if the zoom is already active
       
  1011     if ( type == TPointerEvent::EDrag &&
       
  1012             tchZoomArea.Contains( aPointerEvent.iPosition ) &&
       
  1013          iTouchActive )
       
  1014         { 
       
  1015         TBool ret = StartTouchZoomL( aPointerEvent.iPosition.iY );
       
  1016         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (dragging)" ) );
       
  1017         return ret;
       
  1018         }  
       
  1019     
       
  1020     // Clean up when the touch events are stopped
       
  1021     if ( type == TPointerEvent::EButton1Up ||
       
  1022             (type == TPointerEvent::EDrag &&
       
  1023                     !tchZoomArea.Contains( aPointerEvent.iPosition )))
       
  1024         {
       
  1025         // don't do anything for stray touches
       
  1026         if ( iTouchActive )
       
  1027             {
       
  1028             // Key events are no longer blocked
       
  1029             iTouchActive = EFalse;
       
  1030             // Change zoom thumb to non-dimmed
       
  1031             iIconZoomMarkerCurrent = iIconZoomMarker[0]; 
       
  1032             // force redraw of zoom pane, so knob is not dimmed anymore
       
  1033             MakeVisible( ETrue, ETrue );
       
  1034             PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (touch stopped)" ) );
       
  1035             return ETrue;
       
  1036             }
       
  1037 
       
  1038         PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (touch not active)" ) );
       
  1039         return EFalse;
       
  1040         }
       
  1041          
       
  1042     PRINT( _L( "Camera <= CCamZoomPane::HandlePointerEventL (not handled)" ) );
       
  1043     return EFalse;
       
  1044     }
       
  1045 
       
  1046 // ---------------------------------------------------------
       
  1047 // CCamZoomPane::SizeChanged
       
  1048 // Called when the view size is changed
       
  1049 // ---------------------------------------------------------
       
  1050 //
       
  1051 void CCamZoomPane::SizeChanged() 
       
  1052     {
       
  1053     PRINT( _L( "Camera => CCamZoomPane::SizeChanged" ) );
       
  1054     if ( CamUtility::IsNhdDevice() ) 
       
  1055         {
       
  1056         TouchLayout();
       
  1057         }
       
  1058     else
       
  1059         {
       
  1060         NonTouchLayout();
       
  1061         }
       
  1062                               
       
  1063     PRINT( _L( "Camera <= CCamZoomPane::SizeChanged" ) );                       
       
  1064     }
       
  1065     
       
  1066 // ---------------------------------------------------------
       
  1067 // CCamZoomPane::TouchLayout
       
  1068 // ---------------------------------------------------------
       
  1069 void CCamZoomPane::TouchLayout() 
       
  1070     {
       
  1071     PRINT( _L( "Camera => CCamZoomPane::TouchLayout()" ) );
       
  1072     TRect mainPaneRect;   
       
  1073     iMaxOffset = 0;
       
  1074     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,
       
  1075                                        mainPaneRect );  
       
  1076     mainPaneRect.Move( -mainPaneRect.iTl ); 
       
  1077     
       
  1078     TInt variant = Layout_Meta_Data::IsLandscapeOrientation();                                     
       
  1079     TAknWindowComponentLayout l = AknLayoutScalable_Apps::cam4_zoom_pane(variant); 
       
  1080 
       
  1081     TAknLayoutRect area;
       
  1082     area.LayoutRect( mainPaneRect, l.LayoutLine() ); 
       
  1083     iZoomPaneRect = area.Rect();
       
  1084 
       
  1085     l = AknLayoutScalable_Apps::cam4_zoom_cont_pane(variant); 
       
  1086     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1087     iSliderParentRect = area.Rect();
       
  1088     
       
  1089     l = AknLayoutScalable_Apps::cam4_zoom_pane_g1(variant); // +
       
  1090     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1091     AknIconUtils::SetSize( iIconZoomMax[0], area.Rect().Size(), 
       
  1092                            EAspectRatioNotPreserved );
       
  1093     iPlusPoint = area.Rect().iTl;                       
       
  1094     
       
  1095     l = AknLayoutScalable_Apps::cam4_zoom_pane_g2(variant); // -
       
  1096     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1097     AknIconUtils::SetSize( iIconZoomMin[0], area.Rect().Size(), 
       
  1098                            EAspectRatioNotPreserved );
       
  1099     iMinusPoint = area.Rect().iTl;                             
       
  1100     
       
  1101     l = AknLayoutScalable_Apps::cam4_zoom_cont_pane_g1(variant); // Top
       
  1102     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1103     AknIconUtils::SetSize( iIconZoomTop[0], area.Rect().Size(), 
       
  1104                            EAspectRatioNotPreserved );
       
  1105     iTopPoint = area.Rect().iTl;                           
       
  1106     iMaxOffset += area.Rect().Height();
       
  1107     
       
  1108     l = AknLayoutScalable_Apps::cam4_zoom_cont_pane_g3(variant); // Middle
       
  1109     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1110     iIconZoomMiddle[0]->Resize( area.Rect().Size());
       
  1111     AknIconUtils::SetSize( iIconZoomMiddle[0], area.Rect().Size(), 
       
  1112                            EAspectRatioNotPreserved );
       
  1113     iMiddlePoint = area.Rect().iTl;                        
       
  1114     iMaxOffset += area.Rect().Height();
       
  1115 
       
  1116     l = AknLayoutScalable_Apps::cam4_zoom_cont_pane_g2(variant); // Bottom
       
  1117     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1118     AknIconUtils::SetSize( iIconZoomBottom[0], area.Rect().Size(), 
       
  1119                            EAspectRatioNotPreserved );
       
  1120     iBottomPoint = area.Rect().iTl;                        
       
  1121     TRect bottomRect = area.Rect();
       
  1122     iMaxOffset += area.Rect().Height();
       
  1123     
       
  1124     l = AknLayoutScalable_Apps::cam4_zoom_pane_g3(variant); // Knob
       
  1125     area.LayoutRect(iSliderParentRect, l.LayoutLine() );
       
  1126     TRect adj = iZoomPaneRect;
       
  1127 	adj.SetHeight( area.Rect().Height() );
       
  1128 	adj.Move( bottomRect.Center() - adj.Center() );
       
  1129     AknIconUtils::SetSize( iIconZoomMarker[0], adj.Size() );  
       
  1130     AknIconUtils::SetSize( iIconZoomMarkerGray[0], adj.Size() );
       
  1131    
       
  1132     }
       
  1133 
       
  1134 // ---------------------------------------------------------
       
  1135 // CCamZoomPane::NonTouchLayout
       
  1136 // ---------------------------------------------------------
       
  1137 void CCamZoomPane::NonTouchLayout() 
       
  1138     {
       
  1139     TRect mainPaneRect; 
       
  1140     iMaxOffset = 0;
       
  1141     AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EApplicationWindow,
       
  1142                                        mainPaneRect );  
       
  1143     mainPaneRect.Move( -mainPaneRect.iTl ); 
       
  1144     
       
  1145     TInt variant = Layout_Meta_Data::IsLandscapeOrientation(); 
       
  1146 
       
  1147     TAknWindowComponentLayout l = AknLayoutScalable_Apps::cam6_zoom_pane(variant); 
       
  1148 
       
  1149     TAknLayoutRect area;
       
  1150     area.LayoutRect( mainPaneRect, l.LayoutLine() ); 
       
  1151     iZoomPaneRect = area.Rect();
       
  1152 
       
  1153     l = AknLayoutScalable_Apps::cam6_zoom_cont_pane(variant); 
       
  1154     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1155     iSliderParentRect = area.Rect();
       
  1156     
       
  1157     l = AknLayoutScalable_Apps::cam6_zoom_pane_g1(variant); // +
       
  1158     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1159     AknIconUtils::SetSize( iIconZoomMax[0], area.Rect().Size(), 
       
  1160                            EAspectRatioNotPreserved );
       
  1161     iPlusPoint = area.Rect().iTl;                       
       
  1162     
       
  1163     l = AknLayoutScalable_Apps::cam6_zoom_pane_g2(variant); // -
       
  1164     area.LayoutRect( iZoomPaneRect, l.LayoutLine() );
       
  1165     AknIconUtils::SetSize( iIconZoomMin[0], area.Rect().Size(), 
       
  1166                            EAspectRatioNotPreserved );
       
  1167     iMinusPoint = area.Rect().iTl;                             
       
  1168     
       
  1169     l = AknLayoutScalable_Apps::cam6_zoom_cont_pane_g1(variant); // Top
       
  1170     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1171     AknIconUtils::SetSize( iIconZoomTop[0], area.Rect().Size(), 
       
  1172                            EAspectRatioNotPreserved );
       
  1173     iTopPoint = area.Rect().iTl; 
       
  1174     iMaxOffset += area.Rect().Height();
       
  1175     
       
  1176     l = AknLayoutScalable_Apps::cam6_zoom_cont_pane_g3(variant); // Middle
       
  1177     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1178     iIconZoomMiddle[0]->Resize( area.Rect().Size());
       
  1179     AknIconUtils::SetSize( iIconZoomMiddle[0], area.Rect().Size(), 
       
  1180                            EAspectRatioNotPreserved );
       
  1181     iMiddlePoint = area.Rect().iTl;                        
       
  1182     iMaxOffset += area.Rect().Height();
       
  1183 
       
  1184     l = AknLayoutScalable_Apps::cam6_zoom_cont_pane_g2(variant); // Bottom
       
  1185     area.LayoutRect( iSliderParentRect, l.LayoutLine() );
       
  1186     AknIconUtils::SetSize( iIconZoomBottom[0], area.Rect().Size(), 
       
  1187                            EAspectRatioNotPreserved );
       
  1188     iBottomPoint = area.Rect().iTl;                        
       
  1189     TRect bottomRect = area.Rect();
       
  1190     iMaxOffset += area.Rect().Height();
       
  1191     
       
  1192     l = AknLayoutScalable_Apps::cam6_zoom_pane_g3(variant); // Knob
       
  1193     area.LayoutRect(iSliderParentRect, l.LayoutLine() );
       
  1194     iZoomPaneRect.iTl.iX += area.Rect().Width()/2;
       
  1195     AknIconUtils::SetSize( iIconZoomMarker[0], area.Rect().Size() );  
       
  1196     AknIconUtils::SetSize( iIconZoomMarkerGray[0], area.Rect().Size() );    
       
  1197     }
       
  1198     
       
  1199 // ---------------------------------------------------------
       
  1200 // CCamZoomPane::Touchfeedback
       
  1201 // ---------------------------------------------------------
       
  1202 //
       
  1203 void CCamZoomPane::Touchfeedback() 
       
  1204     {
       
  1205     PRINT( _L( "Camera => CCamZoomPane::Touchfeedback" ) );
       
  1206     if ( iFeedback )
       
  1207         {
       
  1208         iFeedback->InstantFeedback( iRecordingVideo?
       
  1209                                     ETouchFeedbackNone : ETouchFeedbackBasic );        
       
  1210         }
       
  1211     PRINT( _L( "Camera <= CCamZoomPane::Touchfeedback" ) );
       
  1212     }
       
  1213 
       
  1214 //  End of File