/*
* Copyright (c) 2005 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:  Info popup note UI control.
*
*/



// INCLUDE FILES

#include <AknsDrawUtils.h>
#include <AknsFrameBackgroundControlContext.h>
#include <eiklabel.h>
#include <gulicon.h>
#include <aknappui.h>
#include <AknUtils.h>
#include <layoutmetadata.cdl.h>
#include <aknlayoutscalable_avkon.cdl.h>
#include <AknStatuspaneUtils.h>
#include <touchfeedback.h>
#include "akntextcontrol.h"
#include "AknInfoPopupNote.h"
#include "AknInfoPopupNoteController.h"

#include <AknTasHook.h> // for testability hooks

// CONSTANTS
const TInt KMaxNumOfLines = 5; // max number of lines in popup

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

// -----------------------------------------------------------------------------
// ConstructL
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::ConstructL()
    {
    /* Popup should disappear quickly. By making popup as window-owning 
     * control, that backups graphics behind it (backed-up-behind window) 
     * we enable fast hiding. However, it eats more memory, and in OOM
     * situation backup is not done, but status pane is actually redrawn.
     * See Symbian documentation of RWindowBase::EnableBackup for more
     * information.
     */    
    
    delete iBgContext;
    iBgContext = NULL;

    iBgContext = CAknsFrameBackgroundControlContext::NewL(
        KAknsIIDQsnFrPopupPreview, TRect(), TRect(), EFalse );

    CreateWindowL();
    
    EnableDragEvents();
    SetAllowStrayPointers();
    
    if( CAknEnv::Static()->TransparencyEnabled() )
        {
        // try to enable window transparency
        if ( Window().SetTransparencyAlphaChannel() == KErrNone )
            {
            Window().SetRequiredDisplayMode( EColor16MA );
            Window().SetBackgroundColor( ~0 );
            }
        }

    DrawableWindow()->EnableBackup( EWindowBackupAreaBehind );

    DrawableWindow()->SetNonFading( ETrue);
    if ( !iText )
        {
        iText = CAknTextControl::NewL();
        iText->SetContainerWindowL( *this );
        iText->CopyControlContextFrom( this );
        iText->SetComponentsToInheritVisibility( ETrue );
        }

    iAvkonAppUi->AddToStackL( this, ECoeStackPriorityCba,
                              ECoeStackFlagRefusesAllKeys |
                              ECoeStackFlagRefusesFocus );

    DrawableWindow()->SetPointerGrab( ETrue );
    
    SetComponentsToInheritVisibility( ETrue );
    Hide();
    
    ControlEnv()->AddForegroundObserverL( *this );
    }

// -----------------------------------------------------------------------------
// NewL
// 
// -----------------------------------------------------------------------------
//
CAknInfoPopupNote* CAknInfoPopupNote::NewL(
        CAknInfoPopupNoteController& aController )
    {
    CAknInfoPopupNote* self = 
        new( ELeave ) CAknInfoPopupNote( aController );

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    AKNTASHOOK_ADDL( self, "CAknInfoPopupNote" );
    return self;
    }

// -----------------------------------------------------------------------------
// CAknInfoPopupNote
// 
// -----------------------------------------------------------------------------
//
CAknInfoPopupNote::CAknInfoPopupNote( CAknInfoPopupNoteController& aController )
    : iController( aController ),
      iTooltipMode( EFalse ),
      iHideWhenAppFaded( ETrue ),
      iFloatingPositionUsed( EFalse ),
      iFloatingPosition( 0, 0 ),
      iAlignment( EHLeftVTop )

    {   
    }

// -----------------------------------------------------------------------------
// ~CAknInfoPopupNote
// 
// -----------------------------------------------------------------------------
//
CAknInfoPopupNote::~CAknInfoPopupNote()
    {
    AKNTASHOOK_REMOVE();
    ControlEnv()->RemoveForegroundObserver( *this );

    if ( iAvkonAppUi )
        {
        iAvkonAppUi->RemoveFromStack( this );
        }

    delete iBgContext;
    delete iText;
    }

// -----------------------------------------------------------------------------
// CountComponentControls
// 
// -----------------------------------------------------------------------------
//
TInt CAknInfoPopupNote::CountComponentControls() const
    {
    return 1;    
    }

// -----------------------------------------------------------------------------
// ComponentControl
// 
// -----------------------------------------------------------------------------
//
CCoeControl* CAknInfoPopupNote::ComponentControl( TInt /*aIndex*/ ) const 
    {
    return iText;
    }

// -----------------------------------------------------------------------------
// Hide
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::Hide()
    {
    if ( IsVisible() )
        {        
        MakeVisible( EFalse );

        // Change stacked control to refuse all key events while not visible.
        iAvkonAppUi->UpdateStackedControlFlags( this,
                                                ECoeStackFlagRefusesAllKeys,
                                                ECoeStackFlagRefusesAllKeys );
        }
    }

// -----------------------------------------------------------------------------
// SetTextL
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetTextL( const TDesC& aText )
    {
    if ( aText != iText->Text() )
        {
        iText->SetTextL( aText );

        for ( TInt i = 0; i < iText->NumberOfLines(); i++ )
            {
            // Draw the label after the background.
            CEikLabel* line = iText->Line( i );
            line->ActivateL(); // Never leaves

            if ( !IsVisible() )
                {
                line->MakeVisible( EFalse );
                }

            iText->SetLineModified( i, EFalse );
            }

        SetWindowLayoutL();

        if ( IsVisible() )
            {
            Window().Invalidate( Rect() );
            }
        }
    }

// -----------------------------------------------------------------------------
// GetText
// 
// -----------------------------------------------------------------------------
//
const TPtrC CAknInfoPopupNote::GetText() const
    {
    if ( iText->Text().Length() == 0 )
        {
        return KNullDesC().Ptr();
        }
    return iText->Text();
    }

// -----------------------------------------------------------------------------
// SetPositionAndAlignment
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetPositionAndAlignment( const TPoint& aPosition,
        const TGulAlignmentValue& aAlignment  )
    {
    iFloatingPositionUsed = ETrue;
    iFloatingPosition = aPosition;
    iAlignment = aAlignment;
    Relocate();
    }

// -----------------------------------------------------------------------------
// SetPositionAndAlignment
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetPositionByHighlight( const TRect& aHighlightRect )
    {
    SetRect( AknLayoutUtils::HighlightBasedRect( aHighlightRect, this ) );
    iFloatingPositionUsed = ETrue;
    iFloatingPosition = Position();
    iAlignment = EHLeftVTop;
    }

// -----------------------------------------------------------------------------
// RestoreDefaultPosition
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::RestoreDefaultPosition()
    {
    // Get parameter limits for popup preview text window
    TAknLayoutScalableParameterLimits limits = 
        AknLayoutScalable_Avkon::popup_preview_text_window_ParamLimits();

    // Select the variety index depending on the number of lines
    TInt variety = SelectWindowVariety( iText->NumberOfLines(), limits );

    // Get layout rects
    TRect rectScreen = iAvkonAppUi->ApplicationRect();
    TRect rectMainPane = rectScreen;
    TRect rectPopupWindow = RectFromLayout( rectMainPane,
        AknLayoutScalable_Avkon::popup_preview_text_window( variety ) );

    // Set the default position
    SetPosition( rectPopupWindow.iTl );
    iFloatingPositionUsed = EFalse;
    }

// -----------------------------------------------------------------------------
// SetTooltipModeL
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetTooltipModeL( const TBool aTooltipMode )
    {
    if ( iTooltipMode != aTooltipMode )
        {
        iTooltipMode = aTooltipMode;
        SetWindowLayoutL();
        }
    }

// -----------------------------------------------------------------------------
//  AppFaded
//
// -----------------------------------------------------------------------------
//

void CAknInfoPopupNote::HideWhenAppFaded( const TBool aHide )
    {
    iHideWhenAppFaded = aHide;
    }
    
// -----------------------------------------------------------------------------
// ShowL
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::ShowL()
    {
    // Info pop-up note is not shown, when it does not contain any text, or
    // when the screen background is faded by some other UI component.
    if ( !iText->Text().Length() || ( !iAvkonAppUi->IsForeground() 
    		&& iAvkonAppUi->IsFaded() && iHideWhenAppFaded ))
        {        
        return;
        }

    // Because info pop-up note has to be drawn over pop-up toolbar, which has
    // normal window priority, the window priority of info pop-up note has to
    // be also set again to be shown over toolbar.
    Window().SetOrdinalPosition( 0, ECoeWinPriorityNormal );

    if( !IsActivated() )
        {
        ActivateL();
        }

    MakeVisible( ETrue );

    // Change stacked control not to refuse key events
    iAvkonAppUi->UpdateStackedControlFlags( this, NULL,
                                            ECoeStackFlagRefusesAllKeys );    
    }

// -----------------------------------------------------------------------------
// Draw
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::Draw( const TRect& aRect ) const
    {
    CWindowGc& gc = SystemGc();
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    if ( !AknsDrawUtils::Background( skin, iBgContext, gc, aRect ) )
        {
        gc.Clear( aRect );
        gc.DrawRect( aRect );
        }
    }

// -----------------------------------------------------------------------------
// SizeChanged
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SizeChanged()
    {
    const TRect popupRect( Rect() );

    TRect windowPaneBgRect = RectFromLayout( popupRect,
        AknLayoutScalable_Avkon::bg_popup_preview_window_pane( 0 ) );

    // Note: bg_popup_preview_window_pane might not be the right outer rect,
    // but it is used for now, because bg_popup_preview_window_pane_g#
    // functions do not return the correct values.
    iOuterRect = windowPaneBgRect;
    iInnerRect = RectFromLayout( windowPaneBgRect,
        AknLayoutScalable_Avkon::bg_popup_preview_window_pane_g1() );

    iBgContext->SetFrameRects( iOuterRect, iInnerRect );
    }

// -----------------------------------------------------------------------------
// OfferKeyEventL
// 
// -----------------------------------------------------------------------------
//
TKeyResponse CAknInfoPopupNote::OfferKeyEventL( const TKeyEvent& aKeyEvent,
    TEventCode aType )
    {
    if ( aType == EEventKeyDown || aKeyEvent.iCode == EKeyEscape )
        {
        Hide();
        }

    return EKeyWasNotConsumed;
    }
    
// -----------------------------------------------------------------------------
// CAknInfoPopupNote::MakeVisible
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::MakeVisible( TBool aVisible )
    {
    if ( aVisible != IsVisible() )
        {
        CCoeControl::MakeVisible( aVisible );
        
        if ( aVisible )
            {
            iController.NotifyObservers(
                MAknInfoPopupNoteObserver::EInfoPopupNoteShown );
            }
        else
            {
            iController.NotifyObservers(
                MAknInfoPopupNoteObserver::EInfoPopupNoteHidden );
            }
        }
    }

// -----------------------------------------------------------------------------
// CAknInfoPopupNote::HandleResourceChange
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::HandleResourceChange( TInt aType )
    {
    CCoeControl::HandleResourceChange( aType );
    
    if ( aType == KEikDynamicLayoutVariantSwitch )
        {
        TRAP_IGNORE( SetWindowLayoutL() );
        }
    else if ( aType == KAknsMessageSkinChange && iText )
        {
        TRgb textColor = KRgbBlack;
        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor,
            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 );
        TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL( *iText, EColorLabelText,
                textColor ) );
        }
    else if( aType == KEikMessageFadeAllWindows )
        {
        // Infopopu will be canceled when be faded no matter visible or not.
        if ( iHideWhenAppFaded )
            {
            iController.HideInfoPopupNote();
            }
        }
    }

// -----------------------------------------------------------------------------
// CAknInfoPopupNote::HandlePointerEventL
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::HandlePointerEventL( const TPointerEvent& aPointerEvent )
    {
    if ( AknLayoutUtils::PenEnabled() )
        {
        SetPointerCapture( ETrue );

        if ( aPointerEvent.iType == TPointerEvent::EButton1Down
             || aPointerEvent.iType == TPointerEvent::EButton1Up
             || aPointerEvent.iType == TPointerEvent::EDrag )
            {
            Hide();
            if ( aPointerEvent.iType == TPointerEvent::EButton1Down && !IsVisible() )
                {
                MTouchFeedback* feedback = MTouchFeedback::Instance();
                if ( feedback )
                    {
                    feedback->InstantFeedback( ETouchFeedbackPopUp );
                    }
                }

            SetPointerCapture( EFalse ); 
            }
        }
    }

// -----------------------------------------------------------------------------
// SetWindowLayoutL
//
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetWindowLayoutL()
    {
    if ( iText && iText->Text().Length() > 0 )
        {
        if ( iTooltipMode )
            {
            SetTooltipWindowLayoutL();
            }
        else
            {
            SetInfoPopupWindowLayoutL();
            }
        }
    }

// -----------------------------------------------------------------------------
// SetInfoPopupWindowLayoutL
//
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetInfoPopupWindowLayoutL()
    {
    // Get parameter and table limits for popup preview text window
    TAknLayoutScalableParameterLimits limits = 
        AknLayoutScalable_Avkon::popup_preview_text_window_ParamLimits();

    TAknLayoutScalableTableLimits tableLimits =
        AknLayoutScalable_Avkon::popup_preview_text_window_t_Limits();

    // Get layout rects
    TRect rectScreen = iAvkonAppUi->ApplicationRect();
    TInt mainPaneVariety = Layout_Meta_Data::IsLandscapeOrientation() ? 4 : 1;
    TRect rectMainPane = RectFromLayout( rectScreen,
        AknLayoutScalable_Avkon::main_pane( mainPaneVariety ) );

    // Use first variety to be able to get the font for text parsing
    TInt firstVariety = SelectWindowVariety( 1, limits );

    TRect rectPopupWindow = RectFromLayout( rectMainPane,
        AknLayoutScalable_Avkon::popup_preview_text_window( firstVariety ) );

    TInt firstIndex = tableLimits.FirstIndex();
    TInt firstLineVariety = AknLayoutScalable_Avkon::
        popup_preview_text_window_t_ParamLimits( firstIndex ).FirstVariety();
        
    TAknTextLineLayout popupTextLayout =
        AknLayoutScalable_Avkon::popup_preview_text_window_t(
            firstIndex, firstLineVariety );

    TAknLayoutText layoutText;
    layoutText.LayoutText( rectPopupWindow, popupTextLayout );
    TRect rectText = layoutText.TextRect();

    // Prepare text parsing
    const CFont *font = layoutText.Font();

    CArrayFixFlat<TInt>* lineWidths 
        = new ( ELeave ) CArrayFixFlat<TInt>( KMaxNumOfLines );
    CleanupStack::PushL( lineWidths );

    for ( TInt i = 0; i < KMaxNumOfLines; i++ )
        {
        lineWidths->AppendL( rectText.Width() );
        }

    // Parse text
    iText->ParseTextL( font, lineWidths );
    TInt numberOfLines = iText->NumberOfLines();

    CleanupStack::PopAndDestroy( lineWidths );

    // Select the variety index depending on the number of lines
    TInt windowVariety = SelectWindowVariety( numberOfLines, limits );

    // Set layouts for window and text lines
    AknLayoutUtils::LayoutControl( this, rectMainPane,       
        AknLayoutScalable_Avkon::popup_preview_text_window( windowVariety ) );

    rectPopupWindow = Rect();
    iText->SetRect( rectPopupWindow );

    for ( TInt lineIndex = tableLimits.FirstIndex(), ii = 0;
          ( lineIndex <= tableLimits.LastIndex() ) && ( ii < numberOfLines );
          ++lineIndex, ++ii )
        {
        // Select the variety index depending on the number of lines
        TInt lineVariety = SelectLineVariety( numberOfLines, 
            AknLayoutScalable_Avkon::popup_preview_text_window_t_ParamLimits(
                lineIndex ) );

        popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t(
            lineIndex, lineVariety );

        AknLayoutUtils::LayoutLabel( iText->Line( ii ), rectPopupWindow,
            popupTextLayout, font );
       }

    // Override text color
    TRgb textColor = KRgbBlack;
    AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor,
        KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 );
    AknLayoutUtils::OverrideControlColorL( *iText, EColorLabelText, textColor );

    // Move pop-up note to right location
    if ( IsVisible() )
        {
        Relocate();
        }
    }

// -----------------------------------------------------------------------------
// SetTooltipWindowLayoutL
//
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::SetTooltipWindowLayoutL()
    {
    // Get parameter and table limits for popup preview text window
    TAknLayoutScalableParameterLimits limits = 
        AknLayoutScalable_Avkon::popup_preview_text_window_ParamLimits();

    TAknLayoutScalableTableLimits tableLimits =
        AknLayoutScalable_Avkon::popup_preview_text_window_t_Limits();

    // Get layout rects
    const TRect rectScreen = iAvkonAppUi->ApplicationRect();
    const TRect rectMainPane = rectScreen;

    // Set pop-up to contain only one line of text
    const TInt numberOfLines = 1;
    TInt windowVariety = SelectWindowVariety( numberOfLines, limits );

    TInt lineVariety = SelectLineVariety( numberOfLines, 
        AknLayoutScalable_Avkon:: popup_preview_text_window_t_ParamLimits(
             tableLimits.FirstIndex() ) );

    // Get the font for the text
    TRect rectPopupWindow = RectFromLayout( rectMainPane,
        AknLayoutScalable_Avkon::popup_preview_text_window(
            windowVariety ) );

    TAknTextComponentLayout popupTextLayout =
        AknLayoutScalable_Avkon::popup_preview_text_window_t(
            tableLimits.FirstIndex(), lineVariety );

    TAknLayoutText layoutText;
    layoutText.LayoutText( rectPopupWindow, popupTextLayout );
    const CFont *font = layoutText.Font();
    
    TInt maxLineWidth = ( rectMainPane.Width() - popupTextLayout.l() )
                        - popupTextLayout.r();

    TInt textWidth = font->TextWidthInPixels( iText->Text() );
    textWidth = Min( textWidth, maxLineWidth );

    // Parse text
    CArrayFixFlat<TInt>* lineWidths 
        = new ( ELeave ) CArrayFixFlat<TInt>( numberOfLines );
    CleanupStack::PushL( lineWidths );

    lineWidths->AppendL( textWidth );
    iText->ParseTextL( font, lineWidths );
    
    CleanupStack::PopAndDestroy( lineWidths );

    // Set layout for window
    rectPopupWindow = RectFromLayout( rectMainPane,
        AknLayoutScalable_Avkon::popup_preview_text_window( windowVariety ) );

    // Adjust window size depending on text length
    SetSize( TSize( textWidth + popupTextLayout.l() + popupTextLayout.r(),
                    rectPopupWindow.Height() ) );

    // Set layout for text lines
    rectPopupWindow = Rect();
    iText->SetRect( rectPopupWindow );

    for ( TInt lineIndex = tableLimits.FirstIndex(), ii = 0;
          ( lineIndex <= tableLimits.LastIndex() ) && ( ii < numberOfLines );
          ++lineIndex, ++ii )
        {
        popupTextLayout = AknLayoutScalable_Avkon::popup_preview_text_window_t(
            lineIndex, lineVariety );

        AknLayoutUtils::LayoutLabel( iText->Line( ii ), rectPopupWindow,
                                     popupTextLayout, font );
        }

    // Override text color
    TRgb textColor = KRgbBlack;
    AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor,
        KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG55 );
    AknLayoutUtils::OverrideControlColorL( *iText, EColorLabelText, textColor );

    // Move tooltip to right location
    if ( IsVisible() )
        {
        Relocate();
        }
    }

// -----------------------------------------------------------------------------
// Relocate
// 
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::Relocate()
    {
    if ( !iFloatingPositionUsed )
        {
        return;
        }

    TRect rect( Rect() );
    TPoint delta( 0, 0 );

    switch (iAlignment)
        {
        case EHLeftVTop:
            {
            // Tooltip is left and top aligned.
            break;
            }
        case EHLeftVCenter:
            {
            // Tooltip left aligned and centred vertically.
            delta.iY = rect.Height() / 2;
            break;
            }
        case EHLeftVBottom:
            {
            // Tooltip is left aligned and at the bottom.
            delta.iY = rect.Height();
            break;
            }
        case EHCenterVTop:
            {
            // Tooltip is centre aligned horizontally and at the top.
            delta.iX = rect.Width() / 2;
            break;
            }
        case EHCenterVCenter:
            {
            // Tooltip is centred horizontally and vertically.
            delta.SetXY( rect.Width() / 2, rect.Height() / 2 );
            break;
            }
        case EHCenterVBottom:
            {
            // Tooltip is centred horizontally and at the bottom.
            delta.SetXY( rect.Width() / 2, rect.Height() );
            break;
            }
        case EHRightVTop:
            {
            // Tooltip is right and top aligned.
            delta.iX = rect.Width();
            break;
            }
        case EHRightVCenter:
            {
            // Tooltip right aligned and centred vertically.
            delta.SetXY( rect.Width(), rect.Height() / 2 );
            break;
            }
        case EHRightVBottom:
            {
            // Tooltip is right aligned and at the bottom.
            delta.SetXY( rect.Width(), rect.Height() );
            break;
            }
        default:
            {
            break;
            }
        }
        
    AdjustPosition( TPoint( iFloatingPosition - delta ) );

    if ( iFloatingPosition != iPosition )
        {
        SetPosition( iFloatingPosition );
        }
    }

// -----------------------------------------------------------------------------
// AdjustPosition
// Adjusts the position of the info pop-up note so that it fits the screen and
// does not overlap with the control pane.
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::AdjustPosition( const TPoint& aFloatingPosition )
    {
    TRect area( iAvkonAppUi->ApplicationRect() );

    if ( iAvkonAppUi->IsDisplayingControlBetweenPriorities(
             ECoeStackPriorityCba - 1, ECoeStackPriorityCba + 1 ) )
        {
        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, area );

        if ( !AknStatuspaneUtils::StaconPaneActive() )
            {
            TRect statusPaneRect;
            AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EStatusPane,
                                               statusPaneRect );
            
            area.BoundingRect( statusPaneRect );
            }
        }

    TRect rect( aFloatingPosition, Size() );

    iFloatingPosition.SetXY( Max( area.iTl.iX, Min( rect.iBr.iX, area.iBr.iX )
                              - rect.Width() ),
                         Max( area.iTl.iY, Min( rect.iBr.iY, area.iBr.iY )
                              - rect.Height() ) );
    }

// -----------------------------------------------------------------------------
// RectFromLayout
//
// -----------------------------------------------------------------------------
//
TRect CAknInfoPopupNote::RectFromLayout( const TRect& aParent,
        const TAknWindowComponentLayout& aComponentLayout ) const
    {
    TAknWindowLineLayout lineLayout = aComponentLayout.LayoutLine();
    TAknLayoutRect layoutRect;
    layoutRect.LayoutRect(aParent, lineLayout);
    return layoutRect.Rect();
    }

// -----------------------------------------------------------------------------
// SelectLineVariety
//
// -----------------------------------------------------------------------------
//
TInt CAknInfoPopupNote::SelectLineVariety( const TInt aNumberOfLines,
        const TAknLayoutScalableParameterLimits& aLimits ) const
    {
    return Min( Max( aNumberOfLines - 1, aLimits.FirstVariety() ),
                aLimits.LastVariety() );
    }

// -----------------------------------------------------------------------------
// SelectWindowVariety
//
// -----------------------------------------------------------------------------
//
TInt CAknInfoPopupNote::SelectWindowVariety( const TInt aNumberOfLines,
        const TAknLayoutScalableParameterLimits& aLimits ) const
    {
    TInt index = aNumberOfLines - 1;
    if ( Layout_Meta_Data::IsLandscapeOrientation() )
        {
        index += 5;
        }

    return Min( Max( index, aLimits.FirstVariety() ),
                aLimits.LastVariety() );
    }

// -----------------------------------------------------------------------------
// HandleGainingForeground
//
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::HandleGainingForeground()
    {
    // empty implementation
    }
    
// -----------------------------------------------------------------------------
// HandleLosingForeground
//
// -----------------------------------------------------------------------------
//
void CAknInfoPopupNote::HandleLosingForeground()
    {
    if ( IsVisible() && iHideWhenAppFaded )
        {
        iController.HideInfoPopupNote();
        }
    }

//  End of File  
