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

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

MTK

开发平台：

C/C++

wgui_ems.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * wgui_ems_categories.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for UI wrapper routines for EMS .
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  * removed!
  109.  * removed!
  110.  * removed!
  111.  *
  112.  * removed!
  113.  * removed!
  114.  * removed!
  115.  *
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  *
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  *
  124.  * removed!
  125.  * removed!
  126.  * removed!
  127.  *
  128.  * removed!
  129.  * removed!
  130.  * removed!
  131.  *
  132.  * removed!
  133.  * removed!
  134.  * removed!
  135.  *
  136.  * removed!
  137.  * removed!
  138.  * removed!
  139.  *
  140.  * removed!
  141.  * removed!
  142.  * removed!
  143.  *
  144.  * removed!
  145.  * removed!
  146.  * removed!
  147.  *
  148.  * removed!
  149.  * removed!
  150.  * removed!
  151.  *
  152.  * removed!
  153.  * removed!
  154.  * removed!
  155.  *
  156.  * removed!
  157.  * removed!
  158.  * removed!
  159.  *
  160.  * removed!
  161.  * removed!
  162.  * removed!
  163.  *
  164.  * removed!
  165.  * removed!
  166.  * removed!
  167.  *
  168.  * removed!
  169.  * removed!
  170.  * removed!
  171.  *
  172.  * removed!
  173.  * removed!
  174.  * removed!
  175.  *
  176.  * removed!
  177.  * removed!
  178.  * removed!
  179.  *
  180.  * removed!
  181.  * removed!
  182.  * removed!
  183.  *
  184.  * removed!
  185.  * removed!
  186.  * removed!
  187.  *
  188.  * removed!
  189.  * removed!
  190.  * removed!
  191.  *
  192.  * removed!
  193.  * removed!
  194.  * removed!
  195.  *
  196.  * removed!
  197.  * removed!
  198.  * removed!
  199.  *
  200.  * removed!
  201.  * removed!
  202.  * removed!
  203.  *
  204.  * removed!
  205.  * removed!
  206.  * removed!
  207.  *
  208.  * removed!
  209.  * removed!
  210.  * removed!
  211.  *
  212.  * removed!
  213.  * removed!
  214.  * removed!
  215.  *
  216.  * removed!
  217.  * removed!
  218.  * removed!
  219.  *
  220.  * removed!
  221.  * removed!
  222.  * removed!
  223.  *
  224.  * removed!
  225.  * removed!
  226.  * removed!
  227.  *
  228.  * removed!
  229.  * removed!
  230.  * removed!
  231.  *
  232.  * removed!
  233.  * removed!
  234.  * removed!
  235.  *
  236.  * removed!
  237.  * removed!
  238.  * removed!
  239.  *
  240.  * removed!
  241.  * removed!
  242.  * removed!
  243.  *
  244.  * removed!
  245.  * removed!
  246.  * removed!
  247.  *
  248.  * removed!
  249.  * removed!
  250.  * removed!
  251.  *
  252.  * removed!
  253.  * removed!
  254.  * removed!
  255.  *
  256.  * removed!
  257.  * removed!
  258.  * removed!
  259.  *
  260.  * removed!
  261.  * removed!
  262.  * removed!
  263.  *
  264.  * removed!
  265.  * removed!
  266.  * removed!
  267.  *
  268.  * removed!
  269.  * removed!
  270.  * removed!
  271.  *
  272.  * removed!
  273.  * removed!
  274.  * removed!
  275.  *
  276.  * removed!
  277.  * removed!
  278.  * removed!
  279.  *
  280.  * removed!
  281.  * removed!
  282.  * removed!
  283.  *
  284.  * removed!
  285.  * removed!
  286.  * removed!
  287.  *
  288.  * removed!
  289.  * removed!
  290.  * removed!
  291.  *
  292.  * removed!
  293.  * removed!
  294.  * removed!
  295.  *
  296.  * removed!
  297.  * removed!
  298.  * removed!
  299.  *
  300.  * removed!
  301.  * removed!
  302.  * removed!
  303.  *
  304.  * removed!
  305.  * removed!
  306.  * removed!
  307.  *
  308.  * removed!
  309.  * removed!
  310.  * removed!
  311.  *
  312.  * removed!
  313.  * removed!
  314.  * removed!
  315.  *
  316.  * removed!
  317.  * removed!
  318.  * removed!
  319.  *
  320.  * removed!
  321.  * removed!
  322.  * removed!
  323.  *
  324.  *------------------------------------------------------------------------------
  325.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  326.  *============================================================================
  327.  ****************************************************************************/
  328.  /**
  329.  * Copyright Notice
  330.  * (c) 2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  331.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  332.  *  (It is illegal to remove this copyright notice from this software or any
  333.  *  portion of it)
  334.  */
  336. /**********************************************************************************
  337.    Filename:      wgui_ems_categories.c
  338.    Author:        manju
  339.    Date Created:  March-22-2003
  340.    Contains:      UI wrapper routines for EMS and category screens
  341. **********************************************************************************/
  346. #include "PixtelDataTypes.h"
  347. #include "MMI_features.h"
  349. #include "TimerEvents.h"
  350. #include "FileSystemDef.h"
  351. #include "FileSystemGProt.h"
  352. #include "conversions.h"
  354. #include "CustDataProts.h"
  355. #include "HistoryGprot.h"
  356. #include "CustMenuRes.h"
  357. #include "DebugInitDef.h"
  358. #include "GlobalDefs.h"
  359. #include "SettingProfile.h"
  360. #include "wgui.h"
  361. #include "wgui_categories.h"
  362. #include "wgui_categories_inputs.h"
  363. #include "wgui_categories_defs.h"
  364. #include "wgui_softkeys.h"
  365. #include "gdi_include.h"
  366. #include "wgui_ems.h"
  367. #include "MessagesResourceData.h"
  368. #include "CommonScreens.h"
  369. #if (defined(MMI_ON_HARDWARE_P) && defined(__MMI_FILE_MANAGER__))
  370. #include "FileMgr.h"
  371. #include "FileManagerDef.h"
  372. #include "FileManagerGProt.h"
  373. #endif /* (defined(MMI_ON_HARDWARE_P) && defined(__MMI_FILE_MANAGER__)) */ 
  374. #include "wgui_draw_manager.h"
  376. #include "t9def.h"
  378. #ifdef __MMI_HINDI_ALG__
  379. #include "hf_rules.h"
  380. #endif 
  381. #include "wgui_virtual_keyboard.h"
  382. #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  383. #include "EditorPen.h"
  384. #endif 
  386. /* MTK Elvis for R2L characters */
  387. extern BOOL r2lMMIFlag;
  389. /* MTK end */
  391. /* PMT dara added for Multitap thai */
  392. #ifdef __MMI_MULTITAP_THAI__
  393. void handle_category28_change_input_mode_bymultitapthai(void);
  394. #endif 
  396. U8 EMS_inputbox_check_multitap_thai_input(UI_character_type inputchar, U8 *updatef);
  398. extern void handle_category28_change_input_mode(void);
  399. extern void wgui_set_EMS_inputbox_RSK(void);
  400. extern void wgui_EMS_redraw_input_information_bar(void);
  401. extern void gui_EMS_change_DCS(UI_EMS_input_box *b);
  403. #ifdef __MMI_MESSAGES_EMS__
  404. extern void EMS_cancel_object_focus(void);
  405. #endif 
  406. /* MTK end */
  408. /* MTK Elvis */
  409. extern U16 StopMyTimer(U16 nTimerId);
  410. extern U16 StartMyTimerInt(U16 nTimerId, U32 nTimeDuration, oslTimerFuncPtr TimerExpiry, U8 alignment);
  412. /* MTK end */
  414. /* W05.36 Fix Vietnamese Tone Input Issue */
  415. extern void set_current_input_box_type(mmi_editor_inoutbox_enum input_box_type);
  417. /* MTK Elvis for prefered input method */
  418. extern S16 MMI_prefered_input_type;
  420. /* MTK end */
  422. extern void dm_set_scr_bg_image_no_draw(U16 image_id, S8 *file_name, S32 x, S32 y, U8 opacity);        /* 092005 grayscale Calvin */
  424. /* 070505 Calvin Start */
  425. #if defined (__MMI_WALLPAPER_ON_BOTTOM__)
  426. static MMI_ID_TYPE editor_scr_bg_ID;
  427. static S8 *editor_scr_bg_filename;
  428. static S32 editor_scr_bg_x, editor_scr_bg_y;
  429. static U8 editor_scr_bg_opacity;    /* 070505 Calvin added */
  430. #endif /* defined (__MMI_WALLPAPER_ON_BOTTOM__) */ 
  431. /* 070505 Calvin End */
  433. extern U8 PhnsetGetDefEncodingType(void);
  435. /* MTK Terry for RSK Display */
  436. void handle_category28_input(void);
  438. #if(!UI_DISABLE_EMS_CATEGORY_SCREENS)
  440. /* Temporary: Will be removed later */
  441. UI_string_type temp_EMS_buffer;
  442. EMSData *temp_EMS_data;
  444. /* EMS input box: Low level wrappers   */
  446. void (*EMS_inputbox_input_callback) (void);
  449. /*****************************************************************************
  450.  * FUNCTION
  451.  *  register_EMS_inputbox_input_callback
  452.  * DESCRIPTION
  453.  *  
  454.  * PARAMETERS
  455.  *  f       [IN]        
  456.  * RETURNS
  457.  *  void
  458.  *****************************************************************************/
  459. void register_EMS_inputbox_input_callback(void (*f) (void))
  460. {
  461.     /*----------------------------------------------------------------*/
  462.     /* Local Variables                                                */
  463.     /*----------------------------------------------------------------*/
  465.     /*----------------------------------------------------------------*/
  466.     /* Code Body                                                      */
  467.     /*----------------------------------------------------------------*/
  468.     EMS_inputbox_input_callback = f;
  469. }
  471. #if(!UI_DISABLE_EMS_INPUT_BOX)
  473. /* 072904 Calvin moved for centralized control */
  474. // #define ENABLE_EMS_INPUTBOX_FRAME_SKIPPING                   1
  475. /* Calvin end */
  477. U8 EMS_inputbox_has_changed = 0;
  478. UI_EMS_input_box MMI_EMS_inputbox;
  479. EMSTextFormat wgui_EMS_text_format;
  481. extern void wgui_EMS_redraw_remaining_characters_display(void);
  483. #if((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING))
  484. S32 wgui_EMS_inputbox_frame_counter = 0;
  485. #endif 
  488. /*****************************************************************************
  489.  * FUNCTION
  490.  *  show_EMS_inputbox
  491.  * DESCRIPTION
  492.  *  
  493.  * PARAMETERS
  494.  *  void
  495.  * RETURNS
  496.  *  void
  497.  *****************************************************************************/
  498. void show_EMS_inputbox(void)
  499. {
  500. #if(0)
  501.     /*----------------------------------------------------------------*/
  502.     /* Local Variables                                                */
  503.     /*----------------------------------------------------------------*/
  504. PRINT_INFORMATION(("nn"));
  505. if(MMI_EMS_inputbox.data->CurrentPosition.Object!=NULL)
  506. {
  507. if(MMI_EMS_inputbox.data->CurrentPosition.Object->Type==EMS_TYPE_TEXT_FORMAT)
  508. { PRINT_INFORMATION(("O: *"));
  509. }
  510. else
  511. { PRINT_INFORMATION(("O: %d",MMI_EMS_inputbox.data->CurrentPosition.Object->data.picture.pdu[0]));
  512. }
  513. }
  514. PRINT_INFORMATION((" TL: %d, TO: %d, T: %c",MMI_EMS_inputbox.data->textLength,MMI_EMS_inputbox.data->CurrentPosition.OffsetToText,MMI_EMS_inputbox.data->textBuffer[MMI_EMS_inputbox.data->CurrentPosition.OffsetToText+1]));
  515. #endif /* (0) */ 
  517.     /*----------------------------------------------------------------*/
  518.     /* Code Body                                                      */
  519.     /*----------------------------------------------------------------*/
  520.     gui_set_EMS_input_box_current_theme(&MMI_EMS_inputbox);
  522.     gui_show_EMS_input_box(&MMI_EMS_inputbox);
  523. #if(UI_DOUBLE_BUFFER_SUPPORT)
  524.     gui_BLT_double_buffer(
  525.         MMI_EMS_inputbox.x,
  526.         MMI_EMS_inputbox.y,
  527.         MMI_EMS_inputbox.x + MMI_EMS_inputbox.width - 1,
  528.         MMI_EMS_inputbox.y + MMI_EMS_inputbox.height - 1);
  529. #endif /* (UI_DOUBLE_BUFFER_SUPPORT) */ 
  530. }
  532. #if((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING))
  535. /*****************************************************************************
  536.  * FUNCTION
  537.  *  wgui_EMS_inputbox_end_frame
  538.  * DESCRIPTION
  539.  *  
  540.  * PARAMETERS
  541.  *  void
  542.  * RETURNS
  543.  *  void
  544.  *****************************************************************************/
  545. void wgui_EMS_inputbox_end_frame(void)
  546. {
  547.     /*----------------------------------------------------------------*/
  548.     /* Local Variables                                                */
  549.     /*----------------------------------------------------------------*/
  551.     /*----------------------------------------------------------------*/
  552.     /* Code Body                                                      */
  553.     /*----------------------------------------------------------------*/
  554.     if (wgui_EMS_inputbox_frame_counter >= 1)
  555.     {
  556.         S32 BLT_y2, y2;
  558.     #if(UI_DOUBLE_BUFFER_SUPPORT)
  559.         gui_lock_double_buffer();
  560.     #endif 
  561.         gui_show_EMS_input_box(&MMI_EMS_inputbox);
  562.         if (EMS_inputbox_has_changed)
  563.         {
  564.             wgui_EMS_redraw_remaining_characters_display();
  565.             EMS_inputbox_has_changed = 0;
  566.         }
  567.     #if(UI_DOUBLE_BUFFER_SUPPORT)
  568.         gui_unlock_double_buffer();
  569.         BLT_y2 = MMI_EMS_inputbox.y + MMI_EMS_inputbox.height;
  570.         y2 = MMI_multitap_y + MMI_multitap_height + 1;
  571.         if (BLT_y2 < y2)
  572.         {
  573.             BLT_y2 = y2;
  574.         }
  575.         gui_BLT_double_buffer(
  576.             MMI_EMS_inputbox.x,
  577.             MMI_EMS_inputbox.y,
  578.             MMI_EMS_inputbox.x + MMI_EMS_inputbox.width - 1,
  579.             BLT_y2);
  580.     #endif /* (UI_DOUBLE_BUFFER_SUPPORT) */ 
  581.         wgui_EMS_inputbox_frame_counter = 0;
  582.         gui_start_timer(UI_FRAME_SKIP_TIMEOUT, wgui_EMS_inputbox_end_frame);
  583.     }
  584. }
  586. #endif /* ((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING)) */ 
  588. #if(EMS_INPUTBOX_DEBUG)
  590. #define _DEBUG_PRINT(x) _debug_print x
  592. extern void DisplayToDebugwindow(S8 *nPrintableStr);
  595. /*****************************************************************************
  596.  * FUNCTION
  597.  *  _debug_print
  598.  * DESCRIPTION
  599.  *  
  600.  * PARAMETERS
  601.  *  fmt     [?]     
  602.  * RETURNS
  603.  *  void
  604.  *****************************************************************************/
  605. void _debug_print(S8 *fmt, ...)
  606. {
  607.     /*----------------------------------------------------------------*/
  608.     /* Local Variables                                                */
  609.     /*----------------------------------------------------------------*/
  610.     S8 display_string[2048];
  611.     va_list args;
  613.     /*----------------------------------------------------------------*/
  614.     /* Code Body                                                      */
  615.     /*----------------------------------------------------------------*/
  616.     va_start(args, fmt);
  617.     vsprintf(display_string, fmt, args);
  618.     va_end(args);
  619.     DisplayToDebugwindow(display_string);
  620. }
  623. /*****************************************************************************
  624.  * FUNCTION
  625.  *  _DUMP_EMS_TEXT_FORMAT_OBJECT
  626.  * DESCRIPTION
  627.  *  
  628.  * PARAMETERS
  629.  *  x       [?]     
  630.  * RETURNS
  631.  *  void
  632.  *****************************************************************************/
  633. void _DUMP_EMS_TEXT_FORMAT_OBJECT(EMSTextFormat *x)
  634. {
  635.     /*----------------------------------------------------------------*/
  636.     /* Local Variables                                                */
  637.     /*----------------------------------------------------------------*/
  639.     /*----------------------------------------------------------------*/
  640.     /* Code Body                                                      */
  641.     /*----------------------------------------------------------------*/
  642.     if (x != NULL)
  643.     {
  644.         _DEBUG_PRINT(("L=%03d ", x->textLength));
  645.         _DEBUG_PRINT(("AL="));
  646.         switch (x->Alignment)
  647.         {
  648.             case EMS_ALIGN_LEFT:
  649.                 _DEBUG_PRINT(("L"));
  650.                 break;
  651.             case EMS_ALIGN_RIGHT:
  652.                 _DEBUG_PRINT(("R"));
  653.                 break;
  654.             case EMS_ALIGN_CENTER:
  655.                 _DEBUG_PRINT(("C"));
  656.                 break;
  657.             case EMS_ALIGN_LANG_DEP:
  658.                 _DEBUG_PRINT(("D"));
  659.                 break;
  660.         }
  661.         _DEBUG_PRINT((" SZ="));
  662.         switch (x->FontSize)
  663.         {
  664.             case EMS_FONTSIZE_NORMAL:
  665.                 _DEBUG_PRINT(("N"));
  666.                 break;
  667.             case EMS_FONTSIZE_LARGE:
  668.                 _DEBUG_PRINT(("L"));
  669.                 break;
  670.             case EMS_FONTSIZE_SMALL:
  671.                 _DEBUG_PRINT(("S"));
  672.                 break;
  673.         }
  674.         _DEBUG_PRINT((" ST="));
  675.         if (x->isBold)
  676.         {
  677.             _DEBUG_PRINT(("B"));
  678.         }
  679.         if (x->isItalic)
  680.         {
  681.             _DEBUG_PRINT(("I"));
  682.         }
  683.         if (x->isUnderline)
  684.         {
  685.             _DEBUG_PRINT(("U"));
  686.         }
  687.         if (x->isStrikethrough)
  688.         {
  689.             _DEBUG_PRINT(("S"));
  690.         }
  691.     }
  692. }
  695. /*****************************************************************************
  696.  * FUNCTION
  697.  *  _DUMP_EMS_OBJECT
  698.  * DESCRIPTION
  699.  *  
  700.  * PARAMETERS
  701.  *  x       [?]     
  702.  * RETURNS
  703.  *  void
  704.  *****************************************************************************/
  705. void _DUMP_EMS_OBJECT(EMSObject *x)
  706. {
  707.     /*----------------------------------------------------------------*/
  708.     /* Local Variables                                                */
  709.     /*----------------------------------------------------------------*/
  711.     /*----------------------------------------------------------------*/
  712.     /* Code Body                                                      */
  713.     /*----------------------------------------------------------------*/
  714.     if (x == NULL)
  715.     {
  716.         _DEBUG_PRINT(("NULL"));
  717.     }
  718.     else
  719.     {
  720.         _DEBUG_PRINT(("%8X OFF=%03d ", x, x->OffsetToText));
  721.         switch (x->Type)
  722.         {
  723.             case EMS_TYPE_TEXT_FORMAT:
  724.                 _DEBUG_PRINT(("TXT FMT "));
  725.                 _DUMP_EMS_TEXT_FORMAT_OBJECT(&x->data->text_format);
  726.                 break;
  727.             case EMS_TYPE_PREDEF_SND:
  728.                 _DEBUG_PRINT(("PRE SND %d", x->PredefNo));
  729.                 break;
  730.             case EMS_TYPE_USERDEF_SND:
  731.                 _DEBUG_PRINT(("USR SND"));
  732.                 break;
  733.             case EMS_TYPE_PREDEF_ANM:
  734.                 _DEBUG_PRINT(("PRE ANM %d", x->PredefNo));
  735.                 break;
  736.             case EMS_TYPE_USERDEF_ANM:
  737.                 _DEBUG_PRINT(("USR ANM"));
  738.                 break;
  739.             case EMS_TYPE_PIC:
  740.                 _DEBUG_PRINT(("EMS PIC"));
  741.                 break;
  742.         }
  743.     }
  744. }
  746. #else /* (EMS_INPUTBOX_DEBUG) */ 
  748. #define _DEBUG_PRINT(x)
  751. /*****************************************************************************
  752.  * FUNCTION
  753.  *  _DUMP_EMS_OBJECT
  754.  * DESCRIPTION
  755.  *  
  756.  * PARAMETERS
  757.  *  x       [?]     
  758.  * RETURNS
  759.  *  void
  760.  *****************************************************************************/
  761. void _DUMP_EMS_OBJECT(EMSObject *x)
  762. {
  763.     /*----------------------------------------------------------------*/
  764.     /* Local Variables                                                */
  765.     /*----------------------------------------------------------------*/
  767.     /*----------------------------------------------------------------*/
  768.     /* Code Body                                                      */
  769.     /*----------------------------------------------------------------*/
  770.     UI_UNUSED_PARAMETER(x);
  771. }
  773. #endif /* (EMS_INPUTBOX_DEBUG) */ 
  775. extern U16 GetExitScrnID(void);
  777. #include "IdleAppDef.h"
  780. /*****************************************************************************
  781.  * FUNCTION
  782.  *  redraw_EMS_inputbox
  783.  * DESCRIPTION
  784.  *  
  785.  * PARAMETERS
  786.  *  void
  787.  * RETURNS
  788.  *  void
  789.  *****************************************************************************/
  790. void redraw_EMS_inputbox(void)
  791. {
  792.     /*----------------------------------------------------------------*/
  793.     /* Local Variables                                                */
  794.     /*----------------------------------------------------------------*/
  796.     /*----------------------------------------------------------------*/
  797.     /* Code Body                                                      */
  798.     /*----------------------------------------------------------------*/
  799.     if ((SCR_POPUP_SCREEN != GetExitScrnID()) && (POPUP_SCREENID != GetExitScrnID()))
  800.     {
  802.     #if(EMS_INPUTBOX_DEBUG)
  803.         S32 i = 0;
  804.         UI_character_type c = '-';
  805.         EMSObject *object = MMI_EMS_inputbox.data->listHead;
  806.         EMSPosition mapped_position;
  808.         EMS_map_position(MMI_EMS_inputbox.data, &MMI_EMS_inputbox.data->CurrentPosition, &mapped_position);
  809.         if ((MMI_EMS_inputbox.data->textBuffer != NULL) && (MMI_EMS_inputbox.data->textLength > 0) &&
  810.             (MMI_EMS_inputbox.data->CurrentPosition.OffsetToText < MMI_EMS_inputbox.data->textLength))
  811.         {
  812.             c = MMI_EMS_inputbox.data->textBuffer[MMI_EMS_inputbox.data->CurrentPosition.OffsetToText];
  813.         }
  814.         if ((c == 0x0A) || (c == 0x0D))
  815.         {
  816.             c = '.';
  817.         }
  818.         _DEBUG_PRINT(("nnCurrent position: %c OFF=%03d, Object=", c,
  819.                       MMI_EMS_inputbox.data->CurrentPosition.OffsetToText));
  820.         _DUMP_EMS_OBJECT(MMI_EMS_inputbox.data->CurrentPosition.Object);
  821.         _DEBUG_PRINT(("nMapped position:  %c OFF=%03d, Object=", c, mapped_position.OffsetToText,
  822.                       mapped_position.Object));
  823.         _DUMP_EMS_OBJECT(mapped_position.Object);
  824.         _DEBUG_PRINT(("nInputbox text format: "));
  825.         _DUMP_EMS_TEXT_FORMAT_OBJECT(&MMI_EMS_inputbox.text_format);
  826.         _DEBUG_PRINT(("nWGUI text format:     "));
  827.         _DUMP_EMS_TEXT_FORMAT_OBJECT(&wgui_EMS_text_format);
  828.         _DEBUG_PRINT(("nCurrent text format:  "));
  829.         _DUMP_EMS_OBJECT(MMI_EMS_inputbox.data->CurrentTextFormatObj);
  830.         while (object != NULL)
  831.         {
  832.             _DEBUG_PRINT(("nO%d=", i));
  833.             _DUMP_EMS_OBJECT(object);
  834.             object = object->next;
  835.             i++;
  836.         }
  837.         for (i = 0; i < MMI_EMS_inputbox.n_lines; i++)
  838.         {
  839.             _DEBUG_PRINT(("nL%d OFF=%03d, Count=%02d, x=%02d, Object=", i,
  840.                           MMI_EMS_inputbox.line_positions[i].OffsetToText, MMI_EMS_inputbox.line_object_counts[i],
  841.                           MMI_EMS_inputbox.line_x_positions[i]));
  842.             _DUMP_EMS_OBJECT(MMI_EMS_inputbox.line_positions[i].Object);
  843.         }
  844.         _DEBUG_PRINT(("n"));
  845.     #endif /* (EMS_INPUTBOX_DEBUG) */ 
  846.     #if(0)
  847. PRINT_INFORMATION(("nn"));
  848. if(MMI_EMS_inputbox.data->CurrentPosition.Object!=NULL)
  849. {
  850. if(MMI_EMS_inputbox.data->CurrentPosition.Object->Type==EMS_TYPE_TEXT_FORMAT)
  851. { PRINT_INFORMATION(("O: *"));
  852. }
  853. else
  854. { PRINT_INFORMATION(("O: %d",MMI_EMS_inputbox.data->CurrentPosition.Object->data.picture.pdu[0]));
  855. }
  856. }
  857. PRINT_INFORMATION((" TL: %d, TO: %d, T: %c",MMI_EMS_inputbox.data->textLength,MMI_EMS_inputbox.data->CurrentPosition.OffsetToText,MMI_EMS_inputbox.data->textBuffer[MMI_EMS_inputbox.data->CurrentPosition.OffsetToText+1]));
  858.     #endif /* (0) */ 
  860.     #if((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING))
  861.         if (wgui_EMS_inputbox_frame_counter > 0)
  862.         {
  863.             wgui_EMS_inputbox_frame_counter++;
  864.         }
  865.         else
  866.         {
  867.             wgui_EMS_inputbox_frame_counter = 1;
  868.             gui_start_timer(UI_FRAME_START_TIMEOUT, wgui_EMS_inputbox_end_frame);
  869.         }
  870.     #else /* ((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING)) */ 
  872.         gui_show_EMS_input_box(&MMI_EMS_inputbox);
  873.         /* MTK Terry fix EMS remaining characters display unsync bug firefly#278 */
  874.         if (!(MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  875.         {
  876.             wgui_EMS_redraw_remaining_characters_display();
  877.             /* EMS_inputbox_has_changed=0; */
  878.         }
  879.     #if(UI_DOUBLE_BUFFER_SUPPORT)
  880.         gui_BLT_double_buffer(
  881.             MMI_EMS_inputbox.x,
  882.             MMI_EMS_inputbox.y,
  883.             MMI_EMS_inputbox.x + MMI_EMS_inputbox.width - 1,
  884.             MMI_EMS_inputbox.y + MMI_EMS_inputbox.height - 1);
  885.     #endif /* (UI_DOUBLE_BUFFER_SUPPORT) */ 
  887.     #endif /* ((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING)) */ 
  888.     }
  889. }
  892. /*****************************************************************************
  893.  * FUNCTION
  894.  *  show_EMS_inputbox_no_draw
  895.  * DESCRIPTION
  896.  *  
  897.  * PARAMETERS
  898.  *  void
  899.  * RETURNS
  900.  *  void
  901.  *****************************************************************************/
  902. void show_EMS_inputbox_no_draw(void)
  903. {
  904.     /*----------------------------------------------------------------*/
  905.     /* Local Variables                                                */
  906.     /*----------------------------------------------------------------*/
  908.     /*----------------------------------------------------------------*/
  909.     /* Code Body                                                      */
  910.     /*----------------------------------------------------------------*/
  911.     MMI_EMS_inputbox.flags |= (UI_EMS_INPUT_BOX_DISABLE_DRAW);
  912.     gui_show_EMS_input_box(&MMI_EMS_inputbox);
  913.     MMI_EMS_inputbox.flags &= ~(UI_EMS_INPUT_BOX_DISABLE_DRAW);
  914. }
  917. /*****************************************************************************
  918.  * FUNCTION
  919.  *  EMS_inputbox_previous
  920.  * DESCRIPTION
  921.  *  
  922.  * PARAMETERS
  923.  *  void
  924.  * RETURNS
  925.  *  void
  926.  *****************************************************************************/
  927. void EMS_inputbox_previous(void)
  928. {
  929.     /*----------------------------------------------------------------*/
  930.     /* Local Variables                                                */
  931.     /*----------------------------------------------------------------*/
  933.     /*----------------------------------------------------------------*/
  934.     /* Code Body                                                      */
  935.     /*----------------------------------------------------------------*/
  936.     /* W05.34 Fix Multitap in arrow keys */
  937.     if (!(MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  938.     {
  939.         disable_active_multitap();
  940.     }
  941.     gui_EMS_input_box_previous(&MMI_EMS_inputbox);
  942.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  943.     redraw_EMS_inputbox();
  944. }
  947. /*****************************************************************************
  948.  * FUNCTION
  949.  *  EMS_inputbox_next
  950.  * DESCRIPTION
  951.  *  
  952.  * PARAMETERS
  953.  *  void
  954.  * RETURNS
  955.  *  void
  956.  *****************************************************************************/
  957. void EMS_inputbox_next(void)
  958. {
  959.     /*----------------------------------------------------------------*/
  960.     /* Local Variables                                                */
  961.     /*----------------------------------------------------------------*/
  963.     /*----------------------------------------------------------------*/
  964.     /* Code Body                                                      */
  965.     /*----------------------------------------------------------------*/
  966.     /* W05.34 Fix Multitap in arrow keys */
  967.     if (!(MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  968.     {
  969.         disable_active_multitap();
  970.     }
  971.     gui_EMS_input_box_next(&MMI_EMS_inputbox);
  972.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  973.     redraw_EMS_inputbox();
  974. }
  976. #ifdef __MMI_MESSAGES_EMS__
  979. /*****************************************************************************
  980.  * FUNCTION
  981.  *  EMS_inputbox_previous_object
  982.  * DESCRIPTION
  983.  *  
  984.  * PARAMETERS
  985.  *  void
  986.  * RETURNS
  987.  *  void
  988.  *****************************************************************************/
  989. void EMS_inputbox_previous_object(void)
  990. {
  991.     /*----------------------------------------------------------------*/
  992.     /* Local Variables                                                */
  993.     /*----------------------------------------------------------------*/
  995.     /*----------------------------------------------------------------*/
  996.     /* Code Body                                                      */
  997.     /*----------------------------------------------------------------*/
  998.     gui_EMS_input_box_view_previous_object(&MMI_EMS_inputbox);
  999.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1000.     redraw_EMS_inputbox();
  1001. }
  1004. /*****************************************************************************
  1005.  * FUNCTION
  1006.  *  EMS_inputbox_next_object
  1007.  * DESCRIPTION
  1008.  *  
  1009.  * PARAMETERS
  1010.  *  void
  1011.  * RETURNS
  1012.  *  void
  1013.  *****************************************************************************/
  1014. void EMS_inputbox_next_object(void)
  1015. {
  1016.     /*----------------------------------------------------------------*/
  1017.     /* Local Variables                                                */
  1018.     /*----------------------------------------------------------------*/
  1020.     /*----------------------------------------------------------------*/
  1021.     /* Code Body                                                      */
  1022.     /*----------------------------------------------------------------*/
  1023.     gui_EMS_input_box_view_next_object(&MMI_EMS_inputbox);
  1024.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1025.     redraw_EMS_inputbox();
  1026. }
  1027. #endif /* __MMI_MESSAGES_EMS__ */ 
  1030. /*****************************************************************************
  1031.  * FUNCTION
  1032.  *  EMS_inputbox_previous_line
  1033.  * DESCRIPTION
  1034.  *  
  1035.  * PARAMETERS
  1036.  *  void
  1037.  * RETURNS
  1038.  *  void
  1039.  *****************************************************************************/
  1040. void EMS_inputbox_previous_line(void)
  1041. {
  1042.     /*----------------------------------------------------------------*/
  1043.     /* Local Variables                                                */
  1044.     /*----------------------------------------------------------------*/
  1046.     /*----------------------------------------------------------------*/
  1047.     /* Code Body                                                      */
  1048.     /*----------------------------------------------------------------*/
  1049.     /* W05.34 Fix Multitap in arrow keys */
  1050.     if (!(MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  1051.     {
  1052.         disable_active_multitap();
  1053.     }
  1054.     gui_EMS_input_box_previous_line(&MMI_EMS_inputbox);
  1055.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1056.     redraw_EMS_inputbox();
  1057. }
  1060. /*****************************************************************************
  1061.  * FUNCTION
  1062.  *  EMS_inputbox_next_line
  1063.  * DESCRIPTION
  1064.  *  
  1065.  * PARAMETERS
  1066.  *  void
  1067.  * RETURNS
  1068.  *  void
  1069.  *****************************************************************************/
  1070. void EMS_inputbox_next_line(void)
  1071. {
  1072.     /*----------------------------------------------------------------*/
  1073.     /* Local Variables                                                */
  1074.     /*----------------------------------------------------------------*/
  1076.     /*----------------------------------------------------------------*/
  1077.     /* Code Body                                                      */
  1078.     /*----------------------------------------------------------------*/
  1079.     /* W05.34 Fix Multitap in arrow keys */
  1080.     if (!(MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  1081.     {
  1082.         disable_active_multitap();
  1083.     }
  1084.     gui_EMS_input_box_next_line(&MMI_EMS_inputbox);
  1085.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1086.     redraw_EMS_inputbox();
  1087. }
  1089. UI_character_type EMS_GSM_extended_lookup[] = { '[', ']', '{', '}', '~', '\', '^', '|', 0xA2,  /* Euro character is mapped to 0xA2 */
  1090. };
  1093. /*****************************************************************************
  1094.  * FUNCTION
  1095.  *  EMS_GSM_extended_map
  1096.  * DESCRIPTION
  1097.  *  
  1098.  * PARAMETERS
  1099.  *  c       [IN]        
  1100.  * RETURNS
  1101.  *  
  1102.  *****************************************************************************/
  1103. U8 EMS_GSM_extended_map(UI_character_type c)
  1104. {
  1105.     /*----------------------------------------------------------------*/
  1106.     /* Local Variables                                                */
  1107.     /*----------------------------------------------------------------*/
  1108.     S32 i, n;
  1110.     /*----------------------------------------------------------------*/
  1111.     /* Code Body                                                      */
  1112.     /*----------------------------------------------------------------*/
  1113.     if (c & 0xff00)
  1114.     {
  1115.         return (0);
  1116.     }
  1117.     n = sizeof(EMS_GSM_extended_lookup) / sizeof(UI_character_type);
  1118.     for (i = 0; i < n; i++)
  1119.     {
  1120.         if (c == EMS_GSM_extended_lookup[i])
  1121.         {
  1122.             return (1);
  1123.         }
  1124.     }
  1125.     return (0);
  1126. }
  1129. /*****************************************************************************
  1130.  * FUNCTION
  1131.  *  EMS_inputbox_direct_input
  1132.  * DESCRIPTION
  1133.  *  
  1134.  * PARAMETERS
  1135.  *  c       [IN]        
  1136.  * RETURNS
  1137.  *  void
  1138.  *****************************************************************************/
  1139. void EMS_inputbox_direct_input(UI_character_type c)
  1140. {
  1141.     /*----------------------------------------------------------------*/
  1142.     /* Local Variables                                                */
  1143.     /*----------------------------------------------------------------*/
  1145.     /*----------------------------------------------------------------*/
  1146.     /* Code Body                                                      */
  1147.     /*----------------------------------------------------------------*/
  1148.     if (UI_TEST_LF_CHARACTER(c))
  1149.     {
  1150.         gui_EMS_input_box_insert_new_line(&MMI_EMS_inputbox);
  1151.     }
  1152.     else
  1153.     {
  1154.     #if(!EMS_USE_GSM_EXTENDED)
  1155.         if (MMI_EMS_inputbox.UCS2_count == 0)
  1156.         {
  1157.             if (EMS_GSM_extended_map(c))
  1158.             {
  1159.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, 0x1b);
  1160.             }
  1161.         }
  1162.     #endif /* (!EMS_USE_GSM_EXTENDED) */ 
  1163.         gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, c);
  1164.     }
  1165.     redraw_EMS_inputbox();
  1166.     EMS_inputbox_input_callback();
  1167. }
  1170. /*****************************************************************************
  1171.  * FUNCTION
  1172.  *  EMS_inputbox_direct_input_no_LF_check
  1173.  * DESCRIPTION
  1174.  *  
  1175.  * PARAMETERS
  1176.  *  c       [IN]        
  1177.  * RETURNS
  1178.  *  void
  1179.  *****************************************************************************/
  1180. void EMS_inputbox_direct_input_no_LF_check(UI_character_type c)
  1181. {
  1182.     /*----------------------------------------------------------------*/
  1183.     /* Local Variables                                                */
  1184.     /*----------------------------------------------------------------*/
  1186.     /*----------------------------------------------------------------*/
  1187.     /* Code Body                                                      */
  1188.     /*----------------------------------------------------------------*/
  1189.     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, c);
  1190.     redraw_EMS_inputbox();
  1191.     EMS_inputbox_input_callback();
  1192. }
  1195. /*****************************************************************************
  1196.  * FUNCTION
  1197.  *  EMS_inputbox_backspace
  1198.  * DESCRIPTION
  1199.  *  
  1200.  * PARAMETERS
  1201.  *  void
  1202.  * RETURNS
  1203.  *  void
  1204.  *****************************************************************************/
  1205. void EMS_inputbox_backspace(void)
  1206. {
  1207.     /*----------------------------------------------------------------*/
  1208.     /* Local Variables                                                */
  1209.     /*----------------------------------------------------------------*/
  1211.     /*----------------------------------------------------------------*/
  1212.     /* Code Body                                                      */
  1213.     /*----------------------------------------------------------------*/
  1214.     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1215.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1216.     redraw_EMS_inputbox();
  1217.     EMS_inputbox_input_callback();
  1218. }
  1221. /*****************************************************************************
  1222.  * FUNCTION
  1223.  *  EMS_inputbox_delete_all
  1224.  * DESCRIPTION
  1225.  *  
  1226.  * PARAMETERS
  1227.  *  void
  1228.  * RETURNS
  1229.  *  void
  1230.  *****************************************************************************/
  1231. void EMS_inputbox_delete_all(void)
  1232. {
  1233.     /*----------------------------------------------------------------*/
  1234.     /* Local Variables                                                */
  1235.     /*----------------------------------------------------------------*/
  1237.     /*----------------------------------------------------------------*/
  1238.     /* Code Body                                                      */
  1239.     /*----------------------------------------------------------------*/
  1240.     gui_EMS_input_box_delete_all(&MMI_EMS_inputbox);
  1241.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1242.     redraw_EMS_inputbox();
  1243.     EMS_inputbox_input_callback();
  1244. }
  1247. /*****************************************************************************
  1248.  * FUNCTION
  1249.  *  EMS_inputbox_toggle_insert_mode
  1250.  * DESCRIPTION
  1251.  *  
  1252.  * PARAMETERS
  1253.  *  void
  1254.  * RETURNS
  1255.  *  void
  1256.  *****************************************************************************/
  1257. void EMS_inputbox_toggle_insert_mode(void)
  1258. {
  1259.     /*----------------------------------------------------------------*/
  1260.     /* Local Variables                                                */
  1261.     /*----------------------------------------------------------------*/
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Code Body                                                      */
  1265.     /*----------------------------------------------------------------*/
  1266.     gui_EMS_input_box_toggle_insert_mode(&MMI_EMS_inputbox);
  1267.     redraw_EMS_inputbox();
  1268. }
  1271. /*****************************************************************************
  1272.  * FUNCTION
  1273.  *  EMS_inputbox_delete
  1274.  * DESCRIPTION
  1275.  *  
  1276.  * PARAMETERS
  1277.  *  void
  1278.  * RETURNS
  1279.  *  void
  1280.  *****************************************************************************/
  1281. void EMS_inputbox_delete(void)
  1282. {
  1283.     /*----------------------------------------------------------------*/
  1284.     /* Local Variables                                                */
  1285.     /*----------------------------------------------------------------*/
  1287.     /*----------------------------------------------------------------*/
  1288.     /* Code Body                                                      */
  1289.     /*----------------------------------------------------------------*/
  1290.     gui_EMS_input_box_delete(&MMI_EMS_inputbox);
  1291.     wgui_EMS_text_format = MMI_EMS_inputbox.text_format;
  1292.     redraw_EMS_inputbox();
  1293.     EMS_inputbox_input_callback();
  1294. }
  1297. /*****************************************************************************
  1298.  * FUNCTION
  1299.  *  EMS_inputbox_insert_new_line
  1300.  * DESCRIPTION
  1301.  *  
  1302.  * PARAMETERS
  1303.  *  void
  1304.  * RETURNS
  1305.  *  void
  1306.  *****************************************************************************/
  1307. void EMS_inputbox_insert_new_line(void)
  1308. {
  1309.     /*----------------------------------------------------------------*/
  1310.     /* Local Variables                                                */
  1311.     /*----------------------------------------------------------------*/
  1313.     /*----------------------------------------------------------------*/
  1314.     /* Code Body                                                      */
  1315.     /*----------------------------------------------------------------*/
  1316.     gui_EMS_input_box_insert_new_line(&MMI_EMS_inputbox);
  1317.     EMS_inputbox_input_callback();
  1318. }
  1321. /*****************************************************************************
  1322.  * FUNCTION
  1323.  *  EMS_inputbox_alphanumeric_keyboard_input_handler
  1324.  * DESCRIPTION
  1325.  *  
  1326.  * PARAMETERS
  1327.  *  keyc        [IN]        
  1328.  * RETURNS
  1329.  *  void
  1330.  *****************************************************************************/
  1331. void EMS_inputbox_alphanumeric_keyboard_input_handler(S32 keyc)
  1332. {
  1333.     /*----------------------------------------------------------------*/
  1334.     /* Local Variables                                                */
  1335.     /*----------------------------------------------------------------*/
  1337.     /*----------------------------------------------------------------*/
  1338.     /* Code Body                                                      */
  1339.     /*----------------------------------------------------------------*/
  1340.     if (keyc == 0xc0)
  1341.     {
  1342.         EMS_inputbox_direct_input_no_LF_check((UI_character_type) 'n');
  1343.     }
  1344.     else if (keyc == 0xbb)
  1345.     {
  1346.         EMS_inputbox_direct_input((UI_character_type) 0x0d);
  1347.     }
  1348.     else if (keyc == 0x08)
  1349.     {
  1350.         EMS_inputbox_backspace();
  1351.     }
  1352.     else if (keyc == 0x1b)
  1353.     {
  1354.         EMS_inputbox_delete_all();
  1355.     }
  1356.     else if (keyc == 0x0d)
  1357.     {
  1358.         EMS_inputbox_direct_input((UI_character_type) 'n');
  1359.     }
  1360.     else if (keyc == 0xbd)
  1361.     {
  1362.         EMS_inputbox_direct_input((UI_character_type) 0x1b);
  1363.     }
  1364.     else if (keyc > 0x1f)
  1365.     {
  1366.         EMS_inputbox_direct_input((UI_character_type) keyc);
  1367.     }
  1368. }
  1371. /*****************************************************************************
  1372.  * FUNCTION
  1373.  *  EMS_inputbox_key_handler
  1374.  * DESCRIPTION
  1375.  *  
  1376.  * PARAMETERS
  1377.  *  vkey_code       [IN]        
  1378.  *  key_state       [IN]        
  1379.  * RETURNS
  1380.  *  void
  1381.  *****************************************************************************/
  1382. void EMS_inputbox_key_handler(S32 vkey_code, S32 key_state)
  1383. {
  1384. #if(MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32)
  1385.     /*----------------------------------------------------------------*/
  1386.     /* Local Variables                                                */
  1387.     /*----------------------------------------------------------------*/
  1389.     /*----------------------------------------------------------------*/
  1390.     /* Code Body                                                      */
  1391.     /*----------------------------------------------------------------*/
  1392.     if (key_state)
  1393.     {
  1394.         switch (vkey_code)
  1395.         {
  1396.             case 37:
  1397.         #if(ENABLE_EMS_TEST_WORD_HIGHLIGHT)
  1398.                 MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1399.         #endif 
  1400.                 EMS_inputbox_previous();
  1401.                 break;
  1402.             case 38:
  1403.         #if(ENABLE_EMS_TEST_WORD_HIGHLIGHT)
  1404.                 gui_EMS_input_box_highlight_cursor_start(&MMI_EMS_inputbox);
  1405.                 show_EMS_inputbox();
  1406.         #else /* (ENABLE_EMS_TEST_WORD_HIGHLIGHT) */ 
  1407.                 EMS_inputbox_previous_line();
  1408.         #endif /* (ENABLE_EMS_TEST_WORD_HIGHLIGHT) */ 
  1409.                 break;
  1410.             case 39:
  1411.         #if(ENABLE_EMS_TEST_WORD_HIGHLIGHT)
  1412.                 MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1413.         #endif 
  1414.                 EMS_inputbox_next();
  1415.                 break;
  1416.             case 40:
  1417.         #if(ENABLE_EMS_TEST_WORD_HIGHLIGHT)
  1418.                 gui_EMS_input_box_highlight_cursor_end(&MMI_EMS_inputbox);
  1419.                 show_EMS_inputbox();
  1420.         #else /* (ENABLE_EMS_TEST_WORD_HIGHLIGHT) */ 
  1421.                 EMS_inputbox_next_line();
  1422.         #endif /* (ENABLE_EMS_TEST_WORD_HIGHLIGHT) */ 
  1423.                 break;
  1424.             case 36:    /* home */
  1425.                 break;
  1426.             case 35:    /* end */
  1427.                 break;
  1428.             case 33:    /* page up */
  1429.                 break;
  1430.             case 34:    /* page down */
  1431.                 break;
  1432.             case 45:
  1433.                 EMS_inputbox_toggle_insert_mode();
  1434.                 break;
  1435.             case 46:
  1436.                 EMS_inputbox_delete();
  1437.                 break;
  1438.         }
  1439.     }
  1440. #else /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  1441.     UI_UNUSED_PARAMETER(vkey_code);
  1442.     UI_UNUSED_PARAMETER(key_state);
  1443. #endif /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  1444. }
  1447. /*****************************************************************************
  1448.  * FUNCTION
  1449.  *  EMS_inputbox_viewer_key_handler
  1450.  * DESCRIPTION
  1451.  *  
  1452.  * PARAMETERS
  1453.  *  vkey_code       [IN]        
  1454.  *  key_state       [IN]        
  1455.  * RETURNS
  1456.  *  void
  1457.  *****************************************************************************/
  1458. void EMS_inputbox_viewer_key_handler(S32 vkey_code, S32 key_state)
  1459. {
  1460. #if(MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32)
  1461.     /*----------------------------------------------------------------*/
  1462.     /* Local Variables                                                */
  1463.     /*----------------------------------------------------------------*/
  1465.     /*----------------------------------------------------------------*/
  1466.     /* Code Body                                                      */
  1467.     /*----------------------------------------------------------------*/
  1468.     if (key_state)
  1469.     {
  1470.         switch (vkey_code)
  1471.         {
  1472.             case 37:
  1473.         #ifdef __MMI_MESSAGES_EMS__
  1474.                 EMS_inputbox_previous_object();
  1475.         #else 
  1476.                 EMS_inputbox_previous();
  1477.         #endif 
  1479.                 break;
  1480.             case 38:
  1481.                 EMS_inputbox_previous_line();
  1482.                 break;
  1484.             case 39:
  1485.         #ifdef __MMI_MESSAGES_EMS__
  1486.                 EMS_inputbox_next_object();
  1487.         #else 
  1488.                 EMS_inputbox_next();
  1489.         #endif 
  1490.                 break;
  1491.             case 40:
  1492.                 EMS_inputbox_next_line();
  1493.                 break;
  1494.             case 36:    /* home */
  1495.                 break;
  1496.             case 35:    /* end */
  1497.                 break;
  1498.             case 33:    /* page up */
  1499.                 break;
  1500.             case 34:    /* page down */
  1501.                 break;
  1502.             case 45:    /* insert */
  1503.                 break;
  1504.             case 46:    /* delete */
  1505.                 break;
  1506.         }
  1507.     }
  1508. #else /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  1509.     UI_UNUSED_PARAMETER(vkey_code);
  1510.     UI_UNUSED_PARAMETER(key_state);
  1511. #endif /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  1512. }
  1515. /*****************************************************************************
  1516.  * FUNCTION
  1517.  *  EMS_inputbox_multitap_input
  1518.  * DESCRIPTION
  1519.  *  
  1520.  * PARAMETERS
  1521.  *  c       [IN]        
  1522.  * RETURNS
  1523.  *  void
  1524.  *****************************************************************************/
  1525. void EMS_inputbox_multitap_input(UI_character_type c)
  1526. {
  1527.     /*----------------------------------------------------------------*/
  1528.     /* Local Variables                                                */
  1529.     /*----------------------------------------------------------------*/
  1531.     /*----------------------------------------------------------------*/
  1532.     /* Code Body                                                      */
  1533.     /*----------------------------------------------------------------*/
  1534.     gui_EMS_input_box_insert_multitap_character(&MMI_EMS_inputbox, c);
  1535.     redraw_EMS_inputbox();
  1536.     EMS_inputbox_input_callback();
  1537. }
  1540. /*****************************************************************************
  1541.  * FUNCTION
  1542.  *  EMS_inputbox_multitap_input_complete
  1543.  * DESCRIPTION
  1544.  *  
  1545.  * PARAMETERS
  1546.  *  void
  1547.  * RETURNS
  1548.  *  void
  1549.  *****************************************************************************/
  1550. void EMS_inputbox_multitap_input_complete(void)
  1551. {
  1552.     /*----------------------------------------------------------------*/
  1553.     /* Local Variables                                                */
  1554.     /*----------------------------------------------------------------*/
  1556.     /*----------------------------------------------------------------*/
  1557.     /* Code Body                                                      */
  1558.     /*----------------------------------------------------------------*/
  1559.     gui_EMS_input_box_confirm_multitap_character(&MMI_EMS_inputbox);
  1560.     redraw_EMS_inputbox();
  1561. }
  1564. /*****************************************************************************
  1565.  * FUNCTION
  1566.  *  EMS_inputbox_numeric_keyboard_input_handler
  1567.  * DESCRIPTION
  1568.  *  
  1569.  * PARAMETERS
  1570.  *  keyc        [IN]        
  1571.  * RETURNS
  1572.  *  void
  1573.  *****************************************************************************/
  1574. void EMS_inputbox_numeric_keyboard_input_handler(S32 keyc)
  1575. {
  1576.     /*----------------------------------------------------------------*/
  1577.     /* Local Variables                                                */
  1578.     /*----------------------------------------------------------------*/
  1580.     /*----------------------------------------------------------------*/
  1581.     /* Code Body                                                      */
  1582.     /*----------------------------------------------------------------*/
  1583.     if (keyc >= '0' && keyc <= '9')
  1584.     {
  1585.         EMS_inputbox_direct_input((U8) keyc);
  1586.     }
  1587.     else if (keyc == 0x08)
  1588.     {
  1589.         EMS_inputbox_backspace();
  1590.     }
  1591.     else if (keyc == 0x1b)
  1592.     {
  1593.         EMS_inputbox_delete_all();
  1594.     }
  1595. }
  1598. /*****************************************************************************
  1599.  * FUNCTION
  1600.  *  EMS_inputbox_handle_key_down
  1601.  * DESCRIPTION
  1602.  *  
  1603.  * PARAMETERS
  1604.  *  k       [IN]        
  1605.  * RETURNS
  1606.  *  void
  1607.  *****************************************************************************/
  1608. void EMS_inputbox_handle_key_down(MMI_key_code_type k)
  1609. {
  1610.     /*----------------------------------------------------------------*/
  1611.     /* Local Variables                                                */
  1612.     /*----------------------------------------------------------------*/
  1614.     /*----------------------------------------------------------------*/
  1615.     /* Code Body                                                      */
  1616.     /*----------------------------------------------------------------*/
  1617.     EMS_inputbox_direct_input((UI_character_type) ('0' + k));
  1618. }
  1621. /*****************************************************************************
  1622.  * FUNCTION
  1623.  *  register_EMS_inputbox_keys
  1624.  * DESCRIPTION
  1625.  *  
  1626.  * PARAMETERS
  1627.  *  void
  1628.  * RETURNS
  1629.  *  void
  1630.  *****************************************************************************/
  1631. void register_EMS_inputbox_keys(void)
  1632. {
  1633.     /*----------------------------------------------------------------*/
  1634.     /* Local Variables                                                */
  1635.     /*----------------------------------------------------------------*/
  1637.     /*----------------------------------------------------------------*/
  1638.     /* Code Body                                                      */
  1639.     /*----------------------------------------------------------------*/
  1640.     SetKeyHandler(EMS_inputbox_previous, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1641.     SetKeyHandler(EMS_inputbox_next, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1642.     SetKeyHandler(EMS_inputbox_previous_line, KEY_UP_ARROW, KEY_EVENT_DOWN);
  1643.     SetKeyHandler(EMS_inputbox_next_line, KEY_DOWN_ARROW, KEY_EVENT_DOWN);
  1644.     /* SetKeyHandler(EMS_inputbox_backspace,KEY_CLEAR,KEY_EVENT_DOWN); */
  1645.     register_keyboard_key_handler(EMS_inputbox_key_handler);
  1646. }
  1649. /*****************************************************************************
  1650.  * FUNCTION
  1651.  *  wgui_EMS_inputbox_handle_symbol_picker_star_key
  1652.  * DESCRIPTION
  1653.  *  
  1654.  * PARAMETERS
  1655.  *  void
  1656.  * RETURNS
  1657.  *  void
  1658.  *****************************************************************************/
  1659. void wgui_EMS_inputbox_handle_symbol_picker_star_key(void)
  1660. {
  1661.     /*----------------------------------------------------------------*/
  1662.     /* Local Variables                                                */
  1663.     /*----------------------------------------------------------------*/
  1665.     /*----------------------------------------------------------------*/
  1666.     /* Code Body                                                      */
  1667.     /*----------------------------------------------------------------*/
  1668.     disable_active_multitap();
  1669.     EntrySymbolPickerScreen();
  1670. }
  1673. /* MTK Elvis modify for Thai */
  1674. #if !defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__)
  1675. #else /* !defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__) */ 
  1676. extern FuncPtr currKeyFuncPtrs[MAX_KEYS][MAX_KEY_TYPE];
  1677. #endif /* !defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__) */ 
  1678. /* PMT dara added for Multitap thai */
  1679. #ifdef __MMI_MULTITAP_THAI__
  1680. //return 0 not accept input
  1681. //return 1 accept input
  1682. //return 2 normal
  1683. //return 3 means reset the MMI_active_multitap. not use
  1686. /*****************************************************************************
  1687.  * FUNCTION
  1688.  *  EMS_inputbox_check_multitap_thai_input
  1689.  * DESCRIPTION
  1690.  *  
  1691.  * PARAMETERS
  1692.  *  inputchar       [IN]        
  1693.  *  updatef         [?]         
  1694.  * RETURNS
  1695.  *  
  1696.  *****************************************************************************/
  1697. U8 EMS_inputbox_check_multitap_thai_input(UI_character_type inputchar, U8 *updatef)
  1698. {
  1699.     /*----------------------------------------------------------------*/
  1700.     /* Local Variables                                                */
  1701.     /*----------------------------------------------------------------*/
  1702.     EMSPosition p = MMI_EMS_inputbox.data->CurrentPosition;
  1703.     EMSObject *current_object;
  1704.     UI_character_type c;
  1705.     U8 r;
  1706.     UI_character_type cc;
  1708.     /*----------------------------------------------------------------*/
  1709.     /* Code Body                                                      */
  1710.     /*----------------------------------------------------------------*/
  1711.     r = gui_EMS_input_box_get_previous_object(MMI_EMS_inputbox.data, &p, &c, &current_object);
  1713.     if (r == 1) /* means that the previous is character */
  1714.     {
  1715.         if ((inputchar >= 0x0e34 && inputchar <= 0x0e39) || inputchar == 0x0e31)        /* Above Vowels and Below Vowels */
  1716.         {
  1717.             if (c == 0x0e30 || c == 0x0e32 || c == 0x0e33 || c == 0x0e46 || c == 0x0e2f || c == 0x0e3f ||
  1718.                 (c >= 0x0e40 && c <= 0x0e44) || c == 0x0030)
  1719.             {
  1720.                 if (c == 0x0030 && *updatef == 1)
  1721.                 {
  1722.                     MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_STATE_MULTITAP;
  1723.                     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1724.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1725.                     redraw_EMS_inputbox();
  1726.                     wgui_EMS_redraw_remaining_characters_display();
  1727.                     return 1;
  1728.                 }
  1729.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, 0x0030);
  1730.                 redraw_EMS_inputbox();
  1731.                 wgui_EMS_redraw_remaining_characters_display();
  1732.                 return 0;   /* not accept input */
  1733.             }
  1734.             else if ((c == 0x0e31 || (c >= 0x0e34 && c <= 0x0e39)))
  1735.             {   /* Above Vowels and Below Vowels */
  1736.                 if (*updatef == 0)
  1737.                 {
  1738.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, 0x0030);
  1739.                     redraw_EMS_inputbox();
  1740.                     wgui_EMS_redraw_remaining_characters_display();
  1741.                     return 0;
  1742.                 }
  1743.                 gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1744.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1745.                 redraw_EMS_inputbox();
  1746.                 wgui_EMS_redraw_remaining_characters_display();
  1747.                 return 1;
  1748.             }
  1749.             else if (c >= 0x0e47 && c <= 0x0e4c)
  1750.             {   /* tone */
  1751.                 if (*updatef == 0)
  1752.                 {
  1753.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, 0x0030);
  1754.                     redraw_EMS_inputbox();
  1755.                     wgui_EMS_redraw_remaining_characters_display();
  1756.                     return 0;
  1757.                 }
  1758.                 gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1759.                 if (c == 0x0e47)
  1760.                 {
  1761.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1762.                     redraw_EMS_inputbox();
  1763.                     wgui_EMS_redraw_remaining_characters_display();
  1764.                     return 1;
  1765.                 }
  1766.                 r = gui_EMS_input_box_get_previous_object(MMI_EMS_inputbox.data, &p, &cc, &current_object);
  1767.                 if (r == 1 && ((cc >= 0x0e34 && cc <= 0x0e39) || cc == 0x0e31))
  1768.                 {
  1769.                     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1770.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1771.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, c);
  1772.                     redraw_EMS_inputbox();
  1773.                     wgui_EMS_redraw_remaining_characters_display();
  1774.                 }
  1775.                 else
  1776.                 {
  1777.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1778.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, c);
  1779.                     redraw_EMS_inputbox();
  1780.                     wgui_EMS_redraw_remaining_characters_display();
  1781.                 }
  1782.                 return 1;
  1783.             }
  1784.             else if (c >= 0x0e01 && c <= 0x0e2e)
  1785.             {
  1786.                 /* msz00065_20051010 peng hua add for multitap thai begin */
  1787.                 if (gui_EMS_check_input_test_overflow(&MMI_EMS_inputbox, inputchar))
  1788.                     /* msz00065_20051010 peng hua add for multitap thai end */
  1789.                 {
  1790.                     *updatef = 1;
  1791.                 }
  1792.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1793.                 redraw_EMS_inputbox();
  1794.                 wgui_EMS_redraw_remaining_characters_display();
  1795.                 return 1;
  1796.             }
  1797.             else
  1798.             {
  1799.                 if (*updatef == 0)
  1800.                 {
  1801.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, 0x0030);
  1802.                     *updatef = 0;
  1803.                     redraw_EMS_inputbox();
  1804.                     wgui_EMS_redraw_remaining_characters_display();
  1805.                 }
  1806.                 return 0;
  1807.             }
  1808.         }
  1809.         else if (inputchar == 0x0030)
  1810.         {
  1811.             if (*updatef == 1)
  1812.             {
  1813.                 gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1814.                 /* redraw_EMS_inputbox(); */
  1815.                 return 2;
  1816.             }
  1817.         }
  1818.         else if (inputchar >= 0x0e47 && inputchar <= 0x0e4c)
  1819.         {
  1820.             if (c == 0x0e30 || c == 0x0e32 || c == 0x0e33 || c == 0x0e46 || c == 0x0e2f || c == 0x0e3f ||
  1821.                 (c >= 0x0e40 && c <= 0x0e44) || c == 0x0030)
  1822.             {
  1823.                 if ((c == 0x0e46 || c == 0x0e2f || c == 0x0e3f) && *updatef == 1)
  1824.                 {
  1825.                     MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_STATE_MULTITAP;
  1826.                     redraw_EMS_inputbox();
  1827.                     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1828.                     gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1829.                     redraw_EMS_inputbox();
  1830.                     wgui_EMS_redraw_remaining_characters_display();
  1831.                 }
  1832.                 return 1;   /* not accept input */
  1833.             }
  1834.             else if ((c >= 0x0e47 && c <= 0x0e4c))
  1835.             {   /* tone */
  1836.                 if (*updatef == 0)
  1837.                 {
  1838.                     return 1;
  1839.                 }
  1841.                 gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1842.                 if (inputchar == 0x0e47)    /*  */
  1843.                 {
  1844.                     r = gui_EMS_input_box_get_previous_object(MMI_EMS_inputbox.data, &p, &cc, &current_object);
  1845.                     if (r == 1 && ((cc >= 0x0e34 && cc <= 0x0e39) || cc == 0x0e31))
  1846.                     {
  1847.                         gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1848.                         gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1849.                         redraw_EMS_inputbox();
  1850.                         wgui_EMS_redraw_remaining_characters_display();
  1851.                         return 1;
  1852.                     }
  1853.                 }
  1854.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1855.                 redraw_EMS_inputbox();
  1856.                 wgui_EMS_redraw_remaining_characters_display();
  1857.                 return 1;
  1858.             }
  1859.             else if (c >= 0x0e01 && c <= 0x0e2e)
  1860.             {
  1861.                 /* msz00065_20051010 peng hua add for multitap thai begin */
  1862.                 if (gui_EMS_check_input_test_overflow(&MMI_EMS_inputbox, inputchar))
  1863.                     /* msz00065_20051010 peng hua add for multitap thai end */
  1864.                 {
  1865.                     *updatef = 1;
  1866.                 }
  1867.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1868.                 redraw_EMS_inputbox();
  1869.                 wgui_EMS_redraw_remaining_characters_display();
  1870.                 return 1;
  1871.             }
  1872.             else if ((c >= 0x0e34 && c <= 0x0e39) || c == 0x0e31)
  1873.             {
  1874.                 /* msz00065_20051010 peng hua add for multitap thai begin */
  1875.                 if (gui_EMS_check_input_test_overflow(&MMI_EMS_inputbox, inputchar))
  1876.                     /* msz00065_20051010 peng hua add for multitap thai end */
  1877.                 {
  1878.                     *updatef = 1;
  1879.                 }
  1880.                 if (inputchar == 0x0e47)    /*  */
  1881.                 {
  1882.                     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1883.                 }
  1884.                 gui_EMS_input_box_insert_character(&MMI_EMS_inputbox, inputchar);
  1885.                 redraw_EMS_inputbox();
  1886.                 wgui_EMS_redraw_remaining_characters_display();
  1887.                 return 1;
  1888.             }
  1889.             else
  1890.             {
  1891.                 if (*updatef == 1)
  1892.                 {
  1893.                     gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1894.                 }
  1895.                 return 1;
  1896.             }
  1897.         }
  1898.         if ((inputchar == 0x0e46 || inputchar == 0x0e2f || inputchar == 0x0e3f) && *updatef == 1)
  1899.         {
  1900.             gui_EMS_input_box_backspace(&MMI_EMS_inputbox);
  1901.             MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_STATE_MULTITAP;
  1902.             //                      gui_EMS_input_box_insert_character(&MMI_EMS_inputbox,inputchar);
  1903.             //                      redraw_EMS_inputbox();
  1904.             return 2;
  1905.         }
  1906.     }
  1907.     else    /* object */
  1908.     {
  1909.         if ((inputchar >= 0x0e34 && inputchar <= 0x0e39) || inputchar == 0x0e31)
  1910.         {
  1911.             return 0;
  1912.         }
  1913.         if (inputchar >= 0x0e47 && inputchar <= 0x0e4c)
  1914.         {
  1915.             return 0;
  1916.         }
  1917.     }
  1918.     return 2;
  1919. }
  1920. #endif /* __MMI_MULTITAP_THAI__ */ 
  1923. /*****************************************************************************
  1924.  * FUNCTION
  1925.  *  register_EMS_multitap_function
  1926.  * DESCRIPTION
  1927.  *  
  1928.  * PARAMETERS
  1929.  *  void
  1930.  * RETURNS
  1931.  *  void
  1932.  *****************************************************************************/
  1933. void register_EMS_multitap_function(void)
  1934. {
  1935.     /*----------------------------------------------------------------*/
  1936.     /* Local Variables                                                */
  1937.     /*----------------------------------------------------------------*/
  1939.     /*----------------------------------------------------------------*/
  1940.     /* Code Body                                                      */
  1941.     /*----------------------------------------------------------------*/
  1942.     /* W06.09 Touch Screen With Keypad V1 */
  1943. #if defined(__MMI_FULL_SCREEN_EDITOR__) || defined(__MMI_TOUCH_SCREEN__)
  1944.     register_multitap_no_draw_key_handlers();
  1945. #else 
  1946.     register_multitap_key_handlers();
  1947. #endif 
  1948.     register_keyboard_input_handler(EMS_inputbox_alphanumeric_keyboard_input_handler);
  1949.     set_multitap_functions(EMS_inputbox_multitap_input, EMS_inputbox_multitap_input_complete);
  1950.     wgui_set_EMS_inputbox_RSK();
  1951.     register_EMS_inputbox_keys();
  1952.     SetKeyHandler(wgui_EMS_inputbox_handle_symbol_picker_star_key, KEY_STAR, KEY_EVENT_DOWN);
  1953. }
  1959. /*****************************************************************************
  1960.  * FUNCTION
  1961.  *  register_EMS_inputbox_viewer_keys
  1962.  * DESCRIPTION
  1963.  *  
  1964.  * PARAMETERS
  1965.  *  void
  1966.  * RETURNS
  1967.  *  void
  1968.  *****************************************************************************/
  1969. void register_EMS_inputbox_viewer_keys(void)
  1970. {
  1971. #ifdef __MMI_MESSAGES_EMS__
  1972.     /*----------------------------------------------------------------*/
  1973.     /* Local Variables                                                */
  1974.     /*----------------------------------------------------------------*/
  1976.     /*----------------------------------------------------------------*/
  1977.     /* Code Body                                                      */
  1978.     /*----------------------------------------------------------------*/
  1979.     SetKeyHandler(EMS_inputbox_previous_object, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1980.     SetKeyHandler(EMS_inputbox_next_object, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1981. #else /* __MMI_MESSAGES_EMS__ */ 
  1982.     SetKeyHandler(EMS_inputbox_previous, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1983.     SetKeyHandler(EMS_inputbox_next, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1984. #endif /* __MMI_MESSAGES_EMS__ */ 
  1985.     SetKeyHandler(EMS_inputbox_previous_line, KEY_UP_ARROW, KEY_EVENT_DOWN);
  1986.     SetKeyHandler(EMS_inputbox_next_line, KEY_DOWN_ARROW, KEY_EVENT_DOWN);
  1987.     SetKeyHandler(EMS_inputbox_previous_line, KEY_VOL_UP, KEY_EVENT_DOWN);
  1988.     SetKeyHandler(EMS_inputbox_next_line, KEY_VOL_DOWN, KEY_EVENT_DOWN);
  1989.     register_keyboard_key_handler(EMS_inputbox_viewer_key_handler);
  1990. }
  1993. /*****************************************************************************
  1994.  * FUNCTION
  1995.  *  reset_EMS_inputbox
  1996.  * DESCRIPTION
  1997.  *  
  1998.  * PARAMETERS
  1999.  *  void
  2000.  * RETURNS
  2001.  *  void
  2002.  *****************************************************************************/
  2003. void reset_EMS_inputbox(void)
  2004. {
  2005. #if(UI_BLINKING_CURSOR_SUPPORT)
  2006.     /*----------------------------------------------------------------*/
  2007.     /* Local Variables                                                */
  2008.     /*----------------------------------------------------------------*/
  2010.     /*----------------------------------------------------------------*/
  2011.     /* Code Body                                                      */
  2012.     /*----------------------------------------------------------------*/
  2013.     //gui_cancel_timer(UI_inputbox_blink_cursor);
  2014.     //MTK Elvis
  2015.     StopMyTimer(BLINKING_CURSOR);
  2016.     /* MTK end */
  2018. #endif /* (UI_BLINKING_CURSOR_SUPPORT) */ 
  2019. #ifdef __MMI_MESSAGES_EMS__
  2020.     EMS_cancel_object_focus();
  2021. #endif 
  2022.     reset_multitaps();
  2023.     clear_keyboard_key_handler();
  2024.     clear_keyboard_input_handler();
  2025.     clear_multitap_key_handlers();
  2026.     ClearKeyHandler(KEY_CLEAR, KEY_EVENT_DOWN);
  2027.     ClearKeyHandler(KEY_CLEAR, KEY_EVENT_UP);
  2028.     ClearKeyHandler(KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  2029. #if((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING))
  2030.     gui_cancel_timer(wgui_EMS_inputbox_end_frame);
  2031.     wgui_EMS_inputbox_frame_counter = 0;
  2032. #endif /* ((UI_ENABLE_FRAME_SKIPPING) && (ENABLE_EMS_INPUTBOX_FRAME_SKIPPING)) */ 
  2033.     EMS_inputbox_input_callback = UI_dummy_function;
  2034. }
  2037. /*****************************************************************************
  2038.  * FUNCTION
  2039.  *  test_EMS_inputbox_change_mode
  2040.  * DESCRIPTION
  2041.  *  
  2042.  * PARAMETERS
  2043.  *  void
  2044.  * RETURNS
  2045.  *  
  2046.  *****************************************************************************/
  2047. U8 test_EMS_inputbox_change_mode(void)
  2048. {
  2049.     /*----------------------------------------------------------------*/
  2050.     /* Local Variables                                                */
  2051.     /*----------------------------------------------------------------*/
  2053.     /*----------------------------------------------------------------*/
  2054.     /* Code Body                                                      */
  2055.     /*----------------------------------------------------------------*/
  2056.     /* MTK Elvis */
  2057.     if (MMI_EMS_inputbox.UCS2_count == 0)
  2058.     {
  2059.         if (EMSSetDCS(MMI_EMS_inputbox.data, SMSAL_UCS2_DCS) == EMS_OK &&
  2060.             EMS_get_remaining_length(MMI_EMS_inputbox.data) >= 2)
  2061.         {
  2062.             EMSSetDCS(MMI_EMS_inputbox.data, SMSAL_DEFAULT_DCS);
  2063.             return 1;
  2064.         }
  2065.         else
  2066.         {
  2067.             EMSSetDCS(MMI_EMS_inputbox.data, SMSAL_DEFAULT_DCS);
  2068.             return 0;
  2069.         }
  2070.     }
  2071.     else
  2072.     {
  2073.         return 1;
  2074.     }
  2075.     /* MTK end */
  2076. }
  2078. /* Temporary data: for testing         */
  2079. #ifdef __MMI_MESSAGES_EMS__
  2081. const U8 EMS_sample_melody_object_PDU_1[] = 
  2082. {
  2083. #if(0)
  2084. EMS_PREDEFINED_MELODY, 0x69, 0x00,
  2085. 'B','E','G','I','N',':','I','M','E','L','O','D','Y','n',
  2086. 'V','E','R','S','I','O','N',':','1','.','2','n',
  2087. 'F','O','R','M','A','T',':','C','L','A','S','S','1','.','0','n',
  2088. 'M','E','L','O','D','Y',':','*','4','#','f','2','*','4','a','3','.','*','4','#','f','3','*','4','#','f','4','*','4','#','a','3','*','4','#','f','3','*','4','e','3','*','4','#','f','2','*','5','c','3','n',
  2089. 'E','N','D',':','I','M','E','L','O','D','Y','n',
  2090. #else /* (0) */ 
  2091.     EMS_PREDEFINED_MELODY, 0x74, 0x00,
  2092.     'B', 'E', 'G', 'I', 'N', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2093.     'V', 'E', 'R', 'S', 'I', 'O', 'N', ':', '1', '.', '2', 'n',
  2094.     'F', 'O', 'R', 'M', 'A', 'T', ':', 'C', 'L', 'A', 'S', 'S', '1', '.', '0', 'n',
  2095.     'B', 'E', 'A', 'T', ':', '1', '2', '0', 'n',
  2096.     'C', 'O', 'M', 'P', 'O', 'S', 'E', 'R', ':', 'M', 'T', 'K', '(', '2', ')', 'n',
  2097.     'M', 'E', 'L', 'O', 'D', 'Y', ':', 'c', '2', 'd', '2', 'e', '2', 'f', '2', 'g', '2', 'a', '2', 'b', '2', 'n',
  2098.     'E', 'N', 'D', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2099. #endif /* (0) */ 
  2100. };
  2102. const U8 EMS_sample_melody_object_PDU_2[] = {EMS_PREDEFINED_MELODY, 0x6c, 0x00,
  2103.     'B', 'E', 'G', 'I', 'N', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2104.     'V', 'E', 'R', 'S', 'I', 'O', 'N', ':', '1', '.', '2', 'n',
  2105.     'F', 'O', 'R', 'M', 'A', 'T', ':', 'C', 'L', 'A', 'S', 'S', '1', '.', '0', 'n',
  2106.     'M', 'E', 'L', 'O', 'D', 'Y', ':', '*', '5', 'f', '0', '*', '5', '#', 'g', '2', '*', '5', 'g', '3', '*', '5', '#',
  2107.         'd', '0', '*', '5', '#', 'g', '2', '*', '5', 'g', '3', '*', '5', 'c', '0', '*', '5', '#', 'g', '2', '*', '5',
  2108.         'g', '3', '*', '4', '#', 'g', '0', 'n',
  2109.     'E', 'N', 'D', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2110. };
  2112. const U8 EMS_sample_picture_object_PDU_1[] = {EMS_USERDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2113.     0x07, 0xE0, 0x08, 0x10, 0x30, 0x0C, 0x20, 0x04, 0x4E, 0x72, 0x9A, 0x59, 0x86, 0x61, 0x80, 0x01,
  2114.     0x80, 0x01, 0x90, 0x09, 0x88, 0x11, 0x47, 0xE2, 0x23, 0xC4, 0x30, 0x0C, 0x08, 0x10, 0x07, 0xE0,
  2115. };
  2117. #if(!ENABLE_EMS_TEST_OBJECTS)
  2119. const U8 EMS_sample_picture_object_PDU_2[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2120.     0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xC0, 0x03, 0xA0, 0x05, 0x90, 0x09, 0x88, 0x11, 0x8C, 0x31,
  2121.     0x93, 0xC9, 0xA0, 0x05, 0xC0, 0x03, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  2122. };
  2124. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2126. const U8 EMS_sample_picture_object_PDU_2[] = {EMS_PREDEFINED_MELODY, 0x6a, 0x00,
  2127.     'B', 'E', 'G', 'I', 'N', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2128.     'V', 'E', 'R', 'S', 'I', 'O', 'N', ':', '1', '.', '2', 'n',
  2129.     'F', 'O', 'R', 'M', 'A', 'T', ':', 'C', 'L', 'A', 'S', 'S', '1', '.', '0', 'n',
  2130.     'M', 'E', 'L', 'O', 'D', 'Y', ':', '*', '4', '#', 'f', '2', '*', '4', 'a', '3', '.', '*', '4', '#', 'f', '3', '*',
  2131.         '4', '#', 'f', '4', '*', '4', '#', 'a', '3', '*', '4', '#', 'f', '3', '*', '4', 'e', '3', '*', '4', '#', 'f',
  2132.         '2', '*', '5', 'c', '3', 'n',
  2133.     'E', 'N', 'D', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2134. };
  2136. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2138. #if(!ENABLE_EMS_TEST_OBJECTS)
  2140. const U8 EMS_sample_picture_object_PDU_3[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2141.     0x01, 0x80, 0x03, 0xC0, 0x03, 0xC0, 0x07, 0xE0, 0x0F, 0xF0, 0x1F, 0xF8, 0x3F, 0xFC, 0x3F, 0xFC,
  2142.     0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x3D, 0xBC, 0x19, 0x98, 0x01, 0x80, 0x01, 0x80, 0x07, 0xE0,
  2143. };
  2145. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2147. const U8 EMS_sample_picture_object_PDU_3[] = {EMS_PREDEFINED_ANIMATION, 0x01,
  2148. };
  2150. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2152. #if(!ENABLE_EMS_TEST_OBJECTS)
  2154. const U8 EMS_sample_picture_object_PDU_4[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2155.     0x07, 0xE0, 0x08, 0x10, 0x30, 0x0C, 0x20, 0x04, 0x5C, 0x3A, 0x86, 0x61, 0x86, 0x61, 0x80, 0x01,
  2156.     0x80, 0x01, 0x81, 0xC1, 0x82, 0x21, 0x44, 0x12, 0x20, 0x04, 0x30, 0x0C, 0x08, 0x10, 0x07, 0xE0,
  2157. };
  2159. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2161. const U8 EMS_sample_picture_object_PDU_4[] = {EMS_PREDEFINED_MELODY, 0x6c, 0x00,
  2162.     'B', 'E', 'G', 'I', 'N', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2163.     'V', 'E', 'R', 'S', 'I', 'O', 'N', ':', '1', '.', '2', 'n',
  2164.     'F', 'O', 'R', 'M', 'A', 'T', ':', 'C', 'L', 'A', 'S', 'S', '1', '.', '0', 'n',
  2165.     'M', 'E', 'L', 'O', 'D', 'Y', ':', '*', '5', 'f', '0', '*', '5', '#', 'g', '2', '*', '5', 'g', '3', '*', '5', '#',
  2166.         'd', '0', '*', '5', '#', 'g', '2', '*', '5', 'g', '3', '*', '5', 'c', '0', '*', '5', '#', 'g', '2', '*', '5',
  2167.         'g', '3', '*', '4', '#', 'g', '0', 'n',
  2168.     'E', 'N', 'D', ':', 'I', 'M', 'E', 'L', 'O', 'D', 'Y', 'n',
  2169. };
  2171. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2173. const U8 EMS_sample_picture_object_PDU_5[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x18, 0x00, 0x18, 0x00, 0x48, 0x00,
  2174.     0x05, 0x80, 0x00, 0x10, 0x60, 0x00, 0x42, 0x1D, 0xC0, 0x80, 0x06, 0x30, 0x00, 0x29, 0x8C, 0x98,
  2175.     0x02, 0xA2, 0x9E, 0x00, 0xB5, 0x9F, 0x82, 0x77, 0x1F, 0xE1, 0x5B, 0x9F, 0xF9, 0x75, 0x9F, 0xF9,
  2176.     0x5B, 0x1F, 0xF9, 0x75, 0x9F, 0xF9, 0x5B, 0x9F, 0xF9, 0x77, 0x1F, 0xF9, 0x5B, 0xC7, 0xF9, 0x75,
  2177.     0xA1, 0xF9, 0xBA, 0x38, 0x78, 0xDC, 0x0E, 0x1A, 0xB8, 0x03, 0x81, 0x70, 0x00, 0xF1, 0x50, 0x00,
  2178.     0x3D, 0x70, 0x00, 0x0E, 0xE0, 0x00, 0x03, 0x80,
  2179. };
  2181. #if(!ENABLE_EMS_TEST_OBJECTS)
  2183. const U8 EMS_sample_picture_object_PDU_6[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2184.     0x07, 0xE0, 0x08, 0x10, 0x30, 0x0C, 0x26, 0x64, 0x48, 0x12, 0x90, 0x09, 0x86, 0x61, 0x86, 0x61,
  2185.     0x80, 0x01, 0x83, 0xC1, 0x87, 0xE1, 0x47, 0xE2, 0x23, 0xC4, 0x30, 0x0C, 0x08, 0x10, 0x07, 0xE0,
  2186. };
  2188. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2190. const U8 EMS_sample_picture_object_PDU_6[] = {EMS_PREDEFINED_SOUND, 0x01,
  2191. };
  2193. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2195. #if(!ENABLE_EMS_TEST_OBJECTS)
  2197. const U8 EMS_sample_picture_object_PDU_7[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2198.     0x07, 0xE0, 0x08, 0x10, 0x30, 0x0C, 0x2C, 0x64, 0x52, 0x92, 0x96, 0xB1, 0x8C, 0x61, 0x80, 0x01,
  2199.     0xBF, 0xFD, 0xA9, 0x25, 0x99, 0x29, 0x59, 0x2A, 0x29, 0x34, 0x37, 0xEC, 0x08, 0x10, 0x07, 0xE0,
  2200. };
  2202. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2204. const U8 EMS_sample_picture_object_PDU_7[] = {EMS_PREDEFINED_ANIMATION, 0x02,
  2205. };
  2207. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2209. #if(!ENABLE_EMS_TEST_OBJECTS)
  2211. const U8 EMS_sample_picture_object_PDU_8[] = {0x01, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2212.     0x03, 0xC0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x03, 0xC0, 0x01, 0x80, 0x19, 0x98, 0x3D, 0xBC,
  2213.     0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x3D, 0xBC, 0x19, 0x98, 0x01, 0x80, 0x01, 0x80, 0x07, 0xE0,
  2214. };
  2216. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2218. const U8 EMS_sample_picture_object_PDU_8[] = {EMS_USERDEFINED_ANIMATION, 0x01, 0x08, 0x00, 0x08, 0x00, 0x20, 0x00,
  2219.     0xFF, 0x81, 0x81, 0x81, 0xF1, 0xD1, 0xF1, 0xFF,
  2221.     0xFF, 0x81, 0x81, 0x81, 0x8F, 0x8B, 0x8F, 0xFF,
  2223.     0xFF, 0x8F, 0x8B, 0x8F, 0x81, 0x81, 0x81, 0xFF,
  2225.     0xFF, 0xF1, 0xD1, 0xF1, 0x81, 0x81, 0x81, 0xFF,
  2226. };
  2228. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2230. #if(!ENABLE_EMS_TEST_OBJECTS)
  2232. const U8 EMS_sample_picture_object_PDU_9[] = {0x01, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2233.     0x07, 0xE0, 0x08, 0x10, 0x30, 0x0C, 0x20, 0x04, 0x79, 0xCE, 0xBF, 0xF9, 0xB9, 0xC1, 0x80, 0x01,
  2234.     0x80, 0x01, 0x9F, 0x01, 0x9F, 0x81, 0x4F, 0xC2, 0x27, 0xC4, 0x30, 0x0C, 0x08, 0x10, 0x07, 0xE0,
  2235. };
  2237. #else /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2239. const U8 EMS_sample_picture_object_PDU_9[] = {EMS_USERDEFINED_ANIMATION, 0x01, 0x10, 0x00, 0x10, 0x00, 0x80, 0x00,
  2240.     0x0F, 0xF8, 0x0F, 0xF8, 0x04, 0x10, 0x04, 0x10, 0x04, 0x10, 0x04, 0x10, 0x02, 0x20, 0x01, 0x40,
  2241.     0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x04, 0x10, 0x04, 0x10, 0x04, 0x10, 0x0F, 0xF8, 0x0F, 0xF8,
  2243.     0x06, 0x00, 0x0E, 0x00, 0x1F, 0x00, 0x38, 0x80, 0x70, 0x40, 0xE0, 0x40, 0x60, 0x40, 0x10, 0x40,
  2244.     0x0F, 0x3C, 0x00, 0x82, 0x00, 0x81, 0x00, 0x83, 0x00, 0x87, 0x00, 0x4E, 0x00, 0x3C, 0x00, 0x38,
  2246.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03, 0xFC, 0x3F, 0xC2, 0x43, 0xC1, 0x83, 0xC0, 0x03,
  2247.     0xC1, 0x83, 0xC2, 0x43, 0xFC, 0x3F, 0xC0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  2249.     0x00, 0x38, 0x00, 0x3C, 0x00, 0x4E, 0x00, 0x87, 0x00, 0x83, 0x00, 0x81, 0x00, 0x82, 0x0F, 0x3C,
  2250.     0x10, 0x40, 0x60, 0x40, 0xE0, 0x40, 0x70, 0x40, 0x38, 0x80, 0x1F, 0x00, 0x0E, 0x00, 0x06, 0x00,
  2251. };
  2253. #endif /* (!ENABLE_EMS_TEST_OBJECTS) */ 
  2255. const U8 EMS_sample_picture_object_PDU_10[] = {EMS_PREDEFINED_PICTURE, 0x01, 0x20, 0x00, 0x20, 0x00, 0x80, 0x00,
  2256.     0x00, 0xFE, 0x00, 0x00, 0x07, 0xFF, 0x80, 0x00, 0x3F, 0xFF, 0x70, 0x00, 0x7F, 0xFF, 0x8E, 0x00,
  2257.     0x47, 0xFF, 0xC1, 0xC0, 0x40, 0xFF, 0xE0, 0x38, 0x40, 0x1F, 0xF0, 0x06, 0x40, 0x03, 0xF8, 0x02,
  2258.     0x40, 0x00, 0x7C, 0x0E, 0x40, 0x00, 0x0E, 0x3E, 0x40, 0x00, 0x00, 0xFE, 0x20, 0x78, 0x03, 0xFC,
  2259.     0x22, 0x1D, 0x03, 0xFC, 0x27, 0x0F, 0x03, 0xFC, 0x2F, 0x87, 0x03, 0xFC, 0x23, 0xCF, 0x07, 0xF8,
  2260.     0x23, 0x03, 0x07, 0xF8, 0x13, 0x00, 0x07, 0xF8, 0x11, 0x00, 0x07, 0xF8, 0x11, 0x08, 0x8F, 0xF0,
  2261.     0x10, 0x88, 0x8F, 0xF0, 0x10, 0x59, 0x8F, 0xF0, 0x08, 0x3F, 0x8F, 0xE0, 0x08, 0x1F, 0x1F, 0xE0,
  2262.     0x08, 0x0C, 0x1F, 0xE0, 0x04, 0x02, 0x1F, 0xE0, 0x03, 0x00, 0x1F, 0xC0, 0x00, 0xC0, 0x1F, 0xC0,
  2263.     0x00, 0x30, 0x3F, 0xC0, 0x00, 0x0C, 0x3F, 0x00, 0x00, 0x03, 0x3C, 0x00, 0x00, 0x00, 0xF0, 0x00,
  2264. };
  2266. const U8 EMS_sample_picture_object_PDU_11[] = {0x01, 0x01, 0x10, 0x00, 0x10, 0x00, 0x20, 0x00,
  2267.     0x00, 0x00, 0x1F, 0xF8, 0x20, 0x06, 0x26, 0x66, 0x23, 0xC6, 0x21, 0x86, 0x23, 0xC6, 0x26, 0x66,
  2268.     0x20, 0x06, 0x20, 0x06, 0x2A, 0xAE, 0x20, 0x06, 0x35, 0x56, 0x2A, 0xAE, 0x3F, 0xFE, 0x1F, 0xFC,
  2269. };
  2271. const U8 EMS_sample_animation_object_PDU_11[] = {EMS_USERDEFINED_ANIMATION, 0x01, 0x08, 0x00, 0x08, 0x00, 0x20, 0x00,
  2272.     0xFF, 0x81, 0x81, 0x81, 0xF1, 0xD1, 0xF1, 0xFF,
  2274.     0xFF, 0x81, 0x81, 0x81, 0x8F, 0x8B, 0x8F, 0xFF,
  2276.     0xFF, 0x8F, 0x8B, 0x8F, 0x81, 0x81, 0x81, 0xFF,
  2278.     0xFF, 0xF1, 0xD1, 0xF1, 0x81, 0x81, 0x81, 0xFF,
  2279. };
  2281. #define MAX_EMS_PREDEFINED_PICTURES    10
  2283. #if(ENABLE_EMS_TEST_OBJECTS)
  2285. /* Temporary: Needs to populated with actual picture data   */
  2286. U8 *EMS_predefined_pictures[MAX_EMS_PREDEFINED_PICTURES] = { (U8 *) EMS_sample_picture_object_PDU_1,
  2287.     (U8 *) EMS_sample_picture_object_PDU_2,
  2288.     (U8 *) EMS_sample_picture_object_PDU_3,
  2289.     (U8 *) EMS_sample_picture_object_PDU_4,
  2290.     (U8 *) EMS_sample_picture_object_PDU_5,
  2291.     (U8 *) EMS_sample_picture_object_PDU_6,
  2292.     (U8 *) EMS_sample_picture_object_PDU_7,
  2293.     (U8 *) EMS_sample_picture_object_PDU_8,
  2294.     (U8 *) EMS_sample_picture_object_PDU_9,
  2295.     (U8 *) EMS_sample_picture_object_PDU_10,
  2296. };
  2298. #else /* (ENABLE_EMS_TEST_OBJECTS) */ 
  2300. /* This gets populated at run time with picture data     */
  2301. U8 *EMS_predefined_pictures[MAX_EMS_PREDEFINED_PICTURES] = { (U8 *) EMS_sample_picture_object_PDU_11,
  2302.     (U8 *) EMS_sample_picture_object_PDU_11,
  2303.     (U8 *) EMS_sample_picture_object_PDU_11,
  2304.     (U8 *) EMS_sample_picture_object_PDU_11,
  2305.     (U8 *) EMS_sample_picture_object_PDU_11,
  2306.     (U8 *) EMS_sample_picture_object_PDU_11,
  2307.     (U8 *) EMS_sample_picture_object_PDU_11,
  2308.     (U8 *) EMS_sample_picture_object_PDU_11,
  2309.     (U8 *) EMS_sample_picture_object_PDU_11,
  2310.     (U8 *) EMS_sample_picture_object_PDU_11,
  2311. };
  2313. #endif /* (ENABLE_EMS_TEST_OBJECTS) */ 
  2315. U16 EMS_predefined_images[MAX_EMS_PREDEFINED_PICTURES] = {IMG_EMS01_PIC,
  2316.     IMG_EMS02_PIC,
  2317.     IMG_EMS03_PIC,
  2318.     IMG_EMS04_PIC,
  2319.     IMG_EMS05_PIC,
  2320.     IMG_EMS06_PIC,
  2321.     IMG_EMS07_PIC,
  2322.     IMG_EMS08_PIC,
  2323.     IMG_EMS09_PIC,
  2324.     IMG_EMS010_PIC
  2325. };
  2327. #define MAX_EMS_PREDEFINED_ANIMATIONS  15
  2329. U16 EMS_predefined_animations[MAX_EMS_PREDEFINED_ANIMATIONS] = {EMS_BI_ANIMATION_0_ID,
  2330.     EMS_BI_ANIMATION_1_ID,
  2331.     EMS_BI_ANIMATION_2_ID,
  2332.     EMS_BI_ANIMATION_3_ID,
  2333.     EMS_BI_ANIMATION_4_ID,
  2334.     EMS_BI_ANIMATION_5_ID,
  2335.     EMS_BI_ANIMATION_6_ID,
  2336.     EMS_BI_ANIMATION_7_ID,
  2337.     EMS_BI_ANIMATION_8_ID,
  2338.     EMS_BI_ANIMATION_9_ID,
  2339.     EMS_BI_ANIMATION_10_ID,
  2340.     EMS_BI_ANIMATION_11_ID,
  2341.     EMS_BI_ANIMATION_12_ID,
  2342.     EMS_BI_ANIMATION_13_ID,
  2343.     EMS_BI_ANIMATION_14_ID,
  2344. };
  2346. #define MAX_EMS_PREDEFINED_SOUNDS      10
  2348. /* Temporary: Needs to be populated with the actual sound IDs  */
  2349. U16 EMS_predefined_sounds[MAX_EMS_PREDEFINED_SOUNDS] = 
  2350. {
  2351.     EMS_CHIMES_HIGH,
  2352.     EMS_CHIMES_LOW,
  2353.     EMS_DING,
  2354.     EMS_TADA,
  2355.     EMS_NOTIFY,
  2356.     EMS_DRUM,
  2357.     EMS_CLAPS,
  2358.     EMS_FANFAR,
  2359.     EMS_CHORE_HGH,
  2360.     EMS_CHORE_LOW,
  2361. };
  2363. #define MAX_EMS_PREDEFINED_MELODIES    10
  2365. /* Temporary: Needs to be populated with the actual melody data   */
  2366. U8 *EMS_predefined_melodies[MAX_EMS_PREDEFINED_MELODIES] = 
  2367. {
  2368.     (U8 *) EMS_sample_melody_object_PDU_1,
  2369.     (U8 *) EMS_sample_melody_object_PDU_2,
  2370.     (U8 *) EMS_sample_melody_object_PDU_1,
  2371.     (U8 *) EMS_sample_melody_object_PDU_2,
  2372.     (U8 *) EMS_sample_melody_object_PDU_1,
  2373.     (U8 *) EMS_sample_melody_object_PDU_2,
  2374.     (U8 *) EMS_sample_melody_object_PDU_1,
  2375.     (U8 *) EMS_sample_melody_object_PDU_2,
  2376.     (U8 *) EMS_sample_melody_object_PDU_1,
  2377.     (U8 *) EMS_sample_melody_object_PDU_2,
  2378. };
  2380. /* data used for EMS_USERDEFINED_PICTURE, EMS_USERDEFINED_ANIMATION, EMS_USER_DEFINED_MELODY
  2381.    index used for EMS_PREDEFINED_PICTURE, EMS_PREDEFINED_MELODY.
  2382.    If index==-1, data is used for EMS_PREDEFINED_PICTURE, EMS_PREDEFINED_MELODY. */
  2385. /*****************************************************************************
  2386.  * FUNCTION
  2387.  *  EMS_load_object
  2388.  * DESCRIPTION
  2389.  *  
  2390.  * PARAMETERS
  2391.  *  type        [IN]        
  2392.  *  data        [?]         
  2393.  *  index       [IN]        
  2394.  *  object      [?]         
  2395.  * RETURNS
  2396.  *  
  2397.  *****************************************************************************/
  2398. EMSTATUS EMS_load_object(U32 type, U8 *data, S32 index, EMSObjData *object)
  2399. {
  2400.     /*----------------------------------------------------------------*/
  2401.     /* Local Variables                                                */
  2402.     /*----------------------------------------------------------------*/
  2403.     U8 ID;
  2405.     /*----------------------------------------------------------------*/
  2406.     /* Code Body                                                      */
  2407.     /*----------------------------------------------------------------*/
  2408.     switch (type & 0xff)
  2409.     {
  2410.         case EMS_PREDEFINED_PICTURE:
  2411.         {
  2412.             if ((index >= MAX_EMS_PREDEFINED_PICTURES))
  2413.             {
  2414.                 return (EMS_INVALID_OBJECT);
  2415.             }
  2416.             if (index >= 0)
  2417.             {
  2418.                 data = EMS_predefined_pictures[index];
  2419.             }
  2420.             if (data == NULL)
  2421.             {
  2422.                 return (EMS_NULL_POINTER);
  2423.             }
  2424.             ID = data[0];
  2425.             if (ID == EMS_PREDEFINED_PICTURE)
  2426.             {
  2427.                 object->picture.bitsPerPixel = data[1];
  2428.                 object->picture.attribute = data[2];
  2429.                 object->picture.hDim = data[3] | (data[4] << 8);
  2430.                 object->picture.vDim = data[5] | (data[6] << 8);
  2431.                 object->picture.pdu_length = data[7] | (data[8] << 8);
  2432.                 data += 9;
  2433.                 object->picture.pdu = data;
  2434.             #ifdef __EMS_REL5__
  2435.                 if ((object->picture.hDim == 0) || (object->picture.vDim == 0)
  2436.                     || (object->picture.pdu_length == 0) || (object->picture.attribute == 1))
  2437.             #else /* __EMS_REL5__ */ 
  2438.                 if ((object->picture.hDim == 0) || (object->picture.vDim == 0)
  2439.                     || (object->picture.pdu_length == 0) || (object->picture.pdu_length > EMS_MAX_IMELODY_SIZE))
  2440.             #endif /* __EMS_REL5__ */ 
  2441.                     return (EMS_INVALID_OBJECT);
  2442.             }
  2443.             else
  2444.             {
  2445.                 return (EMS_INVALID_OBJECT);
  2446.             }
  2447.         }
  2448.             break;
  2450.         case EMS_USERDEFINED_PICTURE:
  2451.         {
  2452.             if (data == NULL)
  2453.             {
  2454.                 return (EMS_NULL_POINTER);
  2455.             }
  2456.             ID = data[0];
  2457.             if (ID == EMS_USERDEFINED_PICTURE)
  2458.             {
  2459.                 object->picture.bitsPerPixel = data[1];
  2460.                 object->picture.attribute = data[2];
  2461.                 object->picture.hDim = data[3] | (data[4] << 8);
  2462.                 object->picture.vDim = data[5] | (data[6] << 8);
  2463.                 object->picture.pdu_length = data[7] | (data[8] << 8);
  2464.                 data += 9;
  2465.                 object->picture.pdu = data;
  2466.             #ifdef __EMS_REL5__
  2467.                 if ((object->picture.hDim == 0) || (object->picture.vDim == 0)
  2468.                     || (object->picture.pdu_length == 0) || (object->picture.attribute == 1))
  2469.             #else /* __EMS_REL5__ */ 
  2470.                 if ((object->picture.hDim == 0) || (object->picture.vDim == 0)
  2471.                     || (object->picture.pdu_length == 0) || (object->picture.pdu_length > EMS_MAX_IMELODY_SIZE))
  2472.             #endif /* __EMS_REL5__ */ 
  2473.                     return (EMS_INVALID_OBJECT);
  2474.             }
  2475.             else
  2476.             {
  2477.                 return (EMS_INVALID_OBJECT);
  2478.             }
  2479.         }
  2480.             break;
  2482.         case EMS_USERDEFINED_ANIMATION:
  2483.         {
  2484.             if (data == NULL)
  2485.             {
  2486.                 return (EMS_NULL_POINTER);
  2487.             }
  2488.             ID = data[0];
  2489.             if (ID == EMS_USERDEFINED_ANIMATION)
  2490.             {
  2491.                 object->animation.bitsPerPixel = data[1];
  2492.                 object->animation.attribute = data[2];
  2493.                 object->animation.cFrame = data[3];
  2494.                 object->animation.cRepeat = data[4];
  2495.                 object->animation.Duration = data[5];
  2496.                 object->animation.hDim = data[6] | (data[7] << 8);
  2497.                 object->animation.vDim = data[8] | (data[9] << 8);
  2498.                 object->animation.pdu_length = data[10] | (data[11] << 8);
  2499.                 data += 12;
  2500.                 object->animation.pdu = data;
  2501.             #ifdef __EMS_REL5__
  2502.                 if ((object->animation.hDim == 0) || (object->animation.vDim == 0)
  2503.                     || (object->animation.pdu_length == 0)
  2504.                     || (object->animation.attribute == 1) || (object->animation.cFrame == 0))
  2505.             #else /* __EMS_REL5__ */ 
  2506.                 if ((object->animation.hDim == 0) || (object->animation.vDim == 0)
  2507.                     || (object->animation.pdu_length == 0) || (object->animation.pdu_length > EMS_MAX_IMELODY_SIZE))
  2508.             #endif /* __EMS_REL5__ */ 
  2509.                     return (EMS_INVALID_OBJECT);
  2510.             }
  2511.             else
  2512.             {
  2513.                 return (EMS_INVALID_OBJECT);
  2514.             }
  2515.         }
  2516.             break;
  2517.             /* MTK Joy added for customization, 1014 */
  2518.     #if defined(__MMI_IMELODY_SUPPORT__)
  2519.         case EMS_PREDEFINED_MELODY:
  2520.         {
  2521.             if ((index >= MAX_EMS_PREDEFINED_MELODIES))
  2522.             {
  2523.                 return (EMS_INVALID_OBJECT);
  2524.             }
  2525.             if (index >= 0)
  2526.             {
  2527.                 data = EMS_predefined_melodies[index];
  2528.             }
  2529.             if (data == NULL)
  2530.             {
  2531.                 return (EMS_NULL_POINTER);
  2532.             }
  2533.             ID = data[0];
  2534.             if (ID == EMS_PREDEFINED_MELODY)
  2535.             {
  2536.                 object->sound.attribute = data[1];
  2537.                 object->sound.pdu_length = data[2] | (data[3] << 8);
  2538.                 data += 4;
  2539.                 object->sound.pdu = data;
  2540.             #ifdef __EMS_REL5__
  2541.                 if ((object->sound.pdu_length == 0) || (object->sound.attribute == 1))
  2542.             #else 
  2543.                 if ((object->sound.pdu_length == 0) || (object->sound.pdu_length > EMS_MAX_IMELODY_SIZE))
  2544.             #endif 
  2545.                     return (EMS_INVALID_OBJECT);
  2546.             }
  2547.             else
  2548.             {
  2549.                 return (EMS_INVALID_OBJECT);
  2550.             }
  2551.         }
  2552.             break;
  2554.         case EMS_USERDEFINED_MELODY:
  2555.         {
  2556.             if (data == NULL)
  2557.             {
  2558.                 return (EMS_NULL_POINTER);
  2559.             }
  2560.             ID = data[0];
  2561.             if (ID == EMS_USERDEFINED_MELODY)
  2562.             {
  2563.                 object->sound.attribute = data[1];
  2564.                 object->sound.pdu_length = data[2] | (data[3] << 8);
  2565.                 data += 4;
  2566.                 object->sound.pdu = data;
  2567.             #ifdef __EMS_REL5__
  2568.                 if ((object->sound.pdu_length == 0) || (object->sound.attribute == 1))
  2569.             #else 
  2570.                 if ((object->sound.pdu_length == 0) || (object->sound.pdu_length > EMS_MAX_IMELODY_SIZE))
  2571.             #endif 
  2572.                     return (EMS_INVALID_OBJECT);
  2573.             }
  2574.             else
  2575.             {
  2576.                 return (EMS_INVALID_OBJECT);
  2577.             }
  2578.         }
  2579.             break;
  2580.     #endif /* defined(__MMI_IMELODY_SUPPORT__) */ 
  2581.             /* MTK end */
  2582.     }
  2583.     return (EMS_OK);
  2584. }
  2586. #if(ENABLE_EMS_TEST_DEMO || ENABLE_EMS_TEST_OBJECTS)    /* test_block  */
  2588. #define MAX_EMS_TEST_OBJECTS  10
  2590. U8 EMS_test_object_count = 0;
  2591. U8 *EMS_test_objects[MAX_EMS_TEST_OBJECTS] = { (U8 *) EMS_sample_picture_object_PDU_1,
  2592.     (U8 *) EMS_sample_picture_object_PDU_2,
  2593.     (U8 *) EMS_sample_picture_object_PDU_3,
  2594.     (U8 *) EMS_sample_picture_object_PDU_4,
  2595.     (U8 *) EMS_sample_picture_object_PDU_5,
  2596.     (U8 *) EMS_sample_picture_object_PDU_6,
  2597.     (U8 *) EMS_sample_picture_object_PDU_7,
  2598.     (U8 *) EMS_sample_picture_object_PDU_8,
  2599.     (U8 *) EMS_sample_picture_object_PDU_9,
  2600.     (U8 *) EMS_sample_picture_object_PDU_10,
  2601. };
  2603. #endif /* (ENABLE_EMS_TEST_DEMO || ENABLE_EMS_TEST_OBJECTS) */ 
  2605. #if(ENABLE_EMS_TEST_DEMO)       /* test_block  */
  2608. /*****************************************************************************
  2609.  * FUNCTION
  2610.  *  EMS_inputbox_insert_object
  2611.  * DESCRIPTION
  2612.  *  
  2613.  * PARAMETERS
  2614.  *  void
  2615.  * RETURNS
  2616.  *  void
  2617.  *****************************************************************************/
  2618. void EMS_inputbox_insert_object(void)
  2619. {
  2620.     /*----------------------------------------------------------------*/
  2621.     /* Local Variables                                                */
  2622.     /*----------------------------------------------------------------*/
  2623.     EMSObjData object;
  2624.     EMSTATUS ret;
  2625.     U8 *data;
  2626.     U8 ID;
  2628.     S32 index = EMS_test_object_count++;
  2630.     /*----------------------------------------------------------------*/
  2631.     /* Code Body                                                      */
  2632.     /*----------------------------------------------------------------*/
  2633.     if (EMS_test_object_count > 9)
  2634.     {
  2635.         EMS_test_object_count = 0;
  2636.     }
  2637.     data = EMS_test_objects[index];
  2638.     ID = data[0];
  2639.     switch (ID)
  2640.     {
  2641.         case EMS_PREDEFINED_PICTURE:
  2642.         case EMS_USERDEFINED_PICTURE:
  2643.             ret = EMS_load_object(EMS_PREDEFINED_PICTURE, data, index, &object);
  2644.             if (ret == EMS_OK)
  2645.             {
  2646.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PIC, &object, 0);
  2647.             }
  2648.             break;
  2650.         case EMS_USERDEFINED_ANIMATION:
  2651.             ret = EMS_load_object(EMS_USERDEFINED_ANIMATION, data, index, &object);
  2652.             if (ret == EMS_OK)
  2653.             {
  2654.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_USERDEF_ANM, &object, 0);
  2655.             }
  2656.             break;
  2658.         case EMS_PREDEFINED_ANIMATION:
  2659.             ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PREDEF_ANM, NULL, data[1]);
  2660.             break;
  2662.         case EMS_PREDEFINED_SOUND:
  2663.             ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PREDEF_SND, NULL, data[1]);
  2664.             break;
  2666.         case EMS_PREDEFINED_MELODY:
  2667.             ret = EMS_load_object(EMS_PREDEFINED_MELODY, data, index, &object);
  2668.             if (ret == EMS_OK)
  2669.             {
  2670.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_USERDEF_SND, &object, 0);
  2671.             }
  2672.             break;
  2673.     }
  2674.     /* show_EMS_inputbox(); */
  2675. }
  2677. #endif /* (ENABLE_EMS_TEST_DEMO) */ 
  2679. #if(ENABLE_EMS_TEST_OBJECTS)
  2682. /*****************************************************************************
  2683.  * FUNCTION
  2684.  *  EMS_inputbox_insert_predefined_picture
  2685.  * DESCRIPTION
  2686.  *  
  2687.  * PARAMETERS
  2688.  *  index       [IN]        
  2689.  * RETURNS
  2690.  *  
  2691.  *****************************************************************************/
  2692. EMSTATUS EMS_inputbox_insert_predefined_picture(S32 index)
  2693. {
  2694.     /*----------------------------------------------------------------*/
  2695.     /* Local Variables                                                */
  2696.     /*----------------------------------------------------------------*/
  2697.     EMSObjData object;
  2698.     EMSTATUS ret;
  2699.     U8 *data;
  2700.     U8 ID;
  2702.     /*----------------------------------------------------------------*/
  2703.     /* Code Body                                                      */
  2704.     /*----------------------------------------------------------------*/
  2705.     if (index < 0)
  2706.     {
  2707.         index = 0;
  2708.     }
  2709.     if (index > (MAX_EMS_TEST_OBJECTS - 1))
  2710.     {
  2711.         index = MAX_EMS_TEST_OBJECTS - 1;
  2712.     }
  2713.     data = EMS_test_objects[index];
  2714.     ID = data[0];
  2715.     switch (ID)
  2716.     {
  2717.         case EMS_PREDEFINED_PICTURE:
  2718.         case EMS_USERDEFINED_PICTURE:
  2719.             ret = EMS_load_object(EMS_PREDEFINED_PICTURE, data, index, &object);
  2720.             if (ret == EMS_OK)
  2721.             {
  2722.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PIC, &object, 0);
  2723.             }
  2724.             break;
  2726.         case EMS_USERDEFINED_ANIMATION:
  2727.             ret = EMS_load_object(EMS_USERDEFINED_ANIMATION, data, index, &object);
  2728.             if (ret == EMS_OK)
  2729.             {
  2730.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_USERDEF_ANM, &object, 0);
  2731.             }
  2732.             break;
  2734.         case EMS_PREDEFINED_ANIMATION:
  2735.             ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PREDEF_ANM, NULL, data[1]);
  2736.             break;
  2738.         case EMS_PREDEFINED_SOUND:
  2739.             ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PREDEF_SND, NULL, data[1]);
  2740.             break;
  2742.         case EMS_PREDEFINED_MELODY:
  2743.             ret = EMS_load_object(EMS_PREDEFINED_MELODY, data, index, &object);
  2744.             if (ret == EMS_OK)
  2745.             {
  2746.                 ret = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_USERDEF_SND, &object, 0);
  2747.             }
  2748.             break;
  2749.     }
  2750.     return (ret);
  2751. }
  2753. #else /* (ENABLE_EMS_TEST_OBJECTS) */ 
  2756. /*****************************************************************************
  2757.  * FUNCTION
  2758.  *  EMS_inputbox_insert_predefined_picture
  2759.  * DESCRIPTION
  2760.  *  
  2761.  * PARAMETERS
  2762.  *  index       [IN]        
  2763.  * RETURNS
  2764.  *  
  2765.  *****************************************************************************/
  2766. EMSTATUS EMS_inputbox_insert_predefined_picture(S32 index)
  2767. {
  2768.     /*----------------------------------------------------------------*/
  2769.     /* Local Variables                                                */
  2770.     /*----------------------------------------------------------------*/
  2771.     EMSObjData object;
  2772.     U8 *data = NULL;
  2773.     EMSTATUS r = EMS_load_object(EMS_PREDEFINED_PICTURE, data, index, &object);
  2775.     /*----------------------------------------------------------------*/
  2776.     /* Code Body                                                      */
  2777.     /*----------------------------------------------------------------*/
  2778.     if (r == EMS_OK)
  2779.     {
  2780.         r = gui_EMS_inputbox_add_object(&MMI_EMS_inputbox, EMS_TYPE_PIC, &object, 0);
  2781.     }
  2782.     return (r);
  2783. }
  2785. #endif /* (ENABLE_EMS_TEST_OBJECTS) */ 
  2788. /*****************************************************************************
  2789.  * FUNCTION
  2790.  *  EMS_get_object_size
  2791.  * DESCRIPTION
  2792.  *  
  2793.  * PARAMETERS
  2794.  *  type        [IN]        
  2795.  *  objdata     [?]         
  2796.  * RETURNS
  2797.  *  
  2798.  *****************************************************************************/
  2799. S32 EMS_get_object_size(U8 type, EMSObjData *objdata)
  2800. {
  2801.     /*----------------------------------------------------------------*/
  2802.     /* Local Variables                                                */
  2803.     /*----------------------------------------------------------------*/
  2805.     /*----------------------------------------------------------------*/
  2806.     /* Code Body                                                      */
  2807.     /*----------------------------------------------------------------*/
  2808.     return (EMSGetObjectSize(type, objdata));
  2809. }
  2812. /*****************************************************************************
  2813.  * FUNCTION
  2814.  *  EMS_check_object_size
  2815.  * DESCRIPTION
  2816.  *  
  2817.  * PARAMETERS
  2818.  *  type        [IN]        
  2819.  *  objdata     [?]         
  2820.  *  allowed     [?]         
  2821.  * RETURNS
  2822.  *  
  2823.  *****************************************************************************/
  2824. S32 EMS_check_object_size(U8 type, EMSObjData *objdata, U8 *allowed)
  2825. {
  2826.     /*----------------------------------------------------------------*/
  2827.     /* Local Variables                                                */
  2828.     /*----------------------------------------------------------------*/
  2829.     kal_bool flag;
  2830.     S32 size = EMSGetObjectSizeWithCheck(type, objdata, &flag);
  2832.     /*----------------------------------------------------------------*/
  2833.     /* Code Body                                                      */
  2834.     /*----------------------------------------------------------------*/
  2835.     if (flag == KAL_TRUE)
  2836.     {
  2837.         *allowed = 1;
  2838.     }
  2839.     else
  2840.     {
  2841.         *allowed = 0;
  2842.     }
  2843.     return (size);
  2844. }
  2847. /*****************************************************************************
  2848.  * FUNCTION
  2849.  *  EMS_load_predefined_picture
  2850.  * DESCRIPTION
  2851.  *  
  2852.  * PARAMETERS
  2853.  *  index       [IN]        
  2854.  *  data        [?]         
  2855.  * RETURNS
  2856.  *  void
  2857.  *****************************************************************************/
  2858. void EMS_load_predefined_picture(S32 index, U8 *data)
  2859. {
  2860.     /*----------------------------------------------------------------*/
  2861.     /* Local Variables                                                */
  2862.     /*----------------------------------------------------------------*/
  2864.     /*----------------------------------------------------------------*/
  2865.     /* Code Body                                                      */
  2866.     /*----------------------------------------------------------------*/
  2867.     if ((index >= 0) && (index < MAX_EMS_PREDEFINED_PICTURES))
  2868.     {
  2869.         EMS_predefined_pictures[index] = data;
  2870.     }
  2871. }
  2874. /*****************************************************************************
  2875.  * FUNCTION
  2876.  *  EMS_get_predefined_picture_size
  2877.  * DESCRIPTION
  2878.  *  
  2879.  * PARAMETERS
  2880.  *  index       [IN]        
  2881.  * RETURNS
  2882.  *  
  2883.  *****************************************************************************/
  2884. S32 EMS_get_predefined_picture_size(S32 index)
  2885. {
  2886.     /*----------------------------------------------------------------*/
  2887.     /* Local Variables                                                */
  2888.     /*----------------------------------------------------------------*/
  2889.     EMSObjData object;
  2890.     U8 *data = NULL;
  2891.     EMSTATUS r = EMS_load_object(EMS_PREDEFINED_PICTURE, data, index, &object);
  2893.     /*----------------------------------------------------------------*/