/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Base class for video telephone popups

*

*/

#include    <cvtlogger.h>

#include    <AknUtils.h>

#include    <AknVolumePopup.h>

#include    <fbs.h>

#include    "cvtuipopupbase.h"

#include    "mvtuicomponentmanager.h"

#include    "mvtuicomponentstateobserver.h"

#include    "VtUiPanic.h"

#include    <layoutmetadata.cdl.h>

#include    <videotelui.rsg>

#include    <aknlayoutscalable_apps.cdl.h>

// default time out time for popup

const TInt KDefaultTimeOutTime = 2;  

// max value for slider is 100 (100%)

const TInt KMaxSliderValue = 100;  

// Implementation of TVtUiBaseComponentState

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

// TVtUiBaseComponentState::TVtUiBaseComponentState

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

//

TVtUiBaseComponentState::TVtUiBaseComponentState(

    MVtUiComponent& aComponent, TVtUiBlockListBitField aBitField  ) :

    TVtUiComponentState( aComponent, aBitField )

    {

    }

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

// CVtUiPopupBase::~CVtUiPopupBase

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

//

CVtUiPopupBase::~CVtUiPopupBase()

    {

    __VTPRINTENTER( "CVtUiPopupBase.~CVtUiPopupBase" )

    if ( iPopup )

        {

        iPopup->CloseVolumePopup();

        }

     // unregister component change registration

    iComponentManager.ChangeComponentRegistration(

        iComponentState, MVtUiComponentManager::EUnregister );

    delete iPopup;

    __VTPRINTEXIT( "CVtUiPopupBase.~CVtUiPopupBase" )

    }

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

// CVtUiPopupBase::ComponentId

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

//

 MVtUiComponent::TComponentId CVtUiPopupBase::ComponentId() const

    {

    __VTPRINTENTER( "CVtUiPopupBase.ComponentId" )

    __VTPRINTEXIT( "CVtUiPopupBase.ComponentId" )

    return iComponentId;

    }

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

// CVtUiPopupBase::ComponentAsControl

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

//

 CCoeControl* CVtUiPopupBase::ComponentAsControl()

    {

    __VTPRINTENTER( "CVtUiPopupBase.ComponentAsControl" )

    __VTPRINTEXIT( "CVtUiPopupBase.ComponentAsControl" )

    return NULL;

    }

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

// CVtUiPopupBase::DoActivateL

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

//

void CVtUiPopupBase::DoActivateL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.DoActivateL" )

    User::LeaveIfError(

       iComponentManager.ChangeResourceChangeRegistration(

        *this, MVtUiComponentManager::ERegister ) );

    User::LeaveIfError( iComponentManager.ChangeKeyEventRegistration(

        *this, MVtUiComponentManager::ERegister ) );

    ShowPopupL();

    __VTPRINTEXIT( "CVtUiPopupBase.DoActivateL" )

    }

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

// CVtUiPopupBase::DoDeactivateL()

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

//

void CVtUiPopupBase::DoDeactivateL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.DoDeactivateL()" )

    iPopup->CloseVolumePopup();

    //notify observer that popup has been closed

    if ( iCompStateObserver )

        {

        iCompStateObserver->ComponenStateChangedL();

        }

    // unregister resource change registration

    iComponentManager.ChangeResourceChangeRegistration(

        *this, MVtUiComponentManager::EUnregister );

    iComponentManager.ChangeKeyEventRegistration(

        *this, MVtUiComponentManager::EUnregister );

    __VTPRINTEXIT( "CVtUiPopupBase.DoDeactivateL()" )

    }

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

// CVtUiPopupBase::HandleResourceChangeL()

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

//

void CVtUiPopupBase::HandleResourceChangeL( TInt aType )

    {

    __VTPRINTENTER( "CVtUiPopupBase.HandleResourceChangeL()" )

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        iPopup->SetPosition( PopupPosition() );

        }

    __VTPRINTEXIT( "CVtUiPopupBase.HandleResourceChangeL()" )

    }

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

// CVtUiPopupBase::HandleControlEventL

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

//

void CVtUiPopupBase::HandleControlEventL( CCoeControl* /*aControl*/,

    TCoeEvent aEventType )

    {

    __VTPRINTENTER( "CVtUiPopupBase.HandleControlEventL" )

    if ( aEventType == EEventStateChanged )

        {

        // popup closed

        if( !IsPopUpVisible() )

            {

            ClosePopup();

            }

        }

    __VTPRINTEXIT( "CVtUiPopupBase.HandleControlEventL" )

    }

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

// CVtUiPopupBase::OfferKeyEventL()

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

//

TKeyResponse CVtUiPopupBase::OfferKeyEventL( const TKeyEvent& aEvent,

    TEventCode aCode )

    {

    __VTPRINTENTER( "CVtUiPopupBase.OfferKeyEventL" )

    TKeyResponse response( EKeyWasNotConsumed );

    // Don't  handle other types here

    if ( aCode != EEventKey )

        {

        return response;

        }

    if ( aEvent.iScanCode == EStdKeyUpArrow ||

            aEvent.iScanCode == EStdKeyDownArrow )

        {

        __VTPRINT( DEBUG_GEN, "CVtUiPopupBase.OfferKeyEventL" )

        TInt step( 1 );

        if ( aEvent.iScanCode == EStdKeyDownArrow )

            {

            step = -step;

            }

        const TInt current( Value() );

        TInt value( current + step );

        TInt maxValue;

        TInt minValue;

        iPopup->GetRange( minValue, maxValue );

        __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.OfferKeyEventL iPopup minValue = %d",

                minValue )

        __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.OfferKeyEventL iPopup maxValue = %d",

                maxValue )

        minValue = minValue / iScalingConstant;

        value = Max( minValue, Min( value, iStepCount ) );

        if ( value != current )

            {

            __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.OfferKeyEventL Volume value = %d",

                    value )

            SetValue( value );

            response = EKeyWasConsumed;

            }

        ShowPopupL();

        }

    __VTPRINTEXITR( "CVtUiPopupBase.OfferKeyEventL %d", response )

    return response;

    }

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

// CVtUiPopupBase::SetObserver()

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

//

void CVtUiPopupBase::SetObserver( MVtUiComponentStateObserver& aCompStateObserver )

    {

    __VTPRINTENTER( "CVtUiPopupBase.SetObserver()" )

    iCompStateObserver = &aCompStateObserver;

    __VTPRINTEXIT( "CVtUiPopupBase.SetObserver()" )

    }

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

// CVtUiPopupBase::SetValueType()

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

//

void CVtUiPopupBase::SetValueType( TInt aValueType )

    {

    __VTPRINTENTER( "CVtUiPopupBase.SetValueType" )

    iPopup->SetValueType( aValueType );

    __VTPRINTEXIT( "CVtUiPopupBase.SetValueType" )

    }

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

// CVtUiPopupBase::SetPermanenVisibility()

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

//

void CVtUiPopupBase::SetPermanenVisibility( TBool aPermanent )

    {

    __VTPRINTENTER( "CVtUiPopupBase.SetPermanenVisibility" )

    __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase = %d", aPermanent  );

    const TInt longPeriod( 86400 ); // 24 h

    if ( aPermanent ) 

        {

        iPopup->SetTimeOutAsSecond( longPeriod );

        iPopup->ClosePopupWhenTappedOutside( !aPermanent );

        }

     else

        {

        iPopup->ClosePopupWhenTappedOutside( !aPermanent );

        iPopup->SetTimeOutAsSecond( iTimeOutTime );

        }

     __VTPRINTEXIT( "CVtUiPopupBase.SetPermanenVisibility" )

    }

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

// CVtUiPopupBase::CVtUiPopupBase

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

//

CVtUiPopupBase::CVtUiPopupBase(  MVtUiComponentManager& aComponentManager,

  TVtUiBlockListBitField aBitField, TComponentId aComponentId ) :

  iComponentManager ( aComponentManager ), iComponentState( *this, aBitField ),

  iComponentId( aComponentId ), iScalingConstant( 1 )

    {

    __VTPRINTENTER( "CVtUiPopupBase.CVtUiPopupBase" )

    __VTPRINTEXIT( "CVtUiPopupBase.CVtUiPopupBase" )

    }

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

// CVtUiPopupBase::BaseConstructL

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

//

void CVtUiPopupBase::BaseConstructL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.BaseConstructL" )

    iPopup = CAknVolumePopup::NewL( NULL, ETrue );

    iPopup->SetObserver( this );

    // Initialized to 2 seconds

    iTimeOutTime = KDefaultTimeOutTime;

    // set position

    iPopup->SetPosition( PopupPosition() );

    User::LeaveIfError(

        iComponentManager.ChangeComponentRegistration(

        iComponentState, MVtUiComponentManager::ERegister ) );

    __VTPRINTEXIT( "CVtUiPopupBase.BaseConstructL" )

    }

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

// CVtUiPopupBase::ShowPopupL

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

//

void  CVtUiPopupBase::ShowPopupL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.ShowPopupL" )

    iPopup->ShowVolumePopupL();

    __VTPRINTEXIT( "CVtUiPopupBase.ShowPopupL" )

    }

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

// CVtUiPopupBase::OpenPopupL

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

//

void CVtUiPopupBase::OpenPopupL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.OpenPopupL" )

    TRAPD( error,

        iComponentManager.RequestActivationL( ComponentId() ) );

    __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.OpenPopupL reqAct=%d", error );

    User::LeaveIfError( error );

    __VTPRINTEXIT( "CVtUiPopupBase.OpenPopupL" )

    }

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

// CVtUiPopupBase::ClosePopup

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

//

void CVtUiPopupBase::ClosePopup()

    {

    __VTPRINTENTER( "CVtUiPopupBase.ClosePopup" )

    TInt error( KErrNone );

    TRAP( error, iComponentManager.DeActivateComponentL( ComponentId() ) );

    __VTPRINTEXITR( "CVtUiPopupBase.ClosePopup %d", error )

    }

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

// CVtUiPopupBase::SetTimeOut

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

//

void CVtUiPopupBase::SetTimeOut( TInt aTime )

    {

    iTimeOutTime = aTime;

    iPopup->SetTimeOutAsSecond( aTime );

    }

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

// CVtUiPopupBase::IsPopUpVisible

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

//

TBool CVtUiPopupBase::IsPopUpVisible()

    {

    return iPopup->IsVisible();

    }

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

// CVtUiPopupBase::PopupPosition

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

//

TPoint CVtUiPopupBase::PopupPosition() const

    {

    __VTPRINTENTER( "CVtUiPopupBase.PopupPosition" )

    TRect mainPaneRect;

    TAknWindowLineLayout popupLineLayout;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPaneRect );

    if ( Layout_Meta_Data::IsLandscapeOrientation() )

        {

        popupLineLayout =

            AknLayoutScalable_Apps::aid_placing_vt_slider_lsc().LayoutLine();

        }

    else

        {

        popupLineLayout = 

            AknLayoutScalable_Apps::aid_placing_vt_slider_prt().LayoutLine();

        }

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( mainPaneRect, popupLineLayout );

    __VTPRINTEXIT( "CVtUiPopupBase.PopupPosition" )

    return layoutRect.Rect().iTl;

    }

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

// CVtUiPopupBase::SetPopupValue

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

//

void CVtUiPopupBase::SetPopupValue( TInt aValue )

    {

    iPopup->SetValue( aValue * iScalingConstant );

    }

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

// CVtUiPopupBase::SetAdjustRange

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

//

void CVtUiPopupBase::SetAdjustRange( TInt aMinValue, TInt aMaxValue,

    TInt aStepCount )

    {

    __VTPRINTENTER( "CVtUiPopupBase.SetAdjustRange" )

    __ASSERT_ALWAYS( aMinValue <= aMaxValue &&

        ( aMaxValue - aMinValue ) >= aStepCount &&

        aStepCount > 0, VtUiPanic::Panic( EVtUiPanicOutOfRange ) );

    // store stepcount

    iStepCount = aStepCount;

    // Aknvolumepopup does not do any scaling i.e max value

    // must be 100 or otherwise the per cent value is not shown right.

    // Scaling constant is used to multiple max value to be 100.

    iScalingConstant = KMaxSliderValue / aMaxValue;

    iPopup->SetRange( aMinValue, KMaxSliderValue );

    TInt stepSize = KMaxSliderValue / aStepCount;

    iPopup->SetStepSize( stepSize );

    __VTPRINTEXIT( "CVtUiPopupBase.SetAdjustRange" )

    }

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

// CVtUiPopupBase::SetValue

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

//

void CVtUiPopupBase::SetValue( TInt aValue )

    {

    __VTPRINTENTER( "CVtUiPopupBase.SetValue" )

    SetPopupValue( aValue ); 

    __VTPRINTEXITR( "CVtUiPopupBase.SetValue %d", Value() )

    }

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

// CVtUiPopupBase::ScaleAndSetValue

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

//

 void CVtUiPopupBase::ScaleAndSetValue( TInt aValue )

    {

    __VTPRINTENTER( "CVtUiPopupBase.ScaleAndSetValue" )

    SetPopupValue( SliderValueWithScaling( aValue ) );

    __VTPRINTEXITR( "CVtUiPopupBase.ScaleAndSetValue %d", Value() )

    }

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

// CVtUiPopupBase::ScaledValue

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

//

 TInt CVtUiPopupBase::ScaledValue() const

    {

    __VTPRINTENTER( "CVtUiPopupBase.ScaledValue" )

     TInt value = Value() * ( iMax-iMin ) / iStepCount + iMin;

    __VTPRINTEXITR( "CVtUiPopupBase.ScaledValue %d", value )    

    return value;

    }

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

// CVtUiPopupBase::SliderValueWithScaling

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

//

 TInt CVtUiPopupBase::SliderValueWithScaling( TInt aValue) const

    {

    __VTPRINTENTER( "CVtUiPopupBase.SliderValueWithScaling" )

    __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.aValue=%d", aValue )

    __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.iStepCount=%d", iStepCount )

    __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase.iMax=%d", iMax )

    if ( iMax == aValue)

        {

        return iStepCount;

        }

    else if ( iMin == aValue )

        {

        return 0;

        }

    TInt modValue = iStepCount * ( aValue - iMin) % ( iMax - iMin );        

    TInt value = iStepCount * ( aValue - iMin) / ( iMax - iMin ); 

    if ( modValue >  ( iMax - iMin ) / 2 )

        {

        value++;

        }

    __VTPRINTEXITR( "CVtUiPopupBase.SliderValueWithScaling %d", value )    

    return value;

    }

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

// CVtUiPopupBase::SetMinAndMaxValues

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

//

void CVtUiPopupBase::SetMinAndMaxValues( TInt aMin, TInt aMax )

    {

     __VTPRINTENTER( "CVtUiPopupBase.SetMaxAndMinValues" )

     __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase..aMax=%d", aMax )

     __VTPRINT2( DEBUG_GEN, "CVtUiPopupBase..aMinV=%d", aMin )

    iMax = aMax;

    iMin = aMin;

    __VTPRINTEXIT( "CVtUiPopupBase.SetMaxAndMinValues " ) 

    }

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

// CVtUiPopupBase::Value

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

//

TInt CVtUiPopupBase::Value() const

    {

    __VTPRINTENTER( "CVtUiPopupBase.Value" )

    __VTPRINTEXITR( "CVtUiPopupBase.Value %d", iPopup->Value() )

    return iPopup->Value() / iScalingConstant;

    }

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

// CVtUiPopupBase::UpdatePopupL

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

//

void CVtUiPopupBase::UpdatePopupL()

    {

    __VTPRINTENTER( "CVtUiPopupBase.UpdatePopupL" )

    __VTPRINTEXIT( "CVtUiPopupBase.UpdatePopupL " ) 

    }