开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
DictionaryMain.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：85k
源码类别：

MTK

开发平台：

C/C++

DictionaryMain.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * DictionaryMain.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for Dictionary UI implementation
  49.  *
  50.  * Author:
  51.  * Rajbir Singh
  52.  * -------
  53.  *
  54.  
  55.  *------------------------------------------------------------------------------
  56.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *============================================================================
  58.  ****************************************************************************/
  60. #include "MMI_features.h"
  62. #if defined(__MMI_DICTIONARY__)
  63. #if defined(MMI_ON_HARDWARE_P)  /* Not support in PC Simulator */
  65. #include "stdC.h"
  66. #include "L4Dr1.h"
  67. #include "PixtelDataTypes.h"
  68. #include "GlobalConstants.h"
  69. #include "DebugInitDef.h"
  70. #include "wgui_categories.h"
  71. #include "wgui_categories_inputs.h"
  72. #include "HistoryGprot.h"
  73. #include "Unicodexdcl.h"
  74. #include "GlobalDefs.h"
  75. #include "CommonScreens.h"
  76. #include "SettingProfile.h"
  77. #include "DictionaryMain.h"
  79. #if defined(__MMI_DICT_GV__)
  80. #include "DictionaryCoreGV.h"
  81. #elif defined(__MMI_DICT_MOTECH__ )
  82. #include "DictionaryCoreMOTECH.h"
  83. #elif defined(__MMI_DICT_TRILOGY__ )
  84. #include "DictionaryCoreTRILOGY.h"
  85. #endif 
  88. /*
  89.  * Local Variable
  90.  */
  91. pBOOL g_dictionary_last_item = FALSE;
  92. U8 g_mmi_dictionary_prev_input_mode;
  93. S32 g_dictionary_prev_index;
  94. S32 g_dictionary_highlighted_item;
  96. #if defined(__MMI_DICT_GV__) || defined(__MMI_DICT_MOTECH__)
  97. U8 g_dictionary_result_buffer[(1024) * 7];              /* result buffer that contains all data to show to user */
  98. #elif defined(__MMI_DICT_TRILOGY__)
  99. U8 g_dictionary_result_buffer[(1024) * 3];              /* result buffer that contains all data to show to user */
  100. #endif 
  101. U8 g_dictionary_input_buffer[(DICTIONARY_INPUT_LENGTH + 1) * ENCODING_LENGTH];  /* Input buffer on main dictionary screen */
  102. U8 g_dictionary_wildcard_exact_buffer[(DICTIONARY_INPUT_LENGTH + 1) * ENCODING_LENGTH]; /* input buffer for wildcard,exact and chinese string search */
  103. U8 g_dictionary_input[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  104. U8 g_dictionary_last_word[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  105. U8 g_dictionary_first_displayed_buffer[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  106. mmi_dictionary_search_type g_dictionary_search_type;    /* Search enum : can be Browse, Exact, Wildcard search */
  107. mmi_dictionary_cntx g_dictionary_cntx;                  /* context stucture to hold various global flags */
  109. S16 *g_dictionary_input_mode;   /* Input mode for dictionary screen */
  110. S16 g_dictionary_input_mode_Chinese_set[] = 
  111. {
  112.     INPUT_MODE_MULTITAP_UPPERCASE_ABC,
  113.     INPUT_MODE_MULTITAP_LOWERCASE_ABC,
  114.     INPUT_MODE_TR_MULTITAP_BOPOMO,
  115.     INPUT_MODE_SM_MULTITAP_PINYIN,
  116. #if !defined(__MMI_TOUCH_SCREEN__)
  117.     INPUT_MODE_TR_BOPOMO,
  118.     INPUT_MODE_SM_PINYIN,
  119.     INPUT_MODE_TR_STROKE,
  120.     INPUT_MODE_SM_STROKE,
  121. #endif /* !defined(__MMI_TOUCH_SCREEN__) */ 
  122.     -1
  123. };
  125. /*
  126.  * Global Variable
  127.  */
  128. extern pBOOL GetUCS2Flag(PS8);
  129. extern U8 MMI_current_input_mode;   /* Global variable to get the input method */
  130. extern U8 wgui_multiline_inputbox_input_type;
  132. /* Adaptation layer structures */
  133. mmi_dict_id_str_struct g_dict_wildcard_ids[MMI_DICT_ID_FETCH_MAX + 1], ID,
  134.     g_dict_chinese_ids[MMI_DICT_ID_FETCH_MAX + 1];
  135. mmi_dict_result_struct g_dict_fetchresult;
  136. MMI_DICTIONARY_LANGUAGE g_dict_current_language, g_dictionary_language_main_screen;
  138. /*
  139.  * Global Function
  140.  */
  143. /*****************************************************************************
  144.  * FUNCTION
  145.  *  mmi_dictionary_init
  146.  * DESCRIPTION
  147.  *  Initialize Dictionary database. Set highlight handlers
  148.  * PARAMETERS
  149.  *  void
  150.  * RETURNS
  151.  *  void
  152.  *****************************************************************************/
  153. void mmi_dictionary_init(void)
  154. {
  155.     /*----------------------------------------------------------------*/
  156.     /* Local Variables                                                */
  157.     /*----------------------------------------------------------------*/
  159.     /*----------------------------------------------------------------*/
  160.     /* Code Body                                                      */
  161.     /*----------------------------------------------------------------*/
  162.     SetHiliteHandler(EXTRA_DICTIONARY_MENU, mmi_dictionary_main_menu_highlight_hdlr);
  163.     SetHiliteHandler(DICTIONARY_OPTION_SHOW_MEANING_MENU, mmi_dictionary_show_meaning_highlight_hdlr);
  164. #ifdef __MMI_DICTIONARY_WILDCARD_SEARCH__
  165.     SetHiliteHandler(DICTIONARY_OPTION_WILDCARD_SEARCH_MENU, mmi_dictionary_wildcard_highlight_hdlr);
  166. #endif 
  167.     SetHiliteHandler(DICTIONARY_OPTION_EXACT_SEARCH_MENU, mmi_dictionary_exact_highlight_hdlr);
  168. #ifndef __MMI_DICTIONARY_SMALL_SCREEN__
  169.     SetHiliteHandler(DICTIONARY_OPTION_INPUT_METHOD, mmi_dictionary_input_method_highlight_hdlr);
  170. #endif 
  171.     SetHiliteHandler(DICTIONARY_EDITOR_OPTION_SEARCH_MENU, mmi_dictionary_editor_option_search_highlight_hdlr);
  172.     SetHiliteHandler(
  173.         DICTIONARY_EDITOR_OPTION_INPUT_METHOD_MENU,
  174.         mmi_dictionary_editor_option_input_method_highlight_hdlr);
  176.     /* Assign input mode for the dictionary */
  177.     g_dictionary_input_mode = g_dictionary_input_mode_Chinese_set;
  178. }
  180. /*
  181.  * Local Function
  182.  */
  185. /*****************************************************************************
  186.  * FUNCTION
  187.  *  mmi_dictionary_main_menu_highlight_hdlr
  188.  * DESCRIPTION
  189.  *  Highlight handler for the Dictionary menu in Extra menu list
  190.  * PARAMETERS
  191.  *  void
  192.  * RETURNS
  193.  *  void
  194.  *****************************************************************************/
  195. void mmi_dictionary_main_menu_highlight_hdlr(void)
  196. {
  197.     /*----------------------------------------------------------------*/
  198.     /* Local Variables                                                */
  199.     /*----------------------------------------------------------------*/
  201.     /*----------------------------------------------------------------*/
  202.     /* Code Body                                                      */
  203.     /*----------------------------------------------------------------*/
  204.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  205.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  206.     SetLeftSoftkeyFunction(mmi_dictionary_entry_welcome_screen, KEY_EVENT_UP);
  207.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  208.     SetKeyHandler(mmi_dictionary_entry_welcome_screen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  209.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  210. }
  213. /*****************************************************************************
  214.  * FUNCTION
  215.  *  mmi_dictionary_show_meaning_highlight_hdlr
  216.  * DESCRIPTION
  217.  *  Highlight handler for the Show Meaning in Dictionary option menu list
  218.  * PARAMETERS
  219.  *  void
  220.  * RETURNS
  221.  *  void
  222.  *****************************************************************************/
  223. void mmi_dictionary_show_meaning_highlight_hdlr(void)
  224. {
  225.     /*----------------------------------------------------------------*/
  226.     /* Local Variables                                                */
  227.     /*----------------------------------------------------------------*/
  229.     /*----------------------------------------------------------------*/
  230.     /* Code Body                                                      */
  231.     /*----------------------------------------------------------------*/
  232.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  233.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  235.     g_dictionary_search_type = DICTIONARY_BROWSE;
  236. #ifdef __MMI_DICTIONARY_SMALL_SCREEN__
  237.     g_dict_current_language = DICTIONARY_ENGLISH;
  238. #else 
  239.     g_dict_current_language = g_dictionary_language_main_screen;
  240. #endif 
  241.     SetLeftSoftkeyFunction(mmi_dictionary_entry_result_screen, KEY_EVENT_UP);
  242.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  243.     SetKeyHandler(mmi_dictionary_entry_result_screen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  244.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  245. }
  248. /*****************************************************************************
  249.  * FUNCTION
  250.  *  mmi_dictionary_wildcard_highlight_hdlr
  251.  * DESCRIPTION
  252.  *  Highlight handler for the Wildcard Search menu in Dictionary option menu list
  253.  * PARAMETERS
  254.  *  void
  255.  * RETURNS
  256.  *  void
  257.  *****************************************************************************/
  258. void mmi_dictionary_wildcard_highlight_hdlr(void)
  259. {
  260.     /*----------------------------------------------------------------*/
  261.     /* Local Variables                                                */
  262.     /*----------------------------------------------------------------*/
  264.     /*----------------------------------------------------------------*/
  265.     /* Code Body                                                      */
  266.     /*----------------------------------------------------------------*/
  267.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  268.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  270.     g_dictionary_search_type = DICTIONARY_WILDCARD_SEARCH;
  271.     memset(g_dictionary_wildcard_exact_buffer, 0, ENCODING_LENGTH);
  273.     SetLeftSoftkeyFunction(mmi_dictionary_entry_wildcard_exact_editor_screen, KEY_EVENT_UP);
  274.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  275.     SetKeyHandler(mmi_dictionary_entry_wildcard_exact_editor_screen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  276.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  277. }
  280. /*****************************************************************************
  281.  * FUNCTION
  282.  *  mmi_dictionary_exact_highlight_hdlr
  283.  * DESCRIPTION
  284.  *  Highlight handler for the Exact Search menu in Dictionary option menu list
  285.  * PARAMETERS
  286.  *  void
  287.  * RETURNS
  288.  *  void
  289.  *****************************************************************************/
  290. void mmi_dictionary_exact_highlight_hdlr(void)
  291. {
  292.     /*----------------------------------------------------------------*/
  293.     /* Local Variables                                                */
  294.     /*----------------------------------------------------------------*/
  296.     /*----------------------------------------------------------------*/
  297.     /* Code Body                                                      */
  298.     /*----------------------------------------------------------------*/
  299.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  300.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  302.     g_dictionary_search_type = DICTIONARY_EXACT_SEARCH;
  303.     memset(g_dictionary_wildcard_exact_buffer, 0, ENCODING_LENGTH);
  305.     SetLeftSoftkeyFunction(mmi_dictionary_entry_wildcard_exact_editor_screen, KEY_EVENT_UP);
  306.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  307.     SetKeyHandler(mmi_dictionary_entry_wildcard_exact_editor_screen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  308.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  309. }
  312. /*****************************************************************************
  313.  * FUNCTION
  314.  *  mmi_dictionary_input_method_highlight_hdlr
  315.  * DESCRIPTION
  316.  *  Highlight handler for the input method menu in Dictionary option menu list
  317.  * PARAMETERS
  318.  *  void
  319.  * RETURNS
  320.  *  void
  321.  *****************************************************************************/
  322. void mmi_dictionary_input_method_highlight_hdlr(void)
  323. {
  324.     /*----------------------------------------------------------------*/
  325.     /* Local Variables                                                */
  326.     /*----------------------------------------------------------------*/
  328.     /*----------------------------------------------------------------*/
  329.     /* Code Body                                                      */
  330.     /*----------------------------------------------------------------*/
  331.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  332.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  333.     SetLeftSoftkeyFunction(EntryAPRequiredInputMethodScreen, KEY_EVENT_UP);
  334.     SetKeyHandler(EntryAPRequiredInputMethodScreen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  335.     RegisterInputMethodScreenCloseFunction(DictionaryGoBackMainScreen);
  336. }
  339. /*****************************************************************************
  340.  * FUNCTION
  341.  *  mmi_dictionary_editor_option_search_highlight_hdlr
  342.  * DESCRIPTION
  343.  *  Highlight handler for the search menu in Dictionary editor option menu list
  344.  * PARAMETERS
  345.  *  void
  346.  * RETURNS
  347.  *  void
  348.  *****************************************************************************/
  349. void mmi_dictionary_editor_option_search_highlight_hdlr(void)
  350. {
  351.     /*----------------------------------------------------------------*/
  352.     /* Local Variables                                                */
  353.     /*----------------------------------------------------------------*/
  355.     /*----------------------------------------------------------------*/
  356.     /* Code Body                                                      */
  357.     /*----------------------------------------------------------------*/
  358.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  359.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  361.     SetLeftSoftkeyFunction(mmi_dictionary_entry_search, KEY_EVENT_UP);
  362.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  363.     SetKeyHandler(mmi_dictionary_entry_search, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  364.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  365. }
  368. /*****************************************************************************
  369.  * FUNCTION
  370.  *  mmi_dictionary_editor_option_input_method_highlight_hdlr
  371.  * DESCRIPTION
  372.  *  Highlight handler for the input method menu in Dictionary option menu list
  373.  * PARAMETERS
  374.  *  void
  375.  * RETURNS
  376.  *  void
  377.  *****************************************************************************/
  378. void mmi_dictionary_editor_option_input_method_highlight_hdlr(void)
  379. {
  380.     /*----------------------------------------------------------------*/
  381.     /* Local Variables                                                */
  382.     /*----------------------------------------------------------------*/
  384.     /*----------------------------------------------------------------*/
  385.     /* Code Body                                                      */
  386.     /*----------------------------------------------------------------*/
  387.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  388.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  389.     SetLeftSoftkeyFunction(EntryAPRequiredInputMethodScreen, KEY_EVENT_UP);
  390.     SetKeyHandler(EntryAPRequiredInputMethodScreen, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  391.     RegisterInputMethodScreenCloseFunction(DictionaryGoBackEditorScreen);
  392. }
  395. /*****************************************************************************
  396.  * FUNCTION
  397.  *  DictionaryGoBackMainScreen
  398.  * DESCRIPTION
  399.  *  Go back to Main dictionary screen.
  400.  * PARAMETERS
  401.  *  void
  402.  * RETURNS
  403.  *  void
  404.  *****************************************************************************/
  405. void DictionaryGoBackMainScreen(void)
  406. {
  407.     /*----------------------------------------------------------------*/
  408.     /* Local Variables                                                */
  409.     /*----------------------------------------------------------------*/
  411.     /*----------------------------------------------------------------*/
  412.     /* Code Body                                                      */
  413.     /*----------------------------------------------------------------*/
  414.     GoBackToHistory(SCR_DICTIONARY_MAIN);
  415. }
  418. /*****************************************************************************
  419.  * FUNCTION
  420.  *  DictionaryGoBackEditorScreen
  421.  * DESCRIPTION
  422.  *  Go back to  dictionary editor screen(exact/wildcard).
  423.  * PARAMETERS
  424.  *  void
  425.  * RETURNS
  426.  *  void
  427.  *****************************************************************************/
  428. void DictionaryGoBackEditorScreen(void)
  429. {
  430.     /*----------------------------------------------------------------*/
  431.     /* Local Variables                                                */
  432.     /*----------------------------------------------------------------*/
  434.     /*----------------------------------------------------------------*/
  435.     /* Code Body                                                      */
  436.     /*----------------------------------------------------------------*/
  437.     GoBackToHistory(SCR_DICTIONARY_WILDCARD_EXACT_EDITOR);
  438. }
  441. /*****************************************************************************
  442.  * FUNCTION
  443.  *  mmi_dictionary_entry_welcome_screen
  444.  * DESCRIPTION
  445.  *  Welcome screen, when user enter first time in this screen,a customer logo is shown.
  446.  * PARAMETERS
  447.  *  void
  448.  * RETURNS
  449.  *  void
  450.  *****************************************************************************/
  451. void mmi_dictionary_entry_welcome_screen(void)
  452. {
  453. #ifdef __MMI_DICTIONARY_WELCOME_SCREEN__
  454.     /*----------------------------------------------------------------*/
  455.     /* Local Variables                                                */
  456.     /*----------------------------------------------------------------*/
  457.     U8 *guiBuffer;
  459.     /*----------------------------------------------------------------*/
  460.     /* Code Body                                                      */
  461.     /*----------------------------------------------------------------*/
  462.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_WELCOME_SCREEN);
  463.     EntryNewScreen(SCR_DICTIONARY_WELCOME_SCREEN, NULL, mmi_dictionary_entry_welcome_screen, NULL);
  465.     ShowCategory129Screen(
  466.         (U8*) get_string(STR_DICTIONARY_TITLE),
  467.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  468.         STR_GLOBAL_OK,
  469.         IMG_GLOBAL_OK,
  470.         STR_GLOBAL_BACK,
  471.         IMG_GLOBAL_BACK,
  472.         IMG_DICTIONARY_LOGO,
  473.         guiBuffer);
  475.     SetLeftSoftkeyFunction(mmi_dictionary_pre_entry_main_screen, KEY_EVENT_UP);
  476.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  477. #else /* __MMI_DICTIONARY_WELCOME_SCREEN__ */ 
  478.     mmi_dictionary_pre_entry_main_screen();
  479. #endif /* __MMI_DICTIONARY_WELCOME_SCREEN__ */ 
  480. }
  483. /*****************************************************************************
  484.  * FUNCTION
  485.  *  mmi_dictionary_pre_entry_main_screen
  486.  * DESCRIPTION
  487.  *  initialize dictionary database
  488.  * PARAMETERS
  489.  *  void
  490.  * RETURNS
  491.  *  void
  492.  *****************************************************************************/
  493. void mmi_dictionary_pre_entry_main_screen(void)
  494. {
  495.     /*----------------------------------------------------------------*/
  496.     /* Local Variables                                                */
  497.     /*----------------------------------------------------------------*/
  498.     pBOOL dictResult;
  500.     /*----------------------------------------------------------------*/
  501.     /* Code Body                                                      */
  502.     /*----------------------------------------------------------------*/
  503.     dictResult = mmi_dict_init();
  505.     if (dictResult == FALSE)
  506.     {
  507.         PRINT_INFORMATION(("---[DictionaryMain.c] Failed to initialize Dictionary n"));
  508.         return;
  509.     }
  511.     mmi_dictionary_entry_main_screen();
  512. }
  515. /*****************************************************************************
  516.  * FUNCTION
  517.  *  mmi_dictionary_entry_main_screen
  518.  * DESCRIPTION
  519.  *  Entry function for main dictionary screen
  520.  * PARAMETERS
  521.  *  void
  522.  * RETURNS
  523.  *  void
  524.  *****************************************************************************/
  525. void mmi_dictionary_entry_main_screen(void)
  526. {
  527.     /*----------------------------------------------------------------*/
  528.     /* Local Variables                                                */
  529.     /*----------------------------------------------------------------*/
  530.     U8 *guiBuffer;
  531.     S32 cnt;
  532.     MMI_DICTIONARY_LANGUAGE currentLanguage;
  534.     /*----------------------------------------------------------------*/
  535.     /* Code Body                                                      */
  536.     /*----------------------------------------------------------------*/
  537.     g_dictionary_search_type = DICTIONARY_BROWSE;
  538.     g_dict_current_language = g_dictionary_language_main_screen;
  539.     g_dictionary_prev_index = -1;
  541.     EntryNewScreen(SCR_DICTIONARY_MAIN, mmi_dictionary_exit_main_screen, mmi_dictionary_entry_main_screen, NULL);
  542.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_MAIN);
  543.     RegisterCat200SearchFunction(mmi_dictionary_find_entry);
  544.     RegisterHighlightHandler(mmi_dictionary_word_hdlr);
  546.     if (guiBuffer == NULL)
  547.     {
  548.         memset(g_dict_chinese_ids, 0, sizeof(mmi_dict_id_str_struct) * (MMI_DICT_ID_FETCH_MAX + 1));
  549.         g_dictionary_cntx.current_selected_index = 0;
  550.         wgui_multiline_inputbox_input_type = 0;
  552.         /* Default language is English for first time entry */
  553.         g_dict_current_language = DICTIONARY_ENGLISH;
  555.         memset(g_dictionary_input_buffer, 0, ENCODING_LENGTH);
  557.         if (g_dict_current_language == DICTIONARY_ENGLISH)
  558.         {
  559.             AnsiiToUnicodeString((S8*) g_dictionary_input, (S8*) "a");
  560.             cnt = mmi_dict_exact_search_id(
  561.                     (PS8) g_dictionary_input,
  562.                     (U8) g_dict_current_language,
  563.                     (U8) ! g_dict_current_language);
  564.             g_dictionary_cntx.total_browse_entry = (S32) mmi_dict_get_total_num((PS8) g_dictionary_input);
  565.             g_dictionary_cntx.starting_index = cnt;
  566.         }
  567.         else if (g_dict_current_language == DICTIONARY_CHINESE)
  568.         {
  569.             g_dictionary_cntx.total_browse_entry = 0;
  570.             g_dictionary_cntx.starting_index = 0;
  571.         }
  572.         ClearKeyHandler(KEY_UP_ARROW, KEY_EVENT_DOWN);
  573.     }
  574.     else
  575.     {
  576.         memset(g_dictionary_last_word, 0, ENCODING_LENGTH);
  578.         /*
  579.          *  Previous input method is just set to any member of previous family. Here Family is important to know.
  580.          *  the assigned mode can be any mode from a family
  581.          */
  582.         switch (g_dict_current_language)
  583.         {
  584.             case DICTIONARY_ENGLISH:
  585.                 g_mmi_dictionary_prev_input_mode = INPUT_MODE_MULTITAP_LOWERCASE_ABC;
  586.                 break;
  587.             case DICTIONARY_CHINESE:
  588.                 g_mmi_dictionary_prev_input_mode = INPUT_MODE_TR_MULTITAP_BOPOMO;
  589.                 break;
  590.             default:
  591.                 g_mmi_dictionary_prev_input_mode = INPUT_MODE_MULTITAP_LOWERCASE_ABC;
  592.         }
  594.         /* 
  595.          *  wgui_multiline_inputbox_input_type =0 means set to none.
  596.          *  wgui_multiline_inputbox_input_type is set when input method is changed from "input method" option.
  597.          */
  598.         if (wgui_multiline_inputbox_input_type != 0)
  599.         {
  600.             currentLanguage = mmi_dictionary_check_input_family((U8) wgui_multiline_inputbox_input_type);
  602.             if (currentLanguage != g_dict_current_language)
  603.             {
  604.                 switch (currentLanguage)
  605.                 {
  606.                     case DICTIONARY_ENGLISH:
  607.                         AnsiiToUnicodeString((S8*) g_dictionary_input, (S8*) "a");
  608.                         cnt = mmi_dict_exact_search_id(
  609.                                 (PS8) g_dictionary_input,
  610.                                 (U8) g_dict_current_language,
  611.                                 (U8) ! g_dict_current_language);
  612.                         g_dictionary_cntx.total_browse_entry = (S32) mmi_dict_get_total_num((PS8) g_dictionary_input);
  613.                         g_dictionary_cntx.starting_index = cnt;
  614.                         break;
  615.                     case DICTIONARY_CHINESE:
  616.                         g_dictionary_cntx.total_browse_entry = 0;
  617.                         g_dictionary_cntx.starting_index = 0;
  618.                         break;
  619.                     default:
  620.                         g_dictionary_cntx.total_browse_entry = 0;
  621.                         g_dictionary_cntx.starting_index = 0;
  622.                 }
  624.             }
  625.         }
  626.     }
  628. #ifdef __MMI_UI_HINTS_IN_MENUITEM__
  629.     set_force_icon_on_highlight_only_in_menuitem();
  630. #endif 
  631.     Register_pound_key_buffer_flush_test_function(mmi_dictionary_flush_editor_buffer);
  632.     Register_appl_present_function(isFromDictionary);
  634. #ifdef __MMI_DICTIONARY_SMALL_SCREEN__
  635.     ShowCategory200Screen(
  636.         STR_DICTIONARY_TITLE,
  637.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  638.         STR_GLOBAL_OPTIONS,
  639.         IMG_GLOBAL_OPTIONS,
  640.         STR_GLOBAL_BACK,
  641.         IMG_GLOBAL_BACK,
  642.         g_dictionary_cntx.total_browse_entry,
  643.         mmi_dictionary_list_get_item,
  644.         NULL,
  645.         0,
  646.         IMG_DICTIONARY_SEARCH,
  647.         (U8*) g_dictionary_input_buffer,
  648.         DICTIONARY_INPUT_LENGTH + 1,
  649.         guiBuffer);
  651.     SetCategory200RightSoftkeyFunction(mmi_dictionary_exit_engine, KEY_EVENT_UP);
  653. #else /* __MMI_DICTIONARY_SMALL_SCREEN__ */ 
  655.     wgui_set_e_dictionary_test_clear_inputbox_buffer_funcptr(dictionary_dummy_function);
  656.     cat201_register_language_changed_indicator(IsDictionaryLanguageChanged);
  657.     ShowCategory201Screen(
  658.         STR_DICTIONARY_TITLE,
  659.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  660.         STR_GLOBAL_OPTIONS,
  661.         IMG_GLOBAL_OPTIONS,
  662.         STR_GLOBAL_BACK,
  663.         IMG_GLOBAL_BACK,
  664.         g_dictionary_cntx.total_browse_entry,
  665.         mmi_dictionary_list_get_item,
  666.         NULL,
  667.         0,
  668.         IMG_DICTIONARY_SEARCH,
  669.         (U8*) g_dictionary_input_buffer,
  670.         DICTIONARY_INPUT_LENGTH + 1,
  671.         INPUT_TYPE_ALPHANUMERIC_UPPERCASE,
  672.         guiBuffer,
  673.         g_dictionary_input_mode);
  675.     SetCategory201RightSoftkeyFunction(mmi_dictionary_exit_engine, KEY_EVENT_UP);
  677. #endif /* __MMI_DICTIONARY_SMALL_SCREEN__ */ 
  679.     g_mmi_dictionary_prev_input_mode = MMI_current_input_mode;
  681.     SetKeyHandler(mmi_dictionary_entry_result_screen, KEY_ENTER, KEY_EVENT_DOWN);
  682.     SetCategory200LeftSoftkeyFunction(mmi_dictionary_entry_main_option_screen, KEY_EVENT_UP);
  683.     SetLeftSoftkeyFunction(mmi_dictionary_entry_main_option_screen, KEY_EVENT_UP);
  684. }
  687. /*****************************************************************************
  688.  * FUNCTION
  689.  *  mmi_dictionary_exit_main_screen
  690.  * DESCRIPTION
  691.  *  Exit function for main screen
  692.  * PARAMETERS
  693.  *  void
  694.  * RETURNS
  695.  *  void
  696.  *****************************************************************************/
  697. void mmi_dictionary_exit_main_screen(void)
  698. {
  699.     /*----------------------------------------------------------------*/
  700.     /* Local Variables                                                */
  701.     /*----------------------------------------------------------------*/
  703.     /*----------------------------------------------------------------*/
  704.     /* Code Body                                                      */
  705.     /*----------------------------------------------------------------*/
  706.     memset(g_dictionary_last_word, 0, ENCODING_LENGTH);
  707.     memset(g_dictionary_first_displayed_buffer, 0, ENCODING_LENGTH);
  708.     g_dictionary_language_main_screen = g_dict_current_language;
  709.     g_dictionary_highlighted_item = DynamicListGetHighlightedItem((U8*) g_dictionary_last_word);
  710.     DynamicGetFirstDisplayedItem((U8*) g_dictionary_first_displayed_buffer);
  711.     g_dictionary_prev_index = -1;
  712. }
  715. /*****************************************************************************
  716.  * FUNCTION
  717.  *  dictionary_dummy_function
  718.  * DESCRIPTION
  719.  *  dummy function assigned
  720.  * PARAMETERS
  721.  *  void
  722.  * RETURNS
  723.  *  void
  724.  *****************************************************************************/
  725. pBOOL dictionary_dummy_function(void)
  726. {
  727.     /*----------------------------------------------------------------*/
  728.     /* Local Variables                                                */
  729.     /*----------------------------------------------------------------*/
  731.     /*----------------------------------------------------------------*/
  732.     /* Code Body                                                      */
  733.     /*----------------------------------------------------------------*/
  734.     return FALSE;
  735. }
  738. /*****************************************************************************
  739.  * FUNCTION
  740.  *  IsDictionaryLanguageChanged
  741.  * DESCRIPTION
  742.  *  This function tell the GUI layer if language has been changes while coming back from history
  743.  * PARAMETERS
  744.  *  input_type      [IN]        changed input type
  745.  * RETURNS
  746.  *  BOOL TRUE : language has been changed.
  747.  *  FALSE : language is not changed
  748.  *****************************************************************************/
  749. BOOL IsDictionaryLanguageChanged(U8 input_type)
  750. {
  751.     /*----------------------------------------------------------------*/
  752.     /* Local Variables                                                */
  753.     /*----------------------------------------------------------------*/
  754.     MMI_DICTIONARY_LANGUAGE currentLanguage;
  755.     pBOOL languageChanged = MMI_FALSE;
  757.     /*----------------------------------------------------------------*/
  758.     /* Code Body                                                      */
  759.     /*----------------------------------------------------------------*/
  760.     currentLanguage = mmi_dictionary_check_input_family((U8) input_type);
  762.     if (g_dict_current_language != currentLanguage)
  763.     {
  764.         languageChanged = MMI_TRUE;
  765.         memset(g_dictionary_input_buffer, 0, ENCODING_LENGTH);
  766.     }
  767.     else
  768.     {
  769.         languageChanged = MMI_FALSE;
  770.     }
  772.     switch (currentLanguage)
  773.     {
  774.         case DICTIONARY_ENGLISH:
  775.             g_dict_current_language = DICTIONARY_ENGLISH;
  776.             break;
  777.         case DICTIONARY_CHINESE:
  778.             g_dict_current_language = DICTIONARY_CHINESE;
  779.             break;
  780.         default:
  781.             g_dict_current_language = DICTIONARY_NONE;
  782.     }
  784.     return languageChanged;
  785. }
  788. /*****************************************************************************
  789.  * FUNCTION
  790.  *  mmi_dictionary_exit_engine
  791.  * DESCRIPTION
  792.  *  Exit function dictionary. Deinitilize dictionary memory
  793.  * PARAMETERS
  794.  *  void
  795.  * RETURNS
  796.  *  void
  797.  *****************************************************************************/
  798. void mmi_dictionary_exit_engine(void)
  799. {
  800.     /*----------------------------------------------------------------*/
  801.     /* Local Variables                                                */
  802.     /*----------------------------------------------------------------*/
  803.     pBOOL result;
  805.     /*----------------------------------------------------------------*/
  806.     /* Code Body                                                      */
  807.     /*----------------------------------------------------------------*/
  808.     result = mmi_dict_exit();
  809.     if (result == FALSE)
  810.     {
  811.         PRINT_INFORMATION(("---[DictionaryMain.c] Failed to De-initialize Dictionary n"));
  813.         /* return; */
  814.     }
  815.     GoBackHistory();
  816. }
  819. /*****************************************************************************
  820.  * FUNCTION
  821.  *  mmi_dictionary_word_hdlr
  822.  * DESCRIPTION
  823.  *  General highlight handler for word list in main dictionary screen
  824.  * PARAMETERS
  825.  *  index       [IN]        UI index of current selected word.
  826.  * RETURNS
  827.  *  void
  828.  *****************************************************************************/
  829. void mmi_dictionary_word_hdlr(S32 index)
  830. {
  831.     /*----------------------------------------------------------------*/
  832.     /* Local Variables                                                */
  833.     /*----------------------------------------------------------------*/
  834.     pBOOL result;
  835.     S32 dynamicItems;
  836.     U8 g_dictionary_output[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  838.     /*----------------------------------------------------------------*/
  839.     /* Code Body                                                      */
  840.     /*----------------------------------------------------------------*/
  841.     g_dictionary_cntx.current_selected_index = index;
  842.     g_dictionary_prev_index = index;
  843.     DynamicListGetHighlightedItem((U8*) g_dictionary_last_word);
  844.     dynamicItems = DynamicListGetItems(NULL, 0);
  845.     if (index <= 0)
  846.     {
  847.         ClearKeyHandler(KEY_UP_ARROW, KEY_EVENT_DOWN);
  848.         ClearKeyHandler(KEY_VOL_UP, KEY_EVENT_DOWN);
  849.         return;
  850.     }
  851.     else
  852.     {
  853.         SetKeyHandler(dynamic_list_goto_previous_item, KEY_UP_ARROW, KEY_EVENT_DOWN);
  854.         SetKeyHandler(dynamic_list_goto_previous_item, KEY_VOL_UP, KEY_EVENT_DOWN);
  855.     }
  857.     if (g_dict_current_language == DICTIONARY_ENGLISH)
  858.     {
  860.         if (g_dictionary_last_item || dynamicItems < 6)
  861.         {
  862.             return;
  863.         }
  865.         if (index >= (S32) (dynamicItems - 1))
  866.         {
  867.             /* this function is called to find out :whether further words exist in the word list */
  868.             result = mmi_dict_get_word_by_indx(
  869.                         (U8) g_dict_current_language,
  870.                         (U16) (g_dictionary_cntx.starting_index + index + 1),
  871.                         (S8*) g_dictionary_output);
  873.             if (result == TRUE)
  874.             {
  875.                 g_dictionary_last_item = FALSE;
  876.             }
  877.             else
  878.             {
  879.                 g_dictionary_last_item = TRUE;
  880.             }
  882.             g_dictionary_cntx.total_browse_entry++;
  883.             DynamicListIncreaseItem((S16) 1);
  885.         }
  886.     }
  888. }
  891. /*****************************************************************************
  892.  * FUNCTION
  893.  *  mmi_dictionary_list_get_item
  894.  * DESCRIPTION
  895.  *  Fill the UI list for display, on request from UI.
  896.  *  mmi_dict_exact_search_id/mmi_dict_exact_search_prev_id/mmi_dict_exact_search_next_id : set the focus to the word,
  897.  *  mmi_dict_get_word_by_indx : get the focused word
  898.  * PARAMETERS
  899.  *  item_index          [IN]        
  900.  *  str_buff            [IN]        
  901.  *  img_buff_p          [?]         
  902.  *  str_img_mask        [IN]        
  903.  * RETURNS
  904.  *  void
  905.  *****************************************************************************/
  906. pBOOL mmi_dictionary_list_get_item(S32 item_index, UI_string_type str_buff, PU8 *img_buff_p, U8 str_img_mask)
  907. {
  908.     /*----------------------------------------------------------------*/
  909.     /* Local Variables                                                */
  910.     /*----------------------------------------------------------------*/
  911.     U8 g_dictionary_output[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  912.     pBOOL result, bufferCheck;
  913.     S32 index = 0;
  914.     S32 steps;
  915.     U8 *guiBuffer;
  917.     /*----------------------------------------------------------------*/
  918.     /* Code Body                                                      */
  919.     /*----------------------------------------------------------------*/
  920.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_MAIN);
  921.     memset(g_dictionary_input, 0, ENCODING_LENGTH);
  923.     if (g_dict_current_language == DICTIONARY_ENGLISH)
  924.     {
  925.         /* there is no need to give first 32 elements while coming to history ,when highlighted item is > 35 */
  926.         if (guiBuffer && (g_dictionary_highlighted_item >= 35) && (item_index <= 31))
  927.         {
  928.             index = mmi_dict_exact_search_id(
  929.                         (PS8) g_dictionary_input,
  930.                         (U8) g_dict_current_language,
  931.                         (U8) ! g_dict_current_language);
  932.             str_buff = NULL;
  933.             *img_buff_p = get_image(IMG_DICTIONARY_WORD_LIST_SCREEN);
  934.             return TRUE;
  935.         }
  937.         /* While coming back from history, and UI gets the items to display */
  938.         if (guiBuffer && (item_index > 31))
  939.         {
  940.             steps = DynamicGetFirstDisplayedItem(NULL) - item_index;
  941.             pfnUnicodeStrcpy((S8*) g_dictionary_input, (S8*) g_dictionary_first_displayed_buffer);
  942.             if (steps > 0)
  943.             {
  944.                 index = mmi_dict_exact_search_prev_id(
  945.                             (PS8) g_dictionary_input,
  946.                             (steps),
  947.                             (U8) g_dict_current_language,
  948.                             (U8) ! g_dict_current_language);
  949.             }
  950.             else
  951.             {
  952.                 index = mmi_dict_exact_search_next_id(
  953.                             (PS8) g_dictionary_input,
  954.                             (-steps),
  955.                             (U8) g_dict_current_language,
  956.                             (U8) ! g_dict_current_language);
  957.             }
  959.         }
  960.         else if (item_index == 0)
  961.         {
  962.             pfnUnicodeStrcpy((S8*) g_dictionary_input, (S8*) g_dictionary_input_buffer);
  963.             bufferCheck = mmi_dictionary_check_input_buffer((U8*) g_dictionary_input, (U8) g_dict_current_language);
  965.             if (bufferCheck == TRUE)
  966.             {
  967.                 index = mmi_dict_exact_search_id(
  968.                             (PS8) g_dictionary_input,
  969.                             (U8) g_dict_current_language,
  970.                             (U8) ! g_dict_current_language);
  971.                 g_dictionary_cntx.starting_index = index;
  972.             }
  973.             else
  974.             {
  975.                 memset(g_dictionary_input, 0, ENCODING_LENGTH);
  976.                 AnsiiToUnicodeString((S8*) g_dictionary_input, "a");
  977.                 index = mmi_dict_exact_search_id(
  978.                             (PS8) g_dictionary_input,
  979.                             (U8) g_dict_current_language,
  980.                             (U8) ! g_dict_current_language);
  981.                 g_dictionary_cntx.starting_index = index;
  982.             }
  983.         }
  984.         else if (g_dictionary_prev_index > item_index)
  985.         {
  986.             memset(g_dictionary_input, 0, ENCODING_LENGTH);
  987.             /* get the dynamic element from UI. */
  988.             DynamicListGetItems((U8*) g_dictionary_input, (U16) (item_index + 1));
  989.             index = mmi_dict_exact_search_prev_id(
  990.                         (PS8) g_dictionary_input,
  991.                         1,
  992.                         (U8) g_dict_current_language,
  993.                         (U8) ! g_dict_current_language);
  994.         }
  995.         else if (g_dictionary_prev_index < item_index)
  996.         {
  997.             memset(g_dictionary_input, 0, ENCODING_LENGTH);
  998.             /* get the dynamic element from UI. */
  999.             DynamicListGetItems((U8*) g_dictionary_input, (U16) (item_index - 1));
  1000.             index = mmi_dict_exact_search_next_id(
  1001.                         (PS8) g_dictionary_input,
  1002.                         1,
  1003.                         (U8) g_dict_current_language,
  1004.                         (U8) ! g_dict_current_language);
  1005.         }
  1007.         memset(g_dictionary_output, 0, ENCODING_LENGTH);
  1008.         result = mmi_dict_get_word_by_indx((U8) g_dict_current_language, (U16) (index), (S8*) g_dictionary_output);
  1009.         pfnUnicodeStrcpy((S8*) str_buff, (S8*) g_dictionary_output);
  1010.         *img_buff_p = get_image(IMG_DICTIONARY_WORD_LIST_SCREEN);
  1012.         g_dictionary_prev_index = item_index;
  1014.         return TRUE;
  1015.     }
  1017. #ifndef __MMI_DICTIONARY_SMALL_SCREEN__
  1018.     if (g_dict_current_language == DICTIONARY_CHINESE)
  1019.     {
  1020.         if (item_index < g_dictionary_cntx.total_browse_entry)
  1021.         {
  1022.             pfnUnicodeStrcpy((S8*) str_buff, (S8*) g_dict_chinese_ids[item_index].dict_word);
  1023.             *img_buff_p = get_image(IMG_DICTIONARY_WORD_LIST_SCREEN);
  1024.             return TRUE;
  1026.         }
  1027.         return FALSE;
  1028.     }
  1029. #endif /* __MMI_DICTIONARY_SMALL_SCREEN__ */ 
  1030.     return FALSE;
  1032. }
  1035. /*****************************************************************************
  1036.  * FUNCTION
  1037.  *  mmi_dictionary_find_entry
  1038.  * DESCRIPTION
  1039.  *  Find the entries in dictionary based upon the input buffer.
  1040.  * PARAMETERS
  1041.  *  keyword     [?]     
  1042.  * RETURNS
  1043.  *  void
  1044.  *****************************************************************************/
  1045. S32 mmi_dictionary_find_entry(U8 *keyword)
  1046. {
  1047.     /*----------------------------------------------------------------*/
  1048.     /* Local Variables                                                */
  1049.     /*----------------------------------------------------------------*/
  1050.     S32 stringLength, cnt = 0;
  1051.     pBOOL bufferCheck;
  1053. #ifndef __MMI_DICTIONARY_SMALL_SCREEN__
  1054.     U16 resultCount;
  1055. #endif 
  1057.     /*----------------------------------------------------------------*/
  1058.     /* Code Body                                                      */
  1059.     /*----------------------------------------------------------------*/
  1060.     g_dictionary_last_item = FALSE;
  1061.     g_dictionary_prev_index = 0;
  1063.     switch (MMI_current_input_mode)
  1064.     {
  1065.     #ifndef __MMI_DICTIONARY_SMALL_SCREEN__
  1066.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1067.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1068.         case INPUT_MODE_SMART_UPPERCASE_ABC:
  1069.         case INPUT_MODE_SMART_LOWERCASE_ABC:
  1070.         case INPUT_MODE_MMI_LOWERCASE_ABC:
  1071.     #else /* __MMI_DICTIONARY_SMALL_SCREEN__ */ 
  1072.         case INPUT_MODE_MMI_LOWERCASE_ABC:
  1073.     #endif /* __MMI_DICTIONARY_SMALL_SCREEN__ */ 
  1074.         {
  1075.             stringLength = pfnUnicodeStrlen((S8*) keyword);
  1076.             g_dict_current_language = DICTIONARY_ENGLISH;
  1077.             memset(g_dictionary_input, 0, ENCODING_LENGTH);
  1079.             if (stringLength > 0)
  1080.             {
  1081.                 pfnUnicodeStrcpy((S8*) g_dictionary_input, (S8*) keyword);
  1082.                 bufferCheck = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1083.                 if (bufferCheck == FALSE)
  1084.                 {
  1085.                     /* First character  is not alphabet */
  1086.                     memset(g_dictionary_input, 0, ENCODING_LENGTH);
  1087.                     g_dictionary_cntx.starting_index = 0;
  1088.                     AnsiiToUnicodeString((S8*) g_dictionary_input, "a");
  1089.                     cnt = mmi_dict_exact_search_id(
  1090.                             (PS8) g_dictionary_input,
  1091.                             (U8) g_dict_current_language,
  1092.                             (U8) ! g_dict_current_language);
  1093.                     g_dictionary_cntx.total_browse_entry = mmi_dict_get_total_num((S8*) g_dictionary_input);
  1094.                     break;
  1095.                 }
  1097.                 cnt = mmi_dict_exact_search_id(
  1098.                         (PS8) g_dictionary_input,
  1099.                         (U8) g_dict_current_language,
  1100.                         (U8) ! g_dict_current_language);
  1101.                 g_dictionary_cntx.starting_index = cnt;
  1102.                 g_dictionary_cntx.total_browse_entry = mmi_dict_get_total_num((PS8) g_dictionary_input);
  1103.                 break;
  1104.             }
  1105.             else
  1106.             {
  1107.                 g_dict_current_language = DICTIONARY_ENGLISH;
  1108.                 memset(g_dictionary_input, 0, ENCODING_LENGTH);
  1109.                 AnsiiToUnicodeString((S8*) g_dictionary_input, "a");
  1110.                 cnt = mmi_dict_exact_search_id(
  1111.                         (PS8) g_dictionary_input,
  1112.                         (U8) g_dict_current_language,
  1113.                         (U8) ! g_dict_current_language);
  1114.                 g_dictionary_cntx.starting_index = cnt;
  1115.                 g_dictionary_cntx.total_browse_entry = mmi_dict_get_total_num((PS8) g_dictionary_input);
  1116.                 break;
  1117.             }
  1118.             break;
  1119.         }
  1121.     #ifndef __MMI_DICTIONARY_SMALL_SCREEN__
  1122.         case INPUT_MODE_TR_MULTITAP_BOPOMO:
  1123.         case INPUT_MODE_TR_STROKE:
  1124.         case INPUT_MODE_SM_MULTITAP_PINYIN:
  1125.         case INPUT_MODE_SM_STROKE:
  1126.         case INPUT_MODE_SM_PINYIN:
  1127.         case INPUT_MODE_TR_BOPOMO:
  1129.             g_dict_current_language = DICTIONARY_CHINESE;
  1130.             stringLength = pfnUnicodeStrlen((S8*) keyword);
  1131.             memset(g_dictionary_input, 0, ENCODING_LENGTH);
  1132.             memset(g_dict_chinese_ids, 0, sizeof(mmi_dict_id_str_struct) * (MMI_DICT_ID_FETCH_MAX + 1));
  1133.             g_dictionary_cntx.current_selected_index = 0;
  1134.             if (stringLength != 0)
  1135.             {
  1136.                 pfnUnicodeStrcpy((S8*) g_dictionary_input, (S8*) keyword);
  1137.                 bufferCheck = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1138.                 if (bufferCheck == FALSE)
  1139.                 {
  1140.                     /* First character  is not chinese character */
  1141.                     g_dictionary_cntx.starting_index = 0;
  1142.                     g_dictionary_cntx.total_browse_entry = 0;
  1143.                     break;
  1145.                 }
  1147.                 resultCount = mmi_dict_wild_search(
  1148.                                 (U8) g_dict_current_language,
  1149.                                 (S8*) g_dictionary_input,
  1150.                                 0,
  1151.                                 MMI_DICT_ID_FETCH_MAX,
  1152.                                 (void*)g_dict_chinese_ids);
  1153.                 g_dictionary_cntx.starting_index = 0;
  1154.                 g_dictionary_cntx.total_browse_entry = resultCount;
  1155.                 break;
  1156.             }
  1157.             else
  1158.             {
  1159.                 memset(g_dict_chinese_ids, 0, sizeof(mmi_dict_id_str_struct) * (MMI_DICT_ID_FETCH_MAX + 1));
  1160.                 g_dictionary_cntx.starting_index = 0;
  1161.                 g_dictionary_cntx.total_browse_entry = 0;
  1162.                 break;
  1163.             }
  1165.             break;
  1166.     #endif /* __MMI_DICTIONARY_SMALL_SCREEN__ */ /* ifndef  __MMI_DICTIONARY_SMALL_SCREEN__ */
  1167.         default:
  1168.             g_dict_current_language = DICTIONARY_NONE;
  1169.             g_dictionary_cntx.starting_index = 0;
  1170.             g_dictionary_cntx.total_browse_entry = 0;
  1171.             break;
  1172.     }
  1174.     return g_dictionary_cntx.total_browse_entry;
  1176. }
  1179. /*****************************************************************************
  1180.  * FUNCTION
  1181.  *  mmi_dictionary_entry_result_screen
  1182.  * DESCRIPTION
  1183.  *  Entry screen for result screen. Shows the meaning of word to the user.
  1184.  * PARAMETERS
  1185.  *  void
  1186.  * RETURNS
  1187.  *  void
  1188.  *****************************************************************************/
  1189. void mmi_dictionary_entry_result_screen(void)
  1190. {
  1191.     /*----------------------------------------------------------------*/
  1192.     /* Local Variables                                                */
  1193.     /*----------------------------------------------------------------*/
  1194.     S8 tempBuf[MMI_DICT_CORE_WORD_MAX * ENCODING_LENGTH];
  1195.     BOOL result = FALSE;
  1197.     /*----------------------------------------------------------------*/
  1198.     /* Code Body                                                      */
  1199.     /*----------------------------------------------------------------*/
  1200.     EntryNewScreen(SCR_DICTIONARY_RESULT, NULL, mmi_dictionary_entry_result_screen, NULL);
  1202.     memset(g_dictionary_result_buffer, 0, ENCODING_LENGTH);
  1203.     memset(&g_dict_fetchresult, 0, sizeof(mmi_dict_result_struct));
  1205.     DeleteScreenIfPresent(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1207.     switch (g_dictionary_search_type)
  1208.     {
  1209.         case DICTIONARY_BROWSE:
  1210.             if (g_dict_current_language == DICTIONARY_ENGLISH)
  1211.             {
  1212.                 result = mmi_dict_exact_search(
  1213.                             (S8*) g_dictionary_last_word,
  1214.                             (U8) g_dict_current_language,
  1215.                             (U8) (!g_dict_current_language),
  1216.                             MMI_DICT_SYNO | MMI_DICT_ANTO | MMI_DICT_SENTS,
  1217.                             &g_dict_fetchresult);
  1218.             }
  1219.             else if (g_dict_current_language == DICTIONARY_CHINESE)
  1220.             {
  1221.                 if (pfnUnicodeStrlen((S8*) g_dict_chinese_ids[g_dictionary_cntx.current_selected_index].dict_word))
  1222.                 {
  1223.                     result = mmi_dict_exact_search(
  1224.                                 (S8*) g_dict_chinese_ids[g_dictionary_cntx.current_selected_index]. dict_word,
  1225.                                 (U8) g_dict_current_language,
  1226.                                 (U8) (!g_dict_current_language),
  1227.                                 MMI_DICT_SYNO | MMI_DICT_ANTO | MMI_DICT_SENTS,
  1228.                                 &g_dict_fetchresult);
  1229.                 }
  1230.                 else
  1231.                 {
  1232.                     result = FALSE;
  1233.                 }
  1234.             }
  1235.             else
  1236.             {
  1237.                 result = FALSE;
  1238.             }
  1239.             break;
  1240.         case DICTIONARY_WILDCARD_SEARCH:
  1241.             result = mmi_dict_exact_search(
  1242.                         (S8*) g_dict_wildcard_ids[g_dictionary_cntx.current_wildcard_search_index]. dict_word,
  1243.                         (U8) g_dict_current_language,
  1244.                         (U8) (!g_dict_current_language),
  1245.                         MMI_DICT_SYNO | MMI_DICT_ANTO | MMI_DICT_SENTS,
  1246.                         &g_dict_fetchresult);
  1247.             break;
  1248.         case DICTIONARY_EXACT_SEARCH:
  1249.             result = mmi_dict_exact_search(
  1250.                         (S8*) g_dictionary_input,
  1251.                         (U8) g_dict_current_language,
  1252.                         (U8) (!g_dict_current_language),
  1253.                         MMI_DICT_SYNO | MMI_DICT_ANTO | MMI_DICT_SENTS,
  1254.                         &g_dict_fetchresult);
  1255.             break;
  1256.     }
  1258.     if (result == FALSE)
  1259.     {
  1260.         DisplayPopup(
  1261.             (PU8) GetString(STR_DICTIONARY_NO_MATCH_FOUND),
  1262.             IMG_GLOBAL_WARNING,
  1263.             FALSE,
  1264.             UI_POPUP_NOTIFYDURATION_TIME_2000,
  1265.             WARNING_TONE);
  1266.         DeleteNScrId(SCR_DICTIONARY_RESULT);
  1267.         return;
  1268.     }
  1270.     if (pfnUnicodeStrlen((S8*) g_dict_fetchresult.dict_word))
  1271.     {
  1272.         pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) g_dict_fetchresult.dict_word);
  1273.         pfnUnicodeStrcat((PS8) g_dictionary_result_buffer, (S8*) L"n");
  1274.     }
  1275.     pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) g_dict_fetchresult.dict_meaning);
  1277.     if (g_dict_current_language == DICTIONARY_ENGLISH)
  1278.     {
  1279.         if (g_dict_fetchresult.dict_synonym[0] != 0 || g_dict_fetchresult.dict_synonym[1] != 0)
  1280.         {
  1281.             pfnUnicodeStrcpy((S8*) tempBuf, (S8*) L"nn[");
  1282.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) GetString(STR_DICTIONARY_SYNONYMS));
  1283.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) L"]n");
  1285.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) tempBuf);
  1286.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) & g_dict_fetchresult.dict_synonym[2]);
  1287.         }
  1288.         if (g_dict_fetchresult.dict_antonym[0] != 0 || g_dict_fetchresult.dict_antonym[1] != 0)
  1289.         {
  1290.             pfnUnicodeStrcpy((S8*) tempBuf, (S8*) L"nn[");
  1291.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) GetString(STR_DICTIONARY_ANTONYMS));
  1292.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) L"]n");
  1294.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) tempBuf);
  1295.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) & g_dict_fetchresult.dict_antonym[2]);
  1296.         }
  1297.         if (g_dict_fetchresult.dict_example_sentence[0] != 0 || g_dict_fetchresult.dict_example_sentence[1] != 0)
  1298.         {
  1299.             pfnUnicodeStrcpy((S8*) tempBuf, (S8*) L"nn[");
  1300.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) GetString(STR_DICTIONARY_EXAMPLE_SENTENCE));
  1301.             pfnUnicodeStrcat((S8*) tempBuf, (S8*) L"]n");
  1303.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) tempBuf);
  1304.             pfnUnicodeStrcat((S8*) g_dictionary_result_buffer, (S8*) & g_dict_fetchresult.dict_example_sentence[2]);
  1305.         }
  1306.     }
  1308.     ShowCategory78Screen(
  1309.         STR_DICTIONARY_TITLE,
  1310.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  1311.         0,
  1312.         0,
  1313.         STR_GLOBAL_BACK,
  1314.         IMG_GLOBAL_BACK,
  1315.         NULL,
  1316.         (U8*) g_dictionary_result_buffer,
  1317.         pfnUnicodeStrlen((S8*) g_dictionary_result_buffer),
  1318.         NULL /* guiBuffer */ );
  1320.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1321.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1322. }
  1325. /*****************************************************************************
  1326.  * FUNCTION
  1327.  *  mmi_dictionary_entry_main_option_screen
  1328.  * DESCRIPTION
  1329.  *  Entry screen for dictionary option  screen.
  1330.  * PARAMETERS
  1331.  *  void
  1332.  * RETURNS
  1333.  *  void
  1334.  *****************************************************************************/
  1335. void mmi_dictionary_entry_main_option_screen(void)
  1336. {
  1337.     /*----------------------------------------------------------------*/
  1338.     /* Local Variables                                                */
  1339.     /*----------------------------------------------------------------*/
  1340.     U8 *guiBuffer;
  1341.     U16 nStrItemList[4];    /* Need Expansion when has more options. */
  1342.     U16 nNumofItem;
  1344.     /*----------------------------------------------------------------*/
  1345.     /* Code Body                                                      */
  1346.     /*----------------------------------------------------------------*/
  1347.     EntryNewScreen(SCR_DICTIONARY_OPTION, NULL, mmi_dictionary_entry_main_option_screen, NULL);
  1348.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_OPTION);
  1349.     nNumofItem = GetNumOfChild(DICTIONARY_OPTION_MENU);
  1350.     GetSequenceStringIds(DICTIONARY_OPTION_MENU, nStrItemList);
  1351.     SetParentHandler(DICTIONARY_OPTION_MENU);
  1352.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  1353.     ShowCategory15Screen(
  1354.         STR_GLOBAL_OPTIONS,
  1355.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  1356.         STR_GLOBAL_OK,
  1357.         IMG_GLOBAL_OK,
  1358.         STR_GLOBAL_BACK,
  1359.         IMG_GLOBAL_BACK,
  1360.         nNumofItem,
  1361.         nStrItemList,
  1362.         (U16*) gIndexIconsImageList,
  1363.         LIST_MENU,
  1364.         0,
  1365.         guiBuffer);
  1367.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1368.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1369. }
  1372. /*****************************************************************************
  1373.  * FUNCTION
  1374.  *  mmi_dictionary_entry_wildcard_exact_editor_screen
  1375.  * DESCRIPTION
  1376.  *  Entry screen for wildcard, exact and chinese string search
  1377.  * PARAMETERS
  1378.  *  void
  1379.  * RETURNS
  1380.  *  void
  1381.  *****************************************************************************/
  1382. void mmi_dictionary_entry_wildcard_exact_editor_screen(void)
  1383. {
  1384.     /*----------------------------------------------------------------*/
  1385.     /* Local Variables                                                */
  1386.     /*----------------------------------------------------------------*/
  1387.     U8 *guiBuffer;
  1388.     U16 strID = 0;
  1390.     /*----------------------------------------------------------------*/
  1391.     /* Code Body                                                      */
  1392.     /*----------------------------------------------------------------*/
  1393.     EntryNewScreen(
  1394.         SCR_DICTIONARY_WILDCARD_EXACT_EDITOR,
  1395.         mmi_dictionary_exit_wildcard_exact_editor_screen,
  1396.         mmi_dictionary_entry_wildcard_exact_editor_screen,
  1397.         NULL);
  1398.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_WILDCARD_EXACT_EDITOR);
  1400.     switch (g_dictionary_search_type)
  1401.     {
  1402.         case DICTIONARY_WILDCARD_SEARCH:
  1403.     #ifdef __MMI_DICT_GV__
  1404.             strID = STR_DICTIONARY_WILDCARD_SEARCH;
  1405.     #else 
  1406.             strID = STR_DICTIONARY_CHINESE_STRING;
  1407.     #endif 
  1409.             break;
  1410.         case DICTIONARY_EXACT_SEARCH:
  1411.             strID = STR_DICTIONARY_EXACT_SEARCH;
  1412.             break;
  1413.     }
  1415.     Register_cat5_editor_buffer_need_flush(mmi_dictionary_flush_exact_wild_editor_buffer);
  1416.     ShowCategory5Screen_ext(
  1417.         strID,
  1418.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  1419.         STR_GLOBAL_OPTIONS,
  1420.         IMG_GLOBAL_OPTIONS,
  1421.         STR_GLOBAL_BACK,
  1422.         IMG_GLOBAL_BACK,
  1423.         INPUT_TYPE_ALPHANUMERIC_UPPERCASE,
  1424.         (PU8) g_dictionary_wildcard_exact_buffer,
  1425.         DICTIONARY_INPUT_LENGTH + 1,
  1426.         guiBuffer,
  1427.         0,
  1428.         g_dictionary_input_mode,
  1429.         NULL);
  1431.     SetLeftSoftkeyFunction(mmi_dictionary_entry_editor_option_screen, KEY_EVENT_UP);
  1432.     SetKeyHandler(mmi_dictionary_entry_editor_option_screen, KEY_SEND, KEY_EVENT_UP);
  1434.     SetCategory5RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1435.     g_mmi_dictionary_prev_input_mode = MMI_current_input_mode;
  1436. }
  1439. /*****************************************************************************
  1440.  * FUNCTION
  1441.  *  mmi_dictionary_exit_wildcard_exact_editor_screen
  1442.  * DESCRIPTION
  1443.  *  Exit function for exact/wildcard buffer
  1444.  * PARAMETERS
  1445.  *  void
  1446.  * RETURNS
  1447.  *  void
  1448.  *****************************************************************************/
  1449. void mmi_dictionary_exit_wildcard_exact_editor_screen(void)
  1450. {
  1451.     /*----------------------------------------------------------------*/
  1452.     /* Local Variables                                                */
  1453.     /*----------------------------------------------------------------*/
  1455.     /*----------------------------------------------------------------*/
  1456.     /* Code Body                                                      */
  1457.     /*----------------------------------------------------------------*/
  1458.     wgui_multiline_inputbox_input_type = 0;
  1459. }
  1462. /*****************************************************************************
  1463.  * FUNCTION
  1464.  *  mmi_dictionary_entry_editor_option_screen
  1465.  * DESCRIPTION
  1466.  *  Entry function for editor option screen
  1467.  * PARAMETERS
  1468.  *  void
  1469.  * RETURNS
  1470.  *  void
  1471.  *****************************************************************************/
  1472. void mmi_dictionary_entry_editor_option_screen(void)
  1473. {
  1474.     /*----------------------------------------------------------------*/
  1475.     /* Local Variables                                                */
  1476.     /*----------------------------------------------------------------*/
  1477.     U16 nStrItemList[2];    /* Stores the strings id of submenus returned */
  1478.     U16 nNumofItem;         /* Stores no of children in the submenu */
  1479.     U8 *guiBuffer;          /* Buffer holding history data */
  1481.     /*----------------------------------------------------------------*/
  1482.     /* Code Body                                                      */
  1483.     /*----------------------------------------------------------------*/
  1484.     EntryNewScreen(SCR_DICTIONARY_EDITOR_OPTION_SCREEN, NULL, mmi_dictionary_entry_editor_option_screen, NULL);
  1486.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1487.     nNumofItem = GetNumOfChild(DICTIONARY_EDITOR_OPTION_MENU);
  1488.     GetSequenceStringIds(DICTIONARY_EDITOR_OPTION_MENU, nStrItemList);
  1489.     SetParentHandler(DICTIONARY_EDITOR_OPTION_MENU);
  1491.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  1493.     ShowCategory15Screen(
  1494.         STR_GLOBAL_OPTIONS,
  1495.         GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  1496.         STR_GLOBAL_OK,
  1497.         IMG_GLOBAL_OK,
  1498.         STR_GLOBAL_BACK,
  1499.         IMG_GLOBAL_BACK,
  1500.         nNumofItem,
  1501.         nStrItemList,
  1502.         (U16*) gIndexIconsImageList,
  1503.         LIST_MENU,
  1504.         0,
  1505.         guiBuffer);
  1507.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1508.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1509. }
  1512. /*****************************************************************************
  1513.  * FUNCTION
  1514.  *  mmi_dictionary_entry_search
  1515.  * DESCRIPTION
  1516.  *  This function search the database according to input in wildcard/exact search buffer
  1517.  * PARAMETERS
  1518.  *  void
  1519.  * RETURNS
  1520.  *  void
  1521.  *****************************************************************************/
  1522. void mmi_dictionary_entry_search(void)
  1523. {
  1524.     /*----------------------------------------------------------------*/
  1525.     /* Local Variables                                                */
  1526.     /*----------------------------------------------------------------*/
  1527.     S32 cnt = 0, resultCount = 0;
  1528.     U8 length;
  1529.     pBOOL result = TRUE;
  1531.     /*----------------------------------------------------------------*/
  1532.     /* Code Body                                                      */
  1533.     /*----------------------------------------------------------------*/
  1534.     length = pfnUnicodeStrlen((S8*) g_dictionary_wildcard_exact_buffer);
  1536.     length = length * 2;
  1537.     if (length == 0)
  1538.     {
  1539.         DisplayPopup(
  1540.             (PU8) GetString(STR_DICTIONARY_NO_MATCH_FOUND),
  1541.             IMG_GLOBAL_WARNING,
  1542.             FALSE,
  1543.             UI_POPUP_NOTIFYDURATION_TIME_2000,
  1544.             WARNING_TONE);
  1545.         DeleteNScrId(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1546.         return;
  1547.     }
  1548.     pfnUnicodeStrcpy((S8*) g_dictionary_input, (S8*) g_dictionary_wildcard_exact_buffer);
  1550.     if (g_dictionary_search_type == DICTIONARY_WILDCARD_SEARCH)
  1551.     {
  1552.         switch (MMI_current_input_mode)
  1553.         {
  1554.             case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1555.             case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1556.             case INPUT_MODE_SMART_UPPERCASE_ABC:
  1557.             case INPUT_MODE_SMART_LOWERCASE_ABC:
  1558.                 /* clean the string .check: for english string only */
  1560.                 g_dict_current_language = DICTIONARY_ENGLISH;
  1561.                 result = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1562.                 if (result == FALSE)
  1563.                 {
  1564.                     break;
  1565.                 }
  1567.                 memset(g_dict_wildcard_ids, 0, sizeof(mmi_dict_id_str_struct) * (MMI_DICT_ID_FETCH_MAX + 1));
  1568.                 /* DictionaryWaitingPopup(IMG_DICTIONARY_WAIT); */
  1569.                 resultCount = mmi_dict_wild_search(
  1570.                                 (U8) g_dict_current_language,
  1571.                                 (S8*) g_dictionary_input,
  1572.                                 0,
  1573.                                 MMI_DICT_ID_FETCH_MAX,
  1574.                                 (void*)g_dict_wildcard_ids);
  1575.                 if (resultCount != 0)
  1576.                 {
  1577.                     g_dictionary_cntx.wildcard_results = resultCount;
  1578.                     mmi_dictionary_entry_wildcard_result_list_screen();
  1579.                 }
  1580.                 break;
  1582.             case INPUT_MODE_TR_MULTITAP_BOPOMO:
  1583.             case INPUT_MODE_TR_STROKE:
  1584.             case INPUT_MODE_SM_MULTITAP_PINYIN:
  1585.             case INPUT_MODE_SM_STROKE:
  1586.             case INPUT_MODE_SM_PINYIN:
  1587.             case INPUT_MODE_TR_BOPOMO:
  1588.                 /* clean the string .check: for chinese string only  */
  1589.                 g_dict_current_language = DICTIONARY_CHINESE;
  1590.                 result = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1591.                 if (result == FALSE)
  1592.                 {
  1593.                     break;
  1594.                 }
  1596.                 memset(g_dict_wildcard_ids, 0, sizeof(mmi_dict_id_str_struct) * (MMI_DICT_ID_FETCH_MAX + 1));
  1597.                 /* DictionaryWaitingPopup(IMG_DICTIONARY_WAIT); */
  1598.                 resultCount = mmi_dict_wild_search(
  1599.                                 (U8) g_dict_current_language,
  1600.                                 (S8*) g_dictionary_input,
  1601.                                 0,
  1602.                                 MMI_DICT_ID_FETCH_MAX,
  1603.                                 (void*) /* g_dict_chinese_ids */ g_dict_wildcard_ids);
  1604.                 if (resultCount != 0)
  1605.                 {
  1606.                     g_dictionary_cntx.wildcard_results = resultCount;
  1607.                     mmi_dictionary_entry_wildcard_result_list_screen();
  1609.                 }
  1610.                 break;
  1612.             default:
  1613.                 DisplayPopup(
  1614.                     (PU8) GetString(STR_DICTIONARY_LANGUAGE_NOT_SUPPORTED),
  1615.                     IMG_GLOBAL_WARNING,
  1616.                     FALSE,
  1617.                     UI_POPUP_NOTIFYDURATION_TIME_2000,
  1618.                     WARNING_TONE);
  1619.                 DeleteNScrId(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1620.                 break;
  1622.         }
  1623.         if (resultCount == 0)
  1624.         {
  1625.             DisplayPopup(
  1626.                 (PU8) GetString(STR_DICTIONARY_NO_MATCH_FOUND),
  1627.                 IMG_GLOBAL_WARNING,
  1628.                 FALSE,
  1629.                 UI_POPUP_NOTIFYDURATION_TIME_2000,
  1630.                 WARNING_TONE);
  1631.             DeleteNScrId(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1632.         }
  1633.     }
  1634.     else if (g_dictionary_search_type == DICTIONARY_EXACT_SEARCH)
  1635.     {
  1636.         switch (MMI_current_input_mode)
  1637.         {
  1638.             case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1639.             case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1640.             case INPUT_MODE_SMART_UPPERCASE_ABC:
  1641.             case INPUT_MODE_SMART_LOWERCASE_ABC:
  1642.                 /* clean the string  */
  1643.                 g_dict_current_language = DICTIONARY_ENGLISH;
  1644.                 result = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1645.                 if (result == FALSE)
  1646.                 {
  1647.                     break;
  1648.                 }
  1649.                 /* DictionaryWaitingPopup(IMG_DICTIONARY_WAIT); */
  1650.                 mmi_dictionary_entry_result_screen();
  1651.                 break;
  1652.             case INPUT_MODE_TR_MULTITAP_BOPOMO:
  1653.             case INPUT_MODE_TR_STROKE:
  1654.             case INPUT_MODE_SM_MULTITAP_PINYIN:
  1655.             case INPUT_MODE_SM_STROKE:
  1656.             case INPUT_MODE_SM_PINYIN:
  1657.             case INPUT_MODE_TR_BOPOMO:
  1658.                 /* clean the string */
  1659.                 g_dict_current_language = DICTIONARY_CHINESE;
  1660.                 result = mmi_dictionary_check_input_buffer(g_dictionary_input, (U8) g_dict_current_language);
  1661.                 if (result == FALSE)
  1662.                 {
  1663.                     break;
  1664.                 }
  1665.                 /* DictionaryWaitingPopup(IMG_DICTIONARY_WAIT); */
  1666.                 mmi_dictionary_entry_result_screen();
  1667.                 break;
  1668.             default:
  1669.                 DisplayPopup(
  1670.                     (PU8) GetString(STR_DICTIONARY_LANGUAGE_NOT_SUPPORTED),
  1671.                     IMG_GLOBAL_WARNING,
  1672.                     FALSE,
  1673.                     UI_POPUP_NOTIFYDURATION_TIME_2000,
  1674.                     WARNING_TONE);
  1675.                 DeleteNScrId(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1676.                 break;
  1677.         }
  1678.     }
  1680.     /* result popup */
  1681.     if (result == FALSE)
  1682.     {
  1683.         DisplayPopup(
  1684.             (PU8) GetString(STR_DICTIONARY_NO_MATCH_FOUND),
  1685.             IMG_GLOBAL_WARNING,
  1686.             FALSE,
  1687.             UI_POPUP_NOTIFYDURATION_TIME_2000,
  1688.             WARNING_TONE);
  1689.         DeleteNScrId(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1690.     }
  1692.     return;
  1694. }
  1697. /*****************************************************************************
  1698.  * FUNCTION
  1699.  *  mmi_dictionary_check_input_buffer
  1700.  * DESCRIPTION
  1701.  *  This function check the input buffer according to language passed
  1702.  * PARAMETERS
  1703.  *  inputBuffer     [?]         
  1704.  *  language        [IN]        
  1705.  * RETURNS
  1706.  *  void
  1707.  *****************************************************************************/
  1708. pBOOL mmi_dictionary_check_input_buffer(U8 *inputBuffer, U8 language)
  1709. {
  1710.     /*----------------------------------------------------------------*/
  1711.     /* Local Variables                                                */
  1712.     /*----------------------------------------------------------------*/
  1713.     U8 length, cnt = 0;
  1714.     S16 end_cnt;
  1715.     U8 tempBuf[(MMI_DICT_CORE_WORD_MAX + 1) * ENCODING_LENGTH];
  1716.     U16 chineseCode;
  1718.     /*----------------------------------------------------------------*/
  1719.     /* Code Body                                                      */
  1720.     /*----------------------------------------------------------------*/
  1721.     /* filter out any space in the beginning */
  1722.     pfnUnicodeStrcpy((S8*) tempBuf, (S8*) inputBuffer);
  1723.     length = pfnUnicodeStrlen((S8*) inputBuffer);
  1724.     length = length * ENCODING_LENGTH;
  1725.     while (length > cnt)
  1726.     {
  1727.         if ((tempBuf[cnt] == 0x20) && (tempBuf[cnt + 1] == 0x00))       /* if first character is space */
  1728.         {
  1729.             cnt = cnt + 2;
  1730.             continue;
  1731.         }
  1732.         else
  1733.         {
  1734.             break;
  1735.         }
  1736.     }
  1738.     if (cnt == length)
  1739.     {
  1740.         /* user has entered only spaces in editor screen */
  1741.         return FALSE;
  1742.     }
  1744.     /* filter out any space in the end */
  1745.     end_cnt = length - 1;
  1746.     while (end_cnt > 0)
  1747.     {
  1748.         if ((tempBuf[end_cnt - 1] == 0x20) && (tempBuf[end_cnt] == 0x00))
  1749.         {
  1750.             end_cnt = end_cnt - 2;
  1751.         }
  1752.         else
  1753.         {
  1754.             break;
  1755.         }
  1756.     }
  1757.     memset(&tempBuf[end_cnt + 1], 0, 2);
  1759.     if (cnt != length)
  1760.     {
  1761.         pfnUnicodeStrcpy((S8*) inputBuffer, (S8*) & tempBuf[cnt]);    /* copy after intitial space */
  1763.         switch (language)
  1764.         {
  1765.             case DICTIONARY_ENGLISH:
  1767.                 /* first char have to be  english alphabet only */
  1768.                 if (!((inputBuffer[0] >= 65) && (inputBuffer[0] <= 90))
  1769.                     && !((inputBuffer[0] >= 97) && (inputBuffer[0] <= 122)))
  1770.                 {
  1771.                     return FALSE;
  1772.                 }
  1773.                 /* there should not be any chinese character in english string */
  1774.                 if (GetUCS2Flag((S8*) inputBuffer))
  1775.                 {
  1776.                     return FALSE;
  1777.                 }
  1778.                 break;
  1780.             case DICTIONARY_CHINESE:
  1782.                 memcpy(&chineseCode, &inputBuffer[0], 2);
  1783.                 if ((chineseCode < 0x4e00) || (chineseCode > 0x9fa5))
  1784.                 {
  1785.                     /* First character  is not chinese character */
  1786.                     return FALSE;
  1787.                 }
  1789.                 break;
  1791.         }
  1793.     }
  1794.     return TRUE;
  1796. }
  1799. /*****************************************************************************
  1800.  * FUNCTION
  1801.  *  mmi_dictionary_entry_wildcard_result_list_screen
  1802.  * DESCRIPTION
  1803.  *  This function shows the search result of wildcard and chinese search strings
  1804.  * PARAMETERS
  1805.  *  void
  1806.  * RETURNS
  1807.  *  void
  1808.  *****************************************************************************/
  1809. void mmi_dictionary_entry_wildcard_result_list_screen(void)
  1810. {
  1811.     /*----------------------------------------------------------------*/
  1812.     /* Local Variables                                                */
  1813.     /*----------------------------------------------------------------*/
  1814.     U8 *guiBuffer;
  1816.     /*----------------------------------------------------------------*/
  1817.     /* Code Body                                                      */
  1818.     /*----------------------------------------------------------------*/
  1819.     EntryNewScreen(SCR_DICTIONARY_WILDCARD_RESULT_LIST, NULL, mmi_dictionary_entry_wildcard_result_list_screen, NULL);
  1820.     guiBuffer = GetCurrGuiBuffer(SCR_DICTIONARY_WILDCARD_RESULT_LIST);
  1821.     RegisterHighlightHandler(mmi_dictionary_wildcard_word_list_hdlr);
  1822.     DeleteScreenIfPresent(SCR_DICTIONARY_EDITOR_OPTION_SCREEN);
  1823.     ShowCategory184Screen(
  1824. #ifdef __MMI_DICT_GV__
  1825.                              STR_DICTIONARY_WILDCARD_SEARCH,
  1826. #else 
  1827.                              STR_DICTIONARY_CHINESE_STRING,
  1828. #endif 
  1829.                              GetRootTitleIcon(EXTRA_DICTIONARY_MENU),
  1830.                              STR_GLOBAL_OK,
  1831.                              IMG_GLOBAL_OK,
  1832.                              STR_GLOBAL_BACK,
  1833.                              IMG_GLOBAL_BACK, g_dictionary_cntx.wildcard_results, mmi_dictionary_wildcard_list_get_item,
  1834.                              /* HintPtr */ 0,
  1835.                              0, guiBuffer);
  1837.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1838.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1839.     SetLeftSoftkeyFunction(mmi_dictionary_entry_result_screen, KEY_EVENT_UP);
  1840.     SetKeyHandler(mmi_dictionary_entry_result_screen, KEY_ENTER, KEY_EVENT_DOWN);
  1841. }
  1844. /*****************************************************************************
  1845.  * FUNCTION
  1846.  *  mmi_dictionary_wildcard_list_get_item
  1847.  * DESCRIPTION
  1848.  *  This function is to pass the wildcard and chinese strings to the UI to display
  1849.  * PARAMETERS
  1850.  *  item_index          [IN]        
  1851.  *  str_buff            [IN]        
  1852.  *  img_buff_p          [?]         
  1853.  *  str_img_mask        [IN]        
  1854.  * RETURNS
  1855.  *  void
  1856.  *****************************************************************************/
  1857. pBOOL mmi_dictionary_wildcard_list_get_item(S32 item_index, UI_string_type str_buff, PU8 *img_buff_p, U8 str_img_mask)
  1858. {
  1859.     /*----------------------------------------------------------------*/
  1860.     /* Local Variables                                                */
  1861.     /*----------------------------------------------------------------*/
  1863.     /*----------------------------------------------------------------*/
  1864.     /* Code Body                                                      */
  1865.     /*----------------------------------------------------------------*/
  1866.     if (item_index < g_dictionary_cntx.wildcard_results)
  1867.     {
  1869.         pfnUnicodeStrcpy((S8*) str_buff, (S8*) g_dict_wildcard_ids[item_index].dict_word);
  1870.         *img_buff_p = get_image(IMG_DICTIONARY_WORD_LIST_SCREEN);
  1871.         return TRUE;
  1872.     }
  1873.     else
  1874.     {
  1875.         return FALSE;
  1876.     }
  1877. }
  1880. /*****************************************************************************
  1881.  * FUNCTION
  1882.  *  mmi_dictionary_wildcard_word_list_hdlr
  1883.  * DESCRIPTION
  1884.  *  This function is the highlight handler for words in wildcard and chinese search list
  1885.  * PARAMETERS
  1886.  *  index       [IN]        
  1887.  * RETURNS
  1888.  *  void
  1889.  *****************************************************************************/
  1890. void mmi_dictionary_wildcard_word_list_hdlr(S32 index)
  1891. {
  1892.     /*----------------------------------------------------------------*/
  1893.     /* Local Variables                                                */
  1894.     /*----------------------------------------------------------------*/
  1896.     /*----------------------------------------------------------------*/
  1897.     /* Code Body                                                      */
  1898.     /*----------------------------------------------------------------*/
  1899.     g_dictionary_cntx.current_wildcard_search_index = index;
  1900.     return;
  1901. }
  1904. /*****************************************************************************
  1905.  * FUNCTION
  1906.  *  isFromDictionary
  1907.  * DESCRIPTION
  1908.  *  This function returns to the UI whether control has come from dictionary or not
  1909.  *  vice versa
  1910.  * PARAMETERS
  1911.  *  max_number      [?]     
  1912.  * RETURNS
  1913.  *  pBOOL : TRUE :From dictionary
  1914.  *  FALSE : Not from the dictionary
  1915.  *****************************************************************************/
  1916. BOOL isFromDictionary(S32 *max_number)
  1917. {
  1918.     /*----------------------------------------------------------------*/
  1919.     /* Local Variables                                                */
  1920.     /*----------------------------------------------------------------*/
  1921.     U16 scrID;
  1922.     BOOL scrPresent;
  1924.     /*----------------------------------------------------------------*/
  1925.     /* Code Body                                                      */
  1926.     /*----------------------------------------------------------------*/
  1927.     scrID = GetActiveScreenId();
  1928.     scrPresent = IsScreenPresent(SCR_DICTIONARY_MAIN);
  1929.     if (scrID == SCR_DICTIONARY_MAIN || scrPresent)
  1930.     {
  1931.         *max_number = DICTIONARY_MAX_WORDS;
  1932.         return MMI_TRUE;
  1934.     }
  1935.     else
  1936.     {
  1937.         *max_number = 0;
  1938.         return MMI_FALSE;
  1940.     }
  1942. }
  1945. /*****************************************************************************
  1946.  * FUNCTION
  1947.  *  mmi_dictionary_flush_editor_buffer
  1948.  * DESCRIPTION
  1949.  *  This function is  to flush buffer when user change input method, from english family to chinese
  1950.  *  vice versa
  1951.  * PARAMETERS
  1952.  *  void
  1953.  * RETURNS
  1954.  *  pBOOL : TRUE :Family has been changed. Flush the buffer
  1955.  *  FALSE : Need to flush the output.
  1956.  *****************************************************************************/
  1957. BOOL mmi_dictionary_flush_editor_buffer()
  1958. {
  1959.     /*----------------------------------------------------------------*/
  1960.     /* Local Variables                                                */
  1961.     /*----------------------------------------------------------------*/
  1963.     BOOL isOldFamily, scrPresent;
  1964.     U16 activeScrID;
  1966.     /*----------------------------------------------------------------*/
  1967.     /* Code Body                                                      */
  1968.     /*----------------------------------------------------------------*/
  1969.     activeScrID = GetActiveScreenId();
  1970.     scrPresent = IsScreenPresent(SCR_DICTIONARY_MAIN);
  1972.     if (activeScrID == SCR_INPUT_METHOD_LIST)
  1973.     {
  1974.         if (!scrPresent)
  1975.         {
  1976.             return MMI_FALSE;
  1977.         }
  1979.     }
  1980.     else if (!(activeScrID == SCR_DICTIONARY_WILDCARD_EXACT_EDITOR || activeScrID == SCR_DICTIONARY_MAIN))
  1981.     {
  1982.         return MMI_FALSE;
  1983.     }
  1985.     switch (g_mmi_dictionary_prev_input_mode)
  1986.     {
  1987.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1988.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1989.         case INPUT_MODE_SMART_UPPERCASE_ABC:
  1990.         case INPUT_MODE_SMART_LOWERCASE_ABC:
  1991.             switch (MMI_current_input_mode)
  1992.             {
  1993.                 case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1994.                 case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1995.                 case INPUT_MODE_SMART_UPPERCASE_ABC:
  1996.                 case INPUT_MODE_SMART_LOWERCASE_ABC:
  1997.                     isOldFamily = MMI_TRUE;
  1998.                     break;
  1999.                 default:
  2000.                     isOldFamily = MMI_FALSE;
  2002.             }
  2003.             break;
  2004.         case INPUT_MODE_TR_MULTITAP_BOPOMO:
  2005.         case INPUT_MODE_TR_STROKE:
  2006.         case INPUT_MODE_SM_MULTITAP_PINYIN:
  2007.         case INPUT_MODE_SM_STROKE:
  2008.         case INPUT_MODE_SM_PINYIN:
  2009.         case INPUT_MODE_TR_BOPOMO:
  2010.             switch (MMI_current_input_mode)
  2011.             {
  2012.                 case INPUT_MODE_TR_MULTITAP_BOPOMO:
  2013.                 case INPUT_MODE_TR_STROKE:
  2014.                 case INPUT_MODE_SM_MULTITAP_PINYIN:
  2015.                 case INPUT_MODE_SM_STROKE:
  2016.                 case INPUT_MODE_SM_PINYIN:
  2017.                 case INPUT_MODE_TR_BOPOMO:
  2018.                     isOldFamily = MMI_TRUE;
  2019.                     break;
  2020.                 default:
  2021.                     isOldFamily = MMI_FALSE;
  2023.             }
  2024.             break;
  2025.         default:
  2026.             isOldFamily = MMI_FALSE;
  2027.     }
  2029.     g_mmi_dictionary_prev_input_mode = MMI_current_input_mode;
  2031.     if (isOldFamily)
  2032.     {
  2033.         return MMI_FALSE;
  2034.     }
  2035.     else
  2036.     {
  2037.         return MMI_TRUE;
  2039.     }
  2041. }
  2044. /*****************************************************************************
  2045.  * FUNCTION
  2046.  *  mmi_dictionary_check_input_family
  2047.  * DESCRIPTION
  2048.  *  This function is  return the input family type
  2049.  * PARAMETERS
  2050.  *  inputType       [IN]        
  2051.  *  input type(?)
  2052.  * RETURNS
  2053.  *  MMI_DICTIONARY_LANGUAGE : english/chinese/none
  2054.  *****************************************************************************/
  2055. MMI_DICTIONARY_LANGUAGE mmi_dictionary_check_input_family(U8 inputType)
  2056. {
  2057.     /*----------------------------------------------------------------*/
  2058.     /* Local Variables                                                */
  2059.     /*----------------------------------------------------------------*/
  2060.     MMI_DICTIONARY_LANGUAGE family;
  2062.     /*----------------------------------------------------------------*/
  2063.     /* Code Body                                                      */
  2064.     /*----------------------------------------------------------------*/
  2065.     switch (inputType)
  2066.     {
  2067.         case INPUT_TYPE_ALPHANUMERIC_UPPERCASE:
  2068.         case INPUT_TYPE_ALPHANUMERIC_LOWERCASE:
  2069.         case INPUT_TYPE_SMART_UPPERCASE_ABC:
  2070.         case INPUT_TYPE_SMART_LOWERCASE_ABC:
  2071.             family = DICTIONARY_ENGLISH;
  2072.             break;
  2074.         case INPUT_TYPE_TR_MULTITAP_BOPOMO:
  2075.         case INPUT_TYPE_SM_MULTITAP_PINYIN:
  2076.         case INPUT_TYPE_TR_BOPOMO:
  2077.         case INPUT_TYPE_SM_PINYIN:
  2078.         case INPUT_TYPE_TR_STROKE:
  2079.         case INPUT_TYPE_SM_STROKE:
  2080.             family = DICTIONARY_CHINESE;
  2081.             break;
  2083.         default:
  2084.             family = DICTIONARY_NONE;
  2085.     }
  2087.     return family;
  2088. }
  2091. /*****************************************************************************
  2092.  * FUNCTION
  2093.  *  mmi_dictionary_flush_exact_wild_editor_buffer
  2094.  * DESCRIPTION
  2095.  *  This function is  called when  input method is changed from exact/wildcard editor -> option->input method
  2096.  * PARAMETERS
  2097.  *  void
  2098.  * RETURNS
  2099.  *  BOOL TRUE : language has been changed
  2100.  *  FALSE : language is not changed
  2101.  *****************************************************************************/
  2102. BOOL mmi_dictionary_flush_exact_wild_editor_buffer(void)
  2103. {
  2104.     /*----------------------------------------------------------------*/
  2105.     /* Local Variables                                                */
  2106.     /*----------------------------------------------------------------*/
  2107.     BOOL scrPresent;
  2108.     U16 activeScrID;
  2109.     MMI_DICTIONARY_LANGUAGE currentLanguage;
  2111.     /*----------------------------------------------------------------*/
  2112.     /* Code Body                                                      */
  2113.     /*----------------------------------------------------------------*/
  2114.     activeScrID = GetActiveScreenId();
  2115.     scrPresent = IsScreenPresent(SCR_DICTIONARY_WILDCARD_EXACT_EDITOR);
  2117.     if (activeScrID == SCR_INPUT_METHOD_LIST)
  2118.     {
  2119.         if (!scrPresent)
  2120.         {
  2121.             return MMI_FALSE;
  2122.         }
  2124.     }
  2125.     else if (!(activeScrID == SCR_DICTIONARY_WILDCARD_EXACT_EDITOR))
  2126.     {
  2127.         return MMI_FALSE;
  2128.     }
  2130.     if (wgui_multiline_inputbox_input_type != 0)
  2131.     {
  2132.         currentLanguage = mmi_dictionary_check_input_family((U8) wgui_multiline_inputbox_input_type);
  2133.         if (currentLanguage != g_dict_current_language)
  2134.         {
  2135.             g_dict_current_language = currentLanguage;
  2136.             return MMI_TRUE;
  2137.         }
  2138.     }
  2139.     else
  2140.     {
  2141.         /* Reset language if input type not assigned */
  2142.         g_dict_current_language = DICTIONARY_ENGLISH;
  2143.         return MMI_FALSE;
  2144.     }
  2146.     return MMI_FALSE;
  2148. }
  2150. #else /* defined(MMI_ON_HARDWARE_P) */ /* #if defined(MMI_ON_HARDWARE_P) */
  2151. #include "PixtelDataTypes.h"
  2152. #include "CommonScreens.h"
  2155. /*****************************************************************************
  2156.  * FUNCTION
  2157.  *  mmi_dictionary_main_menu_highlight_hdlr
  2158.  * DESCRIPTION
  2159.  *  
  2160.  * PARAMETERS
  2161.  *  void
  2162.  * RETURNS
  2163.  *  void
  2164.  *****************************************************************************/
  2165. void mmi_dictionary_main_menu_highlight_hdlr(void)
  2166. {
  2167.     /*----------------------------------------------------------------*/
  2168.     /* Local Variables                                                */
  2169.     /*----------------------------------------------------------------*/
  2171.     /*----------------------------------------------------------------*/
  2172.     /* Code Body                                                      */
  2173.     /*----------------------------------------------------------------*/
  2174.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  2175.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  2177.     SetLeftSoftkeyFunction(PopupNoSupport, KEY_EVENT_UP);
  2178.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  2179.     SetKeyHandler(PopupNoSupport, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  2180.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  2181. }
  2184. /*****************************************************************************
  2185.  * FUNCTION
  2186.  *  mmi_dictionary_init
  2187.  * DESCRIPTION
  2188.  *  
  2189.  * PARAMETERS
  2190.  *  void
  2191.  * RETURNS
  2192.  *  void
  2193.  *****************************************************************************/
  2194. void mmi_dictionary_init()
  2195. {
  2196.     /*----------------------------------------------------------------*/
  2197.     /* Local Variables                                                */
  2198.     /*----------------------------------------------------------------*/
  2200.     /*----------------------------------------------------------------*/
  2201.     /* Code Body                                                      */
  2202.     /*----------------------------------------------------------------*/
  2203.     SetHiliteHandler(EXTRA_DICTIONARY_MENU, mmi_dictionary_main_menu_highlight_hdlr);
  2204. }
  2207. /*****************************************************************************
  2208.  * FUNCTION
  2209.  *  mmi_dictionary_flush_editor_buffer
  2210.  * DESCRIPTION
  2211.  *  
  2212.  * PARAMETERS
  2213.  *  void
  2214.  * RETURNS
  2215.  *  
  2216.  *****************************************************************************/
  2217. pBOOL mmi_dictionary_flush_editor_buffer(void)
  2218. {
  2219.     /*----------------------------------------------------------------*/
  2220.     /* Local Variables                                                */
  2221.     /*----------------------------------------------------------------*/
  2223.     /*----------------------------------------------------------------*/
  2224.     /* Code Body                                                      */
  2225.     /*----------------------------------------------------------------*/
  2226.     return FALSE;
  2227. }
  2229. #endif /* defined(MMI_ON_HARDWARE_P) */ /* #if defined(MMI_ON_HARDWARE_P) */
  2230. #endif /* defined(__MMI_DICTIONARY__) */ /* #if defined(__MMI_DICTIONARY__) */