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

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

MTK

开发平台：

C/C++

MessagesMiscell.c：源码内容
  1. {
  2.     /*----------------------------------------------------------------*/
  3.     /* Local Variables                                                */
  4.     /*----------------------------------------------------------------*/
  6.     /*----------------------------------------------------------------*/
  7.     /* Code Body                                                      */
  8.     /*----------------------------------------------------------------*/
  9.     mmi_msg_highlight_generic(
  10.         STR_GLOBAL_OK,
  11.         IMG_GLOBAL_OK,
  12.         STR_GLOBAL_BACK,
  13.         IMG_GLOBAL_BACK,
  14.         mmi_msg_club_pre_entry_send_msg,
  15.         GoBackHistory);
  16.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  17.     msg_club_level_3_index = MSG_CLUB_SERVICE_CANCEL;
  18. }
  21. /*****************************************************************************
  22.  * FUNCTION
  23.  *  mmi_msg_club_set_menu_highlight_handler
  24.  * DESCRIPTION
  25.  *  
  26.  * PARAMETERS
  27.  *  void
  28.  * RETURNS
  29.  *  void
  30.  *****************************************************************************/
  31. void mmi_msg_club_set_menu_highlight_handler(void)
  32. {
  33.     /*----------------------------------------------------------------*/
  34.     /* Local Variables                                                */
  35.     /*----------------------------------------------------------------*/
  37.     /*----------------------------------------------------------------*/
  38.     /* Code Body                                                      */
  39.     /*----------------------------------------------------------------*/
  40.     SetHiliteHandler(MENU_MSG_CLUB_SUBSCRIBE, mmi_msg_club_highlight_subscribe);
  41.     SetHiliteHandler(MENU_MSG_CLUB_ORDER, mmi_msg_club_highlight_order);
  42.     SetHiliteHandler(MENU_MSG_CLUB_EXPLAIN, mmi_msg_club_highlight_explain);
  43.     SetHiliteHandler(MENU_MSG_CLUB_QUIT, mmi_msg_club_highlight_quit);
  44. }
  47. /*****************************************************************************
  48.  * FUNCTION
  49.  *  mmi_msg_club_go_back_menu
  50.  * DESCRIPTION
  51.  *  
  52.  * PARAMETERS
  53.  *  void
  54.  * RETURNS
  55.  *  void
  56.  *****************************************************************************/
  57. void mmi_msg_club_go_back_menu(void)
  58. {
  59.     /*----------------------------------------------------------------*/
  60.     /* Local Variables                                                */
  61.     /*----------------------------------------------------------------*/
  63.     /*----------------------------------------------------------------*/
  64.     /* Code Body                                                      */
  65.     /*----------------------------------------------------------------*/
  66.     memset((S8*) & MSGClubScreen[MSGClubCount], 0, sizeof(msg_club_entry_menu_struct));
  67.     MSGClubCount--;
  68.     GoBackHistory();
  69. }
  72. /*****************************************************************************
  73.  * FUNCTION
  74.  *  mmi_msg_club_level_3_get_index
  75.  * DESCRIPTION
  76.  *  
  77.  * PARAMETERS
  78.  *  nIndex      [IN]        
  79.  * RETURNS
  80.  *  void
  81.  *****************************************************************************/
  82. void mmi_msg_club_level_3_get_index(S32 nIndex)
  83. {
  84.     /*----------------------------------------------------------------*/
  85.     /* Local Variables                                                */
  86.     /*----------------------------------------------------------------*/
  88.     /*----------------------------------------------------------------*/
  89.     /* Code Body                                                      */
  90.     /*----------------------------------------------------------------*/
  91.     msg_club_level_3_index = (U8) nIndex;
  92. }
  95. /*****************************************************************************
  96.  * FUNCTION
  97.  *  mmi_msg_club_level_2_get_index
  98.  * DESCRIPTION
  99.  *  
  100.  * PARAMETERS
  101.  *  nIndex      [IN]        
  102.  * RETURNS
  103.  *  void
  104.  *****************************************************************************/
  105. void mmi_msg_club_level_2_get_index(S32 nIndex)
  106. {
  107.     /*----------------------------------------------------------------*/
  108.     /* Local Variables                                                */
  109.     /*----------------------------------------------------------------*/
  111.     /*----------------------------------------------------------------*/
  112.     /* Code Body                                                      */
  113.     /*----------------------------------------------------------------*/
  114.     msg_club_level_2_index = (U8) nIndex;
  115. }
  118. /*****************************************************************************
  119.  * FUNCTION
  120.  *  mmi_msg_club_entry_voice_submenu
  121.  * DESCRIPTION
  122.  *  
  123.  * PARAMETERS
  124.  *  void
  125.  * RETURNS
  126.  *  void
  127.  *****************************************************************************/
  128. void mmi_msg_club_entry_voice_submenu(void)
  129. {
  130.     /*----------------------------------------------------------------*/
  131.     /* Local Variables                                                */
  132.     /*----------------------------------------------------------------*/
  133.     U8 *guiBuffer = NULL;
  134.     U8 *itemList[MSG_CLUB_MENUITEM_NUM];
  135.     U8 itemNum = MSGClubScreen[MSGClubCount].childNum;
  136.     U8 i;
  137.     U8 *caption;
  138.     msg_club_entry_voice_struct *itemInfo = (msg_club_entry_voice_struct*) MSGClubScreen[MSGClubCount].childEntry;
  140.     /*----------------------------------------------------------------*/
  141.     /* Code Body                                                      */
  142.     /*----------------------------------------------------------------*/
  143.     if (MSGClubScreen[MSGClubCount].childNum == 0)
  144.     {
  145.         msg_club_level_2_index = 0;
  146.         mmi_msg_club_entry_make_call();
  147.         memset((S8*) & MSGClubScreen[MSGClubCount], 0, sizeof(msg_club_entry_menu_struct));
  148.         MSGClubCount--;
  149.         return;
  150.     }
  152.     EntryNewScreen(SCR_ID_MSG_CLUB_VOICE_SUBMENU, NULL, mmi_msg_club_entry_voice_submenu, NULL);
  153.     guiBuffer = GetCurrGuiBuffer(SCR_ID_MSG_CLUB_VOICE_SUBMENU);
  154.     for (i = 0; i < MSGClubScreen[MSGClubCount].childNum; i++)
  155. #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  156.         itemList[i] = (U8*) get_string_lang(itemInfo[i].stringID, SSC_ENGLISH);
  157. #else 
  158.         itemList[i] = (U8*) GetString(itemInfo[i].stringID);
  159. #endif 
  160.     RegisterHighlightHandler(mmi_msg_club_level_2_get_index);
  162. #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  163.     caption = (U8*) get_string_lang(MSGClubScreen[MSGClubCount].stringID, SSC_ENGLISH);
  164. #else 
  165.     caption = (U8*) GetString(MSGClubScreen[MSGClubCount].stringID);
  166. #endif 
  167.     ShowCategory353Screen(
  168.         caption,
  169.         IMG_MESSAGE_CLUB_ID,
  170.         STR_GLOBAL_OK,
  171.         IMG_GLOBAL_OK,
  172.         STR_GLOBAL_BACK,
  173.         IMG_GLOBAL_BACK,
  174.         itemNum,
  175.         itemList,
  176.         (U16*) gIndexIconsImageList,
  177.         NULL,
  178.         0,
  179.         0,
  180.         guiBuffer);
  182.     SetLeftSoftkeyFunction(mmi_msg_club_entry_make_call, KEY_EVENT_UP);
  183.     SetKeyHandler(mmi_msg_club_entry_make_call, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  184.     SetRightSoftkeyFunction(mmi_msg_club_go_back_menu, KEY_EVENT_UP);
  185.     SetKeyHandler(mmi_msg_club_go_back_menu, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  187. }
  190. /*****************************************************************************
  191.  * FUNCTION
  192.  *  mmi_msg_club_entry_level_3
  193.  * DESCRIPTION
  194.  *  
  195.  * PARAMETERS
  196.  *  void
  197.  * RETURNS
  198.  *  void
  199.  *****************************************************************************/
  200. void mmi_msg_club_entry_level_3(void)
  201. {
  202.     /*----------------------------------------------------------------*/
  203.     /* Local Variables                                                */
  204.     /*----------------------------------------------------------------*/
  205.     U8 *guiBuffer;
  206.     U16 nStrItemList[MAX_SUB_MENUS];
  207.     U8 *itemList[MSG_CLUB_MENUITEM_NUM];
  208.     U16 numItems;
  209.     U32 menuItemId = -1;
  210.     U32 menuItemId1 = -1;
  211.     U32 maskingByte = -1;
  212.     U8 i = 0;
  213.     U8 *captionStr;
  215.     /*----------------------------------------------------------------*/
  216.     /* Code Body                                                      */
  217.     /*----------------------------------------------------------------*/
  218.     EntryNewScreen(SCR_ID_MSG_CLUB_LEVEL_3, NULL, mmi_msg_club_entry_level_3, NULL);
  219.     guiBuffer = GetCurrGuiBuffer(SCR_ID_MSG_CLUB_LEVEL_3);
  220.     SetParentHandler(MENU_MSG_CLUB_OPTION);
  221.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  222.     numItems = GetNumOfChild(MENU_MSG_CLUB_OPTION);
  223.     GetSequenceStringIds(MENU_MSG_CLUB_OPTION, nStrItemList);
  224.     mmi_msg_club_set_menu_highlight_handler();
  226.     menuItemId = GetChildMenuIDIndexByParentMenuID(MENU_MSG_CLUB_OPTION, MENU_MSG_CLUB_SUBSCRIBE);
  227.     if (menuItemId != -1)
  228.     {
  229.         if (strcmp((S8*) MSGClubSMSItem.codeDY.codeNum, "") == 0)
  230.         {
  231.             ResetBit(maskingByte, menuItemId /* 1 */ );
  232.         }
  233.         else
  234.         {
  235.         #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  236.             itemList[i] = (U8*) get_string_lang(STR_MSG_CLUB_SUBSCRIBE, SSC_ENGLISH);
  237.         #else 
  238.             itemList[i] = (U8*) GetString(STR_MSG_CLUB_SUBSCRIBE);
  239.         #endif 
  240.             i++;
  241.         }
  242.     }
  243.     menuItemId = GetChildMenuIDIndexByParentMenuID(MENU_MSG_CLUB_OPTION, MENU_MSG_CLUB_ORDER);
  244.     if (menuItemId != -1)
  245.     {
  246.         if (strcmp((S8*) MSGClubSMSItem.codeDB.codeNum, "") == 0)
  247.         {
  248.             ResetBit(maskingByte, menuItemId /* 2 */ );
  249.         }
  250.         else
  251.         {
  252.         #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  253.             itemList[i] = (U8*) get_string_lang(STR_MSG_CLUB_ORDER, SSC_ENGLISH);
  254.         #else 
  255.             itemList[i] = (U8*) GetString(STR_MSG_CLUB_ORDER);
  256.         #endif 
  257.             i++;
  258.         }
  259.     }
  260.     menuItemId = GetChildMenuIDIndexByParentMenuID(MENU_MSG_CLUB_OPTION, MENU_MSG_CLUB_EXPLAIN);
  261.     if (menuItemId != -1)
  262.     {
  263.         if (strcmp((S8*) MSGClubSMSItem.codeZF.codeNum, "") == 0)
  264.         {
  265.             ResetBit(maskingByte, menuItemId /* 3 */ );
  266.         }
  267.         else
  268.         {
  269.         #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  270.             itemList[i] = (U8*) get_string_lang(STR_MSG_CLUB_INQUIRE, SSC_ENGLISH);
  271.         #else 
  272.             itemList[i] = (U8*) GetString(STR_MSG_CLUB_INQUIRE);
  273.         #endif 
  274.             i++;
  275.         }
  276.     }
  277.     menuItemId = GetChildMenuIDIndexByParentMenuID(MENU_MSG_CLUB_OPTION, MENU_MSG_CLUB_QUIT);
  278.     if (menuItemId != -1)
  279.     {
  280.         if (strcmp((S8*) MSGClubSMSItem.codeTD.codeNum, "") == 0)
  281.         {
  282.             ResetBit(maskingByte, menuItemId /* 4 */ );
  283.         }
  284.         else
  285.         {
  286.         #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  287.             itemList[i] = (U8*) get_string_lang(STR_MSG_CLUB_QUIT, SSC_ENGLISH);
  288.         #else 
  289.             itemList[i] = (U8*) GetString(STR_MSG_CLUB_QUIT);
  290.         #endif 
  291.             i++;
  292.         }
  293.     }
  295.     MaskHiliteItems(MENU_MSG_CLUB_OPTION, maskingByte);
  296.     numItems = MaskItems(nStrItemList, (U8) numItems, maskingByte);
  298. #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  299.     captionStr = (U8*) get_string_lang(MSGClubSMSItem.stringID, SSC_ENGLISH);
  300. #else 
  301.     captionStr = (U8*) GetString(MSGClubSMSItem.stringID);
  302. #endif 
  304.     ShowCategory353Screen(
  305.         captionStr,
  306.         IMG_MESSAGE_CLUB_ID,
  307.         STR_GLOBAL_OK,
  308.         IMG_GLOBAL_OK,
  309.         STR_GLOBAL_BACK,
  310.         IMG_GLOBAL_BACK,
  311.         numItems,
  312.         itemList,
  313.         (U16*) gIndexIconsImageList,
  314.         NULL,
  315.         0,
  316.         0,
  317.         guiBuffer);
  318.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);   /* MTK Jo */
  319.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  320. }
  323. /*****************************************************************************
  324.  * FUNCTION
  325.  *  mmi_msg_club_pre_entry_level_3
  326.  * DESCRIPTION
  327.  *  
  328.  * PARAMETERS
  329.  *  void
  330.  * RETURNS
  331.  *  void
  332.  *****************************************************************************/
  333. void mmi_msg_club_pre_entry_level_3(void)
  334. {
  335.     /*----------------------------------------------------------------*/
  336.     /* Local Variables                                                */
  337.     /*----------------------------------------------------------------*/
  338.     msg_club_entry_dy_db_zf_struct *itemInfo =
  339.         (msg_club_entry_dy_db_zf_struct*) MSGClubScreen[MSGClubCount].childEntry;
  341.     /*----------------------------------------------------------------*/
  342.     /* Code Body                                                      */
  343.     /*----------------------------------------------------------------*/
  344.     memcpy((S8*) & MSGClubSMSItem, (S8*) & itemInfo[msg_club_level_2_index], sizeof(msg_club_entry_dy_db_zf_struct));
  345.     if ((strcmp((S8*) MSGClubSMSItem.codeDY.codeNum, "") != 0)
  346.         || (strcmp((S8*) MSGClubSMSItem.codeDB.codeNum, "") != 0))
  347.     {
  348.         mmi_msg_club_entry_level_3();
  349.     }
  350.     else
  351.     {
  352.         if (strcmp((S8*) MSGClubSMSItem.codeZF.codeNum, "") != 0)
  353.         {
  354.             msg_club_level_3_index = MSG_CLUB_SERVICE_EXPLAIN;
  355.         }
  356.         else
  357.         {
  358.             msg_club_level_3_index = MSG_CLUB_SERVICE_CANCEL;
  359.         }
  360.         mmi_msg_club_pre_entry_send_msg();
  361.     }
  362. }
  365. /*****************************************************************************
  366.  * FUNCTION
  367.  *  mmi_msg_club_entry_level_2
  368.  * DESCRIPTION
  369.  *  
  370.  * PARAMETERS
  371.  *  void
  372.  * RETURNS
  373.  *  void
  374.  *****************************************************************************/
  375. void mmi_msg_club_entry_level_2(void)
  376. {
  377.     /*----------------------------------------------------------------*/
  378.     /* Local Variables                                                */
  379.     /*----------------------------------------------------------------*/
  380.     U8 *guiBuffer = NULL;
  381.     S32 hiliteitem = 0;
  382.     U8 *itemList[MSG_CLUB_MENUITEM_NUM];
  383.     U8 itemNum = MSGClubScreen[MSGClubCount].childNum;
  384.     U8 i;
  385.     U8 *captionStr;
  386.     msg_club_entry_dy_db_zf_struct *itemInfo =
  387.         (msg_club_entry_dy_db_zf_struct*) MSGClubScreen[MSGClubCount].childEntry;
  389.     /*----------------------------------------------------------------*/
  390.     /* Code Body                                                      */
  391.     /*----------------------------------------------------------------*/
  392.     EntryNewScreen(SCR_ID_MSG_CLUB_LEVEL_2, NULL, mmi_msg_club_entry_level_2, NULL);
  393.     guiBuffer = GetCurrGuiBuffer(SCR_ID_MSG_CLUB_LEVEL_2);
  394.     for (i = 0; i < MSGClubScreen[MSGClubCount].childNum; i++)
  395.     {
  396.     #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  397.         itemList[i] = (U8*) get_string_lang(itemInfo[i].stringID, SSC_ENGLISH);
  398.     #else 
  399.         itemList[i] = (U8*) GetString(itemInfo[i].stringID);
  400.     #endif 
  401.     }
  403.     RegisterHighlightHandler(mmi_msg_club_level_2_get_index);
  405. #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  406.     captionStr = (U8*) get_string_lang(MSGClubMenuItem[msg_club_level_1_index].stringID, SSC_ENGLISH);
  407. #else 
  408.     captionStr = (U8*) GetString(MSGClubMenuItem[msg_club_level_1_index].stringID);
  409. #endif 
  410.     ShowCategory353Screen(
  411.         captionStr,
  412.         IMG_MESSAGE_CLUB_ID,
  413.         STR_GLOBAL_OK,
  414.         IMG_GLOBAL_OK,
  415.         STR_GLOBAL_BACK,
  416.         IMG_GLOBAL_BACK,
  417.         itemNum,
  418.         itemList,
  419.         (U16*) gIndexIconsImageList,
  420.         NULL,
  421.         0,
  422.         0,
  423.         guiBuffer);
  425.     SetLeftSoftkeyFunction(mmi_msg_club_pre_entry_level_3, KEY_EVENT_UP);
  426.     SetKeyHandler(mmi_msg_club_pre_entry_level_3, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  427.     SetRightSoftkeyFunction(mmi_msg_club_go_back_menu, KEY_EVENT_UP);
  428.     SetKeyHandler(mmi_msg_club_go_back_menu, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  429. }
  432. /*****************************************************************************
  433.  * FUNCTION
  434.  *  mmi_msg_club_level_1_get_index
  435.  * DESCRIPTION
  436.  *  
  437.  * PARAMETERS
  438.  *  nIndex      [IN]        
  439.  * RETURNS
  440.  *  void
  441.  *****************************************************************************/
  442. void mmi_msg_club_level_1_get_index(S32 nIndex)
  443. {
  444.     /*----------------------------------------------------------------*/
  445.     /* Local Variables                                                */
  446.     /*----------------------------------------------------------------*/
  448.     /*----------------------------------------------------------------*/
  449.     /* Code Body                                                      */
  450.     /*----------------------------------------------------------------*/
  451.     msg_club_level_1_index = (U8) nIndex;
  452. }
  455. /*****************************************************************************
  456.  * FUNCTION
  457.  *  mmi_msg_club_pre_entry_menu
  458.  * DESCRIPTION
  459.  *  
  460.  * PARAMETERS
  461.  *  void
  462.  * RETURNS
  463.  *  void
  464.  *****************************************************************************/
  465. void mmi_msg_club_pre_entry_menu(void)
  466. {
  467.     /*----------------------------------------------------------------*/
  468.     /* Local Variables                                                */
  469.     /*----------------------------------------------------------------*/
  471.     /*----------------------------------------------------------------*/
  472.     /* Code Body                                                      */
  473.     /*----------------------------------------------------------------*/
  474.     MSGClubCount++;
  475.     memcpy(
  476.         (S8*) & MSGClubScreen[MSGClubCount],
  477.         (S8*) & MSGClubMenuItem[msg_club_level_1_index],
  478.         sizeof(msg_club_entry_menu_struct));
  479.     if ((MSGClubScreen[MSGClubCount].childType & MSG_CLUB_MENU) == MSG_CLUB_MENU)
  480.     {
  481.         mmi_msg_club_entry_level_1();
  482.     }
  483.     else if ((MSGClubScreen[MSGClubCount].childType & MSG_CLUB_VOICE_MENU) == MSG_CLUB_VOICE_MENU)
  484.     {
  485.         mmi_msg_club_entry_voice_submenu();
  486.     }
  487.     else if (MSGClubScreen[MSGClubCount].childNum > 0)
  488.     {
  489.         mmi_msg_club_entry_level_2();
  490.     }
  491.     else
  492.     {
  493.         msg_club_entry_dy_db_zf_struct *itemInfo =
  494.             (msg_club_entry_dy_db_zf_struct*) MSGClubScreen[MSGClubCount].childEntry;
  495.         memcpy((S8*) & MSGClubSMSItem, (S8*) & itemInfo[0], sizeof(msg_club_entry_dy_db_zf_struct));
  496.         memset((S8*) & MSGClubScreen[MSGClubCount], 0, sizeof(msg_club_entry_menu_struct));
  497.         MSGClubCount--;
  498.         if ((strcmp((S8*) MSGClubSMSItem.codeDY.codeNum, "") != 0)
  499.             || (strcmp((S8*) MSGClubSMSItem.codeDB.codeNum, "") != 0))
  500.         {
  501.             mmi_msg_club_entry_level_3();
  502.         }
  503.         else
  504.         {
  505.             if (strcmp((S8*) MSGClubSMSItem.codeZF.codeNum, "") != 0)
  506.             {
  507.                 msg_club_level_3_index = MSG_CLUB_SERVICE_EXPLAIN;
  508.             }
  509.             else
  510.             {
  511.                 msg_club_level_3_index = MSG_CLUB_SERVICE_CANCEL;
  512.             }
  513.             mmi_msg_club_pre_entry_send_msg();
  514.         }
  515.     }
  516. }
  519. /*****************************************************************************
  520.  * FUNCTION
  521.  *  mmi_msg_club_entry_level_1
  522.  * DESCRIPTION
  523.  *  
  524.  * PARAMETERS
  525.  *  void
  526.  * RETURNS
  527.  *  void
  528.  *****************************************************************************/
  529. void mmi_msg_club_entry_level_1(void)
  530. {
  531.     /*----------------------------------------------------------------*/
  532.     /* Local Variables                                                */
  533.     /*----------------------------------------------------------------*/
  534.     U8 *guiBuffer = NULL;
  535.     U8 *itemList[MSG_CLUB_MENUITEM_NUM];
  536.     U8 itemNum = 0;
  537.     U8 i, j = 0;
  538.     U8 *captionStr;
  539.     msg_club_entry_menu_struct *itemInfo = (msg_club_entry_menu_struct*) MSGClubScreen[MSGClubCount].childEntry;
  540.     U16 scrIndex = SCR_ID_MSG_CLUB_LEVEL_1 + (U16) MSGClubCount;
  542.     /*----------------------------------------------------------------*/
  543.     /* Code Body                                                      */
  544.     /*----------------------------------------------------------------*/
  545.     EntryNewScreen(scrIndex, NULL, mmi_msg_club_entry_level_1, NULL);
  546.     guiBuffer = GetCurrGuiBuffer(scrIndex);
  547.     for (i = 0; i < MSGClubScreen[MSGClubCount].childNum; i++)
  548.     {
  549.         if (((itemInfo[i].childType & MSG_CLUB_CT_ONLY) == MSG_CLUB_CT_ONLY) && (MSGClubNetwork != MSG_CLUB_CT))
  550.         {
  551.             continue;
  552.         }
  553.     #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  554.         itemList[j] = (U8*) get_string_lang(itemInfo[i].stringID, SSC_ENGLISH);
  555.     #else 
  556.         itemList[j] = (U8*) GetString(itemInfo[i].stringID);
  557.     #endif 
  558.         memcpy((S8*) & MSGClubMenuItem[j], (S8*) & itemInfo[i], sizeof(msg_club_entry_menu_struct));
  559.         j++;
  560.     }
  561.     itemNum = j;
  562.     RegisterHighlightHandler(mmi_msg_club_level_1_get_index);
  564. #ifdef __MMI_MESSAGES_CLUB_SIM_CHINESE__
  565.     captionStr = (U8*) get_string_lang(MSGClubScreen[MSGClubCount].stringID, SSC_ENGLISH);
  566. #else 
  567.     captionStr = (U8*) GetString(MSGClubScreen[MSGClubCount].stringID);
  568. #endif 
  570.     ShowCategory353Screen(
  571.         captionStr,
  572.         IMG_MESSAGE_CLUB_ID,
  573.         STR_GLOBAL_OK,
  574.         IMG_GLOBAL_OK,
  575.         STR_GLOBAL_BACK,
  576.         IMG_GLOBAL_BACK,
  577.         itemNum,
  578.         itemList,
  579.         (U16*) gIndexIconsImageList,
  580.         NULL,
  581.         0,
  582.         0,
  583.         guiBuffer);
  585.     SetLeftSoftkeyFunction(mmi_msg_club_pre_entry_menu, KEY_EVENT_UP);
  586.     SetKeyHandler(mmi_msg_club_pre_entry_menu, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  587.     SetRightSoftkeyFunction(mmi_msg_club_go_back_menu, KEY_EVENT_UP);
  588.     SetKeyHandler(mmi_msg_club_go_back_menu, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  590. }
  593. /*****************************************************************************
  594.  * FUNCTION
  595.  *  EntryMsgClub
  596.  * DESCRIPTION
  597.  *  
  598.  * PARAMETERS
  599.  *  void
  600.  * RETURNS
  601.  *  void
  602.  *****************************************************************************/
  603. void EntryMsgClub(void)
  604. {
  605.     /*----------------------------------------------------------------*/
  606.     /* Local Variables                                                */
  607.     /*----------------------------------------------------------------*/
  609.     /*----------------------------------------------------------------*/
  610.     /* Code Body                                                      */
  611.     /*----------------------------------------------------------------*/
  612.     /* micha0422 */
  613.     if ((strncmp(gHomePLMNNum, "46000", 5) == 0) || (strncmp(gHomePLMNNum, "46002", 5) == 0))
  614.     {
  615.         MSGClubNetwork = MSG_CLUB_CT;
  616.     }
  617.     else if (strncmp(gHomePLMNNum, "46001", 5) == 0)
  618.     {
  619.         MSGClubNetwork = MSG_CLUB_CU;
  620.     }
  621.     else
  622.     {
  623.         MSGClubNetwork = MSG_CLUB_NETWORK_TOTAL;
  624.     }
  625.     if (MSGClubNetwork == MSG_CLUB_NETWORK_TOTAL)
  626.     {
  627.         DisplayPopup(
  628.             (PU8) GetString(STR_SMS_DOES_NOT_SUPPORT),
  629.             IMG_GLOBAL_UNFINISHED,
  630.             1,
  631.             MESSAGES_POPUP_TIME_OUT,
  632.             (U8) ERROR_TONE);
  633.     }
  634.     else
  635.     {
  636.         MSGClubCount = 0;
  637.         memset(MSGClubScreen, 0, sizeof(msg_club_entry_menu_struct) * MSG_CLUB_SCREEN_NUM);
  638.         MSGClubScreen[0].stringID = STR_MSG_CLUB;
  639.         MSGClubScreen[0].childNum = mmi_msg_club_get_item_total();
  640.         MSGClubScreen[0].childType = MSG_CLUB_MENU;
  641.         MSGClubScreen[0].childEntry = (void*)MenuMSGClub;
  642.         mmi_msg_club_entry_level_1();
  643.     }
  645. }
  647. #endif /* __MMI_MESSAGES_CLUB__ */ 
  649. #ifdef __MMI_UNIFIED_MESSAGE__
  652. /*****************************************************************************
  653.  * FUNCTION
  654.  *  mmi_msg_um_entry_msg
  655.  * DESCRIPTION
  656.  *  entry sms msg
  657.  *  void
  658.  * RETURNS
  659.  *  void
  660.  *****************************************************************************/
  661. void mmi_msg_um_entry_msg(UmMsgBoxType msg_box_type, kal_uint16 msg_index)
  662. {
  663.     /*----------------------------------------------------------------*/
  664.     /* Local Variables                                                */
  665.     /*----------------------------------------------------------------*/
  666.     UmMsgBoxType type = msg_box_type;
  668.     /*----------------------------------------------------------------*/
  669.     /* Code Body                                                      */
  670.     /*----------------------------------------------------------------*/
  671.     g_msg_cntx.currBoxIndex = msg_index;
  673.     switch (type)
  674.     {
  675.     #ifdef __UNIFIED_MESSAGE_LIST_OPTION_SUPPORT__
  676.         case UM_MSG_BOX_TYPE_INBOX:
  677.         {
  678.             /* Update the totalinbox value in order to get the current inbox list size  */
  679.             msgbox_info.totalinbox = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_APP_INBOX);
  680.             mmi_msg_pre_entry_list_option_req(MMI_FRM_SMS_APP_INBOX);            
  681.             break;
  682.         }
  683.         case UM_MSG_BOX_TYPE_SENT:
  684.         {            
  685.             mmi_msg_pre_entry_list_option_req(MMI_FRM_SMS_APP_OUTBOX);
  686.             break;
  687.         }
  688.         case UM_MSG_BOX_TYPE_UNSENT:
  689.         case UM_MSG_BOX_TYPE_DRAFT:
  690.         {
  691.             mmi_msg_pre_entry_list_option_req(MMI_FRM_SMS_APP_DRAFTS);
  692.             break;
  693.         }
  694.     #else /* __UNIFIED_MESSAGE_LIST_OPTION_SUPPORT__ */
  695.         case UM_MSG_BOX_TYPE_INBOX:
  696.         {
  697.             /* Update the totalinbox value in order to get the current inbox list size  */
  698.             msgbox_info.totalinbox = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_APP_INBOX);
  699.             mmi_msg_get_msg_inbox();
  700.             break;
  701.         }
  702.         case UM_MSG_BOX_TYPE_SENT:
  703.         {
  704.             mmi_msg_get_msg_outbox();
  705.             break;
  706.         }
  707.         case UM_MSG_BOX_TYPE_UNSENT:
  708.         case UM_MSG_BOX_TYPE_DRAFT:
  709.         {
  710.             mmi_msg_get_msg_draftbox();
  711.             break;
  712.         }
  713.     #endif /* __UNIFIED_MESSAGE_LIST_OPTION_SUPPORT__ */                    
  714.         default:
  715.         {
  716.             MMI_ASSERT(0);
  717.             break;
  718.         }
  719.     }
  720. }
  723. /*****************************************************************************
  724.  * FUNCTION
  725.  *  mmi_msg_um_entry_write
  726.  * DESCRIPTION
  727.  *  entry function for sms editor by Unified Message
  728.  * PARAMETERS
  729.  *  void
  730.  * RETURNS
  731.  *  void
  732.  *****************************************************************************/
  733. void mmi_msg_um_entry_write(void)
  734. {
  735.     /*----------------------------------------------------------------*/
  736.     /* Local Variables                                                */
  737.     /*----------------------------------------------------------------*/
  739.     /*----------------------------------------------------------------*/
  740.     /* Code Body                                                      */
  741.     /*----------------------------------------------------------------*/
  742.     g_msg_cntx.sendMessageCase = SEND_CASE_SEND_ONLY;
  743.     g_msg_cntx.PhbSmsInterfaceState = MMI_SEND_ONLY;
  744.     mmi_msg_entry_write_msg();
  745. }
  748. /*****************************************************************************
  749.  * FUNCTION
  750.  *  mmi_msg_um_entry_template
  751.  * DESCRIPTION
  752.  *  entry function for sms template
  753.  * PARAMETERS
  754.  *  void
  755.  * RETURNS
  756.  *  void
  757.  *****************************************************************************/
  758. void mmi_msg_um_entry_template(void)
  759. {
  760.     /*----------------------------------------------------------------*/
  761.     /* Local Variables                                                */
  762.     /*----------------------------------------------------------------*/
  764.     /*----------------------------------------------------------------*/
  765.     /* Code Body                                                      */
  766.     /*----------------------------------------------------------------*/
  767.     mmi_msg_entry_template_list();
  768. }
  771. /*****************************************************************************
  772.  * FUNCTION
  773.  *  mmi_msg_um_entry_setting
  774.  * DESCRIPTION
  775.  *  entry function for sms setting
  776.  * PARAMETERS
  777.  *  void
  778.  * RETURNS
  779.  *  void
  780.  *****************************************************************************/
  781. void mmi_msg_um_entry_setting(void)
  782. {
  783.     /*----------------------------------------------------------------*/
  784.     /* Local Variables                                                */
  785.     /*----------------------------------------------------------------*/
  787.     /*----------------------------------------------------------------*/
  788.     /* Code Body                                                      */
  789.     /*----------------------------------------------------------------*/
  790.     mmi_msg_pre_entry_msg_settings();
  791. }
  794. /*****************************************************************************
  795.  * FUNCTION
  796.  *  mmi_msg_set_background_process
  797.  * DESCRIPTION
  798.  *  set if SMS is in the background process
  799.  * PARAMETERS
  800.  *  flag        [IN]        
  801.  * RETURNS
  802.  *  void
  803.  *****************************************************************************/
  804. void mmi_msg_set_background_process(kal_bool flag)
  805. {
  806.     /*----------------------------------------------------------------*/
  807.     /* Local Variables                                                */
  808.     /*----------------------------------------------------------------*/
  810.     /*----------------------------------------------------------------*/
  811.     /* Code Body                                                      */
  812.     /*----------------------------------------------------------------*/
  813.     g_msg_cntx.is_background_process = (U8) flag;
  814. }
  817. /*****************************************************************************
  818.  * FUNCTION
  819.  *  mmi_msg_check_background_process
  820.  * DESCRIPTION
  821.  *  check if SMS is in the background process
  822.  * PARAMETERS
  823.  *  void
  824.  * RETURNS
  825.  *  void
  826.  *****************************************************************************/
  827. kal_bool mmi_msg_check_background_process(void)
  828. {
  829.     /*----------------------------------------------------------------*/
  830.     /* Local Variables                                                */
  831.     /*----------------------------------------------------------------*/
  833.     /*----------------------------------------------------------------*/
  834.     /* Code Body                                                      */
  835.     /*----------------------------------------------------------------*/
  836.     if (g_msg_cntx.is_background_process)
  837.     {
  838.         return KAL_TRUE;
  839.     }
  840.     else
  841.     {
  842.         return KAL_FALSE;
  843.     }
  844. }
  847. /*****************************************************************************
  848.  * FUNCTION
  849.  *  mmi_msg_set_post_send_action_type
  850.  * DESCRIPTION
  851.  *  set the type of action after send
  852.  * PARAMETERS
  853.  *  action      [IN]        
  854.  * RETURNS
  855.  *  void
  856.  *****************************************************************************/
  857. void mmi_msg_set_post_send_action_type(U8 action)
  858. {
  859.     /*----------------------------------------------------------------*/
  860.     /* Local Variables                                                */
  861.     /*----------------------------------------------------------------*/
  863.     /*----------------------------------------------------------------*/
  864.     /* Code Body                                                      */
  865.     /*----------------------------------------------------------------*/
  866.     g_msg_cntx.post_send_action = action;
  867. }
  870. /*****************************************************************************
  871.  * FUNCTION
  872.  *  mmi_msg_get_post_send_action_type
  873.  * DESCRIPTION
  874.  *  get post send action type
  875.  * PARAMETERS
  876.  *  void
  877.  * RETURNS
  878.  *  void
  879.  *****************************************************************************/
  880. U8 mmi_msg_get_post_send_action_type(void)
  881. {
  882.     /*----------------------------------------------------------------*/
  883.     /* Local Variables                                                */
  884.     /*----------------------------------------------------------------*/
  886.     /*----------------------------------------------------------------*/
  887.     /* Code Body                                                      */
  888.     /*----------------------------------------------------------------*/
  889.     return g_msg_cntx.post_send_action;
  890. }
  893. /*****************************************************************************
  894.  * FUNCTION
  895.  *  mmi_msg_get_msg_num
  896.  * DESCRIPTION
  897.  *  get sms msg number of each msg box
  898.  * PARAMETERS
  899.  *  inbox_msg_number            [?]     
  900.  *  inbox_unread_msg_number     [?]     
  901.  *  unsent_msg_number           [?]     
  902.  *  sent_msg_number             [?]     
  903.  *  draft_msg_number            [?]     
  904.  * RETURNS
  905.  *  void
  906.  *****************************************************************************/
  907. kal_bool mmi_msg_get_msg_num(
  908.             kal_uint16 *inbox_msg_number,
  909.             kal_uint16 *inbox_unread_msg_number,
  910.             kal_uint16 *unsent_msg_number,
  911.             kal_uint16 *sent_msg_number,
  912.             kal_uint16 *draft_msg_number)
  913. {
  914.     /*----------------------------------------------------------------*/
  915.     /* Local Variables                                                */
  916.     /*----------------------------------------------------------------*/
  917.     kal_uint16 i = 0;
  918.     U8 type = 0;
  920.     /*----------------------------------------------------------------*/
  921.     /* Code Body                                                      */
  922.     /*----------------------------------------------------------------*/
  923.     if (*inbox_msg_number == MMI_FRM_SMS_INVALID_INDEX)
  924.     {
  925.         return KAL_FALSE;
  926.     }
  928.     *inbox_msg_number = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_INBOX);
  929.     *sent_msg_number = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_OUTBOX);
  931.     *inbox_unread_msg_number = 0;
  932.     *unsent_msg_number = 0;
  933.     *draft_msg_number = 0;
  935.     while (i < *inbox_msg_number)
  936.     {
  937.         type = mmi_frm_sms_get_status(MMI_FRM_SMS_APP_INBOX, i) & 0x0f;
  939.         if (type == MMI_FRM_SMS_APP_UNREAD)
  940.         {
  941.             (*inbox_unread_msg_number)++;
  942.         }
  943.         i++;
  944.     }
  946.     mmi_frm_sms_get_unsent_msg_num(unsent_msg_number);
  947.     mmi_frm_sms_get_draft_msg_num(draft_msg_number);
  949.     return KAL_TRUE;
  950. }
  953. /*****************************************************************************
  954.  * FUNCTION
  955.  *  mmi_msg_get_list_info
  956.  * DESCRIPTION
  957.  *  get sms list info
  958.  * PARAMETERS
  959.  *  msg_box_type        [IN]        
  960.  *  start_entry         [IN]        
  961.  *  max_msg_number      [IN]        
  962.  *  msg_number          [?]         
  963.  *  list_info           [?]         
  964.  *  more                [?]         
  965.  * RETURNS
  966.  *  void
  967.  *****************************************************************************/
  968. kal_bool mmi_msg_get_list_info(
  969.             UmMsgBoxType msg_box_type,
  970.             kal_uint16 start_entry,
  971.             kal_uint16 max_msg_number,
  972.             kal_uint16 *msg_number,
  973.             mmi_um_list_info_struct *list_info,
  974.             kal_bool *more)
  975. {
  976.     /*----------------------------------------------------------------*/
  977.     /* Local Variables                                                */
  978.     /*----------------------------------------------------------------*/
  979.     kal_uint16 msg_list_index = start_entry;
  980.     kal_uint16 i = 0;
  981.     U8 *timestamp = NULL;
  982.     U8 sms_msg_box_type = 0;
  983.     kal_uint16 sms_msg_box_size = 0;
  985.     /*----------------------------------------------------------------*/
  986.     /* Code Body                                                      */
  987.     /*----------------------------------------------------------------*/
  988.     *msg_number = 0;
  990.     switch (msg_box_type)
  991.     {
  992.         case UM_MSG_BOX_TYPE_INBOX:
  993.         {
  994.             sms_msg_box_type = MMI_FRM_SMS_INBOX;
  995.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_INBOX);
  996.             break;
  997.         }
  998.         case UM_MSG_BOX_TYPE_UNSENT:
  999.         {
  1000.             sms_msg_box_type = MMI_FRM_SMS_UNSENT;
  1001.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_UNSENT);
  1002.             break;
  1003.         }
  1004.         case UM_MSG_BOX_TYPE_SENT:
  1005.         {
  1006.             sms_msg_box_type = MMI_FRM_SMS_OUTBOX;
  1007.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_OUTBOX);
  1008.             break;
  1009.         }
  1010.         case UM_MSG_BOX_TYPE_DRAFT:
  1011.         {
  1012.             sms_msg_box_type = MMI_FRM_SMS_DRAFTS;
  1013.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_DRAFTS);
  1014.             break;
  1015.         }
  1016.         default:
  1017.         {
  1018.             MMI_ASSERT(0);
  1019.             break;
  1020.         }
  1021.     }
  1023.     for (; (i < max_msg_number); i++)
  1024.     {
  1025.         UI_time datetime;
  1027.         if (msg_box_type == UM_MSG_BOX_TYPE_UNSENT)
  1028.         {
  1029.             if (!mmi_frm_sms_get_next_unsent_msg(&msg_list_index))
  1030.             {
  1031.                 *more = KAL_FALSE;
  1032.                 return KAL_TRUE;
  1033.             }
  1034.         }
  1035.         else if (msg_box_type == UM_MSG_BOX_TYPE_DRAFT)
  1036.         {
  1037.             if (!mmi_frm_sms_get_next_draft_msg(&msg_list_index))
  1038.             {
  1039.                 *more = KAL_FALSE;
  1040.                 return KAL_TRUE;
  1041.             }
  1042.         }
  1043.         /* For inbox and sent */
  1044.         else
  1045.         {
  1046.             if (msg_list_index >= sms_msg_box_size)
  1047.             {
  1048.                 *more = KAL_FALSE;
  1049.                 return KAL_TRUE;
  1050.             }
  1051.         }
  1053.         timestamp = mmi_frm_sms_get_timestamp(sms_msg_box_type, msg_list_index);
  1055.         if (timestamp[1] == 0)
  1056.         {
  1057.             list_info[i].timestamp = 0;
  1058.         }
  1059.         else
  1060.         {
  1061.             datetime.nYear = timestamp[0] + 2000;
  1062.             if (datetime.nYear > 2090)
  1063.             {
  1064.                 datetime.nYear = datetime.nYear - 100;
  1065.             }
  1067.             datetime.nMonth = timestamp[1];
  1068.             datetime.nDay = timestamp[2];
  1070.             datetime.nHour = timestamp[3];
  1071.             datetime.nMin = timestamp[4];
  1072.             datetime.nSec = timestamp[5];
  1074.         #ifdef MMI_ON_HARDWARE_P
  1075.             list_info[i].timestamp = mmi_dt_mytime_2_utc_sec((MYTIME*) & datetime, MMI_TRUE);
  1076.         #endif 
  1077.         }
  1079.         list_info[i].msg_index = msg_list_index;
  1081.         (*msg_number)++;
  1083.         msg_list_index++;
  1084.     }
  1086.     /* For inbox and sent */
  1087.     if (msg_list_index < sms_msg_box_size)
  1088.     {
  1089.         *more = KAL_TRUE;
  1090.     }
  1091.     else
  1092.     {
  1093.         *more = KAL_FALSE;
  1094.     }
  1096.     return KAL_TRUE;
  1097. }
  1100. /*****************************************************************************
  1101.  * FUNCTION
  1102.  *  mmi_msg_get_msg_info
  1103.  * DESCRIPTION
  1104.  *  get sms msg info
  1105.  * PARAMETERS
  1106.  *  msg_box_type        [IN]        
  1107.  *  start_entry         [IN]        
  1108.  *  req_msg_number      [IN]        
  1109.  *  rsp_msg_number      [?]         
  1110.  *  msg_info            [?]         
  1111.  * RETURNS
  1112.  *  void
  1113.  *****************************************************************************/
  1114. kal_bool mmi_msg_get_msg_info(
  1115.             UmMsgBoxType msg_box_type,
  1116.             kal_uint16 start_entry,
  1117.             kal_uint16 req_msg_number,
  1118.             kal_uint16 *rsp_msg_number,
  1119.             mmi_um_msg_info_struct *msg_info)
  1120. {
  1121.     /*----------------------------------------------------------------*/
  1122.     /* Local Variables                                                */
  1123.     /*----------------------------------------------------------------*/
  1124.     kal_uint16 msg_list_index = start_entry;
  1125.     kal_uint16 i = 0;
  1126.     U8 *timestamp = NULL;
  1127.     U8 sms_msg_box_type = 0;
  1128.     kal_uint16 sms_msg_box_size = 0;
  1130.     /*----------------------------------------------------------------*/
  1131.     /* Code Body                                                      */
  1132.     /*----------------------------------------------------------------*/
  1133.     *rsp_msg_number = 0;
  1135.     switch (msg_box_type)
  1136.     {
  1137.         case UM_MSG_BOX_TYPE_INBOX:
  1138.         {
  1139.             sms_msg_box_type = MMI_FRM_SMS_INBOX;
  1140.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_INBOX);
  1141.             break;
  1142.         }
  1143.         case UM_MSG_BOX_TYPE_UNSENT:
  1144.         {
  1145.             sms_msg_box_type = MMI_FRM_SMS_UNSENT;
  1146.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_UNSENT);
  1147.             break;
  1148.         }
  1149.         case UM_MSG_BOX_TYPE_SENT:
  1150.         {
  1151.             sms_msg_box_type = MMI_FRM_SMS_OUTBOX;
  1152.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_OUTBOX);
  1153.             break;
  1154.         }
  1155.         case UM_MSG_BOX_TYPE_DRAFT:
  1156.         {
  1157.             sms_msg_box_type = MMI_FRM_SMS_DRAFTS;
  1158.             sms_msg_box_size = mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_DRAFTS);
  1159.             break;
  1160.         }
  1161.         default:
  1162.         {
  1163.             MMI_ASSERT(0);
  1164.             break;
  1165.         }
  1166.     }
  1168.     for (; (i < req_msg_number); i++)
  1169.     {
  1170.         UI_time datetime;
  1171.         U8 sms_status;
  1173.         if (msg_box_type == UM_MSG_BOX_TYPE_UNSENT)
  1174.         {
  1175.             if (!mmi_frm_sms_get_next_unsent_msg(&msg_list_index))
  1176.             {
  1177.                 return KAL_TRUE;
  1178.             }
  1179.         }
  1180.         else if (msg_box_type == UM_MSG_BOX_TYPE_DRAFT)
  1181.         {
  1182.             if (!mmi_frm_sms_get_next_draft_msg(&msg_list_index))
  1183.             {
  1184.                 return KAL_TRUE;
  1185.             }
  1186.         }
  1187.         else
  1188.         {
  1189.             if (msg_list_index >= sms_msg_box_size)
  1190.             {
  1191.                 break;
  1192.             }
  1193.         }
  1195.         timestamp = mmi_frm_sms_get_timestamp(sms_msg_box_type, msg_list_index);
  1197.         if (timestamp[1] == 0)
  1198.         {
  1199.             msg_info[i].timestamp = 0;
  1200.         }
  1201.         else
  1202.         {
  1203.             datetime.nYear = timestamp[0] + 2000;
  1204.             if (datetime.nYear > 2090)
  1205.             {
  1206.                 datetime.nYear = datetime.nYear - 100;
  1207.             }
  1209.             datetime.nMonth = timestamp[1];
  1210.             datetime.nDay = timestamp[2];
  1212.             datetime.nHour = timestamp[3];
  1213.             datetime.nMin = timestamp[4];
  1214.             datetime.nSec = timestamp[5];
  1215.         #ifdef MMI_ON_HARDWARE_P
  1216.             msg_info[i].timestamp = mmi_dt_mytime_2_utc_sec((MYTIME*) & datetime, MMI_TRUE);
  1217.         #endif 
  1218.         }
  1219.         msg_info[i].msg_index = msg_list_index;
  1221.         msg_info[i].address_type = UM_ADDR_TYPE_PHONE_NUMBER;
  1222.         mmi_msg_get_address(sms_msg_box_type, msg_list_index, msg_info[i].address, MMI_UM_MAX_ADDR_LEN);
  1223.         msg_info[i].address_length = pfnUnicodeStrlen((S8*) msg_info[i].address);
  1225.         sms_status = mmi_frm_sms_get_sms_status(sms_msg_box_type, msg_list_index);
  1227.         if (!mmi_frm_sms_check_complete(sms_msg_box_type, msg_list_index))
  1228.         {
  1229.             pfnUnicodeStrncpy(
  1230.                 (S8*) msg_info[i].subject,
  1231.                 (S8*) GetString(STR_UM_INCOMPLETE_ID),
  1232.                 MMI_UM_MAX_SUBJECT_LEN);
  1233.             msg_info[i].subject_length = pfnUnicodeStrlen((S8*) GetString(STR_UM_INCOMPLETE_ID));
  1234.         }
  1235.         else if ((sms_status >> 4) == SMSAL_MTI_STATUS_REPORT)
  1236.         {
  1237.             pfnUnicodeStrncpy(
  1238.                 (S8*) msg_info[i].subject,
  1239.                 (S8*) GetString(STR_DELIVERY_REPORT_MENUENTRY),
  1240.                 MMI_UM_MAX_SUBJECT_LEN);
  1241.             msg_info[i].subject_length = pfnUnicodeStrlen((S8*) GetString(STR_DELIVERY_REPORT_MENUENTRY));
  1242.         }
  1243.         else if ((sms_status >> 4) == SMSAL_MTI_UNSPECIFIED)
  1244.         {
  1245.             pfnUnicodeStrncpy(
  1246.                 (S8*) msg_info[i].subject,
  1247.                 (S8*) GetString(STR_UM_NOT_SUPPORT_ID),
  1248.                 MMI_UM_MAX_SUBJECT_LEN);
  1249.             msg_info[i].subject_length = pfnUnicodeStrlen((S8*) GetString(STR_UM_NOT_SUPPORT_ID));
  1250.         }
  1251.         else
  1252.         {
  1253.             mmi_frm_sms_get_content(
  1254.                 sms_msg_box_type,
  1255.                 msg_list_index,
  1256.                 msg_info[i].subject,
  1257.                 (kal_uint8) mmi_msg_get_max_content_size());
  1258.             msg_info[i].subject_length = pfnUnicodeStrlen((S8*) msg_info[i].subject);
  1260.         #ifdef __MMI_MESSAGES_CHAT__
  1261.             if (CheckForInvitationMsg((U8*) msg_info[i].subject, msg_info[i].subject_length * 2, FALSE))
  1262.             {
  1263.                 S8 *chat_invitation_pattern = mmi_msg_chat_get_invitation_pattern();
  1264.                 U8 len = pfnUnicodeStrlen(chat_invitation_pattern);
  1266.                 memcpy(
  1267.                     (S8*) msg_info[i].subject,
  1268.                     (S8*) (msg_info[i].subject + len),
  1269.                     (msg_info[i].subject_length - len) * ENCODING_LENGTH);
  1270.                 memset(
  1271.                     (S8*) (msg_info[i].subject + (msg_info[i].subject_length - len) * ENCODING_LENGTH),
  1272.                     0,
  1273.                     len * ENCODING_LENGTH);
  1274.                 msg_info[i].subject_length -= len;
  1275.             }
  1276.         #endif /* __MMI_MESSAGES_CHAT__ */ 
  1277.         }
  1279.         msg_info[i].icon_id = mmi_msg_get_icon(sms_msg_box_type, msg_list_index);
  1281.         (*rsp_msg_number)++;
  1283.         msg_list_index++;
  1284.     }
  1286.     return KAL_TRUE;
  1287. }
  1290. /*****************************************************************************
  1291.  * FUNCTION
  1292.  *  mmi_msg_get_address
  1293.  * DESCRIPTION
  1294.  *  get sms address
  1295.  * PARAMETERS
  1296.  *  msg_type            [IN]        
  1297.  *  msg_index           [IN]        
  1298.  *  address             [?]         
  1299.  *  max_address_len     [IN]        
  1300.  * RETURNS
  1301.  *  void
  1302.  *****************************************************************************/
  1303. void mmi_msg_get_address(kal_uint8 msg_type, kal_uint16 msg_index, kal_wchar *address, kal_uint8 max_address_len)
  1304. {
  1305.     /*----------------------------------------------------------------*/
  1306.     /* Local Variables                                                */
  1307.     /*----------------------------------------------------------------*/
  1308.     S8 temp[(MAX_DIGITS_SMS + 1) * ENCODING_LENGTH];
  1309.     S8 *name;
  1311.     U8 type = msg_type;
  1312.     kal_uint16 index = msg_index;
  1314.     /*----------------------------------------------------------------*/
  1315.     /* Code Body                                                      */
  1316.     /*----------------------------------------------------------------*/
  1317.     if (((mmi_frm_sms_get_status(type, index) & 0xf0) >> 4) == SMSAL_MTI_STATUS_REPORT)
  1318.     {
  1319.         pfnUnicodeStrncpy((S8*) address, (S8*) GetString(STR_INBOX_REPORT_ID), max_address_len);
  1320.     }
  1321.     else
  1322.     {
  1323.         memset(temp, 0, (MAX_DIGITS_SMS + 1) * ENCODING_LENGTH);
  1324.         AnsiiToUnicodeString(temp, (S8*) mmi_frm_sms_get_address(type, index));
  1326.         if (pfnUnicodeStrlen(temp) == 0)
  1327.         {
  1328.             pfnUnicodeStrcpy((S8*) address, (S8*) GetString(STR_OUTBOX_LIST_MESSAGE));
  1329.         }
  1330.         else
  1331.         {
  1332.             name = lookUpNumber(temp);
  1333.             if (pfnUnicodeStrlen(name))
  1334.             {
  1335.                 pfnUnicodeStrcpy((S8*) address, name);
  1336.             }
  1337.             else
  1338.             {
  1339.                 pfnUnicodeStrcpy((S8*) address, temp);
  1340.             }
  1341.         }
  1342.     }
  1343. }
  1346. /*****************************************************************************
  1347.  * FUNCTION
  1348.  *  mmi_msg_get_icon
  1349.  * DESCRIPTION
  1350.  *  get sms icon id
  1351.  * PARAMETERS
  1352.  *  msg_type        [IN]        
  1353.  *  msg_index       [IN]        
  1354.  * RETURNS
  1355.  *  void
  1356.  *****************************************************************************/
  1357. kal_uint16 mmi_msg_get_icon(kal_uint8 msg_type, kal_uint16 msg_index)
  1358. {
  1359.     /*----------------------------------------------------------------*/
  1360.     /* Local Variables                                                */
  1361.     /*----------------------------------------------------------------*/
  1362.     kal_uint16 icon_id = 0;
  1364.     /*----------------------------------------------------------------*/
  1365.     /* Code Body                                                      */
  1366.     /*----------------------------------------------------------------*/
  1367.     if (msg_type == MMI_FRM_SMS_INBOX)
  1368.     {
  1369.         if ((mmi_frm_sms_get_status(msg_type, (U16) msg_index) & 0x0f) == MMI_FRM_SMS_APP_UNREAD)
  1370.         {
  1371.             icon_id = IMG_MESSAGE_UNREAD;
  1372.         }
  1373.         else
  1374.         {
  1375.             if (mmi_frm_sms_check_complete(msg_type, (U16) msg_index) == TRUE)
  1376.             {
  1377.                 icon_id = IMG_MESSAGE_READ;
  1378.             }
  1379.             else
  1380.             {
  1381.                 icon_id = IMG_MESSAGE_SS_NCOMP;
  1382.             }
  1383.         }
  1384.     }
  1385.     else
  1386.     {
  1387.         if (mmi_frm_sms_check_complete(msg_type, (U16) msg_index) == FALSE)
  1388.         {
  1389.             icon_id = IMG_MESSAGE_SS_NCOMP;
  1390.         }
  1391.         else
  1392.         {
  1393.             if (msg_type == MMI_FRM_SMS_OUTBOX)
  1394.             {
  1395.                 icon_id = IMG_MESSAGE_SENT;
  1396.             }
  1397.             else
  1398.             {
  1399.                 icon_id = IMG_MESSAGE_UNSENT;
  1400.             }
  1401.         }
  1402.     }
  1403.     return icon_id;
  1404. }
  1407. /*****************************************************************************
  1408.  * FUNCTION
  1409.  *  mmi_msg_handle_delete_folder_by_um
  1410.  * DESCRIPTION
  1411.  *  delete sms msg box
  1412.  * PARAMETERS
  1413.  *  msg_box_type        [IN]        
  1414.  * RETURNS
  1415.  *  void
  1416.  *****************************************************************************/
  1417. void mmi_msg_handle_delete_folder_by_um(UmMsgBoxType msg_box_type)
  1418. {
  1419.     /*----------------------------------------------------------------*/
  1420.     /* Local Variables                                                */
  1421.     /*----------------------------------------------------------------*/
  1422.     mmi_frm_sms_msgbox_enum sms_msg_box_type = 0;
  1423.     U16 index = MMI_FRM_SMS_INVALID_INDEX;
  1424.     U8 *bitmap = OslMalloc(sizeof(U8) * 480);
  1426.     /*----------------------------------------------------------------*/
  1427.     /* Code Body                                                      */
  1428.     /*----------------------------------------------------------------*/
  1429.     memset((S8*) bitmap, 0, sizeof(U8) * 480);
  1431.     if ((msg_box_type & UM_MSG_BOX_TYPE_INBOX))
  1432.     {
  1433.         sms_msg_box_type = MMI_FRM_SMS_INBOX;
  1434.         mmi_frm_sms_get_sms_bitmap((U8) sms_msg_box_type, index, bitmap);
  1435.     }
  1437.     if ((msg_box_type & UM_MSG_BOX_TYPE_SENT))
  1438.     {
  1439.         sms_msg_box_type = MMI_FRM_SMS_OUTBOX;
  1440.         mmi_frm_sms_get_sms_bitmap((U8) sms_msg_box_type, index, bitmap);
  1441.     }
  1443.     if ((msg_box_type & UM_MSG_BOX_TYPE_UNSENT))
  1444.     {
  1445.         U16 msg_list_index = 0;
  1447.         sms_msg_box_type = MMI_FRM_SMS_UNSENT;
  1449.         while (mmi_frm_sms_get_next_unsent_msg(&msg_list_index))
  1450.         {
  1451.             mmi_frm_sms_get_sms_bitmap((U8) sms_msg_box_type, msg_list_index, bitmap);
  1452.             msg_list_index++;
  1453.         }
  1454.     }
  1456.     if ((msg_box_type & UM_MSG_BOX_TYPE_DRAFT))
  1457.     {
  1458.         U16 msg_list_index = 0;
  1460.         sms_msg_box_type = MMI_FRM_SMS_DRAFTS;
  1462.         while (mmi_frm_sms_get_next_draft_msg(&msg_list_index))
  1463.         {
  1464.             mmi_frm_sms_get_sms_bitmap((U8) sms_msg_box_type, msg_list_index, bitmap);
  1465.             msg_list_index++;
  1466.         }
  1467.     }
  1469.     mmi_frm_sms_delete_sms_by_bitmap(mmi_msg_delete_folder_by_um_callback, MOD_MMI, bitmap);
  1471.     OslMfree(bitmap);
  1473. }
  1476. /*****************************************************************************
  1477.  * FUNCTION
  1478.  *  mmi_msg_delete_folder_by_um_callback
  1479.  * DESCRIPTION
  1480.  *  delete sms msg box
  1481.  * PARAMETERS
  1482.  *  dummy       [?]         
  1483.  *  mod         [IN]        
  1484.  *  result      [IN]        
  1485.  * RETURNS
  1486.  *  void
  1487.  *****************************************************************************/
  1488. void mmi_msg_delete_folder_by_um_callback(void *dummy, module_type mod, U16 result)
  1489. {
  1490.     /*----------------------------------------------------------------*/
  1491.     /* Local Variables                                                */
  1492.     /*----------------------------------------------------------------*/
  1493.     mmi_um_delete_folder_rsp_struct *msg =
  1494.         (mmi_um_delete_folder_rsp_struct*) OslConstructDataPtr(sizeof(mmi_um_delete_folder_rsp_struct));
  1496.     /*----------------------------------------------------------------*/
  1497.     /* Code Body                                                      */
  1498.     /*----------------------------------------------------------------*/
  1499.     if (result == MMI_FRM_SMS_OK)
  1500.     {
  1501.         msg->result = KAL_TRUE;
  1502.     }
  1503.     else
  1504.     {
  1505.         msg->result = KAL_FALSE;
  1506.     }
  1508.     if (mmi_frm_sms_get_sms_list_size(MMI_FRM_SMS_APP_INBOX) == 0)
  1509.     {
  1510.         mmi_msg_set_msg_icon(FALSE, FALSE);        
  1511.     }
  1512.     
  1513.     msg->msg_type = UM_MSG_TYPE_SMS;
  1514.     mmi_msg_send_message(MOD_MMI, MOD_MMI, 0, PRT_MSG_ID_MMI_UM_DELETE_FOLDER_RSP, (oslParaType*) msg, NULL);
  1515. }
  1517. #endif /* __MMI_UNIFIED_MESSAGE__ */
  1520. #if(!UI_DISABLE_EMS_CATEGORY_SCREENS)
  1521. #if(!EMS_USE_GSM_EXTENDED)
  1523. /* Call after EMSUnpack */
  1526. /*****************************************************************************
  1527.  * FUNCTION
  1528.  *  EMS_ConvertGSM7BitDefaultEncodingToAscii
  1529.  * DESCRIPTION
  1530.  *  
  1531.  * PARAMETERS
  1532.  *  data        [?]     
  1533.  * RETURNS
  1534.  *  void
  1535.  *****************************************************************************/
  1536. void EMS_ConvertGSM7BitDefaultEncodingToAscii(EMSData *data)
  1537. {
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1541.     U16 c, OffsetToText;
  1542.     U8 *textBuffer = data->textBuffer;
  1543.     U16 textBufferLength = data->textLength;
  1545.     /*----------------------------------------------------------------*/
  1546.     /* Code Body                                                      */
  1547.     /*----------------------------------------------------------------*/
  1548.     if (textBuffer == NULL)
  1549.     {
  1550.         return;
  1551.     }
  1552.     ResetCurrentPosition(data);
  1553.     while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1554.     {
  1555.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1556.         c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1557.     #else 
  1558.         c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1559.     #endif 
  1560.         if ((c & 0xff00) != 0)
  1561.         {
  1562.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1563.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1564.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1565.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1566.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  1567.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1568.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1569.         }
  1570.         else if (c == EMS_ESCAPE_CHARACTER)
  1571.         {
  1572.             c = EMS_SPACE_CHARACTER;
  1573.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1574.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1575.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1576.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1577.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  1578.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1579.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1580.         }
  1581.         else
  1582.         {
  1583.             if (c == EMS_CR_CHARACTER)
  1584.             {
  1585.                 ForwardCurrentPosition(data, 1);
  1586.                 CancelCurrentPosition(data, 1);
  1587.                 BackwardCurrentPosition(data, 1);
  1588.             }
  1589.             else
  1590.             {
  1591.                 c = DefaultToAsciiArray[c];
  1592.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1593.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1594.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1595.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1596.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  1597.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1598.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1599.             }
  1600.         }
  1601.         if (ForwardCurrentPosition(data, 1) != 1)
  1602.         {
  1603.             break;
  1604.         }
  1605.     }
  1606.     ResetCurrentPosition(data);
  1607. }
  1609. /* Call before EMSPack  */
  1612. /*****************************************************************************
  1613.  * FUNCTION
  1614.  *  EMS_ConvertAsciiEncodingToGSM7BitDefault
  1615.  * DESCRIPTION
  1616.  *  
  1617.  * PARAMETERS
  1618.  *  data        [?]     
  1619.  * RETURNS
  1620.  *  void
  1621.  *****************************************************************************/
  1622. void EMS_ConvertAsciiEncodingToGSM7BitDefault(EMSData *data)
  1623. {
  1624.     /*----------------------------------------------------------------*/
  1625.     /* Local Variables                                                */
  1626.     /*----------------------------------------------------------------*/
  1627.     U16 c, OffsetToText;
  1628.     U8 *textBuffer = data->textBuffer;
  1629.     U16 textBufferLength = data->textLength;
  1631.     /*----------------------------------------------------------------*/
  1632.     /* Code Body                                                      */
  1633.     /*----------------------------------------------------------------*/
  1634.     if (textBuffer == NULL)
  1635.     {
  1636.         return;
  1637.     }
  1638.     ResetCurrentPosition(data);
  1639.     while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1640.     {
  1641.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1642.         c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1643.     #else 
  1644.         c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1645.     #endif 
  1646.         if ((c & 0xff00) == 0)
  1647.         {
  1648.             c = AsciiToDefaultArray[c];
  1649.         }
  1650.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1651.         textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1652.         textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1653.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1654.         textBuffer[OffsetToText] = (U8) (c & 0xff);
  1655.         textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1656.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1657.         if (ForwardCurrentPosition(data, 1) != 1)
  1658.         {
  1659.             break;
  1660.         }
  1661.     }
  1662.     ResetCurrentPosition(data);
  1663. }
  1665. #if defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__)
  1667. /* Start : JP */
  1668. /* Call after EMSUnpack */
  1671. /*****************************************************************************
  1672.  * FUNCTION
  1673.  *  EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended
  1674.  * DESCRIPTION
  1675.  *  
  1676.  * PARAMETERS
  1677.  *  data        [?]     
  1678.  * RETURNS
  1679.  *  void
  1680.  *****************************************************************************/
  1681. void EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended(EMSData *data)
  1682. {
  1683.     /*----------------------------------------------------------------*/
  1684.     /* Local Variables                                                */
  1685.     /*----------------------------------------------------------------*/
  1686.     U16 c, OffsetToText;
  1687.     U8 *textBuffer = data->textBuffer;
  1688.     U16 textBufferLength = data->textLength;
  1689.     EMSObject *object;
  1691.     /*----------------------------------------------------------------*/
  1692.     /* Code Body                                                      */
  1693.     /*----------------------------------------------------------------*/
  1694.     if (textBuffer == NULL)
  1695.     {
  1696.         return;
  1697.     }
  1698.     ResetCurrentPosition(data);
  1699.     if (data->dcs == SMSAL_DEFAULT_DCS)
  1700.     {
  1701.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1702.         {
  1703.             if (gui_EMS_input_box_get_next_object(data, &data->CurrentPosition, &c, &object) != 1)
  1704.             {
  1705.                 continue;
  1706.             }
  1707.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1708.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1709.         #else 
  1710.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1711.         #endif 
  1712.             if (c == EMS_ESCAPE_CHARACTER)
  1713.             {
  1714.                 U16 next_char = 0;
  1716.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1717.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1718.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1720.                 if (ForwardCurrentPosition(data, 1) != 1)
  1721.                 {
  1722.                     break;
  1723.                 }
  1724.                 CancelCurrentPosition(data, 1);
  1725.                 OffsetToText = data->CurrentPosition.OffsetToText;
  1727.                 c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1728.                 c = DefaultToExtendedAsciiArray[c];
  1730.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1731.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1732.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1733.                 //textBuffer[OffsetToText]=(U8)(c&0xff);
  1734.                 //textBuffer[OffsetToText+1]=(U8)(c>>8);
  1735.                 next_char =
  1736.                     (U16) (textBuffer[data->CurrentPosition.OffsetToText] |
  1737.                            (textBuffer[data->CurrentPosition.OffsetToText + 1] << 8));
  1739.                 /* if(ForwardCurrentPosition(data,1)!=1) break; */
  1740.                 data->CurrentPosition.OffsetToText += ENCODING_LENGTH;  /* JP 20050701 */
  1741.                 CancelCurrentPosition(data, 1);
  1742.                 textBufferLength -= ENCODING_LENGTH;    /* JP */
  1744.                 /* OffsetToText=data->CurrentPosition.OffsetToText; */
  1746.                 /* c=(U16)(textBuffer[OffsetToText]|(textBuffer[OffsetToText+1]<<8)); */
  1747.                 c = next_char;
  1748.                 c = DefaultToExtendedAsciiArray[c];
  1749.                 if (c == 0x00)
  1750.                 {
  1751.                     textBuffer[OffsetToText] = (U8) (next_char & 0xff);
  1752.                     textBuffer[OffsetToText + 1] = (U8) (next_char >> 8);
  1753.                     data->CurrentPosition.OffsetToText -= 2;
  1754.                 }
  1755.                 else
  1756.                 {
  1757.                     textBuffer[OffsetToText] = (U8) (c & 0xff);
  1758.                     textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1759.                 }
  1760.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1761.             }
  1762.             else
  1763.             {
  1764.                 c = DefaultToAsciiArray[c];
  1765.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1766.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1767.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1768.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1769.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  1770.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1771.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1772.             }
  1773.             /* if(ForwardCurrentPosition(data,1)!=1) break; */
  1774.         }
  1775.     }
  1776.     else
  1777.     {
  1778.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1779.         {
  1780.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1781.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1782.         #else 
  1783.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1784.         #endif 
  1785.             /* if(c==EMS_EURO_CHARACTER_UCS2) c=EMS_EURO_CHARACTER; */
  1786.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1787.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1788.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1789.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1790.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  1791.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1792.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1793.             if (ForwardCurrentPosition(data, 1) != 1)
  1794.             {
  1795.                 break;
  1796.             }
  1797.         }
  1798.     }
  1799.     ResetCurrentPosition(data);
  1800. }
  1802. /* Call before EMSPack  */
  1805. /*****************************************************************************
  1806.  * FUNCTION
  1807.  *  EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended
  1808.  * DESCRIPTION
  1809.  *  
  1810.  * PARAMETERS
  1811.  *  data        [?]     
  1812.  * RETURNS
  1813.  *  void
  1814.  *****************************************************************************/
  1815. void EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended(EMSData *data)
  1816. {
  1817.     /*----------------------------------------------------------------*/
  1818.     /* Local Variables                                                */
  1819.     /*----------------------------------------------------------------*/
  1820.     U16 c, OffsetToText;
  1821.     U8 *textBuffer = data->textBuffer;
  1822.     U16 textBufferLength = data->textLength;
  1823.     EMSObject *object;
  1825. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1826.     U8 ESC_string[] = {0x00, 0x1B};
  1827. #else 
  1828.     U8 ESC_string[] = {0x1B, 0x00};
  1829. #endif 
  1831.     /*----------------------------------------------------------------*/
  1832.     /* Code Body                                                      */
  1833.     /*----------------------------------------------------------------*/
  1834.     if (textBuffer == NULL)
  1835.     {
  1836.         return;
  1837.     }
  1838.     ResetCurrentPosition(data);
  1840.     if (data->dcs == SMSAL_DEFAULT_DCS)
  1841.     {
  1842.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1843.         {
  1844.             if (gui_EMS_input_box_get_next_object(data, &data->CurrentPosition, &c, &object) != 1)
  1845.             {
  1846.                 continue;
  1847.             }
  1848.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1849.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1850.         #else 
  1851.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1852.         #endif 
  1853.             if (UI_TEST_GSM_EXTENDED(c))
  1854.             {
  1855.                 data->CurrentPosition.OffsetToText -= ENCODING_LENGTH;  /* JP 20050701 */
  1856.                 AddString(data, ESC_string, 1, NULL);
  1857.                 OffsetToText = data->CurrentPosition.OffsetToText;
  1858.                 /* MTK Elvis 20031126 */
  1859.                 textBufferLength += ENCODING_LENGTH;
  1860.                 /* MTK end */
  1861.                 c = ExtendedAsciiToDefaultArray[c];
  1862.                 data->CurrentPosition.OffsetToText += ENCODING_LENGTH;  /* JP 20050701 */
  1864.             }
  1865.             else
  1866.             {
  1867.                 c = AsciiToDefaultArray[c];
  1868.             }
  1869.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1870.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1871.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1872.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1873.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  1874.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1875.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1876.             // if(ForwardCurrentPosition(data,1)!=1) break; /* JP */
  1877.         }
  1878.     }
  1879.     else
  1880.     {
  1881.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1882.         {
  1883.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1884.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1885.         #else 
  1886.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1887.         #endif 
  1888.             /* if(c==EMS_EURO_CHARACTER) c=EMS_EURO_CHARACTER_UCS2; */
  1889.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1890.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1891.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1892.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1893.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  1894.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1895.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1896.             if (ForwardCurrentPosition(data, 1) != 1)
  1897.             {
  1898.                 break;
  1899.             }
  1900.         }
  1901.     }
  1902.     ResetCurrentPosition(data);
  1903. }
  1905. #else /* defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__) */ 
  1907. /* Call after EMSUnpack */
  1910. /*****************************************************************************
  1911.  * FUNCTION
  1912.  *  EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended
  1913.  * DESCRIPTION
  1914.  *  
  1915.  * PARAMETERS
  1916.  *  data        [?]     
  1917.  * RETURNS
  1918.  *  void
  1919.  *****************************************************************************/
  1920. void EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended(EMSData *data)
  1921. {
  1922.     /*----------------------------------------------------------------*/
  1923.     /* Local Variables                                                */
  1924.     /*----------------------------------------------------------------*/
  1925.     U16 c, OffsetToText;
  1926.     U8 *textBuffer = data->textBuffer;
  1927.     U16 textBufferLength = data->textLength;
  1929.     /*----------------------------------------------------------------*/
  1930.     /* Code Body                                                      */
  1931.     /*----------------------------------------------------------------*/
  1932.     if (textBuffer == NULL)
  1933.     {
  1934.         return;
  1935.     }
  1936.     ResetCurrentPosition(data);
  1937.     if (data->dcs == SMSAL_DEFAULT_DCS)
  1938.     {
  1939.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  1940.         {
  1941.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1942.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1943.         #else 
  1944.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1945.         #endif 
  1946.             if ((c & 0xff00) != 0)
  1947.             {
  1948.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1949.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1950.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1951.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1952.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  1953.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1954.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1955.             }
  1956.             else if (c == EMS_ESCAPE_CHARACTER)
  1957.             {
  1958.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1959.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1960.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1962.                 /* if(ForwardCurrentPosition(data,1)!=1) break; */
  1963.                 data->CurrentPosition.OffsetToText += 2;
  1964.                 if ((OffsetToText = data->CurrentPosition.OffsetToText) >= textBufferLength)
  1965.                 {
  1966.                     break;
  1967.                 }
  1969.                 OffsetToText = data->CurrentPosition.OffsetToText;
  1971.                 c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  1972.                 c = DefaultToExtendedAsciiArray[c];
  1973.                 if (c == 0x00)
  1974.                 {
  1975.                     CancelCurrentPosition(data, 1);
  1976.                     data->CurrentPosition.OffsetToText -= 2;
  1977.                 }
  1978.                 else
  1979.                 {
  1980.                     textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  1981.                     textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  1982.                 }
  1983.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1984.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  1985.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  1987.                 /* if(ForwardCurrentPosition(data,1)!=1) break; */
  1988.                 data->CurrentPosition.OffsetToText += 2;
  1990.                 OffsetToText = data->CurrentPosition.OffsetToText;
  1992.                 c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  1993.                 c = DefaultToExtendedAsciiArray[c];
  1994.                 if (c == 0x00)
  1995.                 {
  1996.                     CancelCurrentPosition(data, 1);
  1997.                     data->CurrentPosition.OffsetToText -= 2;
  1998.                 }
  1999.                 else
  2000.                 {
  2001.                     textBuffer[OffsetToText] = (U8) (c & 0xff);
  2002.                     textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2003.                 }
  2004.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2005.             }
  2006.             else
  2007.             {
  2008.                 c = DefaultToAsciiArray[c];
  2009.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2010.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2011.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2012.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2013.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2014.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2015.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2016.             }
  2017.             /* if(ForwardCurrentPosition(data,1)!=1) break; */
  2018.             data->CurrentPosition.OffsetToText += 2;
  2020.         }
  2021.     }
  2022.     else
  2023.     {
  2024.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2025.         {
  2026.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2027.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2028.         #else 
  2029.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2030.         #endif 
  2031.             /* if(c==EMS_EURO_CHARACTER_UCS2) c=EMS_EURO_CHARACTER; */
  2032.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2033.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2034.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2035.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2036.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2037.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2038.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2039.             /* if(ForwardCurrentPosition(data,1)!=1) break; */
  2040.             data->CurrentPosition.OffsetToText += 2;
  2042.         }
  2043.     }
  2044.     ResetCurrentPosition(data);
  2045. }
  2047. /* Call before EMSPack  */
  2050. /*****************************************************************************
  2051.  * FUNCTION
  2052.  *  EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended
  2053.  * DESCRIPTION
  2054.  *  
  2055.  * PARAMETERS
  2056.  *  data        [?]     
  2057.  * RETURNS
  2058.  *  void
  2059.  *****************************************************************************/
  2060. void EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended(EMSData *data)
  2061. {
  2062.     /*----------------------------------------------------------------*/
  2063.     /* Local Variables                                                */
  2064.     /*----------------------------------------------------------------*/
  2065.     U16 c, OffsetToText;
  2066.     U8 *textBuffer = data->textBuffer;
  2067.     U16 textBufferLength = data->textLength;
  2069.     /*----------------------------------------------------------------*/
  2070.     /* Code Body                                                      */
  2071.     /*----------------------------------------------------------------*/
  2072.     if (textBuffer == NULL)
  2073.     {
  2074.         return;
  2075.     }
  2076.     ResetCurrentPosition(data);
  2077.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2078.     {
  2079.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2080.         {
  2081.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2082.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2083.         #else 
  2084.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2085.         #endif 
  2086.             if ((c & 0xff00) == 0)
  2087.             {
  2088.                 if (c == EMS_ESCAPE_CHARACTER)
  2089.                 {
  2090.                 #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2091.                     textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2092.                     textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2093.                 #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2094.                     textBuffer[OffsetToText] = (U8) (c & 0xff);
  2095.                     textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2096.                 #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2097.                     /* if(ForwardCurrentPosition(data,1)!=1) break; */
  2098.                     data->CurrentPosition.OffsetToText += 2;
  2099.                     if ((OffsetToText = data->CurrentPosition.OffsetToText) >= textBufferLength)
  2100.                     {
  2101.                         break;
  2102.                     }
  2103.                     OffsetToText = data->CurrentPosition.OffsetToText;
  2105.                 #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2106.                     c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2107.                 #else 
  2108.                     c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2109.                 #endif 
  2110.                     c = ExtendedAsciiToDefaultArray[c];
  2111.                 }
  2112.                 else
  2113.                 {
  2114.                     c = AsciiToDefaultArray[c];
  2115.                 }
  2116.             }
  2117.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2118.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2119.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2120.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2121.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2122.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2123.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2124.             /* if(ForwardCurrentPosition(data,1)!=1) break; */
  2125.             data->CurrentPosition.OffsetToText += 2;
  2126.         }
  2127.     }
  2128.     else
  2129.     {
  2130.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2131.         {
  2132.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2133.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2134.         #else 
  2135.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2136.         #endif 
  2137.             /* if(c==EMS_EURO_CHARACTER) c=EMS_EURO_CHARACTER_UCS2; */
  2138.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2139.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2140.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2141.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2142.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2143.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2144.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2145.             /* if(ForwardCurrentPosition(data,1)!=1) break; */
  2146.             data->CurrentPosition.OffsetToText += 2;
  2147.         }
  2148.     }
  2149.     ResetCurrentPosition(data);
  2150. }
  2152. #endif /* defined(__MMI_SMART_MESSAGE_MO__) && !defined(__MMI_MESSAGES_EMS__) */ 
  2153. /* End : JP */
  2156. /*****************************************************************************
  2157.  * FUNCTION
  2158.  *  EMS_ConvertGSM7BitDefaultEncodingToAsciiWithoutEMSlib
  2159.  * DESCRIPTION
  2160.  *  
  2161.  * PARAMETERS
  2162.  *  data        [?]     
  2163.  * RETURNS
  2164.  *  void
  2165.  *****************************************************************************/
  2166. void EMS_ConvertGSM7BitDefaultEncodingToAsciiWithoutEMSlib(EMSData *data)
  2167. {
  2168.     /*----------------------------------------------------------------*/
  2169.     /* Local Variables                                                */
  2170.     /*----------------------------------------------------------------*/
  2171.     U16 c, OffsetToText;
  2172.     U8 *textBuffer = data->textBuffer;
  2173.     U16 textBufferLength = data->textLength;
  2175.     /*----------------------------------------------------------------*/
  2176.     /* Code Body                                                      */
  2177.     /*----------------------------------------------------------------*/
  2178.     if (textBuffer == NULL)
  2179.     {
  2180.         return;
  2181.     }
  2182.     data->CurrentPosition.OffsetToText = 0;
  2183.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2184.     {
  2185.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2186.         {
  2187.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2188.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2189.         #else 
  2190.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2191.         #endif 
  2192.             if ((c & 0xff00) != 0)
  2193.             {
  2194.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2195.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2196.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2197.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2198.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2199.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2200.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2201.             }
  2202.             else if (c == EMS_ESCAPE_CHARACTER)
  2203.             {
  2205.                 U16 tempOffsetToText = data->CurrentPosition.OffsetToText;
  2207.                 while ((tempOffsetToText + 2) < textBufferLength)
  2208.                 {
  2209.                     textBuffer[tempOffsetToText] = textBuffer[tempOffsetToText + 2];
  2210.                     textBuffer[tempOffsetToText + 1] = textBuffer[tempOffsetToText + 3];
  2211.                     tempOffsetToText = tempOffsetToText + 2;
  2212.                 }
  2213.                 textBuffer[tempOffsetToText] = 0;
  2214.                 textBuffer[tempOffsetToText + 1] = 0;
  2215.                 textBufferLength = textBufferLength - 2;
  2216.                 data->textLength = data->textLength - 2;
  2218.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2219.                 //textBuffer[OffsetToText+1]=(U8)(c&0xff);
  2220.                 //textBuffer[OffsetToText+0]=(U8)(c>>8);
  2222.                 if ((data->CurrentPosition.OffsetToText + 2) > textBufferLength)
  2223.                 {
  2224.                     break;
  2225.                 }
  2226.                 OffsetToText = data->CurrentPosition.OffsetToText;
  2228.                 c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2229.                 c = DefaultToExtendedAsciiArray[c];
  2231.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2232.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2233.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2234.                 //textBuffer[OffsetToText]=(U8)(c&0xff);
  2235.                 //textBuffer[OffsetToText+1]=(U8)(c>>8);
  2237.                 if ((data->CurrentPosition.OffsetToText + 2) > textBufferLength)
  2238.                 {
  2239.                     break;
  2240.                 }
  2241.                 OffsetToText = data->CurrentPosition.OffsetToText;
  2243.                 c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2244.                 c = DefaultToExtendedAsciiArray[c];
  2246.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2247.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2248.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2249.             }
  2250.             else
  2251.             {
  2252.                 c = DefaultToAsciiArray[c];
  2253.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2254.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2255.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2256.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2257.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2258.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2259.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2260.             }
  2261.             data->CurrentPosition.OffsetToText += 2;
  2262.         }
  2263.     }
  2264.     else
  2265.     {
  2266.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2267.         {
  2268.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2269.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2270.         #else 
  2271.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2272.         #endif 
  2273.             /* if(c==EMS_EURO_CHARACTER_UCS2) c=EMS_EURO_CHARACTER; */
  2274.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2275.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2276.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2277.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2278.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2279.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2280.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2281.             data->CurrentPosition.OffsetToText += 2;
  2282.         }
  2283.     }
  2284.     data->CurrentPosition.OffsetToText = 0;
  2285. }
  2287. #else /* (!EMS_USE_GSM_EXTENDED) */ 
  2289. /* Call after EMSUnpack */
  2292. /*****************************************************************************
  2293.  * FUNCTION
  2294.  *  EMS_ConvertGSM7BitDefaultEncodingToAscii
  2295.  * DESCRIPTION
  2296.  *  
  2297.  * PARAMETERS
  2298.  *  data        [?]     
  2299.  * RETURNS
  2300.  *  void
  2301.  *****************************************************************************/
  2302. void EMS_ConvertGSM7BitDefaultEncodingToAscii(EMSData *data)
  2303. {
  2304.     /*----------------------------------------------------------------*/
  2305.     /* Local Variables                                                */
  2306.     /*----------------------------------------------------------------*/
  2307.     U16 c, OffsetToText;
  2308.     U8 *textBuffer = data->textBuffer;
  2309.     U16 textBufferLength = data->textLength;
  2311.     /*----------------------------------------------------------------*/
  2312.     /* Code Body                                                      */
  2313.     /*----------------------------------------------------------------*/
  2314.     if (textBuffer == NULL)
  2315.     {
  2316.         return;
  2317.     }
  2318.     ResetCurrentPosition(data);
  2319.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2320.     {
  2321.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2322.         {
  2323.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2324.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2325.         #else 
  2326.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2327.         #endif 
  2328.             if (c == EMS_ESCAPE_CHARACTER)
  2329.             {
  2330.                 c = EMS_SPACE_CHARACTER;
  2331.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2332.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2333.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2334.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2335.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2336.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2337.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2338.             }
  2339.             else
  2340.             {
  2341.                 c = DefaultToAsciiArray[c];
  2342.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2343.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2344.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2345.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2346.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2347.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2348.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2349.             }
  2350.             if (ForwardCurrentPosition(data, 1) != 1)
  2351.             {
  2352.                 break;
  2353.             }
  2354.         }
  2355.     }
  2356.     else
  2357.     {
  2358.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2359.         {
  2360.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2361.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2362.         #else 
  2363.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2364.         #endif 
  2365.             /* if(c==EMS_EURO_CHARACTER_UCS2) c=EMS_EURO_CHARACTER; */
  2366.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2367.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2368.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2369.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2370.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2371.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2372.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2373.             if (ForwardCurrentPosition(data, 1) != 1)
  2374.             {
  2375.                 break;
  2376.             }
  2377.         }
  2378.     }
  2379.     ResetCurrentPosition(data);
  2380. }
  2382. /* Call before EMSPack  */
  2385. /*****************************************************************************
  2386.  * FUNCTION
  2387.  *  EMS_ConvertAsciiEncodingToGSM7BitDefault
  2388.  * DESCRIPTION
  2389.  *  
  2390.  * PARAMETERS
  2391.  *  data        [?]     
  2392.  * RETURNS
  2393.  *  void
  2394.  *****************************************************************************/
  2395. void EMS_ConvertAsciiEncodingToGSM7BitDefault(EMSData *data)
  2396. {
  2397.     /*----------------------------------------------------------------*/
  2398.     /* Local Variables                                                */
  2399.     /*----------------------------------------------------------------*/
  2400.     U16 c, OffsetToText;
  2401.     U8 *textBuffer = data->textBuffer;
  2402.     U16 textBufferLength = data->textLength;
  2404.     /*----------------------------------------------------------------*/
  2405.     /* Code Body                                                      */
  2406.     /*----------------------------------------------------------------*/
  2407.     if (textBuffer == NULL)
  2408.     {
  2409.         return;
  2410.     }
  2411.     ResetCurrentPosition(data);
  2412.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2413.     {
  2414.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2415.         {
  2416.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2417.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2418.         #else 
  2419.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2420.         #endif 
  2421.             c = AsciiToDefaultArray[c];
  2422.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2423.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2424.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2425.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2426.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2427.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2428.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2429.             if (ForwardCurrentPosition(data, 1) != 1)
  2430.             {
  2431.                 break;
  2432.             }
  2433.         }
  2434.     }
  2435.     else
  2436.     {
  2437.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2438.         {
  2439.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2440.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2441.         #else 
  2442.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2443.         #endif 
  2444.             /* if(c==EMS_EURO_CHARACTER) c=EMS_EURO_CHARACTER_UCS2; */
  2445.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2446.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2447.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2448.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2449.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2450.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2451.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2452.             if (ForwardCurrentPosition(data, 1) != 1)
  2453.             {
  2454.                 break;
  2455.             }
  2456.         }
  2457.     }
  2458.     ResetCurrentPosition(data);
  2459. }
  2461. /* Call after EMSUnpack */
  2464. /*****************************************************************************
  2465.  * FUNCTION
  2466.  *  EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended
  2467.  * DESCRIPTION
  2468.  *  
  2469.  * PARAMETERS
  2470.  *  data        [?]     
  2471.  * RETURNS
  2472.  *  void
  2473.  *****************************************************************************/
  2474. void EMS_ConvertGSM7BitDefaultEncodingToAsciiWithExtended(EMSData *data)
  2475. {
  2476.     /*----------------------------------------------------------------*/
  2477.     /* Local Variables                                                */
  2478.     /*----------------------------------------------------------------*/
  2479.     U16 c, OffsetToText;
  2480.     U8 *textBuffer = data->textBuffer;
  2481.     U16 textBufferLength = data->textLength;
  2482.     EMSObject *object;
  2484.     /*----------------------------------------------------------------*/
  2485.     /* Code Body                                                      */
  2486.     /*----------------------------------------------------------------*/
  2487.     if (textBuffer == NULL)
  2488.     {
  2489.         return;
  2490.     }
  2491.     ResetCurrentPosition(data);
  2492.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2493.     {
  2494.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2495.         {
  2496.             if (gui_EMS_input_box_get_next_object(data, &data->CurrentPosition, &c, &object) != 1)
  2497.             {
  2498.                 continue;
  2499.             }
  2500.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2501.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2502.         #else 
  2503.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2504.         #endif 
  2505.             if (c == EMS_ESCAPE_CHARACTER)
  2506.             {
  2507.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2508.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2509.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2511.                 if (ForwardCurrentPosition(data, 1) != 1)
  2512.                 {
  2513.                     break;
  2514.                 }
  2515.                 CancelCurrentPosition(data, 1);
  2516.                 OffsetToText = data->CurrentPosition.OffsetToText;
  2518.                 c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2519.                 c = DefaultToExtendedAsciiArray[c];
  2521.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2522.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2523.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2524.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2525.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2527.                 if (ForwardCurrentPosition(data, 1) != 1)
  2528.                 {
  2529.                     break;
  2530.                 }
  2531.                 CancelCurrentPosition(data, 1);
  2532.                 OffsetToText = data->CurrentPosition.OffsetToText;
  2534.                 c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2535.                 c = DefaultToExtendedAsciiArray[c];
  2537.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2538.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2539.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2540.             }
  2541.             else
  2542.             {
  2543.                 c = DefaultToAsciiArray[c];
  2544.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2545.                 textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2546.                 textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2547.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2548.                 textBuffer[OffsetToText] = (U8) (c & 0xff);
  2549.                 textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2550.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2551.             }
  2552.             if (ForwardCurrentPosition(data, 1) != 1)
  2553.             {
  2554.                 break;
  2555.             }
  2556.         }
  2557.     }
  2558.     else
  2559.     {
  2560.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2561.         {
  2562.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2563.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2564.         #else 
  2565.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2566.         #endif 
  2567.             /* if(c==EMS_EURO_CHARACTER_UCS2) c=EMS_EURO_CHARACTER; */
  2568.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2569.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2570.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2571.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2572.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2573.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2574.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2575.             if (ForwardCurrentPosition(data, 1) != 1)
  2576.             {
  2577.                 break;
  2578.             }
  2579.         }
  2580.     }
  2581.     ResetCurrentPosition(data);
  2582. }
  2584. /* Call before EMSPack  */
  2587. /*****************************************************************************
  2588.  * FUNCTION
  2589.  *  EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended
  2590.  * DESCRIPTION
  2591.  *  
  2592.  * PARAMETERS
  2593.  *  data        [?]     
  2594.  * RETURNS
  2595.  *  void
  2596.  *****************************************************************************/
  2597. void EMS_ConvertAsciiEncodingToGSM7BitDefaultWithExtended(EMSData *data)
  2598. {
  2599.     /*----------------------------------------------------------------*/
  2600.     /* Local Variables                                                */
  2601.     /*----------------------------------------------------------------*/
  2602.     U16 c, OffsetToText;
  2603.     U8 *textBuffer = data->textBuffer;
  2604.     U16 textBufferLength = data->textLength;
  2605.     EMSObject *object;
  2607. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2608.     U8 ESC_string[] = {0x00, 0x1B};
  2609. #else 
  2610.     U8 ESC_string[] = {0x1B, 0x00};
  2611. #endif 
  2613.     /*----------------------------------------------------------------*/
  2614.     /* Code Body                                                      */
  2615.     /*----------------------------------------------------------------*/
  2616.     if (textBuffer == NULL)
  2617.     {
  2618.         return;
  2619.     }
  2620.     ResetCurrentPosition(data);
  2622.     if (data->dcs == SMSAL_DEFAULT_DCS)
  2623.     {
  2624.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2625.         {
  2626.             if (gui_EMS_input_box_get_next_object(data, &data->CurrentPosition, &c, &object) != 1)
  2627.             {
  2628.                 continue;
  2629.             }
  2630.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2631.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2632.         #else 
  2633.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2634.         #endif 
  2635.             if (UI_TEST_GSM_EXTENDED(c))
  2636.             {
  2637.                 AddString(data, ESC_string, 1, NULL);
  2638.                 OffsetToText = data->CurrentPosition.OffsetToText;
  2639.                 /* MTK Elvis 20031126 */
  2640.                 textBufferLength += ENCODING_LENGTH;
  2641.                 /* MTK end */
  2642.                 c = ExtendedAsciiToDefaultArray[c];
  2643.             }
  2644.             else
  2645.             {
  2646.                 c = AsciiToDefaultArray[c];
  2647.             }
  2648.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2649.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2650.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2651.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2652.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2653.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2654.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2655.             if (ForwardCurrentPosition(data, 1) != 1)
  2656.             {
  2657.                 break;
  2658.             }
  2659.         }
  2660.     }
  2661.     else
  2662.     {
  2663.         while ((OffsetToText = data->CurrentPosition.OffsetToText) < textBufferLength)
  2664.         {
  2665.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2666.             c = (U16) (textBuffer[OffsetToText + 1] | (textBuffer[OffsetToText] << 8));
  2667.         #else 
  2668.             c = (U16) (textBuffer[OffsetToText] | (textBuffer[OffsetToText + 1] << 8));
  2669.         #endif 
  2670.             /* if(c==EMS_EURO_CHARACTER) c=EMS_EURO_CHARACTER_UCS2; */
  2671.         #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2672.             textBuffer[OffsetToText + 1] = (U8) (c & 0xff);
  2673.             textBuffer[OffsetToText + 0] = (U8) (c >> 8);
  2674.         #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2675.             textBuffer[OffsetToText] = (U8) (c & 0xff);
  2676.             textBuffer[OffsetToText + 1] = (U8) (c >> 8);
  2677.         #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2678.             if (ForwardCurrentPosition(data, 1) != 1)
  2679.             {
  2680.                 break;
  2681.             }
  2682.         }
  2683.     }
  2684.     ResetCurrentPosition(data);
  2685. }
  2687. #endif /* (!EMS_USE_GSM_EXTENDED) */
  2688. #endif /* (!UI_DISABLE_EMS_CATEGORY_SCREENS) */ 
  2691. #endif /* __MOD_SMSAL__ */