/*
* Copyright (c) 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:       Text scrolling functionality.
*
*/


// INCLUDE FILES
#include "HgMarquee.h"
#include <biditext.h>
#include <AknBidiTextUtils.h>
#include <AknUtils.h>
#include <AknLayout2ScalableDef.h>
#include "HgConstants.h"

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

// -----------------------------------------------------------------------------
// CAknMarqueeControl::CAknMarqueeControl
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CHgMarquee::CHgMarquee(const TInt aLoops, const TInt aScrollAmount, 
                                       const TInt aScrollDelay) : 
    iDelta(0),
    iDelay(aScrollDelay),
    iSpeed(aScrollAmount),
    iInterval(KHgMarqueeInterval),
    iLoops(0),
    iMaxLoops(aLoops),
    iLastCharacter(EFalse)
    {
    iFlags.Set( EFlagIsBeginningOfLoop );
    iFlags.Set( EFlagUseVisualToLogicalConversion );
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHgMarquee::ConstructL()
    {
    iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHgMarquee* CHgMarquee::NewLC(const TInt aLoops, 
                                                       const TInt aScrollAmount,
                                                       const TInt aScrollDelay)
    {
    CHgMarquee* self = new( ELeave )CHgMarquee(aLoops, aScrollAmount, aScrollDelay);
    
    CleanupStack::PushL( self );
    self->ConstructL();

    return self;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CHgMarquee* CHgMarquee::NewL(const TInt aLoops, 
                                                      const TInt aScrollAmount,
                                                      const TInt aScrollDelay)
    {
    CHgMarquee* self = CHgMarquee::NewLC(aLoops, aScrollAmount, aScrollDelay);
    CleanupStack::Pop( self );

    return self;
    }
    
// Destructor
CHgMarquee::~CHgMarquee()
    {
    if (iPeriodicTimer)
        {
        iPeriodicTimer->Cancel();
        delete iPeriodicTimer;
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::SetRedrawCallBack
// 
// -----------------------------------------------------------------------------
//
void CHgMarquee::SetRedrawCallBack(TCallBack& aCallBack)
    {
    iCallBack = aCallBack;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::DrawText
// 
// -----------------------------------------------------------------------------
//
TBool CHgMarquee::DrawText(
    CWindowGc& aGc,
    const TRect& aRect,
    const TAknTextComponentLayout& aTextLayout,
    const TDesC& aText,
    const TRgb& aColor )
    {
    // In this function, TAknLayoutText::DrawText performs logical-to-visual
    // conversion for the given text.
    if ( iLoops < iMaxLoops && aText.Length() < KAknSensibleLength ) // Has every loop been executed
        {
        TAknLayoutText textLayout;
        textLayout.LayoutText( aRect, aTextLayout );

        TRect marqueeRect( textLayout.TextRect() );
        TInt textWidth = textLayout.Font()->TextWidthInPixels( aText );
        if ( textWidth <= marqueeRect.Width() )
            {
            iLoops = iMaxLoops;
            return ETrue;
            }
    
        if ( TBidiText::TextDirectionality( aText ) == TBidiText::ELeftToRight )
            iFlags.Set( EFlagIsWestern );
        else
            iFlags.Clear( EFlagIsWestern );

        aGc.SetClippingRect( marqueeRect );
        
        if ( iFlags.IsSet( EFlagIsBeginningOfLoop ) &&
            !iFlags.IsSet( EFlagIsWaitingForCallBack ) )
            {
            Stop();     // Just in case
            textLayout.DrawText( aGc, aText, iFlags.IsSet( EFlagUseVisualToLogicalConversion ), aColor );
            iFlags.Clear( EFlagIsBeginningOfLoop );
            Start();
            }
        else if ( iDelta == 0 ) // we are still drawing non-scrolling text (2 line lists need this)
            {
            textLayout.DrawText( aGc, aText, iFlags.IsSet( EFlagUseVisualToLogicalConversion ), aColor );
            }
        else if ( iFlags.IsSet( EFlagIsWestern ) ) // Scrolls from right to left.
            {
            DrawWestern(
                    aGc, 
                    aRect, 
                    marqueeRect, 
                    aTextLayout, 
                    textLayout, 
                    aText, 
                    textWidth, 
                    aColor);
            }
        else    // Non-western, scrolls from left to right.
            {
            DrawNonWestern(
                    aGc, 
                    aRect, 
                    marqueeRect, 
                    aTextLayout, 
                    textLayout, 
                    aText, 
                    textWidth, 
                    aColor);
            }

        aGc.CancelClippingRect();
        // Time to let the parent know if all loops aren't executed yet.
        return EFalse;
        }
    else    // No more loops to be executed -> draw text in the default position.
        {
        Stop();         // No need to generate events any longer.
        return ETrue;   // Indicate the parent that marquee has stopped,  
        }               // parent is then able to for example truncate the text.
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::DrawWestern
// Starts scrolling the text.
// -----------------------------------------------------------------------------
//
void CHgMarquee::DrawWestern( CWindowGc& aGc,
                         const TRect& aRect,
                         const TRect& aMarqueeRect,
                         const TAknTextComponentLayout& aTextLayout,
                         TAknLayoutText aLayout,
                         const TDesC& aText,
                         TInt aTextWidth,
                         const TRgb& aColor )
    {
    TRect rect = aRect;
    rect.SetWidth( aRect.Width() + ( aTextWidth - aMarqueeRect.Width() ) );
    rect.Move(-iDelta, 0);

    // ESRY-7M5A33
    // Due to text rolling region is not actual parent region, 
    // textLayout.TextRect() is incorrect. Introduce a temparory layout to recalculate.   
    TAknTextLineLayout  tmpTextLineLayout = aTextLayout;
    tmpTextLineLayout.iW = aTextWidth;
    aLayout.LayoutText( rect, tmpTextLineLayout );
        
    aLayout.DrawText( aGc, aText, iFlags.IsSet( EFlagUseVisualToLogicalConversion ), aColor );

    if ( iFlags.IsSet( EFlagIsWaitingForCallBack ) )
        {
        // do nothing
        }
    // Sliding behaviour: When the last character is visible, scrolling stops
    // and starts from the beginning after a short delay.
    else if ( aLayout.TextRect().iBr.iX >= aMarqueeRect.iBr.iX )
        {
        iFlags.Clear( EFlagIsBeginningOfLoop );
        if ( !iPeriodicTimer->IsActive() )
            Start();
        }
    else    // Last character has appeared, so let's make it reappear from the other 
        {   // side after a delay
        iFlags.Set( EFlagIsBeginningOfLoop );
        iFlags.Set( EFlagIsWaitingForCallBack );
        iLastCharacter = ETrue;
        Stop();    // Cancel all outstanding requests.
        ++iLoops;
        Start();
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::DrawNonWestern
// Starts scrolling the text.
// -----------------------------------------------------------------------------
//
void CHgMarquee::DrawNonWestern( CWindowGc& aGc,
                         const TRect& aRect,
                         const TRect& aMarqueeRect,
                         const TAknTextComponentLayout& aTextLayout,
                         TAknLayoutText aLayout,
                         const TDesC& aText,
                         TInt aTextWidth,
                         const TRgb& aColor )
    {
    TRect rect = aRect;
    // Prepare rect to be scrolled from l -> r
    rect.iTl.iX = rect.iTl.iX - ( aTextWidth - aMarqueeRect.Width() );
    rect.Move(iDelta, 0);

    // note refer to case western               
    TAknTextLineLayout  tmpTextLineLayout = aTextLayout;
    tmpTextLineLayout.iW = aTextWidth;
    aLayout.LayoutText( rect, tmpTextLineLayout );
    
    aLayout.DrawText( aGc, aText, iFlags.IsSet( EFlagUseVisualToLogicalConversion ), aColor );

    if ( iFlags.IsSet( EFlagIsWaitingForCallBack ) )
        {
        // do nothing
        }
    else if ( aLayout.TextRect().iTl.iX < aMarqueeRect.iTl.iX ) 
        {
        iFlags.Clear( EFlagIsBeginningOfLoop );
        if ( !iPeriodicTimer->IsActive() )
            Start();
        }
    else    // Last character has appeared
        {
        iFlags.Set( EFlagIsBeginningOfLoop );
        iFlags.Set( EFlagIsWaitingForCallBack );
        iLastCharacter = ETrue;
        Stop();    // Cancel all outstanding requests.
        ++iLoops;
        Start();
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::Start
// Starts scrolling the text.
// -----------------------------------------------------------------------------
//
void CHgMarquee::Start()
    {
    if ( iFlags.IsSet( EFlagIsOn ) ) 
        {
        if ( !iPeriodicTimer->IsActive() )  // start timer if not already started
            {
            iPeriodicTimer->Start( TTimeIntervalMicroSeconds32( iDelay ),
                                   TTimeIntervalMicroSeconds32( iInterval ), 
                                   TCallBack( CHgMarquee::ScrollEvent, this ) );
            }
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::Stop
// Stops scrolling the text.
// -----------------------------------------------------------------------------
//
void CHgMarquee::Stop()
    {
    //Stop the timer if it is active
    if ( iPeriodicTimer->IsActive() )
        {
        iPeriodicTimer->Cancel();
        }
    if ( !iFlags.IsSet(EFlagIsWaitingForCallBack) )
        {
        iDelta = 0;            // reset scroll position
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::Reset
// Resets the animation data.
// -----------------------------------------------------------------------------
//
void CHgMarquee::Reset()
    {
    iDelta = 0;            // reset scroll position
    iLoops = 0;
    iLastCharacter = EFalse;
    Stop();
    iFlags.Set( EFlagIsBeginningOfLoop );
    iFlags.Clear( EFlagIsWaitingForCallBack );
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::IsMarqueeOn
// Returns marquee status
// Two versions to discard compiler warnings
// -----------------------------------------------------------------------------
//
#ifdef __WINS__
const TBool CHgMarquee::IsMarqueeOn()
    {
    return iFlags.IsSet( EFlagIsOn );
    }
#else
TBool CHgMarquee::IsMarqueeOn()
    {
    return iFlags.IsSet( EFlagIsOn );
    }
#endif // __WINS__

// -----------------------------------------------------------------------------
// CAknMarqueeControl::SetSpeedInPixels
// sets scrolling speed in pixels
// -----------------------------------------------------------------------------
//
void CHgMarquee::SetSpeedInPixels(TInt aSpeed)
    {
    if ( aSpeed <= 0 )
        aSpeed = KHgMarqueeSpeed;
    iSpeed = aSpeed;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::SetDelay
// Sets delay between loops
// -----------------------------------------------------------------------------
//
void CHgMarquee::SetDelay(TInt aDelay)
    {
    if ( aDelay < 0 )
        aDelay = KHgMarqueeDelay;
    iDelay = aDelay;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::SetInterval
// Sets scrolling interval
// -----------------------------------------------------------------------------
//
void CHgMarquee::SetInterval(TInt aInterval)
    {
    iInterval = aInterval;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::SetLoops
// Sets the amount of maximum loops to be executed.
// -----------------------------------------------------------------------------
//
void CHgMarquee::SetLoops(TInt aLoops)
    {
    if ( aLoops < 0 )
        aLoops = KHgMarqueeLoops;
    iMaxLoops = aLoops;
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::DoScroll
// advances text position and instructs parent control to do a redraw
// -----------------------------------------------------------------------------
//
void CHgMarquee::DoScroll()
    {
    if ( !iFlags.IsSet( EFlagIsWaitingForCallBack ) )
        {
        iDelta += iSpeed;            // advance text
        }
  
    iFlags.Clear( EFlagIsWaitingForCallBack );
    
    if ( !iCallBack.CallBack() )   // stop timer if callback returns false
        {
        iPeriodicTimer->Cancel();
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::ScrollEvent
// This static function is called by the periodic timer
// -----------------------------------------------------------------------------
//
TInt CHgMarquee::ScrollEvent(TAny * aPtr)
    {
    ( ( CHgMarquee* ) aPtr )->DoScroll();
    return TRUE; // run again
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::EnableMarquee
// Enables/disables marquee feature.
// -----------------------------------------------------------------------------
//
void CHgMarquee::EnableMarquee(TBool aEnable)
    {
    if ( aEnable )
        {
        iFlags.Set( EFlagIsOn );
        }
    else
        {
        iFlags.Clear( EFlagIsOn );
        }
    }

// -----------------------------------------------------------------------------
// CAknMarqueeControl::UseLogicalToVisualConversion
// -----------------------------------------------------------------------------
//

void CHgMarquee::UseLogicalToVisualConversion(
    TBool aUseConversion )
    {
    if ( aUseConversion )
        {
        iFlags.Set( EFlagUseVisualToLogicalConversion );
        }
    else
        {
        iFlags.Clear( EFlagUseVisualToLogicalConversion );
        }
    }

//  End of File