FCL/sf/mw/classicui: comparison uifw/AvKon/src/AknSmileyModel.cpp

equal deleted inserted replaced

-:9f56a4e1b8ab
+:08e69e956a8c
 #include <smiley.rsg>
 #include <smiley.mbg>
 #include "AknSmileyModel.h"
 #include "AknSmileyImage.h"
+#include "akntrace.h"
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // TSmileyIconInfo
 ///////////////////////////////////////////////////////////////////////////////////////////////
 {
 delete iStillImage;
 delete iAnimationImage;
 iTextArray.Close();
+iCodeArray.Close();
 }
 const CFbsBitmap* CSmileyIcon::Image() const
 {
 if(AnimationImageIsReadyToDraw())
 TBool CSmileyIcon::AnimationImageIsReadyToDraw() const
 {
 return (iAnimationImage && iAnimationImage->ReadyToDraw());
 }
-void CSmileyIcon::AddText(const TDesC& aText) // for spliting strings = ":P :p :-P :-p";
+void CSmileyIcon::AddVariant(const TDesC& aText, TChar aBaseCode)
 {
 TPtrC ptr(aText);
+TUint16 baseCode = aBaseCode;
 while(ptr.Length())
 {
 TInt left = ptr.Find(_L(" "));
 TInt right = ptr.Length() - left - 1;
 right = 0;
 }
 iTextArray.Append(ptr.Left(left));
 ptr.Set(ptr.Right(right));
-}
+iCodeArray.Append(baseCode++);
 }
+}
-const TDesC& CSmileyIcon::Text(TInt aVariate) const
-{
+TInt CSmileyIcon::VariantCount() const
-if(aVariate>=0 && aVariate<TextVariate())
+{
-{
+return iTextArray.Count();
-return iTextArray[aVariate];
+}
+const TDesC& CSmileyIcon::Text(TInt aVariant) const
+{
+if(aVariant>=0 && aVariant<VariantCount())
+{
+return iTextArray[aVariant];
 }
 else
 {
 return KNullDesC;
 }
 }
-TInt CSmileyIcon::TextVariate() const
+TChar CSmileyIcon::Code(TInt aVariant) const
 {
-return iTextArray.Count();
+if(aVariant>=0 && aVariant<VariantCount())
-}
+{
+return iCodeArray[aVariant];
+}
+else
+{
+return 0;
+}
+}
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // CSmileyTnumbnailAsynLoader
 ///////////////////////////////////////////////////////////////////////////////////////////////
 public:
 CSmileyTextTreeNode(TChar aChar);
 ~CSmileyTextTreeNode();
 TChar Char() const;
-TChar LastChildChar() const;
-TChar FirstChildChar() const;
 CSmileyTextTreeNode* AddTreeL(const TDesC& aText, TChar aCode);
 TInt ChildCount() const;
 CSmileyTextTreeNode* Child(TInt aIndex) const;
 CSmileyTextTreeNode* Child(TChar aChar) const;
 private:
-CSmileyTextTreeNode* AddChildL(TChar aChar);
+CSmileyTextTreeNode* AddChildAscendingL(TChar aChar);
 private:
 TChar   iChar;
 typedef CArrayPtrFlat<CSmileyTextTreeNode> CSmileyTextTreeNodeArrayPtrFlat;
 TChar CSmileyTextTreeNode::Char() const
 {
 return iChar;
 }
-TChar CSmileyTextTreeNode::LastChildChar() const
-{
-if(iChildArray)
-{
-TInt index = iChildArray->Count() - 1;
-return iChildArray->At(index)->Char();
-}
-else
-{
-return 0;
-}
-}
-TChar CSmileyTextTreeNode::FirstChildChar() const
-{
-if(iChildArray)
-{
-return iChildArray->At(0)->Char();
-}
-else
-{
-return 0;
-}
-}
 CSmileyTextTreeNode* CSmileyTextTreeNode::AddTreeL(const TDesC& aText, TChar aCode)
 {
 TInt length = aText.Length();
 if(length > 0)
 {
-CSmileyTextTreeNode* node = AddChildL(aText[0]);
+CSmileyTextTreeNode* node = AddChildAscendingL(aText[0]);
 return node->AddTreeL(aText.Right(length-1), aCode);
 }
 else
 {
-return AddChildL(aCode);
+return AddChildAscendingL(aCode);
 }
 }
 TInt CSmileyTextTreeNode::ChildCount() const
 {
 CSmileyTextTreeNode* CSmileyTextTreeNode::Child(TChar aChar) const
 {
 if(iChildArray)
 {
-for(TInt i=iChildArray->Count()-1; i>=0; i--)
+const TInt KFirstPos = 0;
+const TInt KEndPos = iChildArray->Count() - 1;
+if(aChar<iChildArray->At(KFirstPos)->Char() || aChar>iChildArray->At(KEndPos)->Char())
+{
+return NULL;
+}
+for(TInt i=KEndPos; i>=KFirstPos; i--)
 {
 CSmileyTextTreeNode* node = iChildArray->At(i);
 if(node->Char() == aChar)
 {
 return node;
 }
 return NULL;
 }
-CSmileyTextTreeNode* CSmileyTextTreeNode::AddChildL(TChar aChar)
+CSmileyTextTreeNode* CSmileyTextTreeNode::AddChildAscendingL(TChar aChar)
 {
 // new
 if(!iChildArray)
 {
 iChildArray = new (ELeave) CSmileyTextTreeNodeArrayPtrFlat(1);
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // CSmileyModel
 ///////////////////////////////////////////////////////////////////////////////////////////////
-const TUint16 KBaseCodeOn = 0xf880;
+const TUint16 KBaseCode = 0xf880;
-const TUint16 KBaseCodeOff = 0x7FFF;
+//const TUint16 KBaseCodeOff = 0x7FFF;
 _LIT(KPlaceHolder, "\xf880i");
 CSmileyModel::CSmileyModel(MAknSmileyObserver* aObserver) : iSmileyIconObserver(aObserver)
 {
 }
 CSmileyModel::~CSmileyModel()
 {
 ReleaseResource();
 iSmileyIconArray.Close();
+iSmileyCodeIndexArray.Close();
 }
 void CSmileyModel::LoadResourceL()
 {
 if(Count() > 0) return;
 TFileName smileyRscName;
 SmileyUtils::GetCustomizableResPath(smileyRscName, KSmileyRsc);
 TInt offset = CCoeEnv::Static()->AddResourceFileL(smileyRscName);
 CCoeEnv::Static()->CreateResourceReaderLC(reader, R_SMILEY_ICONS_INFO);
-iBaseCode = KBaseCodeOn;
+TUint16 codeRef = KBaseCode;
 TInt index = 0;
 iTextSearchTree = new (ELeave) CSmileyTextTreeNode(0);
 TInt count(reader.ReadInt16());
 for(TInt i(0); i<count; i++)
 {
 TSmileyIconInfo info;
 TBool isAnimation = (reader.ReadInt16() == 1);
-TInt code = reader.ReadInt16();
+TInt16 code = reader.ReadInt16();
 TInt bmpId1 = reader.ReadInt32();
 TInt maskId1 = reader.ReadInt32();
 TInt bmpId2 = reader.ReadInt32();
 TInt maskId2 = reader.ReadInt32();
-if(iBaseCode > code) iBaseCode = code;
 info.iIndex = index++;
 if(bmpId2 > 0)
 {
 }
 TBuf<64> smileyName = reader.ReadTPtrC(); // strings
 CSmileyIcon* icon = CSmileyIcon::NewL(info, this);
-icon->AddText(smileyName);
+icon->AddVariant(smileyName, codeRef);
 iSmileyIconArray.Append(icon);
 // build text search tree
-for(TInt j=0; j<icon->TextVariate(); j++)
+for(TInt j=0; j<icon->VariantCount(); j++)
 {
-iTextSearchTree->AddTreeL(icon->Text(j), SmileyCode(i,j));
+iTextSearchTree->AddTreeL(icon->Text(j), codeRef++);
+iSmileyCodeIndexArray.Append(TSmileyCodeIndex(icon,j));
 }
 }
 CCoeEnv::Static()->DeleteResourceFile(offset);
 CleanupStack::PopAndDestroy(); // reader
 // sct & smiley switch icon
 TSmileyIconInfo info;
 info.iIndex = index++;
 info.iSkinItemID = KAknsIIDQgnIndiSwitchSmiley2;
 info.iDefaultStillImageID = EMbmSmileyQgn_indi_switch_smiley2;
-iSmileyIconArray.Append(CSmileyIcon::NewL(info,this));
+CSmileyIcon* switchSmileyIcon = CSmileyIcon::NewL(info, this);
+iSmileyIconArray.Append(switchSmileyIcon);
+iSmileyCodeIndexArray.Append(TSmileyCodeIndex(switchSmileyIcon));
 info.iIndex = index++;
 info.iSkinItemID = KAknsIIDQgnIndiSwitchSct2;
 info.iDefaultStillImageID = EMbmSmileyQgn_indi_switch_sct2;
-iSmileyIconArray.Append(CSmileyIcon::NewL(info,this));
+CSmileyIcon* switchSctIcon = CSmileyIcon::NewL(info,this);
+iSmileyIconArray.Append(switchSctIcon);
+iSmileyCodeIndexArray.Append(TSmileyCodeIndex(switchSctIcon));
 }
 void CSmileyModel::ReleaseResource()
 {
 delete iSmileyIconArray[i];
 iSmileyIconArray[i] = NULL;
 }
 iSmileyIconArray.Reset();
+iSmileyCodeIndexArray.Reset();
 // reset task loader
 iSmileyLoader.DiscardAll();
 delete iTextSearchTree;
 iTextSearchTree = NULL;
-iBaseCode = 0x7FFF; // max value
 }
 TInt CSmileyModel::ConvertCodesToTextL(TDes& aText)
 {
 TInt converted = 0;
 return converted;
 }
 TInt CSmileyModel::ConvertTextToCodesL(TDes& aText)
 {
+_AKNTRACE_FUNC_ENTER;
 TInt converted = 0;
 iConvertBuffer.Zero();
 CSmileyTextTreeNode* node = iTextSearchTree;
-TChar lastChar = node->LastChildChar();
-TChar firstChar = node->FirstChildChar();
 TInt matchedLength = 0;
 // deal all
 TInt pos = 0;
 while(pos < aText.Length())
 {
 TChar character = aText[pos++];
 iConvertBuffer.Append(character);
-if(!(character<firstChar || character>lastChar)) // is possible
-{
 CSmileyTextTreeNode* find = node->Child(character);
 if(find)
 {
 matchedLength++; // character is mathed
 CSmileyTextTreeNode* child = find->Child(0);
-if(child && child->ChildCount()==0) // whole combination is matched
+TBool notFinished = (child && child->ChildCount());
+if(notFinished) // not ended
 {
-converted++;
+node = find; // match next
+continue;
+}
+else if(child) // whole combination is matched and ended
+{
 TChar code = child->Char();
 // replace with code
 iConvertBuffer.SetLength(iConvertBuffer.Length() - matchedLength);
 iConvertBuffer.Append(code);
 iConvertBuffer.Append('i');
+converted++; // returned value added
 // load thumnail
 LoadStillImageL(code);
 // restart
 matchedLength = 0;
 node = iTextSearchTree;
+continue;
 }
-else
+else // in this case matchedLength already increased by 1
 {
-node = find;
+matchedLength--;
-}
-lastChar = node->LastChildChar();
-firstChar = node->FirstChildChar();
-continue;
 }
 }
-// character is not matched
+// matching failed
 if(matchedLength)
 {
+// back to the 2nd char
+TInt rollBack = matchedLength;
+iConvertBuffer.SetLength(iConvertBuffer.Length() - rollBack);
+pos -= rollBack;
+// reset matching context
 matchedLength = 0;
 node = iTextSearchTree;
-lastChar = node->LastChildChar();
-firstChar = node->FirstChildChar();
 }
 }
 // replace
 if(converted)
 {
 aText.Copy(iConvertBuffer);
 }
+_AKNTRACE_FUNC_EXIT;
 return converted;
 }
 TBool CSmileyModel::IsSmiley(TChar aCode) const
 {
-return (aCode >= iBaseCode);
+TInt smileyCodeIndex = (TUint16)aCode - KBaseCode;
+return (smileyCodeIndex>=0 && smileyCodeIndex<iSmileyCodeIndexArray.Count());
 }
 const TDesC& CSmileyModel::Text(TChar aCode) const
 {
-TInt index, variate;
+if(IsSmiley(aCode))
-if(DecodeSmileyCode(aCode, index, variate))
+{
-{
+TInt smileyCodeIndex = (TUint16)aCode - KBaseCode;
-return Text(index, variate);
+return iSmileyCodeIndexArray[smileyCodeIndex].Text();
 }
 else
 {
 return KNullDesC;
 }
 }
 }
 void CSmileyModel::DrawText(CWindowGc& aGc, const TDesC& aText, const TAknLayoutText& aLayout, TBool aUseLogicalToVisualConversion) const
 {
+_AKNTRACE_FUNC_ENTER;
 // adapter variables
 const CFont* font = aLayout.Font();
 TRect textRect = aLayout.TextRect();
 TInt offset = aLayout.BaselineOffset();
 CGraphicsContext::TTextAlign align = aLayout.Align();
 {
 *visualBuf = aText; // copy
 TPtr ptr = visualBuf->Des();
 TInt maxWidth = textRect.Size().iWidth;
 // Logical to visual conversion.
 AknBidiTextUtils::ConvertToVisualAndClip(
 aText,
 ptr,
 *font,
 maxWidth,
 maxWidth );
 // for smiley begin
 const TInt length = ptr.Length();
 if(length>1 && IsSmiley(ptr[length-2]))
 {
 if(ptr[length-1] != 'i')
 delete visualBuf;
 }
 //aGc.DiscardFont(); // Release the font cache
+_AKNTRACE_FUNC_EXIT;
 }
 void CSmileyModel::DrawText(CWindowGc& aGc, const TDesC& aText, const CFont* aFont, const TRect& aBox, TInt aBaselineOffset,
 CGraphicsContext::TTextAlign aAlignment, TInt aLeftMargin) const
 {
 TPtrC ptr = aText;
 TPoint offset = aOffset;
 aGc.UseFont(aFont);
-TInt fontH = aFont->HeightInPixels();
+TInt fontH = aFont->FontMaxHeight();
 TBool metSmileyNotReady = EFalse;
 while(ptr.Length())
 {
 {
 CAknSmileyIcon* icon = Smiley(ptr[i]);
 if(icon)
 {
 TSize size = icon->Size();
-TPoint tl = aBox.iTl + offset;
+TPoint tl = aBox.iTl;
-tl.iY = tl.iY - (size.iHeight + fontH) / 2;
+tl.iX += offset.iX;
+//tl.iY = tl.iY - size.iHeight/*(size.iHeight + fontH) / 2*/;
 TRect imgWindow(tl, size);
 imgWindow.Intersection(aBox);
 if(!imgWindow.IsEmpty())
 {
 TRect innerRect = TRect(imgWindow.iTl-tl,imgWindow.Size());
 {
 metSmileyNotReady = ETrue;
 }
 }
-offset += TPoint(aFont->TextWidthInPixels(ptr.Left(2)),0);
+//offset += TPoint(aFont->TextWidthInPixels(ptr.Left(2)),0);
+offset.iX += size.iWidth;
 }
 ptr.Set(ptr.Right(ptr.Length()-2));
 }
 }
 }
 CAknSmileyIcon* CSmileyModel::Smiley(TChar aCode) const
 {
-TInt index, variate;
+if(IsSmiley(aCode))
-if(DecodeSmileyCode(aCode, index, variate))
+{
-{
+TInt smileyCodeIndex = (TUint16)aCode - KBaseCode;
-return (*this)[index];
+return iSmileyCodeIndexArray[smileyCodeIndex].Smiley();
 }
 else
 {
 return NULL;
 }
 TChar CSmileyModel::SwitchToSctCode() const
 {
 return SmileyCode(Count()+1);
 }
-TChar CSmileyModel::SmileyCode(TInt aIndex, TInt aVariate) const
+TChar CSmileyModel::SmileyCode(TInt aIndex, TInt aVariant) const
 {
-return EncodeSmileyCode(aIndex, aVariate);
+const CAknSmileyIcon* iconWrapper = (*this)[aIndex];
-}
+const CSmileyIcon* icon = static_cast<const CSmileyIcon*>(iconWrapper);
+if(icon)
-TChar CSmileyModel::SmileyCode(CAknSmileyIcon* aSmileyIcon) const
+{
+return icon->Code(aVariant);
+}
+else
+{
+return 0;
+}
+}
+TChar CSmileyModel::SmileyCode(const CAknSmileyIcon* aSmileyIcon) const
 {
 if(aSmileyIcon)
 {
-CSmileyIcon* icon = static_cast<CSmileyIcon*>(aSmileyIcon);
+const CSmileyIcon* icon = static_cast<const CSmileyIcon*>(aSmileyIcon);
-return EncodeSmileyCode(icon->Index(), 0);
+return icon->Code();
 }
 else
 {
 return 0;
 }
 {
 CSmileyIcon* icon = static_cast<CSmileyIcon*>(Smiley(aChar));
 iSmileyLoader.AddTaskL(icon);
 }
-const TDesC& CSmileyModel::Text(TInt aIndex, TInt aVariate) const
+const TDesC& CSmileyModel::Text(TInt aIndex, TInt aVariant) const
 {
 CSmileyIcon* icon = static_cast<CSmileyIcon*>((*this)[aIndex]);
 if(icon)
 {
-return icon->Text(aVariate);
+return icon->Text(aVariant);
 }
 else
 {
 return KNullDesC;
 }
 }
 TInt CSmileyModel::ArrayCount() const
 {
 return iSmileyIconArray.Count();
-}
-TChar CSmileyModel::EncodeSmileyCode(TInt aIndex, TInt aVariate) const
-{
-if(aVariate)
-{
-return (iBaseCode + aIndex + (aVariate<<8));
-}
-else
-{
-return (iBaseCode + aIndex);
-}
-}
-#define KMaskL 0x00FF
-TBool CSmileyModel::DecodeSmileyCode(TChar aCode, TInt& aIndex, TInt& aVariate) const
-{
-if(aCode >= iBaseCode)
-{
-aIndex = (aCode&KMaskL) - (iBaseCode&KMaskL);
-aVariate = (aCode>>8) - (iBaseCode>>8);
-return ETrue;
-}
-else
-{
-return EFalse;
-}
 }
 void CSmileyModel::SmileyStillImageLoaded(CAknSmileyIcon* aSmileyIcon)
 {
 TRAP_IGNORE(iSmileyLoader.DoNextTaskL());

branch	RCL_3
changeset 15	08e69e956a8c
parent 10	9f56a4e1b8ab
child 18	0aa5fbdfbc30