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

equal deleted inserted replaced

-:8ca85d2f0db7
+:aabf2c525e0f
 const TInt KAreaIdMain   = 1;
 const TInt KAreaIdTail   = 2;
 // ----------------------------------------------------------------------------
-// TEmotionUtils definition
-// ----------------------------------------------------------------------------
-//
-const TUint KEmotionCharBase = 0xf880;
-class TEmotionUtils
-{
-public:
-static TBool IsEmotionChar(TChar aChar);
-static TChar EmotionChar(TInt aId);
-static TInt EmotionId(TChar aChar);
-static TChar EmotionSwitchToSmileyChar();
-static TChar EmotionSwitchToSctChar();
-};
-TBool TEmotionUtils::IsEmotionChar(TChar aChar)
-{
-return (aChar >= KEmotionCharBase);
-}
-TChar TEmotionUtils::EmotionChar(TInt aId)
-{
-return (KEmotionCharBase + aId);
-}
-TInt TEmotionUtils::EmotionId(TChar aChar)
-{
-return (TInt)(aChar - KEmotionCharBase);
-}
-TChar TEmotionUtils::EmotionSwitchToSmileyChar()
-{
-return KEmotionCharBase + CSmileyModel::EIconSwitchToSmiley;
-}
-TChar TEmotionUtils::EmotionSwitchToSctChar()
-{
-return KEmotionCharBase + CSmileyModel::EIconSwitchToSct;
-}
-// ----------------------------------------------------------------------------
 // CAknCharMapHistory definition
 // ----------------------------------------------------------------------------
 //
 /**
 *  Recent data management when a Special characters or a Pictograph characters
 * Insert a character which select on SCT/Picto.
 * @since 2.8
 * @param aHistoryType The kind of charctor map, refer to THistoryType
 * @param aChar    Insert a character
 */
-void InsertChar(THistoryType aHistoryType, const TChar aChar);
+void InsertChar(THistoryType aHistoryType, const TChar aChar, TBool aIsEmotion);
 private:
 /**
 * C++ default constructor.
 * @since 2.8
 //
 NONSHARABLE_CLASS(CAknCharMapExtension) :
 public CBase,
 public MObjectProvider,
 public MAknSctFocusHandler,
-public MSmileyIconObserver
+public MAknSmileyObserver
 {
 public:
 CAknCharMapExtension();
 ~CAknCharMapExtension();
 protected:
 TTypeUid::Ptr MopSupplyObject(TTypeUid aId);
 MObjectProvider* MopNext();
 private: // from MSmileyIconObserver
-virtual void ThumbnailLoaded(CSmileyIcon* aSmileyIcon);
+virtual void SmileyStillImageLoaded(CAknSmileyIcon* aSmileyIcon);
-virtual void AnimationChanged(CSmileyIcon* aSmileyIcon);
+virtual void SmileyAnimationChanged(CAknSmileyIcon* aSmileyIcon);
 public:
 TBool IsEmotionEnabled() const;
 TBool IsShowingEmotion() const;
+void SwitchEmotionVisibilityL();
 TBool NeedEmotionSwitchIcon() const;
 HBufC* ReadEmotionHBufCL();
-void LoadEmotionTumbnails(const TDesC& aSctChars);
+void LoadEmotionTumbnails(const TDesC& aChars);
 void SetEmotionSize(const TSize& aSize);
+TBool IsEmotionChar(TChar aChar);
-CSmileyIcon* EmotionIcon(TChar aEmotionChar);
+TChar SwitchToSctChar();
-TBool DrawEmotion(CWindowGc& aGc, const TRect& aRect, TChar aEmotionChar);
+TChar SwitchToEmotionChar();
+CAknSmileyIcon* EmotionIcon(TChar aChar);
+const TDesC& EmotionText(TChar aChar);
+TBool DrawEmotion(CWindowGc& aGc, const TRect& aRect, CAknSmileyIcon* aSmileyIcon);
 void HandleFocusStatusChanged(TChar aChar, TBool aIsFocused);
 public: // data
 MCoeControlObserver *iObserver;
 HBufC* iCharsQwerty;
 // Indicates whether menu sct is highlighted or not.
 TBool iMenuSctHighlighted;
 public: // for Emotion
 HBufC* iCharsSmiley;
-CSmileyModel iSmileyModel;
+CSmileyModel* iSmileyModel;
 TChar iLastFocusedSmileyChar;
 TBool iIsShowingEmotion;
 TBool iIsEnableEmotion;
 public: // Single click
 /**
 * Is highlight visible
 */
 TBool iHighlightVisible;
+/**
+* Is keyboard event
+*/
+TBool iKeyBrdEvent;
 };
 // ----------------------------------------------------------------------------
 // Navi button class implementation
 // ----------------------------------------------------------------------------
 void CAknSctTableNavi::TableExitL()
 {
 delete iIdle;
 iIdle = 0;
-iIdle = CIdle::NewL(CActive::EPriorityIdle);
+iIdle = CIdle::NewL(CActive::EPriorityStandard);
 iIdle->Start(TCallBack(DoTableExit, this));
 }
 TInt CAknSctTableNavi::DoTableExit(TAny* aThis)
 {
 // ----------------------------------------------------------------------------
 // Extension class implementation
 // ----------------------------------------------------------------------------
 //
-CAknCharMapExtension::CAknCharMapExtension() : iSmileyModel(this)
+CAknCharMapExtension::CAknCharMapExtension() : iSingleClickEnabled( iAvkonAppUi->IsSingleClickCompatible() )
-,iSingleClickEnabled( iAvkonAppUi->IsSingleClickCompatible() )
 {
 iObserver = NULL;
 iPictographsBuffer = FeatureManager::FeatureSupported(KFeatureIdJapanesePicto);
 iPictographsBufferGrouping = FeatureManager::FeatureSupported(KFeatureIdJapanesePictographsGrouping);
 iKineticScrolling = CAknPhysics::FeatureEnabled();
-TRAP_IGNORE(iSmileyModel.LoadResourceL());
+TRAP_IGNORE(iSmileyModel = new (ELeave) CSmileyModel(this));
+TRAP_IGNORE(iSmileyModel->LoadResourceL());
 }
 TTypeUid::Ptr CAknCharMapExtension::MopSupplyObject(TTypeUid aId)
 {
 return MAknsControlContext::SupplyMopObject(aId, iBgContext );
 return iCharMap;
 }
 CAknCharMapExtension::~CAknCharMapExtension()
 {
+delete iSmileyModel;
 delete iCharsSmiley;
 delete iCharsQwerty;
 delete iBgContext;
 delete iRadioButton;
 TBool CAknCharMapExtension::EnterControl(TInt aX, TInt aY)
 {
 if(iCharMapProxy->EnterControl(aX, aY))
 {
 iFocusHandler = this;
-iCharMapProxy->HandleFocusStatusChanged();
 return ETrue;
 }
 else
 {
 return EFalse;
 TBool CAknCharMapExtension::ExitWithKey(TInt /*aKeycode*/)
 {
 return ETrue;
 }
-void CAknCharMapExtension::ThumbnailLoaded(CSmileyIcon* /*aSmileyIcon*/)
+void CAknCharMapExtension::SmileyStillImageLoaded(CAknSmileyIcon* aSmileyIcon)
 {
-iCharMapProxy->DrawDeferred();
+iCharMapProxy->SmileyStillImageLoaded(iSmileyModel->SmileyCode(aSmileyIcon));
 }
-void CAknCharMapExtension::AnimationChanged(CSmileyIcon* /*aSmileyIcon*/)
+void CAknCharMapExtension::SmileyAnimationChanged(CAknSmileyIcon* aSmileyIcon)
 {
-iCharMapProxy->DrawCursor();
+iCharMapProxy->SmileyAnimationChanged(iSmileyModel->SmileyCode(aSmileyIcon));
+User::After(30); // for slow down the AO of this animation
 }
 TBool CAknCharMapExtension::IsEmotionEnabled() const
 {
 return iIsEnableEmotion;
 }
 TBool CAknCharMapExtension::IsShowingEmotion() const
 {
 return iIsShowingEmotion;
+}
+void CAknCharMapExtension::SwitchEmotionVisibilityL()
+{
+iIsShowingEmotion = !iIsShowingEmotion;
 }
 TBool CAknCharMapExtension::NeedEmotionSwitchIcon() const
 {
 // Emotion switch char
 return needEmotionSwitchIcon;
 }
 HBufC* CAknCharMapExtension::ReadEmotionHBufCL()
 {
-TInt smileyCount = iSmileyModel.Count();
+TInt smileyCount = iSmileyModel->Count();
 HBufC* charsSmiley = HBufC::NewL(smileyCount);
 TPtr charsSmileyPtr(charsSmiley->Des());
-for(TInt id(CSmileyModel::EIconSmiley); id<smileyCount; id++)
+for(TInt index(0); index<smileyCount; index++)
 {
-charsSmileyPtr.Append(TEmotionUtils::EmotionChar(id));
+charsSmileyPtr.Append(iSmileyModel->SmileyCode(index));
 }
 return charsSmiley;
 }
-void CAknCharMapExtension::LoadEmotionTumbnails(const TDesC& aSctChars)
+void CAknCharMapExtension::LoadEmotionTumbnails(const TDesC& aChars)
 {
-for(TInt i(0); i<aSctChars.Length(); i++)
+iSmileyModel->LoadStillImagesL(aChars);
-{
-iSmileyModel.LoadThumbnailAsyn(TEmotionUtils::EmotionId(aSctChars[i]));
-}
 }
 void CAknCharMapExtension::SetEmotionSize(const TSize& aSize)
 {
 TInt unit = Min(aSize.iWidth, aSize.iHeight);
-iSmileyModel.SetSize(TSize(unit,unit));
+iSmileyModel->SetSize(TSize(unit,unit));
 }
-CSmileyIcon* CAknCharMapExtension::EmotionIcon(TChar aEmotionChar)
+TBool CAknCharMapExtension::IsEmotionChar(TChar aChar)
 {
-if(TEmotionUtils::IsEmotionChar(aEmotionChar))
+return iSmileyModel->IsSmiley(aChar);
-{
+}
-return iSmileyModel[TEmotionUtils::EmotionId(aEmotionChar)];
-}
+TChar CAknCharMapExtension::SwitchToSctChar()
-else
+{
-{
+return iSmileyModel->SwitchToSctCode();
-return NULL;
+}
-}
-}
+TChar CAknCharMapExtension::SwitchToEmotionChar()
+{
-TBool CAknCharMapExtension::DrawEmotion(CWindowGc& aGc, const TRect& aRect, TChar aEmotionChar)
+return iSmileyModel->SwitchToSmileyCode();
-{
+}
-CSmileyIcon* icon = EmotionIcon(aEmotionChar);
-if(icon && icon->ReadyToDraw())
+CAknSmileyIcon* CAknCharMapExtension::EmotionIcon(TChar aChar)
 {
-TRect iconRect(TPoint(),icon->Size());
+return iSmileyModel->Smiley(aChar);
+}
+const TDesC& CAknCharMapExtension::EmotionText(TChar aChar)
+{
+return iSmileyModel->Text(aChar);
+}
+TBool CAknCharMapExtension::DrawEmotion(CWindowGc& aGc, const TRect& aRect, CAknSmileyIcon* aSmileyIcon)
+{
+if(aSmileyIcon && aSmileyIcon->ReadyToDraw())
+{
+TRect iconRect(TPoint(),aSmileyIcon->Size());
 TInt xoffset = (aRect.Width() - iconRect.Width()) / 2;
 TInt yoffset = (aRect.Height() - iconRect.Height()) / 2;
-aGc.BitBltMasked(aRect.iTl+TPoint(xoffset,yoffset), icon->Image(), iconRect, icon->Mask(), FALSE);
+aGc.BitBltMasked(aRect.iTl+TPoint(xoffset,yoffset), aSmileyIcon->Image(), iconRect, aSmileyIcon->Mask(), FALSE);
 return ETrue;
 }
 else
 {
 return EFalse;
 const TInt KEmotionAnimationRepeatCount = 30; // 30 times
 const TInt KEmotionAnimationDelay = 150*1000; // 0.15s
 void CAknCharMapExtension::HandleFocusStatusChanged(TChar aChar, TBool aIsFocused)
 {
-CSmileyIcon* lastIcon = EmotionIcon(iLastFocusedSmileyChar);
+CAknSmileyIcon* lastIcon = EmotionIcon(iLastFocusedSmileyChar);
 if(lastIcon)
 {
 lastIcon->StopAnimation();
 }
-CSmileyIcon* focusedIcon = EmotionIcon(aChar);
+CAknSmileyIcon* focusedIcon = EmotionIcon(aChar);
 if(focusedIcon)
 {
 if(aIsFocused)
 {
 if(iHighlightVisible)
 // -----------------------------------------------------------------------------
 // CAknCharMapHistory::InsertChar()
 // Insert a character which select on SCT/Picto.
 // -----------------------------------------------------------------------------
 //
-void CAknCharMapHistory::InsertChar(THistoryType aHistoryType, const TChar aChar)
+void CAknCharMapHistory::InsertChar(THistoryType aHistoryType, const TChar aChar, TBool aIsEmotion)
 {
 __ASSERT_ALWAYS((EHistoryTypeFull<=aHistoryType && aHistoryType<EHistoryTypeMax), Panic(EAknPanicInvalidValue));
 InsertCharToHistoryBuf(iMixedHistoryArray[aHistoryType], aChar);
-if(TEmotionUtils::IsEmotionChar(aChar))
+if(aIsEmotion)
 {
 InsertCharToHistoryBuf(iEmotionHistory, aChar);
 }
 else
 {
 CountMaxColumnsAndCellSizes();
 SizeChanged();
 // load Emotion icon resource, but not load images
 TSize iconSize(iGridItemWidth,iGridItemHeight);
-iconSize.iWidth = iconSize.iWidth * 2 / 3;
+iconSize.iWidth = iconSize.iWidth * 3 / 4;
-iconSize.iHeight = iconSize.iHeight * 2 / 3;
+iconSize.iHeight = iconSize.iHeight * 3 / 4;
 Extension()->SetEmotionSize(iconSize);
 }
 EXPORT_C void CAknCharMap::ConstructFromResourceL(TResourceReader& aReader)
 {
 iShowCasesRef = &iSpecialCharCases;
 iShowPagesRef = &iSpecialCharPages;
 // default
+iSpecialCharCase = EAknSCTLowerCase;
 iChars = iCharsBufferLower;
 if(iExtension->iCharsSmiley && iExtension->IsShowingEmotion())
 {
 iChars = iExtension->iCharsSmiley;
 if(pageNavi)
 {
 pageNavi->MakeVisible(PageCount()>1);
 }
-HandleFocusStatusChanged();
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 }
 EXPORT_C void CAknCharMap::SetBuffer(TDes& aSpecialChars)
 {
 {
 if ( code == EKeyUpArrow || code == EKeyDownArrow ||
 code == EKeyLeftArrow || code == EKeyRightArrow ||
 code == EKeyEnter )
 {
+iExtension->iKeyBrdEvent = ETrue;
 iExtension->iHighlightVisible = ETrue;
 iCursorPos = TPoint( 0, 0 );
 DrawCursor();
-HandleFocusStatusChanged();
 return EKeyWasConsumed;
 }
 }
 switch (code)
 // Append right amount of recent characters due to different layout.
 if (recentWasSetBeforeSwitch) AppendRecentCharL();
 // Sets the character case because the buffer content may have changed.
 SetCharacterCaseL(iSpecialCharCase);
-// status after layout switch.
-TInt recentLengthAfterSwitch = iMaxColumns; // recentLength has changed after switch
 TInt cursorIndexAfterSwitch;
-if(cursorIndexBeforeSwitch < recentLengthBeforeSwitch)
+if ( !iExtension->iKeyBrdEvent )
 {
 cursorIndexAfterSwitch = cursorIndexBeforeSwitch;
 }
 else
 {
-cursorIndexAfterSwitch = cursorIndexBeforeSwitch - recentLengthBeforeSwitch + recentLengthAfterSwitch;
+// status after layout switch.
-}
+TInt recentLengthAfterSwitch = iMaxColumns; // recentLength has
+// changed after switch
+if ( cursorIndexBeforeSwitch < recentLengthBeforeSwitch )
+{
+cursorIndexAfterSwitch = cursorIndexBeforeSwitch;
+}
+else
+{
+cursorIndexAfterSwitch = cursorIndexBeforeSwitch -
+recentLengthBeforeSwitch + recentLengthAfterSwitch;
+}
+}
 // the new first row is the top row on the page where the new focus is.
 TInt pageVolume = iMaxColumns * iExtension->iMaxVisibleRows;
 iFirstVisibleRow = (cursorIndexAfterSwitch / pageVolume * pageVolume) / iMaxColumns;
 // the cursor positions are relative to current page
 // !resize an option but the cost only differs with the creation of the graphic objects!
 CreateOffscreenBackgroundL();
 iOffscreenBgDrawn = EFalse;
 }
-else if ( aType == KAknsMessageSkinChange )
+else if( aType == KAknsMessageSkinChange )
 {
 iOffscreenBgDrawn = EFalse;
 }
-else if ( aType == KAknMessageFocusLost && iExtension->iHighlightVisible )
-{
+else if(aType == KEikMessageFadeAllWindows) // focus gained // KEikMessageWindowsFadeChange
-iExtension->iHighlightVisible = EFalse;
+{
-DrawCursor();
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 }
+else if(aType == KAknMessageFocusLost) // focus lost
+{
+SetSmileyAnimationActivityInCurrentPageL(EFalse);
+	if ( iExtension->iHighlightVisible )
+	{
+	iExtension->iHighlightVisible = EFalse;
+	DrawCursor();
+	}
+	}
 }
 void CAknCharMap::EnableNavigationButtonsL()
 {
 if ( iExtension )
 {
 AknsUtils::GetCachedColor( skin, color,
 KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );
 }
-if(TEmotionUtils::IsEmotionChar(symbol[0]))
+CAknSmileyIcon* icon = iExtension->EmotionIcon(symbol[0]);
-{
+if(icon)
-iExtension->DrawEmotion(aGc, textLayout.TextRect(), symbol[0]);
+{
+iExtension->DrawEmotion( aGc, textLayout.TextRect(), icon );
 }
 else
 {
 textLayout.DrawText( aGc, symbol, EFalse, color );
 }
 MTouchFeedback* feedback = MTouchFeedback::Instance();
 CFeedbackSpec* spec = CFeedbackSpec::New();
 if ( feedback && spec )
 {
-TInt orphans = NumberOfVisibleChars() % iMaxColumns;
+TInt orphans = numberOfCells % iMaxColumns;
-TInt rows = NumberOfVisibleChars() / iMaxColumns;
+TInt rows = numberOfCells / iMaxColumns;
 CAknCharMap* mutableThis = MUTABLE_CAST( CAknCharMap* ,this );
 TInt recentChars = mutableThis->LengthOfRecentChar();
 TRect rectMain;
 TPoint nextTopLeft = iGridTopLeft;
 else
 {
 pt.iX = index;
 }
 }
-HandleFocusStatusChanged();
 iCursorPos = pt;
 UpdateScrollIndicatorL();
 DrawNow();
 }
 if ((iRows > iExtension->iMaxVisibleRows) &&
 (iOldCursorPos.iY + oldFirstVisibleRow != iCursorPos.iY + iFirstVisibleRow))
 {
 UpdateScrollIndicatorL();
 }
-HandleFocusStatusChanged();
 if (oldFirstVisibleRow == iFirstVisibleRow)
 {
 // Draw only cursor if the view to the content was not scrolled.
 DrawCursor();
 }
 TInt CAknCharMap::NextPageL()
 {
-HandleFocusStatusChanged(EFalse);
+SetSmileyAnimationActivityInCurrentPageL(EFalse);
 TInt page(0);
 iFirstVisibleRow =
 (((iCursorPos.iY + iFirstVisibleRow) / iExtension->iMaxVisibleRows) + 1)
 * iExtension->iMaxVisibleRows;
 }
 }
 UpdateHeadingPane( ETrue );
 UpdateScrollIndicatorL();
-HandleFocusStatusChanged();
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 DrawNow();
 return page;
 }
 TInt CAknCharMap::PrevPageL()
 {
-HandleFocusStatusChanged(EFalse);
+SetSmileyAnimationActivityInCurrentPageL(EFalse);
 TInt page(0);
 TInt firstVisibleRow =
 (((iCursorPos.iY + iFirstVisibleRow) / iExtension->iMaxVisibleRows) - 1) *
 iExtension->iMaxVisibleRows;
 iCursorPos = TPoint(0, 0);
 }
 }
 UpdateHeadingPane( ETrue );
 UpdateScrollIndicatorL();
-HandleFocusStatusChanged();
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 DrawNow();
 return page;
 }
 // to the array in which all the special characters are placed by the normal
 // (rocker) method.
 //--------------------------------------------------------------------------
 EXPORT_C void CAknCharMap::HandlePointerEventL(const TPointerEvent& aPointerEvent)
 {
+iExtension->iKeyBrdEvent = EFalse;
 if ( AknLayoutUtils::PenEnabled() && Rect().Contains(aPointerEvent.iPosition))
 {
 if (iExtension->iFocusHandler->FocusedControl() != this)// Tapping will move focus to grid.
 {
 iExtension->iFocusHandler->LeaveControl();
 {
 if( iExtension->iSingleClickEnabled )
 {
 iExtension->iHighlightVisible = ETrue;
 }
-HandleFocusStatusChanged();
 }
 DrawCursor();
 }
 else if (aPointerEvent.iType == TPointerEvent::EButton1Up)
 {
 if (iExtension->iObserver)
 {
 iExtension->iObserver->HandleControlEventL(this, MCoeControlObserver::EEventRequestFocus);
 }
-HandleFocusStatusChanged();
 DrawDeferred();
 }
 }
 // -----------------------------------------------------------------------------
 }
 TPtrC textHistory = iCharMapHistory->RecentString(historyType, CAknCharMapHistory::EHistoryFilterTextOnly);
 *charsBuf = InsertSwitchCharAndHistoryToCharsBufL(*charsBuf,
-TEmotionUtils::EmotionSwitchToSmileyChar(),
+iExtension->SwitchToEmotionChar(),
 textHistory);
 }
 // Emotion history
 TPtrC emotionHistory = iCharMapHistory->RecentString(CAknCharMapHistory::EHistoryTypeFull, CAknCharMapHistory::EHistoryFilterEmotionOnly);
 iExtension->iCharsSmiley = InsertSwitchCharAndHistoryToCharsBufL(iExtension->iCharsSmiley,
-TEmotionUtils::EmotionSwitchToSctChar(),
+iExtension->SwitchToSctChar(),
 emotionHistory);
 // ETrue are set to each variable when setting the recent used characters.
 iSetRecentSct = ETrue;
 iSetRecentPic = ETrue;
 // Check whether recent charcters are included in base charcters.
 TBuf<CAknCharMapHistory::KHistoryBufferSize+5> insertBuffer;
 for (TInt index=0; index<aHistory.Length(); index++)
 {
 TChar txt = aHistory[index];
-if(aCharsBuf->Locate(txt)!=KErrNotFound || TEmotionUtils::IsEmotionChar(txt) || txt==KHistoryEmptyChar)
+if(aCharsBuf->Locate(txt)!=KErrNotFound || Extension()->IsEmotionChar(txt) || txt==KHistoryEmptyChar)
 {
 insertBuffer.Append(txt);
 }
 }
 break;
 }
 if (historyType > CAknCharMapHistory::EHistoryTypeNull)
 {
-iCharMapHistory->InsertChar(historyType, aChar);
+TBool isEmotion = Extension()->IsEmotionChar(aChar);
+iCharMapHistory->InsertChar(historyType, aChar, isEmotion);
 }
 // Save recent data
 iCharMapHistory->SaveL();
 }
 // If the row is empty, nothing to do
 if (LengthOfRecentChar() == 0)
 {
 return;
 }
-HandleFocusStatusChanged(aHighlight);
+SetSmileyAnimationActivityInCurrentPageL(aHighlight);
 CWindowGc& gc = SystemGc();
 if( !CAknEnv::Static()->TransparencyEnabled() )
 {
 ActivateGc();
 ptrrecent.Copy(recentChars);
 for (TInt index=0; index < ptrrecent.Length(); index++)
 {
 if (ptrrecent[index] != KHistoryEmptyChar)
 {
-if(TEmotionUtils::IsEmotionChar(ptrrecent[index]))
+if(Extension()->IsEmotionChar(ptrrecent[index]))
 {
 continue;
 }
 else
 {
 if (err == KErrNotFound)
 {
 ptrrecent.Delete(index,1);
 ptrrecent.Append(KHistoryEmptyChar);
 index--;
 }
 }
 }
 }
 if (iExtension->iFlags & EAknCharMapCharsAllocated) // iChars already contains HBufC
 {                                               // so delete old instance
 iExtension->iFlags |= EAknCharMapCharsAllocated; // mark that iChars points to HBufC
 }
 iExtension->LoadEmotionTumbnails(*iChars);
-HandleFocusStatusChanged();
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 }
 // -----------------------------------------------------------------------------
 // CAknCharMap::CharacterCase()
 // Get current character case.
 TRAP_IGNORE(MoveCursorL(aX,aY));
 }
 TBool CAknCharMap::LeaveControl()
 {
-HandleFocusStatusChanged(EFalse);
 CWindowGc& gc = SystemGc();
 if( !CAknEnv::Static()->TransparencyEnabled() )
 {
 ActivateGc();
 gc.UseFont(iFont);
 }
 // for emotion added
-void CAknCharMap::HandleFocusStatusChanged(TBool aIsFocused)
-{
-TInt focusPos = iCursorPos.iX + (iFirstVisibleRow + iCursorPos.iY) * iMaxColumns;
-if(focusPos>=0 && focusPos<iChars->Length())
-{
-aIsFocused &= (iExtension->iFocusHandler->FocusedControl()==this);
-iExtension->HandleFocusStatusChanged((*iChars)[focusPos], aIsFocused);
-}
-}
 TBool CAknCharMap::EmotionsAreAllReadyToDraw(TInt aIndex, TInt aCount) const
 {
 for(TInt i(0); i<aCount; i++)
 {
 if(aIndex < iChars->Length())
 {
-TChar name = (*iChars)[aIndex++];
+TChar code = (*iChars)[aIndex++];
-CSmileyIcon* icon = iExtension->EmotionIcon(name);
+CAknSmileyIcon* icon = Extension()->EmotionIcon(code);
 if(icon && !icon->ReadyToDraw())
 {
 return EFalse;
 }
 }
 }
 return ETrue;
 }
+void CAknCharMap::SmileyStillImageLoaded(TChar aChar)
+{
+const CAknSmileyIcon* loadedIcon = Extension()->EmotionIcon(aChar);
+for(TInt i(0); i<iChars->Length(); i++)
+{
+TChar code = (*iChars)[i];
+CAknSmileyIcon* icon = Extension()->EmotionIcon(code);
+if(icon == loadedIcon)
+{
+if((i%iMaxColumns == 0) || (i == iChars->Length()-1))
+{
+DrawDeferred(); // a new line is finished
+}
+}
+}
+}
+void CAknCharMap::SmileyAnimationChanged(TChar aChar)
+{
+const CAknSmileyIcon* loadedIcon = Extension()->EmotionIcon(aChar);
+TInt pageVolume = iExtension->iMaxVisibleRows * iMaxColumns;
+for(TInt i(0); i<iChars->Length(); i++)
+{
+TChar code = (*iChars)[i];
+CAknSmileyIcon* icon = iExtension->EmotionIcon(code);
+if(icon == loadedIcon)
+{
+TInt index = i % pageVolume;
+TPoint pos(index%iMaxColumns, index/iMaxColumns);
+// grid is focused and cursor pos is same with the current index.
+TBool highlighted = EFalse;
+if(iExtension->iFocusHandler->FocusedControl()==this && iCursorPos==pos)
+{
+highlighted = (!iExtension->iMenuSct || iExtension->iMenuSctHighlighted);
+}
+DrawCell(index, highlighted);
+}
+}
+}
+const TInt KAnimationRepeat = 30;
+const TInt KAnimationDelay = 1000*1000;
+void CAknCharMap::SetSmileyAnimationActivityInCurrentPageL(TBool aIsActive)
+{
+TInt begin = iFirstVisibleRow * iMaxColumns;
+TInt end = iExtension->iMaxVisibleRows * iMaxColumns + begin;
+if(end > iChars->Length()) end = iChars->Length();
+for(TInt i(begin); i<end; i++)
+{
+TChar code = (*iChars)[i];
+CAknSmileyIcon* icon = iExtension->EmotionIcon(code);
+if(!icon) continue;
+if((aIsActive) &&
+(Extension()->IsShowingEmotion()||Extension()->iMenuSctHighlighted)
+)
+{
+icon->PlayAnimationL(KAnimationRepeat, KAnimationDelay);
+}
+else
+{
+icon->StopAnimation();
+}
+}
+}
 void CAknCharMap::GetFocusSctName(TChar& aChar, TDes& aName) const
 {
 TInt pos = iMaxColumns * (iFirstVisibleRow + iCursorPos.iY) + iCursorPos.iX;
 aChar = (*iChars)[pos];
 aName.Zero();
-if(TEmotionUtils::IsEmotionChar(aChar))
+if(Extension()->IsEmotionChar(aChar))
 {
-CSmileyIcon* icon = iExtension->EmotionIcon(aChar);
+aName.Append(Extension()->EmotionText(aChar));
-if ( icon )
-{
-aName.Append(icon->Name());
-}
 }
 else
 {
 aName.Append(aChar);
 }
 TChar sctChar;
 TBuf<10> sctName;
 GetFocusSctName(sctChar, sctName);
 if(Extension()->NeedEmotionSwitchIcon() &&
-(sctChar==TEmotionUtils::EmotionSwitchToSctChar() || sctChar==TEmotionUtils::EmotionSwitchToSmileyChar()))
+(sctChar==Extension()->SwitchToSctChar() || sctChar==Extension()->SwitchToEmotionChar()))
 {
 SwitchSctAndEmotionL();
 }
 else if(iFetcherCharsBuffer->Length() + sctName.Length() < iFetcherCharsBuffer->MaxLength())
 {
 TBool CAknCharMap::SwitchSctAndEmotionL()
 {
 if(Extension()->IsEmotionEnabled())
 {
-Extension()->iIsShowingEmotion = !Extension()->IsShowingEmotion();
+Extension()->SwitchEmotionVisibilityL();
+SetSmileyAnimationActivityInCurrentPageL(EFalse);
 SetCharacterCaseL(iSpecialCharCase);
+SetSmileyAnimationActivityInCurrentPageL(ETrue);
 CAknSctTableNavi* tableNavi = Extension()->iTableNavi;
 if(tableNavi)
 {
 tableNavi->UpdateNextTableButtonL();
 }

branch	RCL_3
changeset 5	aabf2c525e0f
parent 3	8ca85d2f0db7
child 6	9f56a4e1b8ab