MCL/sf/mw/classicui: comparison uifw/AvKon/src/eikfrlbd.cpp

equal deleted inserted replaced

-:fcdfafb36fe7
+:aecbbf00d063
 *
 * Description:
 *
 */
-#ifdef __ARMCC__
-#pragma push
-#pragma O3
-#pragma Otime
-#pragma arm
-#endif // __ARMCC__
 #include <eikfrlbd.h>
 #include <aknlists.h>
 #include <AknMarqueeControl.h>
 #include <AknPictographInterface.h>
 #include <eikslbd.h>
 #include "AknDebug.h"
 #include <aknlayoutscalable_avkon.cdl.h>
 #include <layoutmetadata.cdl.h>
 #include <aknphysics.h>
-#include <AknIconArray.h>
-#include <avkon.mbg>
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 #include <aknlistloadertfx.h>
 #include <aknlistboxtfxinternal.h>
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
 #include <touchfeedback.h>
-#include <AknSmileyUtils.h>
 #include "akntrace.h"
 // there are 17(!) subcells in qdial grid (0 ... 16)
 const TInt KMaxSubCellIndex = 16 + 1;
 // colored tick marks support
 const TInt KColorIconFlag = -1;
 const TInt KColorIconIdx  =  0;
-// Number of icons in marking mode icon array
-const TInt KMarkingModeIconArraySize = 2;
-// smiley text place holder
-_LIT( KPlaceHolder, "\xFFF0i" );
 /**
 * This class needs to be in .cpp file so that we do not accidentally make it
 * derivable; that would destroy all the binary compability advantages this
 * class has..
 NONSHARABLE_CLASS(CFormattedCellListBoxDataExtension) :
 public CActive,
 public MAknPictographAnimatorCallBack,
 public MCoeForegroundObserver,
 public MAknsEffectAnimObserver,
-public MListBoxItemChangeObserver,
+public MListBoxItemChangeObserver
-public MAknSmileyObserver
 {
 public:
 enum TFlag
 {
 // Set if current item background should be copied to animation as
 TInt iSubCell; // Must be first entry
 TAknTextLineLayout iTextLayout;
 TAknWindowLineLayout iGraphicLayout;
 TInt iSubCellType;
 TInt iConditionValue; // used with conditional layouts for not always drawn subcells
-TBool iSmileyCell;
 };
 SRowAndSubCell& At(TInt aArrayIndex);
 const SRowAndSubCell& At(TInt aArrayIndex) const;
 void AddRowAndSubCellL(TInt aRow,TInt aSubCell);
 TInt FindRowAndSubCellIndex(TInt& aArrayIndex,TInt aRow,TInt aSubCell) const;
 void FindRowAndSubCellIndexOrAddL(TInt& aArrayIndex,TInt aRow,TInt aSubCell);
-SSLSubCell& SLAt(TInt aArrayIndex);
+SSLSubCell& AtSL(TInt aArrayIndex);
-const SSLSubCell& SLAt(TInt aArrayIndex) const;
+const SSLSubCell& AtSL(TInt aArrayIndex) const;
 void AddSLSubCellL(TInt aSubCell);
 TInt FindSLSubCellIndex(TInt& aArrayIndex, TInt aSubCell) const;
 void FindSLSubCellIndexOrAddL(TInt& aArrayIndex, TInt aSubCell);
 void ResetSLSubCellArray();
 TBool DrawPressedDownEffect( MAknsSkinInstance* aSkin,
 CWindowGc& aGc,
 const TRect& aOutRect,
 const TRect& aInnerRect ) const;
-void DrawSmileyWithText( CWindowGc& aGc, const TDesC& aSmileyText,
-const TAknLayoutText& aLayout,
-TBool aUseLogicalToVisualConversion,
-const TRgb &aColor);
-TInt ConvertTextToSmiley( TDes& aText );
-void LoadMarkingIconsL();
 private: // New internal methods
 TBool DrawHighlightBackground( CFbsBitGc& aGc );
 void PostDeleteAnimation();
 void CreateAnimationL();
 void DoResizeL( const TSize& aHighlightSize, TBool aAboutToStart );
 void SetSubCellLayoutAlignmentL( TInt aSubCellIndex );
 TInt FindSubCellExtIndex(TInt& aArrayIndex,TInt aSubCell) const;
 TBool SubCellLayoutAlignment(TInt aSubCellIndex) const;
-public: // from MAknSmileyObserver
-void SmileyStillImageLoaded( CAknSmileyIcon* aSmileyIcon );
-void SmileyAnimationChanged( CAknSmileyIcon* aSmileyIcon );
 private: // From MAknPictographAnimatorCallBack
 void DrawPictographArea();
 public:
 CCoeControl *iControl; // not owned
 CArrayFix<TSubCellExt>* iSubCellExtArray; //for subcell alignment
 TRect iMarginRect;
 TBool iKineticScrolling;
-CAknSmileyManager* iSmileyMan;
-TSize iSmileySize; // last set simley size
-CAknIconArray* iMarkingIconArray;
 };
 /**
 * High priority is well argumented because running the active object will
 cenRep->Get( KAknAutomaticListStretching, iStretchingEnabled );
 delete cenRep;
 #endif
 iKineticScrolling = CAknPhysics::FeatureEnabled();
-LoadMarkingIconsL();
 _AKNTRACE_FUNC_EXIT;
 }
 CFormattedCellListBoxDataExtension::~CFormattedCellListBoxDataExtension()
 {
 Cancel();
 // Stop receiving foreground events
 CCoeEnv* env = CCoeEnv::Static();
 env->RemoveForegroundObserver( *this );
-delete iSmileyMan;
 delete iRowAndSubCellArray;
 iRowAndSubCellArray = NULL;
 delete iSLSubCellArray;
 iSLSubCellArray = NULL;
 delete iMarquee;
 delete i2ndLineMarquee;
 delete iAnimation;
 delete iColorBmp;
 delete iHiliBmp;
-if ( iMarkingIconArray )
-{
-iMarkingIconArray->ResetAndDestroy();
-}
-delete iMarkingIconArray;
 _AKNTRACE_FUNC_EXIT;
 }
 void
 CFormattedCellListBoxDataExtension::AddRowAndSubCellL(TInt aRow,TInt aSubCell)
 subcell.iSubCell = aSubCell;
 subcell.iTextLayout = NULL;
 subcell.iGraphicLayout = NULL;
 subcell.iSubCellType = 0;
 subcell.iConditionValue = -1;
-subcell.iSmileyCell = EFalse;
 TKeyArrayFix key(0,ECmpTInt32);
 iSLSubCellArray->InsertIsqL(subcell,key);
 }
 CFormattedCellListBoxDataExtension::SSLSubCell&
-CFormattedCellListBoxDataExtension::SLAt(TInt aArrayIndex)
+CFormattedCellListBoxDataExtension::AtSL(TInt aArrayIndex)
 {
 __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iSLSubCellArray->Count(),Panic(EAknPanicOutOfRange));
 return(iSLSubCellArray->At(aArrayIndex));
 }
 const CFormattedCellListBoxDataExtension::SSLSubCell&
-CFormattedCellListBoxDataExtension::SLAt(TInt aArrayIndex) const
+CFormattedCellListBoxDataExtension::AtSL(TInt aArrayIndex) const
 {
 __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iSLSubCellArray->Count(),Panic(EAknPanicOutOfRange));
 return(iSLSubCellArray->At(aArrayIndex));
 }
 {
 _AKNTRACE_FUNC_ENTER;
 DeleteAnim();
 TryCreateAnimation();
 TRAP_IGNORE(CreateColorBitmapsL());
-TRAP_IGNORE( LoadMarkingIconsL() );
 _AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxDataExtension::SetControl
 if (FindSubCellExtIndex(index,aSubCellIndex)==KErrNotFound)
 return (ETrue);
 return(iSubCellExtArray->At(index).iLayoutAlign);
 }
-void CFormattedCellListBoxDataExtension::SmileyStillImageLoaded(
-CAknSmileyIcon* /*aSmileyIcon*/)
-{
-iControl->DrawDeferred();
-}
-void CFormattedCellListBoxDataExtension::SmileyAnimationChanged(
-CAknSmileyIcon* /*aSmileyIcon*/ )
-{
-}
 ///////////handling TSubCellExt,end
 void CFormattedCellListBoxDataExtension::DrawPictographArea()
 {
 aInnerRect,
 KAknsIIDQsnFrListPressed,
 KAknsIIDQsnFrListCenterPressed );
 }
-void CFormattedCellListBoxDataExtension::DrawSmileyWithText( CWindowGc& aGc,
-const TDesC& aSmileyText,
+EXPORT_C CCoeControl *CFormattedCellListBoxData::Control() const
-const TAknLayoutText& aLayout,
+{
-TBool aUseLogicalToVisualConversion,
+return iExtension->iControl;
-const TRgb& aColor )
+}
-{
-__ASSERT_DEBUG( iSmileyMan, Panic(EAknPanicObjectNotFullyConstructed));
+EXPORT_C void CFormattedCellListBoxData::SetSeparatorLinePosition(TAknSeparatorLinePosition aPosition)
-TInt l = Min( aLayout.Font()->TextWidthInPixels(KPlaceHolder),
+{
-aLayout.Font()->HeightInPixels() );
+if (iExtension)
-TSize s(l,l);
+iExtension->iSeparatorLinePosition = aPosition;
-if ( iSmileySize != s )
+}
-{
+EXPORT_C TAknSeparatorLinePosition CFormattedCellListBoxData::SeparatorLinePosition() const
-iSmileyMan->SetSize( s );
+{
-iSmileySize = s;
+if (iExtension)
-}
+return iExtension->iSeparatorLinePosition;
-aGc.SetPenColor( aColor ); // SmileyManager's DrawText does not accept aColor...
-iSmileyMan->DrawText( aGc, aSmileyText, aLayout, aUseLogicalToVisualConversion );
-}
-TInt CFormattedCellListBoxDataExtension::ConvertTextToSmiley( TDes& aText)
-{
-__ASSERT_DEBUG( iSmileyMan, Panic(EAknPanicObjectNotFullyConstructed));
-TInt count = 0;
-TRAPD( err, count = iSmileyMan->ConvertTextToCodesL( aText )) ;
-return err == KErrNone ? count : err;
-}
-// -----------------------------------------------------------------------------
-// CFormattedCellListBoxDataExtension::LoadMarkingIconsL
-// -----------------------------------------------------------------------------
-//
-void CFormattedCellListBoxDataExtension::LoadMarkingIconsL()
-{
-if ( !iMarkingIconArray )
-{
-iMarkingIconArray = new ( ELeave ) CAknIconArray(
-KMarkingModeIconArraySize );
-}
 else
-{
+return ENoLine;
-iMarkingIconArray->ResetAndDestroy();
-}
-MAknsSkinInstance* skin = AknsUtils::SkinInstance();
-const TDesC& avkonIconFile = AknIconUtils::AvkonIconFileName();
-CGulIcon* icon = AknsUtils::CreateGulIconL( skin,
-KAknsIIDQgnPropCheckboxOn,
-avkonIconFile,
-EMbmAvkonQgn_prop_checkbox_on,
-EMbmAvkonQgn_prop_checkbox_on_mask );
-CleanupStack::PushL( icon );
-iMarkingIconArray->AppendL( icon );
-CleanupStack::Pop( icon );
-icon = AknsUtils::CreateGulIconL( skin,
-KAknsIIDQgnPropCheckboxOff,
-avkonIconFile,
-EMbmAvkonQgn_prop_checkbox_off,
-EMbmAvkonQgn_prop_checkbox_off_mask );
-CleanupStack::PushL( icon );
-iMarkingIconArray->AppendL( icon );
-CleanupStack::Pop( icon );
-}
-EXPORT_C CCoeControl *CFormattedCellListBoxData::Control() const
-{
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
-return iExtension->iControl;
-}
-EXPORT_C void CFormattedCellListBoxData::SetSeparatorLinePosition(TAknSeparatorLinePosition aPosition)
-{
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
-iExtension->iSeparatorLinePosition = aPosition;
-}
-EXPORT_C TAknSeparatorLinePosition CFormattedCellListBoxData::SeparatorLinePosition() const
-{
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
-return iExtension->iSeparatorLinePosition;
 }
 EXPORT_C CAknLayoutData *CFormattedCellListBoxData::LayoutData() const
 {
 return NULL;
 }
 CFormattedCellListBoxDataExtension *CFormattedCellListBoxData::Extension() { return iExtension; }
 CFormattedCellListBoxDataExtension *CFormattedCellListBoxData::Extension() const { return iExtension; }
 EXPORT_C void CFormattedCellListBoxData::SetControl(CCoeControl *aControl)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->SetControl( aControl );
 }
 EXPORT_C MAknsControlContext* CFormattedCellListBoxData::SkinBackgroundContext() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iSkinEnabled)
 {
 if (iExtension->iPopupFrame)
 {
 return iExtension->iPopupFrame;
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinEnabledL(TBool aEnabled)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 CListBoxData::SetSkinEnabledL(aEnabled);
 iExtension->iSkinEnabled = aEnabled;
 }
 EXPORT_C TBool CFormattedCellListBoxData::SkinEnabled() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->iSkinEnabled;
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinStyle(const TAknsItemID *id, const TRect &aTileRect)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iSkinControlContext)
 {
 iExtension->iSkinControlContext->SetTiledBitmap(*id);
 iExtension->iSkinControlContext->SetTiledRect(aTileRect);
 }
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinParentPos(const TPoint &aPos)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iSkinControlContext)
 {
 iExtension->iSkinControlContext->SetParentPos(aPos);
 }
 }
 EXPORT_C void CFormattedCellListBoxData::SetBackgroundSkinStyle(const TAknsItemID *aId, const TRect &aRect)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iSkinControlContext)
 {
 iExtension->iSkinControlContext->SetBitmap(*aId);
 iExtension->iSkinControlContext->SetRect(aRect);
 }
 }
 EXPORT_C void CFormattedCellListBoxData::SetListEndSkinStyle(const TAknsItemID *aListEndId, const TRect &aRect)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iSkinControlContext)
 {
 iExtension->iSkinControlContext->SetBottomBitmap(*aListEndId);
 iExtension->iSkinControlContext->SetBottomRect(aRect);
 }
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinHighlightFrame(const TAknsItemID *aFrameId, const TAknsItemID *aFrameCenterId)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iSkinHighlightFrameId = aFrameId;
 iExtension->iSkinHighlightFrameCenterId = aFrameCenterId;
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinPopupFrame(const TAknsItemID *aFrameId, const TAknsItemID *aFrameCenterId)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension && iExtension->iPopupFrame)
-if ( iExtension->iPopupFrame)
 {
 iExtension->iPopupFrame->SetFrame(*aFrameId);
 iExtension->iPopupFrame->SetCenter(*aFrameCenterId);
 }
 else
 }
 }
 EXPORT_C void CFormattedCellListBoxData::SetSkinPopupFramePosition(const TRect &aOuterRect, const TRect &aInnerRect)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension && iExtension->iPopupFrame)
-if ( iExtension->iPopupFrame)
 iExtension->iPopupFrame->SetFrameRects(aOuterRect, aInnerRect);
 }
 EXPORT_C void CFormattedCellListBoxData::UseLogicalToVisualConversion(
 TBool aUseConversion )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension)
 iExtension->iUseLogicalToVisualConversion = aUseConversion;
 }
 void CFormattedCellListBoxData::CreatePictographInterfaceL()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->CreatePictographInterfaceL();
 }
 void CFormattedCellListBoxData::CreateMarqueeControlL()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TCallBack callBack(CFormattedCellListBoxDataExtension::RedrawEvent, iExtension->iControl);
 //iExtension->iMarquee = CAknMarqueeControl::NewL();
 iExtension->CreateMarqueeControlL();
 iExtension->iMarquee->SetRedrawCallBack(callBack);
 iExtension->i2ndLineMarquee->SetRedrawCallBack(callBack);
 }
 EXPORT_C void
 CFormattedCellListBoxData::SetSubCellAlignmentL(TInt aSubCellIndex, CGraphicsContext::TTextAlign aAlign)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TInt index = 0;
 FindSubCellIndexOrAddL(index,aSubCellIndex);
 At(index).iAlign=aAlign;
 iExtension->SetSubCellLayoutAlignmentL( aSubCellIndex );
 }
 EXPORT_C TBool CFormattedCellListBoxData::RespectFocus() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension)
 return iExtension->iRespectFocus;
+return EFalse;
 }
 EXPORT_C void CFormattedCellListBoxData::SetRespectFocus(TBool aBool)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension)
 iExtension->iRespectFocus = aBool;
 }
 EXPORT_C CFont*
 CFormattedCellListBoxData::Font(const TListItemProperties& /*aItemProperties*/,
 TInt aSubCellIndex) const
 }
 EXPORT_C void CFormattedCellListBoxData::Draw(TListItemProperties aProperties, CWindowGc& aGc,const TDesC* aText,const TRect& aRect,TBool aHighlight, const TColors& aColors) const
 {
 _AKNTRACE_FUNC_ENTER;
-_AKNTRACE("Highlight width: %d, (%d,%d)", aRect.Width(), aRect.iTl.iX, aRect.iBr.iX );
 DrawDefaultHighlight(aGc, aRect, aHighlight);
 // Draw the actual items.
 DrawFormatted(aProperties,aGc,aText,aRect,aHighlight,aColors);
 _AKNTRACE_FUNC_EXIT;
 const TRect& aItemRect,
 TBool aHighlight,
 const TColors& aColors ) const
 {
 _AKNTRACE_FUNC_ENTER;
-_AKNTRACE("DrawFormatted: aItemRect=(%d,%d,%d,%d)",
+_AKNTRACE("DrawFormatted: aText=%S, aItemRect=(%d,%d,%d,%d)",
-aItemRect.iTl.iX, aItemRect.iTl.iY, aItemRect.iBr.iX,
+aText, aItemRect.iTl.iX, aItemRect.iTl.iY, aItemRect.iBr.iX,
 aItemRect.iBr.iY);
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+CListBoxView* view = static_cast<CEikListBox*>( iExtension->iControl )->View();
-__ASSERT_DEBUG( iExtension->iControl, Panic( EAknPanicNullPointer ));
-CEikListBox* listbox = static_cast<CEikListBox*>( iExtension->iControl );
-CListBoxView* view = listbox->View();
 if (!view->ViewRect().Intersects(aItemRect))
 {
 // outside of the clipping rect -> don't process this item
 return;
 }
 if ( aHighlight )
 {
 iExtension->iClippedSubcells = 0;
 }
-TBool backgroundDrawingSuppressed = listbox->BackgroundDrawingSuppressed();
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( &aGc );
-if ( transApi && !backgroundDrawingSuppressed )
+if ( transApi )
 {
 transApi->StartDrawing( MAknListBoxTfxInternal::EListItem );
 if(transApi->EffectsDisabled())
 {
 aGc.SetClippingRect( view->ViewRect() );
 }
 }
 #else
-if ( !backgroundDrawingSuppressed )
+CListBoxView* view = static_cast<CEikListBox*>( iExtension->iControl )->View();
-{
+aGc.SetClippingRect( view->ViewRect() );
-aGc.SetClippingRect( view->ViewRect() );
-}
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
-TRect vr(view->ViewRect());
-_AKNTRACE("Clipping: Width %d, (%d,%d)", vr.Width(), vr.iTl.iX, vr.iBr.iX );
 if ( UsesScalableLayoutData() )
 {
 /* this is a AvKon list or list is created using methods in aknlists.cpp
 * which is _the_ way to set up a list
 */
 */
 DrawFormattedOld( aProperties, aGc, aText, aItemRect, aHighlight, aColors );
 }
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
-if ( transApi && !backgroundDrawingSuppressed )
+if ( transApi )
 {
 if(transApi->EffectsDisabled())
 {
 aGc.CancelClippingRect();
 }
 transApi->StopDrawing();
 }
 #else
-if ( !backgroundDrawingSuppressed )
+aGc.CancelClippingRect();
-{
-aGc.CancelClippingRect();
-}
 #endif //RD_UI_TRANSITION_EFFECTS_LIST
 _AKNTRACE_FUNC_EXIT;
 }
 const CGulIcon* aIcon,
 TInt            aSubcell,
 TBool           aColorIcon,
 const TRect&    aGraphicRect ) const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 // se also eikclbd.cpp ( sigh ).
 CFbsBitmap* bitmap( aIcon->Bitmap() );
 CFbsBitmap* mask( aIcon->Mask() );
 // possibly colorskinnable icon. Check must be after SetSize()
 const TRect& aItemRect,
 TBool aHighlight,
 const TColors& aColors ) const
 {
 _AKNTRACE_FUNC_ENTER;
-_AKNTRACE("DrawFormattedSimple: aItemRect=(%d,%d,%d,%d)",
+_AKNTRACE("DrawFormattedSimple: aText=%S, aItemRect=(%d,%d,%d,%d)",
-aItemRect.iTl.iX, aItemRect.iTl.iY, aItemRect.iBr.iX,
+aText, aItemRect.iTl.iX, aItemRect.iTl.iY, aItemRect.iBr.iX,
 aItemRect.iBr.iY);
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TRect textRect(aItemRect);
-DrawMarkingModeIcons( aProperties, aGc, textRect );
 const TColors *subcellColors = &aColors;
 TInt lastSubCell = Min( LastSubCell(), KMaxSubCellIndex );
 TInt subcell=0;
 Mem::FillZ( &rectClipped[0], KMaxSubCellIndex * sizeof( TBool ) );
 if ( iExtension->iSubCellsMightIntersect )
 {
-CheckIfSubCellsIntersect( &textLines[0], &rectClipped[0], *aText, textRect );
+CheckIfSubCellsIntersect( &textLines[0], &rectClipped[0], *aText, aItemRect );
 }
 TInt SCindex=0;
 // This loop does the drawing.
 {
 // empty subcell, continue to draw next subcell
 ++ subcell;
 continue;
 }
+if (!iExtension) break;
 if (iExtension->FindSLSubCellIndex(SCindex,subcell)!=0) break;
 if (UseSubCellColors(subcell))
 {
 subcellColors = &SubCellColors(subcell);
 {
 subcellColors = &aColors;
 }
 TRgb color;
-CListBoxView* view = static_cast<CEikListBox*>( Control() )->View();
-TBool useOverrideColor = view->ItemDrawer()->Flags() & CListItemDrawer::EUseOverrideSkinTextColor;
 if (aHighlight)
 {
 color = subcellColors->iHighlightedText;
 aGc.SetBrushColor(subcellColors->iHighlightedBack);
-if ( AknsUtils::AvkonSkinEnabled() && !useOverrideColor )
+if ( AknsUtils::AvkonSkinEnabled() )
 {
 if ( iExtension->iHighlightedTextColor != NULL )
 {
 color = iExtension->iHighlightedTextColor;
 }
 }
 else
 {
 color = subcellColors->iText;
 aGc.SetBrushColor(subcellColors->iBack);
-if ( AknsUtils::AvkonSkinEnabled() && !useOverrideColor )
+if ( AknsUtils::AvkonSkinEnabled() )
 {
 if ( iExtension->iTextColor != NULL )
 {
 color = iExtension->iTextColor;
 }
 }
 }
 // graphics or text column
-if (iExtension->SLAt(SCindex).iSubCellType == CFormattedCellListBoxDataExtension::EAknSLText)
+if (iExtension->AtSL(SCindex).iSubCellType == CFormattedCellListBoxDataExtension::EAknSLText)
 {
 const CFont* rowAndCellFont=RowAndSubCellFont(iExtension->iCurrentlyDrawnItemIndex,subcell);
 const CFont* cellFont=Font(aProperties, subcell);
 const CFont* tempFont=(cellFont) ? cellFont : NULL;
 const CFont* usedFont=(rowAndCellFont) ? rowAndCellFont : tempFont;
 textLineLayout = textLines[subcell];
 }
 else
 {
 // check if there are icons affecting this text layout
-TInt gSC = iExtension->SLAt(SCindex).iConditionValue; // graphical subcell which might affect this text subcell
+TInt gSC = iExtension->AtSL(SCindex).iConditionValue; // graphical subcell which might affect this text subcell
 if (gSC > -1)
 {
 TInt tempIndex;
 while (gSC > -1) // when gSC == -1, we have found our graphical subcell
 {
 if (iExtension->FindSLSubCellIndex(tempIndex,gSC)!=0) break;
 TextUtils::ColumnText(tempText,gSC, aText);
 if (tempText != KNullDesC)
 {
-textLineLayout = iExtension->SLAt(tempIndex).iTextLayout;
+textLineLayout = iExtension->AtSL(tempIndex).iTextLayout;
 break;
 }
-gSC = iExtension->SLAt(tempIndex).iConditionValue;
+gSC = iExtension->AtSL(tempIndex).iConditionValue;
 }
 }
 if (gSC == -1) // no affecting icons -> use default layout
 {
-textLineLayout = iExtension->SLAt(SCindex).iTextLayout;
+textLineLayout = iExtension->AtSL(SCindex).iTextLayout;
 }
 }
 CGraphicsContext::TTextAlign align=SubCellAlignment(subcell); //gumq
 textLayout.LayoutText(textRect, textLineLayout, usedFont);
 SetUnderlineStyle( aProperties, aGc, subcell );
 // * 2 == leave some room for marquee
-const TInt maxlen( KMaxColumnDataLength * 3 );
+const TInt maxlen( KMaxColumnDataLength * 2 );
 TBuf<maxlen> convBuf = text.Left(maxlen);
-TBool smileyDraw = EFalse;
-// do smiley convert before clipping. don't worry marquee now.
-if ( iExtension->iSmileyMan &&
-iExtension->SLAt(SCindex).iSmileyCell &&
-iExtension->ConvertTextToSmiley( convBuf ) > 0 )
-{
-smileyDraw = ETrue;
-}
 // Note that this potentially modifies the text so its lenght in pixels
 // might increase. Therefore, this should always be done before
 // wrapping/clipping text. In some cases, WordWrapListItem is called
 // before coming here. Is it certain that it is not done for number subcells?
 if ( marquee && marqueeDisabled )
 {
 marquee->Stop();
 }
-if ( smileyDraw )
-{
-TRect tr(textLayout.TextRect());
-_AKNTRACE( "textLayout Width: %d (%d,%d)", tr.Width(), tr.iTl.iX, tr.iBr.iX );
-iExtension->DrawSmileyWithText( aGc, convBuf, textLayout, bidiConv, color );
-}
-else
-{
 textLayout.DrawText( aGc, convBuf, bidiConv, color );
-}
 }
 if ( iExtension->iPictoInterface )
 {
 index = KColorIconIdx;
 }
 if( !iIconArray )
 {
-++ subcell;
 continue;
 }
 if (aHighlight && (index > 0xffff))
 {
 }
 index = index & 0xffff; // mask off possible highlight icon
 __ASSERT_DEBUG((index>=0 && index<iIconArray->Count()),Panic(EAknPanicFormattedCellListInvalidBitmapIndex));
-TAknWindowLineLayout graphicLayout = iExtension->SLAt(SCindex).iGraphicLayout;
+TAknWindowLineLayout graphicLayout = iExtension->AtSL(SCindex).iGraphicLayout;
 TAknLayoutRect graphicRect;
 graphicRect.LayoutRect(textRect,graphicLayout);
 TSize graphicSize( graphicRect.Rect().Size() );
 const_cast<CFormattedCellListBoxData*>( this )->
 SetWordWrappedSubcellIndices( -1, -1 );
 _AKNTRACE_FUNC_EXIT;
 }
-// -----------------------------------------------------------------------------
-// CFormattedCellListBoxData::DrawMarkingModeIcons
-// -----------------------------------------------------------------------------
-//
-void CFormattedCellListBoxData::DrawMarkingModeIcons(
-TListItemProperties& aProperties,
-CWindowGc& aGc,
-TRect& aItemRect ) const
-{
-CEikListBox* listbox = static_cast<CEikListBox*>( Control() );
-TRect textRect( aItemRect );
-if ( listbox->View()->ItemDrawer()->Flags()
-& CListItemDrawer::EMarkingModeEnabled
-&& !aProperties.IsSelectionHidden()
-&& iExtension->iMarkingIconArray
-&&  iExtension->iMarkingIconArray->Count()
-== KMarkingModeIconArraySize )
-{
-if ( AknLayoutUtils::LayoutMirrored() )
-{
-textRect.iBr.iX -=
-AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
-0 ).LayoutLine().ir;
-}
-else
-{
-textRect.iTl.iX +=
-AknLayoutScalable_Avkon::list_double_graphic_pane_t1(
-0 ).LayoutLine().il;
-}
-TAknLayoutRect layoutRect;
-layoutRect.LayoutRect( aItemRect,
-AknLayoutScalable_Avkon::list_double_graphic_pane_g1( 0 ) );
-// unchecked icon
-CGulIcon* icon = ( *iExtension->iMarkingIconArray )[1];
-if ( listbox->View()->ItemIsSelected(
-iExtension->iCurrentlyDrawnItemIndex ) )
-{
-icon = ( *iExtension->iMarkingIconArray )[0];
-}
-CFbsBitmap* bitmap = icon->Bitmap();
-if ( bitmap )
-{
-TSize size( bitmap->SizeInPixels() ); // set size if not already
-TSize targetSize( layoutRect.Rect().Size() );
-if ( size.iWidth != targetSize.iWidth &&
-size.iHeight != targetSize.iHeight )
-{
-AknIconUtils::SetSize( bitmap, targetSize,
-EAspectRatioPreservedAndUnusedSpaceRemoved );
-}
-aGc.BitBltMasked( layoutRect.Rect().iTl,
-bitmap,
-TRect( layoutRect.Rect().Size() ),
-icon->Mask(), EFalse );
-}
-aItemRect = textRect;
-}
-}
 EXPORT_C
 CFormattedCellListBoxData::CFormattedCellListBoxData()
 : CListBoxData()
 {
 EXPORT_C void CPopupFormattedListBoxData::Draw(TListItemProperties aProperties, CWindowGc& aGc,const TDesC* aText,const TRect& aRect,TBool aHighlight, const TColors& aColors) const
 {
 _AKNTRACE_FUNC_ENTER;
 const TRect &aItemRect = aRect;
-DrawDefaultHighlight( aGc, aItemRect, aHighlight );
+DrawPopupHighlight(aGc, aItemRect, aHighlight);
 // Draw the actual items.
 DrawFormatted(aProperties,aGc,aText,aItemRect,aHighlight,aColors);
 _AKNTRACE_FUNC_EXIT;
 }
 void CFormattedCellListBoxData::DrawDefaultHighlight(CWindowGc &aGc, const TRect &aItemRect, TBool aHighlight) const
 {
 _AKNTRACE_FUNC_ENTER;
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 // When this flag set, draw pressed down state and don't use animation.
 // There are several derived CListboxData in this file. All of them do
 // this same thing.
 CListBoxView* view = static_cast<CEikListBox*>( iExtension->iControl )->View();
 TBool pressedDown = view->ItemDrawer()->Flags() & CListItemDrawer::EPressedDownState;
 #endif
 }
 _AKNTRACE_FUNC_EXIT;
 }
+void CFormattedCellListBoxData::DrawSettingHighlight(CWindowGc &aGc, const TRect &aItemRect, TBool aHighlight) const
+{
+_AKNTRACE_FUNC_ENTER;
+DrawDefaultHighlight( aGc, aItemRect, aHighlight );
+_AKNTRACE_FUNC_EXIT;
+}
+void CFormattedCellListBoxData::DrawPopupHighlight(CWindowGc &aGc, const TRect &aItemRect, TBool aHighlight) const
+{
+_AKNTRACE_FUNC_ENTER;
+DrawDefaultHighlight( aGc, aItemRect, aHighlight );
+_AKNTRACE_FUNC_EXIT;
+}
+void CFormattedCellListBoxData::DrawPopupFrame(CWindowGc &aGc) const
+{
+_AKNTRACE_FUNC_ENTER;
+CCoeControl* control = Control();
+if ( control )
+{
+aGc.SetPenStyle( CGraphicsContext::ENullPen );
+TBool done = AknsDrawUtils::Background( AknsUtils::SkinInstance(),
+iExtension->iPopupFrame,
+control,
+aGc,
+control->Rect() );
+if ( !done )
+{
+aGc.Clear( control->Rect() );
+}
+}
+_AKNTRACE_FUNC_EXIT;
+}
 void CFormattedCellListBoxData::SetWordWrappedSubcellIndices(
 TInt aFirstIndex,
 TInt aSecondIndex )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iFirstWordWrappedSubcellIndex = (TInt16)aFirstIndex;
 iExtension->iSecondWordWrappedSubcellIndex = (TInt16)aSecondIndex;
 }
 EXPORT_C void CFormattedCellListBoxData::EnableMarqueeL(TBool aEnable)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 // CreateMarqueeControlL does nothing if marquee already exists,
 // so let's just call it just in case.
 CreateMarqueeControlL();
 iExtension->iMarquee->EnableMarquee(aEnable);
 iExtension->i2ndLineMarquee->EnableMarquee(aEnable);
 // Two versions to eliminate compiler warnings.
 #ifdef __WINS__
 EXPORT_C const TBool CFormattedCellListBoxData::IsMarqueeOn()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->IsMarqueeOn();
 }
 #else
 EXPORT_C TBool CFormattedCellListBoxData::IsMarqueeOn()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->IsMarqueeOn();
 }
 #endif // __WINS__
 void CFormattedCellListBoxData::FocusGained()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->FocusGained();
 }
 void CFormattedCellListBoxData::FocusLost()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->FocusLost();
 }
 void CFormattedCellListBoxData::HandleResourceChange( TInt aType )
 {
 _AKNTRACE_FUNC_ENTER;
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 // Animation is skin dependent, whenever skin changes animation changes
 // too.
 if( KAknsMessageSkinChange == aType )
 {
 iExtension->SkinChanged();
 // CFormattedCellListBoxData::HighlightAnim
 // -----------------------------------------------------------------------------
 //
 EXPORT_C const CAknsEffectAnim* CFormattedCellListBoxData::HighlightAnim() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( iExtension )
 return iExtension->iAnimation;
+return NULL;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::AboutToDrawHighlightAnim
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CFormattedCellListBoxData::AboutToDrawHighlightAnim() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( !iExtension )
+{
+return;
+}
 if( !iExtension->iAnimation || !iExtension->iControl )
 {
 return;
 }
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CFormattedCellListBoxData::SetHighlightAnimBackgroundDrawer(
 MListBoxAnimBackgroundDrawer* aDrawer )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( iExtension )
-iExtension->iHighlightBgDrawer = aDrawer;
+{
+iExtension->iHighlightBgDrawer = aDrawer;
+}
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::SetItemCellSize
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CFormattedCellListBoxData::SetItemCellSize( const TSize& aSize )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( iExtension )
-if( iExtension->iAnimSize != aSize )
+{
-{
+if( iExtension->iAnimSize != aSize )
-iExtension->Play();
+{
-}
+iExtension->Play();
-iExtension->iAnimSize = aSize;
+}
+iExtension->iAnimSize = aSize;
+}
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::HasHighlightAnim
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool CFormattedCellListBoxData::HasHighlightAnim() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( !iExtension )
-return ( iExtension->iAnimation != NULL );
+return EFalse;
+if( !iExtension->iAnimation )
+return EFalse;
+return ETrue;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::DrawHighlightAnim
 // -----------------------------------------------------------------------------
 //
 EXPORT_C TBool CFormattedCellListBoxData::DrawHighlightAnim(
 CBitmapContext& aGc, const TRect& aRect ) const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if( !iExtension )
+return EFalse;
 if( !iExtension->iAnimation )
 return EFalse;
 return iExtension->SyncAndDrawAnim( aGc, aRect );
 }
 void CFormattedCellListBoxData::ResetMarquee()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if (iExtension->iMarquee)
 {
 iExtension->iMarquee->Reset();
 }
 if (iExtension->i2ndLineMarquee)
 }
 }
 TInt CFormattedCellListBoxData::CurrentMarqueeItemIndex()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->iCurrentItem;
 }
 void CFormattedCellListBoxData::SetCurrentMarqueeItemIndex(TInt aIndex)
 {
 _AKNTRACE("CFormattedCellListBoxData::SetCurrentMarqueeItemIndex aIndex=%d",
 aIndex);
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iCurrentItem = aIndex;
 }
 void CFormattedCellListBoxData::SetCurrentItemIndex(TInt aIndex)
 {
 _AKNTRACE("CFormattedCellListBoxData::SetCurrentItemIndex aIndex=%d", aIndex);
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if( iExtension->iCurrentRow != aIndex )
 {
 iExtension->iAnimFlags.Set( CFormattedCellListBoxDataExtension::EFlagUpdateBg );
 }
 iExtension->iCurrentRow = aIndex;
 void CFormattedCellListBoxData::SetCurrentlyDrawnItemIndex( TInt aIndex )
 {
 _AKNTRACE("CFormattedCellListBoxData::SetCurrentlyDrawnItemIndex aIndex=%d",
 aIndex);
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-iExtension->iCurrentlyDrawnItemIndex = aIndex;
+{
+iExtension->iCurrentlyDrawnItemIndex = aIndex;
+}
 }
 EXPORT_C const CFont*
 CFormattedCellListBoxData::RowAndSubCellFont(TInt aRow,TInt aSubCellIndex) const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (!iExtension) return 0;
 TInt index = 0;
 if (iExtension->FindRowAndSubCellIndex(index,aRow,aSubCellIndex)!=0)
 return 0;
 return(iExtension->At(index).iFont);
 }
 EXPORT_C void CFormattedCellListBoxData::SetSubCellFontForRowL(TInt aRowIndex,
 TInt aSubCellIndex,
 const CFont* aFont)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (!iExtension) return;
 TInt index = 0;
 iExtension->FindRowAndSubCellIndexOrAddL(index,aRowIndex,aSubCellIndex);
 iExtension->At(index).iFont=aFont;
 }
 * Enables / disables transparency effect, ie. does the listbox draw it's own background or not.
 * @param aDrawBackground  EFalse enables transparency
 */
 EXPORT_C void CFormattedCellListBoxData::SetDrawBackground(const TBool aDrawBackground)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iDrawBackground = aDrawBackground;
 if( !aDrawBackground )
 {
 iExtension->DeleteAnim();
 }
 /**
 * Is the listbox drawing the background itself or not (= "transparency")
 */
 TBool CFormattedCellListBoxData::IsBackgroundDrawingEnabled() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->iDrawBackground;
 }
 /**
 * Enables / disables drawing background after scrollbar
 * @param aDrawBackground  default ETrue
 */
 void CFormattedCellListBoxData::SetDrawScrollbarBackground(const TBool aDrawBackground)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iDrawScrollbarBackground = aDrawBackground;
 }
 /**
 * Is the listbox drawing the background after scrollbar or not
 */
 TBool CFormattedCellListBoxData::IsScrollbarBackgroundDrawingEnabled() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 return iExtension->iDrawScrollbarBackground;
 }
 EXPORT_C void CFormattedCellListBoxData::SetMarqueeParams(const TInt aLoops, const TInt aScrollAmount,
 const TInt aScrollDelay, const TInt aInterval)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 if ( iExtension->iMarquee )
 {
 iExtension->iMarquee->SetLoops( aLoops );
 iExtension->iMarquee->SetSpeedInPixels( aScrollAmount );
 iExtension->iMarquee->SetDelay( aScrollDelay );
 }
 EXPORT_C void CFormattedCellListBoxData::SetSubCellIconSize(TInt aIndex, TSize aSize)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension && aIndex <= KMaxSubCellIndex && aIndex >= 0)
-if ( aIndex <= KMaxSubCellIndex && aIndex >= 0)
 {
 iExtension->iSubCellIconSize[aIndex] = aSize;
 }
 }
 TSize CFormattedCellListBoxData::GetSubCellIconSize(TInt aIndex)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension && aIndex <= KMaxSubCellIndex && aIndex >= 0)
-if ( aIndex <= KMaxSubCellIndex && aIndex >= 0)
 {
 return iExtension->iSubCellIconSize[aIndex];
 }
 return TSize(0,0);
 }
 }
 // extended skin support
 void CFormattedCellListBoxData::SetESSTextColor( TAknsQsnTextColorsIndex aIndex )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TRgb color;
 TInt error = AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
 color,
 KAknsIIDQsnTextColors,
 // extended skin support
 void CFormattedCellListBoxData::SetESSHighlightedTextColor( TAknsQsnTextColorsIndex aIndex )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TRgb color;
 TInt error = AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
 color,
 KAknsIIDQsnTextColors,
 void CFormattedCellListBoxData::SetGraphicSubCellL( TInt aSubCell,
 const TAknWindowLineLayout &aGraphicLayout )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension ) return;
 CEikFormattedCellListBox* list = static_cast<CEikFormattedCellListBox*>( iExtension->iControl );
 // this does happen with caknsetstyle, caknform(wide)style lists.
 // eventually they'll get here again with list!=0, so this check is enough
 if ( !list ) return;
 TInt index = 0;
 iExtension->FindSLSubCellIndexOrAddL(index,aSubCell);
-iExtension->SLAt(index).iTextLayout=NULL;
+iExtension->AtSL(index).iTextLayout=NULL;
-iExtension->SLAt(index).iGraphicLayout=aGraphicLayout;
+iExtension->AtSL(index).iGraphicLayout=aGraphicLayout;
-iExtension->SLAt(index).iSubCellType=CFormattedCellListBoxDataExtension::EAknSLGraphic;
+iExtension->AtSL(index).iSubCellType=CFormattedCellListBoxDataExtension::EAknSLGraphic;
 // For compabitility - needed at least for text wrapping.
 // Beware - some of these WILL be overriden if you got here trough
 // old layout methods like AknListBoxLayouts::SetupFormTextCell()
 // & friends.
 }
 void CFormattedCellListBoxData::SetTextSubCellL( TInt aSubCell,
 const TAknTextLineLayout &aTextLayout )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (!iExtension) return;
 CEikFormattedCellListBox* list = static_cast<CEikFormattedCellListBox*>( iExtension->iControl );
 // this does happen with caknsetstyle, caknform(wide)style lists.
 // eventually they'll get here again with list!=0, so this check is enough
 if ( !list ) return;
 TInt index = 0;
 iExtension->FindSLSubCellIndexOrAddL(index,aSubCell);
-iExtension->SLAt(index).iTextLayout=aTextLayout;
+iExtension->AtSL(index).iTextLayout=aTextLayout;
-iExtension->SLAt(index).iGraphicLayout=NULL;
+iExtension->AtSL(index).iGraphicLayout=NULL;
-iExtension->SLAt(index).iSubCellType=CFormattedCellListBoxDataExtension::EAknSLText;
+iExtension->AtSL(index).iSubCellType=CFormattedCellListBoxDataExtension::EAknSLText;
 // For compabitility - needed at least for text wrapping.
 // Beware - some of these WILL be overriden if you got here trough
 // old layout methods like AknListBoxLayouts::SetupFormTextCell()
 void CFormattedCellListBoxData::SetConditionalSubCellL(TInt aSubCell,
 const TAknTextLineLayout &aTextLayout,
 TInt aAffectedSubCell)
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 // iConditionValue of affected subcell (=text subcell, which has different layouts)
 // contains index of graphical subcell, which existence should be checked first.
 // This graphical subcell has in iConditionValue index of graphical subcell,
 // which existence should be checked second etc. Each graphical subcell can
 // affect only to 1 text subcell (or none).
 // for compabitility - needed at least for text wrapping
 SetNotAlwaysDrawnSubCellL( aSubCell, ETrue );
+if (!iExtension) return;
 TInt i = 0x01;
 i = i << aSubCell;
 iExtension->iConditionalCells = iExtension->iConditionalCells | i;
 TInt graphicalIndex = 0;
 if (iExtension->FindSLSubCellIndex(graphicalIndex, aSubCell)!=0) return; // subcell not found
 // conditional layoutline can be only added to graphical subcells
-if (iExtension->SLAt(graphicalIndex).iSubCellType!=CFormattedCellListBoxDataExtension::EAknSLGraphic) return;
+if (iExtension->AtSL(graphicalIndex).iSubCellType!=CFormattedCellListBoxDataExtension::EAknSLGraphic) return;
 TInt textIndex = 0; // index of affected subcell
 if (iExtension->FindSLSubCellIndex(textIndex, aAffectedSubCell)!=0) return; // subcell not found
 // affected subcell can only be text subcell
-if (iExtension->SLAt(textIndex).iSubCellType==CFormattedCellListBoxDataExtension::EAknSLGraphic) return;
+if (iExtension->AtSL(textIndex).iSubCellType==CFormattedCellListBoxDataExtension::EAknSLGraphic) return;
-TInt gSC = iExtension->SLAt(textIndex).iConditionValue; // text subcell to be added in priority chain
+TInt gSC = iExtension->AtSL(textIndex).iConditionValue; // text subcell to be added in priority chain
 while (gSC > -1)
 {
 if (iExtension->FindSLSubCellIndex(textIndex, gSC)!=0) return; // subcell not found
-gSC = iExtension->SLAt(textIndex).iConditionValue;
+gSC = iExtension->AtSL(textIndex).iConditionValue;
 }
-iExtension->SLAt(textIndex).iConditionValue = aSubCell; // add next subcell to chain
+iExtension->AtSL(textIndex).iConditionValue = aSubCell; // add next subcell to chain
-iExtension->SLAt(graphicalIndex).iTextLayout=aTextLayout;
+iExtension->AtSL(graphicalIndex).iTextLayout=aTextLayout;
 iExtension->CreateColorBitmapsL( SubCellSize( aSubCell ) );
 TRect r( SubCellPosition( aSubCell ), SubCellSize( aSubCell ) );
 if ( iExtension->iMarginRect == TRect::EUninitialized )
 }
 else
 {
 iExtension->iMarginRect.BoundingRect( r );
 }
+CEikFormattedCellListBox* list = static_cast<CEikFormattedCellListBox*>( iExtension->iControl );
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
-CEikFormattedCellListBox* list = static_cast<CEikFormattedCellListBox*>( iExtension->iControl );
 MAknListBoxTfxInternal* transApi =
 CAknListLoader::TfxApiInternal( list->View()->ItemDrawer()->Gc() );
 if ( transApi )
 {
 transApi->SetPosition( MAknListBoxTfxInternal::EListTLMargin, iExtension->iMarginRect.iTl );
 // CFormattedCellListBoxData::UsesScalableLayoutData
 // -----------------------------------------------------------------------------
 //
 TBool CFormattedCellListBoxData::UsesScalableLayoutData() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if (iExtension)
 return iExtension->iSimpleList;
+return EFalse;
 }
 void CFormattedCellListBoxData::UseScalableLayoutData( TBool aUse )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-if ( !aUse && iExtension->iSimpleList )
+{
-{
+if ( !aUse && iExtension->iSimpleList )
+{
 #ifdef RD_UI_TRANSITION_EFFECTS_LIST
 CEikFormattedCellListBox* list = static_cast<CEikFormattedCellListBox*>( iExtension->iControl );
 MAknListBoxTfxInternal* transApi =
 CAknListLoader::TfxApiInternal( list->View()->ItemDrawer()->Gc() );
 if ( transApi )
 {
 transApi->SetPosition( MAknListBoxTfxInternal::EListTLMargin, TPoint( 0, 0 ) );
 transApi->SetPosition( MAknListBoxTfxInternal::EListBRMargin, TPoint( 0, 0 ) );
 }
 #endif
 }
 iExtension->iSimpleList = aUse;
+}
 }
 EXPORT_C void CFormattedCellListBoxData::SetSubcellUnderlined( TBitFlags32 aUnderlinedCells )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-iExtension->iUnderlineFlagSet = ETrue;
+{
-iExtension->iUnderlineFlags   = aUnderlinedCells;
+iExtension->iUnderlineFlagSet = ETrue;
+iExtension->iUnderlineFlags   = aUnderlinedCells;
+}
 }
 void CFormattedCellListBoxData::SetUnderlineStyle( TListItemProperties aProperties,
 CWindowGc& aGc,
 TInt aSubCell ) const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return;
+}
 if ( !iExtension->iUnderlineFlagSet )
 {
 // underlining is already either on or off and
 // hardcoded off turning will ensure old style
 // behaviour
 }
 }
 void CFormattedCellListBoxData::UseHighlightIconSwapping( TBool aUse )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-iExtension->iUseHighligthIconSwapping = aUse;
+{
+iExtension->iUseHighligthIconSwapping = aUse;
+}
 }
 TBool CFormattedCellListBoxData::UseHighlightIconSwapping() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-return iExtension->iUseHighligthIconSwapping;
+{
+return iExtension->iUseHighligthIconSwapping;
+}
+return EFalse;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::SetStretchableGraphicSubCellL
 // -----------------------------------------------------------------------------
 const TAknTextComponentLayout& aNormalLayout,
 const TAknTextComponentLayout& aStretchedLayout,
 TInt aNormalSubCell,
 TInt aStretchedSubCell )
 {
-_AKNTRACE_FUNC_ENTER;
 if ( Layout_Meta_Data::IsLandscapeOrientation() &&
 Layout_Meta_Data::IsListStretchingEnabled() &&
 StretchingEnabled() )
 {
-_AKNTRACE("Layout_Meta_Data::IsListStretchingEnabled");
 SetConditionalSubCellL( aSubCell, aStretchedLayout.LayoutLine(), aStretchedSubCell );
 }
 else
 {
 SetConditionalSubCellL( aSubCell, aNormalLayout.LayoutLine(), aNormalSubCell );
 }
-_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::ResetSLSubCellArray
 // -----------------------------------------------------------------------------
 //
 void CFormattedCellListBoxData::ResetSLSubCellArray()
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return;
+}
 iExtension->iMarginRect = TRect::EUninitialized;
 UseScalableLayoutData( EFalse );
 iExtension->ResetSLSubCellArray();
 // This function gets called always when size changes, so here is called
 // -----------------------------------------------------------------------------
 //
 TBool CFormattedCellListBoxData::StretchingEnabled() const
 {
 #ifdef RD_LIST_STRETCH
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return EFalse;
+}
 return iExtension->iStretchingEnabled;
 #else
 return EFalse;
 #endif // #ifdef RD_LIST_STRETCH
 }
 // CFormattedCellListBoxData::EnableStretching
 // -----------------------------------------------------------------------------
 //
 void CFormattedCellListBoxData::EnableStretching( const TBool aEnabled )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return;
+}
 iExtension->iStretchingEnabled = aEnabled;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::HideSecondRow
 // -----------------------------------------------------------------------------
 //
 void CFormattedCellListBoxData::HideSecondRow( const TBool aHide )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return;
+}
 iExtension->iHideSecondRow = aHide;
 }
 #endif // RD_LIST_STRETCH
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::SecondRowHidden
 // -----------------------------------------------------------------------------
 //
 TBool CFormattedCellListBoxData::SecondRowHidden() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return EFalse;
+}
 return iExtension->iHideSecondRow;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::ToggleDropShadows
 // -----------------------------------------------------------------------------
 //
 void CFormattedCellListBoxData::ToggleDropShadows( const TBool aEnable )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( !iExtension )
+{
+return;
+}
 iExtension->iUseDropShadows = aEnable;
 }
 // -----------------------------------------------------------------------------
 // CFormattedCellListBoxData::CheckIfSubCellsIntersect
 TAknTextLineLayout* aLayouts,
 TBool* aResults,
 const TDesC& aText,
 const TRect& aItemRect ) const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 TInt subCell = 0;
 TInt subCell2;
 TInt subCellIndex;
 TInt subCellIndex2;
 TInt lastSubCell = Min( KMaxSubCellIndex, LastSubCell() );
 }
 }
 if ( aResults[subCell] )
 {
-if ( iExtension->SLAt( subCellIndex ).iSubCellType == CFormattedCellListBoxDataExtension::EAknSLText )
+if ( iExtension->AtSL( subCellIndex ).iSubCellType == CFormattedCellListBoxDataExtension::EAknSLText )
 {
-TAknTextLineLayout textLine = iExtension->SLAt( subCellIndex ).iTextLayout;
+TAknTextLineLayout textLine = iExtension->AtSL( subCellIndex ).iTextLayout;
 textLine.iW = bRect.Width();
 if ( !AknLayoutUtils::LayoutMirrored() )
 {
 // CFormattedCellListBoxData::SubCellsMightIntersect
 // -----------------------------------------------------------------------------
 //
 void CFormattedCellListBoxData::SubCellsMightIntersect( const TBool aMightIntersect )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
 iExtension->iSubCellsMightIntersect = aMightIntersect;
 }
 void CFormattedCellListBoxDataExtension::CreateColorBitmapsL( )
 CleanupStack::PopAndDestroy( fbsBitGc );
 _AKNTRACE_FUNC_EXIT;
 }
-struct TCellInfo
-{
-TBool iTextNull;
-TPtrC iTextPtr;
-};
 void
 CFormattedCellListBoxData::DrawFormattedOld( TListItemProperties& aProperties,
 CWindowGc& aGc,
 const TDesC* aText,
 const TRect& aItemRect,
 TBool aHighlight,
 const TColors& aColors ) const
 {
 _AKNTRACE_FUNC_ENTER;
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+TRect aRect(aItemRect);
-_AKNTRACE( "DrawFormattedOld: aText=%S, aItemRect=(%d,%d,%d,%d)",
+const TColors *subcellColors = &aColors;
-aText, aItemRect.iTl.iX,
-aItemRect.iTl.iY,
+TInt lastSubCell=LastSubCell();
-aItemRect.iBr.iX,
+if (lastSubCell==KErrNotFound)
-aItemRect.iBr.iY );
+{
+aGc.UseFont(CEikonEnv::Static()->NormalFont());
-TRect itemRect( aItemRect );
+aGc.DrawText(TPtrC(),aRect,0); // use draw text so that don't need to change pen color/style
-TInt lastSubCell = LastSubCell();
-if ( lastSubCell == KErrNotFound )
-{
-aGc.UseFont( CEikonEnv::Static()->NormalFont() );
-// Use draw text so that there's no need to change pen color/style.
-aGc.DrawText( TPtrC(), itemRect, 0 );
 aGc.DiscardFont(); // Release the font cache
-_AKNTRACE_FUNC_EXIT;
 return;
 }
-CEikListBox* listbox = static_cast<CEikListBox*>( Control() );
-DrawMarkingModeIcons( aProperties, aGc, itemRect );
-TInt iconOffset = aItemRect.Width() - itemRect.Width();
-const TColors* subcellColors = &aColors;
 const CFont* font=SubCellFont(0);
 if (font==NULL)
 {
 font=CEikonEnv::Static()->NormalFont();
 }
-TRect textRect( itemRect );
+TInt extraVerticalSpace=(aRect.Height()-font->HeightInPixels());
-textRect.iBr.iX = itemRect.iTl.iX;
+TInt baseLineOffset=extraVerticalSpace/2+font->AscentInPixels();
+TRect textRect=aRect;
+textRect.iBr.iX=aRect.iTl.iX;
 TInt subcell=0;
 TInt subcell2=0;
+TPtrC text;
-TCellInfo textNull[30];
+TBool textNull[30];
+TRgb bmpBackColor, bmpForeColor;
 TRect textShadowRect;           // For transparent list
 TRgb textShadowColour = AKN_LAF_COLOR_STATIC(215);    // Black shadow for item text.
+MAknsControlContext *cc = AknsDrawUtils::ControlContext( Control() );
 TBool layoutMirrored = AknLayoutUtils::LayoutMirrored();
 TBool skinEnabled = AknsUtils::AvkonSkinEnabled();
+if (!cc)
+{
+cc = SkinBackgroundContext();
+}
+Mem::FillZ( textNull, sizeof( textNull ) );
 // cache the text states.
 subcell = 0;
-SSubCell defaultCell;
-TMargins tm = {0,0,0,0};
-defaultCell.iPosition = TPoint(0,0);
-defaultCell.iSize = TSize(0,0);
-defaultCell.iRealSize = TSize(0,0);
-defaultCell.iRealTextSize = TSize(0,0);
-defaultCell.iMargin = tm;
-defaultCell.iUseSubCellColors = EFalse;
-defaultCell.iColors = defaultcolors;
-defaultCell.iGraphics = EFalse;
-defaultCell.iAlign = CGraphicsContext::ELeft;
-defaultCell.iBaseline = 0;
-defaultCell.iNumberCell = EFalse;
-defaultCell.iTextClipGap = 0;
-defaultCell.iNotAlwaysDrawn = EFalse;
-defaultCell.iTransparent = EFalse;
-defaultCell.iBaseFont = 0;
-SSubCell* sc;
 for(;;)
 {
 if (subcell>lastSubCell)
 {
 break;
 }
-TInt subcellindex = 0;
+TextUtils::ColumnText(text,subcell, aText);
-TInt subcellfound = 0;
+if (text == KNullDesC && SubCellIsNotAlwaysDrawn(subcell))
-subcellfound = FindSubCellIndex(subcellindex,subcell);
+{
-if (subcellfound != KErrNotFound)
+textNull[subcell] = ETrue;
-{
-sc = &(iSubCellArray->At(subcellindex));
-}
-else
-{
-sc = &defaultCell;
-}
-TextUtils::ColumnText(textNull[subcell].iTextPtr,subcell, aText);
-if (textNull[subcell].iTextPtr == KNullDesC && sc->iNotAlwaysDrawn)
-{
-textNull[subcell].iTextNull = ETrue;
-}
-else
-{
-textNull[subcell].iTextNull = EFalse;
 }
 subcell++;
 }
 if (subcell>lastSubCell)
 {
 break;
 }
-if (textNull[subcell].iTextNull)
+if (textNull[subcell])
 {
 ++subcell;
 continue;
 }
-TInt subcellindex = 0;
+TRect bRect(SubCellPosition(subcell),SubCellSize(subcell));
-TInt subcellfound = 0;
+TMargins m(SubCellMargins(subcell));
-subcellfound = FindSubCellIndex(subcellindex,subcell);
+TRect cRect(bRect.iTl+TSize(m.iLeft,m.iTop),bRect.Size()-TSize(m.iRight+m.iLeft,m.iBottom+m.iTop));
-if (subcellfound != KErrNotFound)
-{
-sc = &(iSubCellArray->At(subcellindex));
-}
-else
-{
-sc = &defaultCell;
-}
-TRect bRect = TRect(sc->iPosition,sc->iSize);
+for (subcell2=subcell+1; subcell2<=lastSubCell; subcell2++)
-bRect.iBr.iX -= iconOffset;
+{
-TMargins m = sc->iMargin;
+if (textNull[subcell2])
-TRect cRect = TRect(bRect.iTl+TSize(m.iLeft,m.iTop),bRect.Size()-TSize(m.iRight+m.iLeft,m.iBottom+m.iTop));
-const TBool istrans = sc->iTransparent;
-if (!layoutMirrored)
-{
-for (subcell2=subcell+1; subcell2<=lastSubCell; subcell2++)
 {
-if (textNull[subcell2].iTextNull)
+continue;
-{
+}
-continue;
-}
+// This is called O(N^2) times - Do not put anything extra to it, it'll slow down drawing!
+TRect bRect2 = TRect(SubCellPosition(subcell2),SubCellSize(subcell2));
-// This is called O(N^2) times - Do not put anything extra to it, it'll slow down drawing!
+if (cRect.Intersects(bRect2) && bRect.Intersects(bRect2) && !SubCellIsTransparent(subcell) && !SubCellIsTransparent(subcell2))
-TRect bRect2( SubCellPosition( subcell2 ), SubCellSize( subcell2 ) );
+{
-if (cRect.Intersects(bRect2) && bRect.Intersects(bRect2) && !istrans && !SubCellIsTransparent(subcell2))
+if (!layoutMirrored)
 {
 cRect.iBr.iX = bRect2.iTl.iX;
 bRect.iBr.iX = bRect2.iTl.iX;
 }
-}
+else
-}
-else
-{
-for (subcell2=subcell+1; subcell2<=lastSubCell; subcell2++)
-{
-if (textNull[subcell2].iTextNull)
-{
-continue;
-}
-// This is called O(N^2) times - Do not put anything extra to it, it'll slow down drawing!
-TRect bRect2( SubCellPosition( subcell2 ), SubCellSize( subcell2 ) );
-if (cRect.Intersects(bRect2) && bRect.Intersects(bRect2) && !istrans && !SubCellIsTransparent(subcell2))
 {
 cRect.iTl.iX = bRect2.iBr.iX;
 bRect.iTl.iX = bRect2.iBr.iX;
 }
 }
 }
 SetSubCellRealTextSize(subcell, cRect.Size());
 SetSubCellRealSize(subcell, bRect.Size());
-sc->iRealTextSize = cRect.Size();
-sc->iRealSize = bRect.Size();
 subcell++;
 }
 // This loop does the drawing.
 aGc.SetPenStyle(CGraphicsContext::ENullPen);
 if (subcell>lastSubCell)
 {
 break;
 }
-if (textNull[subcell].iTextNull)
+if (textNull[subcell])
 {
 ++ subcell;
 continue;
 }
-TInt subcellindex = 0;
-TInt subcellfound = 0;
-subcellfound = FindSubCellIndex(subcellindex,subcell);
-if (subcellfound != KErrNotFound)
-{
-sc = &(iSubCellArray->At(subcellindex));
-}
-else
-{
-sc = &defaultCell;
-}
 // SetPosition, SetSize and margins support
-TRect bRect = TRect(sc->iPosition,sc->iRealSize);
+TRect bRect(SubCellPosition(subcell),SubCellRealSize(subcell));
-TMargins m = sc->iMargin;
+TMargins m(SubCellMargins(subcell));
-TRect cRect = TRect(bRect.iTl+TSize(m.iLeft,m.iTop),sc->iRealTextSize);
+TRect cRect(bRect.iTl+TSize(m.iLeft,m.iTop),SubCellRealTextSize(subcell));
 if (bRect.iBr.iX == 0)
 {
 ++subcell;
 continue;
 }
 if ( layoutMirrored )
 {
-TRect bRect( sc->iPosition, sc->iSize );
+TRect bRect = TRect(SubCellPosition(subcell),SubCellSize(subcell));
-bRect.iBr.iX -= iconOffset;
+TRect cRect2 = TRect(bRect.iTl+TSize(m.iLeft,m.iTop),bRect.Size()-TSize(m.iRight+m.iLeft,m.iBottom+m.iTop));
-TRect cRect2( bRect.iTl + TSize( m.iLeft, m.iTop ),
-bRect.Size() - TSize( m.iRight + m.iLeft,
-m.iBottom + m.iTop ) );
-TInt shift = (cRect2.Size() - sc->iRealTextSize).iWidth;
+TInt shift = (cRect2.Size() - SubCellRealTextSize(subcell)).iWidth;
 cRect.iTl.iX += shift;
 cRect.iBr.iX += shift;
 }
-textRect = TRect( itemRect.iTl + cRect.iTl, cRect.Size() );
+textRect.SetRect(aItemRect.iTl+cRect.iTl,cRect.Size());
-if (sc->iUseSubCellColors)
+if (UseSubCellColors(subcell))
 {
-subcellColors = &sc->iColors;
+subcellColors = &SubCellColors(subcell);
 }
 else
 {
 subcellColors = &aColors;
 }
-CListBoxView* view = listbox->View();
-TBool useOverrideColor = view->ItemDrawer()->Flags() & CListItemDrawer::EUseOverrideSkinTextColor;
 if (aHighlight)
 {
 aGc.SetPenColor(subcellColors->iHighlightedText);
 aGc.SetBrushColor(subcellColors->iHighlightedBack);
-if ( skinEnabled && !useOverrideColor )
+bmpBackColor = subcellColors->iHighlightedBack;
+bmpForeColor = subcellColors->iHighlightedText;
+if ( skinEnabled && iExtension )
 {
 if ( iExtension->iHighlightedTextColor != NULL )
 {
 aGc.SetPenColor( iExtension->iHighlightedTextColor );
+bmpForeColor = iExtension->iHighlightedTextColor;
 }
 }
 }
 else
 {
 aGc.SetPenColor(subcellColors->iText);
 aGc.SetBrushColor(subcellColors->iBack);
+bmpBackColor = subcellColors->iBack;
+bmpForeColor = subcellColors->iText;
-if ( skinEnabled && !useOverrideColor )
+if ( skinEnabled && iExtension )
 {
 if ( iExtension->iTextColor != NULL )
 {
 aGc.SetPenColor( iExtension->iTextColor );
+bmpForeColor = iExtension->iTextColor;
 }
 }
 }
 aGc.SetBrushStyle(CGraphicsContext::ENullBrush);
 // The following draws subcells to textRect
 if (textRect.iBr.iX!=textRect.iTl.iX)
 {
+TextUtils::ColumnText(text,subcell,aText);
 // graphics or text column
-CGraphicsContext::TTextAlign align=sc->iAlign;
+CGraphicsContext::TTextAlign align=SubCellAlignment(subcell);
-if (!sc->iGraphics)
+if (!SubCellIsGraphics(subcell))
 {
 const CFont* rowAndCellFont=RowAndSubCellFont(iExtension->iCurrentlyDrawnItemIndex,subcell);
-const CFont* cellFont=sc->iBaseFont;
+const CFont* cellFont=Font(aProperties, subcell);
 const CFont* tempFont=(cellFont) ? cellFont : font;
 const CFont* usedFont=(rowAndCellFont) ? rowAndCellFont : tempFont;
 aGc.UseFont(usedFont);
 SetUnderlineStyle( aProperties, aGc, subcell );
 // baseline calc needed for each cell.
-TInt baseLineOffset = sc->iBaseline;
+baseLineOffset = SubCellBaselinePos(subcell);
 baseLineOffset -= cRect.iTl.iY;
 if (!baseLineOffset)
 {
 baseLineOffset = (cRect.Size().iHeight-usedFont->HeightInPixels())/2 + usedFont->AscentInPixels();
 }
-TBuf<KMaxColumnDataLength + KAknBidiExtraSpacePerLine> clipbuf;// = sc->iColumnText.Left(KMaxColumnDataLength);
+TBuf<KMaxColumnDataLength + KAknBidiExtraSpacePerLine> clipbuf =
+text.Left(KMaxColumnDataLength);
 // Note that this potentially modifies the text so its lenght in pixels
 // might increase. Therefore, this should always be done before
 // wrapping/clipping text. In some cases, WordWrapListItem is called
 // before coming here. Is it certain that it is not done for number subcells?
-TBool bufset = EFalse;
+if (SubCellIsNumberCell(subcell))
-if (sc->iNumberCell)
 {
-clipbuf = textNull[subcell].iTextPtr.Left(KMaxColumnDataLength);
 AknTextUtils::LanguageSpecificNumberConversion(clipbuf);
-bufset = ETrue;
 }
 TBool clipped( EFalse );
-TInt clipgap = sc->iTextClipGap;
+TInt clipgap = SubCellTextClipGap( subcell );
 if ( iExtension->iUseLogicalToVisualConversion &&
 subcell != iExtension->iFirstWordWrappedSubcellIndex &&
 subcell != iExtension->iSecondWordWrappedSubcellIndex )
 {
 TInt maxClipWidth = textRect.Size().iWidth + clipgap;
 clipped = AknBidiTextUtils::ConvertToVisualAndClip(
-textNull[subcell].iTextPtr.Left(KMaxColumnDataLength),
+text.Left(KMaxColumnDataLength),
 clipbuf,
 *usedFont,
-textRect.Width(),
+textRect.Size().iWidth,
 maxClipWidth );
-}
-else if (!bufset)
-{
-clipbuf = textNull[subcell].iTextPtr.Left(KMaxColumnDataLength);
 }
 if (clipped)
 {
 if (!layoutMirrored)
 CAknMarqueeControl* marquee =
 subcell == 1 ? iExtension->iMarquee :
 iExtension->i2ndLineMarquee;
 TBool marqueeDisabled =
-listbox->View()->ItemDrawer()->Flags() & CListItemDrawer::EDisableMarquee;
+static_cast<CEikListBox*>(
+Control() )->View()->ItemDrawer()->Flags() & CListItemDrawer::EDisableMarquee;
 if ( aHighlight && iExtension->IsMarqueeOn() && clipped && !marqueeDisabled )
 {
 // Let marquee know if it needs to do bidi conversion.
 marquee->UseLogicalToVisualConversion( clipped );
-if ( marquee->DrawText( aGc, textRect, textNull[subcell].iTextPtr, baseLineOffset, align, *usedFont ) )
+if ( marquee->DrawText( aGc, textRect, text, baseLineOffset, align, *usedFont ) )
 {
 // All the loops have been executed -> the text needs to be truncated.
 aGc.DrawText( clipbuf, textRect, baseLineOffset, align, 0 );
 }
 }
 aGc.SetUnderlineStyle(EUnderlineOff);
 aGc.DiscardFont(); // Release the font cache
 }
 else // Graphics subcell
 {
-TLex lex(textNull[subcell].iTextPtr);
+TLex lex(text);
 TInt index;
 __ASSERT_ALWAYS(lex.Val(index)==KErrNone,Panic(EAknPanicFormattedCellListInvalidBitmapIndex));
 __ASSERT_DEBUG(iIconArray, Panic(EAknPanicOutOfRange));
 if ( index == KColorIconFlag ) index = KColorIconIdx;
 __ASSERT_DEBUG((index>=0 && index<iIconArray->Count()),Panic(EAknPanicFormattedCellListInvalidBitmapIndex));
 if (index>=0 && iIconArray)
 {
 CGulIcon* icon=(*iIconArray)[index];
 CFbsBitmap* bitmap=icon->Bitmap();
+if ( iExtension )
-TInt w, h;
-TSize sz = bitmap->SizeInPixels();
-w = iExtension->iSubCellIconSize[subcell].iWidth;
-h = iExtension->iSubCellIconSize[subcell].iHeight;
-if (h != 0 && w != 0 && !( sz.iWidth == w || sz.iHeight == h ) )
 {
-AknIconUtils::SetSize( bitmap,
+TInt w, h;
-iExtension->iSubCellIconSize[subcell],
+TSize sz = bitmap->SizeInPixels();
-EAspectRatioPreservedAndUnusedSpaceRemoved );
+w = iExtension->iSubCellIconSize[subcell].iWidth;
+h = iExtension->iSubCellIconSize[subcell].iHeight;
+if (h != 0 && w != 0 && !( sz.iWidth == w || sz.iHeight == h ) )
+{
+AknIconUtils::SetSize( bitmap,
+iExtension->iSubCellIconSize[subcell],
+EAspectRatioPreservedAndUnusedSpaceRemoved );
+}
+else if ( sz.iWidth == 0 || sz.iHeight == 0 ) // check if size is set at all
+{
+// just in case fallback
+AknIconUtils::SetSize( bitmap,
+textRect.Size(),
+EAspectRatioPreservedAndUnusedSpaceRemoved );
+}
 }
-else if ( sz.iWidth == 0 || sz.iHeight == 0 ) // check if size is set at all
-{
-// just in case fallback
-AknIconUtils::SetSize( bitmap,
-textRect.Size(),
-EAspectRatioPreservedAndUnusedSpaceRemoved );
-}
 TSize size=bitmap->SizeInPixels();
-if (size.iWidth>textRect.Width())
+if (size.iWidth>textRect.Size().iWidth)
 {
-size.iWidth = textRect.Width();
+size.iWidth = textRect.Size().iWidth;
 }
-if (size.iHeight>textRect.Height())
+if (size.iHeight>textRect.Size().iHeight)
 {
-size.iHeight = textRect.Height();
+size.iHeight = textRect.Size().iHeight;
 }
 TPoint bmpPos=textRect.iTl;
 bmpPos.iY+=(textRect.Height()-size.iHeight)>>1;
 switch (align)
 _AKNTRACE_FUNC_EXIT;
 }
 void CFormattedCellListBoxData::SetClippedByWrap( TUint32 aClippedCells, TBool aUseClippedByWrap )
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-iExtension->iClippedByWrap = aClippedCells;
+{
-iExtension->iUseClippedByWrap = aUseClippedByWrap;
+iExtension->iClippedByWrap = aClippedCells;
+iExtension->iUseClippedByWrap = aUseClippedByWrap;
+}
 }
 EXPORT_C TUint32 CFormattedCellListBoxData::CurrentItemTextWasClipped() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+return iExtension ? iExtension->iClippedSubcells : 0;
-return iExtension->iClippedSubcells;
 }
 TBool CFormattedCellListBoxData::KineticScrollingEnabled() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension )
-return iExtension->iKineticScrolling;
+{
+return iExtension->iKineticScrolling;
+}
+return EFalse;
 }
 CEikListBox* CFormattedCellListBoxData::ListBox() const
 {
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicNullPointer ));
+if ( iExtension && iExtension->iControl )
-if ( iExtension->iControl )
 {
 return static_cast<CEikListBox*>( iExtension->iControl );
 }
 return NULL;
 }
-void CFormattedCellListBoxData::InitSmileyL()
-{
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicObjectNotFullyConstructed ));
-if ( !iExtension->iSmileyMan )
-{
-iExtension->iSmileyMan = CAknSmileyManager::NewL( iExtension );
-}
-}
-void CFormattedCellListBoxData::SetSmileySubCellL( TInt aSubCell )
-{
-__ASSERT_DEBUG( iExtension, Panic( EAknPanicObjectNotFullyConstructed ));
-TInt index = 0;
-if ( iExtension )
-{
-iExtension->FindSLSubCellIndexOrAddL( index,aSubCell );
-iExtension->SLAt(index).iSmileyCell = ETrue;
-}
-}
-#ifdef __ARMCC__
-#pragma pop
-#endif // __ARMCC__
 // End of File

branch	RCL_3
changeset 19	aecbbf00d063
parent 18	fcdfafb36fe7
child 20	d48ab3b357f1