1 /*

     2 * Copyright (c) 2004 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 CAknFepUICtrlPinyinPopup class definitions.

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 

    27 

    28 

    29 #ifndef __AKN_FEP_UI_AVKON_PINYIN_POPUP_H

    30 #define __AKN_FEP_UI_AVKON_PINYIN_POPUP_H

    31 

    32 #include <AknFepUICtrlPinyinPopup.h>

    33 #include <badesca.h>

    34 #include <coecntrl.h>

    35 #include <AknUtils.h>

    36 #include "AknFepUIAvkonCtrlInputPane.h"

    37 #include "AknFepUIAvkonCtrlCandidatePane.h"

    38 

    39 class MAknFepUICtrlPinyinPopupSizeChangedObserver;

    40 

    41 NONSHARABLE_CLASS(CAknFepUICtrlPinyinPopup):public CCoeControl, public MAknFepUICtrlPinyinPopup

    42 {

    43 public:

    44     /**

    45      * First phase construction

    46      */

    47     static CAknFepUICtrlPinyinPopup* NewL(RWindow& aParent, CAknFepUiLayoutDataMgr* aLafDataMgr);

    48     /**

    49      * destructor

    50      */

    51     ~CAknFepUICtrlPinyinPopup();

    52     /**

    53      * This function returns the index of the selected phrase item .

    54      *

    55      * @return aIndex index of entry in window, zero based

    56      */

    57     TInt CurrentSelection() const;

    58     /**

    59      * This function returns the visible index of the selected item.

    60      *

    61      * @return aIndex index of entry in window, zero based

    62      */

    63     TInt CurrentVisibleSelection() const;

    64 	 /**

    65      * set the observer

    66      * <p> Note that only one observer is supported!

    67      *

    68      * @param aObserver pointer to the observer

    69      */

    70     void SetSizeChangedObserver(MAknFepUICtrlPinyinPopupSizeChangedObserver* aObserver);

    71 

    72     /**

    73      * Enables the display of the control. Sets the control's 

    74      * window postion and visibility, but only if the value has

    75      * changed (so it's ok to call it excessively). 

    76      *

    77      * @param aEnable if ETrue, makes visible

    78      *                          if EFalse, makes non-visible

    79      *

    80      */

    81     void Enable(TBool aEnable);

    82 	/**

    83      * set the number of selections that are visible

    84      *

    85      * @param aCount the number of visible selections, must be 

    86      *                          0 < aCount <= KMaxNumberOfSelections 

    87      */

    88     void SetVisibleSelectionCount(TInt aCount);

    89 	/**

    90      * set the number of selections that are visible

    91      *

    92      * @param aCount the number of visible selections, must be 

    93      *                          0 < aCount <= KMaxNumberOfSelections 

    94      */

    95     void SetVisibleCount(TInt aCount);

    96 

    97     /**

    98      * get the current visible selection count

    99      *

   100      * @return visible selection count

   101      */

   102     TInt VisibleSelectionCount() const;

   103 

   104 

   105     /**

   106      * This sets the string of the internal buffer for the item index aIndex to aText,

   107      * even if the index falls outside the current visible candidates.

   108      *

   109      * @param aText new contents of text item

   110      * @return ETrue if successful

   111      *              EFalse if index outside visible candidates (but value is still set)

   112      *

   113      */

   114     TBool SetItemText(TInt aIndex, const TDesC& aText);

   115 

   116     /**

   117     *   Sets the string of the internal buffer for visible item 

   118     */

   119     TBool SetPhraseItemTexts();

   120     

   121     /**

   122      * This function gets the text at the index aIndex. 

   123      *

   124      * @param aIndex index of entry in window, zero based

   125      * @output aText contains contents of text item

   126      * @return ETrue always

   127      *

   128      */

   129     TBool GetItemText(TInt aIndex, TDes& aText) const;

   130 

   131     /**

   132      * This function sets the Tone Mark for all entries

   133      * 

   134      * @param aToneMark the tone mark

   135      *

   136      */

   137     void SetToneMark(const TDesC& aToneMark);

   138 

   139     /**

   140      * This function sets the Tone Mark for a specific entry

   141      * 

   142      * @param aIndex index of entry

   143      * @param aToneMark the tone mark

   144      *

   145      */

   146     void SetToneMark(TInt aIndex, const TDesC& aToneMark);

   147 

   148     /**

   149      * This function gets the Tone Mark for a specific entry

   150      * 

   151      * @param aIndex index of entry

   152      * @output aToneMark the tone mark

   153      *

   154      */

   155     void GetToneMark(TInt aIndex, TDes& aToneMark) const;

   156 

   157     /**

   158      * This function sets the validity of the tonemark

   159      *

   160      * @param aIndex index of the entry to be affected

   161      * @param aValid if ETrue, tonemark will be displayed as valid

   162      *                          if EFalse, tonemark will be displayed as not valid

   163      */

   164     void SetItemToneMarkValidity(TInt aIndex, TBool aValid);

   165     /**

   166      * Is the control enabled for display?

   167      *

   168      * @return if not enabled, return EFalse

   169      */

   170     TBool IsEnabled() const;

   171 

   172     /**

   173      * Select the next visible item. If already on the last one, loop to the 

   174      * first one.

   175      *

   176      * @return ETrue if success, 

   177      *              EFalse if no items visible, or if selection is outside visible items

   178      */

   179     TBool SelectNextPhrase();

   180 

   181     /**

   182      * Select the previous visible item. If already on the first one, loop to the 

   183      * last one.

   184      *

   185      * @return ETrue if success, 

   186      *              EFalse if no items visible, or if selection is outside visible items

   187      */

   188     TBool SelectPrevPhrase();

   189 

   190     /**

   191      * This function selects the item at index aIndex. 

   192      *

   193      * @param aIndex index of entry in window, zero based

   194      * @return ETrue if success, EFalse if failure.

   195      */

   196     TBool SelectIndex(TInt aIndex);

   197 

   198     /**

   199 	*	Return Pinyin spelling candidate array 

   200 	*/

   201     CDesCArrayFlat* PhoneticSpellingArray(void);

   202 

   203     /**

   204 	*	Return Pinyin spelling candidate array 

   205 	*/

   206     CDesCArrayFlat* PhoneticSpellingIndexArray();    

   207     /**

   208 	*	Split phrase pinyin spelling candidates into pages 

   209 	*/

   210     void SplitPhraseSpellingIntoPages(void);

   211 

   212     /**

   213 	*	Split pinyin spelling candidates into pages 

   214 	*/

   215     void SplitSpellingIntoPages(TInt aCount);

   216     

   217     /**

   218 	*	Set display page for deliberate selection 

   219 	*/

   220     void SetDisplayPage(TInt aSelection);

   221     /**

   222 	*	Return current page start spelling index 

   223 	*/

   224     TInt CurrentPageStartIndex(void);

   225 

   226     /**

   227 	*	Return kestroke array 

   228 	*/

   229     CDesCArrayFlat* KeystrokeArray(void);

   230     

   231     /**

   232 	*	Return in effect kestroke array 

   233 	*/    

   234     CDesCArrayFlat* InEffectKeystrokeArray();

   235     

   236     /**

   237 	*	Return  show kestroke array 

   238 	*/    

   239     CDesCArrayFlat* ShowKeystrokeArray();

   240 

   241     /**

   242 	 *	Return Optimize Spelling array 

   243 	 */    

   244     CDesCArrayFlat* OptimizeSpelling();

   245     

   246     /**

   247      *  Return temp Spelling array 

   248      */    

   249     CDesCArrayFlat* TempSpelling();

   250     

   251     /**

   252      *	Return choose chinese charater array 

   253      */

   254     CDesCArrayFlat* ChooseChineseCharacterArray();    

   255 

   256     /**

   257      *	Return choose chiese charater keystroke array 

   258      */

   259     CDesCArrayFlat* ChooseChineseCharacterArrayKeystroke();    

   260     

   261     /**

   262      *	Return the tone mark state 

   263      */

   264     TBool GetTonemarkState();   

   265     

   266     /**

   267      *	set the tone mark state 

   268      */

   269      void SetTonemarkState( TBool aState );    

   270      

   271     /**

   272     *   Set, clear and check flags status

   273     */

   274     inline void SetFlag(TInt aFlag);

   275     inline void ClearFlag(TInt aFlag);

   276     inline TBool IsFlagSet(TInt aFlag) const;

   277 	void PopupSizeChanged();

   278 	

   279     /**

   280      *  Set all the input pane not highlight

   281      */

   282 	void SetNoneHighlighted();

   283 	

   284     /**

   285     *   Return kestroke array 

   286     */

   287 	CDesCArrayFlat* KeystrokeArrayForStroke();

   288 

   289     /**

   290     *   Return in effect kestroke array 

   291     */  

   292 	CDesCArrayFlat* InEffectKeystrokeArrayForStroke();

   293 

   294     /**

   295     *   Return  show kestroke array 

   296     */ 

   297 	CDesCArrayFlat* ShowKeystrokeArrayForStroke();

   298 

   299     /**

   300      *  Return choose chinese charater array 

   301      */

   302 	CDesCArrayFlat* ChooseChineseCharacterArrayForStroke();

   303 

   304     /**

   305      *  Return choose chiese charater keystroke array 

   306      */

   307 	CDesCArrayFlat* ChooseChineseCharacterArrayKeystrokeForStroke();

   308 	

   309     CDesCArrayFlat* ZhuyinSymbols();

   310     

   311     CDesCArrayFlat* ZhuyinShowSymbols();

   312     

   313     CDesCArrayFlat* FirstValidZhuyinGrp() ;

   314     

   315     CDesCArrayFlat* ChineseCharsDisped() ;

   316     

   317     CDesCArrayFlat* ZhuyinSymbolsForChineseCharsDisped() ;

   318     

   319     void SetEEPContent ( const TDes& aDes );

   320     TDes& GetEEPContent ( );

   321     

   322     void SetEEPContentValid ( TBool aValid );

   323     TBool GetEEPContentValid ( );

   324     

   325     /**

   326      *  Reset all array 

   327      */

   328 	void ResetStrokeArray();

   329 	

   330     /**

   331      *  Set the state is changed 

   332      */

   333     void SetChangeState( TBool aChangeState );

   334     

   335     /**

   336      *  Return if has changed state or not 

   337      */

   338     TBool IsChangeStatet() const;

   339     

   340     /**

   341      * Set whether state change from entry to spelling editing is automatical.

   342      * 

   343      * @param aState.1 for automatical, 0 for manual.

   344      * @return None.

   345      */

   346     void SetState( TInt aState );

   347     

   348     /**

   349      * Get state change status.

   350      */

   351     TInt GetState();

   352     

   353     /**

   354      * Set whether state change from pinyin input state to pinyin phrase creation.

   355      * 

   356      * @param aState. ETrue for state change from pinyin input to phrase creation,

   357      *  EFalse is not.

   358      * @return None.

   359      */

   360     void SetPhraseCreationState( TBool aState );

   361     

   362     /**

   363      * Set whether state change from pinyin input state to pinyin phrase creation.

   364      * 

   365      * @return ETrue for state change from pinyin input to phrase creation,

   366      *  EFalse is not.

   367      */

   368     TBool GetPhraseCreationState();

   369     

   370     /**

   371      * Set whether at the editing state happen editing for pinyin phrase creation.

   372      * 

   373      * @param aState. ETrue happen editing,EFalse others.

   374      * @return None.

   375      */

   376     void SetPhraseCreationEditingState( TBool aState );

   377     

   378     /**

   379      * Get whether at the editing state happen editing for pinyin phrase creation.

   380      * 

   381      * @param aState. ETrue happen editing,EFalse others.

   382      * @return None.

   383      */

   384     TBool GetPhraseCreationEditingState();

   385     

   386     /**

   387      * Set flag whether from candidate state change state.

   388      * 

   389      * @param aFlag  ETrue from the candidate state change state, other EFalse.

   390      * @since S60 V5.0

   391      * @return none.

   392      */

   393     void SetFromCandidateChangeStateFlag( TBool aFlag );

   394     

   395     /**

   396      * Get flag whether from candidate state change state.

   397      * 

   398      * @since S60 V5.0

   399      * @return ETrue from the candidate state change state, other EFalse.

   400      */

   401     TBool GetFromCandidateChangeStateFlag();

   402 

   403     /**

   404      * Set count of valid keystroke.

   405      * 

   406      * @since S60 V5.0

   407      * @return none

   408      */

   409     void SetValidKeystrokeCount( TInt aCount );

   410     

   411     /**

   412      * get count of valid keystroke.

   413      * 

   414      * @since S60 V5.0

   415      * @return count of valid keystroke.

   416      */

   417     TInt GetValidKeystrokeCount();

   418     

   419     /**

   420      * Set last cba resouce id.

   421      * 

   422      * @since S60 V5.0

   423      * @return None

   424      */

   425     void SetLastResouce( TInt aResouceId );

   426     

   427     /**

   428      * Get last cba resouce id.

   429      * 

   430      * @since S60 V5.0

   431      * @return last resouce id

   432      */

   433     TInt GetLastResouce();

   434     

   435     

   436     /**

   437      * Set change state from Edit to Spelling flag.

   438      * 

   439      * @param aFlag,If ETrue Change from Edit state to spelling state,EFalse others. 

   440      * @since S60 V5.0

   441      * @return none.

   442      */

   443     void SetFromEditToSpellingFlag( TBool aFlag = EFalse );

   444 

   445     /**

   446      * Get change state from Edit to Spelling flag.

   447      * 

   448      * @param none. 

   449      * @since S60 V5.0

   450      * @return ETrue Change from Edit state to spelling state,EFalse others..

   451      */

   452     TInt GetFromEditToSpellingFlag();

   453     

   454     

   455     /**

   456      * Set valid keystroke change flag.

   457      * 

   458      * @param aFlag, ETrue valid keystroke changed,EFalse others.

   459      * @since S60 V5.0

   460      * @return none

   461      */

   462     void SetValidKeystrokeChange( TBool aFlag );

   463     

   464     /**

   465      * Get valid keystroke change flag.

   466      * 

   467      * @since S60 V5.0

   468      * @return ETrue,if vallid keystroke changed, others EFalse.

   469      */

   470     TBool GetValidKeystrokeChange();

   471     

   472     /**

   473      * Set PreStateIsPredict flag.

   474      * 

   475      * @param aFlag, ETrue PreStateIsPredict,EFalse others.

   476      * @since S60 V5.0

   477      * @return none

   478      */

   479     void SetPreStateIsPredictive( TBool aFlag );

   480     

   481     /**

   482      * Get PreStateIsPredict flag.

   483      * 

   484      * @since S60 V5.0

   485      * @return ETrue,if PreStateIsPredict, others EFalse.

   486      */

   487     TBool GetPreStateIsPredictive();

   488 

   489     void SetInputLayoutMiniQwertyZhuyin();

   490     

   491     void ResetInputLayoutMiniQwertyZhuyin();

   492 

   493 protected: // From CCoeControl

   494 	TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

   495 

   496 protected:

   497     /**

   498      * constructor

   499      */

   500 	CAknFepUICtrlPinyinPopup(CAknFepUiLayoutDataMgr* aLafDataMgr);

   501     /**

   502      * second phase construction

   503      */

   504     void ConstructL(RWindow& aParent);

   505 	/**

   506      * Construct arrow bitmap class

   507      */

   508 	void ConstructBitmapsL();

   509     /**

   510      * layout the rectangles

   511      */

   512     void LayoutRects();

   513 

   514     /**

   515      * layout contained controls

   516      */

   517     void LayoutContainedControls();

   518 

   519     /**

   520      * Layout the input panes

   521      */

   522     void LayoutInputPanes();

   523  

   524 	/**

   525      * set the visibility of the input panes, according to the current layout

   526      */

   527     void SetInputPaneVisibility();

   528 

   529     /**

   530      * layout the background frames

   531      */

   532     void LayoutFrames();

   533 

   534     /**

   535      * just layout one of the input panes

   536      *

   537      * @param aIndex index of input pane to lay out

   538      *

   539      */

   540     void LayoutInputPane(TInt aIndex);

   541 

   542     /**

   543      * update input panes' visibility

   544      */

   545     void UpdateInputPaneVisibility(void);

   546 

   547 	

   548 public: //from CcoeControl

   549      /**

   550      * size changed

   551      */

   552     virtual void SizeChanged();

   553 

   554     /**

   555      * count component controls

   556      *

   557      * @return number of contained controls

   558      */

   559     TInt CountComponentControls() const;

   560 

   561     /**

   562      * Component control

   563      *

   564      * @param aIndex the control to return, must be between 0 and the number of controls

   565      * @return pointer to contained control, ownership is not passed

   566      * 

   567      */

   568     CCoeControl* ComponentControl(TInt aIndex) const;

   569     /**

   570      * draw

   571      *

   572      * @param aRect rectangle

   573      *

   574      */

   575     virtual void Draw(const TRect& aRect) const;

   576     /**

   577      * layout the background frames

   578      *

   579      * @param aOuterRect filled with outer rect coords

   580      * @param aInnerRect filled with inner rect coords

   581      *

   582      */

   583     void CalculateFrameRects(TRect& aOuterRect, TRect& aInnerRect) const;

   584  

   585 private: // the following need resetting

   586     RPointerArray<CAknFepUICtrlInputPane> iInputPaneArray;

   587 private: // the following are not owned

   588     CAknFepUiLayoutDataMgr* iLafDataMgr;

   589     MAknFepUICtrlPinyinPopupSizeChangedObserver* iSizeChangedObserver;

   590 private: // the following are owned

   591     CAknsFrameBackgroundControlContext* iBgContext; 

   592     CFbsBitmap* iNaviArrowBitmapLeft;

   593     CFbsBitmap* iNaviArrowBitmapLeftMask;

   594     CFbsBitmap* iNaviArrowBitmapRight;

   595     CFbsBitmap* iNaviArrowBitmapRightMask;

   596 

   597 private:

   598 	TAknLayoutRect iIndiFepArrowLeft;

   599     TAknLayoutRect iIndiFepArrowRight;

   600     TInt iSelected;

   601     TInt iEnabled;

   602     TToneMark iToneMark;

   603    	TAknLayoutRect iRectCoverMainPaneInput;

   604     TAknLayoutRect iRectFirstShadowInput;

   605     TAknLayoutRect iRectOutlineFrameInput;

   606     TAknLayoutRect iRectInsideAreaInput;

   607 	TInt iVisibleCount;

   608     RArray<TPage> iPages;

   609     TInt iCurDisplayPage;

   610     CDesCArrayFlat* iSpellingArray;

   611     //Spelling index array

   612     CDesCArrayFlat* iSpellingIndexArray;

   613     //keystroke arrray

   614     CDesCArrayFlat* iKeystrokeArray;

   615     //in effect keystroke array

   616     CDesCArrayFlat* iInEffectKeystrokeArray;

   617     //show Keystroke array

   618     CDesCArrayFlat* iShowKeystrokeArray;

   619     //Optimize Keystroke array

   620     CDesCArrayFlat* iOptimizeSpelling;

   621     //temp Keystroke array

   622     CDesCArrayFlat* iTempSpelling;

   623     //Chinese array

   624     CDesCArrayFlat* iChooseChineseCharacterArray;

   625     //Chinese Keystroke array

   626     CDesCArrayFlat* iChooseChineseCharacterArrayKeystroke;

   627     

   628     CDesCArrayFlat* iKeystrokeArrayForStroke;

   629     CDesCArrayFlat* iInEffectKeystrokeArrayForStroke;

   630     CDesCArrayFlat* iShowKeystrokeArrayForStroke;

   631     CDesCArrayFlat* iChooseChineseCharacterArrayForStroke;

   632     CDesCArrayFlat* iChooseChineseCharacterArrayKeystrokeForStroke;

   633 

   634     CDesCArrayFlat* iZhuyinSymbols;

   635     CDesCArrayFlat* iZhuyinShowSymbols;

   636     CDesCArrayFlat* iFirstValidZhuyinGrp;

   637     CDesCArrayFlat* iChineseCharsDisped;

   638     CDesCArrayFlat* iZhuyinSymbolsForChineseCharsDisped;

   639     TBuf<100> iEEPContent;

   640     TBool iEEPContentValid;

   641     

   642     //the tone mark state

   643     TInt iTonemarkState;

   644     

   645     //the stroke state

   646     TInt iStrokeState;

   647     

   648     // The highlight goes back to wrong position when transfer from pinyin 

   649     // spelling pane to pinyin candidate pane more than one time.

   650     TInt iHighLightFlag;

   651     

   652     TInt iFlags;

   653     

   654     TInt iValidKeystrokeCount;

   655     TInt iPhraseCreation;

   656     TInt iPhraseCreationEditingState;

   657     TInt iChangeState;

   658     /**

   659      * whether the state change from entry to spelling editing is automatical.

   660      */

   661     TInt iState;

   662     

   663     TInt iLastResouce;

   664     

   665     /**

   666      * whether the state change from Edit to spelling.

   667      */

   668     TInt iChangeStateFromEditToSpelling;

   669     

   670     /**

   671      * whether the valid keystroke changed.

   672      */

   673     TInt iValidKeystrokeChanged;

   674     

   675     /**

   676      * whether the previous state is predictive display.

   677      */

   678     TBool iPreStateIsPredictive;

   679 };

   680 

   681 inline void CAknFepUICtrlPinyinPopup::SetFlag(TInt aFlag)

   682     {

   683     iFlags |= aFlag;

   684     }

   685 

   686 inline void CAknFepUICtrlPinyinPopup::ClearFlag(TInt aFlag)

   687     {

   688     iFlags &= ~aFlag;

   689     }

   690 

   691 inline TBool CAknFepUICtrlPinyinPopup::IsFlagSet(TInt aFlag) const

   692     {

   693     return iFlags & aFlag;

   694     }

   695 

   696 #endif // __AKN_FEP_UI_AVKON_PINYIN_POPUP_H

   697 

   698 // End of file