1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:           

    15  *      Provides the CAknFepUICtrlPinyinEEP definition 

    16  *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 

    30 #include <eikenv.h>

    31 #include <eikappui.h>

    32 #include <AknsSkinInstance.h> 

    33 #include <AknsUtils.h> 

    34 #include <AknsDrawUtils.h> 

    35 #include <skinlayout.cdl.h>

    36 

    37 #include "aknlayoutscalable_avkon.cdl.h"

    38 #include "aknfepuictrlpinyineep.h"

    39 #include "aknfepuilayoutdatamgr.h"

    40 #include "aknfepchineseuidataconv.h"

    41 

    42 _LIT(KFullStop, "\x002E");

    43 

    44 _LIT( KToneMark1, "\x0020");

    45 _LIT( KToneMark2, "\x02CA");

    46 _LIT( KToneMark3, "\x02C7");

    47 _LIT( KToneMark4, "\x02CB");

    48 _LIT( KToneMark5, "\x02D9");

    49 _LIT( KLeftBracket, "\x0028");

    50 const TInt KControlNum = 1;

    51 const TInt KMaxCharNum = 200;

    52 const TInt KMaxDispNum = 200;

    53 

    54 // ---------------------------------------------------------

    55 // NewL function.

    56 // ---------------------------------------------------------

    57 //

    58 CAknFepUICtrlPinyinEEP* CAknFepUICtrlPinyinEEP::NewL( RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr )

    59     {

    60     CAknFepUICtrlPinyinEEP* self=CAknFepUICtrlPinyinEEP::NewLC( aParent, aLafDataMgr );

    61     CleanupStack::Pop(self); // self;

    62     return self;

    63     }

    64 

    65 // ---------------------------------------------------------

    66 // NewLC function.

    67 // ---------------------------------------------------------

    68 //

    69 CAknFepUICtrlPinyinEEP* CAknFepUICtrlPinyinEEP::NewLC( RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr )

    70     {

    71     CAknFepUICtrlPinyinEEP* self = new(ELeave)CAknFepUICtrlPinyinEEP( aLafDataMgr );

    72     CleanupStack::PushL( self );

    73     self->ConstructL( aParent, aLafDataMgr);

    74     return self;

    75     }

    76 

    77 // ---------------------------------------------------------

    78 // Destructor.

    79 // ---------------------------------------------------------

    80 //

    81 CAknFepUICtrlPinyinEEP::~CAknFepUICtrlPinyinEEP()

    82     {

    83     if ( iEditableEntryPane )

    84         {

    85         delete iEditableEntryPane;

    86         iEditableEntryPane = NULL;

    87         }

    88 //    if ( iBgContext )

    89 //        {

    90 //        delete iBgContext;

    91 //        iBgContext = NULL;

    92 //        }

    93     if ( iAbsoluteBuffer )

    94         {

    95         delete iAbsoluteBuffer;

    96         iAbsoluteBuffer = NULL;

    97         }

    98     if ( iVisualBuffer )

    99         {

   100         delete iVisualBuffer;

   101         iVisualBuffer = NULL;

   102         }

   103     iArray.ResetAndDestroy();

   104     delete iKeystrokeArray;

   105     delete iShowKeystrokeArray;

   106     delete iPhraseArray;

   107     delete iPhraseShowKeyStrokeArray;

   108     delete iTempArray;

   109     }

   110 

   111 // ---------------------------------------------------------

   112 // From CCoeControl.

   113 // ---------------------------------------------------------

   114 //

   115 TInt CAknFepUICtrlPinyinEEP::CountComponentControls() const

   116     {

   117     return KControlNum;

   118     }

   119 

   120 // ---------------------------------------------------------

   121 // From CCoeControl.

   122 // ---------------------------------------------------------

   123 //

   124 CCoeControl* CAknFepUICtrlPinyinEEP::ComponentControl( TInt aIndex ) const

   125     {

   126     switch ( aIndex )

   127         {

   128         case EEditableEntryPane:

   129             return iEditableEntryPane;

   130         default:

   131             return NULL;

   132         }

   133     }

   134 

   135 // ---------------------------------------------------------

   136 // From CCoeControl.

   137 // ---------------------------------------------------------

   138 //

   139 void CAknFepUICtrlPinyinEEP::Draw( const TRect& /*aRect*/) const

   140     {

   141     }

   142 

   143 // ---------------------------------------------------------

   144 // From CCoeControl.

   145 // ---------------------------------------------------------

   146 //

   147 void CAknFepUICtrlPinyinEEP::SizeChanged()

   148     {

   149     LayoutContainedControls();

   150     }

   151 

   152 // ---------------------------------------------------------

   153 // Set the text buffer and posit the cursor index.

   154 // ---------------------------------------------------------

   155 //

   156 void CAknFepUICtrlPinyinEEP::SetText( const TDesC& aDes, TInt aCursorIndex, TBool aMiniQwertyZhuyin )

   157     {

   158     iMiniQwertyZhuyin = aMiniQwertyZhuyin;

   159     iAbsoluteUnderlineBeg = -1;

   160     iAbsoluteUnderlineEnd = -1;

   161     iAbsoluteHighlightBeg = -1;

   162     iAbsoluteHighlightEnd = -1;

   163     iArray.ResetAndDestroy();

   164     TInt absoluteBufferLen = iAbsoluteBuffer->Length();

   165     TInt desLen = aDes.Length();

   166 

   167     if ( aCursorIndex > aDes.Length() )

   168         {

   169         aCursorIndex = aDes.Length();

   170         }

   171     else if ( aCursorIndex < 0 )

   172         {

   173         aCursorIndex = 0;

   174         }

   175 

   176     // cursor is at the end of buffer and add a character 

   177     if ( aDes.Left( iAbsoluteBuffer->Length() ) == *iAbsoluteBuffer

   178         && iAbsoluteCursorPos == iAbsoluteBuffer->Length() && aCursorIndex

   179         == aDes.Length() )

   180         {

   181         Append( aDes.Right( aDes.Length() - iAbsoluteBuffer->Length() ) );

   182         }

   183     //    delete one character

   184     else if ( iAbsoluteBuffer->Left( aCursorIndex ).Compare(aDes.Left(aCursorIndex)) == 0

   185         && aCursorIndex < iAbsoluteCursorPos

   186         && iAbsoluteBuffer->Compare( aDes ) != 0

   187         && 0 == iAbsoluteBuffer->Right( absoluteBufferLen - iAbsoluteCursorPos ).Compare( 

   188             aDes.Right( desLen - aCursorIndex)) )

   189         {

   190         Delete( iAbsoluteCursorPos - (iAbsoluteBuffer->Length()

   191             - aDes.Length()), iAbsoluteBuffer->Length() - aDes.Length() );

   192         }

   193     else if ( iAbsoluteBuffer->Length() < aDes.Length()

   194         && iAbsoluteBuffer->Left( iAbsoluteCursorPos )

   195             == aDes.Left( iAbsoluteCursorPos )

   196         && iAbsoluteBuffer->Right( iAbsoluteBuffer->Length()

   197             - iAbsoluteCursorPos ) == aDes.Right( iAbsoluteBuffer->Length()

   198             - iAbsoluteCursorPos ) && aCursorIndex - iAbsoluteCursorPos

   199         == aDes.Length() - iAbsoluteBuffer->Length() )

   200         {

   201         TPtrC tmp = aDes.Mid( iAbsoluteCursorPos, aDes.Length()

   202             - iAbsoluteBuffer->Length() );

   203         Insert( iAbsoluteCursorPos, tmp );

   204         }

   205     else

   206         {

   207         SetText( aDes );

   208         SetCursor( aCursorIndex );

   209         }

   210     }

   211 

   212 // ---------------------------------------------------------

   213 // Set the text buffer and posit the cursor index for zhuyin.

   214 // ---------------------------------------------------------

   215 //

   216 void CAknFepUICtrlPinyinEEP::SetTextForZhuyin( 

   217     const TDesC& aDes, 

   218     TInt aCursor, 

   219     TInt aChineseCount, 

   220     const TDesC& aJudgeSeed, 

   221     TInt aKeystroke, 

   222     TBool aInvalid,

   223     TBool aMiniQwertyZhuyin)

   224     {

   225     iMiniQwertyZhuyin = aMiniQwertyZhuyin;

   226     TInt actionType = EZhuyinNULL;

   227     if ( aKeystroke == 0 && aJudgeSeed.Compare(iJudgeSeed) == 0)

   228         {

   229         actionType = EZhuyinMoveCursor;

   230         }

   231     else if ( aChineseCount == iChineseCount + 1 )

   232         {

   233         actionType = EZhuyinNULL;

   234         }

   235     else if ( aKeystroke == 0 && aJudgeSeed.Length() <= iJudgeSeed.Length() - 1)

   236         {

   237         actionType = EZhuyinDelete;

   238         }

   239     else

   240         {

   241         if ( aJudgeSeed.Length() == iJudgeSeed.Length())

   242             {

   243             if ( aJudgeSeed.Left(aKeystroke - 1).Compare(iJudgeSeed.Left(aKeystroke - 1)) == 0 

   244                 && aJudgeSeed.Mid(aKeystroke - 1,1).Compare(iJudgeSeed.Mid(aKeystroke - 1,1)) != 0 ) 

   245                 {

   246                 actionType = EZhuyinReplace;

   247                 }

   248             else if ( aCursor == GetCursor() )

   249                 {

   250                 actionType = EZhuyinReplace;

   251                 }

   252             else

   253                 {

   254                 actionType = EZhuyinMoveCursor;

   255                 }

   256             }

   257         else if ( aJudgeSeed.Length() == iJudgeSeed.Length() + 1)

   258             {

   259             actionType = EZhuyinInsert;

   260             }

   261         else if ( aJudgeSeed.Length() == iJudgeSeed.Length() - 1)

   262             {

   263             actionType = EZhuyinDelete;

   264             }

   265         else if ( KErrNotFound != iJudgeSeed.Find( aJudgeSeed ) )

   266             {

   267             actionType = EZhuyinDelete;

   268             }

   269         else

   270             {

   271             actionType = EZhuyinNULL;

   272             }

   273         }

   274     iArray.ResetAndDestroy();

   275     iJudgeSeed = aJudgeSeed;

   276     iChineseCount = aChineseCount;

   277     if ( iLastValid && aInvalid )

   278         {

   279         TInt newOffset = 0;

   280         TPtrC ptr = iAbsoluteBuffer->Des();

   281         for ( TInt i = 0; i < iOffset; i++ )

   282             {

   283             if ( ptr.Mid(i,1).Compare(KFullStop) == 0 )

   284                 {

   285                 continue;

   286                 }

   287             newOffset++;

   288             }

   289         iOffset = newOffset;

   290         }

   291     else if ( !iLastValid && !aInvalid )

   292         {

   293         TInt newOffset = 0;

   294         TInt i = 0;

   295         TPtrC ptr = aDes;

   296         for ( i = 0; i < iOffset && newOffset < ptr.Length(); )

   297             {

   298             if ( ptr.Mid(newOffset,1).Compare(KFullStop) != 0 )

   299                 {

   300                 i++;

   301                 }

   302             newOffset++;

   303             }

   304         iOffset = newOffset;

   305         }

   306     iLastValid = !aInvalid;

   307     switch ( actionType )

   308         {

   309         case EZhuyinInsert:

   310             {

   311             *iAbsoluteBuffer = aDes;

   312             iAbsoluteCursorPos = aCursor;

   313             this->CalculateVisualTextForInsert( 0, aDes );

   314             this->iEditableEntryPane->SetText( *iVisualBuffer );

   315             this->CalculateVisualIndex();

   316             iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos

   317                 - iOffset );

   318             }

   319             break;

   320         case EZhuyinReplace:

   321             {

   322             TRect panerect = iEditableEntryPane->Rect();

   323             TAknTextLineLayout textPaneTextLayout = 

   324                     CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

   325             const CFont* font = AknLayoutUtils::FontFromId(

   326                 textPaneTextLayout.iFont, 

   327                 NULL );

   328             TInt lenToCursor = font->TextWidthInPixels( aDes.Mid( iOffset,

   329                 aCursor - iOffset ) );

   330             if ( lenToCursor < panerect.Width() - panerect.Width()

   331                 *KLROffset/KDenominator * 2 )

   332                 {

   333                 *iAbsoluteBuffer = aDes;

   334                 iAbsoluteCursorPos = aCursor;

   335                 TInt stride = 0;

   336                 for (stride = 1;; stride ++ )

   337                     {

   338                     if ( iOffset + stride > aDes.Length() )

   339                         {

   340                         break;

   341                         }

   342                     TInt tmpFontLen = font->TextWidthInPixels( aDes.Mid(

   343                         iOffset, stride ) );

   344                     if ( tmpFontLen > panerect.Width() - panerect.Width()

   345                         *KLROffset/KDenominator * 2 )

   346                         {

   347                         break;

   348                         }

   349                     }

   350                 *iVisualBuffer = aDes.Mid( iOffset, stride - 1 );

   351                 iEditableEntryPane->SetText( *iVisualBuffer );

   352                 iEditableEntryPane->SetCursorPosition( aCursor-iOffset );

   353                 }

   354             else

   355                 {

   356                 SetText( aDes, aCursor );

   357                 }

   358             CalculateVisualIndex();

   359             break;

   360             }

   361         case EZhuyinDelete:

   362             {

   363             *iAbsoluteBuffer = aDes;

   364             iAbsoluteCursorPos = aCursor;

   365             this->CalculateVisualTextForDelete( 0, 0 );

   366             this->iEditableEntryPane->SetText( *iVisualBuffer );

   367             this->CalculateVisualIndex();

   368             iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos

   369                 - iOffset );

   370             }

   371             break;

   372         default:

   373             SetText( aDes, aCursor );

   374         }

   375     }

   376 

   377 // ---------------------------------------------------------

   378 // Set the text buffer and maintain the current cursor position.

   379 // ---------------------------------------------------------

   380 //

   381 void CAknFepUICtrlPinyinEEP::SetText( const TDesC& aDes )

   382     {

   383     iAbsoluteCursorPos = 0;

   384     iOffset = 0;

   385     iAbsoluteBuffer->Des().Zero();

   386     iVisualBuffer->Des().Zero();

   387     *iAbsoluteBuffer = aDes;

   388     CalculateVisualTextForMoveRight();

   389     iEditableEntryPane->SetText( *iVisualBuffer );

   390     CalculateVisualIndex();

   391     }

   392 

   393 // ---------------------------------------------------------

   394 // Set the cursor position.

   395 // ---------------------------------------------------------

   396 //

   397 void CAknFepUICtrlPinyinEEP::SetCursor( const TInt aIndex )

   398     {

   399     SetCursorForMoveRight( aIndex );

   400     }

   401 

   402 // ---------------------------------------------------------

   403 // get the position index of cursor.The max cursor index must 

   404 // be larger than the length of text buffer by 1.

   405 // ---------------------------------------------------------

   406 //

   407 TInt CAknFepUICtrlPinyinEEP::GetCursor()

   408     {

   409     return iAbsoluteCursorPos;

   410     }

   411 

   412 // ---------------------------------------------------------

   413 // move cursor to the left by a 1 stride.

   414 // ---------------------------------------------------------

   415 //

   416 TBool CAknFepUICtrlPinyinEEP::MoveCursorLeft( TInt aStride  )

   417     {

   418     if ( iAbsoluteCursorPos - aStride < 0 )

   419         {

   420         return EFalse;

   421         }

   422     if ( iEditableEntryPane->MoveCursorLeft( aStride ) == 0 )

   423         {

   424         iAbsoluteCursorPos = iAbsoluteCursorPos - aStride;

   425         }

   426     else

   427         {

   428         iAbsoluteCursorPos = iAbsoluteCursorPos - aStride;

   429         SetCursorForMoveLeft( iAbsoluteCursorPos );

   430         }

   431     return ETrue;

   432     }

   433 

   434 // ---------------------------------------------------------

   435 // move cursor to the right by a 1 stride.

   436 // ---------------------------------------------------------

   437 //

   438 TBool CAknFepUICtrlPinyinEEP::MoveCursorRight( TInt aStride )

   439     {

   440     if ( iAbsoluteCursorPos + aStride > iAbsoluteBuffer->Length() )

   441         {

   442         return EFalse;

   443         }

   444     if ( iEditableEntryPane->MoveCursorRight( aStride ) == 0 )

   445         {

   446         iAbsoluteCursorPos = iAbsoluteCursorPos + aStride;

   447         }

   448     else

   449         {

   450         iAbsoluteCursorPos = iAbsoluteCursorPos + aStride;

   451         SetCursorForMoveRight( iAbsoluteCursorPos );

   452         }

   453     return ETrue;

   454     }

   455 

   456 // ---------------------------------------------------------

   457 // active the cursor,the cursor will be black and with a wink

   458 // this cursor state represent this control is focused.

   459 // ---------------------------------------------------------

   460 //

   461 void CAknFepUICtrlPinyinEEP::ActiveCursor()

   462     {

   463     iEditableEntryPane->ActiveCursor();

   464     }

   465 

   466 // ---------------------------------------------------------

   467 // deactive the cursor, the cursor will be gray and no wink this cursor

   468 // state represent this control with no focus.

   469 // ---------------------------------------------------------

   470 //

   471 void CAknFepUICtrlPinyinEEP::DeactiveCursor()

   472     {

   473     iEditableEntryPane->DeactiveCursor();

   474     }

   475 

   476 // ---------------------------------------------------------

   477 // enable the cursor,the cursor will be drawn.

   478 // ---------------------------------------------------------

   479 //

   480 void CAknFepUICtrlPinyinEEP::EnableCursor()

   481     {

   482     iEditableEntryPane->EnableCursor();

   483     }

   484 

   485 // ---------------------------------------------------------

   486 // deactive the cursor, the cursor will not be drawn.

   487 // ---------------------------------------------------------

   488 //

   489 void CAknFepUICtrlPinyinEEP::DisableCursor()

   490     {

   491     iEditableEntryPane->DisableCursor();

   492     }

   493 

   494 // ---------------------------------------------------------

   495 // set the beginning and ending index for the underline text.

   496 // ---------------------------------------------------------

   497 //

   498 void CAknFepUICtrlPinyinEEP::SetUnderline( TInt aBeg, TInt aEnd )

   499     {

   500     CAknFepUICtrlEEPControl::TSegment* tmp =

   501         new CAknFepUICtrlEEPControl::TSegment ( aBeg, aEnd, CAknFepUICtrlEEPControl::EUnderline );

   502     iArray.Append( tmp );

   503 

   504     TInt visualUnderlineBeg = aBeg - iOffset;

   505     TInt visualUnderlineEnd = aEnd - iOffset;

   506 

   507     if (

   508         visualUnderlineBeg < 0 &&

   509         visualUnderlineEnd < 0

   510         ||

   511         visualUnderlineBeg> iVisualBuffer->Length() - 1 &&

   512         visualUnderlineEnd> iVisualBuffer->Length() - 1

   513     )

   514         {

   515         visualUnderlineBeg = -1;

   516         visualUnderlineEnd = -1;

   517         }

   518     else

   519         {

   520         if ( visualUnderlineBeg < 0 )

   521             {

   522             visualUnderlineBeg = 0;

   523             }

   524         if ( visualUnderlineEnd> iVisualBuffer->Length() - 1 )

   525             {

   526             visualUnderlineEnd = iVisualBuffer->Length() - 1;

   527             }

   528         }

   529     iEditableEntryPane->SetUnderline( visualUnderlineBeg, visualUnderlineEnd );

   530 

   531     iAbsoluteUnderlineBeg = aBeg;

   532     iAbsoluteUnderlineEnd = aEnd;

   533     }

   534 

   535 // ---------------------------------------------------------

   536 // get the indexes for text with underline.

   537 // ---------------------------------------------------------

   538 //

   539 void CAknFepUICtrlPinyinEEP::GetUnderlineIndex( TInt& aBeg, TInt& aEnd )

   540     {

   541     aBeg = iAbsoluteUnderlineBeg;

   542     aEnd = iAbsoluteUnderlineEnd;

   543     }

   544 

   545 // ---------------------------------------------------------

   546 // set the indexes for the text with highlight

   547 // ---------------------------------------------------------

   548 //

   549 void CAknFepUICtrlPinyinEEP::SetHighlight( TInt aBeg, TInt aEnd )

   550     {

   551     CAknFepUICtrlEEPControl::TSegment* tmp =

   552         new CAknFepUICtrlEEPControl::TSegment ( aBeg, aEnd, CAknFepUICtrlEEPControl::EHighlight );

   553     iArray.Append( tmp );

   554 

   555     TInt visualHighlightBeg = aBeg - iOffset;

   556     TInt visualHighlightEnd = aEnd - iOffset;

   557 

   558     if (

   559         visualHighlightBeg < 0 &&

   560         visualHighlightEnd < 0

   561         ||

   562         visualHighlightBeg> iVisualBuffer->Length() - 1 &&

   563         visualHighlightEnd> iVisualBuffer->Length() - 1

   564     )

   565         {

   566         visualHighlightBeg = -1;

   567         visualHighlightEnd = -1;

   568         }

   569     else

   570         {

   571         if ( visualHighlightBeg < 0 )

   572             {

   573             visualHighlightBeg = 0;

   574             }

   575         if ( visualHighlightEnd> iVisualBuffer->Length() - 1 )

   576             {

   577             visualHighlightEnd = iVisualBuffer->Length() - 1;

   578             }

   579         }

   580     iEditableEntryPane->SetHighlight( visualHighlightBeg, visualHighlightEnd );

   581 

   582     iAbsoluteHighlightBeg = aBeg;

   583     iAbsoluteHighlightEnd = aEnd;

   584     }

   585 

   586 // ---------------------------------------------------------

   587 // get the indexes for the text with highlight

   588 // ---------------------------------------------------------

   589 //

   590 void CAknFepUICtrlPinyinEEP::GetHighlightIndex( TInt& aBeg, TInt& aEnd )

   591     {

   592     aBeg = iAbsoluteHighlightBeg;

   593     aEnd = iAbsoluteHighlightEnd;

   594     }

   595 

   596 // ---------------------------------------------------------

   597 // set keystroke index. 

   598 // ---------------------------------------------------------

   599 //

   600 void CAknFepUICtrlPinyinEEP::SetCursorIndexOfKeystroke( const TInt aStartIndex )

   601     {

   602     iIndex = aStartIndex;

   603     }

   604 

   605 // ---------------------------------------------------------

   606 // get the keystroke index

   607 // ---------------------------------------------------------

   608 //

   609 TInt CAknFepUICtrlPinyinEEP::GetCursorIndexOfKeystroke()

   610     {

   611     return iIndex;

   612     }

   613 

   614 // ---------------------------------------------------------

   615 // whether this control will be actived.ETrue represent enable 

   616 // otherwise disable.

   617 // ---------------------------------------------------------

   618 //

   619 void CAknFepUICtrlPinyinEEP::Enable( TBool aEnable )

   620     {

   621     iEnabled = aEnable;

   622     if ( aEnable == EFalse )

   623         {

   624         Reset();

   625         DrawNow();

   626         }

   627     iEditableEntryPane->MakeVisible( aEnable );

   628     MakeVisible( aEnable );

   629     }

   630 	

   631 // ---------------------------------------------------------

   632 // return whether this control is enabled.

   633 // ---------------------------------------------------------

   634 //

   635 TBool CAknFepUICtrlPinyinEEP::IsEnabled() const

   636     {

   637     return iEnabled;

   638     }

   639 

   640 // ---------------------------------------------------------

   641 // Get the info before cursor.

   642 // ---------------------------------------------------------

   643 //

   644 void CAknFepUICtrlPinyinEEP::GetText( TDes& aText )

   645     {

   646     aText = *iAbsoluteBuffer;

   647     }

   648 

   649 // ---------------------------------------------------------

   650 // Get the info before cursor.

   651 // ---------------------------------------------------------

   652 //

   653 TBool CAknFepUICtrlPinyinEEP::GetDesBeforeCursor( TDes& aOut )

   654     {

   655     if ( iAbsoluteCursorPos == 0 )

   656         {

   657         return EFalse;

   658         }

   659     else

   660         {

   661         aOut = iAbsoluteBuffer->Mid( (iAbsoluteCursorPos - 1 ), 1 );

   662         return ETrue;

   663         }

   664     }

   665 

   666 // ---------------------------------------------------------

   667 // From MAknFepUICtrlEditPane.

   668 // ---------------------------------------------------------

   669 //

   670 void CAknFepUICtrlPinyinEEP::SetToneMark( const TDesC& /*aToneMark*/)

   671     {

   672     }

   673 

   674 // ---------------------------------------------------------

   675 // From MAknFepUICtrlEditPane.

   676 // ---------------------------------------------------------

   677 //

   678 void CAknFepUICtrlPinyinEEP::SetToneMarkValidity( TBool /*aValid*/)

   679     {

   680     }

   681 

   682 // ---------------------------------------------------------

   683 // From MAknFepUICtrlEditPane.

   684 // ---------------------------------------------------------

   685 //

   686 void CAknFepUICtrlPinyinEEP::SetOverrideFontId( TInt /*aFontId*/)

   687     {

   688     }

   689 

   690 // ---------------------------------------------------------

   691 // From MAknFepUICtrlEditPane.

   692 // ---------------------------------------------------------

   693 //

   694 void CAknFepUICtrlPinyinEEP::SetFlag( TInt /*aFlag*/)

   695     {

   696     }

   697 

   698 // ---------------------------------------------------------

   699 // From MAknFepUICtrlEditPane.

   700 // ---------------------------------------------------------

   701 //

   702 void CAknFepUICtrlPinyinEEP::ClearFlag( TInt /*aFlag*/)

   703     {

   704     }

   705 

   706 // ---------------------------------------------------------

   707 // From MAknFepUICtrlEditPane.

   708 // ---------------------------------------------------------

   709 //

   710 TBool CAknFepUICtrlPinyinEEP::IsFlagSet( TInt /*aFlag*/) const

   711     {

   712     return EFalse;

   713     }

   714 

   715 // ---------------------------------------------------------

   716 // Set the cursor index for moving to the left.

   717 // ---------------------------------------------------------

   718 //

   719 void CAknFepUICtrlPinyinEEP::SetCursorForMoveLeft( const TInt aIndex )

   720     {

   721     iAbsoluteCursorPos = aIndex;

   722     CalculateVisualTextForMoveLeft();

   723     iEditableEntryPane->SetText( *iVisualBuffer );

   724     iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos - iOffset );

   725     CalculateVisualIndex();

   726     }

   727 

   728 // ---------------------------------------------------------

   729 // Set the cursor index for moving to the right.

   730 // ---------------------------------------------------------

   731 //

   732 void CAknFepUICtrlPinyinEEP::SetCursorForMoveRight( const TInt aIndex )

   733     {

   734     iAbsoluteCursorPos = aIndex;

   735     CalculateVisualTextForMoveRight();

   736     iEditableEntryPane->SetText( *iVisualBuffer );

   737     iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos - iOffset );

   738     CalculateVisualIndex();

   739     }

   740 

   741 // ---------------------------------------------------------

   742 // Add some text at the end of buffer.

   743 // ---------------------------------------------------------

   744 //

   745 TBool CAknFepUICtrlPinyinEEP::Append( const TDesC& aDes )

   746     {

   747     if ( this->iAbsoluteCursorPos != this->iAbsoluteBuffer->Length() )

   748         {

   749         return EFalse;

   750         }

   751     else

   752         {

   753         if ( iAbsoluteBuffer->Length() + aDes.Length()

   754             > iAbsoluteBuffer->Des().MaxLength() )

   755             {

   756             return EFalse;

   757             }

   758         iAbsoluteBuffer->Des().Append( aDes );

   759         iAbsoluteCursorPos = iAbsoluteCursorPos + aDes.Length();

   760         this->CalculateVisualTextForAppend( aDes );

   761         this->iEditableEntryPane->SetText( *iVisualBuffer );

   762         this->CalculateVisualIndex();

   763         iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos - iOffset );

   764         return ETrue;

   765         }

   766     }

   767 

   768 // ---------------------------------------------------------

   769 // delete the content begin with aBeg index, and with an aLen length.

   770 // ---------------------------------------------------------

   771 //

   772 TBool CAknFepUICtrlPinyinEEP::Delete( TInt aBeg, TInt aLen )

   773     {

   774     if ( aBeg < 0 || aLen < 0 || aBeg + aLen> iAbsoluteBuffer->Length() )

   775         {

   776         return EFalse;

   777         }

   778     else

   779         {

   780         iAbsoluteBuffer->Des().Delete( aBeg, aLen );

   781         iAbsoluteCursorPos = aBeg;

   782         this->CalculateVisualTextForDelete( aBeg, aLen );

   783         this->iEditableEntryPane->SetText( *iVisualBuffer );

   784         this->CalculateVisualIndex();

   785         iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos - iOffset );

   786         return ETrue;

   787         }

   788     }

   789 

   790 // ---------------------------------------------------------

   791 // Insert some text after aIndex character.

   792 // ---------------------------------------------------------

   793 //

   794 TBool CAknFepUICtrlPinyinEEP::Insert( TInt aIndex, const TDesC& aDes )

   795     {

   796     if ( iAbsoluteBuffer->Length() + aDes.Length() > iAbsoluteBuffer->Des().MaxLength() )

   797         {

   798         return EFalse;

   799         }

   800     iAbsoluteBuffer->Des().Insert( aIndex, aDes );

   801     iAbsoluteCursorPos = iAbsoluteCursorPos + aDes.Length();

   802     this->CalculateVisualTextForInsert( aIndex, aDes );

   803     this->iEditableEntryPane->SetText( *iVisualBuffer );

   804     this->CalculateVisualIndex();

   805     iEditableEntryPane->SetCursorPosition( iAbsoluteCursorPos - iOffset );

   806     return ETrue;

   807     }

   808 

   809 // ---------------------------------------------------------

   810 // Replace text from aBeg index to aBeg + aLen with aDes.

   811 // ---------------------------------------------------------

   812 //

   813 TBool CAknFepUICtrlPinyinEEP::Replace( TInt /*aBeg*/, TInt /*aLen*/,

   814     const TDesC& /*aDes*/)

   815     {

   816     return EFalse;

   817     }

   818 

   819 // ---------------------------------------------------------

   820 // Reset private member viariable.

   821 // ---------------------------------------------------------

   822 //

   823 void CAknFepUICtrlPinyinEEP::Reset()

   824     {

   825     iIndex = 0;

   826     iEnabled = EFalse;

   827     iAbsoluteCursorPos = 0;

   828     iOffset = 0;

   829     iAbsoluteUnderlineBeg = -1;

   830     iAbsoluteUnderlineEnd = -1;

   831     iAbsoluteHighlightBeg = -1;

   832     iAbsoluteHighlightEnd = -1;

   833     iAbsoluteBuffer->Des().Zero();

   834     iVisualBuffer->Des().Zero();

   835     iEditableEntryPane->ResetAll();

   836     iArray.ResetAndDestroy();

   837     iJudgeSeed.Zero();

   838     iLastValid = ETrue;

   839     iChineseCount = 0;

   840     }

   841 

   842 // ---------------------------------------------------------

   843 // Layout contained controls.

   844 // ---------------------------------------------------------

   845 //

   846 void CAknFepUICtrlPinyinEEP::LayoutContainedControls()

   847     {

   848     TRect outerRect;

   849     TRect innerRect;

   850     CalculateFrameRects( outerRect, innerRect );

   851     TRect rect = Rect();

   852     iEditableEntryPane->SetRect( rect );

   853     }

   854 

   855 // ---------------------------------------------------------

   856 // layout the background frames.

   857 // ---------------------------------------------------------

   858 //

   859 void CAknFepUICtrlPinyinEEP::LayoutFrames()

   860     {

   861     TRect outerRect;

   862     TRect innerRect;

   863 //    CalculateFrameRects( outerRect, innerRect );

   864 //    iBgContext->SetFrameRects( outerRect, innerRect );

   865 //    iBgContext->SetParentPos( PositionRelativeToScreen() );

   866     }

   867 

   868 // ---------------------------------------------------------

   869 // layout its rectangles

   870 // ---------------------------------------------------------

   871 //

   872 void CAknFepUICtrlPinyinEEP::LayoutRects()

   873     {

   874     TRect windowRect = 

   875         CAknFepChineseUIDataConv::AnyToRect( iLafDataMgr->RequestData( EEEPWindowRect ));

   876     TInt height = windowRect.Height();

   877     TInt width = windowRect.Width();

   878     windowRect.iTl.iY = 0;

   879     windowRect.iTl.iX = 0;

   880     windowRect.SetHeight( height );

   881     windowRect.SetWidth( width );

   882     iSize.SetSize( width, Rect().Height() );

   883     }

   884 

   885 // ---------------------------------------------------------

   886 // C++ constructor

   887 // ---------------------------------------------------------

   888 //

   889 CAknFepUICtrlPinyinEEP::CAknFepUICtrlPinyinEEP( CAknFepUiLayoutDataMgr* aLafDataMgr )

   890     {

   891     iIndex = 0;

   892     iEnabled = EFalse;

   893     iAbsoluteCursorPos = 0;

   894     iAbsoluteUnderlineBeg = -1;

   895     iAbsoluteUnderlineEnd = -1;

   896     iAbsoluteHighlightBeg = -1;

   897     iAbsoluteHighlightEnd = -1;

   898     iOffset = 0;

   899     iJudgeSeed.Zero();

   900     iLastValid = ETrue;

   901     iChineseCount = 0;

   902     iChangeFlag = 0;

   903     iAutoChangeFlag = 1;

   904     iAllValidFlag = 1;

   905     iInvalidKeystrokeIndex = 0;

   906     iCandidateRefreshFlag = 0;

   907     iDelimiterCount = 0;

   908     iLafDataMgr = aLafDataMgr;

   909     }

   910 

   911 // ---------------------------------------------------------

   912 // Two-phrase constructor.

   913 // ---------------------------------------------------------

   914 //

   915 void CAknFepUICtrlPinyinEEP::ConstructL( RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr )

   916     {

   917     SetContainerWindowL( aParent );

   918     iEditableEntryPane = CAknFepUICtrlEEPControl::NewL( Window(), aLafDataMgr );

   919     iAbsoluteBuffer = HBufC::New( KMaxCharNum );

   920     iVisualBuffer = HBufC::New( KMaxDispNum );

   921     TRect outerRect = TRect();

   922     TRect innerRect = TRect();

   923     CalculateFrameRects( outerRect, innerRect );

   924 //    iBgContext = CAknsFrameBackgroundControlContext::NewL(

   925 //        KAknsIIDQsnFrPopupSub, outerRect, innerRect, ETrue );

   926     iKeystrokeArray = new(ELeave)CDesCArrayFlat(1);

   927     iShowKeystrokeArray = new(ELeave)CDesCArrayFlat(1);

   928     iPhraseArray = new(ELeave)CDesCArrayFlat(1);

   929     iPhraseShowKeyStrokeArray = new(ELeave)CDesCArrayFlat(1);

   930     iTempArray = new(ELeave)CDesCArrayFlat(1);

   931     iMiniQwertyZhuyin = EFalse;

   932     iNeedClearDeliberateSelection = EFalse;

   933     }

   934 

   935 // ---------------------------------------------------------

   936 // Calculate visual text for appending.

   937 // ---------------------------------------------------------

   938 //

   939 void CAknFepUICtrlPinyinEEP::CalculateVisualTextForAppend( const TDesC& aDes )

   940     {

   941     TRect panerect = iEditableEntryPane->Rect();

   942     TAknTextLineLayout textPaneTextLayout = 

   943             CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

   944     const CFont* font = AknLayoutUtils::FontFromId( textPaneTextLayout.iFont, 

   945     NULL );

   946 

   947     TInt lenToEnd = font->TextWidthInPixels( iAbsoluteBuffer->Right( iVisualBuffer->Length()

   948         + aDes.Length() ) );

   949     if ( lenToEnd <= panerect.Width() - panerect.Width()*KLROffset

   950         /KDenominator * 2 )

   951         {

   952         *iVisualBuffer = iAbsoluteBuffer->Right( iVisualBuffer->Length()

   953             + aDes.Length() );

   954         }

   955     else

   956         {

   957         this->CalculateVisualTextForMoveRight();

   958         }

   959     }

   960 

   961 // ---------------------------------------------------------

   962 // Calculate visual text for deleting.

   963 // ---------------------------------------------------------

   964 //

   965 void CAknFepUICtrlPinyinEEP::CalculateVisualTextForDelete( TInt /*aBeg*/,

   966     TInt /*aLen*/)

   967     {

   968     TRect panerect = iEditableEntryPane->Rect();

   969     TAknTextLineLayout textPaneTextLayout = 

   970             CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

   971     const CFont* font = AknLayoutUtils::FontFromId( textPaneTextLayout.iFont, 

   972     NULL );

   973     iOffset = iOffset > iAbsoluteBuffer->Length()?iAbsoluteBuffer->Length():iOffset;

   974     TInt lenToEnd = font->TextWidthInPixels( iAbsoluteBuffer->Right( iAbsoluteBuffer->Length()

   975         - iOffset ) );

   976     

   977     TInt offsetLen = iAbsoluteCursorPos - iOffset;

   978     if ( offsetLen < 0 )

   979         {

   980         offsetLen = 0;

   981         }

   982     TInt LenOffsetToCursor = font->TextWidthInPixels( iAbsoluteBuffer->Mid( 

   983             iOffset, offsetLen ) );

   984 

   985     if ( lenToEnd > 0 && iAbsoluteCursorPos >= iOffset && LenOffsetToCursor > panerect.Width()*KLROffset/KDenominator )

   986         {

   987         TInt stride = 0;

   988         for (stride = 1;; stride ++ )

   989             {

   990             if ( iOffset + stride > iAbsoluteBuffer->Length() )

   991                 {

   992                 break;

   993                 }

   994             TInt tmpFontLen = font->TextWidthInPixels( iAbsoluteBuffer->Mid(

   995                 iOffset, stride ) );

   996             if ( tmpFontLen > panerect.Width() - panerect.Width()

   997                 *KLROffset/KDenominator * 2 )

   998                 {

   999                 break;

  1000                 }

  1001             }

  1002         *iVisualBuffer = iAbsoluteBuffer->Mid( iOffset, stride - 1 );

  1003         }

  1004     else

  1005         {

  1006         this->CalculateVisualTextForMoveLeft();

  1007         }

  1008     }

  1009 

  1010 // ---------------------------------------------------------

  1011 // Calculate visual text for inserting.

  1012 // ---------------------------------------------------------

  1013 //

  1014 void CAknFepUICtrlPinyinEEP::CalculateVisualTextForInsert( TInt /*aIndex*/,

  1015     const TDesC& /*aDes*/)

  1016     {

  1017     TRect panerect = iEditableEntryPane->Rect();

  1018     TAknTextLineLayout textPaneTextLayout = 

  1019             CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

  1020     const CFont* font = AknLayoutUtils::FontFromId( textPaneTextLayout.iFont, 

  1021     NULL );

  1022     

  1023     TInt offsetLen = iAbsoluteCursorPos - iOffset;

  1024     if ( offsetLen < 0 )

  1025         {

  1026         offsetLen = 0;

  1027         }

  1028 

  1029     TInt lenToCursor = font->TextWidthInPixels( iAbsoluteBuffer->Mid(

  1030         iOffset, offsetLen ) );

  1031     if ( lenToCursor < panerect.Width()* KCursorResetStartOffset / KDenominator

  1032         || iAbsoluteCursorPos == iAbsoluteBuffer->Length()

  1033         && lenToCursor <= panerect.Width() - panerect.Width()*KLROffset/KDenominator * 2)

  1034         {

  1035         TInt stride = 0;

  1036         for (stride = 1;; stride ++ )

  1037             {

  1038             if ( iOffset + stride > iAbsoluteBuffer->Length() )

  1039                 {

  1040                 break;

  1041                 }

  1042             TInt tmpFontLen = font->TextWidthInPixels( iAbsoluteBuffer->Mid(

  1043                 iOffset, stride ) );

  1044             if ( tmpFontLen > panerect.Width() - panerect.Width()

  1045                 *KLROffset/KDenominator * 2 )

  1046                 {

  1047                 break;

  1048                 }

  1049             }

  1050         *iVisualBuffer = iAbsoluteBuffer->Mid( iOffset, stride - 1 );

  1051         }

  1052     else

  1053         {

  1054         this->CalculateVisualTextForMoveRight();

  1055         }

  1056     }

  1057 

  1058 // ---------------------------------------------------------

  1059 // Calculate visual text for replacing.

  1060 // ---------------------------------------------------------

  1061 //

  1062 void CAknFepUICtrlPinyinEEP::CalculateVisualTextForReplace( TInt /*aBeg*/,

  1063     TInt /*aLen*/, const TDesC& /*aDes*/)

  1064     {

  1065     }

  1066 

  1067 // ---------------------------------------------------------

  1068 // Calculate visual text for moving to left.

  1069 // ---------------------------------------------------------

  1070 //

  1071 void CAknFepUICtrlPinyinEEP::CalculateVisualTextForMoveLeft()

  1072     {

  1073     TRect panerect = iEditableEntryPane->Rect();

  1074     TAknTextLineLayout textPaneTextLayout = 

  1075             CAknFepChineseUIDataConv::AnyToTextLine( iLafDataMgr->RequestData( EEEPTextLine ));

  1076     const CFont* font = AknLayoutUtils::FontFromId( textPaneTextLayout.iFont, 

  1077     NULL );

  1078     TInt absolutelength = font->TextWidthInPixels( *iAbsoluteBuffer );

  1079     TInt

  1080         cursorToBegLength =

  1081             font->TextWidthInPixels( iAbsoluteBuffer->Left( iAbsoluteCursorPos ) );

  1082     if ( iAbsoluteCursorPos > iAbsoluteBuffer->Length() + 1 )

  1083         {

  1084         iAbsoluteCursorPos = iAbsoluteBuffer->Length() + 1;

  1085         }

  1086     TInt lenPixelToVisualBeg = panerect.Width() * KCursorResetOffset

  1087         / KDenominator;

  1088     TInt stride = 0;

  1089     TInt visualBeg = 0;

  1090     TInt visualEnd = 0;

  1091     for (stride = 1;; stride ++ )

  1092         {

  1093         if ( 0 > iAbsoluteCursorPos - stride )

  1094             {

  1095             visualBeg = 0;

  1096             break;

  1097             }

  1098         TInt tmpFontLen = font->TextWidthInPixels( iAbsoluteBuffer->Mid(

  1099             iAbsoluteCursorPos - stride, stride ) );

  1100         if ( tmpFontLen > lenPixelToVisualBeg )

  1101             {

  1102             visualBeg = iAbsoluteCursorPos - stride + 1;

  1103             break;

  1104             }

  1105         }

  1106         

  1107     //Fix for bug ESXU-7U68JT, let adjustment of visualBeg before caculation of visualEnd. 

  1108     //For one, calculation always start before "(" for miniqwertyzhuyin

  1109     //For two, because characters(markers) might have different length in pixel, it's better recalculate visualEnd

  1110     // after changing visualBeg, therefore move changing visualBeg ahead of caculation take effect too.

  1111     if ( iMiniQwertyZhuyin && 

  1112         iAbsoluteBuffer->Length() > 0 && 

  1113         visualBeg >= iPhraseArray->Count() )

  1114         {

  1115         while ( visualBeg > 0 &&

  1116             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KLeftBracket ) != 0 &&

  1117             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KToneMark1 ) != 0 &&

  1118             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KToneMark2 ) != 0 &&

  1119             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KToneMark3 ) != 0 &&

  1120             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KToneMark4 ) != 0 &&

  1121             iAbsoluteBuffer->Mid( visualBeg, 1 ).Compare( KToneMark5 ) != 0 )

  1122             {

  1123             visualBeg--;

  1124             }

  1125         }

  1126 

  1127     for (stride = 1;; stride ++ )

  1128         {

  1129         if ( visualBeg + stride > iAbsoluteBuffer->Length() )

  1130             {

  1131             visualEnd = visualBeg + stride - 1;

  1132             break;

  1133             }

  1134         TPtrC tempString = iAbsoluteBuffer->Mid(visualBeg, stride );