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

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

MTK

开发平台：

C/C++

TextPhoneControl.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  35. /*******************************************************************************
  36.  *  Modification Notice:
  37.  *  --------------------------
  38.  *  This software is modified by MediaTek Inc. and the information contained
  39.  *  herein is confidential. The software may not be copied and the information
  40.  *  contained herein may not be used or disclosed except with the written
  41.  *  permission of MediaTek Inc. (C) 2001
  42.  *
  43.  *******************************************************************************/
  45.  /*******************************************************************************
  46.  * Filename:
  47.  * ---------
  48.  *   TextPhoneControl.c
  49.  *
  50.  * Project:
  51.  * --------
  52.  *   Maui_Software
  53.  *
  54.  * Description:
  55.  * ------------
  56.  *  .......
  57.  *
  58.  * Author:
  59.  * -------
  60.  * -------
  61.  *
  62.  *------------------------------------------------------------------------------
  63.  * $Log$
  64.  *
  65.  * removed!
  66.  * removed!
  67.  * 
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * 
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * 
  76.  *
  77.  * removed!
  78.  * removed!
  79.  * 
  80.  *
  81.  * removed!
  82.  * removed!
  83.  * 
  84.  *
  85.  * removed!
  86.  * removed!
  87.  * 
  88.  *
  89.  * removed!
  90.  * removed!
  91.  * 
  92.  *
  93.  * removed!
  94.  * removed!
  95.  * 
  96.  *
  97.  * removed!
  98.  * removed!
  99.  * 
  100.  *
  101.  * removed!
  102.  * removed!
  103.  * 
  104.  *
  105.  * removed!
  106.  * removed!
  107.  * 
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * 
  112.  *
  113.  * removed!
  114.  * removed!
  115.  * 
  116.  *
  117.  * removed!
  118.  * removed!
  119.  * 
  120.  *
  121.  * removed!
  122.  * removed!
  123.  * 
  124.  *
  125.  * removed!
  126.  * removed!
  127.  * 
  128.  *
  129.  * removed!
  130.  * removed!
  131.  * 
  132.  *
  133.  * removed!
  134.  * removed!
  135.  * 
  136.  *
  137.  * removed!
  138.  * removed!
  139.  * 
  140.  *
  141.  *******************************************************************************/
  143. #ifdef __CTM_SUPPORT__
  145. // #define __CTM_DEBUG
  147. #include "stdC.h"
  148. #include "MMI_Features.h"
  149. #include "L4Dr.h"
  150. #include "L4Dr1.h"
  151. #include "TimerEvents.h"
  152. #include "PixtelDataTypes.h"
  153. #include "DebugInitDef.h"
  154. #include "EventsGprot.h"
  155. #include "GlobalDefs.h"
  156. #include "GlobalConstants.h"
  157. #include "GlobalMenuItems.h"
  158. #include "QueueGprot.h"
  159. #include "HistoryGprot.h"
  160. #include "CommonScreens.h"
  161. #include "NVRAMEnum.h"
  162. #include "NVRAMType.h"
  163. #include "NVRAMProt.h"
  165. #include "wgui_categories.h"
  166. #include "wgui_categories_util.h"
  167. #include "wgui_categories_inputs.h"
  168. #include "wgui_status_icons.h"
  169. #include "wgui_tab_bars.h"
  170. #include "wgui_categories_IMPS.h"
  172. #include "gpioInc.h"
  173. #include "SettingProfile.h"
  174. #include "CallManagementIDDef.h"
  175. #include "CallManagementStruct.h"
  176. #include "OutgoingCallHelperProt.h"
  177. #include "OutgoingCallManagementProt.h"
  179. #include "TextPhoneDef.h"
  180. #include "TextPhoneProt.h"
  183. static mmi_ctm_context_struct g_ctm_cntxt;
  184. mmi_ctm_context_struct *ctm_p = &g_ctm_cntxt;
  187. /*****************************************************************************
  188.  * FUNCTION
  189.  *  mmi_init_ctm_call
  190.  * DESCRIPTION
  191.  *  To Initialize the CTM Call application
  192.  *  
  193.  *  This function sets up the handlers required for event flow and
  194.  *  application management
  195.  * PARAMETERS
  196.  *  void
  197.  * RETURNS
  198.  *  void
  199.  *****************************************************************************/
  200. void mmi_init_ctm_call(void)
  201. {
  202.     /*----------------------------------------------------------------*/
  203.     /* Local Variables                                                */
  204.     /*----------------------------------------------------------------*/
  205.     S16 error;
  207.     /*----------------------------------------------------------------*/
  208.     /* Code Body                                                      */
  209.     /*----------------------------------------------------------------*/
  210.     memset(ctm_p, 0, sizeof(mmi_ctm_context_struct));
  212.     ReadValue(NVRAM_CTM_MODE, &ctm_p->status, DS_BYTE, &error);
  213.     ReadValue(NVRAM_CTM_SETTING, &ctm_p->mode_setting, DS_BYTE, &error);
  214.     if (ctm_p->status == 0xff)
  215.     {
  216.         ctm_p->status = FALSE;
  217.     }
  218.     if (ctm_p->mode_setting == 0xff)
  219.     {
  220.         ctm_p->mode_setting = MMI_CTM_SETTING_MANUAL_DIRECT;
  221.     }
  223.     mmi_ctm_send_get_default_req();
  225.     SetHiliteHandler(MITEM_CTM_MENU, highlight_ctm_main);
  226.     SetHiliteHandler(MITEM_CTM_MODE, highlight_ctm_mode);
  227.     SetHiliteHandler(MITEM_CTM_SETTING, highlight_ctm_setting);
  229.     SetHiliteHandler(MITEM_CTM_EDITOR_DONE, highlight_ctm_edit_done);
  230.     SetHiliteHandler(MITEM_CTM_INPUT_METHOD, highlight_ctm_input_method);
  232.     SetHintHandler(MITEM_CTM_MODE, hint_ctm_mode);
  234.     SetProtocolEventHandler(mmi_ctm_get_default_rsp_hdlr, MSG_ID_MMI_CTM_DEFAULT_CHANGED_IND);
  235.     SetProtocolEventHandler(mmi_ctm_connect_ind_hdlr, MSG_ID_MMI_CTM_CONNECTED_IND);
  236.     SetProtocolEventHandler(mmi_ctm_recv_text_ind_hdlr, MSG_ID_MMI_CTM_RECV_TEXT_IND);
  237.     /* SetProtocolEventHandler (mmi_ctm_tty_plug_ind_hdlr, MSG_ID_MMI_CTM_TTY_PLUG_IND); */
  238. }
  241. /*****************************************************************************
  242.  * FUNCTION
  243.  *  mmi_ctm_get_state
  244.  * DESCRIPTION
  245.  *  
  246.  * PARAMETERS
  247.  *  void
  248.  *  void(?)     [IN]        *
  249.  * RETURNS
  250.  *  void
  251.  *****************************************************************************/
  252. U8 mmi_ctm_get_state(void)
  253. {
  254.     /*----------------------------------------------------------------*/
  255.     /* Local Variables                                                */
  256.     /*----------------------------------------------------------------*/
  258.     /*----------------------------------------------------------------*/
  259.     /* Code Body                                                      */
  260.     /*----------------------------------------------------------------*/
  261.     return (U8) ctm_p->state;
  262. }
  265. /*****************************************************************************
  266.  * FUNCTION
  267.  *  mmi_ctm_set_state
  268.  * DESCRIPTION
  269.  *  
  270.  * PARAMETERS
  271.  *  state       [IN]        
  272.  *  void(?)     [IN]        *
  273.  * RETURNS
  274.  *  void
  275.  *****************************************************************************/
  276. void mmi_ctm_set_state(U8 state)
  277. {
  278.     /*----------------------------------------------------------------*/
  279.     /* Local Variables                                                */
  280.     /*----------------------------------------------------------------*/
  282.     /*----------------------------------------------------------------*/
  283.     /* Code Body                                                      */
  284.     /*----------------------------------------------------------------*/
  285.     PRINT_INFORMATION(("n SET CTM STATE:%d n", state));
  287.     ctm_p->state = state;
  288. }
  291. /*****************************************************************************
  292.  * FUNCTION
  293.  *  mmi_ctm_reset_buffer
  294.  * DESCRIPTION
  295.  *  
  296.  * PARAMETERS
  297.  *  void
  298.  *  void(?)     [IN]        *
  299.  * RETURNS
  300.  *  void
  301.  *****************************************************************************/
  302. void mmi_ctm_reset_buffer(void)
  303. {
  304.     /*----------------------------------------------------------------*/
  305.     /* Local Variables                                                */
  306.     /*----------------------------------------------------------------*/
  308.     /*----------------------------------------------------------------*/
  309.     /* Code Body                                                      */
  310.     /*----------------------------------------------------------------*/
  311.     memset(ctm_p->remote_buffer, 0, MAX_CTM_DATA_BUFFER_LEN);
  312.     memset(ctm_p->local_buffer, 0, MAX_CTM_DATA_BUFFER_LEN);
  313.     memset(ctm_p->pending_buffer, 0, MAX_CTM_EDITOR_BUFFER_LEN);
  314.     memset(ctm_p->editor_buffer, 0, MAX_CTM_EDITOR_BUFFER_LEN);
  315.     ctm_p->remote_len = 0;
  316.     ctm_p->local_len = 0;
  317.     ctm_p->pending_len = 0;
  318.     ctm_p->sent_len = 0;
  319. }
  322. /*****************************************************************************
  323.  * FUNCTION
  324.  *  highlight_ctm_main
  325.  * DESCRIPTION
  326.  *  
  327.  * PARAMETERS
  328.  *  void
  329.  *  void(?)     [IN]        *
  330.  * RETURNS
  331.  *  void
  332.  *****************************************************************************/
  333. void highlight_ctm_main(void)
  334. {
  335.     /*----------------------------------------------------------------*/
  336.     /* Local Variables                                                */
  337.     /*----------------------------------------------------------------*/
  339.     /*----------------------------------------------------------------*/
  340.     /* Code Body                                                      */
  341.     /*----------------------------------------------------------------*/
  342.     ChangeLeftSoftkey(STR_GLOBAL_OK, 0);
  343.     SetLeftSoftkeyFunction(entry_ctm_menu, KEY_EVENT_UP);
  344.     SetKeyHandler(entry_ctm_menu, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  345.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  346. }
  349. /*****************************************************************************
  350.  * FUNCTION
  351.  *  highlight_ctm_mode
  352.  * DESCRIPTION
  353.  *  
  354.  * PARAMETERS
  355.  *  void
  356.  *  void(?)     [IN]        *
  357.  * RETURNS
  358.  *  void
  359.  *****************************************************************************/
  360. void highlight_ctm_mode(void)
  361. {
  362.     /*----------------------------------------------------------------*/
  363.     /* Local Variables                                                */
  364.     /*----------------------------------------------------------------*/
  366.     /*----------------------------------------------------------------*/
  367.     /* Code Body                                                      */
  368.     /*----------------------------------------------------------------*/
  369.     if (ctm_p->status == TRUE)
  370.     {
  371.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  372.     }
  373.     else
  374.     {
  375.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  376.     }
  378.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  379.     SetLeftSoftkeyFunction(mmi_ctm_toggle_mode, KEY_EVENT_UP);
  380. }
  383. /*****************************************************************************
  384.  * FUNCTION
  385.  *  highlight_ctm_setting
  386.  * DESCRIPTION
  387.  *  
  388.  * PARAMETERS
  389.  *  void
  390.  *  void(?)     [IN]        *
  391.  * RETURNS
  392.  *  void
  393.  *****************************************************************************/
  394. void highlight_ctm_setting(void)
  395. {
  396.     /*----------------------------------------------------------------*/
  397.     /* Local Variables                                                */
  398.     /*----------------------------------------------------------------*/
  400.     /*----------------------------------------------------------------*/
  401.     /* Code Body                                                      */
  402.     /*----------------------------------------------------------------*/
  403.     ChangeLeftSoftkey(STR_GLOBAL_OK, 0);
  404.     SetLeftSoftkeyFunction(entry_ctm_setting_selection, KEY_EVENT_UP);
  405.     SetKeyHandler(entry_ctm_setting_selection, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  406. }
  409. /*****************************************************************************
  410.  * FUNCTION
  411.  *  highlight_ctm_setting_items
  412.  * DESCRIPTION
  413.  *  
  414.  * PARAMETERS
  415.  *  index       [IN]        
  416.  *  void(?)     [IN]        *
  417.  * RETURNS
  418.  *  void
  419.  *****************************************************************************/
  420. void highlight_ctm_setting_items(S32 index)
  421. {
  422.     /*----------------------------------------------------------------*/
  423.     /* Local Variables                                                */
  424.     /*----------------------------------------------------------------*/
  426.     /*----------------------------------------------------------------*/
  427.     /* Code Body                                                      */
  428.     /*----------------------------------------------------------------*/
  429.     ctm_p->index = index;
  430. }
  433. /*****************************************************************************
  434.  * FUNCTION
  435.  *  highlight_ctm_edit_done
  436.  * DESCRIPTION
  437.  *  highlight handler for change input method in editor option
  438.  * PARAMETERS
  439.  *  void
  440.  * RETURNS
  441.  *  void
  442.  *****************************************************************************/
  443. void highlight_ctm_edit_done(void)
  444. {
  445.     /*----------------------------------------------------------------*/
  446.     /* Local Variables                                                */
  447.     /*----------------------------------------------------------------*/
  449.     /*----------------------------------------------------------------*/
  450.     /* Code Body                                                      */
  451.     /*----------------------------------------------------------------*/
  452.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  453.     SetLeftSoftkeyFunction(mmi_ctm_edit_done, KEY_EVENT_UP);
  454. }
  457. /*****************************************************************************
  458.  * FUNCTION
  459.  *  highlight_ctm_input_method
  460.  * DESCRIPTION
  461.  *  highlight handler for change input method in editor option
  462.  * PARAMETERS
  463.  *  void
  464.  * RETURNS
  465.  *  void
  466.  *****************************************************************************/
  467. void highlight_ctm_input_method(void)
  468. {
  469.     /*----------------------------------------------------------------*/
  470.     /* Local Variables                                                */
  471.     /*----------------------------------------------------------------*/
  473.     /*----------------------------------------------------------------*/
  474.     /* Code Body                                                      */
  475.     /*----------------------------------------------------------------*/
  476.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  477.     SetLeftSoftkeyFunction(EntryInputMethodScreen, KEY_EVENT_UP);
  478. }
  481. /*****************************************************************************
  482.  * FUNCTION
  483.  *  hint_ctm_mode
  484.  * DESCRIPTION
  485.  *  hint
  486.  * PARAMETERS
  487.  *  index       [IN]        
  488.  * RETURNS
  489.  *  void
  490.  *****************************************************************************/
  491. void hint_ctm_mode(U16 index)
  492. {
  493.     /*----------------------------------------------------------------*/
  494.     /* Local Variables                                                */
  495.     /*----------------------------------------------------------------*/
  497.     /*----------------------------------------------------------------*/
  498.     /* Code Body                                                      */
  499.     /*----------------------------------------------------------------*/
  500.     if (ctm_p->status == TRUE)
  501.     {
  502.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_ON));
  503.     }
  504.     else
  505.     {
  506.         pfnUnicodeStrcpy((S8*) hintData[index], (S8*) GetString(STR_GLOBAL_OFF));
  507.     }
  508.     return;
  509. }
  512. /*****************************************************************************
  513.  * FUNCTION
  514.  *  mmi_ctm_set_default_rsp_hdlr
  515.  * DESCRIPTION
  516.  *  
  517.  * PARAMETERS
  518.  *  info        [?]     
  519.  * RETURNS
  520.  *  void
  521.  *****************************************************************************/
  522. void mmi_ctm_set_default_rsp_hdlr(void *info)
  523. {
  524.     /*----------------------------------------------------------------*/
  525.     /* Local Variables                                                */
  526.     /*----------------------------------------------------------------*/
  527.     pBOOL result = TRUE;
  529. #ifndef __CTM_DEBUG
  530.     mmi_ctm_set_default_rsp_struct *rsp;
  532.     /*----------------------------------------------------------------*/
  533.     /* Code Body                                                      */
  534.     /*----------------------------------------------------------------*/
  535.     rsp = (mmi_ctm_set_default_rsp_struct*) info;
  536.     result = rsp->result;
  537. #endif /* __CTM_DEBUG */ 
  539.     PRINT_INFORMATION(("n CTM SET DEFAULT RSP n"));
  541.     if (result == TRUE)
  542.     {
  544.     }
  545.     else
  546.     {
  548.     }
  549. }
  552. /*****************************************************************************
  553.  * FUNCTION
  554.  *  mmi_ctm_get_default_rsp_hdlr
  555.  * DESCRIPTION
  556.  *  
  557.  * PARAMETERS
  558.  *  info        [?]     
  559.  * RETURNS
  560.  *  void
  561.  *****************************************************************************/
  562. void mmi_ctm_get_default_rsp_hdlr(void *info)
  563. {
  564.     /*----------------------------------------------------------------*/
  565.     /* Local Variables                                                */
  566.     /*----------------------------------------------------------------*/
  567.     pBOOL result = TRUE;
  568.     pBOOL on_off = TRUE;
  569.     U8 mode = CTM_DIRECT_MODE;
  570.     U8 mmi_mode;
  572. #ifndef __CTM_DEBUG
  573.     mmi_ctm_get_default_rsp_struct *rsp;
  575.     /*----------------------------------------------------------------*/
  576.     /* Code Body                                                      */
  577.     /*----------------------------------------------------------------*/
  578.     rsp = (mmi_ctm_get_default_rsp_struct*) info;
  579.     result = rsp->result;
  580.     on_off = rsp->is_turn_on;
  581.     mode = rsp->ctm_interface;
  582. #endif /* __CTM_DEBUG */ 
  584.     PRINT_INFORMATION(("n CTM GET DEFAULT RSP n"));
  586.     if (result == TRUE)
  587.     {
  588.         S16 error;
  590.         if (ctm_p->status != on_off)
  591.         {
  592.             ctm_p->status = on_off;
  593.             WriteValue(NVRAM_CTM_MODE, &ctm_p->status, DS_BYTE, &error);
  594.         }
  595.         switch (mode)
  596.         {
  597.             case CTM_BAUDOT_MODE:
  598.                 mmi_mode = MMI_CTM_SETTING_BAUDOT;
  599.                 break;
  600.             case CTM_HCO_MODE:
  601.                 mmi_mode = MMI_CTM_SETTING_HCO;
  602.                 break;
  603.             case CTM_VCO_MODE:
  604.                 mmi_mode = MMI_CTM_SETTING_VCO;
  605.                 break;
  606.             case CTM_DIRECT_MODE:
  607.                 /* MMI mode_setting should be auto or manual direct */
  608.                 if (ctm_p->mode_setting != MMI_CTM_SETTING_MANUAL_DIRECT &&
  609.                     ctm_p->mode_setting != MMI_CTM_SETTING_AUTO_DIRECT)
  610.                 {
  611.                     mmi_mode = MMI_CTM_SETTING_MANUAL_DIRECT;
  612.                 }
  613.                 else
  614.                 {
  615.                     mmi_mode = ctm_p->mode_setting;
  616.                 }
  617.                 break;
  618.             default:
  619.                 ASSERT(0);
  620.                 break;
  621.         }
  623.         /* MMI mode setting should be the same as L4 mode */
  624.         if (mmi_mode != ctm_p->mode_setting)
  625.         {
  626.             ctm_p->mode_setting = mmi_mode;
  627.             WriteValue(NVRAM_CTM_SETTING, &ctm_p->mode_setting, DS_BYTE, &error);
  628.         }
  630.         if (ctm_p->status == TRUE)
  631.         {
  632.             ShowStatusIcon(STATUS_ICON_TTY_INDICATOR);
  633.             /* only hide earphone when it's real tty, 
  634.                direct mode still take as earphone */
  635.             if (ctm_p->mode_setting < MMI_CTM_SETTING_MANUAL_DIRECT)
  636.             HideStatusIcon(STATUS_ICON_EARPHONE_INDICATOR);
  637.         }
  638.         else
  639.         {
  640.             HideStatusIcon(STATUS_ICON_TTY_INDICATOR);
  641.         }
  642.         UpdateStatusIcons();
  643.     }
  644.     //else
  645.     //ASSERT(0);
  646. }
  649. /*****************************************************************************
  650.  * FUNCTION
  651.  *  mmi_ctm_open_rsp_hdlr
  652.  * DESCRIPTION
  653.  *  
  654.  * PARAMETERS
  655.  *  info        [?]     
  656.  * RETURNS
  657.  *  void
  658.  *****************************************************************************/
  659. void mmi_ctm_open_rsp_hdlr(void *info)
  660. {
  661.     /*----------------------------------------------------------------*/
  662.     /* Local Variables                                                */
  663.     /*----------------------------------------------------------------*/
  664.     pBOOL result = TRUE;
  665.     U8 ctm_interface = CTM_DIRECT_MODE;
  667. #ifndef __CTM_DEBUG
  668.     mmi_ctm_open_rsp_struct *rsp;
  670.     /*----------------------------------------------------------------*/
  671.     /* Code Body                                                      */
  672.     /*----------------------------------------------------------------*/
  673.     rsp = (mmi_ctm_open_rsp_struct*) info;
  674.     result = rsp->result;
  675.     ctm_interface = rsp->ctm_interface;
  676. #endif /* __CTM_DEBUG */ 
  678.     PRINT_INFORMATION(("n CTM OPEN RSP n"));
  680.     if (ctm_p->state == MMI_CTM_STATE_OPENING)
  681.     {
  682.         if (result == TRUE)
  683.         {
  684.             /* open OK */
  685.             mmi_ctm_set_state(MMI_CTM_STATE_OPENED);
  686.             ctm_p->mode_activated = ctm_interface;
  687.         }
  688.         else
  689.         {
  690.             mmi_ctm_set_state(MMI_CTM_STATE_IDLE);
  691.         }
  693.         {
  694.             S8 mode = 0xff;
  696.             /* open fail */
  698.             if (ctm_p->tty_status == TRUE)
  699.             {
  700.                 /* with TTY, open as TTY */
  701.                 switch (ctm_p->mode_setting)
  702.                 {
  703.                     case MMI_CTM_SETTING_HCO:
  704.                         mode = CTM_HCO_MODE;
  705.                         break;
  706.                     case MMI_CTM_SETTING_VCO:
  707.                         mode = CTM_VCO_MODE;
  708.                         break;
  709.                     case MMI_CTM_SETTING_BAUDOT:
  710.                         mode = CTM_BAUDOT_MODE;
  711.                         break;
  712.                     default:
  713.                  /* CTM ON, earphone in, direct mode => keep open as direct mode, take it as earphone */
  714.                  mode = CTM_DIRECT_MODE;
  715.                         break;
  716.                 }
  717.             }
  718.             else
  719.             {
  720.                 switch (ctm_p->mode_setting)
  721.                 {
  722.                     case MMI_CTM_SETTING_AUTO_DIRECT:
  723.                     case MMI_CTM_SETTING_MANUAL_DIRECT:
  724.                         /* no TTY, open as direct */
  725.                         mode = CTM_DIRECT_MODE;
  726.                         break;
  727.                     default:
  728.                         break;
  729.                 }
  730.             }
  732.             ASSERT(ctm_p->mode_setting <= MMI_CTM_SETTING_AUTO_DIRECT);
  734.             if (mode != 0xff && mode != ctm_interface)
  735.             {
  736.                 mmi_ctm_set_state(MMI_CTM_STATE_OPENING);
  737.                 mmi_ctm_send_open_req(mode);
  738.                 return;
  739.             }
  740.         }
  741.     }
  742. }
  745. /*****************************************************************************
  746.  * FUNCTION
  747.  *  mmi_ctm_close_rsp_hdlr
  748.  * DESCRIPTION
  749.  *  
  750.  * PARAMETERS
  751.  *  info        [?]     
  752.  * RETURNS
  753.  *  void
  754.  *****************************************************************************/
  755. void mmi_ctm_close_rsp_hdlr(void *info)
  756. {
  757.     /*----------------------------------------------------------------*/
  758.     /* Local Variables                                                */
  759.     /*----------------------------------------------------------------*/
  761.     /*----------------------------------------------------------------*/
  762.     /* Code Body                                                      */
  763.     /*----------------------------------------------------------------*/
  764.     PRINT_INFORMATION(("n CTM CLOSE RSPn"));
  766.     if (ctm_p->state == MMI_CTM_STATE_CLOSING)
  767.     {
  768.         mmi_ctm_set_state(MMI_CTM_STATE_IDLE);
  769.     }
  770. }
  773. /*****************************************************************************
  774.  * FUNCTION
  775.  *  mmi_ctm_connect_rsp_hdlr
  776.  * DESCRIPTION
  777.  *  
  778.  * PARAMETERS
  779.  *  info        [?]     
  780.  * RETURNS
  781.  *  void
  782.  *****************************************************************************/
  783. void mmi_ctm_connect_rsp_hdlr(void *info)
  784. {
  785.     /*----------------------------------------------------------------*/
  786.     /* Local Variables                                                */
  787.     /*----------------------------------------------------------------*/
  788.     pBOOL result = TRUE;
  790. #ifndef __CTM_DEBUG
  791.     mmi_ctm_connect_rsp_struct *rsp;
  793.     /*----------------------------------------------------------------*/
  794.     /* Code Body                                                      */
  795.     /*----------------------------------------------------------------*/
  796.     rsp = (mmi_ctm_connect_rsp_struct*) info;
  797.     result = rsp->result;
  798. #endif /* __CTM_DEBUG */ 
  800.     PRINT_INFORMATION(("n CTM CONNECT RSPn"));
  802.     if (ctm_p->state == MMI_CTM_STATE_CONNECTING)
  803.     {
  804.         if (result == TRUE)
  805.         {
  806.             /* connect OK */
  807.             mmi_ctm_set_state(MMI_CTM_STATE_CONNECTED);
  809.             mmi_ctm_reset_buffer();
  811.             /* enter chat screen */
  812.             if (GetExitScrnID() == SCR_CTM_CONNECTING ||
  813.              GetExitScrnID() == SCR_CM_ACTIVECALLSCREEN)
  814.             {
  815.                 entry_ctm_talking();
  816.                 DeleteScreenIfPresent(SCR_CM_ACTIVECALLSCREEN);
  817.             }
  818.         }
  819.         else
  820.         {
  821.             /* connect fail */
  822.             mmi_ctm_set_state(MMI_CTM_STATE_OPENED);
  823.             DisplayPopup((PU8) GetString(STR_GLOBAL_UNFINISHED), IMG_GLOBAL_ERROR, 0, 2000, ERROR_TONE);
  824.         }
  825.     }
  826. #ifdef __CTM_DEBUG
  827.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_recv_text_ind_hdlr);
  828. #endif 
  829.     DeleteScreenIfPresent(SCR_CTM_CONNECTING);
  830. }
  833. /*****************************************************************************
  834.  * FUNCTION
  835.  *  mmi_ctm_connect_ind_hdlr
  836.  * DESCRIPTION
  837.  *  
  838.  * PARAMETERS
  839.  *  info        [?]     
  840.  * RETURNS
  841.  *  void
  842.  *****************************************************************************/
  843. void mmi_ctm_connect_ind_hdlr(void *info)
  844. {
  845.     /*----------------------------------------------------------------*/
  846.     /* Local Variables                                                */
  847.     /*----------------------------------------------------------------*/
  849.     /*----------------------------------------------------------------*/
  850.     /* Code Body                                                      */
  851.     /*----------------------------------------------------------------*/
  852.     if (ctm_p->state == MMI_CTM_STATE_OPENED || ctm_p->state == MMI_CTM_STATE_CONNECTING)
  853.     {
  854.         mmi_ctm_set_state(MMI_CTM_STATE_CONNECTED);
  855.         mmi_ctm_reset_buffer();
  856.     }
  858.     /* enter chat screen */
  859.     if (GetExitScrnID() == SCR_CM_ACTIVECALLSCREEN)
  860.     {
  861.         entry_ctm_talking();
  862.         DeleteScreenIfPresent(SCR_CM_ACTIVECALLSCREEN);
  863.     }
  864. }
  867. /*****************************************************************************
  868.  * FUNCTION
  869.  *  mmi_ctm_send_text_rsp_hdlr
  870.  * DESCRIPTION
  871.  *  
  872.  * PARAMETERS
  873.  *  info        [?]     
  874.  * RETURNS
  875.  *  void
  876.  *****************************************************************************/
  877. void mmi_ctm_send_text_rsp_hdlr(void *info)
  878. {
  879.     /*----------------------------------------------------------------*/
  880.     /* Local Variables                                                */
  881.     /*----------------------------------------------------------------*/
  882.     pBOOL result = TRUE;
  883.     U16 finished_len;
  885. #ifndef __CTM_DEBUG
  886.     mmi_ctm_send_text_rsp_struct *rsp;
  888.     /*----------------------------------------------------------------*/
  889.     /* Code Body                                                      */
  890.     /*----------------------------------------------------------------*/
  891.     rsp = (mmi_ctm_send_text_rsp_struct*) info;
  892.     result = rsp->result;
  893. #endif /* __CTM_DEBUG */ 
  895.     PRINT_INFORMATION(("n CTM SEND TEXT RSPn"));
  897.     finished_len = ctm_p->sent_len;
  898.     ctm_p->sent_len = 0;
  900.     if (result == TRUE)
  901.     {
  902.         if (MAX_CTM_DATA_COUNT - ctm_p->local_len > finished_len)
  903.         {
  904.             ctm_p->local_len += finished_len;
  905.             pfnUnicodeStrncat((PS8) ctm_p->local_buffer, (PS8) ctm_p->pending_buffer, finished_len);
  906.         }
  907.         else
  908.         {
  909.             memset(ctm_p->local_buffer, 0, MAX_CTM_DATA_BUFFER_LEN);
  910.             ctm_p->local_len = finished_len;
  911.             pfnUnicodeStrncpy((PS8) ctm_p->local_buffer, (PS8) ctm_p->pending_buffer, finished_len);
  912.         }
  914.         ctm_p->pending_len -= finished_len;
  916.         if (ctm_p->pending_len > 0)
  917.         {
  918.             pfnUnicodeStrcpy((PS8) ctm_p->pending_buffer, (PS8) & ctm_p->pending_buffer[finished_len << 1]);
  919.         }
  920.         else
  921.         {
  922.             memset(ctm_p->pending_buffer, 0, MAX_CTM_EDITOR_BUFFER_LEN);
  923.         }
  925.         if (finished_len > 0)
  926.         {
  927.             UpdateCategory430LSK(STR_GLOBAL_EDIT, 0);
  928.         }
  930.         if (GetExitScrnID() == SCR_CTM_TALKING)
  931.         {
  932.             if (ctm_p->pending_len == 0)
  933.             {
  934.                 ConfigureCategory430SendingBox(FALSE, 0);
  935.             }
  936.             else
  937.             {
  938.                 ConfigureCategory430SendingBox(TRUE, 0);
  939.             }
  940.         }
  941.     }
  943.     if (ctm_p->pending_len > 0)
  944.     {
  945.         mmi_ctm_send_text_req((PS8) ctm_p->pending_buffer, ctm_p->pending_len);
  946.     }
  948. }
  951. /*****************************************************************************
  952.  * FUNCTION
  953.  *  mmi_ctm_recv_text_ind_hdlr
  954.  * DESCRIPTION
  955.  *  
  956.  * PARAMETERS
  957.  *  info        [?]     
  958.  * RETURNS
  959.  *  void
  960.  *****************************************************************************/
  961. void mmi_ctm_recv_text_ind_hdlr(void *info)
  962. {
  963.     /*----------------------------------------------------------------*/
  964.     /* Local Variables                                                */
  965.     /*----------------------------------------------------------------*/
  966.     U16 space, len;
  967.     PU16 text;
  969. #ifdef __CTM_DEBUG
  970.     U16 temp[] = L"abc12345defn";
  972.     /*----------------------------------------------------------------*/
  973.     /* Code Body                                                      */
  974.     /*----------------------------------------------------------------*/
  975.     len = 12;
  976.     text = temp;
  977. #else /* __CTM_DEBUG */ 
  978.     mmi_ctm_recv_text_ind_struct *ind;
  980.     ind = (mmi_ctm_recv_text_ind_struct*) info;
  981.     len = ind->num_of_char;
  982.     text = ind->text;
  983. #endif /* __CTM_DEBUG */ 
  985.     PRINT_INFORMATION(("n CTM RECV TEXT INDn"));
  987.     len = mmi_skip_unicode_char(text, len, 0x0008);
  988.     space = MAX_CTM_DATA_COUNT - ctm_p->remote_len;
  989.     if (space > len)
  990.     {
  991.         ctm_p->remote_len += len;
  992.         pfnUnicodeStrcat((PS8) ctm_p->remote_buffer, (PS8) text);
  993.     }
  994.     else
  995.     {
  996.         ctm_p->remote_len = len;
  997.         pfnUnicodeStrcpy((PS8) ctm_p->remote_buffer, (PS8) text);
  998.     }
  999.     if (GetExitScrnID() == SCR_CTM_TALKING)
  1000.     {
  1001.         UpdateCategory430LogBox(TRUE, FALSE);
  1002.     }
  1004. #ifdef __CTM_DEBUG
  1005.     StartTimer(CM_AUTOANSWER_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_recv_text_ind_hdlr);
  1006. #endif 
  1007. }
  1010. /*****************************************************************************
  1011.  * FUNCTION
  1012.  *  mmi_ctm_tty_plug_ind_hdlr
  1013.  * DESCRIPTION
  1014.  *  
  1015.  * PARAMETERS
  1016.  *  info        [?]     
  1017.  * RETURNS
  1018.  *  void
  1019.  *****************************************************************************/
  1020. void mmi_ctm_tty_plug_ind_hdlr(void *info)
  1021. {
  1022.     /*----------------------------------------------------------------*/
  1023.     /* Local Variables                                                */
  1024.     /*----------------------------------------------------------------*/
  1025.     mmi_ctm_tty_plug_ind_struct *ind;
  1027.     /*----------------------------------------------------------------*/
  1028.     /* Code Body                                                      */
  1029.     /*----------------------------------------------------------------*/
  1030.     ind = (mmi_ctm_tty_plug_ind_struct*) info;
  1032.     /* ctm_p->tty_status = ind->is_plug_in; */
  1034.     mmi_ctm_switch_tty_status(ind->is_plug_in);
  1035. }
  1038. /*****************************************************************************
  1039.  * FUNCTION
  1040.  *  mmi_ctm_switch_tty_status
  1041.  * DESCRIPTION
  1042.  *  
  1043.  * PARAMETERS
  1044.  *  is_present      [IN]        
  1045.  *  void(?)         [IN]        *
  1046.  * RETURNS
  1047.  *  void
  1048.  *****************************************************************************/
  1049. void mmi_ctm_switch_tty_status(pBOOL is_present)
  1050. {
  1051.     /*----------------------------------------------------------------*/
  1052.     /* Local Variables                                                */
  1053.     /*----------------------------------------------------------------*/
  1055.     /*----------------------------------------------------------------*/
  1056.     /* Code Body                                                      */
  1057.     /*----------------------------------------------------------------*/
  1058.     if (is_present)
  1059.     {
  1060.         /* plug in */
  1061.         if (mmi_ctm_get_mode())
  1062.         {
  1063.             /* CTM on, take as TTY */
  1064.             ctm_p->tty_status = TRUE;
  1065.             if ((ctm_p->state != MMI_CTM_STATE_IDLE &&
  1066.                  ctm_p->mode_activated == CTM_DIRECT_MODE) ||
  1067.                 (ctm_p->state == MMI_CTM_STATE_IDLE && GetTotalActiveCallCount() + GetTotalHoldCallCount() >= 1))
  1068.             {
  1069.                 S8 mode = 0xff;
  1071.                 /* plug in, open again */
  1072.                 if (ctm_p->state != MMI_CTM_STATE_IDLE)
  1073.                 {
  1074.                     mmi_ctm_set_state(MMI_CTM_STATE_CLOSING);
  1075.                     mmi_ctm_send_close_req();
  1076.                 }
  1077.                 switch (ctm_p->mode_setting)
  1078.                 {
  1079.                     case MMI_CTM_SETTING_HCO:
  1080.                         mode = CTM_HCO_MODE;
  1081.                         break;
  1082.                     case MMI_CTM_SETTING_VCO:
  1083.                         mode = CTM_VCO_MODE;
  1084.                         break;
  1085.                     case MMI_CTM_SETTING_BAUDOT:
  1086.                         mode = CTM_BAUDOT_MODE;
  1087.                         break;
  1088.                     default:
  1089.                      /* CTM ON, earphone in, direct mode => keep open as direct mode, take it as earphone */
  1090.                  mode = CTM_DIRECT_MODE;
  1091.                         break;
  1092.                 }
  1093.                 if (mode != 0xff)
  1094.                 {
  1095.                     mmi_ctm_set_state(MMI_CTM_STATE_OPENING);
  1096.                     mmi_ctm_send_open_req(mode);
  1097.                 }
  1098.             }
  1099.         }
  1100.         else
  1101.         {
  1102.             /* CTM off, take as headset */
  1103.             ctm_p->tty_status = FALSE;
  1104.         }
  1105.     }
  1106.     else
  1107.     {
  1108.         /* plug out */
  1109.         ctm_p->tty_status = FALSE;
  1110.         if (mmi_ctm_get_mode())
  1111.         {
  1112.             /* CTM on, TTY to direct */
  1113.             if (ctm_p->state != MMI_CTM_STATE_IDLE)
  1114.             {
  1115.                 mmi_ctm_set_state(MMI_CTM_STATE_CLOSING);
  1116.                 mmi_ctm_send_close_req();
  1117.             }
  1119.             if (((ctm_p->mode_setting == MMI_CTM_SETTING_AUTO_DIRECT ||
  1120.                   ctm_p->mode_setting == MMI_CTM_SETTING_MANUAL_DIRECT) &&
  1121.                  (ctm_p->mode_activated != CTM_DIRECT_MODE || 
  1122.                   ctm_p->state == MMI_CTM_STATE_CLOSING)) ||
  1123.                 (ctm_p->state == MMI_CTM_STATE_IDLE && GetTotalActiveCallCount() + GetTotalHoldCallCount() >= 1))
  1124.             {
  1125.                 /* plug out, open again */
  1126.                 mmi_ctm_set_state(MMI_CTM_STATE_OPENING);
  1127.                 mmi_ctm_send_open_req(CTM_DIRECT_MODE);
  1128.             }
  1129.         }
  1130.         else
  1131.         {
  1132.             /* CTM off, do nothing */
  1133.         }
  1134.     }
  1135. }
  1138. /*****************************************************************************
  1139.  * FUNCTION
  1140.  *  mmi_ctm_send_open_req
  1141.  * DESCRIPTION
  1142.  *  
  1143.  * PARAMETERS
  1144.  *  mode        [IN]        
  1145.  *  void(?)     [IN]        *
  1146.  * RETURNS
  1147.  *  void
  1148.  *****************************************************************************/
  1149. void mmi_ctm_send_open_req(U8 mode)
  1150. {
  1151. #ifndef __CTM_DEBUG
  1152.     /*----------------------------------------------------------------*/
  1153.     /* Local Variables                                                */
  1154.     /*----------------------------------------------------------------*/
  1155.     MYQUEUE Message;
  1156.     mmi_ctm_open_req_struct *param;
  1158.     /*----------------------------------------------------------------*/
  1159.     /* Code Body                                                      */
  1160.     /*----------------------------------------------------------------*/
  1161.     /* ClearInputEventHandler(MMI_DEVICE_ALL); */
  1163.     Message.oslSrcId = MOD_MMI;
  1164.     Message.oslDestId = MOD_L4C;
  1165.     Message.oslMsgId = MSG_ID_MMI_CTM_OPEN_REQ;
  1167.     param = (mmi_ctm_open_req_struct*) OslConstructDataPtr(sizeof(mmi_ctm_open_req_struct));
  1169.     param->ctm_interface = mode;
  1171.     Message.oslDataPtr = (oslParaType*) param;
  1172.     Message.oslPeerBuffPtr = NULL;
  1174.     SetProtocolEventHandler(mmi_ctm_open_rsp_hdlr, MSG_ID_MMI_CTM_OPEN_RSP);
  1175.     OslMsgSendExtQueue(&Message);
  1176. #else /* __CTM_DEBUG */ 
  1177.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_open_rsp_hdlr);
  1178. #endif /* __CTM_DEBUG */ 
  1179.     PRINT_INFORMATION(("n CTM OPEN REQn"));
  1180. }
  1183. /*****************************************************************************
  1184.  * FUNCTION
  1185.  *  mmi_ctm_send_close_req
  1186.  * DESCRIPTION
  1187.  *  
  1188.  * PARAMETERS
  1189.  *  void
  1190.  *  void(?)     [IN]        *
  1191.  * RETURNS
  1192.  *  void
  1193.  *****************************************************************************/
  1194. void mmi_ctm_send_close_req(void)
  1195. {
  1196. #ifndef __CTM_DEBUG
  1197.     /*----------------------------------------------------------------*/
  1198.     /* Local Variables                                                */
  1199.     /*----------------------------------------------------------------*/
  1200.     MYQUEUE Message;
  1202.     /*----------------------------------------------------------------*/
  1203.     /* Code Body                                                      */
  1204.     /*----------------------------------------------------------------*/
  1205.     /* ClearInputEventHandler(MMI_DEVICE_ALL); */
  1207.     Message.oslSrcId = MOD_MMI;
  1208.     Message.oslDestId = MOD_L4C;
  1209.     Message.oslMsgId = MSG_ID_MMI_CTM_CLOSE_REQ;
  1211.     Message.oslDataPtr = NULL;
  1212.     Message.oslPeerBuffPtr = NULL;
  1214.     SetProtocolEventHandler(mmi_ctm_close_rsp_hdlr, MSG_ID_MMI_CTM_CLOSE_RSP);
  1215.     OslMsgSendExtQueue(&Message);
  1216. #else /* __CTM_DEBUG */ 
  1217.     StartTimer(CM_ALERT_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_close_rsp_hdlr);
  1218. #endif /* __CTM_DEBUG */ 
  1219.     PRINT_INFORMATION(("n CTM CLOSE REQn"));
  1220. }
  1223. /*****************************************************************************
  1224.  * FUNCTION
  1225.  *  mmi_ctm_send_connect_req
  1226.  * DESCRIPTION
  1227.  *  
  1228.  * PARAMETERS
  1229.  *  void
  1230.  *  void(?)     [IN]        *
  1231.  * RETURNS
  1232.  *  void
  1233.  *****************************************************************************/
  1234. void mmi_ctm_send_connect_req(void)
  1235. {
  1236. #ifndef __CTM_DEBUG
  1237.     /*----------------------------------------------------------------*/
  1238.     /* Local Variables                                                */
  1239.     /*----------------------------------------------------------------*/
  1240.     MYQUEUE Message;
  1242.     /*----------------------------------------------------------------*/
  1243.     /* Code Body                                                      */
  1244.     /*----------------------------------------------------------------*/
  1245.     ClearInputEventHandler(MMI_DEVICE_ALL);
  1247.     Message.oslSrcId = MOD_MMI;
  1248.     Message.oslDestId = MOD_L4C;
  1249.     Message.oslMsgId = MSG_ID_MMI_CTM_CONNECT_REQ;
  1251.     Message.oslDataPtr = NULL;
  1252.     Message.oslPeerBuffPtr = NULL;
  1254.     SetProtocolEventHandler(mmi_ctm_connect_rsp_hdlr, MSG_ID_MMI_CTM_CONNECT_RSP);
  1255.     OslMsgSendExtQueue(&Message);
  1256. #else /* __CTM_DEBUG */ 
  1257.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_connect_rsp_hdlr);
  1258. #endif /* __CTM_DEBUG */ 
  1259.     PRINT_INFORMATION(("n CTM CONNECT REQn"));
  1260. }
  1263. /*****************************************************************************
  1264.  * FUNCTION
  1265.  *  mmi_ctm_send_text_req
  1266.  * DESCRIPTION
  1267.  *  
  1268.  * PARAMETERS
  1269.  *  text        [IN]        
  1270.  *  length      [IN]        
  1271.  *  void(?)     [IN]        *
  1272.  * RETURNS
  1273.  *  void
  1274.  *****************************************************************************/
  1275. void mmi_ctm_send_text_req(PS8 text, U16 length)
  1276. {
  1277. #ifndef __CTM_DEBUG
  1278.     /*----------------------------------------------------------------*/
  1279.     /* Local Variables                                                */
  1280.     /*----------------------------------------------------------------*/
  1281.     MYQUEUE Message;
  1282.     mmi_ctm_send_text_req_struct *param;
  1284.     /*----------------------------------------------------------------*/
  1285.     /* Code Body                                                      */
  1286.     /*----------------------------------------------------------------*/
  1287.     ClearInputEventHandler(MMI_DEVICE_ALL);
  1289.     Message.oslSrcId = MOD_MMI;
  1290.     Message.oslDestId = MOD_L4C;
  1291.     Message.oslMsgId = MSG_ID_MMI_CTM_SEND_TEXT_REQ;
  1293.     param = (mmi_ctm_send_text_req_struct*) OslConstructDataPtr(sizeof(mmi_ctm_send_text_req_struct));
  1295.     if (length > CTM_SEND_TEXT_CHAR_MAX_NUM)
  1296.     {
  1297.         param->num_of_char = CTM_SEND_TEXT_CHAR_MAX_NUM;
  1298.         pfnUnicodeStrncpy((PS8) param->text, text, CTM_SEND_TEXT_CHAR_MAX_NUM);
  1299.     }
  1300.     else
  1301.     {
  1302.         param->num_of_char = length;
  1303.         pfnUnicodeStrcpy((PS8) param->text, text);
  1304.     }
  1305.     ctm_p->sent_len = param->num_of_char;
  1307.     Message.oslDataPtr = (oslParaType*) param;
  1308.     Message.oslPeerBuffPtr = NULL;
  1310.     SetProtocolEventHandler(mmi_ctm_send_text_rsp_hdlr, MSG_ID_MMI_CTM_SEND_TEXT_RSP);
  1311.     OslMsgSendExtQueue(&Message);
  1312. #else /* __CTM_DEBUG */ 
  1313.     if (length > CTM_SEND_TEXT_CHAR_MAX_NUM)
  1314.     {
  1315.         ctm_p->sent_len = CTM_SEND_TEXT_CHAR_MAX_NUM;
  1316.     }
  1317.     else
  1318.     {
  1319.         ctm_p->sent_len = length;
  1320.     }
  1322.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_send_text_rsp_hdlr);
  1323. #endif /* __CTM_DEBUG */ 
  1324.     PRINT_INFORMATION(("n CTM SEND TEXT REQn"));
  1325. }
  1328. /*****************************************************************************
  1329.  * FUNCTION
  1330.  *  mmi_ctm_send_set_default_req
  1331.  * DESCRIPTION
  1332.  *  
  1333.  * PARAMETERS
  1334.  *  on_off      [IN]        
  1335.  *  mode        [IN]        
  1336.  *  void(?)     [IN]        *
  1337.  * RETURNS
  1338.  *  void
  1339.  *****************************************************************************/
  1340. void mmi_ctm_send_set_default_req(pBOOL on_off, U8 mode)
  1341. {
  1342. #ifndef __CTM_DEBUG
  1343.     /*----------------------------------------------------------------*/
  1344.     /* Local Variables                                                */
  1345.     /*----------------------------------------------------------------*/
  1346.     MYQUEUE Message;
  1347.     mmi_ctm_set_default_req_struct *param;
  1349.     /*----------------------------------------------------------------*/
  1350.     /* Code Body                                                      */
  1351.     /*----------------------------------------------------------------*/
  1352.     ClearInputEventHandler(MMI_DEVICE_ALL);
  1354.     Message.oslSrcId = MOD_MMI;
  1355.     Message.oslDestId = MOD_L4C;
  1356.     Message.oslMsgId = MSG_ID_MMI_CTM_SET_DEFAULT_REQ;
  1358.     param = (mmi_ctm_set_default_req_struct*) OslConstructDataPtr(sizeof(mmi_ctm_set_default_req_struct));
  1360.     param->is_turn_on = on_off;
  1362.     switch (mode)
  1363.     {
  1364.         case MMI_CTM_SETTING_BAUDOT:
  1365.             param->ctm_interface = CTM_BAUDOT_MODE;
  1366.             break;
  1367.         case MMI_CTM_SETTING_HCO:
  1368.             param->ctm_interface = CTM_HCO_MODE;
  1369.             break;
  1370.         case MMI_CTM_SETTING_VCO:
  1371.             param->ctm_interface = CTM_VCO_MODE;
  1372.             break;
  1373.         default:
  1374.             param->ctm_interface = CTM_DIRECT_MODE;
  1375.             break;
  1376.     }
  1377.     Message.oslDataPtr = (oslParaType*) param;
  1378.     Message.oslPeerBuffPtr = NULL;
  1380.     SetProtocolEventHandler(mmi_ctm_set_default_rsp_hdlr, MSG_ID_MMI_CTM_SET_DEFAULT_RSP);
  1381.     OslMsgSendExtQueue(&Message);
  1382. #else /* __CTM_DEBUG */ 
  1383.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_set_default_rsp_hdlr);
  1384. #endif /* __CTM_DEBUG */ 
  1385.     PRINT_INFORMATION(("n CTM SEND SET DEFAULT REQn"));
  1386. }
  1389. /*****************************************************************************
  1390.  * FUNCTION
  1391.  *  mmi_ctm_send_get_default_req
  1392.  * DESCRIPTION
  1393.  *  
  1394.  * PARAMETERS
  1395.  *  void
  1396.  *  void(?)     [IN]        *
  1397.  * RETURNS
  1398.  *  void
  1399.  *****************************************************************************/
  1400. void mmi_ctm_send_get_default_req(void)
  1401. {
  1402. #ifndef __CTM_DEBUG
  1403.     /*----------------------------------------------------------------*/
  1404.     /* Local Variables                                                */
  1405.     /*----------------------------------------------------------------*/
  1406.     MYQUEUE Message;
  1408.     /*----------------------------------------------------------------*/
  1409.     /* Code Body                                                      */
  1410.     /*----------------------------------------------------------------*/
  1411.     Message.oslSrcId = MOD_MMI;
  1412.     Message.oslDestId = MOD_L4C;
  1413.     Message.oslMsgId = MSG_ID_MMI_CTM_GET_DEFAULT_REQ;
  1415.     Message.oslDataPtr = NULL;
  1416.     Message.oslPeerBuffPtr = NULL;
  1418.     SetProtocolEventHandler(mmi_ctm_get_default_rsp_hdlr, MSG_ID_MMI_CTM_GET_DEFAULT_RSP);
  1419.     OslMsgSendExtQueue(&Message);
  1420. #else /* __CTM_DEBUG */ 
  1421.     StartTimer(CM_NOTIFYDURATION_TIMER, 2000, (FuncPtr) mmi_ctm_get_default_rsp_hdlr);
  1422. #endif /* __CTM_DEBUG */ 
  1423.     PRINT_INFORMATION(("n CTM SEND GET DEFAULT REQn"));
  1424. }
  1427. /*****************************************************************************
  1428.  * FUNCTION
  1429.  *  mmi_ctm_connect
  1430.  * DESCRIPTION
  1431.  *  
  1432.  * PARAMETERS
  1433.  *  void
  1434.  *  void(?)     [IN]        *
  1435.  * RETURNS
  1436.  *  void
  1437.  *****************************************************************************/
  1438. void mmi_ctm_connect(void)
  1439. {
  1440.     /*----------------------------------------------------------------*/
  1441.     /* Local Variables                                                */
  1442.     /*----------------------------------------------------------------*/
  1444.     /*----------------------------------------------------------------*/
  1445.     /* Code Body                                                      */
  1446.     /*----------------------------------------------------------------*/
  1447.     if (ctm_p->state == MMI_CTM_STATE_OPENED)
  1448.     {
  1449.         mmi_ctm_set_state(MMI_CTM_STATE_CONNECTING);
  1450.         mmi_ctm_send_connect_req();
  1451.         entry_ctm_connect_animation();
  1452.     }
  1453.     else if (ctm_p->state == MMI_CTM_STATE_CONNECTED)
  1454.     {
  1455.         /* back to active screen to direct to chat screen */
  1456.         GoBackHistory();
  1457.     }
  1458. }
  1461. /*****************************************************************************
  1462.  * FUNCTION
  1463.  *  mmi_ctm_edit_done
  1464.  * DESCRIPTION
  1465.  *  
  1466.  * PARAMETERS
  1467.  *  void
  1468.  *  void(?)     [IN]        *
  1469.  * RETURNS
  1470.  *  void
  1471.  *****************************************************************************/
  1472. void mmi_ctm_edit_done(void)
  1473. {
  1474.     /*----------------------------------------------------------------*/
  1475.     /* Local Variables                                                */
  1476.     /*----------------------------------------------------------------*/
  1478.     /*----------------------------------------------------------------*/
  1479.     /* Code Body                                                      */
  1480.     /*----------------------------------------------------------------*/
  1481.     ctm_p->pending_len += pfnUnicodeStrlen((PS8) ctm_p->editor_buffer);
  1482.     pfnUnicodeStrcat((PS8) ctm_p->pending_buffer, (PS8) ctm_p->editor_buffer);
  1483.     memset(ctm_p->editor_buffer, 0, MAX_CTM_EDITOR_BUFFER_LEN);
  1485.     if (ctm_p->sent_len == 0)
  1486.     {
  1487.         mmi_ctm_send_text_req((PS8) ctm_p->pending_buffer, ctm_p->pending_len);
  1488.     }
  1490.     if (IsScreenPresent(SCR_CM_ACTIVECALLSCREEN))
  1491.     {
  1492.         GoBackToHistory(SCR_CM_ACTIVECALLSCREEN);
  1493.     }
  1494.     else if (IsScreenPresent(SCR_CTM_TALKING))
  1495.     {
  1496.         GoBackToHistory(SCR_CTM_TALKING);
  1497.     }
  1498.     else
  1499.     {
  1500.         ASSERT(0);
  1501.     }
  1502. }
  1505. /*****************************************************************************
  1506.  * FUNCTION
  1507.  *  mmi_ctm_toggle_mode
  1508.  * DESCRIPTION
  1509.  *  
  1510.  * PARAMETERS
  1511.  *  void
  1512.  *  void(?)     [IN]        *
  1513.  * RETURNS
  1514.  *  void
  1515.  *****************************************************************************/
  1516. void mmi_ctm_toggle_mode(void)
  1517. {
  1518.     /*----------------------------------------------------------------*/
  1519.     /* Local Variables                                                */
  1520.     /*----------------------------------------------------------------*/
  1521.     S16 error;
  1522.     U16 str_id;
  1523.     pBOOL old;
  1525.     /*----------------------------------------------------------------*/
  1526.     /* Code Body                                                      */
  1527.     /*----------------------------------------------------------------*/
  1528.     old = mmi_ctm_is_tty_on();
  1529.     if (ctm_p->status == TRUE)
  1530.     {
  1531.         ctm_p->status = FALSE;
  1532.     }
  1533.     else
  1534.     {
  1535.         ctm_p->status = TRUE;
  1536.     }
  1538.     WriteValue(NVRAM_CTM_MODE, &ctm_p->status, DS_BYTE, &error);
  1540.     mmi_ctm_send_set_default_req(ctm_p->status, ctm_p->mode_setting);
  1542.     if (ctm_p->status == TRUE)
  1543.     {
  1544.         /* off -> on */
  1545.         str_id = STR_CTM_ON_SELECTED;
  1546.         ShowStatusIcon(STATUS_ICON_TTY_INDICATOR);
  1547.         /* with earphone, take as TTY */
  1548.         ctm_p->tty_status = isEarphonePlugged;
  1549.         if (isEarphonePlugged == TRUE && mmi_ctm_is_tty_on())
  1550.         {
  1551.             str_id = STR_CTM_HEADSET_TO_TTY;
  1552.             /* deactivate earphone mode, Tim */
  1553.             mmi_profiles_earphone_plug_out_callback();
  1554.         #if (defined (__MMI_STATUS_ICON_EN_EARPHONE__) || defined(__MMI_BT_SUPPORT__))
  1555.             IdleResetStatusIcon(STATUS_ICON_EARPHONE_INDICATOR);
  1556.         #endif 
  1557.         }
  1558.     }
  1559.     else
  1560.     {
  1561.         /* on -> off */
  1562.         str_id = STR_CTM_OFF_SELECTED;
  1563.         HideStatusIcon(STATUS_ICON_TTY_INDICATOR);
  1564.         ctm_p->tty_status = FALSE;
  1565.         if (isEarphonePlugged == TRUE && old == TRUE)
  1566.         {
  1567.             str_id = STR_CTM_TTY_TO_HEADSET;
  1568.             /* activate earphone mode, Tim */
  1569.             mmi_profiles_earphone_plug_in_callback();
  1570.         #if (defined (__MMI_STATUS_ICON_EN_EARPHONE__) || defined(__MMI_BT_SUPPORT__))
  1571.             IdleSetStatusIcon(STATUS_ICON_EARPHONE_INDICATOR);
  1572.         #endif 
  1573.         }
  1574.     }
  1576.     DisplayPopup((PU8) GetString(str_id), IMG_GLOBAL_ACTIVATED, 1, 2000, SUCCESS_TONE);
  1578.     /*
  1579.      * hint_ctm_mode(GetCurrHiliteID());
  1580.      * RedrawCategoryFunction();
  1581.      * highlight_ctm_mode();
  1582.      */
  1583. }
  1586. /*****************************************************************************
  1587.  * FUNCTION
  1588.  *  mmi_ctm_setting_select
  1589.  * DESCRIPTION
  1590.  *  
  1591.  * PARAMETERS
  1592.  *  void
  1593.  *  void(?)     [IN]        *
  1594.  * RETURNS
  1595.  *  void
  1596.  *****************************************************************************/
  1597. void mmi_ctm_setting_select(void)
  1598. {
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Local Variables                                                */
  1601.     /*----------------------------------------------------------------*/
  1602.     S16 error;
  1603.     U16 str_id = STR_GLOBAL_DONE;
  1604.     pBOOL old;
  1606.     /*----------------------------------------------------------------*/
  1607.     /* Code Body                                                      */
  1608.     /*----------------------------------------------------------------*/
  1609.     old = mmi_ctm_is_tty_on();
  1610.     ctm_p->mode_setting = (U8) ctm_p->index;
  1612.     WriteValue(NVRAM_CTM_SETTING, &ctm_p->mode_setting, DS_BYTE, &error);
  1614.     mmi_ctm_send_set_default_req(ctm_p->status, ctm_p->mode_setting);
  1615.  if (old == FALSE && mmi_ctm_is_tty_on() == TRUE)
  1616.     {
  1617.         /* off -> on */
  1618.         /* with earphone, take as TTY */
  1619.         if (isEarphonePlugged == TRUE)
  1620.         {
  1621.             str_id = STR_CTM_HEADSET_TO_TTY;
  1622.             /* deactivate earphone mode, Tim */
  1623.             mmi_profiles_earphone_plug_out_callback();
  1624.         #if (defined (__MMI_STATUS_ICON_EN_EARPHONE__) || defined(__MMI_BT_SUPPORT__))
  1625.             IdleResetStatusIcon(STATUS_ICON_EARPHONE_INDICATOR);
  1626.         #endif 
  1627.         }
  1628.     }
  1629.  else if (old == TRUE && mmi_ctm_is_tty_on() == FALSE)
  1630.     {
  1631.         /* on -> off */
  1632.         if (isEarphonePlugged == TRUE)
  1633.         {
  1634.             str_id = STR_CTM_TTY_TO_HEADSET;
  1635.             /* activate earphone mode, Tim */
  1636.             mmi_profiles_earphone_plug_in_callback();
  1637.         #if (defined (__MMI_STATUS_ICON_EN_EARPHONE__) || defined(__MMI_BT_SUPPORT__))
  1638.             IdleSetStatusIcon(STATUS_ICON_EARPHONE_INDICATOR);
  1639.         #endif 
  1640.         }
  1641.     }
  1643.     DisplayPopup((PU8) GetString(str_id), IMG_GLOBAL_ACTIVATED, 1, 2000, SUCCESS_TONE);
  1645.     DeleteScreenIfPresent(SCR_CTM_SETTING);
  1646. }
  1649. /*****************************************************************************
  1650.  * FUNCTION
  1651.  *  mmi_ctm_get_mode
  1652.  * DESCRIPTION
  1653.  *  
  1654.  * PARAMETERS
  1655.  *  void
  1656.  *  void(?)     [IN]        *
  1657.  * RETURNS
  1658.  *  void
  1659.  *****************************************************************************/
  1660. pBOOL mmi_ctm_get_mode(void)
  1661. {
  1662.     /*----------------------------------------------------------------*/
  1663.     /* Local Variables                                                */
  1664.     /*----------------------------------------------------------------*/
  1666.     /*----------------------------------------------------------------*/
  1667.     /* Code Body                                                      */
  1668.     /*----------------------------------------------------------------*/
  1669.     return ctm_p->status;
  1670. }
  1673. /*****************************************************************************
  1674.  * FUNCTION
  1675.  *  mmi_ctm_get_setting
  1676.  * DESCRIPTION
  1677.  *  
  1678.  * PARAMETERS
  1679.  *  void
  1680.  *  void(?)     [IN]        *
  1681.  * RETURNS
  1682.  *  void
  1683.  *****************************************************************************/
  1684. U8 mmi_ctm_get_setting(void)
  1685. {
  1686.     /*----------------------------------------------------------------*/
  1687.     /* Local Variables                                                */
  1688.     /*----------------------------------------------------------------*/
  1690.     /*----------------------------------------------------------------*/
  1691.     /* Code Body                                                      */
  1692.     /*----------------------------------------------------------------*/
  1693.     return ctm_p->mode_setting;
  1694. }
  1696. /*****************************************************************************
  1697.  * FUNCTION
  1698.  *  mmi_ctm_is_tty_on
  1699.  * DESCRIPTION
  1700.  *  
  1701.  * PARAMETERS
  1702.  *  void
  1703.  *  void(?)     [IN]        *
  1704.  * RETURNS
  1705.  *  void
  1706.  *****************************************************************************/
  1707. pBOOL mmi_ctm_is_tty_on(void)
  1708. {
  1709.     /*----------------------------------------------------------------*/
  1710.     /* Local Variables                                                */
  1711.     /*----------------------------------------------------------------*/
  1713.     /*----------------------------------------------------------------*/
  1714.     /* Code Body                                                      */
  1715.     /*----------------------------------------------------------------*/
  1716.     /* TTY on depends on status and setting */
  1717.     /* TTY status depends on status and earphone plug in or not */
  1718.     if (ctm_p->status == TRUE && 
  1719.        (ctm_p->mode_setting == MMI_CTM_SETTING_BAUDOT ||
  1720.         ctm_p->mode_setting == MMI_CTM_SETTING_HCO ||
  1721.         ctm_p->mode_setting == MMI_CTM_SETTING_VCO))
  1722.         return TRUE;
  1723.     else
  1724.        return FALSE;
  1725. }
  1727. /*****************************************************************************
  1728.  * FUNCTION
  1729.  *  mmi_ctm_get_tty_status
  1730.  * DESCRIPTION
  1731.  *  
  1732.  * PARAMETERS
  1733.  *  void
  1734.  *  void(?)     [IN]        *
  1735.  * RETURNS
  1736.  *  void
  1737.  *****************************************************************************/
  1738. pBOOL mmi_ctm_get_tty_status(void)
  1739. {
  1740.     /*----------------------------------------------------------------*/
  1741.     /* Local Variables                                                */
  1742.     /*----------------------------------------------------------------*/
  1744.     /*----------------------------------------------------------------*/
  1745.     /* Code Body                                                      */
  1746.     /*----------------------------------------------------------------*/
  1747.     return ctm_p->tty_status;
  1748. }
  1751. /*****************************************************************************
  1752.  * FUNCTION
  1753.  *  mmi_skip_unicode_char
  1754.  * DESCRIPTION
  1755.  *  
  1756.  * PARAMETERS
  1757.  *  str         [IN]        
  1758.  *  len         [IN]        
  1759.  *  ch          [IN]        
  1760.  *  void(?)     [IN]        *
  1761.  * RETURNS
  1762.  *  void
  1763.  *****************************************************************************/
  1764. U16 mmi_skip_unicode_char(PU16 str, U16 len, U16 ch)
  1765. {
  1766.     /*----------------------------------------------------------------*/
  1767.     /* Local Variables                                                */
  1768.     /*----------------------------------------------------------------*/
  1769.     U16 length, i;
  1771.     /*----------------------------------------------------------------*/
  1772.     /* Code Body                                                      */
  1773.     /*----------------------------------------------------------------*/
  1774.     length = len;
  1775.     for (i = 0; i < length; i++)
  1776.     {
  1777.         if (str[i] == ch)
  1778.         {
  1779.             pfnUnicodeStrcpy((PS8) & str[i], (PS8) & str[i + 1]);
  1780.             str[length] = 0;
  1781.             length--;
  1782.         }
  1783.     }
  1784.     return length;
  1785. }
  1788. /*****************************************************************************
  1789.  * FUNCTION
  1790.  *  mmi_ctm_set_tty_status
  1791.  * DESCRIPTION
  1792.  *  
  1793.  * PARAMETERS
  1794.  *  is_present      [IN]        
  1795.  *  void(?)         [IN]        *
  1796.  * RETURNS
  1797.  *  void
  1798.  *****************************************************************************/
  1799. void mmi_ctm_set_tty_status(pBOOL is_present)
  1800. {
  1801.     /*----------------------------------------------------------------*/
  1802.     /* Local Variables                                                */
  1803.     /*----------------------------------------------------------------*/
  1805.     /*----------------------------------------------------------------*/
  1806.     /* Code Body                                                      */
  1807.     /*----------------------------------------------------------------*/
  1808.     if (mmi_ctm_get_mode())
  1809.     {
  1810.         ctm_p->tty_status = is_present;
  1811.     }
  1812.     else
  1813.     {
  1814.         ctm_p->tty_status = FALSE;
  1815.     }
  1816. }
  1819. /*****************************************************************************
  1820.  * FUNCTION
  1821.  *  entry_ctm_menu
  1822.  * DESCRIPTION
  1823.  *  CTM main menu: Mode, Setting
  1824.  * PARAMETERS
  1825.  *  void
  1826.  *  void(?)     [IN]        *
  1827.  * RETURNS
  1828.  *  void
  1829.  *****************************************************************************/
  1830. void entry_ctm_menu(void)
  1831. {
  1832.     /*----------------------------------------------------------------*/
  1833.     /* Local Variables                                                */
  1834.     /*----------------------------------------------------------------*/
  1835.     U16 nStrItemList[4];
  1836.     U16 nNumofItem;
  1837.     S16 error;
  1838.     U8 *guiBuffer;
  1839.     static U8 *PopUpList[4];
  1841.     /*----------------------------------------------------------------*/
  1842.     /* Code Body                                                      */
  1843.     /*----------------------------------------------------------------*/
  1844.     EntryNewScreen(SCR_CTM_MENU, NULL, entry_ctm_menu, NULL);
  1846.     ReadValue(NVRAM_CTM_MODE, &ctm_p->status, DS_BYTE, &error);
  1847.     if (ctm_p->status == 0xff)
  1848.     {
  1849.         ctm_p->status = FALSE;
  1850.     }
  1852.     ReadValue(NVRAM_CTM_SETTING, &ctm_p->mode_setting, DS_BYTE, &error);
  1853.     if (ctm_p->mode_setting == 0xff)
  1854.     {
  1855.         ctm_p->mode_setting = MMI_CTM_SETTING_MANUAL_DIRECT;
  1856.     }
  1858.     guiBuffer = GetCurrGuiBuffer(SCR_CTM_MENU);
  1860.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  1861.     nNumofItem = GetNumOfChild(MITEM_CTM_MENU);
  1862.     GetSequenceStringIds(MITEM_CTM_MENU, nStrItemList);
  1863.     SetParentHandler(MITEM_CTM_MENU);
  1864.     ConstructHintsList(MITEM_CTM_MENU, PopUpList);
  1866.     ShowCategory55Screen(
  1867.         STR_GLOBAL_OPTIONS,
  1868.         GetRootTitleIcon(MAIN_MENU_SETTINGS_MENUID),
  1869.         STR_GLOBAL_OK,
  1870.         IMG_GLOBAL_OK,
  1871.         STR_GLOBAL_BACK,
  1872.         IMG_GLOBAL_BACK,
  1873.         nNumofItem,
  1874.         nStrItemList,
  1875.         (U8 **) PopUpList,
  1876.         0,
  1877.         guiBuffer);
  1879.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1880.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1881.     return;
  1883. }
  1886. /*****************************************************************************
  1887.  * FUNCTION
  1888.  *  entry_ctm_setting_selection
  1889.  * DESCRIPTION
  1890.  *  
  1891.  * PARAMETERS
  1892.  *  void
  1893.  *  void(?)     [IN]        *
  1894.  * RETURNS
  1895.  *  void
  1896.  *****************************************************************************/
  1897. void entry_ctm_setting_selection(void)
  1898. {
  1899.     /*----------------------------------------------------------------*/
  1900.     /* Local Variables                                                */
  1901.     /*----------------------------------------------------------------*/
  1902.     U16 nStrItemList[20];
  1903.     U16 nNumofItem;
  1904.     U8 *guiBuffer;
  1906.     /*----------------------------------------------------------------*/
  1907.     /* Code Body                                                      */
  1908.     /*----------------------------------------------------------------*/
  1909.     EntryNewScreen(SCR_CTM_SETTING, NULL, entry_ctm_setting_selection, NULL);
  1911.     guiBuffer = GetCurrGuiBuffer(SCR_CTM_SETTING);
  1913.     RegisterHighlightHandler(highlight_ctm_setting_items);
  1914.     nNumofItem = GetNumOfChild(MITEM_CTM_SETTING);
  1915.     GetSequenceStringIds(MITEM_CTM_SETTING, nStrItemList);
  1916.     SetParentHandler(MITEM_CTM_SETTING);
  1918.     ShowCategory11Screen(
  1919.         STR_MITEM_CTM_SETTING,
  1920.         GetRootTitleIcon(MAIN_MENU_SETTINGS_MENUID),
  1921.         STR_GLOBAL_OK,
  1922.         0,
  1923.         STR_GLOBAL_BACK,
  1924.         0,
  1925.         nNumofItem,
  1926.         nStrItemList,
  1927.         ctm_p->mode_setting,
  1928.         guiBuffer);
  1930.     SetLeftSoftkeyFunction(mmi_ctm_setting_select, KEY_EVENT_UP);
  1931.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1932.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1933.     return;
  1934. }
  1937. /*****************************************************************************
  1938.  * FUNCTION
  1939.  *  entry_ctm_connect_animation
  1940.  * DESCRIPTION
  1941.  *  
  1942.  * PARAMETERS
  1943.  *  void
  1944.  *  void(?)     [IN]        *
  1945.  * RETURNS
  1946.  *  void
  1947.  *****************************************************************************/
  1948. void entry_ctm_connect_animation(void)
  1949. {
  1950.     /*----------------------------------------------------------------*/
  1951.     /* Local Variables                                                */
  1952.     /*----------------------------------------------------------------*/
  1954.     /*----------------------------------------------------------------*/
  1955.     /* Code Body                                                      */
  1956.     /*----------------------------------------------------------------*/
  1957.     EntryNewScreen(SCR_CTM_CONNECTING, NULL, entry_ctm_connect_animation, NULL);
  1959.     DeleteScreenIfPresent(SCR1003_CM_ACTIVECALLOPTIONS);
  1961.     ShowCategory66Screen(0, 0, 0, 0, 0, 0, (PU8) GetString(STR_CTM_CONNECTING), IMG_GLOBAL_PROGRESS, NULL);
  1963.     ClearKeyHandler(KEY_END, KEY_EVENT_DOWN);
  1964. }
  1967. /*****************************************************************************
  1968.  * FUNCTION
  1969.  *  entry_ctm_talking
  1970.  * DESCRIPTION
  1971.  *  
  1972.  * PARAMETERS
  1973.  *  void
  1974.  *  void(?)     [IN]        *
  1975.  * RETURNS
  1976.  *  void
  1977.  *****************************************************************************/
  1978. void entry_ctm_talking(void)
  1979. {
  1980.     /*----------------------------------------------------------------*/
  1981.     /* Local Variables                                                */
  1982.     /*----------------------------------------------------------------*/
  1983.     U16 lsk = 0;
  1985.     /*----------------------------------------------------------------*/
  1986.     /* Code Body                                                      */
  1987.     /*----------------------------------------------------------------*/
  1988.     if (ctm_p->state < MMI_CTM_STATE_CONNECTED)
  1989.     {
  1990.         /* not connected, use default active screen */
  1991.         if (IsScreenPresent(SCR_CM_ACTIVECALLSCREEN))
  1992.         {
  1993.             GoBackToHistory(SCR_CM_ACTIVECALLSCREEN);
  1994.         }
  1995.         else
  1996.         {
  1997.             EntryScr1002ActiveCall();
  1998.         }
  1999.         return;
  2000.     }
  2002.     EntryNewScreen(SCR_CTM_TALKING, NULL, entry_ctm_talking, NULL);
  2004.     PRINT_INFORMATION(("nCTM TALKING SCREENn"));
  2006.     if (MAX_CTM_EDITOR_COUNT - ctm_p->pending_len > 0)
  2007.     {
  2008.         lsk = STR_GLOBAL_EDIT;
  2009.     }
  2011.     ShowCategory430Screen(
  2012.         STR_CTM_CHAT,
  2013.         0,
  2014.         lsk,
  2015.         0,
  2016.         STR_MITEM2041_CM_DROP,
  2017.         0,
  2018.         ctm_p->remote_buffer,
  2019.         ctm_p->remote_len,
  2020.         ctm_p->local_buffer,
  2021.         ctm_p->local_len,
  2022.         TRUE,
  2023.         MAX_CTM_EDITOR_COUNT,
  2024.         ctm_p->pending_buffer,
  2025.         0,
  2026.         (PU8) GetString(STR_CTM_REMOTE),
  2027.         (PU8) GetString(STR_CTM_LOCAL),
  2028.         NULL);
  2030.     SetLeftSoftkeyFunction(entry_ctm_editor, KEY_EVENT_UP);
  2032.     SetRightSoftkeyFunction(HangupAll, KEY_EVENT_UP);
  2033.     SetKeyHandler(HangupAll, KEY_END, KEY_EVENT_DOWN);
  2034. }
  2037. /*****************************************************************************
  2038.  * FUNCTION
  2039.  *  entry_ctm_editor
  2040.  * DESCRIPTION
  2041.  *  
  2042.  * PARAMETERS
  2043.  *  void
  2044.  *  void(?)     [IN]        *
  2045.  * RETURNS
  2046.  *  void
  2047.  *****************************************************************************/
  2048. void entry_ctm_editor(void)
  2049. {
  2050.     /*----------------------------------------------------------------*/
  2051.     /* Local Variables                                                */
  2052.     /*----------------------------------------------------------------*/
  2053.     U8 *guiBuffer;
  2054.     S32 length;
  2056.     /*----------------------------------------------------------------*/
  2057.     /* Code Body                                                      */
  2058.     /*----------------------------------------------------------------*/
  2059.     EntryNewScreen(SCR_CTM_EDITOR, NULL, entry_ctm_editor, NULL);
  2061.     guiBuffer = GetCurrGuiBuffer(SCR_CTM_EDITOR);
  2063.     length = MAX_CTM_EDITOR_COUNT - ctm_p->pending_len;
  2064.     ShowCategory5Screen(
  2065.         STR_GLOBAL_EDIT,
  2066.         0,
  2067.         STR_GLOBAL_OK,
  2068.         IMG_GLOBAL_OK,
  2069.         STR_GLOBAL_BACK,
  2070.         IMG_GLOBAL_BACK,
  2071.         (INPUT_TYPE_ALPHANUMERIC_UPPERCASE),
  2072.         (PU8) ctm_p->editor_buffer,
  2073.         length + 1,
  2074.         guiBuffer);
  2076.     ClearKeyHandler(KEY_POUND, KEY_EVENT_DOWN);
  2077.     SetLeftSoftkeyFunction(mmi_ctm_edit_done/*entry_ctm_editor_option*/, KEY_EVENT_UP);
  2078.     SetCategory5RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  2079.     return;
  2081. }
  2084. /*****************************************************************************
  2085.  * FUNCTION
  2086.  *  ctm_return_to_editor
  2087.  * DESCRIPTION
  2088.  *  
  2089.  * PARAMETERS
  2090.  *  void
  2091.  *  void(?)     [IN]        *
  2092.  * RETURNS
  2093.  *  void
  2094.  *****************************************************************************/
  2095. void ctm_return_to_editor(void)
  2096. {
  2097.     /*----------------------------------------------------------------*/
  2098.     /* Local Variables                                                */
  2099.     /*----------------------------------------------------------------*/
  2101.     /*----------------------------------------------------------------*/
  2102.     /* Code Body                                                      */
  2103.     /*----------------------------------------------------------------*/
  2104.     GoBacknHistory(1);
  2105. }
  2108. /*****************************************************************************
  2109.  * FUNCTION
  2110.  *  entry_ctm_editor_option
  2111.  * DESCRIPTION
  2112.  *  
  2113.  * PARAMETERS
  2114.  *  void
  2115.  *  void(?)     [IN]        *
  2116.  * RETURNS
  2117.  *  void
  2118.  *****************************************************************************/
  2119. void entry_ctm_editor_option(void)
  2120. {
  2121.     /*----------------------------------------------------------------*/
  2122.     /* Local Variables                                                */
  2123.     /*----------------------------------------------------------------*/
  2124.     U16 nStrItemList[10];
  2125.     U8 *guiBuffer;
  2126.     U16 nNumofItem;
  2128.     /*----------------------------------------------------------------*/
  2129.     /* Code Body                                                      */
  2130.     /*----------------------------------------------------------------*/
  2131.     EntryNewScreen(SCR_CTM_EDITOR_OPTION, NULL, entry_ctm_editor_option, NULL);
  2133.     guiBuffer = GetCurrGuiBuffer(SCR_CTM_EDITOR_OPTION);
  2135.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  2136.     nNumofItem = GetNumOfChild(MITEM_CTM_EDITOR_OPTION);
  2137.     GetSequenceStringIds(MITEM_CTM_EDITOR_OPTION, nStrItemList);
  2138.     SetParentHandler(MITEM_CTM_EDITOR_OPTION);
  2140.     ShowCategory15Screen(
  2141.         STR_GLOBAL_OPTIONS,
  2142.         0,
  2143.         STR_GLOBAL_OK,
  2144.         IMG_GLOBAL_OK,
  2145.         STR_GLOBAL_BACK,
  2146.         IMG_GLOBAL_BACK,
  2147.         nNumofItem,
  2148.         nStrItemList,
  2149.         (U16*) gIndexIconsImageList,
  2150.         1,
  2151.         0,
  2152.         guiBuffer);
  2154.     RegisterInputMethodScreenCloseFunction(ctm_return_to_editor);
  2155.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  2156.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  2157.     return;
  2159. }
  2161. #endif /* __CTM_SUPPORT__ */