/*
* Copyright (c) 2003, 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Class for displaying icons in viewfinder view
*
*/


// USER
#include "musuizoomindicator.h"
#include "muslogger.h"
#include "musuizoomindicatorobserver.h"

// SYSTEM
#include <aknutils.h>
#include <aknsutils.h>
#include <data_caging_path_literals.hrh>
#include <camcorder.mbg>
#include <gulicon.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <AknsDrawUtils.h>



// CONSTANTS
const TInt KMusUiZoomDisableTime = 3000000;


using namespace AknLayoutScalable_Apps;

_LIT( KMyMbmFileName, "z:Camcorder.mbm");


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiZoomIndicator::CMusUiZoomIndicator(
                        TInt aZoomMin,
                        TInt aZoomMax,
                        MMusUiZoomIndicatorObserver* aObserver )
    : iZoomMin( aZoomMin ),
      iZoomMax( aZoomMax ),
      iZoomLevel( aZoomMin ),
      iObserver( aObserver )
    {
    MUS_LOG( "mus: mus: [MUSUI ] -> CMusUiZoomIndicator::CMusUiZoomIndicator()" );
    // pass
    iDisableZoomTimer = NULL;
    iTopMargin =  5;
    iBottomMargin = 5;

    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::CMusUiZoomIndicator()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiZoomIndicator* CMusUiZoomIndicator::NewLC(
                        TInt aZoomMin,
                        TInt aZoomMax,
                        MMusUiZoomIndicatorObserver* aObserver )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::NewLC()" );
    CMusUiZoomIndicator* self = new ( ELeave ) CMusUiZoomIndicator(
                            aZoomMin,
                            aZoomMax,
                            aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();

    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::NewLC()" );
    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiZoomIndicator* CMusUiZoomIndicator::NewL(
                        TInt aZoomMin,
                        TInt aZoomMax,
                        MMusUiZoomIndicatorObserver* aObserver )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::NewL()" );
    CMusUiZoomIndicator* self = NewLC( aZoomMin,
                                       aZoomMax,
                                       aObserver );
    CleanupStack::Pop( self );

    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::NewL()" );
    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::ConstructL()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::ConstructL()" );

    if( iZoomMin > iZoomMax )
        {
        User::Leave( KErrArgument );
        }

    iIconElevator = new (ELeave) CEikImage();
    iIconElevator->SetContainerWindowL( *this );

    iIconMin = new (ELeave) CEikImage();
    iIconMin->SetContainerWindowL( *this );

    iIconMax = new (ELeave) CEikImage();
    iIconMax->SetContainerWindowL( *this );

    iIconBg = new (ELeave) CEikImage();
    iIconBg->SetContainerWindowL( *this );

    
    ConstructImageL( iIconMin,
                     AknsUtils::SkinInstance(),
                     KAknsIIDQsnIconColors,
                     EMbmCamcorderQgn_indi_cams_zoom_bg_min,
                     EMbmCamcorderQgn_indi_cams_zoom_bg_min);

    ConstructImageL( iIconMax,
                     AknsUtils::SkinInstance(),
                     KAknsIIDQsnIconColors,
                     EMbmCamcorderQgn_indi_cams_zoom_bg_max,
                     EMbmCamcorderQgn_indi_cams_zoom_bg_max);

    ConstructImageL( iIconBg,
                     AknsUtils::SkinInstance(),
                     KAknsIIDQsnIconColors,
                     EMbmCamcorderQgn_indi_cams_zoom_bg,
                     EMbmCamcorderQgn_indi_cams_zoom_bg);

    ConstructImageL( iIconElevator,
                     AknsUtils::SkinInstance(),
                     KAknsIIDQsnIconColors,
                     EMbmCamcorderQgn_indi_cams_zoom_elevator,
                     EMbmCamcorderQgn_indi_cams_zoom_elevator);


    UpdateZoomLayout();

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiZoomIndicator::ConstructL()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiZoomIndicator::~CMusUiZoomIndicator()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::~CMusUiZoomIndicator()" );

    DisableTimer();
    delete iDisableZoomTimer;

    delete iIconElevator;
    delete iIconMin;
    delete iIconMax;
    delete iIconBg;

    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::~CMusUiZoomIndicator()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::SetZoomLevel( TInt aZoomLevel )
    {
    MUS_LOG1( "mus: [MUSUI ] -> CMusUiZoomIndicator::SetZoomLevel( %d ) ",
              aZoomLevel );
    if( aZoomLevel >= iZoomMin && aZoomLevel <= iZoomMax )
        {
        iZoomLevel = aZoomLevel;
        }
    DisableTimer();
    UpdateZoomLayout();
    EnableTimer();
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::SetZoomLevel()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMusUiZoomIndicator::GetZoomLevel()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::GetZoomLevel()" );
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::GetZoomLevel()" );
    return iZoomLevel;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::SetZoomMin( TInt aZoomMin )
    {
    MUS_LOG1( "mus: [MUSUI ] -> CMusUiZoomIndicator::SetZoomMin( %d ) ", aZoomMin );
    if( aZoomMin >= 0 && aZoomMin < iZoomMax )
        {
        iZoomMin = aZoomMin;
        }
    DisableTimer();
    UpdateZoomLayout();
    EnableTimer();
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::SetZoomMin()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::SetZoomMax( TInt aZoomMax )
    {
    MUS_LOG1( "mus: [MUSUI ] -> CMusUiZoomIndicator::SetZoomMax( %d ) ", aZoomMax );
    if( aZoomMax >= iZoomMin )
        {
        iZoomMax = aZoomMax;
        }
    DisableTimer();
    UpdateZoomLayout();
    EnableTimer();
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::SetZoomMax()" );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::SetFullRect( const TRect aRect  )
    {
    iFullRect = aRect;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::SizeChanged()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::SizeChanged()" );
    UpdateZoomLayout();
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::SizeChanged()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::Draw( const TRect& aRect ) const
    {

    CWindowGc& gc = SystemGc();

    TRect rect( 0,0, iFullRect.Width(), iFullRect.Height() );
    //TRect rect( iFullRect.Width()-20, iFullRect.iTl.iY, iFullRect.iBr.iX, iFullRect.iBr.iY ); //TRect( 40,0,380,382 ) );

/*
    AknsUtils::RegisterControlPosition( this, TPoint( iFullRect.Width()-20, iFullRect.iTl.iY ) );
 //   gc.Clear( aRect );
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
    if(!AknsDrawUtils::Background( skin, cc,this,gc,rect,KAknsDrawParamDefault ))
        {
*/        
        MUS_LOG( "mus: [MUSUI ]     Skin not valid or not found" );
        gc.SetBrushColor( iEikonEnv->ControlColor( EColorWindowBackground, *this ) );
        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
        gc.Clear( aRect );
//        }    
  
}


// -----------------------------------------------------------------------------
// Draw all icons and texts to given graphics context.
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::DrawIcons( const TRect& /*aRect*/ )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::DrawIcons()" );
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::DrawIcons()" );
    }


// -----------------------------------------------------------------------------
// Draw all icons and texts to given graphics context.
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::UpdateZoomLayout()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::UpdateZoomLayout()" );
    
    TSize sz = iIconBg->MinimumSize();
    
    TRect rect = Rect();
    
    // TODO: Remove all magic constants!
    AknLayoutUtils::LayoutImage(iIconMax, Rect(), 0, 0, 0, 0, 0, 20, 20 );
    AknLayoutUtils::LayoutImage(iIconMin, Rect(), 0, 0, 68, 0, 0, 20, 20 );
    AknLayoutUtils::LayoutImage(iIconBg, Rect(), 0, 0, 20, 0, 0, 20, 48 );
    
    // 20 - 68
    iScaleStep = (  48 << 8 ) /
                 ( ( iZoomMax - iZoomMin ) );
    iScaleY = ( 58 ) -
                            ( ( iScaleStep * iZoomLevel ) >> 8 );
    
    
    AknLayoutUtils::LayoutImage(iIconElevator, Rect(), 0, 0, iScaleY, 0, 0, 20, 20 );
    
    DrawNow();
    
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::UpdateZoomLayout()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMusUiZoomIndicator::CountComponentControls() const
    {
    return 4; //iIconElevator ? 1 : 0; // return nbr of controls inside this container
    //return 0; // return nbr of controls inside this container
    }


// --------------------------------------------------------------------------
// Called by framework to retrieve the control specified by index.
// --------------------------------------------------------------------------
//
CCoeControl* CMusUiZoomIndicator::ComponentControl( TInt aIndex ) const
    {
    switch ( aIndex )
        {
        
        case 0:
            return iIconMin;
        case 1:
            return iIconMax;
        case 2:
            return iIconBg;
        case 3:
            return iIconElevator;
        
        default:
            return NULL;
        }
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void  CMusUiZoomIndicator::ConstructImageL( CEikImage* aImage,
                                         MAknsSkinInstance* aSkin,
                                         const TAknsItemID& aId,
                                         TInt aBitmapId,
                                         TInt aMaskId )

    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::ConstructIconL()" );

    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;

    TParse parse;
    parse.Set( KMyMbmFileName, &KDC_APP_RESOURCE_DIR, NULL );

    AknsUtils::CreateIconL(aSkin,
                           aId,
                           bitmap,
                           mask,
                           parse.FullName(),
                           aBitmapId,
                           aMaskId);

    aImage->SetPicture(bitmap, mask); // Owership transferred to CEikImage



    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::ConstructIconL()" );

    }



// -----------------------------------------------------------------------------
// Callback for disable zoom indicator.
// -----------------------------------------------------------------------------
//
TInt CMusUiZoomIndicator::DisableZoomIndicator( TAny* aThis )
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::DisableZoomIndicator()" );
    CMusUiZoomIndicator* indicator =
                            static_cast< CMusUiZoomIndicator* > ( aThis );
    indicator->DisableTimer();
    if( indicator->iObserver )
        {
        indicator->iObserver->DisableZoomIndicator();
        }
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::DisableZoomIndicator()" );
    return KErrNone;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::DisableTimer()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::DisableTimer()" );
    if ( iDisableZoomTimer )
        {
        if ( iDisableZoomTimer->IsActive() )
            {
            iDisableZoomTimer->Cancel();
            }
        }
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::DisableTimer()" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiZoomIndicator::EnableTimer()
    {
    MUS_LOG( "mus: [MUSUI ] -> CMusUiZoomIndicator::EnableTimer()" );

    if ( !iDisableZoomTimer )
        {
        TRAP_IGNORE( iDisableZoomTimer = CPeriodic::NewL( CActive::EPriorityStandard ) );
        }
    else
        {
        DisableTimer();
        }

    // Start disable timer; callback triggers exit.
    iDisableZoomTimer->Start( KMusUiZoomDisableTime,
                             KMusUiZoomDisableTime,
                             TCallBack( DisableZoomIndicator, this ) );
    MUS_LOG( "mus: [MUSUI ] <- CMusUiZoomIndicator::EnableTimer()" );
    }
    

// End of File