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

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

MTK

开发平台：

C/C++

gui_ems.c：源码内容
  1.         case EMS_TYPE_PIC:
  2.             gui_EMS_input_box_display_object_pic(
  3.                         x,y,
  4.                         (U8*)o->data->picture.pdu,
  5.                         o->data->picture.pdu_length,
  6.                         o->data->picture.hDim,o->data->picture.vDim,
  7.                         o->data->picture.bitsPerPixel);
  8.             break;
  10.         case EMS_TYPE_USERDEF_ANM:
  11.             if (display_cursor)
  12.             {
  13.                 EMS_object_x = x;
  14.                 EMS_object_y = y;
  15.                 EMS_object_frame_counter = 0;
  16.                 EMS_object_repeat_counter = 0;
  17.                 EMS_current_object = o;
  18.             }
  19.             
  20.             EMS_object_current_frame_size = o->data->animation.pdu_length;
  21.             if (o->data->animation.cFrame != 0)
  22.                 EMS_object_current_frame_size /= o->data->animation.cFrame;
  24.             gui_EMS_input_box_display_object_pic(
  25.                     x,y,
  26.                     (U8*) o->data->animation.pdu,
  27.                     EMS_object_current_frame_size,
  28.                     o->data->animation.hDim,o->data->animation.vDim,
  29.                     o->data->animation.bitsPerPixel);
  30.             
  31.             if (display_cursor && playback_flag)
  32.             {
  33.                 EMS_object_animation_timer_flag = 1;
  34.                 gui_start_timer((o->data->animation.Duration + 1) * 100, EMS_input_box_show_animation_frame);
  35.             }
  36.             break;
  37.         case EMS_TYPE_PREDEF_ANM:
  38.         {
  39.             PU8 image = get_image(EMS_predefined_animations[o->PredefNo]);
  41.             gui_show_animated_image_frame(x, y, image, 0);
  42.             if (display_cursor && playback_flag)
  43.             {
  44.                 EMS_object_x = x;
  45.                 EMS_object_y = y;
  46.                 gui_measure_image(image, &EMS_object_width, &EMS_object_height);
  47.                 EMS_object_n_frames = gui_image_n_frames(image);
  48.                 EMS_object_frame_counter = 0;
  49.                 EMS_current_object = o;
  50.                 EMS_current_predefined_image = image;
  51.                 EMS_object_predefined_animation_timer_flag = 1;
  52.                 gui_start_timer(EMS_ANIMATION_TIME, EMS_input_box_show_predefined_animation_frame);
  53.             }
  54.         }
  55.             break;
  56.         case EMS_TYPE_PREDEF_SND:
  57.         {
  58.             gui_show_transparent_image(x, y, EMS_editor_sound_icon, 0);
  59.             if (display_cursor && playback_flag)
  60.             {
  61.                 EMS_object_pre_defined_sound_flag = 1;
  62.                 EMS_play_pre_defined_sound(o->PredefNo);
  63.             }
  64.         }
  65.             break;
  66.         case EMS_TYPE_USERDEF_SND:
  67.         {
  68.             gui_show_transparent_image(x, y, EMS_editor_melody_icon, 0);
  69.             if (display_cursor && playback_flag)
  70.             {
  71.                 EMS_object_user_defined_melody_flag = 1;
  72.                 /* MTK Joy added for customization, 1014 */
  73.             #if defined(__MMI_IMELODY_SUPPORT__)
  74.                 EMS_play_user_defined_melody(o->data->sound.pdu, o->data->sound.pdu_length);
  75.             #endif 
  76.                 /* MTK end */
  77.             }
  78.         }
  79.             break;
  80.     }
  81. }
  84. /*****************************************************************************
  85.  * FUNCTION
  86.  *  gui_EMS_playback_object
  87.  * DESCRIPTION
  88.  *  
  89.  * PARAMETERS
  90.  *  o       [?]     
  91.  * RETURNS
  92.  *  void
  93.  *****************************************************************************/
  94. void gui_EMS_playback_object(EMSObject *o)
  95. {
  96.     /*----------------------------------------------------------------*/
  97.     /* Local Variables                                                */
  98.     /*----------------------------------------------------------------*/
  100.     /*----------------------------------------------------------------*/
  101.     /* Code Body                                                      */
  102.     /*----------------------------------------------------------------*/
  103.     switch (o->Type)
  104.     {
  105.         case EMS_TYPE_PREDEF_SND:
  106.         {
  107.             EMS_object_pre_defined_sound_flag = 1;
  108.             EMS_play_pre_defined_sound(o->PredefNo);
  109.         }
  110.             break;
  111.             /* MTK Joy added for customization, 1014 */
  112.     #if defined(__MMI_IMELODY_SUPPORT__)
  113.         case EMS_TYPE_USERDEF_SND:
  114.         {
  115.             EMS_object_user_defined_melody_flag = 1;
  116.             EMS_play_user_defined_melody(o->data->sound.pdu, o->data->sound.pdu_length);
  117.         }
  118.             break;
  119.     #endif /* defined(__MMI_IMELODY_SUPPORT__) */ 
  120.             /* MTK end */
  121.     }
  122. }
  125. /*****************************************************************************
  126.  * FUNCTION
  127.  *  EMS_cancel_object_focus
  128.  * DESCRIPTION
  129.  *  
  130.  * PARAMETERS
  131.  *  void
  132.  * RETURNS
  133.  *  void
  134.  *****************************************************************************/
  135. void EMS_cancel_object_focus(void)
  136. {
  137.     /*----------------------------------------------------------------*/
  138.     /* Local Variables                                                */
  139.     /*----------------------------------------------------------------*/
  141.     /*----------------------------------------------------------------*/
  142.     /* Code Body                                                      */
  143.     /*----------------------------------------------------------------*/
  144.     if (EMS_object_animation_timer_flag)
  145.     {
  146.         gui_cancel_timer(EMS_input_box_show_animation_frame);
  147.         EMS_object_animation_timer_flag = 0;
  148.     }
  149.     else if (EMS_object_predefined_animation_timer_flag)
  150.     {
  151.         gui_cancel_timer(EMS_input_box_show_predefined_animation_frame);
  152.         EMS_object_predefined_animation_timer_flag = 0;
  153.     }
  154.     else if (EMS_object_pre_defined_sound_flag)
  155.     {
  156.         EMS_stop_pre_defined_sound();
  157.         EMS_object_pre_defined_sound_flag = 0;
  158.     }
  159.     else if (EMS_object_user_defined_melody_flag)
  160.     {
  161.         EMS_stop_user_defined_melody();
  162.         EMS_object_user_defined_melody_flag = 0;
  163.     }
  164. }
  167. /*****************************************************************************
  168.  * FUNCTION
  169.  *  gui_EMS_input_box_set_text_format
  170.  * DESCRIPTION
  171.  *  
  172.  * PARAMETERS
  173.  *  b       [?]     
  174.  *  o       [?]     
  175.  * RETURNS
  176.  *  void
  177.  *****************************************************************************/
  178. void gui_EMS_input_box_set_text_format(UI_EMS_input_box *b, EMSObject *o)
  179. {
  180.     /*----------------------------------------------------------------*/
  181.     /* Local Variables                                                */
  182.     /*----------------------------------------------------------------*/
  183.     U8 font_size = (U8) MEDIUM_FONT;
  184.     U8 font_bold = 0;
  185.     U8 font_italic = 0;
  186.     U8 font_underline = 0;
  188.     /*----------------------------------------------------------------*/
  189.     /* Code Body                                                      */
  190.     /*----------------------------------------------------------------*/
  191.     /* color        c={0,0,0,100}; */
  193.     /* UI_EMS_inputbox_text_color=c; */
  194.     if (o == NULL)
  195.     {
  196.         EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  197.         EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  198.         b->flags &=
  199.             ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT | UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT |
  200.               UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  201.     }
  202.     else
  203.     {
  204.         if (o->Type == EMS_TYPE_TEXT_FORMAT)
  205.         {
  206.             EMSTextFormat *t = &(o->data->text_format);
  208.             b->flags &=
  209.                 ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT | UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT |
  210.                   UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  211.             switch (t->Alignment)
  212.             {
  213.                 case EMS_ALIGN_LEFT:
  214.                     b->flags |= UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT;
  215.                     break;
  216.                 case EMS_ALIGN_RIGHT:
  217.                     b->flags |= UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT;
  218.                     break;
  219.                 case EMS_ALIGN_CENTER:
  220.                     b->flags |= UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER;
  221.                     break;
  222.                 case EMS_ALIGN_LANG_DEP:
  223.                     b->flags |= UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT;
  224.                     break;
  225.             }
  226.             switch (t->FontSize)
  227.             {
  228.                 case EMS_FONTSIZE_NORMAL:
  229.                     font_size = (U8) UI_EMS_inputbox_medium_font.size;
  230.                     /* c.r=0;c.g=0;c.b=0; */
  231.                     break;
  232.                 case EMS_FONTSIZE_LARGE:
  233.                     font_size = (U8) UI_EMS_inputbox_large_font.size;
  234.                     /* c.r=255;c.g=0;c.b=0; */
  235.                     break;
  236.                 case EMS_FONTSIZE_SMALL:
  237.                     font_size = (U8) UI_EMS_inputbox_small_font.size;
  238.                     /* c.r=0;c.g=0;c.b=255; */
  239.                     break;
  240.             }
  241.         #ifndef __MMI_TEXT_FORMAT_WITHOUT_BOLD__
  242.             if (t->isBold)
  243.             {
  244.                 font_bold = 1;
  245.             }
  246.         #endif /* __MMI_TEXT_FORMAT_WITHOUT_BOLD__ */ 
  247.             if (t->isItalic)
  248.             {
  249.                 font_italic = 1;
  250.             }
  251.             if (t->isUnderline)
  252.             {
  253.                 font_underline = 1;
  254.             }
  255.             UI_EMS_inputbox_current_font.bold = font_bold;
  256.             UI_EMS_inputbox_current_font.italic = font_italic;
  257.             UI_EMS_inputbox_current_font.underline = font_underline;
  258.             UI_EMS_inputbox_current_font.size = font_size;
  259.             EMS_SET_FONT(&UI_EMS_inputbox_current_font);
  260.             /* UI_EMS_inputbox_text_color=c; */
  261.             EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  262.         }
  263.     }
  264. }
  265. #endif /* __MMI_MESSAGES_EMS__ */ 
  266. #define UI_EMS_INPUTBOX_N_BREAK_CHARACTERS   2
  268. UI_character_type EMS_input_box_break_characters[] = { ' ',
  269.     /*
  270.      * '.',
  271.      * ',',
  272.      * '\',
  273.      * '/',
  274.      * '-',
  275.      * ':',
  276.      * ';',
  277.      * '?',
  278.      * '!',
  279.      * '|',
  280.      * '+',
  281.      * '=',
  282.      * '_',
  283.      */
  284.     'n'
  285. };
  287. UI_character_type EMS_input_box_new_line_character = (UI_character_type) 'n';
  290. /*****************************************************************************
  291.  * FUNCTION
  292.  *  gui_EMS_breakable_character
  293.  * DESCRIPTION
  294.  *  
  295.  * PARAMETERS
  296.  *  c       [IN]        
  297.  * RETURNS
  298.  *  
  299.  *****************************************************************************/
  300. U8 gui_EMS_breakable_character(UI_character_type c)
  301. {
  302.     /*----------------------------------------------------------------*/
  303.     /* Local Variables                                                */
  304.     /*----------------------------------------------------------------*/
  305.     S32 i;
  307.     /*----------------------------------------------------------------*/
  308.     /* Code Body                                                      */
  309.     /*----------------------------------------------------------------*/
  310.     for (i = 0; i < UI_EMS_INPUTBOX_N_BREAK_CHARACTERS; i++)
  311.     {
  312.         if ((UI_character_type) c == EMS_input_box_break_characters[i])
  313.         {
  314.             return (1);
  315.         }
  316.     }
  317.     return (0);
  318. }
  320. #define UI_EMS_INPUT_BOX_BREAK_CHARACTER(c,flag)                                                      
  321.       {  S32 _ii_;                                                                                    
  322.          flag=0;                                                                                      
  323.          for(_ii_=0;_ii_<UI_EMS_INPUTBOX_N_BREAK_CHARACTERS;_ii_++)                                   
  324.          {  if((UI_character_type)c==(UI_character_type)EMS_input_box_break_characters[_ii_])         
  325.             {  flag=1;                                                                                
  326.                break;                                                                                 
  327.             }                                                                                         
  328.          }                                                                                            
  329.       }
  332. /*****************************************************************************
  333.  * FUNCTION
  334.  *  gui_EMS_new_line_character
  335.  * DESCRIPTION
  336.  *  
  337.  * PARAMETERS
  338.  *  c       [IN]        
  339.  * RETURNS
  340.  *  
  341.  *****************************************************************************/
  342. U8 gui_EMS_new_line_character(UI_character_type c)
  343. {
  344.     /*----------------------------------------------------------------*/
  345.     /* Local Variables                                                */
  346.     /*----------------------------------------------------------------*/
  348.     /*----------------------------------------------------------------*/
  349.     /* Code Body                                                      */
  350.     /*----------------------------------------------------------------*/
  351.     if ((UI_character_type) c == EMS_input_box_new_line_character)
  352.     {
  353.         return (1);
  354.     }
  355.     else
  356.     {
  357.         return (0);
  358.     }
  359. }
  361. #if(EMS_USE_CRLF_COMBINATION)
  364. /*****************************************************************************
  365.  * FUNCTION
  366.  *  gui_EMS_input_box_insert_new_line
  367.  * DESCRIPTION
  368.  *  
  369.  * PARAMETERS
  370.  *  b       [?]     
  371.  * RETURNS
  372.  *  
  373.  *****************************************************************************/
  374. U8 gui_EMS_input_box_insert_new_line(UI_EMS_input_box *b)
  375. {
  376.     /*----------------------------------------------------------------*/
  377.     /* Local Variables                                                */
  378.     /*----------------------------------------------------------------*/
  380.     U8 ret = EMS_OK;
  382. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  383.     U8 s[4] = {0x00, 0x0D, 0x00, 0x0A};
  384. #else 
  385.     U8 s[4] = {0x0D, 0x00, 0x0A, 0x00};
  386. #endif 
  387.     S32 remaining_length;
  389.     /*----------------------------------------------------------------*/
  390.     /* Code Body                                                      */
  391.     /*----------------------------------------------------------------*/
  392. #ifdef __MMI_MESSAGES_EMS__
  393.     EMS_cancel_object_focus();
  394. #endif 
  395.     if (b->UCS2_count > 0)
  396.     {
  397.         remaining_length = (EMS_get_remaining_length(b->data) >> 1);
  398.     }
  399.     else
  400.     {
  401.         remaining_length = EMS_get_remaining_length(b->data);
  402.     }
  403.     if (remaining_length < 2)
  404.     {
  405.         UI_editor_play_tone_cannot_insert();
  406.         ret = EMS_NO_SPACE;
  407.         return ret;
  408.     }
  409.     /* Overwrite mode is un-implemented */
  410.     if (AddString(b->data, s, 2, NULL) == EMS_NO_SPACE)
  411.     {
  412.         UI_editor_play_tone_cannot_insert();
  413.         b->overflow_callback();
  414.         ret = EMS_NO_SPACE;
  415.     }
  416.     else
  417.     {
  418.         b->change_callback();
  419.     }
  420. b->text_format.Alignment = EMS_ALIGN_LANG_DEP; // reset alignment when input 'enter' symbol
  421.     gui_EMS_input_box_locate_cursor(b);
  422.     return ret;
  423. }
  425. #else /* (EMS_USE_CRLF_COMBINATION) */ 
  428. /*****************************************************************************
  429.  * FUNCTION
  430.  *  gui_EMS_input_box_insert_new_line
  431.  * DESCRIPTION
  432.  *  
  433.  * PARAMETERS
  434.  *  b       [?]     
  435.  * RETURNS
  436.  *  
  437.  *****************************************************************************/
  438. U8 gui_EMS_input_box_insert_new_line(UI_EMS_input_box *b)
  439. {
  440.     /*----------------------------------------------------------------*/
  441.     /* Local Variables                                                */
  442.     /*----------------------------------------------------------------*/
  444.     /*----------------------------------------------------------------*/
  445.     /* Code Body                                                      */
  446.     /*----------------------------------------------------------------*/
  447.     gui_EMS_input_box_insert_character(b, EMS_input_box_new_line_character);
  448.     return EMS_OK;
  449. }
  451. #endif /* (EMS_USE_CRLF_COMBINATION) */ 
  453. #if(0)
  455. UI_character_type TEMP_EMS_GET_OBJECT(EMSObject *o)
  456. { if((o!=NULL) && (o->Type==EMS_TYPE_PIC) && (o->data->picture.pdu!=NULL))
  457. { return((UI_character_type)((UI_character_type)'0'+(UI_character_type)(o->data->picture.pdu[0])));
  458. }
  459. else return((UI_character_type)' ');
  460. }
  462. void temp_print_object(EMSObject *o)
  463. {
  464. if(o==NULL) PRINT_INFORMATION(("-"));
  465. else if(o->Type==0) PRINT_INFORMATION(("*"));
  466. else if(o->Type==5) PRINT_INFORMATION(("%d",o->data->picture.pdu[0]));
  467. }
  469. void temp_print_next_object(EMSObject *o)
  470. {
  471. if(o==NULL) PRINT_INFORMATION(("-"));
  472. else if(o->next==NULL) PRINT_INFORMATION(("-"));
  473. else if(o->next->Type==0) PRINT_INFORMATION(("*"));
  474. else if(o->next->Type==5) PRINT_INFORMATION(("%d",o->next->data->picture.pdu[0]));
  475. }
  477. #endif /* (0) */ 
  479. #define EMS_SET_BREAK_POSITION()                                     
  480. {  break_line_width=line_width;                                      
  481.    break_line_height=line_height;                                    
  482.    break_line_object_count=line_object_count;                        
  483.    break_line_alignment=line_alignment;                              
  484.    break_line_text_object_count=line_text_object_count;              
  485. }
  487. #define EMS_SET_NEXT_BREAK_POSITION()                                
  488. {  break_line_width=line_width;                                      
  489.    break_line_height=line_height;                                    
  490.    break_line_object_count=line_object_count+1;                      
  491.    break_line_alignment=line_alignment;                              
  492.    break_line_text_object_count=line_text_object_count;              
  493. }
  496. /*****************************************************************************
  497.  * FUNCTION
  498.  *  EMS_handle_CRLF_navigation
  499.  * DESCRIPTION
  500.  *  
  501.  * PARAMETERS
  502.  *  data        [?]     
  503.  * RETURNS
  504.  *  void
  505.  *****************************************************************************/
  506. void EMS_handle_CRLF_navigation(EMSData *data)
  507. {
  508.     /*----------------------------------------------------------------*/
  509.     /* Local Variables                                                */
  510.     /*----------------------------------------------------------------*/
  511.     U8 r;
  512.     EMSPosition p;
  513.     UI_character_type c;
  514.     EMSObject *o;
  516.     /*----------------------------------------------------------------*/
  517.     /* Code Body                                                      */
  518.     /*----------------------------------------------------------------*/
  519. #if(EMS_USE_CRLF_COMBINATION)
  520.     p = data->CurrentPosition;
  521.     r = gui_EMS_input_box_get_next_object(data, &p, &c, &o);
  522.     if ((r == 1) && UI_TEST_LF_CHARACTER(c))
  523.     {
  524.         p = data->CurrentPosition;
  525.         r = gui_EMS_input_box_get_previous_object(data, &p, &c, &o);
  526.         if ((r == 1) && UI_TEST_CR_CHARACTER(c))
  527.         {
  528.             BackwardCurrentPosition(data, 1);
  529.             return;
  530.         }
  531.     }
  532. #endif /* (EMS_USE_CRLF_COMBINATION) */ 
  533. #if(EMS_USE_ESC_COMBINATION)
  534.     if (data->dcs == SMSAL_DEFAULT_DCS)
  535.     {
  536.         p = data->CurrentPosition;
  537.         r = gui_EMS_input_box_get_previous_object(data, &p, &c, &o);
  538.         if ((r == 1) && UI_TEST_ESC_CHARACTER(c))
  539.         {
  540.             BackwardCurrentPosition(data, 1);
  541.         }
  542.     }
  543. #endif /* (EMS_USE_ESC_COMBINATION) */ 
  544. }
  546. #define EMS_EDITOR_DRAW_DOTTED_LINE(x1,x2,y,c)                       
  547. {  S32 i,xx1=(x1),xx2=(x2),yy=(y);                                   
  548.    for(i=xx1;i<=xx2;i++)                                             
  549.    {  if(i&1) gui_putpixel(i,yy,c);                                  
  550.    }                                                                 
  551. }
  553. #define EMS_EDITOR_DRAW_LINE(x1,x2,y,c)                              
  554. {  S32 i,xx1=(x1),xx2=(x2),yy=(y);                                   
  555.    for(i=xx1;i<=xx2;i++)                                             
  556.    {  gui_putpixel(i,yy,c);                                          
  557.    }                                                                 
  558. }
  560. U8 EMS_object_width_cache[128];
  561. U8 EMS_object_height_cache[128];
  562. U16 EMS_object_str_cache[128];
  565. /* Gurinder - 03/15/2004 - EMS Input Box InfoBar BG Image */
  566. extern S32 wgui_EMS_inputbox_information_bar_height;
  568. #define MAX_EMS_DISP_CLUSTER_LEN 50
  569. /* START TARUN PMT 20050128 */
  570. #ifdef __MMI_HINDI_ALG__
  571. extern BOOL cancelWidth;
  572. #endif 
  573. //END TARUN PMT 20050128
  574. //W05.52 Fix Cursor Moviong issue for ESC character
  577. /*****************************************************************************
  578.  * FUNCTION
  579.  *  gui_EMS_input_box_back_cursor_for_ESC_character
  580.  * DESCRIPTION
  581.  *  
  582.  * PARAMETERS
  583.  *  data            [?]     
  584.  *  position        [?]     
  585.  * RETURNS
  586.  *  void
  587.  *****************************************************************************/
  588. void gui_EMS_input_box_back_cursor_for_ESC_character(EMSData *data, EMSPosition *position)
  589. {
  590.     /*----------------------------------------------------------------*/
  591.     /* Local Variables                                                */
  592.     /*----------------------------------------------------------------*/
  593.     EMSObject *current_object;
  594.     UI_character_type current_character;
  595.     U8 object_type;
  597.     /*----------------------------------------------------------------*/
  598.     /* Code Body                                                      */
  599.     /*----------------------------------------------------------------*/
  600.     object_type = gui_EMS_input_box_get_previous_object(data, position, &current_character, &current_object);   /* get next character */
  601.     if (1 == object_type)
  602.     {
  603.         if (UI_TEST_ESC_CHARACTER(current_character))
  604.         {
  605.             if (BackwardCurrentPositionSkipCR(data) != 1)
  606.             {
  607.                 UI_editor_play_tone_cannot_navigate();
  608.             }
  609.         }
  610.     }
  611. }
  614. #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  618. /*****************************************************************************
  619.  * FUNCTION
  620.  *  gui_is_ems_object_can_display_in_editor
  621.  * DESCRIPTION
  622.  *  
  623.  * PARAMETERS
  624.  *  type        [IN]        
  625.  * RETURNS
  626.  *  
  627.  *****************************************************************************/
  628. MMI_BOOL gui_is_ems_object_can_display_in_editor(U8 type)
  629. {
  630.     /*----------------------------------------------------------------*/
  631.     /* Local Variables                                                */
  632.     /*----------------------------------------------------------------*/
  634.     /*----------------------------------------------------------------*/
  635.     /* Code Body                                                      */
  636.     /*----------------------------------------------------------------*/
  637.     if (type == EMS_TYPE_PREDEF_SND ||
  638.         type == EMS_TYPE_USERDEF_SND ||
  639.         type == EMS_TYPE_PREDEF_ANM || type == EMS_TYPE_USERDEF_ANM || type == EMS_TYPE_PIC)
  640.     {
  641.         return MMI_TRUE;
  642.     }
  643.     else
  644.     {
  645.         return MMI_FALSE;
  646.     }
  647. }
  650. /*****************************************************************************
  651.  * FUNCTION
  652.  *  gui_insert_character_into_buffer
  653.  * DESCRIPTION
  654.  *  
  655.  * PARAMETERS
  656.  *  buffer      [?]         
  657.  *  offset      [IN]        
  658.  *  c           [IN]        
  659.  * RETURNS
  660.  *  void
  661.  *****************************************************************************/
  662. void gui_insert_character_into_buffer(U16 *buffer, U16 offset, UI_character_type c)
  663. {
  664.     /*----------------------------------------------------------------*/
  665.     /* Local Variables                                                */
  666.     /*----------------------------------------------------------------*/
  667.     UI_buffer_type p1, p2;
  668.     UI_character_type old_c;
  670.     /*----------------------------------------------------------------*/
  671.     /* Code Body                                                      */
  672.     /*----------------------------------------------------------------*/
  673.     p1 = p2 = ((U8*) buffer) + offset;
  675.     while (!UI_STRING_END_OF_STRING_CHARACTER(c))
  676.     {
  677.         UI_STRING_GET_NEXT_CHARACTER(p1, old_c);
  678.         UI_STRING_INSERT_CHARACTER(p2, c);
  679.         c = old_c;
  680.     }
  681.     UI_STRING_INSERT_CHARACTER(p2, c);  /* insert character */
  682. }
  685. /*****************************************************************************
  686.  * FUNCTION
  687.  *  gui_delete_character_from_buffer
  688.  * DESCRIPTION
  689.  *  
  690.  * PARAMETERS
  691.  *  buffer      [?]         
  692.  *  offset      [IN]        
  693.  * RETURNS
  694.  *  void
  695.  *****************************************************************************/
  696. void gui_delete_character_from_buffer(U16 *buffer, U16 offset)
  697. {
  698.     /*----------------------------------------------------------------*/
  699.     /* Local Variables                                                */
  700.     /*----------------------------------------------------------------*/
  701.     UI_buffer_type p1, p2;
  702.     UI_character_type c, old_c;
  704.     /*----------------------------------------------------------------*/
  705.     /* Code Body                                                      */
  706.     /*----------------------------------------------------------------*/
  707.     p1 = p2 = ((U8*) buffer) + offset;
  708.     c = *p1;
  709.     p1 += 2;
  711.     while (!UI_STRING_END_OF_STRING_CHARACTER(c))
  712.     {
  713.         UI_STRING_GET_NEXT_CHARACTER(p1, c);
  714.         UI_STRING_INSERT_CHARACTER(p2, c);  /* insert character */
  715.     }
  716. }
  719. /*****************************************************************************
  720.  * FUNCTION
  721.  *  gui_get_ems_text_actual_idx
  722.  * DESCRIPTION
  723.  *  
  724.  * PARAMETERS
  725.  *  b                   [?]         
  726.  *  OffsetToText        [IN]        
  727.  * RETURNS
  728.  *  
  729.  *****************************************************************************/
  730. U16 gui_get_ems_text_actual_idx(UI_EMS_input_box *b, U16 OffsetToText)
  731. {
  732.     /*----------------------------------------------------------------*/
  733.     /* Local Variables                                                */
  734.     /*----------------------------------------------------------------*/
  735.     EMSData *data = b->data;
  736.     EMSObject *cur_obj = data->listHead;
  737.     U16 offset = 0;
  739.     /*----------------------------------------------------------------*/
  740.     /* Code Body                                                      */
  741.     /*----------------------------------------------------------------*/
  742.     while (cur_obj != NULL)
  743.     {
  744.         if (gui_is_ems_object_can_display_in_editor((U8) cur_obj->Type))
  745.         {
  746.             if (cur_obj->OffsetToText < OffsetToText)
  747.             {
  748.                 offset += 2;
  749.             }
  750.             else
  751.             {
  752.                 return (OffsetToText + offset);
  753.             }
  754.         }
  755.         cur_obj = cur_obj->next;
  756.     }
  757.     return (OffsetToText + offset);
  759. }
  761. #define dummy_char 0x01
  762. U16 object_position[128];
  763. U8 object_no = 0;
  766. /*****************************************************************************
  767.  * FUNCTION
  768.  *  gui_ems_data_apply_shaping
  769.  * DESCRIPTION
  770.  *  
  771.  * PARAMETERS
  772.  *  b                       [?]     
  773.  *  text_shaping_buffer     [?]     
  774.  * RETURNS
  775.  *  void
  776.  *****************************************************************************/
  777. void gui_ems_data_apply_shaping(UI_EMS_input_box *b, U16 *text_shaping_buffer)
  778. {
  779.     /*----------------------------------------------------------------*/
  780.     /* Local Variables                                                */
  781.     /*----------------------------------------------------------------*/
  782.     EMSData *data = b->data;
  783.     EMSObject *cur_obj = data->listHead;
  784.     S32 i = 0;
  785.     S32 text_len = (b->data->textLength / 2);
  786.     MMI_BOOL has_ems_display_object = MMI_FALSE;
  788.     /*----------------------------------------------------------------*/
  789.     /* Code Body                                                      */
  790.     /*----------------------------------------------------------------*/
  791.     object_no = 0;
  792.     while (cur_obj != NULL)
  793.     {
  794.         if (gui_is_ems_object_can_display_in_editor((U8) cur_obj->Type))
  795.         {
  796.             has_ems_display_object = MMI_TRUE;
  797.             gui_insert_character_into_buffer(
  798.                 text_shaping_buffer,
  799.                 cur_obj->OffsetToText + (object_no * 2),
  800.                 (UI_character_type) dummy_char);
  801.             text_len++;
  802.             object_position[object_no] = cur_obj->OffsetToText / 2 + object_no + 1;
  803.             object_no++;
  804.         }
  805.         cur_obj = cur_obj->next;
  806.     }
  808.     unshaped_text_len = text_len;
  809. #ifdef __MMI_ZI__
  811.     #ifdef __MMI_ZI_V7__
  812.         #if defined(__MMI_ZI_ARABIC__) && defined(__MMI_ZI_PERSIAN__)
  813.             ZiStringShapeEx(ZI8_LANG_FA, (U16*) & text_len, (U16*) text_shaping_buffer, (U16*) OrgToSha, NULL);      /* 19 is the Arabic id */
  814.         #elif defined(__MMI_ZI_PERSIAN__)
  815.             ZiStringShapeEx(ZI8_LANG_FA, (U16*) & text_len, (U16*) text_shaping_buffer, (U16*) OrgToSha, NULL);      /* 19 is the Arabic id */
  816.         #elif defined(__MMI_ZI_ARABIC__)
  817.             ZiStringShapeEx(ZI8_LANG_AR, (U16*) & text_len, (U16*) text_shaping_buffer, (U16*) OrgToSha, NULL);      /* 19 is the Arabic id */
  818.         #endif 
  819.     #else /* __MMI_ZI_V7__ */ 
  820.         ArabicStringShape2((U16*) & text_len, (U16*) text_shaping_buffer, (U16*) OrgToSha, NULL);
  821.     #endif /* __MMI_ZI_V7__ */ 
  822.   
  823. #else /* __MMI_ZI__ */ 
  824.     ArabicShapeEngine2((U16*) & text_len, (U16*) text_shaping_buffer, (U16*) OrgToSha, NULL);
  825. #endif /* __MMI_ZI__ */ 
  827. }
  828. #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  831. /*****************************************************************************
  832.  * FUNCTION
  833.  *  gui_show_EMS_input_box
  834.  * DESCRIPTION
  835.  *  
  836.  * PARAMETERS
  837.  *  b       [?]     
  838.  * RETURNS
  839.  *  void
  840.  *****************************************************************************/
  841. void gui_show_EMS_input_box(UI_EMS_input_box *b)
  842. {
  843.     /*----------------------------------------------------------------*/
  844.     /* Local Variables                                                */
  845.     /*----------------------------------------------------------------*/
  847.     /*----------------------------------------------------------------*/
  848.     /* Code Body                                                      */
  849.     /*----------------------------------------------------------------*/
  850.     gui_show_EMS_input_box_ext(b, (-1), (-1));
  851. }
  854. /*****************************************************************************
  855.  * FUNCTION
  856.  *  gui_show_EMS_input_box_ext
  857.  * DESCRIPTION
  858.  *  
  859.  * PARAMETERS
  860.  *  b               [?]         
  861.  *  move_to_x       [IN]        
  862.  *  move_to_y       [IN]        
  863.  * RETURNS
  864.  *  void
  865.  *****************************************************************************/
  866. void gui_show_EMS_input_box_ext(UI_EMS_input_box *b, S32 move_to_x, S32 move_to_y)
  867. {
  868.     /*----------------------------------------------------------------*/
  869.     /* Local Variables                                                */
  870.     /*----------------------------------------------------------------*/
  871.     S32 x1, y1;                 /* x1,y1 -> left-top corner of the editor windows */
  872.     S32 x2, y2;                 /* x2,y2 -> right-bottom of the editor windows */
  873.     UI_filled_area f;           /* Gurinder - 03/15/2004 - EMS Input Box InfoBar BG Image */
  874.     U8 selection_flag = 0;
  875.     U8 overwrite_mode_flag = 0;
  876.     S32 tx = 0, ty;             /* specify the positon at which the text display starts */
  877.     EMSData *data = b->data;
  878.     UI_character_type current_character = 0, pre2_character = 0, pre_character = 0;
  879.     EMSPosition current_position;
  880.     EMSPosition line_start_position;
  881.     EMSPosition previous_position;
  882.     U8 object_type;
  883.     EMSObject *current_object;
  884.     S32 line_width, line_height;
  885.     S32 break_line_width, break_line_height;
  886.     S32 object_width, object_height;
  887.     U8 done = 0;
  888.     U8 display_done;
  889.     EMSObject *current_text_format;
  890.     EMSObject *line_start_text_format;
  891.     U32 flags = b->flags;
  892.     S32 set_cursor_flag = 0;
  893.     S32 center_x, box_width;
  894.     S32 line_object_count;
  895.     S32 cursor_ax, cursor_ay;   /* Absolute cursor co-ordinates  */
  896.     S32 break_line_object_count;
  897.     S32 text_format_object_count, break_text_format_object_count;
  898.     U8 disable_draw_flag = 0;
  899.     U8 *object_width_cache = EMS_object_width_cache;
  900.     U8 *object_height_cache = EMS_object_height_cache;
  901.     U8 word_highlight = 0;
  903.     /* byte                                 has_ems_boundary_flag   =       0;  //Gurinder - 03/15/2004 - EMS Input Box InfoBar BG Image */
  904.     S32 n_lines = 0;
  905.     U8 first_object_flag;
  906.     EMSPosition mapped_cursor_position;
  907.     EMSPosition mapped_current_position;
  908.     EMSPosition mapped_previous_position;
  909.     U8 cursor_displayed_flag = 0;
  910.     U8 alignment, break_line_alignment = EMS_ALIGN_LANG_DEP, line_alignment;
  911.     S32 line_text_object_count, break_line_text_object_count;
  912.     color normal_text_color = b->normal_text_color;
  913.     color selected_text_color = b->selected_text_color;
  915.     /* PMT LANGUAGE START 20051221 */
  917. #if defined __MMI_LANG_HINDI__ && (defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__)
  919.     U16 unicode = 0;
  920.     U16 clFill = 0;
  921. #endif /* defined __MMI_LANG_HINDI__ && (defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__) */ 
  922.     //PMT LANGUAGE END 20051221
  923.     //START PMT NEERAJ 20050916
  924. #if(EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES)
  925.     S32 minimum_line_height;
  926.     S32 last_line_y = 0;
  927. #endif /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  928.     /* END PMT NEERAJ 20050916 */
  929. #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY)
  930.     color underline_color = b->underline_color;
  931.     color strikethrough_color = b->strikethrough_color;
  932.     color paragraph_color = b->paragraph_color;
  933.     U8 underline_flag = 0, strikethrough_flag = 0;
  934. #endif /* (EMS_ENABLE_SPECIAL_FONT_DISPLAY) */ 
  935. #ifdef __MMI_HINDI_ALG__
  936.     PU8 move_ems_cursor_prev_p = data->textBuffer;
  937.     PU8 move_ems_cursor_curr_p = data->textBuffer;
  938.     PU8 temp_ems_cursor_p = data->textBuffer;
  939.     PU8 move_ems_cursor_disp_prev_p = data->textBuffer;
  940.     PU8 move_ems_cursor_disp_curr_p = data->textBuffer;
  941.     U16 disp_ems_cluster[MAX_EMS_DISP_CLUSTER_LEN];
  942.     S32 skip_ems_moves = 1;         /* for skipping by cluster */
  943.     S32 saved_ems_skip_moves = 1;
  944.     S32 display_ems_skip_moves = 1; /* for skipping by cluster while display */
  945.     S32 saved_ems_display_skip_moves = 0;
  946.     S32 ems_cluster_width = 0;
  947.     S32 ems_cursor_width = 0;
  948.     U8 kdx = 0;
  949.     S32 hindi_ems_cluster_counter = 0;
  951.     /* Performance related to store the cluster width */
  952.     S32 hindi_cluster_cache[50];
  953.     S32 hindi_cache_counter = 0;
  955.     /* MTK Begin Hindi patch 0425 */
  956.     BOOL set_hindi_text_format_flag = MMI_FALSE;
  957.     EMSObject *hindi_text_format = NULL;
  959.     /* MTK End Hindi patch 0425 */
  961. #endif /* __MMI_HINDI_ALG__ */ 
  962.     PMT_BIDI_TYPES default_direction = BIDI_L;
  963.     S32 vbar_x = 0, vbar_button_x = 0;
  965. #ifdef __MMI_BIDI_ALG__
  966.     U16 logical_cur_pos;
  967.     U8 *temp_text_pt;
  968.     U16 temp_text_position;
  969.     U8 temp_text_buffer[MAX_NUM_OF_CHAR_FOR_EACH_LINE];
  970.     U16 temp_cursor_position;
  971.     U16 visual_str_len;
  972.     U16 visual_cur_pos;
  973.     U16 logical_hilight_start;
  974.     U16 logical_hilight_end;
  975.     U16 visual_hilight_start;
  976.     U16 visual_hilight_end;
  977.     U16 temp_hilight_start;
  978.     U16 temp_hilight_end;
  979.     PMT_BIDI_TYPES default_line_direction = BIDI_L;
  980.     pBOOL reverse_flag;
  981.     S32 num_char;
  982.     U32 iCount;
  983.     pBOOL arabic_char_flag = MMI_FALSE;
  984.     U8 lastest_char_type;
  985.     UI_character_type test_current_character;
  987.     /* PMT NO_AR_SL_DU START 20050909 */
  988.     S32 text_len;
  989.     PU8 ptr_text_buffer;
  991.     /* PMT NO_AR_SL_DU END 20050909 */
  992. #endif /* __MMI_BIDI_ALG__ */ 
  993. #if defined(__MMI_LANG_VIETNAMESE__)
  994.     UI_character_type dummy_c = 0;
  995.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  996.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  997. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  999.     /*----------------------------------------------------------------*/
  1000.     /* Code Body                                                      */
  1001.     /*----------------------------------------------------------------*/
  1002.     /* PMT RAKESH START 20061006 */
  1003. #if defined __MMI_HINDI_ALG__
  1004.     overwrite_current_language_for_hindi_rules_based_on_input_method();
  1005. #endif 
  1006.     /* PMT RAKESH END 20061006 */
  1007.     if (((-1) != move_to_x) || ((-1) != move_to_y))
  1008.     {
  1009.         flags |= UI_EMS_INPUT_BOX_DISABLE_DRAW;
  1010.     }
  1013. #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  1015.     if ((b->data->textLength / ENCODING_LENGTH) != 0)
  1016.     {
  1017.         if (!(flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  1018.         {
  1019.             pfnUnicodeStrncpy(
  1020.                 (S8*) shaping_str,
  1021.                 (const S8*)b->data->textBuffer,
  1022.                 b->data->textLength / ENCODING_LENGTH);
  1023.             gui_ems_data_apply_shaping(b, shaping_str);
  1024.         }
  1025.         else
  1026.         {
  1027.             pfnUnicodeStrncpy(
  1028.                 (S8*) shaping_str,
  1029.                 (const S8*)b->data->textBuffer,
  1030.                 b->data->textLength / ENCODING_LENGTH);
  1031.             gui_ems_data_apply_shaping(b, shaping_str);
  1033.         #ifdef __MMI_HINDI_ALG__
  1034.             move_ems_cursor_prev_p = data->textBuffer;
  1035.             move_ems_cursor_curr_p = data->textBuffer;
  1036.             temp_ems_cursor_p = data->textBuffer;
  1037.             move_ems_cursor_disp_prev_p = data->textBuffer;
  1038.             move_ems_cursor_disp_curr_p = data->textBuffer;
  1039.         #endif /* __MMI_HINDI_ALG__ */ 
  1040.         }
  1041.     }
  1042. #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  1044. #if defined __MMI_LANG_HINDI__ && (defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__)
  1046.     /* U16 unicode        =  0;
  1047.        U16 clFill        =  0; */
  1048.     /* PMT LANGUAGE END 20051221 */
  1049.     HINDI_PRESENT = 0;
  1050.     ARABIC_PRESENT = 0;
  1051.     while ((data->textBuffer[clFill] != '' || data->textBuffer[clFill + 1] != '') && !HINDI_PRESENT)
  1052.     {
  1053.         unicode = data->textBuffer[clFill];
  1054.         unicode |= (data->textBuffer[clFill + 1] << 8);
  1055.         if (UI_HINDI_CHARACTER_UCS2_RANGE(unicode))
  1056.         {
  1057.             HINDI_PRESENT = 1;
  1058.             ARABIC_PRESENT = 0;
  1059.         }
  1060.         /* PMT LANGUAGE START 20051221 */
  1061.         else if (IS_ARABIC_CHARACTER(unicode))
  1062.         {
  1063.             ARABIC_PRESENT = 1;
  1064.             HINDI_PRESENT = 0;
  1065.         }
  1066.         /* PMT LANGUAGE END 20051221 */
  1067.         clFill += 2;
  1068.     }
  1069. #endif /* defined __MMI_LANG_HINDI__ && (defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__) */ 
  1070.     /* END PMTFARHAD  20050224 */
  1072. #ifdef __MMI_BIDI_ALG__
  1073.     if (!(flags & UI_EMS_INPUT_BOX_DISABLE_DRAW) && (data->textLength != 0))
  1074.     {
  1075.         bidi_get_char_type(data->textBuffer, (U8*) & default_direction);
  1076.         if (default_direction == BIDI_R || default_direction == AL)
  1077.         {
  1078.             default_direction = BIDI_R;
  1079.         }
  1080.         else
  1081.         {
  1082.             default_direction = BIDI_L;
  1083.         }
  1085.         for (iCount = 0; iCount < (U32) (data->textLength >> 1); iCount++)
  1086.         {
  1087.             bidi_get_char_type((U8*) (data->textBuffer + iCount * ENCODING_LENGTH), (U8*) & lastest_char_type);
  1088.             if ((lastest_char_type == AL) || (lastest_char_type == AN) || (lastest_char_type == BIDI_R))
  1089.             {
  1090.                 arabic_char_flag = MMI_TRUE;
  1091.                 break;
  1092.             }
  1093.         }
  1094.     }
  1095. #endif /* __MMI_BIDI_ALG__ */ 
  1097. #if 0
  1098. #ifdef __MMI_BIDI_ALG__
  1099. /* under construction !*/
  1100. /* under construction !*/
  1101. /* under construction !*/
  1102. /* under construction !*/
  1103. /* under construction !*/
  1104. /* under construction !*/
  1105. /* under construction !*/
  1106. /* under construction !*/
  1107. /* under construction !*/
  1108. /* under construction !*/
  1109. /* under construction !*/
  1110. /* under construction !*/
  1111. /* under construction !*/
  1112. /* under construction !*/
  1113. /* under construction !*/
  1114. /* under construction !*/
  1115. /* under construction !*/
  1116. /* under construction !*/
  1117. /* under construction !*/
  1118. /* under construction !*/
  1119. /* under construction !*/
  1120. /* under construction !*/
  1121. /* under construction !*/
  1122. /* under construction !*/
  1123. /* under construction !*/
  1124. /* under construction !*/
  1125. /* under construction !*/
  1126. /* under construction !*/
  1127. /* under construction !*/
  1128. /* under construction !*/
  1129. /* under construction !*/
  1130. /* under construction !*/
  1131. /* under construction !*/
  1132. /* under construction !*/
  1133. /* under construction !*/
  1134. /* under construction !*/
  1135. /* under construction !*/
  1136. /* under construction !*/
  1137. /* under construction !*/
  1138. #if defined __MMI_LANG_HINDI__ && ( defined __MMI_LANG_ARABIC__|| defined __MMI_LANG_PERSIAN__ )
  1139. /* under construction !*/
  1140. #endif
  1141. /* under construction !*/
  1142. /* under construction !*/
  1143. /* under construction !*/
  1144. /* under construction !*/
  1145. /* under construction !*/
  1146. /* under construction !*/
  1147. /* under construction !*/
  1148. /* under construction !*/
  1149. /* under construction !*/
  1150. /* under construction !*/
  1151. /* under construction !*/
  1152. /* under construction !*/
  1153. /* under construction !*/
  1154. /* under construction !*/
  1155. /* under construction !*/
  1156. /* under construction !*/
  1157. #if defined __MMI_LANG_HINDI__ && ( defined __MMI_LANG_ARABIC__|| defined __MMI_LANG_PERSIAN__ )
  1158. /* under construction !*/
  1159. #endif
  1160. /* under construction !*/
  1161. /* under construction !*/
  1162. /* under construction !*/
  1163. /* under construction !*/
  1164. /* under construction !*/
  1165. /* under construction !*/
  1166. /* under construction !*/
  1167. #if defined __MMI_LANG_HINDI__ && ( defined __MMI_LANG_ARABIC__|| defined __MMI_LANG_PERSIAN__ )
  1168. /* under construction !*/
  1169. #endif
  1170. /* under construction !*/
  1171. /* under construction !*/
  1172. /* under construction !*/
  1173. /* under construction !*/
  1174. /* under construction !*/
  1175. /* under construction !*/
  1176. /* under construction !*/
  1177. /* under construction !*/
  1178. /* under construction !*/
  1179. /* under construction !*/
  1180. /* under construction !*/
  1181. /* under construction !*/
  1182. /* under construction !*/
  1183. /* under construction !*/
  1184. /* under construction !*/
  1185. /* under construction !*/
  1186. #if defined __MMI_LANG_HINDI__ && ( defined __MMI_LANG_ARABIC__|| defined __MMI_LANG_PERSIAN__ )
  1187. /* under construction !*/
  1188. #endif
  1189. /* under construction !*/
  1190. /* under construction !*/
  1191. /* under construction !*/
  1192. /* under construction !*/
  1193. /* under construction !*/
  1194. /* under construction !*/
  1195. /* under construction !*/
  1196. /* under construction !*/
  1197. /* under construction !*/
  1198. /* under construction !*/
  1199. /* under construction !*/
  1200. #ifdef __MMI_HINDI_ALG__
  1201. /* under construction !*/
  1202. /* under construction !*/
  1203. /* under construction !*/
  1204. /* under construction !*/
  1205. /* under construction !*/
  1206. #endif
  1207. /* under construction !*/
  1208. /* under construction !*/
  1209. /* under construction !*/
  1210. /* under construction !*/
  1211. /* under construction !*/
  1212. /* under construction !*/
  1213. /* under construction !*/
  1214. /* under construction !*/
  1215. /* under construction !*/
  1216. /* under construction !*/
  1217. /* under construction !*/
  1218. /* under construction !*/
  1219. /* under construction !*/
  1220. /* under construction !*/
  1221. /* under construction !*/
  1222. /* under construction !*/
  1223. /* under construction !*/
  1224. /* under construction !*/
  1225. /* under construction !*/
  1226. /* under construction !*/
  1227. /* under construction !*/
  1228. /* under construction !*/
  1229. /* under construction !*/
  1230. /* under construction !*/
  1231. /* under construction !*/
  1232. /* under construction !*/
  1233. /* under construction !*/
  1234. /* under construction !*/
  1235. /* under construction !*/
  1236. /* under construction !*/
  1237. /* under construction !*/
  1238.   #endif
  1239. #endif /* 0 */ 
  1241.     if (r2lMMIFlag)
  1242.     {
  1243.         x1 = b->x + b->vbar.width;
  1244.     }
  1245.     else
  1246.     {
  1247.         x1 = b->x;
  1248.     }
  1249.     y1 = b->y;
  1250.     x2 = b->x /* x1 */  + b->width - 1;
  1251.     y2 = y1 + b->height - 1;
  1252.     b->display_height = 0;
  1254. #ifdef __MMI_HINDI_ALG__
  1255.     memset(disp_ems_cluster, 0, sizeof(disp_ems_cluster));
  1256. #endif 
  1258.     if (flags & UI_EMS_INPUT_BOX_DISABLE_DRAW)
  1259.     {
  1260.         disable_draw_flag = 1;
  1261.     }
  1262.     if (flags & UI_EMS_INPUT_BOX_VIEW_MODE)
  1263.     {
  1264.         EMS_view_mode = 1;
  1265.     }
  1266.     else
  1267.     {
  1268.         EMS_view_mode = 0;
  1269.     }
  1270.     if (!disable_draw_flag)
  1271.     {
  1272.         if (flags & UI_EMS_INPUT_BOX_STATE_SELECTED)
  1273.         {
  1274.             f = *b->selected_filler;
  1275.         }
  1276.         else if (flags & UI_EMS_INPUT_BOX_STATE_DISABLED)
  1277.         {
  1278.             f = *b->disabled_filler;
  1279.         }
  1280.         /* Gurinder - 03/15/2004 - EMS Input Box InfoBar BG Image */
  1281.         else
  1282.         {
  1283.             f = *b->normal_filler;
  1284.         }
  1286.         if (r2lMMIFlag)
  1287.         {
  1288.             gui_set_clip(x1 - b->vbar.width, y1, x2 + 2 /* +b->vbar.width */ , y2 + 2);
  1289.         }
  1290.         else
  1291.         {
  1292.             gui_set_clip(x1, y1, x2 + 2, y2 + 2);
  1293.         }
  1294.         /* Gurinder - 03/15/2004 - EMS Input Box InfoBar BG Image */
  1295.         if (!(flags & UI_EMS_INPUT_BOX_DISABLE_BACKGROUND)) /* if not disable background then do ... */
  1296.         {
  1297.             if (!(flags & UI_EMS_INPUT_BOX_INCLUDE_INFO_AREA))  /* not include info area */
  1298.             {
  1299.                 /* 070405 Calvin Start */
  1300.                 if (r2lMMIFlag)
  1301.                 {
  1302.                     if ((wgui_is_wallpaper_on_bottom() == MMI_TRUE) &&
  1303.                         (flags & UI_EMS_INPUT_BOX_TRANSPARENT_BACKGROUND))
  1304.                     {
  1305.                         gdi_draw_solid_rect(
  1306.                             x1 - b->vbar.width,
  1307.                             y1,
  1308.                             x2 /* +b->vbar.width */ ,
  1309.                             y2,
  1310.                             GDI_COLOR_TRANSPARENT);
  1311.                     }
  1312.                     else
  1313.                     {
  1314.                         gui_draw_filled_area(x1 - b->vbar.width, y1, x2 /* +b->vbar.width */ , y2, &f);
  1315.                     }
  1316.                 }
  1317.                 else
  1318.                 {
  1319.                     if ((wgui_is_wallpaper_on_bottom() == MMI_TRUE) &&
  1320.                         (flags & UI_EMS_INPUT_BOX_TRANSPARENT_BACKGROUND))
  1321.                     {
  1322.                         gdi_draw_solid_rect(x1, y1, x2, y2, GDI_COLOR_TRANSPARENT);
  1323.                     }
  1324.                     else
  1325.                     {
  1326.                         gui_draw_filled_area(x1, y1, x2, y2, &f);
  1327.                     }
  1328.                 }
  1329.                 /* 070405 Calvin End */
  1331.             }
  1332.             else    /* include info area */
  1333.             {
  1334.                 if (r2lMMIFlag)
  1335.                 {
  1336.                     gui_set_clip(
  1337.                         x1 - b->vbar.width,
  1338.                         y1 - wgui_EMS_inputbox_information_bar_height,
  1339.                         x2 /* +b->vbar.width */ ,
  1340.                         y2);
  1341.                 }
  1342.                 else
  1343.                 {
  1344.                     gui_set_clip(x1, y1 - wgui_EMS_inputbox_information_bar_height, x2, y2);
  1345.                 }
  1347.                 f.flags = UI_FILLED_AREA_TYPE_BITMAP;
  1348.                 f.b = get_image(WGUI_VOLUME_LEVEL1);
  1349.                 if (r2lMMIFlag)
  1350.                 {
  1351.                     /* 070405 Calvin Start */
  1352.                     if ((wgui_is_wallpaper_on_bottom() == MMI_TRUE) &&
  1353.                         (flags & UI_EMS_INPUT_BOX_TRANSPARENT_BACKGROUND))
  1354.                     {
  1355.                         gdi_draw_solid_rect(
  1356.                             x1 - b->vbar.width,
  1357.                             y1 - wgui_EMS_inputbox_information_bar_height,
  1358.                             x2 /* + b->vbar.width */ ,
  1359.                             y2,
  1360.                             GDI_COLOR_TRANSPARENT);
  1361.                     }
  1362.                     else
  1363.                     {
  1364.                         gui_draw_filled_area(
  1365.                             x1 - b->vbar.width,
  1366.                             y1 - wgui_EMS_inputbox_information_bar_height,
  1367.                             x2 /* + b->vbar.width */ ,
  1368.                             y2,
  1369.                             &f);
  1370.                     }
  1371.                     /* 070405 Calvin End */
  1372.                     gui_draw_rectangle(
  1373.                         x1 - b->vbar.width,
  1374.                         y1,
  1375.                         x2 /* + b->vbar.width */ ,
  1376.                         y2,
  1377.                         b->boundary_color);
  1378.                 }
  1379.                 else
  1380.                 {
  1381.                     /* 070405 Calvin Start */
  1382.                     if ((wgui_is_wallpaper_on_bottom() == MMI_TRUE) &&
  1383.                         (flags & UI_EMS_INPUT_BOX_TRANSPARENT_BACKGROUND))
  1384.                     {
  1385.                         gdi_draw_solid_rect(
  1386.                             x1,
  1387.                             y1 - wgui_EMS_inputbox_information_bar_height,
  1388.                             x2,
  1389.                             y2,
  1390.                             GDI_COLOR_TRANSPARENT);
  1391.                     }
  1392.                     else
  1393.                     {
  1394.                         gui_draw_filled_area(x1, y1 - wgui_EMS_inputbox_information_bar_height, x2, y2, &f);
  1395.                     }
  1396.                     /* 070405 Calvin End */
  1397.                     gui_draw_rectangle(x1, y1, x2, y2, b->boundary_color);
  1398.                 }
  1400.                 if (flags & UI_MULTI_LINE_INPUT_BOX_USE_PRESET_CLIPPING)
  1401.                 {
  1402.                     gui_set_clip_preset(x1, y1, x2 + 2, y2 + 2);
  1403.                 }
  1404.                 else
  1405.                 {
  1406.                     gui_set_clip(x1, y1, x2 + 2, y2 + 2);
  1407.                 }
  1408.             }
  1409.         }
  1410.     }
  1411.     if (!(flags & UI_EMS_INPUT_BOX_DISABLE_SCROLLBAR))
  1412.     {
  1413.         x2 -= b->vbar.width;
  1414.     }
  1415.     box_width = (x2 - x1 - 2);
  1416.     center_x = x1 + (box_width >> 1) + 1;
  1417.     ty = y1 + 2 + b->display_y;
  1418.     if (flags & UI_EMS_INPUT_BOX_DISPLAY_HEADER)
  1419.     {
  1420.         S32 h, ty1, ty2;
  1422.         h = b->measure_header();
  1423.         b->header_height = h;
  1424.         ty1 = ty - 2;
  1425.         ty2 = ty + h - 1;
  1426.         if (!disable_draw_flag && (ty2 > y1))
  1427.         {
  1428.             b->display_header(x1, ty1, x2, ty2);
  1429.         }
  1430.         ty += h;
  1431.     }
  1432.     else
  1433.     {
  1434.         b->header_height = 0;
  1435.     }
  1436.     if (!disable_draw_flag)
  1437.     {
  1439.         if (flags & UI_EMS_INPUT_BOX_STATE_MULTITAP)
  1440.         {
  1441.         #ifdef __MMI_BIDI_ALG__
  1442.             if (arabic_char_flag)
  1443.             {
  1444.                 selection_flag = 0;
  1445.             }
  1446.             else
  1447.         #endif /* __MMI_BIDI_ALG__ */ 
  1448.                 selection_flag = 1;
  1449.         }
  1450.         if ((flags & UI_EMS_INPUT_BOX_OVERWRITE_MODE) && (!selection_flag))
  1451.         {
  1452.             overwrite_mode_flag = 1;
  1453.         }
  1454.         gui_set_clip(x1 + 1, y1 + 1, x2, y2 - 1);
  1455.         EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  1456.         /* gui_set_text_clip(x1+2,y1+2,x2-2,y2-2); */
  1457.         EMS_SET_TEXT_COLOR(normal_text_color);
  1458.     }
  1459.     line_start_position.Object = NULL;
  1460.     line_start_position.OffsetToText = 0;
  1461.     current_text_format = NULL;
  1462.     cursor_ay = 0;
  1463.     text_format_object_count = 0;
  1464.     b->first_displayed_line = -1;
  1465.     b->last_displayed_line = -1;
  1466.     EMS_map_position(data, &data->CurrentPosition, &mapped_cursor_position);
  1467.     line_alignment = EMS_ALIGN_LANG_DEP;
  1469. #if defined(__MMI_LANG_VIETNAMESE__)
  1470.     /* W05.38 Fix Viet Tone Cursor Moving Issue */
  1471.     if ((flags & UI_EMS_INPUT_BOX_DISABLE_DRAW) && (data->textLength != 0))
  1472.     {
  1473.         EMSPosition temp_cursor_position;
  1475.         EMS_map_position(data, &data->CurrentPosition, &temp_cursor_position);
  1476.         object_type = gui_EMS_input_box_get_next_object(data, &temp_cursor_position, &current_character, &current_object);
  1477.         if (1 == object_type)
  1478.         {
  1479.             if ((current_character >= 0x0300) && (current_character <= 0x0323))
  1480.             {
  1481.                 EMS_map_position(data, &data->CurrentPosition, &temp_cursor_position);
  1482.                 object_type = gui_EMS_input_box_get_previous_object(data, &temp_cursor_position, &dummy_c, &current_object);    /* get next character */
  1483.                 if (1 == object_type)
  1484.                 {
  1485.                     viet_vowel = mmi_viet_vowel_letter(dummy_c);
  1486.                     if (VIET_VOWEL_NONE != viet_vowel)
  1487.                     {
  1488.                         tone_mark = mmi_viet_tone_mark(current_character);
  1489.                         if (VIET_TONE_NONE != tone_mark)
  1490.                         {
  1491.                             current_character = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  1492.                             gui_EMS_input_box_forward_cursor(b);
  1493.                         }
  1494.                     }
  1495.                 }
  1496.             }
  1497.         }
  1498.     }
  1499. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  1501.     while (!done)
  1502.     {   /* First Pass: Find the start and end of a line, line height and line width   */
  1503.         line_start_text_format = current_text_format;
  1504.     #ifdef __MMI_MESSAGES_EMS__
  1505.         gui_EMS_input_box_set_text_format(b, current_text_format);
  1506.     #else /* __MMI_MESSAGES_EMS__ */ 
  1507.         {
  1508.             EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  1509.             EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  1510.             b->flags &= ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT |
  1511.                           UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT | UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  1512.         }
  1513.     #endif /* __MMI_MESSAGES_EMS__ */ 
  1514.         break_line_height = line_height = gui_get_character_height();
  1515.         current_position = line_start_position;
  1516.         break_text_format_object_count = text_format_object_count;
  1517.         /* PMT SHAILESH START 20060619 */
  1518.     #ifdef __MMI_HINDI_ALG__
  1519.         break_line_width = line_width = 1;
  1520.     #else 
  1521.         break_line_width = line_width = 0;
  1522.     #endif 
  1523.         /* PMT SHAILESH END 20060619 */
  1524.         break_line_object_count = line_object_count = 0;
  1525.         break_line_text_object_count = line_text_object_count = 0;
  1526.     #ifdef __MMI_HINDI_ALG__
  1527.         hindi_cache_counter = 0;
  1528.         saved_ems_skip_moves = skip_ems_moves = 1;
  1529.         object_width = 0;
  1530.         move_ems_cursor_prev_p = (data->textBuffer + line_start_position.OffsetToText); /* TARUN */
  1531.     #endif /* __MMI_HINDI_ALG__ */ 
  1532.         first_object_flag = 1;
  1533.         while (!done)
  1534.         {
  1535.             previous_position = current_position;
  1536.             if (TestLastPosition(data, &current_position))
  1537.             {
  1538.                 current_character = 0;
  1539.                 EMS_SET_BREAK_POSITION();
  1540.                 /* MTK Terry for adjust the line width with italic style */
  1541.                 if (UI_EMS_inputbox_current_font.italic && pre_character != 0)
  1542.                 {
  1543.                     break_line_width += 3;
  1544.                 }
  1545.                 done = 1;
  1546.                 break;
  1547.             }
  1548.         #ifdef __MMI_HINDI_ALG__
  1549.             PRINT_INFORMATION_2((MMI_TRACE_INFO, "pixtel_UI_show_EMS_input_box[skip_ems_moves]:%d  ", skip_ems_moves));
  1550.             while (skip_ems_moves--)
  1551.             {
  1552.         #endif /* __MMI_HINDI_ALG__ */ 
  1553.                 object_type = gui_EMS_input_box_get_next_object(
  1554.                                 data,
  1555.                                 &current_position,
  1556.                                 &current_character,
  1557.                                 &current_object);
  1558.             #ifdef __MMI_HINDI_ALG__
  1559.                 /* MTK Begin Hindi patch 0425 */
  1560.                 if ((skip_ems_moves >= 1) && (object_type == 2) && (current_object->Type == EMS_TYPE_TEXT_FORMAT))
  1561.                 {
  1562.                     object_type = gui_EMS_input_box_get_next_object(
  1563.                                     data,
  1564.                                     &current_position,
  1565.                                     &current_character,
  1566.                                     &current_object);
  1567.                 }
  1568.                 /* MTK End Hindi patch 0425 */
  1570.             }
  1571.             /* Not when object is images */
  1572.             if (HF_HINDI_RANGE(current_character) && !(object_type == 2))
  1573.             {
  1574.                 object_type = 1;
  1575.             }
  1576.             #endif /* __MMI_HINDI_ALG__ */ 
  1577.             switch (object_type)
  1578.             {
  1579.                 case 0:
  1580.                     done = 1;
  1581.                     break;
  1582.                 case 1: /* character */
  1583.             #if(EMS_DISPLAY_SPECIAL_CHARACTERS)
  1584.                     if (UI_TEST_CR_CHARACTER(current_character) ||
  1585.                         UI_TEST_LF_CHARACTER(current_character) || UI_TEST_ESC_CHARACTER(current_character))
  1586.                     {
  1587.                         object_width = 10;
  1588.                         object_height = 10;
  1589.                     }
  1590.                     else
  1591.             #else /* (EMS_DISPLAY_SPECIAL_CHARACTERS) */ 
  1592.                 #if(EMS_USE_CRLF_COMBINATION)
  1593.                     if (UI_TEST_CR_CHARACTER(current_character) &&
  1594.                         (current_position.OffsetToText < data->textLength) &&
  1595.                         UI_TEST_LF_CHARACTER(data->textBuffer[current_position.OffsetToText]))
  1596.                     {
  1597.                     #ifdef __MMI_HINDI_ALG__
  1598.                         skip_ems_moves = 1;
  1599.                     #endif 
  1600.                         object_width = 0;
  1601.                         object_height = line_height;
  1602.                     }
  1603.                     else if (UI_TEST_LF_CHARACTER(current_character) || UI_TEST_CR_CHARACTER(current_character))
  1604.                     {
  1605.                     #ifdef __MMI_HINDI_ALG__
  1606.                         skip_ems_moves = 1;
  1607.                     #endif 
  1608.                         object_width = 0;
  1609.                         object_height = line_height;
  1610.                     }
  1611.                     else
  1612.                 #endif /* (EMS_USE_CRLF_COMBINATION) */ 
  1613.                 #if(EMS_USE_ESC_COMBINATION)
  1614.                     if (UI_TEST_ESC_CHARACTER(current_character))
  1615.                     {
  1616.                     #ifdef __MMI_HINDI_ALG__
  1617.                         skip_ems_moves = 1;
  1618.                     #endif 
  1619.                         object_width = 0;
  1620.                         object_height = line_height;
  1621.                     }
  1622.                     else
  1623.                 #endif /* (EMS_USE_ESC_COMBINATION) */ 
  1624.             #endif /* (EMS_DISPLAY_SPECIAL_CHARACTERS) */ 
  1625.                     if (UI_STRING_END_OF_STRING_CHARACTER(current_character))
  1626.                     {
  1627.                         /* PMT FARHAD START 20050708 */
  1628.                     #ifdef __MMI_HINDI_ALG__
  1629.                         skip_ems_moves = 1;
  1630.                         /* PMT Start 20060725 */
  1631.                         move_ems_cursor_prev_p += 2;
  1632.                         /* PMT End 20060725 */
  1633.                     #endif /* __MMI_HINDI_ALG__ */ 
  1634.                         /* PMT FARHAD END 20050708 */
  1635.                         object_width = 0;
  1636.                         object_height = line_height;
  1637.                     }
  1638.                     else
  1639.                     {
  1640.                     #if defined(__MMI_LANG_VIETNAMESE__)
  1641.                         if ((current_character > 0x0040) && (current_character < 0x01B1))
  1642.                         {
  1643.                             object_type = gui_EMS_input_box_get_next_object(data, &current_position, &dummy_c, &current_object);        /* get next character */
  1644.                             if (1 == object_type)
  1645.                             {
  1646.                                 tone_mark = mmi_viet_tone_mark(dummy_c);
  1647.                                 if (VIET_TONE_NONE != tone_mark)
  1648.                                 {
  1649.                                     viet_vowel = mmi_viet_vowel_letter(current_character);
  1650.                                     if (VIET_VOWEL_NONE != viet_vowel)
  1651.                                     {
  1652.                                         current_character = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  1653.                                     }
  1654.                                     else
  1655.                                     {
  1656.                                         object_type = gui_EMS_input_box_get_previous_object(
  1657.                                                         data,
  1658.                                                         &current_position,
  1659.                                                         &dummy_c,
  1660.                                                         &current_object);
  1661.                                     }
  1662.                                 }
  1663.                                 else
  1664.                                 {
  1665.                                     object_type = gui_EMS_input_box_get_previous_object(
  1666.                                                     data,
  1667.                                                     &current_position,
  1668.                                                     &dummy_c,
  1669.                                                     &current_object);
  1670.                                 }
  1671.                             }
  1672.                             else if (0 != object_type)
  1673.                             {
  1674.                                 object_type = gui_EMS_input_box_get_previous_object(
  1675.                                                 data,
  1676.                                                 &current_position,
  1677.                                                 &dummy_c,
  1678.                                                 &current_object);
  1679.                             }
  1680.                         }
  1681.                     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  1684.                     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  1686.                         if (IS_ARABIC_CHARACTER(current_character))
  1687.                         {
  1689.                             U32 idx = gui_get_ems_text_actual_idx(b, current_position.OffsetToText) / 2 - 1;
  1690.                             U32 ligature_move = 0;
  1691.                             UI_character_type dummy_c_arabic = 0;
  1693.                             current_character = (UI_character_type) shaping_str[OrgToSha[idx]];
  1694.                             while (idx < unshaped_text_len)
  1695.                             {
  1696.                                 if (OrgToSha[idx] == OrgToSha[idx + 1])
  1697.                                 {
  1698.                                     ligature_move++;
  1699.                                 }
  1700.                                 else
  1701.                                 {
  1702.                                     break;
  1703.                                 }
  1704.                                 idx++;
  1705.                             }
  1706.                             while (ligature_move > 0)
  1707.                             {
  1708.                                 object_type = gui_EMS_input_box_get_next_object(data, &current_position, &dummy_c_arabic, &current_object);     /* get next character */
  1709.                                 ligature_move--;
  1710.                             }
  1711.                         }
  1712.                     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  1714.                     #ifdef __MMI_HINDI_ALG__
  1715.                         /* MTK Terry for Cursor Height Issue */
  1716.                         if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  1717.                         {
  1718.                             /* PMT START FIX HINDI ISSUES 20060604 */
  1719.                             gui_measure_character(current_character, &object_width, &object_height);
  1720.                             if (object_height > line_height)
  1721.                             {
  1722.                                 line_height = object_height;
  1723.                             }
  1724.                             object_height = gui_get_character_height();
  1725.                             /* PMT END FIX HINDI ISSUES 20060604 */
  1726.                         }
  1727.                         else
  1728.                         {
  1729.                             gui_measure_character(current_character, &object_width, &object_height);
  1730.                         }
  1731.                         PRINT_INFORMATION_2((MMI_TRACE_INFO, "pixtel_UI_show_EMS_input_box[object_height]:%d  ",
  1732.                                              object_height));
  1733.                     #else /* __MMI_HINDI_ALG__ */ 
  1734.                         gui_measure_character(current_character, &object_width, &object_height);
  1735.                     #endif /* __MMI_HINDI_ALG__ */ 
  1737.                         if (!RequireToMoveCursor(pre_character, current_character))
  1738.                         {
  1739.                             object_width = 0;
  1740.                         #ifdef __MMI_HINDI_ALG__
  1741.                             skip_ems_moves = 1;
  1742.                             /* START TARUN PMT 20050128 */
  1743.                             move_ems_cursor_prev_p += 2;
  1744.                             /* END TARUN PMT 20050128 */
  1745.                         #endif /* __MMI_HINDI_ALG__ */ 
  1746.                         }
  1747.                         else
  1748.                         {
  1749.                         #ifdef __MMI_HINDI_ALG__
  1751.                             /* Move pointer by the cluster width */
  1752.                             //For performance issue b->text is also assumed as current cluster pos
  1753.                             //move_ems_cursor_curr_p = hf_get_next_cluster_p(data->textBuffer,move_ems_cursor_prev_p);
  1754.                             move_ems_cursor_curr_p = hf_get_next_cluster_p(move_ems_cursor_prev_p, move_ems_cursor_prev_p);
  1755.                             skip_ems_moves = move_ems_cursor_curr_p - move_ems_cursor_prev_p;   /* Number of moves */
  1756.                             skip_ems_moves = skip_ems_moves >> 1;
  1757.                             saved_ems_skip_moves = skip_ems_moves;      /* Save moves to skip the current_text_p also */
  1759.                             /* Calculate the width of current cluster as well as english character */
  1760.                             /* object_width = hf_size_of_current_cluster(data->textBuffer,move_ems_cursor_curr_p,0); */
  1761.                             object_width = hf_size_of_current_cluster(move_ems_cursor_prev_p, move_ems_cursor_curr_p, 0);
  1762.                             /* for bold italic in hindi */
  1763.                             if (UI_EMS_inputbox_current_font.italic || UI_EMS_inputbox_current_font.bold)
  1764.                             {
  1765.                                 object_width += 1;
  1766.                             }
  1767.                             PRINT_INFORMATION_2((MMI_TRACE_INFO, "pixtel_UI_show_EMS_input_box[object_width]:%d  ",
  1768.                                                  object_width));
  1769.                             if (UI_TEST_CR_CHARACTER(current_character))
  1770.                             {
  1771.                                 object_width = 0;
  1772.                             }
  1773.                             move_ems_cursor_prev_p = move_ems_cursor_curr_p;
  1774.                         #else /* __MMI_HINDI_ALG__ */ 
  1775.                             /* Arabic Connectivity issue */    
  1777.                         #if defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__
  1778.                             if (!IS_ARABIC_CHARACTER(current_character))
  1779.                             {
  1780.                         #endif
  1781.                                 /* PMT START 17082006 */
  1782.                                 if (!UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  1783.                                     /* PMT END 17082006 */
  1784.                                 {
  1785.                                     object_width += 1;
  1786.                                 }
  1788.                         #if defined __MMI_LANG_ARABIC__ || defined __MMI_LANG_PERSIAN__                        
  1789.                              }
  1790.                         #endif 
  1792.                         #endif /* __MMI_HINDI_ALG__ */ 
  1793.                         }
  1794.                     }
  1796.                     /* MTK Terry for adjust the line width with italic style */
  1797.                     if ((line_width + object_width + 1) > box_width ||
  1798.                         (UI_EMS_inputbox_current_font.italic && (line_width + object_width + 3) > box_width))
  1799.                     {
  1800.                         line_width += object_width;
  1801.                     }
  1802.                     else
  1803.                     {
  1804.                         U8 bflag;
  1806.                         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1807.                         if (bflag)
  1808.                         {
  1809.                             EMS_SET_NEXT_BREAK_POSITION();
  1810.                         }
  1811.                         line_width += object_width;
  1812.                     #ifdef __MMI_HINDI_ALG__
  1813.                         if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  1814.                         {
  1815.                             hindi_ems_cluster_counter = line_object_count;
  1816.                             while (saved_ems_skip_moves--)
  1817.                             {
  1818.                                 object_width_cache[hindi_ems_cluster_counter] = 0;
  1819.                                 object_height_cache[hindi_ems_cluster_counter] = (U8) object_height;
  1820.                                 hindi_ems_cluster_counter++;
  1821.                             }
  1822.                             hindi_cluster_cache[hindi_cache_counter] = object_width;
  1823.                         }
  1824.                         else
  1825.                     #endif /* __MMI_HINDI_ALG__ */ 
  1826.                         {
  1827.                             object_width_cache[line_object_count] = (U8) object_width;
  1828.                             /*
  1829.                              * #ifdef __MMI_BIDI_ALG__
  1830.                              * if(arabic_char_flag)
  1831.                              * object_height_cache[line_object_count]=(byte)gui_get_character_height()+2;
  1832.                              * else
  1833.                              * #endif
  1834.                              */
  1835.                             object_height_cache[line_object_count] = (U8) object_height;
  1836.                         }
  1838.                         if (object_height > line_height)
  1839.                         {
  1840.                             line_height = object_height;
  1841.                         }
  1842.                     #ifdef __MMI_HINDI_ALG__
  1843.                         line_object_count += skip_ems_moves;
  1844.                         line_text_object_count += skip_ems_moves;
  1845.                         hindi_cache_counter++;
  1846.                     #else /* __MMI_HINDI_ALG__ */ 
  1847.                         line_object_count++;
  1848.                         line_text_object_count++;
  1849.                     #endif /* __MMI_HINDI_ALG__ */ 
  1851.                         if (UI_STRING_LINE_BREAK_CHARACTER(current_character))
  1852.                         {
  1853.                             EMS_SET_BREAK_POSITION();
  1854.                             if (text_format_object_count <= 1)
  1855.                             {
  1856.                                 line_alignment = EMS_ALIGN_LANG_DEP;
  1857.                             }
  1858.                         }
  1859.                         if (text_format_object_count)
  1860.                         {
  1861.                             text_format_object_count--;
  1862.                             if ((text_format_object_count == 0) && (current_position.OffsetToText < data->textLength))
  1863.                             {
  1864.                             #ifdef __MMI_MESSAGES_EMS__
  1865.                                 gui_EMS_input_box_set_text_format(b, &UI_EMS_normal_text_format_object);
  1866.                             #else /* __MMI_MESSAGES_EMS__ */ 
  1867.                                 {
  1868.                                     EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  1869.                                     EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  1870.                                     b->flags &= ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT |
  1871.                                                   UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT |
  1872.                                                   UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  1873.                                 }
  1874.                             #endif /* __MMI_MESSAGES_EMS__ */ 
  1875.                                 object_height = gui_get_character_height();
  1876.                                 if (object_height > line_height)
  1877.                                 {
  1878.                                     line_height = object_height;
  1879.                                 }
  1880.                                 if (line_object_count == 0)
  1881.                                 {
  1882.                                     line_height = object_height;
  1883.                                 }
  1884.                             }
  1885.                         }
  1886.                         /* MTK Terry for FireFly#159 */
  1887.                     #ifdef __MMI_HINDI_ALG__
  1888.                         /* Hindi condition also added for word wrap issue */
  1889.                         if ((!UI_MULTI_LINE_INPUT_BOX_ALPHABETIC_CHARACTER(current_character)) &&
  1890.                             (!UI_HINDI_CHARACTER_UCS2_RANGE(current_character)))
  1891.                     #else /* __MMI_HINDI_ALG__ */ 
  1892.                         if ((!UI_MULTI_LINE_INPUT_BOX_ALPHABETIC_CHARACTER(current_character)))
  1893.                     #endif /* __MMI_HINDI_ALG__ */ 
  1894.                         {
  1895.                             break_line_object_count = 0;
  1896.                         }
  1897.                     }
  1898.                     pre2_character = pre_character;
  1899.                     pre_character = current_character;
  1900.                     /* MTK end */
  1901.                     break;
  1902.                 #ifdef __MMI_MESSAGES_EMS__
  1903.                 case 2: /* object */
  1904.                     if (current_object->Type == EMS_TYPE_TEXT_FORMAT)
  1905.                     {
  1906.                         line_alignment = current_object->data->text_format.Alignment;
  1907.                         gui_EMS_input_box_set_text_format(b, current_object);
  1908.                         text_format_object_count = ((current_object->data->text_format.textLength) >> 1);
  1909.                         object_height = gui_get_character_height();
  1910.                         if (object_height > line_height)
  1911.                         {
  1912.                             line_height = object_height;
  1913.                         }
  1914.                         if (line_object_count == 0)
  1915.                         {
  1916.                             line_height = object_height;
  1917.                         }
  1918.                     }
  1919.                     else
  1920.                     {
  1921.                         gui_EMS_input_box_measure_object(current_object, &object_width, &object_height);
  1922.                         object_width += 2;
  1923.                         if (first_object_flag)
  1924.                         {
  1925.                             object_width += 1;
  1926.                         }
  1927.                         else
  1928.                         {
  1929.                             line_width += 3;
  1930.                         }
  1932.                         object_height += 1; /* 1 pixel gap between lines  */
  1933.                         /* MTK Elvis 20040322 to avoid the cursor overlap with scroll bar */
  1934.                         if ((line_width + object_width + 1) > box_width)
  1935.                             /* MTK end */
  1936.                         {
  1937.                             line_width += object_width;
  1938.                             /* Removed line breaking rule for objects */
  1939.                             /* EMS_SET_BREAK_POSITION(); */
  1940.                         }
  1941.                         else
  1942.                         {
  1943.                             if (object_height > line_height)
  1944.                             {
  1945.                                 line_height = object_height;
  1946.                             }
  1947.                             line_width += object_width;
  1948.                             if (first_object_flag)
  1949.                             {
  1950.                                 object_width -= 2;
  1951.                             }
  1952.                             object_width_cache[line_object_count] = (S8) object_width;
  1953.                             object_height_cache[line_object_count] = (S8) object_height;
  1954.                             line_object_count++;
  1955.                             /* Removed line breaking rule for objects */
  1956.                             /* EMS_SET_BREAK_POSITION(); */
  1957.                         }
  1958.                     }
  1959.                     current_character = 0;
  1960.                 #ifdef __MMI_HINDI_ALG__
  1961.                     skip_ems_moves = 1;
  1962.                 #endif 
  1963.                     break;
  1964.                     /* PMT FARHAD START 20050708 */
  1965.                 #else /* __MMI_MESSAGES_EMS__ */ 
  1966.                 case 2: /* object */
  1967.                     current_character = 0;
  1968.                 #ifdef __MMI_HINDI_ALG__
  1969.                     skip_ems_moves = 1;
  1970.                 #endif 
  1971.                     break;
  1972.                     /* PMT FARHAD END 20050708 */
  1973.                 #endif /* __MMI_MESSAGES_EMS__ */ 
  1974.             }
  1975.             first_object_flag = 0;
  1976.             /* MTK Elvis to avoid the cursor overlap with scroll bar */
  1977.             /* MTK Terry for adjust the line width with italic style only for character type */
  1978.             if ((line_width + 1 > box_width) ||
  1979.                 (UI_EMS_inputbox_current_font.italic && (line_width + 3) > box_width) && (1 == object_type) ||
  1980.                 UI_STRING_LINE_BREAK_CHARACTER(current_character))
  1981.                 /* MTK end */
  1982.             {
  1983.                 if ((break_line_object_count == 0) && (line_object_count > 0))
  1984.                 {
  1985.                     EMS_SET_BREAK_POSITION();
  1986.                     break_line_width -= object_width;
  1987.                 }
  1988.                 /* MTK Terry for adjust the line width with italic style */
  1989.                 if ((UI_EMS_inputbox_current_font.italic && (line_width + 3) > box_width) && pre_character != 0)
  1990.                 {
  1991.                     break_line_width += 3;
  1992.                 }
  1993.                 break;
  1994.             }
  1995.         }
  1997.         /* Second pass: Display the line */
  1998.         pre2_character = 0;
  1999.         pre_character = 0;
  2001.     #ifdef __MMI_HINDI_ALG__
  2002.         ems_cluster_width = 0;
  2003.         ems_cursor_width = 0;
  2004.     #endif /* __MMI_HINDI_ALG__ */ 
  2006.         line_width = break_line_width;
  2007.         line_height = break_line_height;
  2008.         current_text_format = line_start_text_format;
  2009.         current_position = line_start_position;
  2010.         alignment = break_line_alignment;
  2011.         if ((alignment != b->text_format.Alignment) &&
  2012.             (break_line_text_object_count == 0) && (b->current_line == n_lines) && (EMS_view_mode == 0))
  2013.         {
  2014.             alignment = b->text_format.Alignment;
  2015.         }
  2016.         /*       Old code: For testing                  */
  2017.         /*       else if((break_line_text_object_count!=0) && (data->textLength==0))
  2018.            alignment=b->text_format.Alignment;    */
  2019.         switch (alignment)
  2020.         {
  2021.             case EMS_ALIGN_LEFT:
  2022.                 if (default_direction == BIDI_L)
  2023.                 {
  2024.                     tx = x1 + 2;
  2025.                 }
  2026.                 else
  2027.                 {
  2028.                     tx = x1 + line_width + 2;
  2029.                 }
  2030.                 break;
  2031.             case EMS_ALIGN_RIGHT:
  2032.                 if (default_direction == BIDI_L)
  2033.                 {
  2034.                     tx = x2 - line_width - 2;
  2035.                 }
  2036.                 else
  2037.                 {
  2038.                     tx = x1 + box_width;
  2039.                 }
  2040.                 break;
  2041.             case EMS_ALIGN_CENTER:
  2042.                 if (default_direction == BIDI_L)
  2043.                 {
  2044.                     tx = center_x - (line_width >> 1);
  2045.                 }
  2046.                 else
  2047.                 {
  2048.                     tx = center_x + (line_width >> 1);
  2049.                 }
  2050.                 break;
  2051.             case EMS_ALIGN_LANG_DEP:
  2052.                 if (default_direction == BIDI_L)
  2053.                 {
  2054.                     tx = x1 + 2;
  2055.                 }
  2056.                 else
  2057.                 {
  2058.                     tx = x1 + box_width;
  2059.                 }
  2060.                 break;
  2061.             default:
  2062.                 tx = x1 + 2;
  2063.                 break;
  2064.         }
  2065.         if (tx < (x1 + 2))
  2066.         {
  2067.             tx = x1 + 2;
  2068.         }
  2069.         cursor_ax = tx - (x1 + 2);
  2070.         if ((b->first_displayed_line == -1) && (ty >= (y1 + 2)))
  2071.         {
  2072.             b->first_displayed_line = n_lines;
  2073.         }
  2074.         if ((ty + line_height) <= y2)
  2075.         {
  2076.             b->last_displayed_line = n_lines;
  2077.         }
  2078.         b->line_positions[n_lines] = line_start_position;
  2079.         b->line_object_counts[n_lines] = (U8) break_line_object_count;
  2080.         b->line_x_positions[n_lines] = (U8) cursor_ax;
  2081.         n_lines++;
  2082.     #ifdef __MMI_MESSAGES_EMS__
  2083.         gui_EMS_input_box_set_text_format(b, current_text_format);
  2084.     #else /* __MMI_MESSAGES_EMS__ */ 
  2085.         {
  2086.             EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  2087.             EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  2088.             b->flags &= ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT |
  2089.                           UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT | UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  2090.         }
  2091.     #endif /* __MMI_MESSAGES_EMS__ */ 
  2092.         object_height = gui_get_character_height();
  2093.         text_format_object_count = break_text_format_object_count;
  2094.         display_done = 0;
  2095.         line_object_count = 0;
  2096.     #ifdef __MMI_HINDI_ALG__
  2097.         hindi_cache_counter = 0;
  2098.     #endif 
  2099.         first_object_flag = 1;
  2100.     #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY)
  2101.         if (current_text_format != NULL)
  2102.         {
  2103.             if (current_text_format->data->text_format.isUnderline == KAL_TRUE)
  2104.             {
  2105.                 underline_flag = 1;
  2106.             }
  2107.             else
  2108.             {
  2109.                 underline_flag = 0;
  2110.             }
  2111.             if (current_text_format->data->text_format.isStrikethrough == KAL_TRUE)
  2112.             {
  2113.                 strikethrough_flag = 1;
  2114.             }
  2115.             else
  2116.             {
  2117.                 strikethrough_flag = 0;
  2118.             }
  2119.         }
  2120.     #endif /* (EMS_ENABLE_SPECIAL_FONT_DISPLAY) */ 
  2122.     #ifdef __MMI_BIDI_ALG__
  2123.         if (!(flags & UI_EMS_INPUT_BOX_DISABLE_DRAW) && arabic_char_flag)
  2124.         {
  2126.             /* get last character unicode of previous line */
  2127.             if (n_lines == 1)
  2128.             {
  2129.                 if (break_line_text_object_count < data->textLength / 2)
  2130.                 {
  2131.                 #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2132.                     test_current_character = (data->textBuffer[current_position.OffsetToText +
  2133.                                                                ((1 + break_line_text_object_count) * ENCODING_LENGTH) -
  2134.                                                                1] | (data->textBuffer[current_position.OffsetToText +
  2135.                                                                                       ((1 +
  2136.                                                                                         break_line_text_object_count) *
  2137.                                                                                        ENCODING_LENGTH) - 2] << 8));
  2138.                 #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2139.                     test_current_character = (data->textBuffer[current_position.OffsetToText +
  2140.                                                                ((1 + break_line_text_object_count) * ENCODING_LENGTH) -
  2141.                                                                2] | (data->textBuffer[current_position.OffsetToText +
  2142.                                                                                       ((1 +
  2143.                                                                                         break_line_text_object_count) *
  2144.                                                                                        ENCODING_LENGTH) - 1] << 8));
  2145.                 #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2146.                 }
  2147.                 else
  2148.                 {
  2149.                 #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2150.                     test_current_character = (data->textBuffer[current_position.OffsetToText +
  2151.                                                                ((break_line_text_object_count) * ENCODING_LENGTH) - 1] |
  2152.                                               (data->textBuffer[current_position.OffsetToText +
  2153.                                                                 ((break_line_text_object_count) * ENCODING_LENGTH) -
  2154.                                                                 2] << 8));
  2155.                 #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2156.                     test_current_character = (data->textBuffer[current_position.OffsetToText +
  2157.                                                                ((break_line_text_object_count) * ENCODING_LENGTH) - 2] |
  2158.                                               (data->textBuffer[current_position.OffsetToText +
  2159.                                                                 ((break_line_text_object_count) * ENCODING_LENGTH) -
  2160.                                                                 1] << 8));
  2161.                 #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2162.                 }
  2164.             }
  2165.             else
  2166.             {
  2167.             #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2168.                 test_current_character = (data->textBuffer[current_position.OffsetToText - 1] |
  2169.                                           (data->textBuffer[current_position.OffsetToText - 2] << 8));
  2170.             #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2171.                 test_current_character = (data->textBuffer[current_position.OffsetToText - 2] |
  2172.                                           (data->textBuffer[current_position.OffsetToText - 1] << 8));
  2173.             #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  2174.             }
  2176.             if (line_text_object_count > break_line_text_object_count)
  2177.             {
  2178.                 num_char = break_line_text_object_count + 1;
  2179.             }
  2180.             else
  2181.             {
  2182.                 num_char = break_line_text_object_count;    /* line_text_object_count; */
  2183.             }
  2184.             MMI_ASSERT(!(num_char > ((MAX_NUM_OF_CHAR_FOR_EACH_LINE >> 1) - 1)));
  2186.             if (((mapped_cursor_position.OffsetToText) / ENCODING_LENGTH) <
  2187.                 ((current_position.OffsetToText) / ENCODING_LENGTH))
  2188.             {
  2189.                 logical_cur_pos = 0xFFFF;
  2190.             }
  2191.             else if ((((mapped_cursor_position.OffsetToText) - (current_position.OffsetToText)) / ENCODING_LENGTH) >
  2192.                      (num_char))
  2193.             {
  2194.                 logical_cur_pos = 0xFFFF;
  2195.             }
  2196.             else
  2197.             {
  2198.                 logical_cur_pos =
  2199.                     ((mapped_cursor_position.OffsetToText) - (current_position.OffsetToText)) / ENCODING_LENGTH;
  2200.             }
  2202.             if ((n_lines > 1 && logical_cur_pos == 0))
  2203.             {
  2204.                 /* pfnEncodingSchemeToUnicode(&test_current_character, (data->textBuffer + current_position.OffsetToText - ENCODING_LENGTH)); */
  2205.                 if (!UI_STRING_LINE_BREAK_CHARACTER(test_current_character))
  2206.                 {
  2207.                     logical_cur_pos = 0xFFFF;
  2208.                 }
  2209.             }
  2210.             //if(UI_STRING_LINE_BREAK_CHARACTER(current_character))
  2211.             //     logical_cur_pos = 0xFFFF;
  2213.         #if 0
  2214. /* under construction !*/
  2215. /* under construction !*/
  2216. /* under construction !*/
  2217. /* under construction !*/
  2218. /* under construction !*/
  2219. /* under construction !*/
  2220. /* under construction !*/
  2221. /* under construction !*/
  2222. /* under construction !*/
  2223. /* under construction !*/
  2224. /* under construction !*/
  2225. /* under construction !*/
  2226. /* under construction !*/
  2227. /* under construction !*/
  2228. /* under construction !*/
  2229. /* under construction !*/
  2230. /* under construction !*/
  2231. /* under construction !*/
  2232. /* under construction !*/
  2233. /* under construction !*/
  2234. /* under construction !*/
  2235. /* under construction !*/
  2236. /* under construction !*/
  2237. /* under construction !*/
  2238. /* under construction !*/
  2239.         #endif /* 0 */ 
  2240.             {
  2241.                 logical_hilight_start = 0;
  2242.                 logical_hilight_end = 0;
  2243.             }
  2245.             bidi_get_char_type(data->textBuffer + current_position.OffsetToText, (U8*) & default_line_direction);
  2246.             if (default_line_direction == BIDI_R || default_line_direction == AL)
  2247.             {
  2248.                 default_line_direction = BIDI_R;
  2249.             }
  2250.             else
  2251.             {
  2252.                 default_line_direction = BIDI_L;
  2253.             }
  2254.             if (default_direction == BIDI_R && default_line_direction == BIDI_R)
  2255.             {
  2256.                 reverse_flag = MMI_TRUE;
  2257.             }
  2258.             else if (default_direction == BIDI_R && default_line_direction == BIDI_L)
  2259.             {
  2260.                 reverse_flag = MMI_TRUE;
  2261.             }
  2262.             else if (default_direction == BIDI_L && default_line_direction == BIDI_R)
  2263.             {
  2264.                 reverse_flag = MMI_FALSE;
  2265.             }
  2266.             else if (default_direction == BIDI_L && default_line_direction == BIDI_L)
  2267.             {
  2268.                 reverse_flag = MMI_FALSE;
  2269.             }
  2271.             bidi_main(
  2272.                 data->textBuffer + current_position.OffsetToText,
  2273.                 (U16) num_char,
  2274.                 logical_cur_pos,
  2275.                 visual_str,
  2276.                 &visual_str_len,
  2277.                 &visual_cur_pos,
  2278.                 reverse_flag,
  2279.                 MMI_bidi_input_type,
  2280.                 logical_hilight_start,
  2281.                 logical_hilight_end,
  2282.                 &visual_hilight_start,
  2283.                 &visual_hilight_end);
  2285.             temp_text_position = current_position.OffsetToText;
  2286.             memcpy(
  2287.                 temp_text_buffer,
  2288.                 data->textBuffer + current_position.OffsetToText,
  2289.                 visual_str_len * ENCODING_LENGTH);
  2290.             memcpy(data->textBuffer + current_position.OffsetToText, visual_str, visual_str_len * ENCODING_LENGTH);
  2291.             temp_cursor_position = mapped_cursor_position.OffsetToText;
  2292.             if (visual_cur_pos != 0xFFFF)
  2293.             {
  2294.                 mapped_cursor_position.OffsetToText =
  2295.                     line_start_position.OffsetToText + (visual_cur_pos * ENCODING_LENGTH);
  2296.             }
  2298.             
  2299.             //if (default_line_direction == BIDI_L || (default_direction == BIDI_L && default_line_direction == BIDI_R))
  2300.             if(arabic_char_flag)
  2301.             {
  2302.                 pfnUnicodeStrncpy(
  2303.                     (S8*) shaping_str,
  2304.                     (const S8*)b->data->textBuffer,
  2305.                     b->data->textLength / ENCODING_LENGTH);
  2306.                 gui_ems_data_apply_shaping(b, shaping_str);
  2307.             }
  2308.            
  2310.         #if 0
  2311. /* under construction !*/
  2312. /* under construction !*/
  2313. /* under construction !*/
  2314. /* under construction !*/
  2315. /* under construction !*/
  2316. /* under construction !*/
  2317. /* under construction !*/
  2318. /* under construction !*/
  2319. /* under construction !*/
  2320. /* under construction !*/
  2321. /* under construction !*/
  2322. /* under construction !*/
  2323. /* under construction !*/
  2324. /* under construction !*/
  2325. /* under construction !*/
  2326. /* under construction !*/
  2327. /* under construction !*/
  2328. /* under construction !*/
  2329. /* under construction !*/
  2330. /* under construction !*/
  2331. /* under construction !*/
  2332. /* under construction !*/
  2333. /* under construction !*/
  2334. /* under construction !*/
  2335. /* under construction !*/
  2336. /* under construction !*/
  2337.         #endif /* 0 */ 
  2339.         }
  2340.     #endif /* __MMI_BIDI_ALG__ */ /* endif of __MMI_BIDI_ALG__ */
  2342.         while (!display_done)
  2343.         {
  2344.             previous_position = current_position;
  2345.             if (line_object_count >= break_line_object_count)
  2346.             {
  2347.                 break;
  2348.             }
  2349.             if (flags & UI_EMS_INPUT_BOX_WORD_HIGHLIGHT)
  2350.             {
  2351.                 if (current_position.OffsetToText == b->highlight_start_position.OffsetToText)
  2352.                 {
  2353.                 #ifdef __MMI_BIDI_ALG__
  2354.                     if (arabic_char_flag)
  2355.                     {
  2356.                         word_highlight = 0;
  2357.                     }
  2358.                     else
  2359.                 #endif /* __MMI_BIDI_ALG__ */ 
  2360.                         word_highlight = 1;
  2361.                 }
  2362.                 if (current_position.OffsetToText == b->highlight_end_position.OffsetToText)
  2363.                 {
  2364.                     word_highlight = 0;
  2365.                 }
  2366.             }
  2367.             object_type = gui_EMS_input_box_get_next_object(
  2368.                             data,
  2369.                             &current_position,
  2370.                             &current_character,
  2371.                             &current_object);
  2372.             EMS_map_position(data, &previous_position, &mapped_previous_position);
  2373.             EMS_map_position(data, &current_position, &mapped_current_position);
  2374.             switch (object_type)
  2375.             {
  2376.                     int no_show_char;
  2378.                 case 0:
  2379.                     current_character = 0;
  2380.                     display_done = 1;
  2381.                     break;
  2382.                 case 1: /* character */
  2383.                     /* MTK Steven for speed up Editor by only display the characters in the display area */
  2384.                     no_show_char = 0;
  2385.                     if (!(flags & UI_EMS_INPUT_BOX_DISABLE_DRAW))
  2386.                     {
  2387.                         if (((ty + line_height) < (y1 + 2)) || ((ty - line_height) > y2))
  2388.                         {
  2389.                             no_show_char = 1;
  2390.                         }
  2391.                     }
  2392.                 #ifdef __MMI_HINDI_ALG__
  2393.                     /* MTK Begin Hindi patch 0425 */
  2394.                     if (set_hindi_text_format_flag == MMI_TRUE)
  2395.                     {
  2396.                         gui_EMS_input_box_set_text_format(b, hindi_text_format);
  2397.                         set_hindi_text_format_flag = MMI_FALSE;
  2398.                         current_text_format = hindi_text_format;
  2399.                     }
  2400.                     /* MTK End Hindi patch 0425 */
  2401.                 #endif /* __MMI_HINDI_ALG__ */ 
  2403.                 #if defined(__MMI_LANG_VIETNAMESE__)
  2404.                     if ((current_character > 0x0040) && (current_character < 0x01B1))
  2405.                     {
  2406.                         object_type = gui_EMS_input_box_get_next_object(data, &current_position, &dummy_c, &current_object);    /* get next character */
  2407.                         if (1 == object_type)
  2408.                         {
  2409.                             tone_mark = mmi_viet_tone_mark(dummy_c);
  2410.                             if (VIET_TONE_NONE != tone_mark)
  2411.                             {
  2412.                                 viet_vowel = mmi_viet_vowel_letter(current_character);
  2413.                                 if (VIET_VOWEL_NONE != viet_vowel)
  2414.                                 {
  2415.                                     current_character = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  2416.                                 }
  2417.                                 else
  2418.                                 {
  2419.                                     object_type = gui_EMS_input_box_get_previous_object(
  2420.                                                     data,
  2421.                                                     &current_position,
  2422.                                                     &dummy_c,
  2423.                                                     &current_object);
  2424.                                 }
  2425.                             }
  2426.                             else
  2427.                             {
  2428.                                 object_type = gui_EMS_input_box_get_previous_object(
  2429.                                                 data,
  2430.                                                 &current_position,
  2431.                                                 &dummy_c,
  2432.                                                 &current_object);
  2433.                             }
  2434.                         }
  2435.                         else
  2436.                         {
  2437.                             object_type = gui_EMS_input_box_get_previous_object(
  2438.                                             data,
  2439.                                             &current_position,
  2440.                                             &dummy_c,
  2441.                                             &current_object);
  2442.                         }
  2443.                     }
  2444.                 #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  2446.                 #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  2448.                     if (IS_ARABIC_CHARACTER(current_character))
  2449.                     {
  2451.                         U32 idx = gui_get_ems_text_actual_idx(b, current_position.OffsetToText) / 2 - 1;
  2452.                         U32 ligature_move = 0;
  2453.                         UI_character_type dummy_c_arabic = 0;
  2455.                         current_character = (UI_character_type) shaping_str[OrgToSha[idx]];
  2456.                         while (idx < unshaped_text_len)
  2457.                         {
  2458.                             if (OrgToSha[idx] == OrgToSha[idx + 1])
  2459.                             {
  2460.                                 ligature_move++;
  2461.                             }
  2462.                             else
  2463.                             {
  2464.                                 break;
  2465.                             }
  2466.                             idx++;
  2467.                         }
  2468.                         while (ligature_move > 0)
  2469.                         {
  2470.                             object_type = gui_EMS_input_box_get_next_object(data, &current_position, &dummy_c_arabic, &current_object); /* get next character */
  2471.                             ligature_move--;
  2472.                         }
  2473.                     }
  2474.                 #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  2476.                 #ifdef __MMI_BIDI_ALG__
  2477.                     if (!(flags & UI_EMS_INPUT_BOX_DISABLE_DRAW) && arabic_char_flag)
  2478.                     {
  2479.                         gui_measure_character(current_character, &object_width, &object_height);
  2480.                         if (!RequireToMoveCursor(pre_character, current_character))
  2481.                         {
  2482.                             object_width = 0;
  2483.                         }
  2484.                         else
  2485.                         {
  2486.                             /* Arabic Connectivity issue */
  2487.                         #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  2488.                             /* PMT START 17082006 */
  2489.                             if (!UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2490.                                 /* PMT END 17082006 */
  2491.                                 if (!IS_ARABIC_CHARACTER(current_character))
  2492.                         #endif /* __MMI_LANG_ARABIC__ */ 
  2493.                                     object_width++;
  2494.                         }
  2496.                         object_width_cache[line_object_count] = object_width;
  2497.                     }
  2498.                 #endif /* __MMI_BIDI_ALG__ */ 
  2499.                     object_width = object_width_cache[line_object_count];
  2500.                     object_height = object_height_cache[line_object_count];
  2501.                 #ifdef __MMI_HINDI_ALG__
  2502.                     if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))       /* space shud have been added in the Hindi range */
  2503.                     {
  2505.                         if (!(TestLastPosition(data, &previous_position)))
  2506.                         {
  2507.                             //For performance issues first argument= second srgument
  2508.                             //move_ems_cursor_disp_curr_p = hf_get_next_cluster_p(data->textBuffer,move_ems_cursor_disp_prev_p);
  2509.                             move_ems_cursor_disp_curr_p = hf_get_next_cluster_p(move_ems_cursor_disp_prev_p, move_ems_cursor_disp_prev_p);
  2510.                             display_ems_skip_moves = move_ems_cursor_disp_curr_p - move_ems_cursor_disp_prev_p;
  2511.                             display_ems_skip_moves = display_ems_skip_moves >> 1;
  2513.                             /* ems_cluster_width=ems_cursor_width=hf_size_of_current_cluster(data->textBuffer,move_ems_cursor_disp_curr_p,0); */
  2514.                         #if 0
  2515. /* under construction !*/
  2516.                         #else /* 0 */ 
  2517.                             ems_cluster_width = ems_cursor_width = hindi_cluster_cache[hindi_cache_counter];
  2518.                         #endif /* 0 */ 
  2520.                             move_ems_cursor_disp_prev_p = move_ems_cursor_disp_curr_p;
  2521.                             saved_ems_display_skip_moves = display_ems_skip_moves;
  2522.                             display_ems_skip_moves--;
  2523.                             for (kdx = 0; kdx < display_ems_skip_moves; kdx++)
  2524.                             {
  2525.                                 object_type = gui_EMS_input_box_get_next_object(
  2526.                                                 data,
  2527.                                                 &current_position,
  2528.                                                 &current_character,
  2529.                                                 &current_object);
  2530.                                 /* MTK Begin Hindi patch 0425 */
  2531.                                 if (display_ems_skip_moves >= 1 && object_type == 2 &&
  2532.                                     current_object->Type == EMS_TYPE_TEXT_FORMAT)
  2533.                                 {
  2534.                                     hindi_text_format = current_object;
  2535.                                     set_hindi_text_format_flag = MMI_TRUE;
  2536.                                     object_type = gui_EMS_input_box_get_next_object(
  2537.                                                     data,
  2538.                                                     &current_position,
  2539.                                                     &current_character,
  2540.                                                     &current_object);
  2542.                                 }
  2543.                                 /* MTK End Hindi patch 0425 */
  2545.                             }
  2546.                         }
  2547.                     }
  2548.                     else
  2549.                     {
  2550.                         move_ems_cursor_disp_prev_p += 2;
  2551.                         saved_ems_display_skip_moves = 1;
  2552.                     }
  2553.                 #endif /* __MMI_HINDI_ALG__ */ 
  2554.                     if (!disable_draw_flag)
  2555.                     {
  2556.                         EMS_SET_TEXT_COLOR(normal_text_color);
  2557.                         if (default_direction == BIDI_R)
  2558.                         {
  2559.                             /* START FARHAD PMT 20050211 */
  2560.                         #ifdef __MMI_HINDI_ALG__
  2561.                             if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2562.                             {
  2563.                                 tx -= ems_cluster_width;
  2564.                                 cursor_ax -= ems_cursor_width;
  2565.                             }
  2566.                             else
  2567.                         #endif /* __MMI_HINDI_ALG__ */ 
  2568.                             {
  2569.                                 tx -= object_width;
  2570.                                 cursor_ax -= object_width;
  2571.                             }
  2572.                             /* END FARHAD PMT 20050211 */
  2573.                         }
  2574.                         /* MTK end */
  2575.                         if (word_highlight ||
  2576.                             (overwrite_mode_flag &&
  2577.                              !cursor_displayed_flag &&
  2578.                              (mapped_previous_position.OffsetToText == mapped_cursor_position.OffsetToText)) ||
  2579.                             (selection_flag &&
  2580.                              (mapped_current_position.OffsetToText == mapped_cursor_position.OffsetToText)))
  2581.                         {
  2582.                             S32 rx1, ry1, rx2, ry2;
  2584.                             rx1 = tx;
  2585.                             /* PMT START FIX HINDI ISSUES 20060604 */
  2586.                         #ifdef __MMI_HINDI_ALG__
  2587.                             if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2588.                             {
  2589.                                 S32 h, w;
  2591.                                 gui_measure_character(current_character, &w, &h);
  2592.                                 /* PMT BEGIN 29082006 */
  2593.                                 ry1 = ty;
  2594.                                 /* PMT END 29082006 */
  2595.                                 rx2 = rx1 + ems_cluster_width - 1;
  2596.                                 ry2 = ry1 + h - 1;
  2597.                                 PRINT_INFORMATION_2((MMI_TRACE_INFO,
  2598.                                                      "pixtel_UI_show_EMS_input_box[ems_cluster_width]:%d  ",
  2599.                                                      ems_cluster_width));
  2600.                             }
  2601.                             else
  2602.                         #endif /* __MMI_HINDI_ALG__ */ 
  2603.                             {
  2604.                                 ry1 = line_height - object_height + ty;
  2605.                                 rx2 = rx1 + object_width - 1;
  2606.                                 ry2 = ry1 + object_height - 1;
  2607.                             }
  2608.                             /* PMT END FIX HINDI ISSUES 20060604 */
  2609.                             EMS_SET_TEXT_COLOR(selected_text_color);
  2610.                         #ifdef __MMI_HINDI_ALG__
  2611.                             /* PMT START 17082006 */
  2612.                             if (MMI_current_input_mode == INPUT_MODE_SMART_HINDI)
  2613.                             {
  2614.                                 if (!UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  2615.                                 {
  2616.                                     gui_fill_rectangle(rx1, ry1, rx2 + 2, ry2, b->selection_color);
  2617.                                 }
  2618.                                 else
  2619.                                 {
  2620.                                     gui_fill_rectangle(rx1 + 2, ry1, rx2 + 2, ry2, b->selection_color);
  2621.                                 }
  2622.                             }
  2623.                             else
  2624.                         #endif /* __MMI_HINDI_ALG__ */ 
  2625.                                 /* PMT END 17082006 */
  2626.                                 gui_fill_rectangle(rx1, ry1, rx2, ry2, b->selection_color);
  2627.                         }
  2628.                         /* PMT START FIX HINDI ISSUES 20060604 */
  2629.                     #ifdef __MMI_HINDI_ALG__
  2630.                         if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2631.                         {
  2632.                             /* PMT START 29082006 */
  2633.                             EMS_MOVE_TEXT_CURSOR(tx, ty);
  2634.                             /* PMT END 29082006 */
  2635.                         }
  2636.                         else
  2637.                     #endif /* __MMI_HINDI_ALG__ */ 
  2638.                             /* PMT END FIX HINDI ISSUES 20060604 */
  2639.                             EMS_MOVE_TEXT_CURSOR(tx, line_height - object_height + ty);
  2640.                     #if(EMS_DISPLAY_SPECIAL_CHARACTERS)
  2641.                         if (UI_TEST_CR_CHARACTER(current_character))
  2642.                         {
  2643.                             gui_show_transparent_image(
  2644.                                 tx,
  2645.                                 line_height - object_height + ty,
  2646.                                 (PU8) EMS_CR_display_character,
  2647.                                 0);
  2648.                         }
  2649.                         else if (UI_TEST_LF_CHARACTER(current_character))
  2650.                         {
  2651.                             gui_show_transparent_image(
  2652.                                 tx,
  2653.                                 line_height - object_height + ty,
  2654.                                 (PU8) EMS_LF_display_character,
  2655.                                 0);
  2656.                         }
  2657.                         else if (UI_TEST_ESC_CHARACTER(current_character))
  2658.                         {
  2659.                             gui_show_transparent_image(
  2660.                                 tx,
  2661.                                 line_height - object_height + ty,
  2662.                                 (PU8) EMS_ESC_display_character,
  2663.                                 0);
  2664.                         }
  2665.                         else
  2666.                     #endif /* (EMS_DISPLAY_SPECIAL_CHARACTERS) */ 
  2667.                         {
  2668.                             /* MTK Terry for Skip Special Character Issue */
  2669.                             if (!(
  2670.                         #if(EMS_USE_ESC_COMBINATION)
  2671.                                      UI_TEST_ESC_CHARACTER(current_character) ||
  2672.                         #endif 
  2673.                         #if(EMS_PREVENT_CRLF_DISPLAY)
  2674.                                      UI_TEST_LF_CHARACTER(current_character) || UI_TEST_CR_CHARACTER(current_character)
  2675.                                      ||
  2676.                         #endif /* (EMS_PREVENT_CRLF_DISPLAY) */ 
  2677.                                      UI_STRING_END_OF_STRING_CHARACTER(current_character)))
  2678.                             {
  2680.                                 /* gui_print_character(current_character); */
  2681.                             #ifdef __MMI_HINDI_ALG__
  2682.                                 PU8 prev_temp_ems_cursor_p;
  2684.                                 if (TestLastPosition(data, &previous_position))
  2685.                                 {
  2686.                                     goto end_ems_disp;
  2687.                                 }
  2689.                                 //Performance issues 
  2690.                                 //temp_ems_cursor_p = hf_get_next_cluster_p(data->textBuffer,temp_ems_cursor_p);
  2691.                                 prev_temp_ems_cursor_p = temp_ems_cursor_p;
  2692.                                 temp_ems_cursor_p = hf_get_next_cluster_p(temp_ems_cursor_p, temp_ems_cursor_p);
  2693.                                 /* if(hf_get_current_cluster(data->textBuffer,temp_ems_cursor_p,disp_ems_cluster)) */
  2694.                                 if (hf_get_current_cluster(prev_temp_ems_cursor_p, temp_ems_cursor_p, disp_ems_cluster))
  2695.                                 {
  2696.                                     S32 disp_len = pfnUnicodeStrlen((PS8) disp_ems_cluster);
  2698.                                     MMI_ASSERT(!(disp_len > MAX_EMS_DISP_CLUSTER_LEN));
  2699.                                     /* To avoid rule appln in showstring */
  2700.                                     hf_disable_hindi_rules_parsing();
  2701.                                     hf_padding_value(0);
  2702.                                     /* START TARUN PMT 20050128 */
  2703.                                     if (!UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2704.                                     {
  2705.                                         if (no_show_char != 1)
  2706.                                         {
  2707.                                             cancelWidth = 1;
  2708.                                             /* PMT MAUI_00015716 START FIX */
  2709.                                             if (underline_flag)
  2710.                                             {
  2711.                                                 UI_font->underline = 0;
  2712.                                             }
  2713.                                             /* PMT MAUI_00015716 END FIX */
  2714.                                             ShowString(
  2715.                                                 UI_text_x,
  2716.                                                 UI_text_y,
  2717.                                                 *UI_font,
  2718.                                                 0,
  2719.                                                 (U8*) (disp_ems_cluster),
  2720.                                             /* PMT MAUI_00015716 START FIX */ 
  2721.                                                  object_height);
  2722.                                             if (underline_flag)
  2723.                                             {
  2724.                                                 UI_font->underline = 1;
  2725.                                             }
  2726.                                             /* PMT MAUI_00015716 END FIX */
  2728.                                             cancelWidth = 0;
  2729.                                         }
  2730.                                     }
  2731.                                     else
  2732.                                     {
  2733.                                         if (no_show_char != 1)
  2734.                                         {
  2735.                                             cancelWidth = 1;
  2736.                                             /* PMT MAUI_00015716 START FIX */
  2737.                                             if (underline_flag)
  2738.                                             {
  2739.                                                 UI_font->underline = 0;
  2740.                                             }
  2741.                                             /* PMT MAUI_00015716 END FIX */
  2742.                                             ShowString(
  2743.                                                 UI_text_x,
  2744.                                                 UI_text_y,
  2745.                                                 *UI_font,
  2746.                                                 0,
  2747.                                                 (U8*) (disp_ems_cluster),
  2748.                                                 UI_text_height);
  2749.                                             /* PMT MAUI_00015716 START FIX */
  2750.                                             if (underline_flag)
  2751.                                             {
  2752.                                                 UI_font->underline = 1;
  2753.                                             }
  2754.                                             /* PMT MAUI_00015716 END FIX */
  2756.                                             cancelWidth = 0;
  2757.                                         }
  2758.                                     }
  2759.                                     //END TARUN PMT 20050128          
  2760.                                     //Open it again
  2761.                                     hf_enable_hindi_rules_parsing();
  2762.                                     hf_padding_def_value();
  2763.                                 }
  2764.                                 else
  2765.                             #endif /* __MMI_HINDI_ALG__ */ 
  2766.                                 {
  2767.                                     if (no_show_char != 1)
  2768.                                     {
  2769.                                         gui_print_stacked_character(current_character, pre2_character, pre_character);
  2770.                                     }
  2771.                                 }
  2772.                             #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY)
  2773.                                 if (underline_flag)
  2774.                                 {
  2775.                                     /* PMT MAUI_00015716 START FIX */
  2776.                                 #ifdef __MMI_HINDI_ALG__
  2777.                                     if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2778.                                     {
  2779.                                         S32 h, w;
  2781.                                         gui_measure_character(current_character, &w, &h);
  2782.                                         UI_draw_horizontal_line(
  2783.                                             tx,
  2784.                                             tx + ems_cluster_width - 1,
  2785.                                             ty + h,
  2786.                                             underline_color);
  2787.                                     }
  2788.                                     else
  2789.                                 #endif /* __MMI_HINDI_ALG__ */ 
  2790.                                         /* PMT MAUI_00015716 END FIX */
  2791.                                         UI_draw_horizontal_line(
  2792.                                             tx,
  2793.                                             tx + object_width - 1,
  2794.                                             ty + line_height - 1,
  2795.                                             underline_color);
  2796.                                 }
  2797.                                 if (strikethrough_flag)
  2798.                                 {
  2799.                                 #ifdef __MMI_HINDI_ALG__
  2800.                                     if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2801.                                     {
  2802.                                         /* PMT MAUI_00015716 START FIX */
  2803.                                         S32 h, w;
  2805.                                         gui_measure_character(current_character, &w, &h);
  2806.                                         /* PMT MAUI_00015716 END FIX */
  2807.                                         UI_draw_horizontal_line(
  2808.                                             tx,
  2809.                                             tx + ems_cluster_width - 1,
  2810.                                             /* PMT MAUI_00015716 START FIX */ 
  2811.                                             ty + (h >> 1),
  2812.                                             /* PMT MAUI_00015716 END FIX */ 
  2813.                                             strikethrough_color);
  2814.                                     }
  2815.                                     else
  2816.                                 #endif /* __MMI_HINDI_ALG__ */ 
  2817.                                     {
  2819.                                         UI_draw_horizontal_line(
  2820.                                             tx,
  2821.                                             tx + object_width - 1,