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

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

MTK

开发平台：

C/C++

gui_ems.c：源码内容
  1.                                             ty + line_height - (object_height >> 1),
  2.                                             strikethrough_color);
  3.                                     }
  4.                                 }
  5.                             #ifdef __MMI_HINDI_ALG__
  6.                               end_ems_disp:
  7.                                 memset(disp_ems_cluster, 0, sizeof(disp_ems_cluster));
  8.                             #endif /* __MMI_HINDI_ALG__ */ 
  9.                             #endif /* (EMS_ENABLE_SPECIAL_FONT_DISPLAY) */ /* end of #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY) */
  10.                             }
  11.                         #ifdef __MMI_HINDI_ALG__
  12.                             else
  13.                             {
  14.                                 temp_ems_cursor_p += 2;
  15.                             }
  16.                         #endif /* __MMI_HINDI_ALG__ */ 
  17.                         }
  18.                     }
  19.                     if (!(((-1) != move_to_x) || ((-1) != move_to_y)))
  20.                     {
  21.                         if ((!cursor_displayed_flag) &&
  22.                             (mapped_previous_position.OffsetToText == mapped_cursor_position.OffsetToText))
  23.                         {
  24.                             b->cursor_ax = cursor_ax;
  25.                             b->cursor_ay = cursor_ay;
  26.                             b->cursor_line_height = line_height;
  27.                             b->cursor_line_position = line_object_count;
  28.                             b->current_line = n_lines - 1;
  29.                             if (!disable_draw_flag && !(flags & UI_EMS_INPUT_BOX_DISABLE_CURSOR_DRAW))
  30.                             {
  31.                                 if (default_direction != BIDI_L)
  32.                                 {
  33.                                 #ifdef __MMI_HINDI_ALG__
  34.                                     if (UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  35.                                     {
  36.                                         /* PMT START FIX HINDI ISSUES 20060604 */
  37.                                         S32 h, w;
  39.                                         gui_measure_character(pre_character, &w, &h);
  40.                                         tx -= ems_cluster_width;
  41.                                         tx += ems_cursor_width;
  42.                                         gui_show_EMS_input_box_cursor(b, tx + 1 + ems_cluster_width, ty, 0, h, 1);
  43.                                     }
  44.                                     else
  45.                                     {
  46.                                         gui_show_EMS_input_box_cursor(
  47.                                             b,
  48.                                             tx + 1 + ems_cluster_width,
  49.                                             line_height - object_height + ty,
  50.                                             0,
  51.                                             object_height,
  52.                                             1);
  53.                                     }
  54.                                     /* PMT END FIX HINDI ISSUES 20060604 */
  55.                                 #else /* __MMI_HINDI_ALG__ */ 
  56.                                     gui_show_EMS_input_box_cursor(
  57.                                         b,
  58.                                         tx + object_width,
  59.                                         line_height - object_height + ty,
  60.                                         0,
  61.                                         object_height,
  62.                                         1);
  63.                                 #endif /* __MMI_HINDI_ALG__ */ 
  64.                                 }
  65.                                 else
  66.                                 {
  67.                                 #ifdef __MMI_HINDI_ALG__
  68.                                     if (UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  69.                                     {
  70.                                         /* PMT START FIX HINDI ISSUES 20060604 */
  71.                                         S32 h, w;
  73.                                         gui_measure_character(pre_character, &w, &h);
  74.                                         tx -= ems_cluster_width;
  75.                                         tx += ems_cursor_width;
  76.                                         gui_show_EMS_input_box_cursor(b, tx + 1, ty, 0, h, 1);
  77.                                     }
  78.                                     else
  79.                                     {
  80.                                         gui_show_EMS_input_box_cursor(
  81.                                             b,
  82.                                             tx + 1,
  83.                                             line_height - object_height + ty,
  84.                                             0,
  85.                                             object_height,
  86.                                             1);
  87.                                     }
  88.                                     /* PMT END FIX HINDI ISSUES 20060604 */
  89.                                 #else /* __MMI_HINDI_ALG__ */ 
  90.                                     gui_show_EMS_input_box_cursor(
  91.                                         b,
  92.                                         tx,
  93.                                         line_height - object_height + ty,
  94.                                         0,
  95.                                         object_height,
  96.                                         1);
  97.                                 #endif /* __MMI_HINDI_ALG__ */ 
  98.                                 }
  99.                             }
  100.                             cursor_displayed_flag = 1;
  101.                         }
  102.                     }
  103.                     else if ((((-1) != move_to_x) || ((-1) != move_to_y)))
  104.                     {
  105.                         if (((tx + b->x + object_width) > move_to_x) &&
  106.                             ((cursor_ay + line_height + b->y + b->display_y + b->header_height) > move_to_y) &&
  107.                             (!set_cursor_flag))
  108.                         {
  109.                             b->cursor_ax = cursor_ax;
  110.                             b->cursor_ay = cursor_ay;
  111.                             b->cursor_line_height = line_height;
  112.                             b->cursor_line_position = line_object_count;
  113.                             b->current_line = n_lines - 1;
  114.                             /* EMS_map_position(data,&previous_position,&(data->CurrentPosition)); */
  115.                             MoveCursorToPosition(data, &previous_position);
  116.                             set_cursor_flag = 1;
  117.                         #if(EMS_USE_ESC_COMBINATION)
  118.                             /* W05.52 Fix Cursor Moviong issue for ESC character */
  119.                             gui_EMS_input_box_back_cursor_for_ESC_character(data, &previous_position);
  120.                         #endif /* (EMS_USE_ESC_COMBINATION) */ 
  121.                         }
  122.                         else if (((cursor_ay + line_height + b->y + b->display_y + b->header_height) > move_to_y) &&
  123.                                  (n_lines < (b->n_lines)) && (!set_cursor_flag) &&
  124.                                  (((line_object_count + 1) >= break_line_object_count) ||
  125.                                   (UI_TEST_CR_CHARACTER(current_character))))
  126.                         {
  127.                             b->cursor_ax = cursor_ax;
  128.                             b->cursor_ay = cursor_ay;
  129.                             b->cursor_line_height = line_height;
  130.                             b->cursor_line_position = line_object_count;
  131.                             b->current_line = n_lines - 1;
  132.                             /* EMS_map_position(data,&previous_position,&(data->CurrentPosition)); */
  133.                             MoveCursorToPosition(data, &previous_position);
  134.                             set_cursor_flag = 1;
  135.                         #if(EMS_USE_ESC_COMBINATION)
  136.                             /* W05.52 Fix Cursor Moviong issue for ESC character */
  137.                             gui_EMS_input_box_back_cursor_for_ESC_character(data, &previous_position);
  138.                         #endif /* (EMS_USE_ESC_COMBINATION) */ 
  139.                         }
  140.                     }
  141.                     /* START FARHAD PMT 20050211 */
  142.                     if (default_direction == BIDI_L)
  143.                     {
  144.                     #ifdef __MMI_HINDI_ALG__
  145.                         if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  146.                         {
  147.                             tx += ems_cluster_width;
  148.                             cursor_ax += ems_cursor_width;
  149.                         }
  150.                         else
  151.                     #endif /* __MMI_HINDI_ALG__ */ 
  152.                         {
  153.                             tx += object_width;
  154.                             cursor_ax += object_width;
  155.                         }
  156.                     }
  157.                 #ifdef __MMI_HINDI_ALG__
  158.                     line_object_count += saved_ems_display_skip_moves;
  159.                     hindi_cache_counter++;
  160.                 #else /* __MMI_HINDI_ALG__ */ 
  161.                     line_object_count++;
  162.                 #endif /* __MMI_HINDI_ALG__ */ 
  164.                     if (text_format_object_count)
  165.                     {
  166.                         text_format_object_count--;
  167.                         if ((text_format_object_count == 0) && (current_position.OffsetToText <= data->textLength))
  168.                         {
  169.                         #ifdef __MMI_MESSAGES_EMS__
  170.                             gui_EMS_input_box_set_text_format(b, &UI_EMS_normal_text_format_object);
  171.                         #else /* __MMI_MESSAGES_EMS__ */ 
  172.                             {
  173.                                 EMS_SET_FONT(&UI_EMS_inputbox_medium_font);
  174.                                 EMS_SET_TEXT_COLOR(UI_EMS_inputbox_text_color);
  175.                                 b->flags &= ~(UI_EMS_INPUT_BOX_CURRENT_ALIGN_LEFT |
  176.                                               UI_EMS_INPUT_BOX_CURRENT_ALIGN_RIGHT |
  177.                                               UI_EMS_INPUT_BOX_CURRENT_ALIGN_CENTER);
  178.                             }
  179.                         #endif /* __MMI_MESSAGES_EMS__ */ 
  180.                             object_height = gui_get_character_height();
  181.                             if (line_object_count == 0)
  182.                             {
  183.                                 line_height = object_height;
  184.                             }
  185.                             current_text_format = &UI_EMS_normal_text_format_object;
  186.                         #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY)
  187.                             if (current_text_format != NULL)
  188.                             {
  189.                                 if (current_text_format->data->text_format.isUnderline == KAL_TRUE)
  190.                                 {
  191.                                     underline_flag = 1;
  192.                                 }
  193.                                 else
  194.                                 {
  195.                                     underline_flag = 0;
  196.                                 }
  197.                                 if (current_text_format->data->text_format.isStrikethrough == KAL_TRUE)
  198.                                 {
  199.                                     strikethrough_flag = 1;
  200.                                 }
  201.                                 else
  202.                                 {
  203.                                     strikethrough_flag = 0;
  204.                                 }
  205.                             }
  206.                         #endif /* (EMS_ENABLE_SPECIAL_FONT_DISPLAY) */ 
  207.                         }
  208.                     }
  209.                     pre2_character = pre_character;
  210.                     pre_character = current_character;
  211.                     break;
  212.                 #ifdef __MMI_MESSAGES_EMS__
  213.                 case 2: /* object */
  214.                     /* MTK Terry for speed up Editor by only display the characters in the display area */
  215.                     if (((ty + line_height) < (y1 + 2)) && ((ty - line_height) > y2))
  216.                     {
  217.                         break;
  218.                     }
  219.                     if (current_object->Type == EMS_TYPE_TEXT_FORMAT)
  220.                     {
  221.                         gui_EMS_input_box_set_text_format(b, current_object);
  222.                         object_height = gui_get_character_height();
  223.                         current_text_format = current_object;
  224.                     #if(EMS_ENABLE_SPECIAL_FONT_DISPLAY)
  225.                         if (current_text_format != NULL)
  226.                         {
  227.                             if (current_text_format->data->text_format.isUnderline == KAL_TRUE)
  228.                             {
  229.                                 underline_flag = 1;
  230.                             }
  231.                             else
  232.                             {
  233.                                 underline_flag = 0;
  234.                             }
  235.                             if (current_text_format->data->text_format.isStrikethrough == KAL_TRUE)
  236.                             {
  237.                                 strikethrough_flag = 1;
  238.                             }
  239.                             else
  240.                             {
  241.                                 strikethrough_flag = 0;
  242.                             }
  243.                         }
  244.                     #endif /* (EMS_ENABLE_SPECIAL_FONT_DISPLAY) */ 
  245.                         text_format_object_count = ((current_object->data->text_format.textLength) >> 1);
  246.                         if (line_object_count == 0)
  247.                         {
  248.                             switch (current_text_format->data->text_format.Alignment)
  249.                             {
  250.                                 case EMS_ALIGN_LEFT:
  251.                                     if (default_direction == BIDI_L)
  252.                                     {
  253.                                         tx = x1 + 2;
  254.                                     }
  255.                                     else
  256.                                     {
  257.                                         tx = x1 + line_width + 2;
  258.                                     }
  259.                                     break;
  260.                                 case EMS_ALIGN_RIGHT:
  261.                                     if (default_direction == BIDI_L)
  262.                                     {
  263.                                         tx = x2 - line_width - 2;
  264.                                     }
  265.                                     else
  266.                                     {
  267.                                         tx = x1 + box_width;
  268.                                     }
  269.                                     break;
  270.                                 case EMS_ALIGN_CENTER:
  271.                                     if (default_direction == BIDI_L)
  272.                                     {
  273.                                         tx = center_x - (line_width >> 1);
  274.                                     }
  275.                                     else
  276.                                     {
  277.                                         tx = center_x + (line_width >> 1);
  278.                                     }
  279.                                     break;
  280.                                 case EMS_ALIGN_LANG_DEP:
  281.                                     if (default_direction == BIDI_L)
  282.                                     {
  283.                                         tx = x1 + 2;
  284.                                     }
  285.                                     else
  286.                                     {
  287.                                         tx = x1 + box_width;
  288.                                     }
  289.                                     break;
  290.                             }
  291.                         }
  292.                     }
  293.                     else
  294.                     {
  295.                         object_width = object_width_cache[line_object_count];
  296.                         object_height = object_height_cache[line_object_count];
  297.                         if (first_object_flag)
  298.                         {
  299.                             if (default_direction == BIDI_L)
  300.                             {
  301.                                 object_width += 1;
  302.                                 tx += 1;
  303.                             }
  304.                             else
  305.                             {
  306.                                 object_width += 1;
  307.                                 tx -= 1;
  308.                             }
  310.                         }
  311.                         else
  312.                         {
  313.                          if(default_direction == BIDI_L)
  314. {
  315. tx += 3;
  316. }                          
  317.                         }
  318.                         if (default_direction == BIDI_R)
  319.                         {
  320.                             tx -= object_width;
  321.                             cursor_ax -= object_width;
  322.                         }
  323.                         /* MTK end */
  324.                         if (!(((-1) != move_to_x) || ((-1) != move_to_y)))
  325.                         {
  326.                             if ((mapped_cursor_position.Object != NULL) &&
  327.                                 (mapped_previous_position.Object != NULL) &&
  328.                                 (mapped_previous_position.OffsetToText == mapped_cursor_position.OffsetToText) &&
  329.                                 (mapped_previous_position.Object == mapped_cursor_position.Object))
  330.                             {
  331.                                 b->cursor_ax = cursor_ax;
  332.                                 b->cursor_ay = cursor_ay;
  333.                                 b->cursor_line_height = line_height;
  334.                                 b->cursor_line_position = line_object_count;
  335.                                 b->current_line = n_lines - 1;
  336.                                 if (!disable_draw_flag)
  337.                                 {
  338.                                     gui_EMS_input_box_display_object(
  339.                                         tx,
  340.                                         line_height - object_height + ty,
  341.                                         current_object,
  342.                                         1);
  343.                                     if (!(flags & UI_EMS_INPUT_BOX_DISABLE_CURSOR_DRAW))
  344.                                     {
  345.                                         /* MTK Terry for EMS Multitap Highlight Issue */
  346.                                         if (overwrite_mode_flag ||
  347.                                             selection_flag && !(flags & UI_EMS_INPUT_BOX_STATE_MULTITAP))
  348.                                         {
  349.                                             S32 rx1, ry1, rx2, ry2;
  351.                                             rx1 = tx;
  352.                                             ry1 = line_height - object_height + ty;
  353.                                             rx2 = rx1 + object_width - 1;
  354.                                             ry2 = ry1 + object_height - 1;
  355.                                             gui_cross_hatch_fill_rectangle(rx1, ry1, rx2, ry2, b->selection_color);
  356.                                         }
  358.                                         if (default_direction != BIDI_L)
  359.                                             /* PMT START MAUI_00223197 */
  360.                                         {
  361.                                         #ifdef __MMI_HINDI_ALG__
  362.                                             if (UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  363.                                             {
  364.                                                 S32 h, w;
  366.                                                 gui_measure_character(pre_character, &w, &h);
  367.                                                 gui_show_EMS_input_box_cursor(
  368.                                                     b,
  369.                                                     tx + object_width,
  370.                                                     ty,
  371.                                                     object_width,
  372.                                                     h,
  373.                                                     2);
  374.                                             }
  375.                                             else
  376.                                         #endif /* __MMI_HINDI_ALG__ */ 
  377.                                             {
  378.                                                 /* PMT END MAUI_00223197 */
  379.                                                 gui_show_EMS_input_box_cursor(
  380.                                                     b,
  381.                                                     tx + object_width,
  382.                                                     line_height - object_height + ty,
  383.                                                     object_width,
  384.                                                     object_height,
  385.                                                     2);
  386.                                                 /* PMT START MAUI_00223197 */
  387.                                             }
  388.                                         }
  389.                                         else
  390.                                         {
  391.                                         #ifdef __MMI_HINDI_ALG__
  392.                                             if (UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  393.                                             {
  394.                                                 S32 h, w;
  396.                                                 gui_measure_character(pre_character, &w, &h);
  397.                                                 gui_show_EMS_input_box_cursor(b, tx, ty, object_width, h, 2);
  398.                                             }
  399.                                             else
  400.                                         #endif /* __MMI_HINDI_ALG__ */ 
  401.                                             {
  402.                                                 /* PMT END MAUI_00223197 */
  403.                                                 gui_show_EMS_input_box_cursor(
  404.                                                     b,
  405.                                                     tx,
  406.                                                     line_height - object_height + ty,
  407.                                                     object_width,
  408.                                                     object_height,
  409.                                                     2);
  410.                                                 /* PMT START MAUI_00223197 */
  411.                                             }
  412.                                         }
  414.                                     }
  415.                                     else if (EMS_view_mode)
  416.                                     {
  417.                                     #ifdef __MMI_HINDI_ALG__
  418.                                         if (UI_HINDI_CHARACTER_UCS2_RANGE(pre_character))
  419.                                         {
  420.                                             S32 h, w;
  422.                                             gui_measure_character(pre_character, &w, &h);
  423.                                             gui_show_EMS_input_box_cursor(b, tx, ty, object_width, h, 3);
  424.                                         }
  425.                                         else
  426.                                     #endif /* __MMI_HINDI_ALG__ */ 
  427.                                         {
  428.                                             gui_show_EMS_input_box_cursor(
  429.                                                 b,
  430.                                                 tx,
  431.                                                 line_height - object_height + ty,
  432.                                                 object_width,
  433.                                                 object_height,
  434.                                                 3);
  435.                                         }
  436.                                     }
  437.                                     /* PMT END MAUI_00223197 */
  438.                                 }
  439.                                 cursor_displayed_flag = 1;
  440.                             }
  441.                             else if (!disable_draw_flag)
  442.                             {
  443.                                 gui_EMS_input_box_display_object(
  444.                                     tx,
  445.                                     line_height - object_height + ty,
  446.                                     current_object,
  447.                                     0);
  448.                             }
  449.                         }
  450.                         else if ((((-1) != move_to_x) || ((-1) != move_to_y)))
  451.                         {
  452.                             if (((tx + b->x + object_width) > move_to_x) &&
  453.                                 ((cursor_ay + line_height + b->y + b->display_y + b->header_height) > move_to_y) &&
  454.                                 (!set_cursor_flag))
  455.                             {
  456.                                 b->cursor_ax = cursor_ax;
  457.                                 b->cursor_ay = cursor_ay;
  458.                                 b->cursor_line_height = line_height;
  459.                                 b->cursor_line_position = line_object_count;
  460.                                 b->current_line = n_lines - 1;
  461.                                 /* EMS_map_position(data,&previous_position,&(data->CurrentPosition)); */
  462.                                 MoveCursorToPosition(data, &previous_position);
  463.                                 set_cursor_flag = 1;
  464.                             }
  465.                         }
  467.                         if (default_direction == BIDI_L)
  468.                         {
  469.                             tx += object_width;
  470.                             cursor_ax += object_width;
  471.                         }
  472.                         line_object_count++;
  473.                     }
  474.                     current_character = 0;
  475.                     break;
  476.                 #endif /* __MMI_MESSAGES_EMS__ */ 
  477.             }
  478.             first_object_flag = 0;
  479.         }
  481.     #ifdef __MMI_BIDI_ALG__
  482.         if (!(flags & UI_EMS_INPUT_BOX_DISABLE_DRAW) && arabic_char_flag)
  483.         {
  484.             memcpy(data->textBuffer + temp_text_position, temp_text_buffer, visual_str_len * ENCODING_LENGTH);
  485.             mapped_cursor_position.OffsetToText = temp_cursor_position;
  487.         #if 0
  488. /* under construction !*/
  489. /* under construction !*/
  490. /* under construction !*/
  491. /* under construction !*/
  492. /* under construction !*/
  493.         #endif /* 0 */ 
  495.         }
  496.     #endif /* __MMI_BIDI_ALG__ */ 
  498.         line_start_position = current_position;
  499.         if ((current_character == EMS_INPUTBOX_PARAGRAPH_BREAK_CHARACTER)
  500.     #if(EMS_SHOW_HORIZONTAL_RULE_FOR_NEWLINE)
  501.             || (UI_TEST_LF_CHARACTER(current_character) && (flags & UI_EMS_INPUT_BOX_NEWLINE_DRAW))
  502.     #endif 
  503.             )
  504.         {
  505.             if (!disable_draw_flag)
  506.             {
  507.                 EMS_EDITOR_DRAW_DOTTED_LINE(x1 + 2, x2 - 1, ty + line_height + 2, paragraph_color);
  508.             }
  509.             ty += 4;    /*  4=height of line break horizontal rule display  */
  510.             cursor_ay += 4;
  511.             b->display_height += 4;
  512.         }
  513.         /* START PMT NEERAJ 20050916 */
  514.     #if(EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES)
  515.         else
  516.         {
  517.             if (flags & UI_EMS_INPUT_BOX_ALL_LINE_DRAW)
  518.             {
  519.                 if (!disable_draw_flag)
  520.                 {
  521.                     UI_draw_horizontal_line(x1 + 2, x2 - 1, ty + line_height + 2, gui_color(112, 125, 240));
  522.                     last_line_y = ty + line_height + 2;
  523.                     line_height += 4;
  524.                 }
  525.                 else
  526.                 {
  527.                     line_height += 4;
  528.                 }
  529.             }
  530.         }
  531.     #endif /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  532.         /* END PMT NEERAJ 20050916 */
  533.         line_height += 1;   /*  +1 added for 1 pixel gap between lines */
  534.         ty += line_height;
  535.         cursor_ay += line_height;
  536.         b->display_height += line_height;
  537.     }
  538.     b->n_lines = n_lines;
  539.     /* START PMT NEERAJ 20050916 */
  540. #if(EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES)
  541.     if (flags & UI_EMS_INPUT_BOX_ALL_LINE_DRAW)
  542.     {      
  543.         minimum_line_height = object_height;
  544.         if (!disable_draw_flag)
  545.         {
  546.             while (last_line_y <= y2)
  547.             {
  548.                 last_line_y += minimum_line_height + 5;
  549.                 UI_draw_horizontal_line(x1 + 2, x2 - 1, last_line_y, gui_color(112, 125, 240));
  550.             }
  551. /*            if (EMS_view_mode)
  552.             {
  553.             #if defined(__MMI_MAINLCD_240X320__)
  554.                     if (last_line_y - y2 <= minimum_line_height - 13 && b->display_y != 0)
  555.             #elif defined(__MMI_MAINLCD_128X128__)
  556.                 if (last_line_y - y2 <= minimum_line_height - 12 && b->display_y != 0)
  557.             #else 
  558.                 if (last_line_y - y2 <= minimum_line_height - 11 && b->display_y != 0)
  559.             #endif 
  560.                 {
  561.                     b->display_y -= 3;
  562.                 }
  563.             }*/
  564.         }
  565.     }
  566. #endif /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  567.     /* END PMT NEERAJ 20050916 */
  568.     /* W06.12 cursor_displayed_flag is only used when not moving cusrsor by pen */
  569.     if (!cursor_displayed_flag && ((move_to_x == (-1)) && (move_to_y == (-1))))
  570.     {
  571.         cursor_ay -= (line_height);
  572.         b->cursor_ax = cursor_ax;
  573.         b->cursor_ay = cursor_ay;
  574.         b->cursor_line_height = line_height - 1;
  575.         b->cursor_line_position = line_object_count;
  576.         b->current_line = n_lines - 1;
  577.         if (!disable_draw_flag && !(flags & UI_EMS_INPUT_BOX_DISABLE_CURSOR_DRAW))
  578.         {
  579.             /* START PMT NEERAJ 20050916 */
  580.         #if(EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES)
  581.         #ifdef __MMI_HINDI_ALG__
  582.             if (flags & UI_EMS_INPUT_BOX_ALL_LINE_DRAW)
  583.             {
  584.                 gui_show_EMS_input_box_cursor(b, tx + 1, ty - line_height, 0, line_height - 5, 1);
  585.             }
  586.             else
  587.             {
  588.                 gui_show_EMS_input_box_cursor(b, tx + 1, ty - line_height, 0, line_height - 1, 1);
  589.             }
  590.         #else /* __MMI_HINDI_ALG__ */ 
  591.             if (flags & UI_EMS_INPUT_BOX_ALL_LINE_DRAW)
  592.             {
  593.                 gui_show_EMS_input_box_cursor(b, tx, ty - line_height, 0, line_height - 5, 1);
  594.             }
  595.             else
  596.             {
  597.                 gui_show_EMS_input_box_cursor(b, tx, ty - line_height, 0, line_height - 1, 1);
  598.             }
  599.         #endif /* __MMI_HINDI_ALG__ */ 
  600.         #else /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  601.             /* END PMT NEERAJ 20050916 */
  602.         #ifdef __MMI_HINDI_ALG__
  603.             /* if( UI_HINDI_CHARACTER_UCS2_RANGE(pre_character)) */
  604.             gui_show_EMS_input_box_cursor(b, tx + 1, ty - line_height, 0, line_height - 1, 1);
  605.         #else /* __MMI_HINDI_ALG__ */ 
  606.             gui_show_EMS_input_box_cursor(b, tx, ty - line_height, 0, line_height - 1, 1);
  607.         #endif /* __MMI_HINDI_ALG__ */ 
  608.             /* START PMT NEERAJ 20050916 */
  609.         #endif /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  610.             /* END PMT NEERAJ 20050916 */
  611.         }
  612.         cursor_ay += line_height;
  613.     }
  614.     if ((((-1) != move_to_x) || ((-1) != move_to_y)) && (!set_cursor_flag))
  615.     {
  616.         cursor_ay -= (line_height);
  617.         b->cursor_ax = cursor_ax;
  618.         b->cursor_ay = cursor_ay;
  619.         b->cursor_line_height = line_height - 1;
  620.         b->cursor_line_position = line_object_count;
  621.         b->current_line = n_lines - 1;
  622.         /* EMS_map_position(data,&current_position,&(data->CurrentPosition)); */
  623.         MoveCursorToPosition(data, &current_position);
  624.         //W05.34 Fix warning tone in stylus on the blank area
  625.         //gui_EMS_input_box_next(b);
  626.         cursor_ay += line_height;
  627.     }
  628. #if(EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES)
  629.     /* W06.16 If EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES, the height of the last line is different */
  630.     if ((flags & UI_EMS_INPUT_BOX_ALL_LINE_DRAW) && (b->current_line == (b->n_lines - 1)))
  631.     {
  632.         b->cursor_line_height = line_height;
  633.     }
  634. #endif /* (EMS_SHOW_HORIZONTAL_RULE_FOR_ALL_LINES) */ 
  635.     if (b->saved_cursor_ax == -1)
  636.     {
  637.         b->saved_cursor_ax = b->cursor_ax;
  638.     }
  639.     /* W06.16 Set text format after changing cursor position by pen */
  640.     if ((!EMS_view_mode) && (((-1) != move_to_x) || ((-1) != move_to_y)))
  641.     {
  642.         gui_EMS_input_box_set_text_format_cursor_position(b);
  643.     }
  644.     if (!disable_draw_flag && !(flags & UI_EMS_INPUT_BOX_DISABLE_SCROLLBAR))
  645.     {
  646.         if (flags & UI_EMS_INPUT_BOX_DISPLAY_HEADER)
  647.         {
  648.             gui_set_vertical_scrollbar_scale(&b->vbar, b->height - 2);
  649.             gui_set_vertical_scrollbar_range(&b->vbar, cursor_ay + b->header_height);
  650.             gui_set_vertical_scrollbar_value(&b->vbar, -b->display_y);
  651.         }
  652.         else
  653.         {
  654.             gui_set_vertical_scrollbar_scale(&b->vbar, b->height - 2);
  655.             /* W06.12 Use b->display_height + 2 instead of cursor_ay 
  656.                1.cursor_ay is different when the cusrosr at the last line
  657.                2.(+2)because that the box_height is b->height - 4 in gui_EMS_input_box_locate_cursor */
  658.             gui_set_vertical_scrollbar_range(&b->vbar, b->display_height + 2);
  659.             /* gui_set_vertical_scrollbar_range(    &b->vbar,       cursor_ay               ); */
  660.             gui_set_vertical_scrollbar_value(&b->vbar, -b->display_y);
  661.         }
  662.         if (flags & UI_EMS_INPUT_BOX_AUTO_DISABLE_SCROLLBAR)
  663.         {
  664.             if (b->vbar.scale < b->vbar.range)
  665.             {
  666.                 if (r2lMMIFlag)
  667.                 {
  668.                     vbar_x = b->vbar.x;
  669.                     vbar_button_x = b->vbar.scroll_button.x;
  670.                     b->vbar.x = b->vbar.x + b->vbar.width - b->width;
  671.                     b->vbar.scroll_button.x = b->vbar.scroll_button.x + b->vbar.scroll_button.width - b->width;
  672.                     gui_show_vertical_scrollbar(&b->vbar);
  673.                 }
  674.                 else
  675.                 {
  676.                     gui_show_vertical_scrollbar(&b->vbar);
  677.                 }
  678.                 if (r2lMMIFlag)
  679.                 {
  680.                     b->vbar.x = vbar_x;
  681.                     b->vbar.scroll_button.x = vbar_button_x;
  682.                 }
  684.             }
  686.         }
  687.         else
  688.         {
  689.             if (r2lMMIFlag)
  690.             {
  691.                 vbar_x = b->vbar.x;
  692.                 vbar_button_x = b->vbar.scroll_button.x;
  693.                 b->vbar.x = b->vbar.x + b->vbar.width - b->width;
  694.                 b->vbar.scroll_button.x = b->vbar.scroll_button.x + b->vbar.scroll_button.width - b->width;
  695.                 gui_show_vertical_scrollbar(&b->vbar);
  696.             }
  697.             else
  698.             {
  699.                 gui_show_vertical_scrollbar(&b->vbar);
  700.             }
  701.             if (r2lMMIFlag)
  702.             {
  703.                 b->vbar.x = vbar_x;
  704.                 b->vbar.scroll_button.x = vbar_button_x;
  705.             }
  707.         }
  709.     }
  711.     /* Handle next line, previous line navigation   */
  712.     if (disable_draw_flag)
  713.     {
  714.         if (flags & UI_EMS_INPUT_BOX_PREVIOUS_LINE)
  715.         {
  716.             if (EMS_view_mode)
  717.             {
  718.                 S32 fdl = b->first_displayed_line;
  719.                 EMSPosition new_position;
  721.                 if (data->listHead == NULL)
  722.                 {
  723.                     b->current_line = fdl;
  724.                     if (b->current_line > 0)
  725.                     {
  726.                         b->current_line--;
  727.                     }
  728.                     else
  729.                     {
  730.                         b->cursor_ay = 0;
  731.                     }
  732.                     new_position = b->line_positions[b->current_line];
  733.                     MoveCursorToPosition(data, &new_position);
  734.                 }
  735.                 else
  736.                 {
  737.                     if ((data->CurrentPosition.OffsetToText > 0) || (data->CurrentPosition.Object != NULL))
  738.                     {
  739.                         EMSPosition new_position;
  740.                         U8 flag;
  741.                         U8 done = 0;
  743.                         while (!done)
  744.                         {
  745.                             flag = 0;
  746.                             if (b->current_line > 0)
  747.                             {
  748.                                 flag = 1;
  749.                                 b->current_line--;
  750.                             }
  751.                             else
  752.                             {
  753.                                 b->cursor_ay = 0;
  754.                             }
  756.                             new_position = b->line_positions[b->current_line];
  757.                             if (BackwardCurrentPositionObject(data, &new_position))
  758.                             {
  759.                                 if (flag)
  760.                                 {
  761.                                     b->current_line++;
  762.                                 }
  763.                             }
  764.                             else
  765.                             {
  766.                                 break;
  767.                             }
  768.                             if (b->current_line > 0)
  769.                             {
  770.                                 b->current_line--;
  771.                             }
  772.                             else
  773.                             {
  774.                                 break;
  775.                             }
  776.                             if (b->current_line <= (fdl - 1))
  777.                             {
  778.                                 break;
  779.                             }
  780.                         }
  781.                     }
  782.                 }
  783.             }
  784.             else
  785.             {
  786.                 if (b->current_line > 0)
  787.                 {
  788.                     EMSPosition new_position;
  789.                     S32 object_count = b->cursor_line_position;
  790.                     S32 new_position_object_count;
  792.                     b->current_line--;
  793.                     new_position = b->line_positions[b->current_line];
  794.                     new_position_object_count = b->line_object_counts[b->current_line] - 1;
  795.                     if (object_count > new_position_object_count)
  796.                     {
  797.                         object_count = new_position_object_count;
  798.                     }
  799.                     MoveCursorToPosition(data, &new_position);
  800.                 #if(EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT)
  801.                     EMS_move_graphical_cursor(
  802.                         data,
  803.                         b->line_x_positions[b->current_line],
  804.                         b->saved_cursor_ax,
  805.                         new_position_object_count);
  806.                 #else /* (EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT) */ 
  807.                     ForwardCurrentPosition(data, (U16) object_count);
  808.                 #endif /* (EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT) */ 
  809.                 }
  810.                 else
  811.                 {
  812.                     if (flags & UI_EMS_INPUT_BOX_DISABLE_TONE)
  813.                     {
  814.                         b->flags &= ~UI_EMS_INPUT_BOX_DISABLE_TONE;
  815.                     }
  816.                     else
  817.                     {
  818.                         UI_editor_play_tone_cannot_navigate();
  819.                     }
  820.                 }
  821.             }
  822.             /* MTK Terry for scroll down problem for extension character in EMS_view_mode temp solution */
  823.             if (!EMS_view_mode)
  824.             {
  825.                 EMS_handle_CRLF_navigation(data);
  826.             }
  827.             /* if(!TestFirstPosition(data,&data->CurrentPosition)) */
  828.             gui_EMS_input_box_set_text_format_cursor_position(b);
  829.         }
  830.         else if (flags & UI_EMS_INPUT_BOX_PREVIOUS_OBJECT)
  831.         {
  832.             if (EMS_view_mode && (data->listHead != NULL))
  833.             {
  834.                 if ((data->CurrentPosition.OffsetToText > 0) || (data->CurrentPosition.Object != NULL))
  835.                 {
  836.                     EMSPosition new_position;
  838.                     new_position = b->line_positions[b->current_line];
  839.                     BackwardCurrentPositionSeekObject(data, &new_position);
  840.                 }
  841.             }
  842.         }
  843.         if (flags & UI_EMS_INPUT_BOX_NEXT_LINE)
  844.         {
  845.             if (EMS_view_mode)
  846.             {
  847.                 S32 ldl = b->last_displayed_line;
  848.                 EMSPosition new_position;
  850.                 if (data->listHead == NULL)
  851.                 {
  852.                     b->current_line = ldl;
  853.                     if (b->current_line < (b->n_lines - 1))
  854.                     {
  855.                         b->current_line++;
  856.                     }
  857.                     new_position = b->line_positions[b->current_line];
  858.                     MoveCursorToPosition(data, &new_position);
  859.                 }
  860.                 else
  861.                 {
  862.                     if (!TestLastPosition(data, &data->CurrentPosition))
  863.                     {
  864.                         EMSPosition new_position, old_position;
  865.                         U8 flag;
  866.                         U8 done = 0;
  868.                         while (!done)
  869.                         {
  870.                             flag = 0;
  871.                             if (b->current_line < (b->n_lines - 1))
  872.                             {
  873.                                 flag = 1;
  874.                                 b->current_line++;
  875.                             }
  876.                             new_position = b->line_positions[b->current_line];
  877.                             if (ForwardCurrentPositionObject(data, &new_position))
  878.                             {
  879.                                 if (flag)
  880.                                 {
  881.                                     b->current_line--;
  882.                                 }
  883.                             }
  884.                             else
  885.                             {
  886.                                 break;
  887.                             }
  888.                             flag = 0;
  889.                             if (b->current_line < (b->n_lines - 1))
  890.                             {
  891.                                 new_position = b->line_positions[b->current_line + 1];
  892.                             }
  893.                             else
  894.                             {
  895.                                 new_position.OffsetToText = data->textLength;
  896.                                 new_position.Object = data->listTail;
  897.                                 flag = 1;
  898.                             }
  899.                             old_position = data->CurrentPosition;
  900.                             if (ForwardCurrentPositionObject(data, &new_position))
  901.                             {
  902.                                 if (!flag)
  903.                                 {
  904.                                     MoveCursorToPosition(data, &old_position);
  905.                                 }
  906.                             }
  907.                             else
  908.                             {
  909.                                 break;
  910.                             }
  911.                             if (b->current_line < (b->n_lines - 1))
  912.                             {
  913.                                 b->current_line++;
  914.                             }
  915.                             else
  916.                             {
  917.                                 break;
  918.                             }
  919.                             if (b->current_line >= (ldl + 1))
  920.                             {
  921.                                 break;
  922.                             }
  923.                         }
  924.                     }
  925.                 }
  926.             }
  927.             else
  928.             {
  929.                 if (b->current_line < (b->n_lines - 1))
  930.                 {
  931.                     EMSPosition new_position;
  932.                     S32 object_count = b->cursor_line_position;
  933.                     S32 new_position_object_count;
  935.                     b->current_line++;
  936.                     new_position = b->line_positions[b->current_line];
  937.                     new_position_object_count = b->line_object_counts[b->current_line];
  938.                     if (b->current_line != (b->n_lines - 1))
  939.                     {
  940.                         new_position_object_count -= 1;
  941.                     }
  942.                     if (object_count > new_position_object_count)
  943.                     {
  944.                         object_count = new_position_object_count;
  945.                     }
  946.                     MoveCursorToPosition(data, &new_position);
  947.                 #if(EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT)
  948.                     EMS_move_graphical_cursor(
  949.                         data,
  950.                         b->line_x_positions[b->current_line],
  951.                         b->saved_cursor_ax,
  952.                         new_position_object_count);
  953.                 #else /* (EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT) */ 
  954.                     ForwardCurrentPosition(data, (U16) object_count);
  955.                 #endif /* (EMS_ENABLE_GRAPHICAL_CURSOR_MOVEMENT) */ 
  956.                 }
  957.                 else
  958.                 {
  959.                     if (flags & UI_EMS_INPUT_BOX_DISABLE_TONE)
  960.                     {
  961.                         b->flags &= ~UI_EMS_INPUT_BOX_DISABLE_TONE;
  962.                     }
  963.                     else
  964.                     {
  965.                         UI_editor_play_tone_cannot_navigate();
  966.                     }
  967.                 }
  968.             }
  969.             /* MTK Terry for scroll down problem for extension character in EMS_view_mode temp solution */
  970.             if (!EMS_view_mode)
  971.             {
  972.                 EMS_handle_CRLF_navigation(data);
  973.             }
  974.             /* if(!TestLastPosition(data,&data->CurrentPosition)) */
  975.             gui_EMS_input_box_set_text_format_cursor_position(b);
  976.         }
  977.         else if (flags & UI_EMS_INPUT_BOX_NEXT_OBJECT)
  978.         {
  979.             if (EMS_view_mode && (data->listHead != NULL))
  980.             {
  981.                 if (!TestLastPosition(data, &data->CurrentPosition))
  982.                 {
  983.                     EMSPosition new_position;
  985.                     if (b->current_line >= (b->n_lines - 1))
  986.                     {
  987.                         new_position.OffsetToText = data->textLength;
  988.                         new_position.Object = data->listTail;
  989.                     }
  990.                     else
  991.                     {
  992.                         new_position = b->line_positions[b->current_line + 1];
  993.                     }
  994.                     ForwardCurrentPositionSeekObject(data, &new_position);
  995.                 }
  996.             }
  997.         }
  998.     }
  1000. #if 0
  1001. #ifdef __MMI_BIDI_ALG__
  1002. /* under construction !*/
  1003. /* under construction !*/
  1004. /* under construction !*/
  1005. /* under construction !*/
  1006. /* under construction !*/
  1007. /* under construction !*/
  1008. /* under construction !*/
  1009. /* under construction !*/
  1010. /* under construction !*/
  1011. /* under construction !*/
  1012. /* under construction !*/
  1013. /* under construction !*/
  1014. /* under construction !*/
  1015.   #endif
  1016. #endif /* 0 */ 
  1017. #ifdef __MMI_BIDI_ALG__
  1018.     UI_UNUSED_PARAMETER(temp_hilight_start);
  1019.     UI_UNUSED_PARAMETER(temp_hilight_end);
  1020.     UI_UNUSED_PARAMETER(temp_text_pt);
  1021. #endif /* __MMI_BIDI_ALG__ */ 
  1022.     /* PMT RAKESH START 20061006 */
  1023. #if defined __MMI_HINDI_ALG__
  1024.     restore_current_language_for_hindi_rules();
  1025. #endif 
  1026.     /* PMT RAKESH END 20061006 */
  1028. }
  1031. /*****************************************************************************
  1032.  * FUNCTION
  1033.  *  gui_EMS_input_box_toggle_insert_mode
  1034.  * DESCRIPTION
  1035.  *  
  1036.  * PARAMETERS
  1037.  *  b       [?]     
  1038.  * RETURNS
  1039.  *  void
  1040.  *****************************************************************************/
  1041. void gui_EMS_input_box_toggle_insert_mode(UI_EMS_input_box *b)
  1042. {
  1043.     /*----------------------------------------------------------------*/
  1044.     /* Local Variables                                                */
  1045.     /*----------------------------------------------------------------*/
  1047.     /*----------------------------------------------------------------*/
  1048.     /* Code Body                                                      */
  1049.     /*----------------------------------------------------------------*/
  1050. #ifdef __MMI_MESSAGES_EMS__
  1051.     EMS_cancel_object_focus();
  1052. #endif 
  1053.     if (b->flags & UI_EMS_INPUT_BOX_OVERWRITE_MODE)
  1054.     {
  1055.         b->flags &= ~UI_EMS_INPUT_BOX_OVERWRITE_MODE;
  1056.     }
  1057.     else
  1058.     {
  1059.         b->flags |= UI_EMS_INPUT_BOX_OVERWRITE_MODE;
  1060.     }
  1061. }
  1064. /*****************************************************************************
  1065.  * FUNCTION
  1066.  *  gui_EMS_input_box_backspace
  1067.  * DESCRIPTION
  1068.  *  
  1069.  * PARAMETERS
  1070.  *  b       [?]     
  1071.  * RETURNS
  1072.  *  void
  1073.  *****************************************************************************/
  1074. void gui_EMS_input_box_backspace(UI_EMS_input_box *b)
  1075. {
  1076.     /*----------------------------------------------------------------*/
  1077.     /* Local Variables                                                */
  1078.     /*----------------------------------------------------------------*/
  1079.     U8 paragraph_text_align_flag = 0;
  1080.     U8 previous_paragraph_text_alignment = EMS_ALIGN_LANG_DEP;
  1081.     EMSPosition current_position;
  1082.     UI_character_type c;
  1083.     EMSObject *o;
  1085.     /*----------------------------------------------------------------*/
  1086.     /* Code Body                                                      */
  1087.     /*----------------------------------------------------------------*/
  1088. #ifdef __MMI_MESSAGES_EMS__
  1089.     EMS_cancel_object_focus();
  1090. #endif 
  1091.     if ((b->data != NULL) && (b->data->listHead != NULL))
  1092.     {
  1093.         current_position = b->data->CurrentPosition;
  1094.         if (gui_EMS_input_box_test_paragraph_start(b, &current_position))
  1095.         {
  1096.             gui_EMS_input_box_get_previous_object(b->data, &current_position, &c, &o);
  1097.             previous_paragraph_text_alignment = gui_EMS_input_box_get_previous_text_alignment(b, &current_position);
  1098.             paragraph_text_align_flag = 1;
  1099.         }
  1100.     }
  1101.     if (gui_EMS_cancel_current_position(b) == 0)
  1102.     {
  1103.         UI_editor_play_tone_cannot_change();
  1104.     }
  1105.     else
  1106.     {
  1107.         
  1108.         if (b->locate_cursor_flag)
  1109.         {
  1110.             gui_EMS_input_box_locate_cursor(b);
  1111.         }
  1112.         
  1113.         gui_EMS_input_box_set_text_format_cursor_position(b);
  1114.         if (paragraph_text_align_flag)
  1115.         {
  1116.             current_position = b->data->CurrentPosition;
  1117.             gui_EMS_input_box_set_paragraph_text_alignment(b, &current_position, previous_paragraph_text_alignment);
  1118.         }
  1119.     }
  1120.     b->saved_cursor_ax = -1;
  1121. }
  1124. /*****************************************************************************
  1125.  * FUNCTION
  1126.  *  gui_EMS_input_box_previous_line
  1127.  * DESCRIPTION
  1128.  *  
  1129.  * PARAMETERS
  1130.  *  b       [?]     
  1131.  * RETURNS
  1132.  *  void
  1133.  *****************************************************************************/
  1134. void gui_EMS_input_box_previous_line(UI_EMS_input_box *b)
  1135. {
  1136.     /*----------------------------------------------------------------*/
  1137.     /* Local Variables                                                */
  1138.     /*----------------------------------------------------------------*/
  1139.     U8 hflag = 0;
  1140.     EMSPosition current_position = b->data->CurrentPosition;
  1142.     /*----------------------------------------------------------------*/
  1143.     /* Code Body                                                      */
  1144.     /*----------------------------------------------------------------*/
  1145. #ifdef __MMI_MESSAGES_EMS__
  1146.     EMS_cancel_object_focus();
  1147. #endif 
  1148. if(b->cursor_ay == 0 && b->display_y <0)
  1149. {
  1150. b->display_y +=20;
  1151. if(b->display_y >0) b->display_y = 0;
  1152. return;
  1153. }
  1154.     b->flags |= (UI_EMS_INPUT_BOX_PREVIOUS_LINE | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1155.     gui_show_EMS_input_box(b);
  1156.     b->flags &= ~(UI_EMS_INPUT_BOX_PREVIOUS_LINE | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1157.     if (b->cursor_ay == 0)
  1158.     {
  1159.         hflag = 1;
  1160.     }
  1161.     /* if(!TestFirstPosition(b->data,&current_position)) */
  1162.     gui_EMS_input_box_locate_cursor(b);
  1163.     if ((b->flags & UI_EMS_INPUT_BOX_DISPLAY_HEADER) && hflag
  1164.         && (b->cursor_ay == 0) && (b->display_y != 0) &&
  1165.         (current_position.Object == NULL) /* && TestFirstPosition(b->data,&current_position) */ )
  1166.     {
  1167.         b->flags |= UI_EMS_INPUT_BOX_DISABLE_TONE;
  1168.         b->display_y += EMS_HEADER_SCROLL_SIZE; /* Scroll through header   */
  1169.         if (b->display_y > 0)
  1170.         {
  1171.             b->display_y = 0;
  1172.         }
  1173.     }
  1174. }
  1177. /*****************************************************************************
  1178.  * FUNCTION
  1179.  *  gui_EMS_input_box_next_line
  1180.  * DESCRIPTION
  1181.  *  
  1182.  * PARAMETERS
  1183.  *  b       [?]     
  1184.  * RETURNS
  1185.  *  void
  1186.  *****************************************************************************/
  1187. void gui_EMS_input_box_next_line(UI_EMS_input_box *b)
  1188. {
  1189.     /*----------------------------------------------------------------*/
  1190.     /* Local Variables                                                */
  1191.     /*----------------------------------------------------------------*/
  1193.     /*----------------------------------------------------------------*/
  1194.     /* Code Body                                                      */
  1195.     /*----------------------------------------------------------------*/
  1196. #ifdef __MMI_MESSAGES_EMS__
  1197.     EMS_cancel_object_focus();
  1198. #endif 
  1199.     b->flags |= (UI_EMS_INPUT_BOX_NEXT_LINE | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1200.     gui_show_EMS_input_box(b);
  1201.     b->flags &= ~(UI_EMS_INPUT_BOX_NEXT_LINE | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1202.     /* if(!TestLastPosition(b->data,&b->data->CurrentPosition)) */
  1203.     gui_EMS_input_box_locate_cursor(b);
  1204. }
  1206. #ifdef __MMI_MESSAGES_EMS__
  1209. /*****************************************************************************
  1210.  * FUNCTION
  1211.  *  gui_EMS_input_box_view_previous_object
  1212.  * DESCRIPTION
  1213.  *  
  1214.  * PARAMETERS
  1215.  *  b       [?]     
  1216.  * RETURNS
  1217.  *  void
  1218.  *****************************************************************************/
  1219. void gui_EMS_input_box_view_previous_object(UI_EMS_input_box *b)
  1220. {
  1221.     /*----------------------------------------------------------------*/
  1222.     /* Local Variables                                                */
  1223.     /*----------------------------------------------------------------*/
  1225.     /*----------------------------------------------------------------*/
  1226.     /* Code Body                                                      */
  1227.     /*----------------------------------------------------------------*/
  1228.     EMS_cancel_object_focus();
  1229.     b->flags |= (UI_EMS_INPUT_BOX_PREVIOUS_OBJECT | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1230.     gui_show_EMS_input_box(b);
  1231.     b->flags &= ~(UI_EMS_INPUT_BOX_PREVIOUS_OBJECT | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1232.     gui_EMS_input_box_locate_cursor(b);
  1233.     b->saved_cursor_ax = -1;
  1234. }
  1237. /*****************************************************************************
  1238.  * FUNCTION
  1239.  *  gui_EMS_input_box_view_next_object
  1240.  * DESCRIPTION
  1241.  *  
  1242.  * PARAMETERS
  1243.  *  b       [?]     
  1244.  * RETURNS
  1245.  *  void
  1246.  *****************************************************************************/
  1247. void gui_EMS_input_box_view_next_object(UI_EMS_input_box *b)
  1248. {
  1249.     /*----------------------------------------------------------------*/
  1250.     /* Local Variables                                                */
  1251.     /*----------------------------------------------------------------*/
  1253.     /*----------------------------------------------------------------*/
  1254.     /* Code Body                                                      */
  1255.     /*----------------------------------------------------------------*/
  1256.     EMS_cancel_object_focus();
  1257.     b->flags |= (UI_EMS_INPUT_BOX_NEXT_OBJECT | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1258.     gui_show_EMS_input_box(b);
  1259.     b->flags &= ~(UI_EMS_INPUT_BOX_NEXT_OBJECT | UI_EMS_INPUT_BOX_DISABLE_DRAW);
  1260.     gui_EMS_input_box_locate_cursor(b);
  1261.     b->saved_cursor_ax = -1;
  1262. }
  1263. #endif /* __MMI_MESSAGES_EMS__ */ 
  1266. /*****************************************************************************
  1267.  * FUNCTION
  1268.  *  gui_EMS_inputbox_empty
  1269.  * DESCRIPTION
  1270.  *  
  1271.  * PARAMETERS
  1272.  *  b       [?]     
  1273.  * RETURNS
  1274.  *  
  1275.  *****************************************************************************/
  1276. U8 gui_EMS_inputbox_empty(UI_EMS_input_box *b)
  1277. {
  1278.     /*----------------------------------------------------------------*/
  1279.     /* Local Variables                                                */
  1280.     /*----------------------------------------------------------------*/
  1282.     /*----------------------------------------------------------------*/
  1283.     /* Code Body                                                      */
  1284.     /*----------------------------------------------------------------*/
  1285.     if ((b->data->textLength == 0) && (b->data->listHead == NULL))
  1286.     {
  1287.         return (1);
  1288.     }
  1289.     else
  1290.     {
  1291.         return (0);
  1292.     }
  1293. }
  1296. /*****************************************************************************
  1297.  * FUNCTION
  1298.  *  gui_EMS_input_box_highlight_cursor_end
  1299.  * DESCRIPTION
  1300.  *  
  1301.  * PARAMETERS
  1302.  *  b       [?]     
  1303.  * RETURNS
  1304.  *  
  1305.  *****************************************************************************/
  1306. S32 gui_EMS_input_box_highlight_cursor_end(UI_EMS_input_box *b)
  1307. {
  1308.     /*----------------------------------------------------------------*/
  1309.     /* Local Variables                                                */
  1310.     /*----------------------------------------------------------------*/
  1311.     EMSPosition *current_position = &b->data->CurrentPosition;
  1312.     EMSPosition previous_position;
  1313.     EMSPosition saved_current_position = b->data->CurrentPosition;
  1314.     U8 done = 0, bflag;
  1315.     UI_character_type current_character;
  1316.     S32 count = 0;
  1318.     /*----------------------------------------------------------------*/
  1319.     /* Code Body                                                      */
  1320.     /*----------------------------------------------------------------*/
  1321.     /* Move cursor backwards until a break character is encountered   */
  1322.     while (!done)
  1323.     {
  1324.         previous_position = *current_position;
  1325.         if ((current_position->Object != NULL) &&
  1326.             (current_position->Object->OffsetToText == current_position->OffsetToText))
  1327.         {
  1328.             break;
  1329.         }
  1330.         if (current_position->OffsetToText == 0)
  1331.         {
  1332.             break;
  1333.         }
  1334.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1335.         {
  1336.             break;
  1337.         }
  1338.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1339.         current_character =
  1340.             b->data->textBuffer[current_position->OffsetToText +
  1341.                                 1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1342.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1343.         current_character =
  1344.             b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1345.                                                                    textBuffer[current_position->OffsetToText + 1] << 8);
  1346.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1347.         count++;
  1348.         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1349.         if (bflag)
  1350.         {
  1351.             break;
  1352.         }
  1353.     }
  1354.     b->highlight_start_position = previous_position;
  1355.     /* *current_position=saved_current_position; */
  1356.     MoveCursorToPosition(b->data, &saved_current_position);
  1358.     /* Move cursor forwards until a break character is encountered */
  1359. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1360.     current_character =
  1361.         b->data->textBuffer[current_position->OffsetToText +
  1362.                             1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1363. #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1364.     current_character =
  1365.         b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1366.                                                                textBuffer[current_position->OffsetToText + 1] << 8);
  1367. #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1368.     UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1369.     if (b->data->CurrentPosition.OffsetToText >= b->data->textLength)
  1370.     {
  1371.         bflag = 1;
  1372.     }
  1373.     if (bflag)
  1374.     {
  1375.         done = 1;
  1376.         b->flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1377.     }
  1378.     else
  1379.     {
  1380.         done = 0;
  1381.         b->flags |= UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1382.     }
  1383.     while (!done)
  1384.     {
  1385.         if ((current_position->Object != NULL) &&
  1386.             (current_position->Object->OffsetToText == current_position->OffsetToText))
  1387.         {
  1388.             break;
  1389.         }
  1390.         if (current_position->OffsetToText >= b->data->textLength)
  1391.         {
  1392.             break;
  1393.         }
  1394.         if (ForwardCurrentPosition(b->data, 1) != 1)
  1395.         {
  1396.             break;
  1397.         }
  1398.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1399.         current_character =
  1400.             b->data->textBuffer[current_position->OffsetToText +
  1401.                                 1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1402.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1403.         current_character =
  1404.             b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1405.                                                                    textBuffer[current_position->OffsetToText + 1] << 8);
  1406.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1407.         count++;
  1408.         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1409.         if (bflag)
  1410.         {
  1411.             break;
  1412.         }
  1413.     }
  1414.     b->highlight_end_position = *current_position;
  1415.     gui_EMS_input_box_locate_cursor(b);
  1416.     return (count);
  1417. }
  1420. /*****************************************************************************
  1421.  * FUNCTION
  1422.  *  gui_EMS_input_box_highlight_cursor_number
  1423.  * DESCRIPTION
  1424.  *  
  1425.  * PARAMETERS
  1426.  *  b               [?]         
  1427.  *  numOfChar       [IN]        
  1428.  * RETURNS
  1429.  *  
  1430.  *****************************************************************************/
  1431. S32 gui_EMS_input_box_highlight_cursor_number(UI_EMS_input_box *b, S32 numOfChar)
  1432. {
  1433.     /*----------------------------------------------------------------*/
  1434.     /* Local Variables                                                */
  1435.     /*----------------------------------------------------------------*/
  1436.     EMSPosition *current_position = &b->data->CurrentPosition;
  1437.     EMSPosition saved_current_position = b->data->CurrentPosition;
  1438.     U8 bflag;
  1439.     UI_character_type current_character;
  1440.     S32 count = 0, i;
  1442.     /*----------------------------------------------------------------*/
  1443.     /* Code Body                                                      */
  1444.     /*----------------------------------------------------------------*/
  1445.     for (i = 0; i < numOfChar; i++)
  1446.     {
  1447.         if ((current_position->Object != NULL) &&
  1448.             (current_position->Object->OffsetToText == current_position->OffsetToText))
  1449.         {
  1450.             break;
  1451.         }
  1452.         if (current_position->OffsetToText == 0)
  1453.         {
  1454.             break;
  1455.         }
  1456.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1457.         {
  1458.             break;
  1459.         }
  1460.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1461.         current_character =
  1462.             b->data->textBuffer[current_position->OffsetToText +
  1463.                                 1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1464.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1465.         current_character =
  1466.             b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1467.                                                                    textBuffer[current_position->OffsetToText + 1] << 8);
  1468.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1469.         count++;
  1470.         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1471.         if (bflag)
  1472.         {
  1473.             break;
  1474.         }
  1475.     }
  1477.     b->highlight_start_position = *current_position;
  1478.     /* *current_position=saved_current_position; */
  1479.     MoveCursorToPosition(b->data, &saved_current_position);
  1481. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1482.     current_character =
  1483.         b->data->textBuffer[current_position->OffsetToText +
  1484.                             1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1485. #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1486.     current_character =
  1487.         b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1488.                                                                textBuffer[current_position->OffsetToText + 1] << 8);
  1489. #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1490.     UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1491.     if(current_character == (UI_character_type)0x20) bflag =0;
  1493.     if (bflag)
  1494.     {
  1495.         b->flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1496.     }
  1497.     else
  1498.     {
  1499.         b->flags |= UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1500.     }
  1501.     b->highlight_end_position = *current_position;
  1502.     
  1503.     if (b->locate_cursor_flag)
  1504.     {
  1505.         gui_EMS_input_box_locate_cursor(b);
  1506.     }
  1507.     
  1508.     return (count);
  1509. }
  1512. /*****************************************************************************
  1513.  * FUNCTION
  1514.  *  gui_EMS_input_box_highlight_cursor_start
  1515.  * DESCRIPTION
  1516.  *  
  1517.  * PARAMETERS
  1518.  *  b       [?]     
  1519.  * RETURNS
  1520.  *  
  1521.  *****************************************************************************/
  1522. S32 gui_EMS_input_box_highlight_cursor_start(UI_EMS_input_box *b)
  1523. {
  1524.     /*----------------------------------------------------------------*/
  1525.     /* Local Variables                                                */
  1526.     /*----------------------------------------------------------------*/
  1527.     EMSPosition *current_position = &b->data->CurrentPosition;
  1528.     EMSPosition previous_position;
  1529.     EMSPosition saved_current_position = b->data->CurrentPosition;
  1530.     U8 done = 0, bflag;
  1531.     UI_character_type current_character;
  1532.     S32 count = 0;
  1534.     /*----------------------------------------------------------------*/
  1535.     /* Code Body                                                      */
  1536.     /*----------------------------------------------------------------*/
  1537.     if (BackwardCurrentPosition(b->data, 1) != 1)
  1538.     {
  1539.         b->flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1540.         return (0);
  1541.     }
  1542.     /* Move cursor forwards until a break character is encountered */
  1543.     while (!done)
  1544.     {
  1545.         if ((current_position->Object != NULL) &&
  1546.             (current_position->Object->OffsetToText == current_position->OffsetToText))
  1547.         {
  1548.             break;
  1549.         }
  1550.         if (current_position->OffsetToText >= b->data->textLength)
  1551.         {
  1552.             break;
  1553.         }
  1554.         if (ForwardCurrentPosition(b->data, 1) != 1)
  1555.         {
  1556.             break;
  1557.         }
  1558.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1559.         current_character =
  1560.             b->data->textBuffer[current_position->OffsetToText +
  1561.                                 1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1562.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1563.         current_character =
  1564.             b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1565.                                                                    textBuffer[current_position->OffsetToText + 1] << 8);
  1566.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1567.         count++;
  1568.         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1569.         if (bflag)
  1570.         {
  1571.             break;
  1572.         }
  1573.     }
  1574.     b->highlight_end_position = *current_position;
  1575.     /* *current_position=saved_current_position; */
  1576.     MoveCursorToPosition(b->data, &saved_current_position);
  1578.     /* Move cursor backwards until a break character is encountered   */
  1579.     if (BackwardCurrentPosition(b->data, 1) != 1)
  1580.     {
  1581.         b->flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1582.         return (0);
  1583.     }
  1584. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1585.     current_character =
  1586.         b->data->textBuffer[current_position->OffsetToText +
  1587.                             1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1588. #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1589.     current_character =
  1590.         b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1591.                                                                textBuffer[current_position->OffsetToText + 1] << 8);
  1592. #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1593.     UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1594.     if (bflag)
  1595.     {
  1596.         ForwardCurrentPosition(b->data, 1);
  1597.         done = 1;
  1598.         b->flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1599.         return (0);
  1600.     }
  1601.     else
  1602.     {
  1603.         done = 0;
  1604.         b->flags |= UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  1605.     }
  1606.     while (!done)
  1607.     {
  1608.         previous_position = *current_position;
  1609.         if ((current_position->Object != NULL) &&
  1610.             (current_position->Object->OffsetToText == current_position->OffsetToText))
  1611.         {
  1612.             break;
  1613.         }
  1614.         if (current_position->OffsetToText == 0)
  1615.         {
  1616.             break;
  1617.         }
  1618.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1619.         {
  1620.             break;
  1621.         }
  1622.     #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  1623.         current_character =
  1624.             b->data->textBuffer[current_position->OffsetToText +
  1625.                                 1] | (b->data->textBuffer[current_position->OffsetToText] << 8);
  1626.     #else /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1627.         current_character =
  1628.             b->data->textBuffer[current_position->OffsetToText] | (b->data->
  1629.                                                                    textBuffer[current_position->OffsetToText + 1] << 8);
  1630.     #endif /* (EMS_BYTE_ORDER_BIG_ENDIAN) */ 
  1631.         count++;
  1632.         UI_EMS_INPUT_BOX_BREAK_CHARACTER(current_character, bflag);
  1633.         if (bflag)
  1634.         {
  1635.             break;
  1636.         }
  1637.     }
  1638.     b->highlight_start_position = previous_position;
  1639.     /* *current_position=previous_position; */
  1640.     MoveCursorToPosition(b->data, &previous_position);
  1641.     gui_EMS_input_box_locate_cursor(b);
  1642.     return (count);
  1643. }
  1646. /*****************************************************************************
  1647.  * FUNCTION
  1648.  *  gui_EMS_input_box_text_format_forward_seek
  1649.  * DESCRIPTION
  1650.  *  
  1651.  * PARAMETERS
  1652.  *  b                               [?]         
  1653.  *  t                               [?]         
  1654.  *  length                          [?]         
  1655.  *  isModifyExistedTextformat       [IN]        
  1656.  * RETURNS
  1657.  *  void
  1658.  *****************************************************************************/
  1659. void gui_EMS_input_box_text_format_forward_seek(
  1660.         UI_EMS_input_box *b,
  1661.         EMSTextFormat *t,
  1662.         S32 *length,
  1663.         BOOL isModifyExistedTextformat)
  1664. {
  1665.     /*----------------------------------------------------------------*/
  1666.     /* Local Variables                                                */
  1667.     /*----------------------------------------------------------------*/
  1668.     EMSPosition current_position = b->data->CurrentPosition;
  1669.     UI_character_type c;
  1670.     EMSObject *o;
  1671.     U8 r;
  1672.     U8 done = 0;
  1673.     S32 text_format_object_count = 0;
  1674.     S32 text_length = 0;
  1675.     BOOL isModify = isModifyExistedTextformat;
  1677.     /*----------------------------------------------------------------*/
  1678.     /* Code Body                                                      */
  1679.     /*----------------------------------------------------------------*/
  1680.     while (!done)
  1681.     {
  1682.         if (current_position.OffsetToText >= b->data->textLength)
  1683.         {
  1684.             break;
  1685.         }
  1686.         r = gui_EMS_input_box_get_next_object(b->data, &current_position, &c, &o);
  1687.         switch (r)
  1688.         {
  1689.             case 0:
  1690.                 done = 1;
  1691.                 break;
  1692.             case 1:
  1693.                 if (c == EMS_INPUTBOX_PARAGRAPH_BREAK_CHARACTER)
  1694.                 {
  1695.                     done = 1;
  1696.                 }
  1697.                 if (text_format_object_count == 0)
  1698.                 {
  1699.                     text_length++;
  1700.                 }
  1701.                 break;
  1702.             case 2:
  1703.                 if (o->Type == EMS_TYPE_TEXT_FORMAT)
  1704.                 {
  1705.                     text_format_object_count++;
  1706.                     if (isModify)
  1707.                     {
  1708.                         o->data->text_format.Alignment = t->Alignment;
  1709.                     }
  1710.                 }
  1711.                 break;
  1712.         }
  1713.     }
  1714.     *length = text_length;
  1715. }
  1718. /*****************************************************************************
  1719.  * FUNCTION
  1720.  *  gui_EMS_input_box_text_format_backward_seek
  1721.  * DESCRIPTION
  1722.  *  
  1723.  * PARAMETERS
  1724.  *  b                               [?]         
  1725.  *  t                               [?]         
  1726.  *  length                          [?]         
  1727.  *  isModifyExistedTextformat       [IN]        
  1728.  * RETURNS
  1729.  *  void
  1730.  *****************************************************************************/
  1731. void gui_EMS_input_box_text_format_backward_seek(
  1732.         UI_EMS_input_box *b,
  1733.         EMSTextFormat *t,
  1734.         S32 *length,
  1735.         BOOL isModifyExistedTextformat)
  1736. {
  1737.     /*----------------------------------------------------------------*/
  1738.     /* Local Variables                                                */
  1739.     /*----------------------------------------------------------------*/
  1740.     S32 text_length = *length;
  1741.     EMSPosition current_position = b->data->CurrentPosition;
  1742.     UI_character_type c;
  1743.     EMSObject *o;
  1744.     U8 r;
  1745.     U8 done = 0;
  1746.     U8 counter_reset_flag = 0;
  1747.     S32 saved_text_length = 0;
  1748.     S32 old_OffsetToText;
  1749.     BOOL isModify = isModifyExistedTextformat;
  1751.     /*----------------------------------------------------------------*/
  1752.     /* Code Body                                                      */
  1753.     /*----------------------------------------------------------------*/
  1754.     while (!done)
  1755.     {
  1756.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1757.         {
  1758.             if (counter_reset_flag)
  1759.             {
  1760.                 text_length = saved_text_length;
  1761.             }
  1762.             break;
  1763.         }
  1764.         gui_EMS_input_box_set_text_format_cursor_position(b);
  1765.         current_position = b->data->CurrentPosition;
  1766.         r = gui_EMS_input_box_get_next_object(b->data, &current_position, &c, &o);
  1767.         switch (r)
  1768.         {
  1769.             case 0:
  1770.                 if (counter_reset_flag)
  1771.                 {
  1772.                     text_length = saved_text_length;
  1773.                 }
  1774.                 counter_reset_flag = 0;
  1775.                 done = 1;
  1776.                 break;
  1777.             case 1:
  1778.                 if (c == EMS_INPUTBOX_PARAGRAPH_BREAK_CHARACTER)
  1779.                 {
  1780.                     if (counter_reset_flag)
  1781.                     {
  1782.                         text_length = saved_text_length;
  1783.                     }
  1784.                     ForwardCurrentPosition(b->data, 1);
  1785.                     done = 1;
  1786.                 }
  1787.                 else
  1788.                 {
  1789.                     text_length++;
  1790.                 }
  1791.                 counter_reset_flag = 0;
  1792.                 break;
  1793.             case 2:
  1794.                 if (o->Type == EMS_TYPE_TEXT_FORMAT)
  1795.                 {
  1796.                     if (text_length > 0)
  1797.                     {
  1798.                         saved_text_length = text_length + 1;
  1799.                     }
  1800.                     else
  1801.                     {
  1802.                         saved_text_length = text_length;
  1803.                     }
  1804.                     text_length = 0;
  1805.                     if (isModify)
  1806.                     {
  1807.                         o->data->text_format.Alignment = t->Alignment;
  1808.                     }
  1809.                     counter_reset_flag = 1;
  1810.                 }
  1811.                 break;
  1812.         }
  1813.     }
  1814.     *length = text_length;
  1816. #if(EMS_ENABLE_TESTFIX_OBJECT_ORDERING)
  1817.     old_OffsetToText = b->data->CurrentPosition.OffsetToText;
  1818.     while (b->data->CurrentPosition.OffsetToText == old_OffsetToText)
  1819.     {
  1820.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1821.         {
  1822.             break;
  1823.         }
  1824.     }
  1825.     if (b->data->CurrentPosition.OffsetToText != old_OffsetToText)
  1826.     {
  1827.         ForwardCurrentPosition(b->data, 1);
  1828.     }
  1829. #endif /* (EMS_ENABLE_TESTFIX_OBJECT_ORDERING) */ 
  1830. }
  1833. /*****************************************************************************
  1834.  * FUNCTION
  1835.  *  GetTextFormatObjectAtPosition
  1836.  * DESCRIPTION
  1837.  *  
  1838.  * PARAMETERS
  1839.  *  data        [?]     
  1840.  *  p           [?]     
  1841.  * RETURNS
  1842.  *  
  1843.  *****************************************************************************/
  1844. EMSObject *GetTextFormatObjectAtPosition(EMSData *data, EMSPosition *p)
  1845. {
  1846.     /*----------------------------------------------------------------*/
  1847.     /* Local Variables                                                */
  1848.     /*----------------------------------------------------------------*/
  1849.     EMSObject *current = data->listHead;
  1850.     U16 OffsetToText = (U16) p->OffsetToText;
  1851.     EMSObject *return_object = NULL;
  1853.     /*----------------------------------------------------------------*/
  1854.     /* Code Body                                                      */
  1855.     /*----------------------------------------------------------------*/
  1856.     while (current != NULL)
  1857.     {
  1858.         if ((current->Type == EMS_TYPE_TEXT_FORMAT) && (current->OffsetToText == OffsetToText))
  1859.         {
  1860.             return_object = current;
  1861.             break;
  1862.         }
  1863.         if (current->OffsetToText > OffsetToText)
  1864.         {
  1865.             break;
  1866.         }
  1867.         current = current->next;
  1868.     }
  1869.     return (return_object);
  1870. }
  1872. #ifdef __MMI_MESSAGES_EMS__
  1875. /*****************************************************************************
  1876.  * FUNCTION
  1877.  *  gui_EMS_input_box_find_paragraph_range
  1878.  * DESCRIPTION
  1879.  *  
  1880.  * PARAMETERS
  1881.  *  b                   [?]     
  1882.  *  offsetToText        [?]     
  1883.  *  textLength          [?]     
  1884.  * RETURNS
  1885.  *  void
  1886.  *****************************************************************************/
  1887. void gui_EMS_input_box_find_paragraph_range(UI_EMS_input_box *b, kal_uint16 *offsetToText, kal_uint16 *textLength)
  1888. {
  1889.     /*----------------------------------------------------------------*/
  1890.     /* Local Variables                                                */
  1891.     /*----------------------------------------------------------------*/
  1892.     kal_uint16 *offset = offsetToText;
  1893.     kal_uint16 *textLen = textLength;
  1894.     EMSPosition saved_position = b->data->CurrentPosition;
  1895.     EMSPosition current_position = b->data->CurrentPosition;
  1896.     UI_character_type c;
  1897.     EMSObject *o;
  1898.     U8 r;
  1899.     U8 done = 0;
  1901.     /*----------------------------------------------------------------*/
  1902.     /* Code Body                                                      */
  1903.     /*----------------------------------------------------------------*/
  1904.     /* Move to the beginning of paragraph */
  1905.     while (!done)
  1906.     {
  1907.         /* Reach the first position */
  1908.         if (BackwardCurrentPosition(b->data, 1) != 1)
  1909.         {
  1910.             break;
  1911.         }
  1913.         current_position = b->data->CurrentPosition;
  1914.         r = gui_EMS_input_box_get_next_object(b->data, &current_position, &c, &o);
  1915.         switch (r)
  1916.         {
  1917.                 /* check if reach the start of paragraph */
  1918.             case 1:
  1919.                 if (c == EMS_INPUTBOX_PARAGRAPH_BREAK_CHARACTER)
  1920.                 {
  1921.                     ForwardCurrentPosition(b->data, 1);
  1922.                     done = 1;
  1923.                 }
  1924.                 break;
  1926.                 /* ignore object */
  1927.             case 2:
  1928.                 break;
  1930.                 /* impossible case */
  1931.             case 0:
  1932.             default:
  1933.                 MMI_ASSERT(0);
  1934.                 break;
  1935.         }
  1936.     }
  1938.     *offset = b->data->CurrentPosition.OffsetToText;
  1940.     done = 0;
  1941.     current_position = b->data->CurrentPosition;
  1943.     /* count to the end of the paragraph */
  1944.     while (!done)
  1945.     {
  1947.         if (current_position.OffsetToText >= b->data->textLength)
  1948.         {
  1949.             break;
  1950.         }
  1951.         r = gui_EMS_input_box_get_next_object(b->data, &current_position, &c, &o);
  1952.         switch (r)
  1953.         {
  1954.                 /* count the number of characters in the paragraph */
  1955.             case 1:
  1956.                 if (c == EMS_INPUTBOX_PARAGRAPH_BREAK_CHARACTER)
  1957.                 {
  1958.                     done = 1;
  1959.                     (*textLen)++;
  1960.                     /* Exclude 0x0d and 0x0a */
  1961.                     /* (*textLen)--; */
  1962.                 }
  1963.                 else
  1964.                 {
  1965.                     (*textLen)++;
  1966.                 }
  1967.                 break;
  1969.                 /* To the end of the message */
  1970.             case 0:
  1971.                 done = 1;
  1972.                 break;
  1974.                 /* ignore object */
  1975.             case 2:
  1976.                 break;
  1978.                 /* impossible case */
  1979.             default:
  1980.                 MMI_ASSERT(0);
  1981.                 break;
  1982.         }
  1983.     }
  1985.     MoveCursorToPosition(b->data, &saved_position);
  1987. }
  1989. /* Warning: Function requires the parameter t to be modified in some cases.
  1990.    So it is necessary to pass a copy instead of the actual data            */
  1991. /* MTK Joy added for text format insert, 0112 */
  1994. /*****************************************************************************
  1995.  * FUNCTION
  1996.  *  gui_EMS_input_box_insert_text_alignment
  1997.  * DESCRIPTION
  1998.  *  
  1999.  * PARAMETERS
  2000.  *  b       [?]     
  2001.  *  t       [?]     
  2002.  * RETURNS
  2003.  *  
  2004.  *****************************************************************************/
  2005. EMSTATUS gui_EMS_input_box_insert_text_alignment(UI_EMS_input_box *b, EMSTextFormat *t)
  2006. {
  2007.     /*----------------------------------------------------------------*/
  2008.     /* Local Variables                                                */
  2009.     /*----------------------------------------------------------------*/
  2011. #if (0)
  2012. /* under construction !*/
  2013. /* under construction !*/
  2014. /* under construction !*/
  2015. /* under construction !*/
  2016. /* under construction !*/
  2017. /* under construction !*/
  2018. #if(1)
  2019. /* under construction !*/
  2020. /* under construction !*/
  2021. #endif
  2022. /* under construction !*/
  2023. /* under construction !*/
  2024. /* under construction !*/
  2025. /* under construction !*/
  2026. /* under construction !*/
  2027. /* under construction !*/
  2028. /* under construction !*/
  2029. /* under construction !*/
  2030. /* under construction !*/
  2031. /* under construction !*/
  2032. /* under construction !*/
  2033. /* under construction !*/
  2034. /* under construction !*/
  2035. /* under construction !*/
  2036. /* under construction !*/
  2037. /* under construction !*/
  2038. /* under construction !*/
  2039. /* under construction !*/
  2040. /* under construction !*/
  2041. /* under construction !*/
  2042. /* under construction !*/
  2043. /* under construction !*/
  2044. /* under construction !*/
  2045. /* under construction !*/
  2046. /* under construction !*/
  2047. /* under construction !*/
  2048. /* under construction !*/
  2049. /* under construction !*/
  2050. /* under construction !*/
  2051. /* under construction !*/
  2052. /* under construction !*/
  2053. /* under construction !*/
  2054. /* under construction !*/
  2055. /* under construction !*/
  2056. /* under construction !*/
  2057. #if(0)
  2058. /* under construction !*/
  2059. /* under construction !*/
  2060. /* under construction !*/
  2061. /* under construction !*/
  2062. /* under construction !*/
  2063. /* under construction !*/
  2064. /* under construction !*/
  2065. #endif
  2066. /* under construction !*/
  2067. /* under construction !*/
  2068. /* under construction !*/
  2069. /* under construction !*/
  2070. /* under construction !*/
  2071. /* under construction !*/
  2072. /* under construction !*/
  2073. /* under construction !*/
  2074. /* under construction !*/
  2075. /* under construction !*/
  2076. #if(1)
  2077. /* under construction !*/
  2078. /* under construction !*/
  2079. /* under construction !*/
  2080. /* under construction !*/
  2081. /* under construction !*/
  2082. /* under construction !*/
  2083. /* under construction !*/
  2084. /* under construction !*/
  2085. #endif
  2086. /* under construction !*/
  2087. /* under construction !*/
  2088. /* under construction !*/
  2089. #if(EMS_BYTE_ORDER_BIG_ENDIAN)
  2090. /* under construction !*/
  2091. /* under construction !*/
  2092. #else
  2093. /* under construction !*/
  2094. /* under construction !*/
  2095. #endif
  2096. /* under construction !*/
  2097. /* under construction !*/
  2098. /* under construction !*/
  2099. /* under construction !*/
  2100. /* under construction !*/
  2101. /* under construction !*/
  2102. /* under construction !*/
  2103. /* under construction !*/
  2104. /* under construction !*/
  2105. /* under construction !*/
  2106. /* under construction !*/
  2107. /* under construction !*/
  2108. /* under construction !*/
  2109. /* under construction !*/
  2110. /* under construction !*/
  2111. /* under construction !*/
  2112. /* under construction !*/
  2113. /* under construction !*/
  2114. /* under construction !*/
  2115. /* under construction !*/
  2116. /* under construction !*/
  2117. /* under construction !*/
  2118. /* under construction !*/
  2119. /* under construction !*/
  2120. /* under construction !*/
  2121. /* under construction !*/
  2122. /* under construction !*/
  2123. /* under construction !*/
  2124. /* under construction !*/
  2125. /* under construction !*/
  2126. /* under construction !*/
  2127. /* under construction !*/
  2128. /* under construction !*/
  2129. /* under construction !*/
  2130. /* under construction !*/
  2131. /* under construction !*/
  2132. /* under construction !*/
  2133. /* under construction !*/
  2134. /* under construction !*/
  2135. /* under construction !*/
  2136. /* under construction !*/
  2137. /* under construction !*/
  2138. /* under construction !*/
  2139. /* under construction !*/
  2140. /* under construction !*/
  2141. /* under construction !*/
  2142. /* under construction !*/
  2143. /* under construction !*/
  2144. /* under construction !*/
  2145. /* under construction !*/
  2146. /* under construction !*/
  2147. /* under construction !*/
  2148. /* under construction !*/
  2149. /* under construction !*/
  2150. /* under construction !*/
  2151. /* under construction !*/
  2152. /* under construction !*/
  2153. #endif /* (0) */ 
  2154.     kal_uint16 offsetToText = 0;
  2155.     kal_uint16 textLength = 0;
  2156.     EMSTATUS emsObjectStatus = EMS_OK;
  2157.     EMSTextFormat textFormat = *t;
  2159.     /*----------------------------------------------------------------*/
  2160.     /* Code Body                                                      */
  2161.     /*----------------------------------------------------------------*/
  2162.     if (b->data->textLength == 0)
  2163.     {
  2164.         return EMS_OK;
  2165.     }
  2167.     gui_EMS_input_box_find_paragraph_range(b, &offsetToText, &textLength);
  2169.     if (textLength == 0)
  2170.     {
  2171.         return EMS_OK;
  2172.     }
  2174.     textFormat.textLength = textLength * 2;
  2176.     textFormat.FontSize = EMS_FONTSIZE_NORMAL;
  2177.     textFormat.isBold = KAL_FALSE;
  2178.     textFormat.isItalic = KAL_FALSE;
  2179.     textFormat.isStrikethrough = KAL_FALSE;
  2180.     textFormat.isUnderline = KAL_FALSE;
  2182.     emsObjectStatus = AddTextAlignment(b->data, offsetToText, &textFormat);
  2184.     gui_EMS_input_box_set_text_format_cursor_position(b);
  2185.     return emsObjectStatus;
  2186. }
  2189. /*****************************************************************************
  2190.  * FUNCTION
  2191.  *  gui_EMS_input_box_insert_new_paragraph
  2192.  * DESCRIPTION
  2193.  *  
  2194.  * PARAMETERS
  2195.  *  b       [?]     
  2196.  *  t       [?]     
  2197.  * RETURNS
  2198.  *  
  2199.  *****************************************************************************/
  2200. EMSTATUS gui_EMS_input_box_insert_new_paragraph(UI_EMS_input_box *b, EMSTextFormat *t)
  2201. {
  2202.     /*----------------------------------------------------------------*/
  2203.     /* Local Variables                                                */
  2204.     /*----------------------------------------------------------------*/
  2205.     EMSTATUS emsObjectStatus;
  2207.     /*----------------------------------------------------------------*/
  2208.     /* Code Body                                                      */
  2209.     /*----------------------------------------------------------------*/
  2210.     emsObjectStatus = gui_EMS_input_box_insert_new_line(b);
  2212.     if (emsObjectStatus == EMS_OK)
  2213.     {
  2214.         emsObjectStatus = gui_EMS_input_box_insert_text_alignment(b, t);
  2215.     }
  2217.     return emsObjectStatus;
  2218. }
  2220. /* MTK end */
  2221. #endif /* __MMI_MESSAGES_EMS__ */ 
  2224. /*****************************************************************************
  2225.  * FUNCTION
  2226.  *  EMS_move_graphical_cursor
  2227.  * DESCRIPTION
  2228.  *  
  2229.  * PARAMETERS
  2230.  *  data            [?]         
  2231.  *  start_x         [IN]        
  2232.  *  cursor_x        [IN]        
  2233.  *  max_count       [IN]        
  2234.  * RETURNS
  2235.  *  void
  2236.  *****************************************************************************/
  2237. void EMS_move_graphical_cursor(EMSData *data, S32 start_x, S32 cursor_x, S32 max_count)
  2238. {
  2239.     /*----------------------------------------------------------------*/
  2240.     /* Local Variables                                                */
  2241.     /*----------------------------------------------------------------*/
  2242.     EMSPosition current_position = data->CurrentPosition;
  2243.     U8 done = 0;
  2244.     S32 x = start_x;
  2245.     S32 count = 0;
  2246.     U8 r;
  2247.     EMSObject *current_object;
  2248.     UI_character_type current_character;
  2249.     S32 width = 0, height;
  2251.     /* PMT START FIX HINDI ISSUES 20060604 */
  2252. #ifdef __MMI_HINDI_ALG__
  2253.     EMSData *data_chk_type = data;
  2254.     UI_character_type dummy_c = 0;
  2255.     S32 next_ems_moves = 0;
  2256.     PU8 src_p;
  2257.     PU8 dest_p;
  2258. #endif /* __MMI_HINDI_ALG__ */ 
  2259.     /* PMT END FIX HINDI ISSUES 20060604 */
  2260. #if defined(__MMI_LANG_VIETNAMESE__)
  2261.     /* W05.38 Fix Viet Tone Cursor Moving Issue */
  2262.     U8 viet_tone_move = 0;
  2263. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  2265.     /*----------------------------------------------------------------*/
  2266.     /* Code Body                                                      */
  2267.     /*----------------------------------------------------------------*/
  2268.     while (!done)
  2269.     {
  2270.         if (count >= max_count)
  2271.         {
  2272.             break;
  2273.         }
  2274.         r = gui_EMS_input_box_get_next_object(data, &current_position, &current_character, &current_object);
  2275.         switch (r)
  2276.         {
  2277.             case 0:
  2278.                 done = 1;
  2279.                 break;
  2280.             case 1:
  2281.         #if(EMS_USE_CRLF_COMBINATION)
  2282.                 if (UI_TEST_CR_CHARACTER(current_character) && (current_position.OffsetToText < data->textLength) &&
  2283.                     UI_TEST_LF_CHARACTER(data->textBuffer[current_position.OffsetToText]))
  2284.                 {
  2285.                     width = 0;
  2286.                 }
  2287.                 else if (UI_TEST_LF_CHARACTER(current_character))
  2288.                 {
  2289.                     width = 0;
  2290.                 }
  2291.                 else
  2292.         #endif /* (EMS_USE_CRLF_COMBINATION) */ 
  2293.             #if(EMS_USE_ESC_COMBINATION)
  2294.                 if (UI_TEST_ESC_CHARACTER(current_character))
  2295.                 {
  2296.                     width = 0;
  2297.                 }
  2298.                 else
  2299.             #endif /* (EMS_USE_ESC_COMBINATION) */ 
  2300.                 {
  2301.                 #if defined(__MMI_LANG_VIETNAMESE__)
  2302.                     /* MTK Terry for Cursor Move Up and Down Issue */
  2303.                     UI_character_type dummy_c = 0;
  2304.                     viet_tone_mark tone_mark = VIET_TONE_NONE;
  2305.                     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  2307.                     if ((current_character > 0x0040) && (current_character < 0x01B1))
  2308.                     {
  2309.                         r = gui_EMS_input_box_get_next_object(data, &current_position, &dummy_c, &current_object);      /* get next character */
  2310.                         if (1 == r)
  2311.                         {
  2312.                             tone_mark = mmi_viet_tone_mark(dummy_c);
  2313.                             if (VIET_TONE_NONE != tone_mark)
  2314.                             {
  2315.                                 viet_vowel = mmi_viet_vowel_letter(current_character);
  2316.                                 if (VIET_VOWEL_NONE != viet_vowel)
  2317.                                 {
  2318.                                     current_character = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  2319.                                     /* W05.38 Fix Viet Tone Cursor Moving Issue */
  2320.                                     viet_tone_move = 1;
  2321.                                 }
  2322.                                 else
  2323.                                 {
  2324.                                     r = gui_EMS_input_box_get_previous_object(
  2325.                                             data,
  2326.                                             &current_position,
  2327.                                             &dummy_c,
  2328.                                             &current_object);
  2329.                                 }
  2330.                             }
  2331.                             else
  2332.                             {
  2333.                                 r = gui_EMS_input_box_get_previous_object(
  2334.                                         data,
  2335.                                         &current_position,
  2336.                                         &dummy_c,
  2337.                                         &current_object);
  2338.                             }
  2339.                         }
  2340.                         else if (0 != r)
  2341.                         {
  2342.                             r = gui_EMS_input_box_get_previous_object(
  2343.                                     data,
  2344.                                     &current_position,
  2345.                                     &dummy_c,
  2346.                                     &current_object);
  2347.                         }
  2348.                     }
  2349.                 #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  2350.                     /* PMT START FIX HINDI ISSUES 20060604 */
  2351.                 #ifdef __MMI_HINDI_ALG__
  2352.                 #ifdef __MMI_HINDI_ALG__
  2353.                     src_p = (data->textBuffer + data->CurrentPosition.OffsetToText) - 2;
  2354.                 #endif 
  2355.                     if (UI_HINDI_CHARACTER_UCS2_RANGE(current_character))
  2356.                     {
  2357.                         dest_p = hf_get_next_cluster_p(src_p, src_p);
  2358.                         next_ems_moves = dest_p - src_p;
  2359.                         next_ems_moves = next_ems_moves >> 1;
  2360.                         if (next_ems_moves >= 2)    /* && r==2) //&& current_object->Type==EMS_TYPE_TEXT_FORMAT) */
  2361.                         {
  2362.                             ForwardCurrentPosition(data, next_ems_moves - 1);
  2363.                             count += next_ems_moves - 1;
  2364.                             next_ems_moves = 0;
  2365.                             width = hf_size_of_current_cluster(src_p, dest_p, 1);
  2366.                         }
  2367.                         else
  2368.                         {
  2369.                             gui_measure_character(current_character, &width, &height);
  2370.                         }
  2371.                         src_p = dest_p;
  2372.                     }
  2373.                     else
  2374.                 #endif /* __MMI_HINDI_ALG__ */ 
  2375.                         /* PMT END FIX HINDI ISSUES 20060604 */
  2376.                         gui_measure_character(current_character, &width, &height);
  2377.                     width += 1;
  2378.                 }
  2379.                 x += width;
  2380.                 break;
  2381.             #ifdef __MMI_MESSAGES_EMS__
  2382.             case 2:
  2383.                 if (current_object->Type == EMS_TYPE_TEXT_FORMAT)
  2384.                 {
  2385.                     width = 0;
  2386.                 }
  2387.                 else
  2388.                 {
  2389.                     gui_EMS_input_box_measure_object(current_object, &width, &height);
  2390.                     width += 2;
  2391.                 }
  2392.                 x += width;
  2393.                 break;
  2394.             #endif /* __MMI_MESSAGES_EMS__ */ 
  2395.         }
  2396.         if (x <= (cursor_x + (width >> 1)))
  2397.         {
  2398.             count++;
  2399.             if (ForwardCurrentPosition(data, 1) != 1)
  2400.             {
  2401.                 break;
  2402.             }
  2403.         #if defined(__MMI_LANG_VIETNAMESE__)
  2404.             /* W05.38 Fix Viet Tone Cursor Moving Issue */
  2405.             if (1 == viet_tone_move)
  2406.             {
  2407.                 if (ForwardCurrentPosition(data, 1) != 1)
  2408.                 {
  2409.                 }
  2410.                 viet_tone_move = 0;
  2411.             }
  2412.         #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  2413.         }
  2414.         else
  2415.         {
  2416.             break;
  2417.         }
  2418.     }
  2419. }
  2421. #endif /* (!UI_DISABLE_EMS_INPUT_BOX) */ 
  2423. /* msz00065_20051010 peng hua add for multitap thai begin */
  2424. #ifdef __MMI_MULTITAP_THAI__
  2427. /*****************************************************************************
  2428.  * FUNCTION
  2429.  *  gui_EMS_check_input_test_overflow
  2430.  * DESCRIPTION
  2431.  *  
  2432.  * PARAMETERS
  2433.  *  b       [?]         
  2434.  *  c       [IN]        
  2435.  * RETURNS
  2436.  *  
  2437.  *****************************************************************************/
  2438. U8 gui_EMS_check_input_test_overflow(UI_EMS_input_box *b, UI_character_type c)
  2439. {
  2440.     /*----------------------------------------------------------------*/
  2441.     /* Local Variables                                                */
  2442.     /*----------------------------------------------------------------*/
  2443.     U16 ch = (U16) c;
  2444.     U8 s[2] = {0, 0};
  2445.     S32 remaining_length;
  2447.     /*----------------------------------------------------------------*/
  2448.     /* Code Body                                                      */
  2449.     /*----------------------------------------------------------------*/
  2450. #ifdef __MMI_MESSAGES_EMS__
  2451.     EMS_cancel_object_focus();
  2452. #endif 
  2453.     if (b->UCS2_count > 0)
  2454.     {
  2455.         remaining_length = (EMS_get_remaining_length(b->data) >> 1);
  2456.     }
  2457.     else
  2458.     {
  2459.         remaining_length = EMS_get_remaining_length(b->data);
  2461.     }
  2462.     if (remaining_length <= 0)
  2463.     {
  2464.         return FALSE;
  2465.     }
  2466.     if (b->UCS2_count == 0)
  2467.     {
  2468.         if (UI_TEST_UCS2_CHARACTER(c))
  2469.         {
  2470.             if (EMSSetDCS(b->data, SMSAL_UCS2_DCS) != EMS_OK)
  2471.             {
  2472.                 EMSSetDCS(b->data, SMSAL_DEFAULT_DCS);
  2473.                 return FALSE;
  2474.             }
  2475.             else
  2476.             {
  2477.                 if (EMS_get_remaining_length(b->data) < 2)
  2478.                 {
  2479.                     EMSSetDCS(b->data, SMSAL_DEFAULT_DCS);
  2480.                     return FALSE;
  2481.                 }
  2482.                 else
  2483.                 {
  2484.                     EMSSetDCS(b->data, SMSAL_DEFAULT_DCS);
  2485.                     return TRUE;
  2486.                 }
  2487.             }
  2488.         }
  2489.         else if (UI_TEST_GSM_EXTENDED(c))
  2490.         {
  2491.             if (EMS_get_remaining_length(b->data) < 1)  /* JP : 408 info bar issue */
  2492.             {
  2493.                 return FALSE;
  2494.             }
  2495.         }
  2496.     }
  2497.     /* MTK end */
  2499.     /* If in Overwrite mode, delete the current character/object and insert the new one */
  2500.     if (b->flags & UI_EMS_INPUT_BOX_OVERWRITE_MODE)
  2501.     {
  2502.         return TRUE;
  2503.     }
  2504.     return TRUE;
  2505. }
  2506. #endif /* __MMI_MULTITAP_THAI__ */ 
  2507. /* msz00065_20051010 peng hua add for multitap thai end */
  2509. #ifdef __MMI_TOUCH_SCREEN__
  2510. static UI_EMS_input_box *gui_pen_scroll_EMS_input_box = NULL;
  2513. /*****************************************************************************
  2514.  * FUNCTION
  2515.  *  gui_EMS_input_box_scroll_by_pen
  2516.  * DESCRIPTION
  2517.  *  
  2518.  * PARAMETERS
  2519.  *  b                       [?]         
  2520.  *  offset_y                [IN]        
  2521.  *  EMS_input_box_event     [?]         
  2522.  * RETURNS
  2523.  *  void
  2524.  *****************************************************************************/
  2525. static void gui_EMS_input_box_scroll_by_pen(
  2526.                 UI_EMS_input_box *b,
  2527.                 S32 offset_y,
  2528.                 gui_EMS_input_box_pen_enum *EMS_input_box_event)
  2529. {
  2530.     /*----------------------------------------------------------------*/
  2531.     /* Local Variables                                                */
  2532.     /*----------------------------------------------------------------*/
  2533.     int move_gap = b->display_y + offset_y;
  2535.     /*----------------------------------------------------------------*/
  2536.     /* Code Body                                                      */
  2537.     /*----------------------------------------------------------------*/
  2538. #ifdef __MMI_MESSAGES_EMS__
  2539.     EMS_cancel_object_focus();
  2540. #endif 
  2541.     b->display_y = -offset_y;
  2542.     /* W06.06 Fix Cursor issue in EMS Input Box */
  2543.     if (!(b->flags & UI_EMS_INPUT_BOX_VIEW_MODE))
  2544.     {
  2545.         if (b->cursor_ay < -(b->display_y) || b->cursor_ay + b->cursor_line_height > b->height - b->display_y)
  2546.         {
  2547.             if (move_gap > 0)
  2548.             {
  2549.                 gui_show_EMS_input_box_ext(b, UI_cursor_x1, UI_cursor_y1 + b->cursor_line_height);
  2550.             }
  2551.             else
  2552.             {
  2553.                 if (0 == offset_y)
  2554.                 {
  2555.                     gui_show_EMS_input_box_ext(b, UI_cursor_x1, UI_cursor_y1 + move_gap);
  2556.                 }
  2557.                 else
  2558.                 {
  2559.                     gui_show_EMS_input_box_ext(b, UI_cursor_x1, UI_cursor_y1);
  2560.                 }
  2561.             }
  2562.         }
  2563.     }
  2564.     b->display_y = -offset_y;
  2565.     if (!(b->flags & UI_EMS_INPUT_BOX_VIEW_MODE) && (0 != offset_y))
  2566.     {
  2567.         gui_EMS_input_box_locate_cursor(b);
  2568.     }
  2569.     gui_show_EMS_input_box(b);
  2570.     gui_BLT_double_buffer(b->x, b->y, b->x + b->width, b->y + b->height);
  2571. }
  2574. /*****************************************************************************
  2575.  * FUNCTION
  2576.  *  gui_EMS_input_box_scroll_timer_hdlr
  2577.  * DESCRIPTION
  2578.  *  
  2579.  * PARAMETERS
  2580.  *  void
  2581.  * RETURNS
  2582.  *  void
  2583.  *****************************************************************************/
  2584. static void gui_EMS_input_box_scroll_timer_hdlr(void)
  2585. {
  2586.     /*----------------------------------------------------------------*/
  2587.     /* Local Variables                                                */
  2588.     /*----------------------------------------------------------------*/
  2589.     UI_EMS_input_box *b = gui_pen_scroll_EMS_input_box;
  2590.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  2592.     /*----------------------------------------------------------------*/
  2593.     /* Code Body                                                      */
  2594.     /*----------------------------------------------------------------*/
  2595.     gui_pen_scroll_EMS_input_box = NULL;
  2597.     if (!b)
  2598.     {
  2599.         return;
  2600.     }
  2602.     gui_EMS_input_box_scroll_by_pen(b, b->pen_scroll_after_delay, &EMS_input_box_event);
  2603. }
  2606. /*****************************************************************************
  2607.  * FUNCTION
  2608.  *  gui_EMS_input_box_abort_scroll_timer
  2609.  * DESCRIPTION
  2610.  *  
  2611.  * PARAMETERS
  2612.  *  void
  2613.  * RETURNS
  2614.  *  void
  2615.  *****************************************************************************/
  2616. static void gui_EMS_input_box_abort_scroll_timer(void)
  2617. {
  2618.     /*----------------------------------------------------------------*/
  2619.     /* Local Variables                                                */
  2620.     /*----------------------------------------------------------------*/
  2622.     /*----------------------------------------------------------------*/
  2623.     /* Code Body                                                      */
  2624.     /*----------------------------------------------------------------*/
  2625.     gui_pen_scroll_EMS_input_box = NULL;
  2626. }
  2629. /*****************************************************************************
  2630.  * FUNCTION
  2631.  *  gui_EMS_input_box_start_scroll_timer
  2632.  * DESCRIPTION
  2633.  *  
  2634.  * PARAMETERS
  2635.  *  b           [?]         
  2636.  *  value       [IN]        
  2637.  * RETURNS
  2638.  *  void
  2639.  *****************************************************************************/
  2640. static void gui_EMS_input_box_start_scroll_timer(UI_EMS_input_box *b, S32 value)
  2641. {
  2642.     /*----------------------------------------------------------------*/
  2643.     /* Local Variables                                                */
  2644.     /*----------------------------------------------------------------*/
  2646.     /*----------------------------------------------------------------*/
  2647.     /* Code Body                                                      */
  2648.     /*----------------------------------------------------------------*/
  2649.     /* assert that no two input box at the same time */
  2650.     MMI_DBG_ASSERT(!gui_pen_scroll_EMS_input_box || gui_pen_scroll_EMS_input_box == b);
  2652.     b->pen_scroll_after_delay = value;
  2653.     gui_pen_scroll_EMS_input_box = b;
  2655.     gui_cancel_timer(gui_EMS_input_box_scroll_timer_hdlr);
  2656.     gui_start_timer(b->pen_scroll_delay_time, gui_EMS_input_box_scroll_timer_hdlr);
  2658.     gui_add_cleanup_hook(gui_EMS_input_box_abort_scroll_timer);
  2659. }
  2662. /*****************************************************************************
  2663.  * FUNCTION
  2664.  *  gui_EMS_input_box_set_pen_scroll_delay
  2665.  * DESCRIPTION
  2666.  *  
  2667.  * PARAMETERS
  2668.  *  b               [?]         
  2669.  *  delay_time      [IN]        
  2670.  * RETURNS
  2671.  *  void
  2672.  *****************************************************************************/
  2673. void gui_EMS_input_box_set_pen_scroll_delay(UI_EMS_input_box *b, S32 delay_time)
  2674. {
  2675.     /*----------------------------------------------------------------*/
  2676.     /* Local Variables                                                */
  2677.     /*----------------------------------------------------------------*/
  2679.     /*----------------------------------------------------------------*/
  2680.     /* Code Body                                                      */
  2681.     /*----------------------------------------------------------------*/
  2682.     MMI_DBG_ASSERT(delay_time < (S32) 0x0000FFFF);
  2683.     b->pen_scroll_delay_time = (S16) delay_time;
  2684. }
  2687. /*****************************************************************************
  2688.  * FUNCTION
  2689.  *  gui_EMS_input_box_translate_pen_event
  2690.  * DESCRIPTION
  2691.  *  
  2692.  * PARAMETERS
  2693.  *  b                       [?]         
  2694.  *  pen_event               [IN]        
  2695.  *  x                       [IN]        
  2696.  *  y                       [IN]        
  2697.  *  EMS_input_box_event     [?]         
  2698.  * RETURNS
  2699.  *  
  2700.  *****************************************************************************/
  2701. BOOL gui_EMS_input_box_translate_pen_event(
  2702.         UI_EMS_input_box *b,
  2703.         mmi_pen_event_type_enum pen_event,
  2704.         S16 x,
  2705.         S16 y,
  2706.         gui_EMS_input_box_pen_enum *EMS_input_box_event)
  2707. {
  2708.     /*----------------------------------------------------------------*/
  2709.     /* Local Variables                                                */
  2710.     /*----------------------------------------------------------------*/
  2711.     BOOL ret = MMI_TRUE;
  2712.     gui_EMS_input_box_pen_state_struct *pen_state;
  2713.     gui_scrollbar_pen_enum scrollbar_event;
  2714.     gui_pen_event_param_struct scrollbar_param;
  2715.     int scroll_bar_width;
  2717.     /*----------------------------------------------------------------*/
  2718.     /* Code Body                                                      */
  2719.     /*----------------------------------------------------------------*/
  2720.     if (UI_EMS_INPUT_BOX_DISABLE_SCROLLBAR & b->flags)
  2721.     {
  2722.         scroll_bar_width = 0;
  2723.     }
  2724.     else
  2725.     {
  2726.         scroll_bar_width = b->vbar.width;
  2727.     }
  2729.     pen_state = &b->pen_state;
  2730.     ret = MMI_TRUE;
  2732.     if (pen_event != MMI_PEN_EVENT_DOWN && pen_state->pen_on_scroll_bar)
  2733.     {
  2734.         gui_vertical_scrollbar_translate_pen_event(&b->vbar, pen_event, x, y, &scrollbar_event, &scrollbar_param);
  2735.         if (scrollbar_event == GUI_SCROLLBAR_PEN_JUMP_TO_I)
  2736.         {
  2737.             if (b->pen_scroll_delay_time > 0)   /* Delay time for scrollbar scrolling */
  2738.             {
  2739.                 gui_EMS_input_box_start_scroll_timer(b, scrollbar_param._u.i);
  2740.             }
  2741.             else
  2742.             {
  2743.                 gui_EMS_input_box_scroll_by_pen(b, scrollbar_param._u.i, EMS_input_box_event);
  2744.             }
  2745.         }
  2746.         *EMS_input_box_event = GUI_EMS_INPUT_BOX_PEN_SCROLL_BAR;
  2747.     }
  2748.     else
  2749.     {
  2750.         switch (pen_event)
  2751.         {
  2752.             case MMI_PEN_EVENT_DOWN:
  2753.                 if (PEN_CHECK_BOUND(x, y, b->x, b->y, b->width, b->height))
  2754.                 {
  2755.                     pen_state->pen_on_scroll_bar = 0;
  2756.                     if (!(b->flags & UI_EMS_INPUT_BOX_DISABLE_SCROLLBAR) &&
  2757.                         gui_vertical_scrollbar_translate_pen_event(
  2758.                             &b->vbar,
  2759.                             MMI_PEN_EVENT_DOWN,
  2760.                             x,
  2761.                             y,
  2762.                             &scrollbar_event,
  2763.                             &scrollbar_param))
  2764.                     {
  2765.                         pen_state->pen_on_scroll_bar = 1;
  2766.                         gui_vertical_scrollbar_set_minimum_pen_offset(&b->vbar, b->cursor_line_height);
  2767.                         if (scrollbar_event == GUI_SCROLLBAR_PEN_JUMP_TO_I)
  2768.                         {
  2769.                             if (b->pen_scroll_delay_time > 0)   /* Delay time for scrollbar scrolling */
  2770.                             {
  2771.                                 gui_EMS_input_box_start_scroll_timer(b, scrollbar_param._u.i);
  2772.                             }
  2773.                             else
  2774.                             {
  2775.                                 gui_EMS_input_box_scroll_by_pen(b, scrollbar_param._u.i, EMS_input_box_event);
  2776.                             }
  2777.                         }
  2778.                         *EMS_input_box_event = GUI_EMS_INPUT_BOX_PEN_SCROLL_BAR;
  2779.                     }
  2780.                     else
  2781.                     {
  2782.                         *EMS_input_box_event = GUI_EMS_INPUT_BOX_PEN_TEXT_DOWN;
  2783.                     }
  2784.                 }
  2785.                 else
  2786.                 {
  2787.                     ret = MMI_FALSE;
  2788.                 }
  2789.                 break;
  2790.             case MMI_PEN_EVENT_UP:
  2791.                 if (PEN_CHECK_BOUND(x, y, b->x, b->y, b->width - scroll_bar_width, b->height))
  2792.                 {
  2793.                     *EMS_input_box_event = GUI_EMS_INPUT_BOX_PEN_TEXT_UP;
  2794.                 }
  2795.                 else
  2796.                 {
  2797.                     ret = MMI_FALSE;
  2798.                 }
  2799.                 break;
  2800.             case MMI_PEN_EVENT_MOVE:
  2801.             case MMI_PEN_EVENT_LONG_TAP:
  2802.             case MMI_PEN_EVENT_REPEAT:
  2803.             case MMI_PEN_EVENT_ABORT:
  2804.                 if (PEN_CHECK_BOUND(x, y, b->x, b->y, b->width - scroll_bar_width, b->height))
  2805.                 {
  2806.                 }
  2807.                 else
  2808.                 {
  2809.                     ret = MMI_FALSE;
  2810.                 }
  2811.                 break;
  2812.         }
  2813.     }
  2814.     return ret;
  2815. }
  2816. #endif /* __MMI_TOUCH_SCREEN__ */