/*
* Copyright (c) 2005-2009 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:  Preview pop-up controller.
*
*/


// INCLUDE FILES
#include "AknPreviewPopUpController.h"
#include "AknPreviewPopUpContentProvider.h"
#include "AknPreviewPopUp.h"
#include <AknUtils.h>
#include <aknappui.h>
#include <AknSgcc.h>
#include <w32std.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <layoutmetadata.cdl.h>

// CONSTANTS
const TInt KDefaultPopUpShowDelay = 1000000;
const TInt KDefaultPopUpHideDelay = 10000000;
const TInt KObserverArrayGranularity = 1;

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

// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CAknPreviewPopUpController* CAknPreviewPopUpController::NewL(
        CCoeControl& aContent, 
        MAknPreviewPopUpContentProvider& aContentProvider )
    {
    return CAknPreviewPopUpController::NewL( aContent, 
                                             aContentProvider, 
                                             ELayoutDefault );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CAknPreviewPopUpController* CAknPreviewPopUpController::NewL(
        CCoeControl& aContent )
    {
    return CAknPreviewPopUpController::NewL( aContent, ELayoutDefault);
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CAknPreviewPopUpController* CAknPreviewPopUpController::NewL(
        CCoeControl& aContent, 
        MAknPreviewPopUpContentProvider& aContentProvider,
        const TInt aStyle )
    {
    CAknPreviewPopUpController* self = new ( ELeave ) CAknPreviewPopUpController(
        &aContentProvider );
    CleanupStack::PushL( self );
    self->ConstructL( aContent, aStyle );
    CleanupStack::Pop( self );
    return self;
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CAknPreviewPopUpController* CAknPreviewPopUpController::NewL( 
        CCoeControl& aContent,
        const TInt aStyle )
    {
    CAknPreviewPopUpController* self = new ( ELeave ) CAknPreviewPopUpController(
        NULL );
    CleanupStack::PushL( self );
    self->ConstructL( aContent, aStyle );
    CleanupStack::Pop( self );        
    return self;        
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::CAknPreviewPopUpController
// -----------------------------------------------------------------------------
//
CAknPreviewPopUpController::CAknPreviewPopUpController(
        MAknPreviewPopUpContentProvider* aContentProvider )
    : CTimer( CActive::EPriorityStandard ),
      iContentProvider( aContentProvider ),
      iPopUpShowDelay( KDefaultPopUpShowDelay ),
      iPopUpHideDelay( KDefaultPopUpHideDelay ),
      iObservers( KObserverArrayGranularity ),
      iResetting( EFalse )
    {
        
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::ConstructL
// -----------------------------------------------------------------------------
//
void CAknPreviewPopUpController::ConstructL( CCoeControl& aContent, 
                                             const TInt aStyle )

    {
    iPopUp = CAknPreviewPopUp::NewL( aContent, *this, aStyle );
    CTimer::ConstructL();
    CActiveScheduler::Add( this );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::~CAknPreviewPopUpController
// -----------------------------------------------------------------------------
//
CAknPreviewPopUpController::~CAknPreviewPopUpController()
    {
    Cancel();
    delete iPopUp;
    iObservers.Reset();
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::ContentSizeInLayout
// -----------------------------------------------------------------------------
//
EXPORT_C CAknPreviewPopUpController::TAknPreviewPopUpContentSize 
    CAknPreviewPopUpController::ContentSizeInLayout()
    {
    // feature removed
    return CAknPreviewPopUpController::ELarge;        
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::SetPopUpShowDelay
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::SetPopUpShowDelay(
        const TTimeIntervalMicroSeconds32& aDelay )
    {
    iPopUpShowDelay = aDelay;
    }

    
 // -----------------------------------------------------------------------------
// CAknPreviewPopUpController::SetPopUpHideDelay
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::SetPopUpHideDelay(
        const TTimeIntervalMicroSeconds32& aDelay )
    {
    iPopUpHideDelay = aDelay;
    }

   
// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::ShowPopUp
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::ShowPopUp()
    {
    Cancel();
    UpdateContentSize();
    iState = EShowing;
    After( iPopUpShowDelay );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::HidePopUp
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::HidePopUp()
    {
    Cancel();
    iPopUp->Hide();
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::ContentReady
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::ContentReady()
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::SetPosition
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::SetPosition( const TPoint& aPoint )
    {
    if ( !( iPopUp->Flags() & EFixedMode ) )
        {
        TPoint askedPoint( aPoint );
        TSize popupSize( iPopUp->MinimumSize() );
        
        // if popup's position is to be mirrored then open it right from the asked
        // location
        if ( ( iPopUp->Flags() & EAutoMirror ) && AknLayoutUtils::LayoutMirrored() )
            {
            askedPoint.iX += popupSize.iWidth;
            }
        
        TBool resize = EFalse;

        if ( popupSize != iPopUp->Size() )
            {
            resize = ETrue;
            }

        // allowed rect
        TRect clientRect;
        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, clientRect );
        
        // Control is allowed to be on top of the status pane but it cannot
        // overlay either stacon pane or control pane.
        
        //switch ( iAvkonAppUi->StatusPane()->CurrentLayoutResId() )
        CEikStatusPaneBase* statusPane = CEikStatusPaneBase::Current();
        TInt currentStatusPaneLayoutResId = 0;
        if (statusPane)
            {
            currentStatusPaneLayoutResId = statusPane->CurrentLayoutResId();
            }
        else
            {
            // If this app does not have statuspane, then we ask the layout from AknCapServer.
            currentStatusPaneLayoutResId = CAknSgcClient::CurrentStatuspaneResource();        
            }
            
        switch ( currentStatusPaneLayoutResId )
            {
            case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT:
            case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT:
            case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT:
            case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT:
            case R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_RIGHT:
            case R_AVKON_STACON_PANE_LAYOUT_EMPTY_SOFTKEYS_LEFT:
                break;
                
            default:
                TRect statusPaneRect;
                AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EStatusPane, 
                                                   statusPaneRect );

                clientRect.BoundingRect( statusPaneRect );
            }

        TPoint finalPosition;

        // resize if the popup is too wide
        if ( popupSize.iWidth > clientRect.Width() )
            {
            resize = ETrue;
            popupSize.iWidth = clientRect.Width();
            }

        // resize if the popup is too tall
        if ( popupSize.iHeight > clientRect.Height() )
        	{
            resize = ETrue;
            popupSize.iHeight = clientRect.Height();
        	}

        // default horizontal position is left from the given point
        if ( askedPoint.iX - popupSize.iWidth >= clientRect.iTl.iX )
            {
            finalPosition.iX = askedPoint.iX - popupSize.iWidth;
            }
        else
            {
            // outside left border, move to left border
            finalPosition.iX = clientRect.iTl.iX;
            }

        // check the right border
        if ( finalPosition.iX + popupSize.iWidth > clientRect.iBr.iX )
            {
            finalPosition.iX = clientRect.iBr.iX - popupSize.iWidth;
            }

        // default vertical position is up from the given point
        // coordinates grow from top to bottom
        if ( askedPoint.iY > clientRect.iTl.iY )
            {
            finalPosition.iY = askedPoint.iY;
            }
        else
            {
            // outside top border, move to top border
            finalPosition.iY = clientRect.iTl.iY;
            }

        // outside bottom border, move to bottom border
        if ( ( askedPoint.iY + popupSize.iHeight ) > clientRect.iBr.iY )
            {
            finalPosition.iY = clientRect.iBr.iY - popupSize.iHeight;
            }

        if ( resize )
            {
            iPopUp->SetSize( popupSize );
            }

        iPopUp->SetPosition( finalPosition );
        }
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::SetPositionByHighlight
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::SetPositionByHighlight( 
    const TRect& aHighlightRect )
    {
    if ( !( iPopUp->Flags() & EFixedMode ) )
        {
        TRect rect( AknLayoutUtils::HighlightBasedRect( aHighlightRect, iPopUp ) );

        // Call SetRect only when truly necessary in order to avoid unnecessary 
        // SizeChanged calls in the pop-up side.
        if ( rect.Size() != iPopUp->Size() )
            {
            iPopUp->SetRect( rect );
            }
        else
            {
            iPopUp->SetPosition( rect.iTl );
            }
        }
    }

    
// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::AddObserverL
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::AddObserverL(
        const MAknPreviewPopUpObserver& aObserver )
    {
    iObservers.InsertInAddressOrderL( &aObserver );
    }

        
// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::RemoveObserver
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::RemoveObserver(
        const MAknPreviewPopUpObserver& aObserver )
    {
    TInt index = iObservers.FindInAddressOrder( &aObserver );
    
    if ( index != KErrNotFound )
        {
        iObservers.Remove( index );
        }
    }

        
// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::UpdateContentSize
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::UpdateContentSize()
    {
    TSize popupSize( iPopUp->MinimumSize() );

    if ( popupSize != iPopUp->Size() )
        {
        iPopUp->SetSize( popupSize );
        }
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::Size
// -----------------------------------------------------------------------------
//
EXPORT_C TSize CAknPreviewPopUpController::Size() const
    {
    return iPopUp->Size();
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::SetHeadingTextL
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::SetHeadingTextL( const TDesC& aText )
    {
    iPopUp->SetHeadingTextL( aText );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::NotifyObservers
// -----------------------------------------------------------------------------
//
void CAknPreviewPopUpController::NotifyObservers(
        MAknPreviewPopUpObserver::TPreviewPopUpEvent aEvent )
    {
    for ( TInt i = 0; i < iObservers.Count(); ++i )
        {
        TRAP_IGNORE( iObservers[i]->HandlePreviewPopUpEventL( this, aEvent ) );
        }
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::RunL
// -----------------------------------------------------------------------------
//
void CAknPreviewPopUpController::RunL()
    {
    switch ( iState )
        {
        case EShowing:
            if ( iContentProvider )
                {
                iState = EBuildingContent;
                iStatus = KRequestPending;
                SetActive();
                iContentProvider->StartContentBuildingL();
                }
            else
                {
                iPopUp->Show();
                
                if ( iPopUpHideDelay.Int() > 0 && 
                     !( iPopUp->Flags() & EPermanentMode ) )
                    {
                    iState = EHiding;
                    After( iPopUpHideDelay );
                    }
                }
            break;
            
        case EHiding:
            iPopUp->Hide();
            break;
            
        case EBuildingContent:
            iPopUp->Show();

            if ( iPopUpHideDelay.Int() > 0 && 
                 !( iPopUp->Flags() & EPermanentMode ) )
                {
                iState = EHiding;
                After( iPopUpHideDelay );
                }
            break;
            
        default:
            User::Panic( _L( "Preview pop-up" ), KErrUnknown );
        }
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::DoCancel
// -----------------------------------------------------------------------------
//
void CAknPreviewPopUpController::DoCancel()
    {
    if ( iState == EBuildingContent )
        {
        iContentProvider->CancelContentBuilding();
        if ( iStatus.Int() == KRequestPending )
            {
            TRequestStatus* status = &iStatus;
            User::RequestComplete( status, KErrCancel );    
            }
        }
    else
        {
        CTimer::DoCancel();

        if(iResetting)
        	{       	
        	iResetting = EFalse;
        	}
        else
        	{
        	iPopUp->Hide();	
        	}
        }
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::ResetTimer
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknPreviewPopUpController::ResetTimer()
    {
	iResetting = ETrue;
	Cancel();
	After( iPopUpHideDelay );
    }


// -----------------------------------------------------------------------------
// CAknPreviewPopUpController::RunError
// -----------------------------------------------------------------------------
//
TInt CAknPreviewPopUpController::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }
    
//  End of File  
