MCL/sf/app/homescreen: comparison idlehomescreen/xmluirendering/renderingplugins/xnnewstickerfactory/src/xnnewstickeradapter.cpp

equal deleted inserted replaced

-:137ebc85284b
+:1b758917cafc
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
-* Description:  Implementation for wrapper for a label
+* Description:  Marquee control
 *
 */
 // System includes
 #include <utf.h>
 #include "xnnewstickeradapter.h"
 #include "xnnewstickercontrol.h"
 #include "xncomponentnodeimpl.h"
+// Constants
 const TInt KThousandCoef = 1000;
 const TInt KByteLength = 8;
+const TInt KXnNewstickerDelay = 1000000;   // start scrolling after a delay of 1 second
+const TInt KXnNewstickerInterval = 100000; // scroll 10 times in a second
+const TInt KXnNewstickerScrollAmount = 6;  // scroll 6 pixels at time
 // ============================= LOCAL FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CXnNewstickerAdapter::SetNewstickerPropertiesL()
 {
 // scroll amount
-TInt scrollamount = GetIntPropertyL( iNode,
+TInt scrollamount( GetIntPropertyL( iNode,
-XnPropertyNames::newsticker::KXnScrollAmount );   // px
+XnPropertyNames::newsticker::KXnScrollAmount ) );   // px
-if( KErrNotFound == scrollamount )
+if ( scrollamount == KErrNotFound )
 {
 scrollamount = KXnNewstickerScrollAmount;
 }
 CXnProperty* prop( iNode.GetPropertyL(
 XnPropertyNames::newsticker::KScrollBehaviour ) );
-if( prop )
+// Default
-{
+iScrollBehaviour = EScroll;
-if ( prop->StringValue() ==
-XnPropertyNames::newsticker::scroll_behaviour::KAlternate )
+if ( prop )
+{
+const TDesC8& value( prop->StringValue() );
+if ( value == XnPropertyNames::newsticker::scroll_behaviour::KAlternate )
 {
 scrollamount = 0;
 iScrollBehaviour = EAlternate;
 }
-else if ( prop->StringValue() ==
+else if ( value == XnPropertyNames::newsticker::scroll_behaviour::KScrollAlternate )
-XnPropertyNames::newsticker::scroll_behaviour::KScrollAlternate )
 {
 iScrollBehaviour = EScrollAlternate;
 }
-else
+}
-{
-iScrollBehaviour = EScroll;
-}
-}
-else
-{
-iScrollBehaviour = EScroll;
-}
 iMarqueeControl->SetSpeedInPixels( scrollamount );
-if( iScrollBehaviour == EScroll )
+if ( iScrollBehaviour == EScroll || iScrollBehaviour == EScrollAlternate )
 {
-// scroll delay
+// scroll delay, i.e. fps
-TInt scrolldelay = GetIntPropertyL( iNode,
+TInt scrolldelay( GetIntPropertyL( iNode,
-XnPropertyNames::newsticker::KXnScrollDelay );  // ms
+XnPropertyNames::newsticker::KXnScrollDelay ) );  // ms
-if( KErrNotFound == scrolldelay )
+if ( scrolldelay == KErrNotFound )
 {
 scrolldelay = KXnNewstickerInterval;
 }
 else
 {
-scrolldelay *= KThousandCoef;    // change to microseconds
+// change to seconds
-}
+scrolldelay *= KThousandCoef;
+}
-iMarqueeControl->SetInterval( scrolldelay );
-iAlternateInterval = scrolldelay;
+iMarqueeControl->SetInterval( scrolldelay );
 // start delay
-TInt startdelay = GetIntPropertyL( iNode,
+TInt startdelay( GetIntPropertyL( iNode,
-XnPropertyNames::newsticker::KXnStartDelay ); // ms
+XnPropertyNames::newsticker::KXnStartDelay ) ); // ms
-if( KErrNotFound == startdelay )
+if ( startdelay == KErrNotFound )
 {
 startdelay = KXnNewstickerDelay;
 }
 else
 {
-startdelay *= KThousandCoef;    // change to microseconds
+// change to seconds
+startdelay *= KThousandCoef;
 }
 iMarqueeControl->SetDelay( startdelay );
 iAlternateDelay = startdelay;
-}
-else if( iScrollBehaviour == EScrollAlternate )
+if ( iScrollBehaviour == EScrollAlternate )
-		{
+{
-// scroll delay
+TInt alternateTime( GetIntPropertyL( iNode,
-TInt scrolldelay = GetIntPropertyL( iNode,
+XnPropertyNames::newsticker::KDisplayTime ) );
-XnPropertyNames::newsticker::KXnScrollDelay );  // ms
+if( alternateTime == KErrNotFound )
-if( KErrNotFound == scrolldelay )
+{
-{
+alternateTime = KXnNewstickerDelay;
-scrolldelay = KXnNewstickerInterval;
+}
-}
+else
-else
+{
-{
+// change to seconds
-scrolldelay *= KThousandCoef;    // change to microseconds
+alternateTime *= KThousandCoef;
 }
-iMarqueeControl->SetInterval( scrolldelay );
+iAlternateDelay = alternateTime;
-iAlternateInterval = scrolldelay;
+}
+}
-TInt alternateTime( GetIntPropertyL( iNode, XnPropertyNames::newsticker::KDisplayTime ) );
-if( alternateTime == KErrNotFound )
-{
-alternateTime = 0;
-}
-alternateTime *= KThousandCoef; // change to ms
-iAlternateInterval = alternateTime;
-// start delay
-TInt startdelay = GetIntPropertyL( iNode,
-XnPropertyNames::newsticker::KXnStartDelay ); // ms
-if( KErrNotFound == startdelay )
-{
-startdelay = 0;
-}
-else
-{
-startdelay *= KThousandCoef;    // change to microseconds
-}
-iMarqueeControl->SetDelay( startdelay );
-iAlternateDelay = startdelay;
-}
 else // TScrollBehaviour::EAlternate
 {
-TInt alternateTime( GetIntPropertyL( iNode, XnPropertyNames::newsticker::KDisplayTime ) );
+TInt alternateTime( GetIntPropertyL(
+iNode, XnPropertyNames::newsticker::KDisplayTime ) );
-if( alternateTime == KErrNotFound )
-{
+if ( alternateTime == KErrNotFound )
-alternateTime = 0;
+{
-}
+alternateTime = KXnNewstickerDelay;
+}
-alternateTime *= KThousandCoef; // change to ms
+else
+{
+// change to seconds
+alternateTime *= KThousandCoef;
+}
 iMarqueeControl->SetDelay( 0 );
-iMarqueeControl->SetInterval( alternateTime );
+iMarqueeControl->SetInterval( 0 );
-iAlternateDelay = 0;
+iAlternateDelay = alternateTime;
-iAlternateInterval = alternateTime;
 }
 // _s60-scroll-loop property. True by default.
 CXnProperty* loopProp( iNode.GetPropertyL(
 XnPropertyNames::newsticker::KScrollLoop ) );
-if( loopProp && loopProp->StringValue() == XnPropertyNames::KFalse )
+TBool looping( ETrue );
-{
-iScrollLooping = EFalse;
+if ( loopProp && loopProp->StringValue() == XnPropertyNames::KFalse )
-}
+{
-else
+looping = EFalse;
-{
+}
-iScrollLooping = ETrue;
-}
+iControl->SetScrollLooping( looping );
 CXnProperty* restartProperty( iNode.GetPropertyL(
 XnPropertyNames::newsticker::KRestartAfterUpdate ) );
 if ( restartProperty && restartProperty->StringValue() == XnPropertyNames::KTrue )
 {
 iRestartAfterUpdate = ETrue;
 }
 }
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::NewL
 TCallBack callback( RedrawCallback, this );
 iMarqueeControl->SetRedrawCallBack( callback );
 iMarqueeControl->SetContainerWindowL( *aParent );
 iMarqueeControl->ActivateL();
-iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityStandard );
+iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityLow );
 SetTextPropertiesL();
 SetNewstickerPropertiesL();
 RPointerArray<CXnNodePluginIf> children = iNode.ChildrenL();
 for( TInt i = 0; i < children.Count(); ++i )
 {
 CXnNodePluginIf* child( children[i] );
-CXnType* xnType = child->Type();
+const TDesC8& type( child->Type()->Type() );
 // We only care for <title> nodes
-if ( xnType && xnType->Type() == XnPropertyNames::title::KTitle )
+if ( type == XnPropertyNames::title::KTitle )
 {
-// Append  title, if one is given from the theme use that.
+iControl->AppendTitleL( KNullDesC );
-// If no content yet available create empty title so that
+}
-// indexing is always current
+}
-const TDesC8& pcData( child->GetPCData() );
+CleanupStack::PopAndDestroy( &children );
-HBufC* pcData16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L( pcData );
-CleanupStack::PushL( pcData16 );
-TPtr ptr( pcData16->Des() );
-CXnUtils::CollapseWhiteSpace( iNode, ptr );
-if( ptr.Length() > 0 )
-{
-iControl->AppendTitleL( *pcData16 );
-}
-else
-{
-iControl->AppendTitleL( KNullDesC );
-}
-CleanupStack::PopAndDestroy( pcData16 );
-}
-}
-CleanupStack::PopAndDestroy( &children );
-iControl->SetCurrentTitle( ETrue );
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::CXnNewstickerAdapter
 // C++ default constructor
 // -----------------------------------------------------------------------------
 //
 CXnNewstickerAdapter::CXnNewstickerAdapter( CXnControlAdapter* /*aParent*/,
 CXnNodePluginIf& aNode )
 : iNode( aNode ),
-iPowerSaveMode( ETrue ),
+iPowerSaveMode( EFalse ),
 iRestartAfterUpdate( EFalse ),
 iTextColor( KRgbBlack ),
-iTextAlignment( ELayoutAlignLeft ),
+iTextAlignment( CGraphicsContext::ELeft ),
 iTextBaseline( 0 ),
 iUnderlining( EUnderlineOff ),
 iStrikethrough( EStrikethroughOff ),
-iScrollLooping( ETrue ),
 iRedraw( ETrue )
 {
 }
 // -----------------------------------------------------------------------------
 // C++ destructor
 // -----------------------------------------------------------------------------
 //
 CXnNewstickerAdapter::~CXnNewstickerAdapter()
 {
-if( iPeriodicTimer && iPeriodicTimer->IsActive() )
-{
-iPeriodicTimer->Cancel();
-}
 delete iPeriodicTimer;
 if( iFont && ( iReleaseFont == 1 ) )
 {
 CWsScreenDevice* dev = iCoeEnv->ScreenDevice();
 dev->ReleaseFont( iFont );
 }
 delete iMarqueeControl;
 delete iControl;
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::SetTextPropertiesL
 // Sets text properties, such as color, font, etc.
 TGulAlignmentValue alignment = CXnUtils::TextAlignment( iNode );
 switch( alignment )
 {
 case EHCenterVCenter:
-iTextAlignment = ELayoutAlignCenter;
+iTextAlignment = CGraphicsContext::ECenter;
 break;
 case EHRightVCenter:
-iTextAlignment = ELayoutAlignRight;
+iTextAlignment = CGraphicsContext::ERight;
 break;
 default:
-iTextAlignment = ELayoutAlignLeft;
+iTextAlignment = CGraphicsContext::ELeft;
 break;
 }
 }
 // -----------------------------------------------------------------------------
 {
 iControl->UpdateTitleL( aTitle, aIndex );
 iNode.SetDirtyL();
 if ( iRestartAfterUpdate )
 {
-Stop();
+Restart();
-Start();
 }
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DeleteTitleL
 iControl->ClearTitles();
 TRAP_IGNORE( iNode.SetDirtyL() );
 }
 // -----------------------------------------------------------------------------
-// CXnNewstickerAdapter::SetCallbackInterfaceL
+// CXnNewstickerAdapter::Restart
 // -----------------------------------------------------------------------------
 //
-void CXnNewstickerAdapter::SetCallbackInterfaceL(
+void CXnNewstickerAdapter::Restart()
-XnNewstickerInterface::MXnNewstickerCallbackInterface* aCallback )
+{
-{
+Stop();
-iCallback = aCallback;
+Start( ETrue );
 }
 // -----------------------------------------------------------------------------
-// CXnNewstickerAdapter::TitleScrolled
+// CXnNewstickerAdapter::Start
 // -----------------------------------------------------------------------------
 //
-void CXnNewstickerAdapter::TitleScrolled( TInt aTitleIndex )
+void CXnNewstickerAdapter::Start( TBool aSelectTitle )
 {
-if( iCallback )
+if ( IsVisible() && !iPowerSaveMode && !iNode.Rect().IsEmpty() )
 {
-iCallback->TitleScrolled( aTitleIndex );
+if ( aSelectTitle )
-}
+{
-}
+if ( iControl->SelectTitle() == KErrNotFound )
+{
-// -----------------------------------------------------------------------------
+return;
-// CXnNewstickerAdapter::StartL
+}
-// -----------------------------------------------------------------------------
+}
-//
-void CXnNewstickerAdapter::Start()
+const TDesC& title( iControl->CurrentTitle() );
-{
-if( IsVisible() && !iPowerSaveMode )
+switch ( iScrollBehaviour )
-{
-if( iControl->TitleCount() < 1 )
-{
-// Nothing to show
-return;
-}
-switch( iScrollBehaviour )
 {
 case EScroll:
+case EScrollAlternate:
 {
 iMarqueeControl->EnableMarquee( ETrue );
 iRedraw = ETrue;
-}
-break;
+TInt textWidth(
+iFont->TextWidthInPixels( title ) );
+TInt rectWidth( iNode.Rect().Width() );
+if ( textWidth < rectWidth )
+{
+StartAlternateCounter();
+}
+}
+break;
 case EAlternate:
 {
 iMarqueeControl->EnableMarquee( EFalse );
 StartAlternateCounter();
 }
 break;
-case EScrollAlternate:
-{
-iMarqueeControl->EnableMarquee( ETrue );
-StartAlternateCounter();
-iRedraw = ETrue;
-}
-break;
 default:
 break;
 }
+DrawDeferred();
 }
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::Stop
 // CXnNewstickerAdapter::StopAlternateCounter
 // -----------------------------------------------------------------------------
 //
 void CXnNewstickerAdapter::StopAlternateCounter()
 {
-if( iPeriodicTimer && iPeriodicTimer->IsActive() )
+iPeriodicTimer->Cancel();
-{
-iPeriodicTimer->Cancel();
-}
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::StopMarquee
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::StartCounter
 // -----------------------------------------------------------------------------
 //
 void CXnNewstickerAdapter::StartAlternateCounter()
 {
-if( iPeriodicTimer && iPeriodicTimer->IsActive() )
+iPeriodicTimer->Cancel();
-{
-iPeriodicTimer->Cancel();
-}
 iPeriodicTimer->Start(
 TTimeIntervalMicroSeconds32( iAlternateDelay ),
-TTimeIntervalMicroSeconds32( iAlternateInterval ),
+TTimeIntervalMicroSeconds32( 0 ),
-TCallBack( CXnNewstickerAdapter::PeriodicEventL, this ) );
+TCallBack( PeriodicEventL, this ) );
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::PeriodicEventL
 // -----------------------------------------------------------------------------
 //
 TInt CXnNewstickerAdapter::PeriodicEventL( TAny* aPtr )
 {
 __PRINTS( "CXnNewstickerAdapter::PeriodicEventL, timer runs" );
 CXnNewstickerAdapter* self = static_cast< CXnNewstickerAdapter* >( aPtr );
-self->DoScroll();
+self->iPeriodicTimer->Cancel();
+TBool endOfLoop( self->iControl->SelectNextTitle() );
+self->DoScroll( endOfLoop );
+self->DrawNow();
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::MakeVisible()
 //
 void CXnNewstickerAdapter::MakeVisible( TBool aVisible )
 {
 CCoeControl::MakeVisible( aVisible );
-if( aVisible )
+if ( aVisible )
 {
-Start();
+Restart();
 }
 else
 {
 Stop();
 }
 void CXnNewstickerAdapter::SizeChanged()
 {
 CXnControlAdapter::SizeChanged();
 iMarqueeControl->SetExtent( iNode.Rect().iTl, iNode.Rect().Size() );
 iTextBaseline = iNode.Rect().Height() / 2 + iFont->AscentInPixels() / 2;
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::CountComponentControls() const
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::ComponentControl(TInt aIndex) const
 // -----------------------------------------------------------------------------
 //
 CCoeControl* CXnNewstickerAdapter::ComponentControl( TInt aIndex ) const
 {
-switch ( aIndex )
+if ( aIndex == 0 )
 {
-case 0:
+return iMarqueeControl;
-return iMarqueeControl;
+}
-default:
+return NULL;
-return NULL;
-}
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DoHandlePropertyChangeL
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::ReportNewstickerEventL
 // -----------------------------------------------------------------------------
 //
-void CXnNewstickerAdapter::ReportNewstickerEvent( const TDesC8& aEventName )
+void CXnNewstickerAdapter::ReportNewstickerEvent( const TDesC8& aEventName,
+TInt aIndex )
 {
-TBuf8<KByteLength>index( KNullDesC8 );
+TBuf8< KByteLength >index( KNullDesC8 );
-index.Num( CurrentTitleIndex() );
+index.Num( aIndex );
 TRAP_IGNORE( iNode.ReportTriggerEventL( aEventName,
 XnPropertyNames::action::trigger::name::KTitleIndex, index ); )
 }
 // CXnNewstickerAdapter::Draw
 // Draws the text component
 // -----------------------------------------------------------------------------
 void CXnNewstickerAdapter::Draw( const TRect& aRect ) const
 {
-const_cast<CXnNewstickerAdapter*>(this)->DrawText( iControl->SelectTitle(), aRect );
+CXnControlAdapter::Draw( aRect );
+if ( iControl->CurrentTitleIndex() != KErrNotFound )
+{
+const TDesC& title( iControl->CurrentTitle() );
+const_cast< CXnNewstickerAdapter* >( this )->DrawText( title );
+}
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DoEnterPowerSaveModeL
 // Enter power save mode
 // -----------------------------------------------------------------------------
 void CXnNewstickerAdapter::DoEnterPowerSaveModeL( TModeEvent /*aEvent*/ )
 {
 iPowerSaveMode = ETrue;
 Stop();
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DoExitPowerSaveModeL
 // -----------------------------------------------------------------------------
 void CXnNewstickerAdapter::DoExitPowerSaveModeL( TModeEvent /*aEvent*/ )
 {
 iPowerSaveMode = EFalse;
-if( IsVisible() )
+if ( IsVisible() )
 {
-Start();
+Restart();
 }
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DrawText
 // Text drawing function is selected by scrolling behaviour
 // -----------------------------------------------------------------------------
-void CXnNewstickerAdapter::DrawText( const TDesC& aText, const TRect& aRect )
+void CXnNewstickerAdapter::DrawText( const TDesC& aText )
 {
-CWindowGc& gc = SystemGc();
+CWindowGc& gc( SystemGc() );
-TRect rect = iNode.Rect();
+TRect rect( iNode.Rect() );
-CXnControlAdapter::Draw( aRect );
 gc.SetPenColor( iTextColor );
 gc.UseFont( iFont );
 gc.SetUnderlineStyle( iUnderlining );
 gc.SetStrikethroughStyle( iStrikethrough );
-TInt textWidth = iFont->TextWidthInPixels( aText );
+TInt textWidth( iFont->TextWidthInPixels( aText ) );
-TInt rectWidth = rect.Width();
+TInt rectWidth( rect.Width() );
-switch( iScrollBehaviour )
+switch ( iScrollBehaviour )
 {
 case EScroll:
 case EScrollAlternate:
 {
-if( !iRedraw || textWidth < rectWidth )
+if ( !iRedraw || textWidth < rectWidth )
 {
 iMarqueeControl->Stop();
 DrawStaticText( gc, aText );
 }
 else
 {
 iMarqueeControl->Start();
-TBool isLast = DrawMarqueeText( gc, aText );
+iRedraw = !DrawMarqueeText( gc, aText );
-if( isLast )
+if ( !iRedraw )
 {
-if( !iScrollLooping )
+// Marquee is in end
+if ( iPeriodicTimer && !iPeriodicTimer->IsActive() )
 {
-iRedraw = EFalse;
+iPeriodicTimer->Start(
+TTimeIntervalMicroSeconds32( 0 ),
+TTimeIntervalMicroSeconds32( 0 ),
+TCallBack( PeriodicEventL, this ) );
 }
-iMarqueeControl->Reset();
+TBool endOfLoop;
-StartAlternateCounter();
-}
+const TDesC& next( iControl->PeekNextTitle( endOfLoop ) );
-}
-}
+DrawStaticText( gc, next, endOfLoop );
-break;
+}
+}
+}
+break;
 case EAlternate:
 {
 DrawStaticText( gc, aText );
 }
 break;
 default:
 break;
 }
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::RedrawCallback
 // Callback function for marquee control
 // -----------------------------------------------------------------------------
 //
 TInt CXnNewstickerAdapter::RedrawCallback( TAny* aPtr )
 {
-CXnNewstickerAdapter* self = static_cast<CXnNewstickerAdapter*>( aPtr );
+CXnNewstickerAdapter* self = static_cast< CXnNewstickerAdapter* >( aPtr );
-self->DrawNow();
+if ( self->iRedraw )
-return self->Redraw();
+{
+self->DrawNow();
+}
+return self->iRedraw;
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DoScroll
-// Scrolls alternative text. Function is called by periodic timer
+//
 // -----------------------------------------------------------------------------
 //
-void CXnNewstickerAdapter::DoScroll()
+void CXnNewstickerAdapter::DoScroll( TBool aEndOfLoop )
 {
-ReportNewstickerEvent( XnPropertyNames::action::trigger::name::KTitleScrolled );
+iMarqueeControl->Reset();
-if( iControl->SetCurrentTitle() )
+iRedraw = EFalse;
-{
-// stop alternate scrolling if current index is last
+if ( !aEndOfLoop )
-StopAlternateCounter();
+{
-}
+Start();
+}
-DrawNow();
+else
+{
-ReportNewstickerEvent( XnPropertyNames::action::trigger::name::KTitleToScroll );
+Stop();
+}
 }
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DrawStatic
 // Draws text directly to screen when scrolling is not needed
 // -----------------------------------------------------------------------------
 //
-void CXnNewstickerAdapter::DrawStaticText( CWindowGc& aGc, const TDesC& aText ) const
+void CXnNewstickerAdapter::DrawStaticText( CWindowGc& aGc,
+const TDesC& aText, TBool aTruncate ) const
 {
 HBufC* text = HBufC::New( aText.Length() + KAknBidiExtraSpacePerLine );
-if( text )
+if ( text )
 {
 TRect rect = iNode.Rect();
 TInt maxLength = rect.Width();
+TChar clipChar( aTruncate ? KEllipsis : 0xFFFF );
 TPtr ptr = text->Des();
 AknBidiTextUtils::ConvertToVisualAndClip(
-aText, ptr, *iFont, maxLength, maxLength );
+aText, ptr, *iFont, maxLength, maxLength,
+AknBidiTextUtils::EImplicit, clipChar );
 aGc.DrawText( *text, rect, iTextBaseline,
 ( CGraphicsContext::TTextAlign )iTextAlignment );
 delete text;
 // -----------------------------------------------------------------------------
 // CXnNewstickerAdapter::DrawScrolling
 // Draws scrolling text to screen via marquee control
 // -----------------------------------------------------------------------------
 //
-TBool CXnNewstickerAdapter::DrawMarqueeText( CWindowGc& aGc, const TDesC& aText ) const
+TBool CXnNewstickerAdapter::DrawMarqueeText( CWindowGc& aGc,
-{
+const TDesC& aText ) const
-TRect rect = iNode.Rect();
+{
+TRect rect( iNode.Rect() );
 // returns true when all loops have been executed
 return iMarqueeControl->DrawText( aGc, rect, aText, iTextBaseline,
 ( CGraphicsContext::TTextAlign )iTextAlignment, *iFont );
 }

branch	RCL_3
changeset 26	1b758917cafc
parent 23	7be2816dbabd