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

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

MTK

开发平台：

C/C++

PixcomFontEngine.c：源码内容
  1.     {
  2.     #if defined(__MMI_ZI__)
  3.         index = SearchInPropFont(Ch, &nBase);
  4.         if (index == -1)
  5.         {
  6.     #endif /* defined(__MMI_ZI__) */ 
  8.             Ch = 65515;
  9.             index = SearchInPropFont(Ch, &nBase);
  10.             if (index == -1)
  11.             {
  12.                 return index;
  13.             }
  15.         #if defined(__MMI_ZI__)
  16.         }
  17.         *pHeight = gMTKProprietaryFont.nHeight;
  18.         *pWidth = gMTKProprietaryFont.pWidthArray[index];
  19.         goto label_out2;
  20.         #endif /* defined(__MMI_ZI__) */ 
  22.     }
  24. #if defined(__MMI_ZI__)
  25.     *pHeight = gZiExtraCharacter.nHeight;
  26.     *pWidth = gZiExtraCharacter.pWidthArray[index];
  27.   label_out2:;
  28. #else /* defined(__MMI_ZI__) */ 
  29.     *pHeight = gMTKProprietaryFont.nHeight;
  30.     *pWidth = gMTKProprietaryFont.pWidthArray[index];
  31. #endif /* defined(__MMI_ZI__) */ 
  32.     /* MTK End */
  33.     return index;
  34. }
  37. /*****************************************************************************
  38.  * FUNCTION
  39.  *  Get_StringWidthHeight
  40.  * DESCRIPTION
  41.  *  To get string width and height
  42.  *  
  43.  *  This is used to get string widths
  44.  * PARAMETERS
  45.  *  String      [IN]        
  46.  *  pWidth      [?]         
  47.  *  pHeight     [?]         
  48.  * RETURNS
  49.  *  S32(?)
  50.  *****************************************************************************/
  51. void Get_StringWidthHeight(U8 *String, S32 *pWidth, S32 *pHeight)
  52. {
  53.     /*----------------------------------------------------------------*/
  54.     /* Local Variables                                                */
  55.     /*----------------------------------------------------------------*/
  56.     S32 StrWidth = 0;
  57.     S32 nHeight = 0;
  58.     S32 Counter = 0;
  59.     U16 unicode = 0;
  60.     U16 curCh = 0, preCh = 0, pre2Ch = 0;
  62. #if defined(__MMI_LANG_VIETNAMESE__)
  63.     U16 next_unicode = 0;
  64.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  65.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  66. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  67. #ifdef __MMI_BIDI_ALG__
  68.     S32 nLen;
  69. #endif 
  71.     /*----------------------------------------------------------------*/
  72.     /* Code Body                                                      */
  73.     /*----------------------------------------------------------------*/
  74.     *pHeight = 0;
  75.     *pWidth = 0;
  76.     /* START VIJAY PMT 20050728 */
  77. #ifdef __MMI_HINDI_ALG__
  78.     if (hf_is_reset_hindi_params())
  79.     {
  80.         reset_hindi_params();
  81.     }
  82.     if (hf_is_hindi_rules_parsing())
  83.     {
  84.         U16 cluster_fill[G_MAX];
  85.         S32 cluster_length;
  86.         U16 glyph_output[G_MAX];
  87.         S32 Len;
  88.         S32 len;
  90.         S32 total_len = 0;
  91.         S32 original_len = 0;
  93.         S32 width, height;
  95.         pre2Ch = 0;
  96.         preCh = 0;
  97.         if (String == NULL)
  98.         {
  99.             return;
  100.         }
  101.         /* PMT START LANGUAGE 20060104 */
  102.     #if defined (__MMI_BIDI_ALG__)
  103.         nLen = UCS2Strlen((const char*)String);
  104.         //MMI_ASSERT(!(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH));
  105.         if(nLen>MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH) nLen = MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH;
  106.         //UCS2Strcpy((S8*) show_pwcWord, (S8*) String);
  107.         UCS2Strncpy((S8*) show_pwcWord, (S8*) String,nLen);
  108.         show_pwcWord[nLen] = 0;
  109.         nLen = UCS2Strlen((const char*)show_pwcWord);
  110.     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  111.     #if defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__)
  112.         if (nLen)
  113.         {
  114.         #ifdef __MMI_ZI_V7__
  115.         #if defined(__MMI_ZI_PERSIAN__) && defined(__MMI_ZI_ARABIC__)
  116.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  117.         #elif defined (__MMI_ZI_PERSIAN__)
  118.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  119.         #elif defined (__MMI_ZI_ARABIC__)
  120.             ZiStringShape(ZI8_LANG_AR, (U16 *) & nLen, show_pwcWord);
  121.         #endif 
  123.         #else /* __MMI_ZI_V7__ */ 
  124.             ArabicStringShape((U16 *) & nLen, show_pwcWord);
  125.         #endif /* __MMI_ZI_V7__ */ 
  126.         }
  127.     #else /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  128.         if (nLen)
  129.         {
  130.             ArabicShapeEngine((U16*) & nLen, show_pwcWord); /* output will replace the input string after returning */
  131.         }
  132.     #endif /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  133.     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  134.         String = (U8*) show_pwcWord;
  135.     #endif /* defined (__MMI_BIDI_ALG__) */ 
  136.         /* PMT END LANGUAGE 20060104 */
  137.         init_cluster_start_p(String);
  138.         len = gui_strlen((UI_string_type) String);
  140.         if (len > 0)
  141.         {
  142.             init_cluster_end_p(String + (len * 2));
  143.         }
  144.         else
  145.         {
  146.             init_cluster_end_p(String + (2 * UCS2Strlen((const char*)String) + 1));
  147.         }
  148.         original_len = len;
  150.         hf_disable_hindi_rules_parsing();
  151.         hf_disable_hindi_reset_hindi_params();
  153.         do
  154.         {
  155.             cluster_length = hf_get_cluster(cluster_fill);
  157.             total_len += cluster_length;
  158.             if (original_len > 0)
  159.             {
  160.                 if (total_len > original_len)
  161.                 {
  162.                     break;
  163.                 }
  164.             }
  166.             if (cluster_length)
  167.             {
  168.                 Len = hf_hindi_rules(glyph_output, cluster_fill, cluster_length);
  169.                 Get_StringWidthHeight((U8*) glyph_output, &width, &height);
  170.                 if (height > *pHeight)
  171.                 {
  172.                     *pHeight = height;
  173.                 }
  174.                 *pWidth += width;
  175.             }
  176.         } while (cluster_length);
  177.         hf_enable_hindi_rules_parsing();
  178.         hf_enable_hindi_reset_hindi_params();
  179.         return;
  180.     }
  181. #endif /* __MMI_HINDI_ALG__ */ 
  182.     /* END VIJAY PMT 20050728 */
  183.     if (String == NULL)
  184.     {
  185.         return;
  186.     }
  187.     /* PMT START LANGUAGE 20060104 */
  188. #if defined (__MMI_BIDI_ALG__) && !defined(__MMI_HINDI_ALG__)
  189.     /* PMT END LANGUAGE 20060104 */
  190.     nLen = UCS2Strlen((const char*)String);
  191.     //MMI_ASSERT(!(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH));
  192.     if(nLen>MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH) nLen = MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH;
  193.     //UCS2Strcpy((S8*) show_pwcWord, (S8*) String);
  194.     UCS2Strncpy((S8*) show_pwcWord, (S8*) String,nLen);
  195.     show_pwcWord[nLen] = 0;
  196.     nLen = UCS2Strlen((const char*)show_pwcWord);
  197.     /* PMT NO_AR_SL_DU START 20050909 */
  198.     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  199.     #if defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__)
  200.         if (nLen)
  201.         {
  202.         #ifdef __MMI_ZI_V7__
  203.         #if defined(__MMI_ZI_PERSIAN__) && defined(__MMI_ZI_ARABIC__)
  204.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  205.         #elif defined (__MMI_ZI_PERSIAN__)
  206.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  207.         #elif defined (__MMI_ZI_ARABIC__)
  208.             ZiStringShape(ZI8_LANG_AR, (U16 *) & nLen, show_pwcWord);
  209.         #endif 
  211.         #else /* __MMI_ZI_V7__ */ 
  212.             ArabicStringShape((U16 *) & nLen, show_pwcWord);
  213.         #endif /* __MMI_ZI_V7__ */ 
  214.         }
  215.     #else /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  216.         if (nLen)
  217.         {
  218.             ArabicShapeEngine((U16*) & nLen, show_pwcWord); /* output will replace the input string after returning */
  219.         }
  220.     #endif /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  221.     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  222.  
  223.     /* PMT NO_AR_SL_DU END 20050909 */
  224.     String = (U8*) show_pwcWord;
  225. #endif /* defined (__MMI_BIDI_ALG__) && !defined(__MMI_HINDI_ALG__) */ 
  227.     while (1)
  228.     {
  229.         if ((String[0] == '') && (String[1] == ''))
  230.         {
  231.             break;
  233.         }
  235.         memcpy(&unicode, String, 2);
  236.     #if defined(__MMI_LANG_VIETNAMESE__)
  237.         if ((unicode > 0x0040) && (unicode < 0x01B1))
  238.         {
  239.             next_unicode = String[2];
  240.             next_unicode |= (String[3] << 8);
  241.             tone_mark = mmi_viet_tone_mark(next_unicode);
  242.             if (VIET_TONE_NONE != tone_mark)
  243.             {
  244.                 viet_vowel = mmi_viet_vowel_letter(unicode);
  245.                 if (VIET_VOWEL_NONE != viet_vowel)
  246.                 {
  247.                     unicode = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  248.                     String += 2;
  249.                 }
  250.             }
  251.         }
  252.     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  254.         Get_CharWidthHeight(unicode, &StrWidth, &nHeight);
  255.         /* Consider the Thai String length is different from others */
  256.         curCh = unicode;
  257.         if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  258.         {
  259.             /* Base line character, can combinate with above vowels,bottom vowels, tone mark, and sign */
  260.             if (IsThaiBaseLineChar(curCh))
  261.             {
  262.                 //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  263.                 //moved ahead to let the circyle sign on the top of previous or previous2 character
  264.                 if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  265.                 {
  266.                     *pWidth = *pWidth - 4 + (S32) StrWidth + gThaiFontInterSpace;
  267.                 }
  268.                 else
  269.                 {
  270.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  271.                 }
  272.             }
  273.             /* For Thai digits and base line sign, the only thing we have to do is moving cursor */
  274.             else if (IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  275.             {
  276.                 *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  277.             }
  278.             else if (IsThaiToneMark(curCh))
  279.             {
  280.                 if (IsThaiBaseLineChar(preCh) || IsThaiAboveLineChar(preCh) || IsThaiBottomLineChar(preCh))
  281.                 {
  282.                 }
  283.                 else if (preCh == 0x0E47 || preCh == 0x0E4C)
  284.                 {
  285.                     /* move the tone mark to next character space */
  286.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  287.                 }
  288.                 else
  289.                 {
  290.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  291.                 }
  293.             }
  295.             *pHeight = gThaiLineHeight; /* If  the string has Thai characters,the height will become gThaiLineHeight(now the value is 17) */
  296.             pre2Ch = preCh;
  297.             preCh = curCh;
  298.         }
  299.     #ifdef __MMI_HINDI_ALG__
  300.         else if (UI_HINDI_CHARACTER_UCS2_RANGE(curCh))
  301.         {
  302.             U16 nextCharUCS2;
  304.             memcpy(&nextCharUCS2, String + 2, 2);
  305.             /* PMT START MAUI_00223197 */
  306.             if ((curCh != S_VISARGA) && UI_HINDI_SIGN_RANGE(curCh))
  307.                 /* PMT END MAUI_00223197 */
  308.             {
  309.                 (*pWidth) += 0;
  310.             }
  311.             else
  312.             {
  313.                 if (UI_HINDI_CHARACTER_UCS2_RANGE(nextCharUCS2) || nextCharUCS2 == 0)
  314.                 {
  315.                     (*pWidth) += StrWidth;
  316.                 }
  317.                 else
  318.                 {
  319.                     Get_CharWidth(curCh, &StrWidth);
  320.                     (*pWidth) += StrWidth;
  321.                 }
  322.             }
  323.         }
  324.     #endif /* __MMI_HINDI_ALG__ */ 
  325.         else
  326.         {
  327.             (*pWidth) += StrWidth;
  328.         }
  330.         if (*pHeight < nHeight)
  331.         {
  332.             *pHeight = nHeight;
  333.         }
  334.         Counter++;
  336.         String += 2;
  337.     }
  338.     return;
  339. }
  341. #if(FONTENGINE_IRAM_PLACEMENT)
  342. #ifdef __MTK_TARGET__
  343. #pragma arm section code
  344. #endif 
  345. #endif /* (FONTENGINE_IRAM_PLACEMENT) */ 
  347. /* july-28-2002 manju: required by UI elements. This function measures a text string's width upto a given number of characters */
  350. /*****************************************************************************
  351.  * FUNCTION
  352.  *  Get_StringWidthHeight_n
  353.  * DESCRIPTION
  354.  *  To get string widths and height upto a given number of characters
  355.  *  
  356.  *  This is used to get string widths upto a given number of characters
  357.  * PARAMETERS
  358.  *  String      [IN]        
  359.  *  n           [IN]        
  360.  *  pWidth      [IN]        
  361.  *  pHeight     [IN]        
  362.  * RETURNS
  363.  *  void
  364.  *****************************************************************************/
  365. void Get_StringWidthHeight_n(U8 *String, S32 n, S32 *pWidth, S32 *pHeight)
  366. {
  367.     /*----------------------------------------------------------------*/
  368.     /* Local Variables                                                */
  369.     /*----------------------------------------------------------------*/
  371.     S32 StrWidth = 0;
  372.     S32 Counter = 0;
  373.     S32 nHeight = 0;
  375.     U16 unicode = 0;
  376.     U16 curCh = 0, preCh = 0, pre2Ch = 0;
  378. #if defined(__MMI_LANG_VIETNAMESE__)
  379.     U16 next_unicode = 0;
  380.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  381.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  382. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  385.     #ifdef __MMI_BIDI_ALG__
  386.     S32 nLen;
  387.     #endif
  388.     /*----------------------------------------------------------------*/
  389.     /* Code Body                                                      */
  390.     /*----------------------------------------------------------------*/
  391.     *pHeight = 0;
  392.     *pWidth = 0;
  393.     //Modified by Ailsa start
  394. #ifdef __MMI_HINDI_ALG__
  395.             if (hf_is_reset_hindi_params())
  396.             {
  397.                 reset_hindi_params();
  398.             }
  399.             if (hf_is_hindi_rules_parsing())
  400.             {
  401.                 U16 cluster_fill[G_MAX];
  402.                 S32 cluster_length;
  403.                 U16 glyph_output[G_MAX];
  404.                 S32 Len;
  405.                 S32 len;
  407.                 S32 total_len = 0;
  408.                 S32 original_len = 0;
  409.         
  410.                 S32 width, height;
  412.                 pre2Ch = 0;
  413.                 preCh = 0;
  414.                 if (String == NULL)
  415.                 {
  416.                     return;
  417.                 }
  418.     //Modified by Ailsa end
  419.     #if defined (__MMI_BIDI_ALG__)
  420.         nLen = UCS2Strlen((const char*)String);
  421.         //MMI_ASSERT(!(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH));
  422.         if(nLen>MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH) nLen = MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH;
  423.         if(n< nLen) nLen = n;
  424.         //UCS2Strcpy((S8*) show_pwcWord, (S8*) String);
  425.         UCS2Strncpy((S8*) show_pwcWord, (S8*) String,nLen);
  426.         show_pwcWord[nLen] = 0;
  427.         nLen = UCS2Strlen((const char*)show_pwcWord);
  428.     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  429.     #if defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__)
  430.         if (nLen)
  431.         {
  432.         #ifdef __MMI_ZI_V7__
  433.         #if defined(__MMI_ZI_PERSIAN__) && defined(__MMI_ZI_ARABIC__)
  434.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  435.         #elif defined (__MMI_ZI_PERSIAN__)
  436.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  437.         #elif defined (__MMI_ZI_ARABIC__)
  438.             ZiStringShape(ZI8_LANG_AR, (U16 *) & nLen, show_pwcWord);
  439.         #endif 
  441.         #else /* __MMI_ZI_V7__ */ 
  442.             ArabicStringShape((U16 *) & nLen, show_pwcWord);
  443.         #endif /* __MMI_ZI_V7__ */ 
  444.         }
  445.     #else /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  446.         if (nLen)
  447.         {
  448.             ArabicShapeEngine((U16*) & nLen, show_pwcWord); /* output will replace the input string after returning */
  449.         }
  450.     #endif /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  451.     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  453.         String = (U8*) show_pwcWord;
  454.     #endif /* defined (__MMI_BIDI_ALG__) */ 
  455.         //Modified by Ailsa start
  456.             init_cluster_start_p(String);
  457.             len = gui_strlen((UI_string_type) String);
  458.     
  459.             if (len > 0)
  460.             {
  461.                 init_cluster_end_p(String + (len * 2));
  462.             }
  463.             else
  464.             {
  465.                 init_cluster_end_p(String + (2 * UCS2Strlen((const char*)String) + 1));
  466.             }
  467.             original_len = len;
  468.     
  469.             hf_disable_hindi_rules_parsing();
  470.             hf_disable_hindi_reset_hindi_params();
  471.     
  472.             do
  473.             {
  474.                 cluster_length = hf_get_cluster(cluster_fill);
  475.     
  476.                 total_len += cluster_length;
  477.                 if (original_len > 0)
  478.                 {
  479.                     if (total_len > original_len)
  480.                     {
  481.                         break;
  482.                     }
  483.                 }
  484.     
  485.                 if (cluster_length)
  486.                 {
  487.                     Len = hf_hindi_rules(glyph_output, cluster_fill, cluster_length);
  488.                     Get_StringWidthHeight((U8*) glyph_output, &width, &height);
  489.                     if (height > *pHeight)
  490.                     {
  491.                         *pHeight = height;
  492.                     }
  493.                     *pWidth += width;
  494.                 }
  495.             } while (cluster_length);
  496.             hf_enable_hindi_rules_parsing();
  497.             hf_enable_hindi_reset_hindi_params();
  498.             return;
  499.         }
  500. #endif /* __MMI_HINDI_ALG__ */ 
  501.     //Modified by Ailsa end
  503.     if (String == NULL)
  504.     {
  505.         return;
  506.     }
  508. #if defined (__MMI_BIDI_ALG__) && !defined(__MMI_HINDI_ALG__)    
  509.     nLen = UCS2Strlen((const char*)String);
  510.     //MMI_ASSERT(!(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH));
  511.     if(nLen>MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH) nLen = MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH;
  512.     if(n< nLen) nLen = n;
  513.     //UCS2Strcpy((S8*) show_pwcWord, (S8*) String);
  514.     UCS2Strncpy((S8*) show_pwcWord, (S8*) String,nLen);
  515.     show_pwcWord[nLen] = 0;
  516.     nLen = UCS2Strlen((const char*)show_pwcWord);    
  517.     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  518.     #if defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__)
  519.         if (nLen)
  520.         {
  521.         #ifdef __MMI_ZI_V7__
  522.         #if defined(__MMI_ZI_PERSIAN__) && defined(__MMI_ZI_ARABIC__)
  523.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  524.         #elif defined (__MMI_ZI_PERSIAN__)
  525.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  526.         #elif defined (__MMI_ZI_ARABIC__)
  527.             ZiStringShape(ZI8_LANG_AR, (U16 *) & nLen, show_pwcWord);
  528.         #endif 
  530.         #else /* __MMI_ZI_V7__ */ 
  531.             ArabicStringShape((U16 *) & nLen, show_pwcWord);
  532.         #endif /* __MMI_ZI_V7__ */ 
  533.         }
  534.     #else /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  535.         if (nLen)
  536.         {
  537.             ArabicShapeEngine((U16*) & nLen, show_pwcWord); /* output will replace the input string after returning */
  538.         }
  539.     #endif /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  540.     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  541.     
  542.     String = (U8*) show_pwcWord;
  543. #endif /* defined (__MMI_BIDI_ALG__) && !defined(__MMI_HINDI_ALG__) */ 
  545.     while (Counter < n)
  546.     {
  547.         if ((String[0] == '') && (String[1] == ''))
  548.         {
  549.             break;
  550.         }
  552.         memcpy(&unicode, String, 2);
  553.     #if defined(__MMI_LANG_VIETNAMESE__)
  554.         if ((unicode > 0x0040) && (unicode < 0x01B1))
  555.         {
  556.             next_unicode = String[2];
  557.             next_unicode |= (String[3] << 8);
  558.             tone_mark = mmi_viet_tone_mark(next_unicode);
  559.             if (VIET_TONE_NONE != tone_mark)
  560.             {
  561.                 viet_vowel = mmi_viet_vowel_letter(unicode);
  562.                 if (VIET_VOWEL_NONE != viet_vowel)
  563.                 {
  564.                     unicode = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  565.                     String += 2;
  566.                     n += 1;
  567.                 }
  568.             }
  569.         }
  570.     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  572.         Get_CharWidthHeight(unicode, &StrWidth, &nHeight);
  573.         /* Consider the Thai String length is different from others */
  574.         curCh = unicode;
  575.         if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  576.         {
  577.             /* Base line character, can combinate with above vowels,bottom vowels, tone mark, and sign */
  578.             if (IsThaiBaseLineChar(curCh))
  579.             {
  580.                 //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  581.                 //moved ahead to let the circyle sign on the top of previous or previous2 character
  582.                 if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  583.                 {
  584.                     *pWidth = *pWidth - 4 + (S32) StrWidth + gThaiFontInterSpace;
  585.                 }
  586.                 else
  587.                 {
  588.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  589.                 }
  590.             }
  591.             /* For Thai digits and base line sign, the only thing we have to do is moving cursor */
  592.             else if (IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  593.             {
  594.                 *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  595.             }
  596.             else if (IsThaiToneMark(curCh))
  597.             {
  598.                 if (IsThaiBaseLineChar(preCh) || IsThaiAboveLineChar(preCh) || IsThaiBottomLineChar(preCh))
  599.                 {
  600.                 }
  601.                 else if (preCh == 0x0E47 || preCh == 0x0E4C)
  602.                 {
  603.                     /* move the tone mark to next character space */
  604.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  605.                 }
  606.                 else
  607.                 {
  608.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  609.                 }
  611.             }
  613.             *pHeight = gThaiLineHeight; /* If  the string has Thai characters,the height will become gThaiLineHeight(now the value is 17) */
  614.             pre2Ch = preCh;
  615.             preCh = curCh;
  616.         }
  617. #ifdef __MMI_HINDI_ALG__
  618.             else if (UI_HINDI_CHARACTER_UCS2_RANGE(curCh))
  619.             {
  620.                 U16 nextCharUCS2;
  621.         
  622.                 memcpy(&nextCharUCS2, String + 2, 2);
  623.                 /* PMT START MAUI_00223197 */
  624.                 if ((curCh != S_VISARGA) && UI_HINDI_SIGN_RANGE(curCh))
  625.                     /* PMT END MAUI_00223197 */
  626.                 {
  627.                     (*pWidth) += 0;
  628.                 }
  629.                 else
  630.                 {
  631.                     if (UI_HINDI_CHARACTER_UCS2_RANGE(nextCharUCS2) || nextCharUCS2 == 0)
  632.                     {
  633.                         (*pWidth) += StrWidth;
  634.                     }
  635.                     else
  636.                     {
  637.                         Get_CharWidth(curCh, &StrWidth);
  638.                         (*pWidth) += StrWidth;
  639.                     }
  640.                 }
  641.             }
  642. #endif /* __MMI_HINDI_ALG__ */ 
  643.         else
  644.         {
  645.             (*pWidth) += StrWidth;
  646.         }
  648.         if (*pHeight < nHeight)
  649.         {
  650.             *pHeight = nHeight;
  651.         }
  652.         Counter++;
  654.         String += 2;
  655.     }
  656.     return;
  657. }
  659. /* PMT dara added for Multitap thai */
  662. /*****************************************************************************
  663.  * FUNCTION
  664.  *  Get_StringWidthHeight_multitap
  665.  * DESCRIPTION
  666.  *  
  667.  * PARAMETERS
  668.  *  String      [?]         
  669.  *  w           [IN]        
  670.  *  pWidth      [?]         
  671.  *  pHeight     [?]         
  672.  * RETURNS
  673.  *  void
  674.  *****************************************************************************/
  675. void Get_StringWidthHeight_multitap(U8 *String, S32 w, S32 *pWidth, S32 *pHeight)
  676. {
  677.     /*----------------------------------------------------------------*/
  678.     /* Local Variables                                                */
  679.     /*----------------------------------------------------------------*/
  680.     S32 StrWidth = 0;
  681.     S32 Counter = 0;
  682.     S32 nHeight = 0;
  683.     U16 unicode = 0;
  685.     /*----------------------------------------------------------------*/
  686.     /* Code Body                                                      */
  687.     /*----------------------------------------------------------------*/
  688.     *pHeight = 0;
  689.     *pWidth = 0;
  691.     if (String == NULL)
  692.     {
  693.         return;
  694.     }
  696.     while (1)
  697.     {
  698.         if ((String[0] == '') && (String[1] == ''))
  699.         {
  700.             break;
  701.         }
  702.         memcpy(&unicode, String, 2);
  704.         Get_CharWidthHeight(unicode, &StrWidth, &nHeight);
  705.         /* Consider the Thai String length is different from others */
  707.         (*pWidth) += (StrWidth + w);
  708.         if (*pHeight < nHeight)
  709.         {
  710.             *pHeight = nHeight;
  711.         }
  712.         Counter++;
  714.         String += 2;
  715.     }
  716.     return;
  717. }
  720. /*****************************************************************************
  721.  * FUNCTION
  722.  *  Get_StringWidthHeight_w
  723.  * DESCRIPTION
  724.  *  
  725.  * PARAMETERS
  726.  *  String      [?]         
  727.  *  w           [IN]        
  728.  *  pWidth      [?]         
  729.  *  pHeight     [?]         
  730.  * RETURNS
  731.  *  void
  732.  *****************************************************************************/
  733. void Get_StringWidthHeight_w(U8 *String, S32 w, S32 *pWidth, S32 *pHeight)
  734. {
  735.     /*----------------------------------------------------------------*/
  736.     /* Local Variables                                                */
  737.     /*----------------------------------------------------------------*/
  738.     S32 StrWidth = 0;
  739.     S32 Counter = 0;
  740.     S32 nHeight = 0;
  741.     U16 unicode = 0;
  742.     U16 curCh = 0, preCh = 0, pre2Ch = 0;
  744. #if defined(__MMI_LANG_VIETNAMESE__)
  745.     U16 next_unicode = 0;
  746.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  747.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  748. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  750.     /*----------------------------------------------------------------*/
  751.     /* Code Body                                                      */
  752.     /*----------------------------------------------------------------*/
  753.     *pHeight = 0;
  754.     *pWidth = 0;
  756.     if (String == NULL)
  757.     {
  758.         return;
  759.     }
  761.     while (1)
  762.     {
  763.         if ((String[0] == '') && (String[1] == ''))
  764.         {
  765.             break;
  766.         }
  767.         memcpy(&unicode, String, 2);
  768.     #if defined(__MMI_LANG_VIETNAMESE__)
  769.         if ((unicode > 0x0040) && (unicode < 0x01B1))
  770.         {
  771.             next_unicode = String[2];
  772.             next_unicode |= (String[3] << 8);
  773.             tone_mark = mmi_viet_tone_mark(next_unicode);
  774.             if (VIET_TONE_NONE != tone_mark)
  775.             {
  776.                 viet_vowel = mmi_viet_vowel_letter(unicode);
  777.                 if (VIET_VOWEL_NONE != viet_vowel)
  778.                 {
  779.                     unicode = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  780.                     String += 2;
  781.                 }
  782.             }
  783.         }
  784.     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  786.         Get_CharWidthHeight(unicode, &StrWidth, &nHeight);
  787.         /* Consider the Thai String length is different from others */
  788.         curCh = unicode;
  789.         if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  790.         {
  791.             /* Base line character, can combinate with above vowels,bottom vowels, tone mark, and sign */
  792.             if (IsThaiBaseLineChar(curCh))
  793.             {
  794.                 //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  795.                 //moved ahead to let the circyle sign on the top of previous or previous2 character
  796.                 if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  797.                 {
  798.                     *pWidth = *pWidth - 4 + (S32) StrWidth + gThaiFontInterSpace + w;
  799.                 }
  800.                 else
  801.                 {
  802.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  803.                 }
  804.             }
  805.             /* For Thai digits and base line sign, the only thing we have to do is moving cursor */
  806.             else if (IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  807.             {
  808.                 *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  809.             }
  810.             else if (IsThaiToneMark(curCh))
  811.             {
  812.                 if (IsThaiBaseLineChar(preCh) || IsThaiAboveLineChar(preCh) || IsThaiBottomLineChar(preCh))
  813.                 {
  814.                 }
  815.                 else if (preCh == 0x0E47 || preCh == 0x0E4C)
  816.                 {
  817.                     /* move the tone mark to next character space */
  818.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  819.                 }
  820.                 else
  821.                 {
  822.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  823.                 }
  825.             }
  827.             *pHeight = gThaiLineHeight; /* If  the string has Thai characters,the height will become gThaiLineHeight(now the value is 17) */
  828.             pre2Ch = preCh;
  829.             preCh = curCh;
  830.         }
  831.         else
  832.         {
  833.             (*pWidth) += (StrWidth + w);
  834.         }
  835.         if (*pHeight < nHeight)
  836.         {
  837.             *pHeight = nHeight;
  838.         }
  839.         Counter++;
  841.         String += 2;
  842.     }
  843.     return;
  844. }
  847. /*****************************************************************************
  848.  * FUNCTION
  849.  *  Get_StringWidthHeight_wn
  850.  * DESCRIPTION
  851.  *  
  852.  * PARAMETERS
  853.  *  String      [?]         
  854.  *  w           [IN]        
  855.  *  n           [IN]        
  856.  *  pWidth      [?]         
  857.  *  pHeight     [?]         
  858.  * RETURNS
  859.  *  void
  860.  *****************************************************************************/
  861. void Get_StringWidthHeight_wn(U8 *String, S32 w, S32 n, S32 *pWidth, S32 *pHeight)
  862. {
  863.     /*----------------------------------------------------------------*/
  864.     /* Local Variables                                                */
  865.     /*----------------------------------------------------------------*/
  866.     S32 StrWidth = 0;
  867.     S32 Counter = 0;
  868.     S32 nHeight = 0;
  869.     U16 unicode = 0;
  870.     U16 curCh = 0, preCh = 0, pre2Ch = 0;
  872. #if defined(__MMI_LANG_VIETNAMESE__)
  873.     U16 next_unicode = 0;
  874.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  875.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  876. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  878.     /*----------------------------------------------------------------*/
  879.     /* Code Body                                                      */
  880.     /*----------------------------------------------------------------*/
  881.     if (String == NULL)
  882.     {
  883.         return;
  884.     }
  885.     *pHeight = 0;
  886.     *pWidth = 0;
  888.     while (Counter < n)
  889.     {
  890.         if ((String[0] == '') && (String[1] == ''))
  891.         {
  892.             break;
  893.         }
  895.         memcpy(&unicode, String, 2);
  896.     #if defined(__MMI_LANG_VIETNAMESE__)
  897.         if ((unicode > 0x0040) && (unicode < 0x01B1))
  898.         {
  899.             next_unicode = String[2];
  900.             next_unicode |= (String[3] << 8);
  901.             tone_mark = mmi_viet_tone_mark(next_unicode);
  902.             if (VIET_TONE_NONE != tone_mark)
  903.             {
  904.                 viet_vowel = mmi_viet_vowel_letter(unicode);
  905.                 if (VIET_VOWEL_NONE != viet_vowel)
  906.                 {
  907.                     unicode = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  908.                     String += 2;
  909.                     n += 1;
  910.                 }
  911.             }
  912.         }
  913.     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  914.         Get_CharWidthHeight(unicode, &StrWidth, &nHeight);
  915.         /* Consider the Thai String length is different from others */
  916.         curCh = unicode;
  917.         if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  918.         {
  919.             //curCh = unicode;
  920.             // Base line character, can combinate with above vowels,bottom vowels, tone mark, and sign
  921.             if (IsThaiBaseLineChar(curCh))
  922.             {
  923.                 //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  924.                 //moved ahead to let the circyle sign on the top of previous or previous2 character
  925.                 if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  926.                 {
  927.                     *pWidth = *pWidth - 4 + (S32) StrWidth + gThaiFontInterSpace + w;
  928.                 }
  929.                 else
  930.                 {
  931.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  932.                 }
  933.             }
  934.             /* For Thai digits and base line sign, the only thing we have to do is moving cursor */
  935.             else if (IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  936.             {
  937.                 *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace;
  938.             }
  939.             else if (IsThaiToneMark(curCh))
  940.             {
  941.                 if (IsThaiBaseLineChar(preCh) || IsThaiAboveLineChar(preCh) || IsThaiBottomLineChar(preCh))
  942.                 {
  943.                 }
  944.                 else if (preCh == 0x0E47 || preCh == 0x0E4C)
  945.                 {
  946.                     /* move the tone mark to next character space */
  947.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  948.                 }
  949.                 else
  950.                 {
  951.                     *pWidth = *pWidth + (S32) StrWidth + gThaiFontInterSpace + w;
  952.                 }
  953.             }
  955.             *pHeight = gThaiLineHeight; /* If  the string has Thai characters,the height will become gThaiLineHeight(now the value is 17) */
  956.             pre2Ch = preCh;
  957.             preCh = curCh;
  958.         }
  959.         else
  960.         {
  961.             (*pWidth) += (StrWidth + w);
  962.         }
  964.         Counter++;
  966.         String += 2;
  967.     }
  969.     return;
  970. }
  973. /*****************************************************************************
  974.  * FUNCTION
  975.  *  Get_CharHeight
  976.  * DESCRIPTION
  977.  *  To get char height
  978.  *  
  979.  *  This is used to get char height
  980.  * PARAMETERS
  981.  *  void
  982.  * RETURNS
  983.  *  S32
  984.  *****************************************************************************/
  985. S32 Get_CharHeight()
  986. {
  987.     /*----------------------------------------------------------------*/
  988.     /* Local Variables                                                */
  989.     /*----------------------------------------------------------------*/
  991.     /*----------------------------------------------------------------*/
  992.     /* Code Body                                                      */
  993.     /*----------------------------------------------------------------*/
  994.     return (S32) gpCurrentFont->nHeight;
  995. }
  998. /*****************************************************************************
  999.  * FUNCTION
  1000.  *  Get_CharHeightOfAllLang
  1001.  * DESCRIPTION
  1002.  *  To get maximum char height regardless of language
  1003.  *  
  1004.  *  Justin. for WAP layout formating.
  1005.  * PARAMETERS
  1006.  *  size        [IN]        
  1007.  * RETURNS
  1008.  *  S32
  1009.  *****************************************************************************/
  1010. S32 Get_CharHeightOfAllLang(U8 size)
  1011. {
  1012.     /*----------------------------------------------------------------*/
  1013.     /* Local Variables                                                */
  1014.     /*----------------------------------------------------------------*/
  1015.     int lang_index;
  1016.     sFontFamily *pFontFamily;
  1017.     S32 height = 0, h;
  1019.     /*----------------------------------------------------------------*/
  1020.     /* Code Body                                                      */
  1021.     /*----------------------------------------------------------------*/
  1022.     for (lang_index = 0; lang_index < gMaxDeployedLangs; lang_index++)
  1023.     {
  1024.         pFontFamily = gLanguageArray[lang_index].fontfamilyList[gLanguageArray[lang_index].nCurrentFamily];
  1025.         if ((h = (S32) pFontFamily->fontData[size]->nHeight) > height)
  1026.         {
  1027.             height = h;
  1028.         }
  1029.     }
  1031.     if (height < (S32) gMTKProprietaryFont.nHeight)
  1032.     {
  1033.         height = (S32) gMTKProprietaryFont.nHeight;
  1034.     }
  1036.     /* MTK Add steven 2005.06.03 */
  1037. #if defined(__MMI_ZI__)
  1038.     if (height < (S32) gZiExtraCharacter.nHeight)
  1039.     {
  1040.         height = (S32) gZiExtraCharacter.nHeight;
  1041.     }
  1042. #endif /* defined(__MMI_ZI__) */ 
  1043.     /* MTK End */
  1045.     return height;
  1046. }
  1049. /*****************************************************************************
  1050.  * FUNCTION
  1051.  *  Get_StringHeight
  1052.  * DESCRIPTION
  1053.  *  To get string height
  1054.  *  
  1055.  *  This is used to get string height
  1056.  * PARAMETERS
  1057.  *  void
  1058.  * RETURNS
  1059.  *  S32
  1060.  *****************************************************************************/
  1061. S32 Get_StringHeight()
  1062. {
  1063.     /*----------------------------------------------------------------*/
  1064.     /* Local Variables                                                */
  1065.     /*----------------------------------------------------------------*/
  1066.     sFontFamily *pFontFamily;
  1068.     /*----------------------------------------------------------------*/
  1069.     /* Code Body                                                      */
  1070.     /*----------------------------------------------------------------*/
  1071.     pFontFamily = gLanguageArray[gCurrLangIndex].fontfamilyList[gLanguageArray[gCurrLangIndex].nCurrentFamily];
  1072.     return (S32) (pFontFamily->fontData[gnCurrentFont]->nHeight);
  1074. #if 0
  1075. /* under construction !*/
  1076. #endif /* 0 */ 
  1077. }
  1080. /*****************************************************************************
  1081.  * FUNCTION
  1082.  *  TestDiffFonts
  1083.  * DESCRIPTION
  1084.  *  To test the different fonts with diferent sizes.
  1085.  *  
  1086.  *  This is used to test the different fonts with diferent sizes.
  1087.  * PARAMETERS
  1088.  *  void
  1089.  * RETURNS
  1090.  *  void
  1091.  * BOOL
  1092.  *  
  1093.  *****************************************************************************/
  1094. void TestDiffFonts()
  1095. {
  1096.     /*----------------------------------------------------------------*/
  1097.     /* Local Variables                                                */
  1098.     /*----------------------------------------------------------------*/
  1099.     S16 count = 0, y = 20;
  1100.     stFontAttribute fontInfo;
  1102.     /*----------------------------------------------------------------*/
  1103.     /* Code Body                                                      */
  1104.     /*----------------------------------------------------------------*/
  1105.     fontInfo.bold = 0;
  1106.     fontInfo.italic = 0;
  1107.     fontInfo.underline = 0;
  1109.     fontInfo.size = 9;  /* (size 8..15 FOR type 2..5 ) & (size 9...15 FOR type 1 ) */
  1110.     fontInfo.type = 1;  /* 1...5 */
  1112.     for (count = 0; count < 2; count++)
  1113.     {
  1114.         ShowString(0, y, fontInfo, 0, (PU8) "abcdefghij", 30);
  1115.         y += 20;
  1117.         ShowString(0, y, fontInfo, 0, (PU8) "klmnopqrst", 30);
  1118.         y += 20;
  1120.         ShowString(0, y, fontInfo, 0, (PU8) "uvwxyz", 30);
  1121.         fontInfo.size += 1;
  1122.         y += 20;
  1124.     }
  1125. }
  1128. /*****************************************************************************
  1129.  * FUNCTION
  1130.  *  Get_FontHeight
  1131.  * DESCRIPTION
  1132.  *  
  1133.  * PARAMETERS
  1134.  *  f               [IN]        
  1135.  *  arrCount        [IN]        
  1136.  * RETURNS
  1137.  *  
  1138.  *****************************************************************************/
  1139. S32 Get_FontHeight(stFontAttribute f, U8 arrCount)
  1140. {
  1141.     /*----------------------------------------------------------------*/
  1142.     /* Local Variables                                                */
  1143.     /*----------------------------------------------------------------*/
  1144.     sFontFamily *pFontFamily;
  1146.     /*----------------------------------------------------------------*/
  1147.     /* Code Body                                                      */
  1148.     /*----------------------------------------------------------------*/
  1149.     pFontFamily = gLanguageArray[arrCount].fontfamilyList[gLanguageArray[arrCount].nCurrentFamily];
  1150.     return (S32) (pFontFamily->fontData[f.size]->nHeight);
  1151. }
  1154. /*****************************************************************************
  1155.  * FUNCTION
  1156.  *  IsThaiToneMark
  1157.  * DESCRIPTION
  1158.  *  
  1159.  * PARAMETERS
  1160.  *  ch      [IN]        
  1161.  * RETURNS
  1162.  *  
  1163.  *****************************************************************************/
  1164. BOOL IsThaiToneMark(U16 ch)
  1165. {
  1166.     /*----------------------------------------------------------------*/
  1167.     /* Local Variables                                                */
  1168.     /*----------------------------------------------------------------*/
  1170.     /*----------------------------------------------------------------*/
  1171.     /* Code Body                                                      */
  1172.     /*----------------------------------------------------------------*/
  1173.     if (ch == 0x0E48 || ch == 0x0E49 || ch == 0x0E4A || ch == 0x0E4B)
  1174.     {
  1175.         return TRUE;
  1176.     }
  1177.     else
  1178.     {
  1179.         return FALSE;
  1180.     }
  1181. }
  1184. /*****************************************************************************
  1185.  * FUNCTION
  1186.  *  IsThaiBaseLineChar
  1187.  * DESCRIPTION
  1188.  *  
  1189.  * PARAMETERS
  1190.  *  ch      [IN]        
  1191.  * RETURNS
  1192.  *  
  1193.  *****************************************************************************/
  1194. BOOL IsThaiBaseLineChar(U16 ch)
  1195. {
  1196.     /*----------------------------------------------------------------*/
  1197.     /* Local Variables                                                */
  1198.     /*----------------------------------------------------------------*/
  1200.     /*----------------------------------------------------------------*/
  1201.     /* Code Body                                                      */
  1202.     /*----------------------------------------------------------------*/
  1203.     if (ch >= 0x0E01 && ch <= 0x0E7F)
  1204.     {
  1205.         /* above vowels */
  1206.         if (ch != 0x0E31 && ch != 0x0E34 && ch != 0x0E35 && ch != 0x0E36 && ch != 0x0E37 &&
  1207.             /* Tone marks */
  1208.             ch != 0x0E48 && ch != 0x0E49 && ch != 0x0E4A && ch != 0x0E4B &&
  1209.             /* Below vowels */
  1210.             ch != 0x0E38 && ch != 0x0E39 && ch != 0X0E3A &&
  1211.             /* Signs */
  1212.             ch != 0x0E2F && ch != 0x0E3F && ch != 0x0E46 && ch != 0x0E47 && ch != 0x0E4C &&
  1213.             /* Exclude Thai digits */
  1214.             ch < 0x0E4F)
  1215.         {
  1216.             return TRUE;
  1217.         }
  1218.         else
  1219.         {
  1220.             return FALSE;
  1221.         }
  1223.     }
  1224.     else
  1225.     {
  1226.         return FALSE;
  1227.     }
  1229. }
  1232. /*****************************************************************************
  1233.  * FUNCTION
  1234.  *  IsThaiAboveLineChar
  1235.  * DESCRIPTION
  1236.  *  
  1237.  * PARAMETERS
  1238.  *  ch      [IN]        
  1239.  * RETURNS
  1240.  *  
  1241.  *****************************************************************************/
  1242. BOOL IsThaiAboveLineChar(U16 ch)
  1243. {
  1244.     /*----------------------------------------------------------------*/
  1245.     /* Local Variables                                                */
  1246.     /*----------------------------------------------------------------*/
  1248.     /*----------------------------------------------------------------*/
  1249.     /* Code Body                                                      */
  1250.     /*----------------------------------------------------------------*/
  1251.     if (ch == 0x0E31 || ch == 0x0E34 || ch == 0x0E35 || ch == 0x0E36 || ch == 0x0E37 || ch == 0x0E47 || ch == 0x0E4C)
  1252.     {
  1253.         return TRUE;
  1254.     }
  1255.     else
  1256.     {
  1257.         return FALSE;
  1258.     }
  1260. }
  1263. /*****************************************************************************
  1264.  * FUNCTION
  1265.  *  IsThaiBottomLineChar
  1266.  * DESCRIPTION
  1267.  *  
  1268.  * PARAMETERS
  1269.  *  ch      [IN]        
  1270.  * RETURNS
  1271.  *  
  1272.  *****************************************************************************/
  1273. BOOL IsThaiBottomLineChar(U16 ch)
  1274. {
  1275.     /*----------------------------------------------------------------*/
  1276.     /* Local Variables                                                */
  1277.     /*----------------------------------------------------------------*/
  1279.     /*----------------------------------------------------------------*/
  1280.     /* Code Body                                                      */
  1281.     /*----------------------------------------------------------------*/
  1282.     if (ch == 0x0E38 || ch == 0x0E39 || ch == 0x0E3A)
  1283.     {
  1284.         return TRUE;
  1285.     }
  1286.     else
  1287.     {
  1288.         return FALSE;
  1289.     }
  1290. }
  1293. /*****************************************************************************
  1294.  * FUNCTION
  1295.  *  IsThaiLongTailChar
  1296.  * DESCRIPTION
  1297.  *  
  1298.  * PARAMETERS
  1299.  *  ch      [IN]        
  1300.  * RETURNS
  1301.  *  
  1302.  *****************************************************************************/
  1303. BOOL IsThaiLongTailChar(U16 ch)
  1304. {
  1305.     /*----------------------------------------------------------------*/
  1306.     /* Local Variables                                                */
  1307.     /*----------------------------------------------------------------*/
  1309.     /*----------------------------------------------------------------*/
  1310.     /* Code Body                                                      */
  1311.     /*----------------------------------------------------------------*/
  1312.     if (ch == 0x0E1B || ch == 0x0E1D || ch == 0x0E1F)
  1313.     {
  1314.         return TRUE;
  1315.     }
  1316.     else
  1317.     {
  1318.         return FALSE;
  1319.     }
  1320. }
  1323. /*****************************************************************************
  1324.  * FUNCTION
  1325.  *  IsThaiDigitChar
  1326.  * DESCRIPTION
  1327.  *  
  1328.  * PARAMETERS
  1329.  *  ch      [IN]        
  1330.  * RETURNS
  1331.  *  
  1332.  *****************************************************************************/
  1333. BOOL IsThaiDigitChar(U16 ch)
  1334. {
  1335.     /*----------------------------------------------------------------*/
  1336.     /* Local Variables                                                */
  1337.     /*----------------------------------------------------------------*/
  1339.     /*----------------------------------------------------------------*/
  1340.     /* Code Body                                                      */
  1341.     /*----------------------------------------------------------------*/
  1342.     if (ch >= 0x0E50 && ch <= 0x0E59)
  1343.     {
  1344.         return TRUE;
  1345.     }
  1346.     else
  1347.     {
  1348.         return FALSE;
  1349.     }
  1351. }
  1354. /*****************************************************************************
  1355.  * FUNCTION
  1356.  *  IsThaiBaseSignChar
  1357.  * DESCRIPTION
  1358.  *  
  1359.  * PARAMETERS
  1360.  *  ch      [IN]        
  1361.  * RETURNS
  1362.  *  
  1363.  *****************************************************************************/
  1364. BOOL IsThaiBaseSignChar(U16 ch)
  1365. {
  1366.     /*----------------------------------------------------------------*/
  1367.     /* Local Variables                                                */
  1368.     /*----------------------------------------------------------------*/
  1370.     /*----------------------------------------------------------------*/
  1371.     /* Code Body                                                      */
  1372.     /*----------------------------------------------------------------*/
  1373.     if (ch == 0x0E2F || ch == 0x0E3F || ch == 0x0E46 || ch == 0x0E4F || ch == 0x0E5A || ch == 0x0E5B)
  1374.     {
  1375.         return TRUE;
  1376.     }
  1377.     else
  1378.     {
  1379.         return FALSE;
  1380.     }
  1381. }
  1384. /*****************************************************************************
  1385.  * FUNCTION
  1386.  *  HaveThaiCharacter
  1387.  * DESCRIPTION
  1388.  *  
  1389.  * PARAMETERS
  1390.  *  str     [?]     
  1391.  * RETURNS
  1392.  *  
  1393.  *****************************************************************************/
  1394. BOOL HaveThaiCharacter(U16 *str)
  1395. {
  1396.     /*----------------------------------------------------------------*/
  1397.     /* Local Variables                                                */
  1398.     /*----------------------------------------------------------------*/
  1399.     U16 ch = 0;
  1401.     /*----------------------------------------------------------------*/
  1402.     /* Code Body                                                      */
  1403.     /*----------------------------------------------------------------*/
  1404.     while (1)
  1405.     {
  1406.         ch = str[0];
  1407.         if (ch == 0)
  1408.         {
  1409.             return FALSE;
  1410.         }
  1411.         if (ch >= 0x0E01 && ch <= 0x0E7F)
  1412.         {
  1413.             return TRUE;
  1414.         }
  1415.         str++;
  1416.     }
  1417.     return FALSE;
  1419. }
  1422. /*****************************************************************************
  1423.  * FUNCTION
  1424.  *  RequireToMoveCursor
  1425.  * DESCRIPTION
  1426.  *  
  1427.  * PARAMETERS
  1428.  *  preCh       [IN]        
  1429.  *  curCh       [IN]        
  1430.  * RETURNS
  1431.  *  
  1432.  *****************************************************************************/
  1433. BOOL RequireToMoveCursor(U16 preCh, U16 curCh)
  1434. {
  1435.     /*----------------------------------------------------------------*/
  1436.     /* Local Variables                                                */
  1437.     /*----------------------------------------------------------------*/
  1439.     pBOOL isPreBaseLineChar = IsThaiBaseLineChar(preCh);
  1441.     /*----------------------------------------------------------------*/
  1442.     /* Code Body                                                      */
  1443.     /*----------------------------------------------------------------*/
  1444.     if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  1445.     {
  1447.         if (IsThaiBaseLineChar(curCh) || IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  1448.         {   /* For base level character */
  1449.             return TRUE;
  1450.         }
  1451.         else if (IsThaiAboveLineChar(curCh))
  1452.         {   /* For above level character */
  1453.             if (isPreBaseLineChar)
  1454.             {
  1455.                 return FALSE;
  1456.             }
  1457.             else if (curCh == 0x0E4C && preCh != 0x0E4C && preCh != 0x0E47)
  1458.             {
  1459.                 return FALSE;
  1460.             }
  1461.             else
  1462.             {
  1463.                 return TRUE;
  1464.             }
  1466.         }
  1467.         else if (IsThaiBottomLineChar(curCh))
  1468.         {   /* For below level character */
  1469.             if (isPreBaseLineChar)
  1470.             {
  1471.                 return FALSE;
  1472.             }
  1473.             else
  1474.             {
  1475.                 return TRUE;
  1476.             }
  1477.         }
  1478.         else if (IsThaiToneMark(curCh))
  1479.         {   /* For Tone mark characters */
  1481.             if (isPreBaseLineChar || IsThaiAboveLineChar(preCh) || IsThaiBottomLineChar(preCh))
  1482.             {
  1483.                 return FALSE;
  1484.             }
  1485.             else
  1486.             {
  1487.                 return TRUE;
  1488.             }
  1490.         }
  1491.         else
  1492.         {
  1493.             return TRUE;
  1494.         }
  1495.     }
  1496.     else
  1497.     {
  1498.         return TRUE;
  1499.     }
  1501. }
  1504. /*****************************************************************************
  1505.  * FUNCTION
  1506.  *  ShowCharFuncDispatch
  1507.  * DESCRIPTION
  1508.  *  
  1509.  * PARAMETERS
  1510.  *  LineHeight      [IN]        
  1511.  *  nWidth          [IN]        
  1512.  *  nHgt            [IN]        
  1513.  *  CurrentX        [IN]        
  1514.  *  CurrentY        [IN]        
  1515.  *  Font            [IN]        
  1516.  *  BackGround      [IN]        
  1517.  *  CharData        [?]         
  1518.  *  NumChar         [IN]        
  1519.  *  Bordered        [IN]        
  1520.  * RETURNS
  1521.  *  void
  1522.  *****************************************************************************/
  1523. __inline static void ShowCharFuncDispatch(
  1524.                         U32 LineHeight,
  1525.                         U16 nWidth,
  1526.                         U16 nHgt,
  1527.                         S32 CurrentX,
  1528.                         S32 CurrentY,
  1529.                         stFontAttribute Font,
  1530.                         U8 BackGround,
  1531.                         U8 *CharData,
  1532.                         U32 NumChar,
  1533.                         U32 Bordered)
  1534. {
  1535.     /*----------------------------------------------------------------*/
  1536.     /* Local Variables                                                */
  1537.     /*----------------------------------------------------------------*/
  1538.     S32 nXOffset, nYOffset;
  1539.     U8 font_attr = 0;
  1540.     gdi_color border_color = 0, text_color;
  1542.     /*----------------------------------------------------------------*/
  1543.     /* Code Body                                                      */
  1544.     /*----------------------------------------------------------------*/
  1545.     if (gnCurrentFontAttrib & FONTATTRIB_ITALIC)
  1546.     {
  1547.         font_attr |= FONTATTRIB_ITALIC;
  1548.     }
  1549.     else if (gnCurrentFontAttrib & FONTATTRIB_OBLIQUE)
  1550.     {
  1551.         font_attr |= FONTATTRIB_OBLIQUE;
  1552.     }
  1554.     if (Font.underline)
  1555.     {
  1556.         font_attr |= FONTATTRIB_UNDERLINE;
  1557.     }
  1559.     {
  1560.         if (Bordered)
  1561.         {
  1562.             border_color = gdi_act_color_from_rgb(0xff, UI_text_border_color.r, UI_text_border_color.g, UI_text_border_color.b);
  1563.         }
  1565.         text_color = gdi_act_color_from_rgb(0xff, UI_current_text_color.r, UI_current_text_color.g, UI_current_text_color.b);
  1567.     }
  1569.     /*
  1570.      * MTK Terry to consider Thai display in ShowStackedString
  1571.      * if(LineHeight>0)
  1572.      * {
  1573.      * 
  1574.      * if(LineHeight==gThaiLineHeight ) //If the line height is equal to 17 points
  1575.      * CurrentY+=(LineHeight-(S32)nHgt-1); // Lower one pixel to centralize ThaiFont
  1576.      * else
  1577.      * CurrentY+=(LineHeight-(S32)nHgt);
  1578.      * 
  1579.      * }
  1580.      */
  1581.     nXOffset = CurrentX + nWidth;
  1582.     nYOffset = CurrentY + nHgt;
  1583.     if (Bordered)
  1584.     {
  1585.         gdi_show_char_bordered(
  1586.             CurrentX,
  1587.             CurrentY,
  1588.             text_color,
  1589.             border_color,
  1590.             CharData,
  1591.             NumChar,
  1592.             nWidth,
  1593.             nHgt,
  1594.             font_attr);
  1595.     }
  1596.     else if (!
  1597.              (gnCurrentFontAttrib & FONTATTRIB_BOLD &&
  1598.               gpCurrentFont->pFontType[gnCurrentFont][gbFontType] & FONTATTRIB_BOLD) ||
  1599.              !(gpCurrentFont->pFontType[gnCurrentFont][gbFontType] & FONTATTRIB_NORMAL))
  1600.     {
  1601.         gdi_show_char(CurrentX, CurrentY, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  1602.     }
  1603.     else
  1604.     {
  1605.         gdi_show_char(CurrentX + 1, CurrentY, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  1606.         gdi_show_char(CurrentX, CurrentY, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  1607.     }
  1608. }
  1611. /*****************************************************************************
  1612.  * FUNCTION
  1613.  *  ShowStackedString
  1614.  * DESCRIPTION
  1615.  *  
  1616.  * PARAMETERS
  1617.  *  CurrentX        [IN]        
  1618.  *  CurrentY        [IN]        
  1619.  *  Font            [IN]        
  1620.  *  BackGround      [IN]        
  1621.  *  String          [?]         
  1622.  *  LineHeight      [IN]        
  1623.  *  Bordered        [IN]        
  1624.  *  len             [IN]        
  1625.  * RETURNS
  1626.  *  
  1627.  *****************************************************************************/
  1628. U32 ShowStackedString(
  1629.         S32 CurrentX,
  1630.         S32 CurrentY,
  1631.         stFontAttribute Font,
  1632.         U8 BackGround,
  1633.         U8 *String,
  1634.         U32 LineHeight,
  1635.         U32 Bordered,
  1636.         S32 len)
  1637. {
  1638.     /*----------------------------------------------------------------*/
  1639.     /* Local Variables                                                */
  1640.     /*----------------------------------------------------------------*/
  1641.     /* GDI_ENTER_CRITICAL_SECTION(ShowStackedString) */
  1642.     U8 *CharData;
  1643.     U32 NumChar;
  1644.     U16 nHgt;
  1645.     U16 nWidth;
  1646.     S32 temp_len = 0;
  1647.     BOOL has_thai_char = MMI_FALSE;
  1648.     S32 iX, iY;
  1649.     static U16 curCh = 0, preCh = 0, pre2Ch = 0, nextCharUCS2 = 0;
  1650.     S32 interLeaving = gThaiFontInterSpace;
  1651.     gdi_color border_color, text_color;
  1652.     U8 font_attr = 0;
  1653.     S32 str_width, str_height;
  1654.     S32 clip_x1, clip_y1, clip_x2, clip_y2;
  1656. #if defined(__MMI_LANG_VIETNAMESE__)
  1657.     viet_tone_mark tone_mark = VIET_TONE_NONE;
  1658.     viet_vowel_letter viet_vowel = VIET_VOWEL_NONE;
  1659. #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  1661. #ifdef __MMI_HINDI_ALG__
  1662.     U16 nDWidth = 0;
  1663.     static S32 single_time_bidi = 0;    /* added farhad 20012004 */
  1664.     static S32 hindi_rule_string = 1;
  1665. #endif /* __MMI_HINDI_ALG__ */ 
  1667. #ifdef __MMI_BIDI_ALG__
  1668.     PMT_BIDI_TYPES default_direction = BIDI_L;
  1669.     U16 logical_cur_pos;
  1670.     U8 *temp_text_P;
  1671.     U16 visual_str_len;
  1672.     U16 visual_cur_pos;
  1673.     S32 nLen;
  1674.     U16 visual_hilight_start;
  1675.     U16 visual_hilight_end;
  1676. #endif /* __MMI_BIDI_ALG__ */ 
  1678.     /*----------------------------------------------------------------*/
  1679.     /* Code Body                                                      */
  1680.     /*----------------------------------------------------------------*/
  1681.     gdi_layer_get_clip(&clip_x1, &clip_y1, &clip_x2, &clip_y2);
  1682.     Get_StringWidthHeight(String, &str_width, &str_height);
  1683. #ifdef __MMI_SUPPORT_DUMP_SCREEN_STRING__
  1684. mmi_trace_screen_string(CurrentX, CurrentY, String, len, Bordered);
  1685. #endif
  1687. #ifdef __MMI_HINDI_ALG__
  1688.     if (!single_time_bidi && !cancelWidth)
  1689. #endif 
  1690.     {
  1691.     #ifdef __MMI_BIDI_ALG__
  1692.         nLen = UCS2Strlen((const char*)String);
  1693.         if(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH) 
  1694.             len = MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH;
  1695. //        MMI_ASSERT(!(nLen > MAX_SHOW_STRING_TEXT_LENGTH - ENCODING_LENGTH));
  1696.         if (len > 0)
  1697.         {
  1698.             UCS2Strncpy((S8*) show_pwcWord, (S8*) String, len);
  1699.         }
  1700.         else
  1701.         {
  1702.             UCS2Strcpy((S8*) show_pwcWord, (S8*) String);
  1703.         }
  1704.         nLen = UCS2Strlen((const char*)show_pwcWord);
  1705.         /* PMT NO_AR_SL_DU START 20050909 */
  1706.     #if defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__)
  1707.     #if defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__)
  1708.         if (nLen)
  1709.         {
  1710.         #ifdef __MMI_ZI_V7__
  1711.         #if defined(__MMI_ZI_PERSIAN__) && defined(__MMI_ZI_ARABIC__)
  1712.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  1713.         #elif defined (__MMI_ZI_PERSIAN__)
  1714.             ZiStringShape(ZI8_LANG_FA, (U16 *) & nLen, show_pwcWord);
  1715.         #elif defined (__MMI_ZI_ARABIC__)
  1716.             ZiStringShape(ZI8_LANG_AR, (U16 *) & nLen, show_pwcWord);
  1717.         #endif 
  1719.         #else /* __MMI_ZI_V7__ */ 
  1720.             ArabicStringShape((U16 *) & nLen, show_pwcWord);
  1721.         #endif /* __MMI_ZI_V7__ */ 
  1722.         }
  1723.     #else /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  1724.         if (nLen)
  1725.         {
  1726.             ArabicShapeEngine((U16*) & nLen, show_pwcWord); /* output will replace the input string after returning */
  1727.         }
  1728.     #endif /* defined(__MMI_ZI_ARABIC__) || defined(__MMI_ZI_PERSIAN__) */ 
  1729.     #endif /* defined(__MMI_LANG_ARABIC__) || defined(__MMI_LANG_PERSIAN__) */ 
  1730.  
  1731.         /* PMT NO_AR_SL_DU END 20050909 */
  1732.         String = (U8*) show_pwcWord;
  1733.         bidi_get_char_type((U8*) String, (U8*) & default_direction);
  1734.         logical_cur_pos = 0;
  1736.         if (default_direction == BIDI_R || default_direction == AL)
  1737.         {
  1738.             bidi_main(
  1739.                 (U8*) String,
  1740.                 (U16) UCS2Strlen((const S8*)String),
  1741.                 logical_cur_pos,
  1742.                 show_visual_str,
  1743.                 &visual_str_len,
  1744.                 &visual_cur_pos,
  1745.                 MMI_TRUE,
  1746.                 MMI_bidi_input_type,
  1747.                 0,
  1748.                 0,
  1749.                 &visual_hilight_start,
  1750.                 &visual_hilight_end);
  1751.             default_direction = BIDI_R;
  1752.         }
  1753.         else    /* if(default_direction == BIDI_L) */
  1754.         {
  1755.             bidi_main(
  1756.                 (U8*) String,
  1757.                 (U16) UCS2Strlen((const S8*)String),
  1758.                 logical_cur_pos,
  1759.                 show_visual_str,
  1760.                 &visual_str_len,
  1761.                 &visual_cur_pos,
  1762.                 MMI_FALSE,
  1763.                 MMI_bidi_input_type,
  1764.                 0,
  1765.                 0,
  1766.                 &visual_hilight_start,
  1767.                 &visual_hilight_end);
  1768.             default_direction = BIDI_L;
  1769.         }
  1771.         /* START FARHAD PMT 20050211 */
  1772.     #ifdef __MMI_HINDI_ALG__
  1773.         if (r2lMMIFlag)
  1774.         {
  1775.             get_hindi_rules_for_whole_string(show_visual_str);
  1776.             hindi_rule_string = 0;
  1777.         }
  1778.     #endif /* __MMI_HINDI_ALG__ */ 
  1779.         /* END FARHAD PMT 20050211 */
  1781.         if ((r2lMMIFlag && default_direction == BIDI_L) || (!r2lMMIFlag && default_direction != BIDI_L))
  1782.         {
  1783.             bidi_reverse(show_visual_str, (U16) UCS2Strlen((const S8*)show_visual_str));
  1784.         }
  1786.         temp_text_P = String;
  1787.         String = show_visual_str;
  1788.     #endif /* __MMI_BIDI_ALG__ */ 
  1789.     }   /* added farhad 20012005 */
  1791.     if (gnCurrentFontAttrib & FONTATTRIB_ITALIC)
  1792.     {
  1793.         font_attr |= FONTATTRIB_ITALIC;
  1794.     }
  1795.     else if (gnCurrentFontAttrib & FONTATTRIB_OBLIQUE)
  1796.     {
  1797.         font_attr |= FONTATTRIB_OBLIQUE;
  1798.     }
  1800.     if (Font.underline)
  1801.     {
  1802.         font_attr |= FONTATTRIB_UNDERLINE;
  1803.     }
  1805.     if (Bordered)
  1806.     {
  1807.         border_color = gdi_act_color_from_rgb(0xff, UI_text_border_color.r, UI_text_border_color.g, UI_text_border_color.b);
  1808.     }
  1809.     text_color = gdi_act_color_from_rgb(0xff, UI_current_text_color.r, UI_current_text_color.g, UI_current_text_color.b);
  1811.     gdi_font_begin(text_color, font_attr);
  1812.     //UI_current_text_color = UI_text_color;
  1813.     //Process string
  1814. #ifdef __MMI_HINDI_ALG__
  1815.     if (hf_is_reset_hindi_params())
  1816.     {
  1817.         reset_hindi_params();
  1818.     }
  1819.     if (Font.color == 0)
  1820.     {
  1821.         Font.color = 15;
  1822.     }
  1823.     //For hindi character sudden disappear 
  1824.     //UI_current_text_color = UI_text_color;
  1825.     if (hf_is_hindi_rules_parsing())
  1826.     {
  1827.         U16 cluster_fill[G_MAX];
  1828.         S32 cluster_length;
  1829.         U16 glyph_output[G_MAX];
  1830.         S32 Len;
  1832.         /* PMT FARHAD START 20050708 */
  1833.         S32 total_len = 0;
  1834.         S32 original_len = 0;
  1836.         /* PMT FARHAD END 20050708 */
  1837.         S32 width, height;
  1839.         pre2Ch = 0;
  1840.         preCh = 0;
  1841.         init_cluster_start_p(String);
  1842.         /* PMT FARHAD START 20050708 */
  1843.         if (len > 0)
  1844.         {
  1845.             init_cluster_end_p(String + (len * 2));
  1846.         }
  1847.         else
  1848.         {
  1849.             init_cluster_end_p(String + (2 * UCS2Strlen((const char*)String) + 1));
  1850.         }
  1851.         original_len = len;
  1852.         /* PMT FARHAD END 20050708 */
  1853.         hf_disable_hindi_rules_parsing();
  1854.         hf_disable_hindi_reset_hindi_params();
  1855.         /* W05.34 For Hindi with Bidi issue */
  1856.         single_time_bidi = 1;
  1857.         do
  1858.         {
  1859.             cluster_length = hf_get_cluster(cluster_fill);
  1860.             /* PMT FARHAD START 20050708 */
  1861.             total_len += cluster_length;
  1862.             if (original_len > 0)
  1863.             {
  1864.                 if (total_len > original_len)
  1865.                 {
  1866.                     break;
  1867.                 }
  1868.             }
  1869.             /* PMT FARHAD END 20050708 */
  1870.             if (cluster_length)
  1871.             {
  1872.                 Len = hf_hindi_rules(glyph_output, cluster_fill, cluster_length);
  1873.                 ShowStackedString(CurrentX, CurrentY, Font, BackGround, (U8*) glyph_output, LineHeight, Bordered, len);
  1874.                 Get_StringWidthHeight((U8*) glyph_output, &width, &height);
  1875.                 CurrentX += width;
  1876.             }
  1877.         } while (cluster_length);
  1878.         hf_enable_hindi_rules_parsing();
  1879.         hf_enable_hindi_reset_hindi_params();
  1880.         /* W05.34 For Hindi with Bidi issue */
  1881.         single_time_bidi = 0;
  1882.         gdi_font_end();
  1884.         return 0;
  1885.         /* GDI_RETURN(0); */
  1886.     }
  1887. #endif /* __MMI_HINDI_ALG__ */ 
  1889.     if (r2lMMIFlag)
  1890.     {
  1892.         while (1)
  1893.         {
  1894.             curCh = (String[temp_len] | (String[temp_len + 1] << 8));
  1895.             if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  1896.             {
  1897.                 has_thai_char = MMI_TRUE;
  1898.                 break;
  1899.             }
  1900.             temp_len += 2;
  1901.             if (curCh == 0x0000)
  1902.             {
  1903.                 break;
  1904.             }
  1905.         }
  1907.         if (has_thai_char == MMI_TRUE)
  1908.         {
  1909.             bidi_reverse(String, (U16) UCS2Strlen((const S8*)String));
  1910.             Get_StringWidthHeight(String, &str_width, &str_height);
  1911.             CurrentX -= str_width;
  1912.         }
  1914.     }
  1916.     while (len != 0)
  1917.     {
  1918.         iX = CurrentX;
  1919.         iY = CurrentY;
  1920.         /* prepare the unicode of current and next characters */
  1921.         curCh = (String[0] | (String[1] << 8));
  1922.         nextCharUCS2 = (String[2] | (String[3] << 8));
  1924.         if (curCh == 0x0000)
  1925.         {
  1926.             break;
  1927.         }
  1929.         len--;
  1931.         if (FONT_TEST_CONTROL_CHAR(curCh))
  1932.         {
  1933.             curCh = 0x20;
  1934.         }
  1935.     #if defined(__MMI_LANG_VIETNAMESE__)
  1936.         if ((curCh > 0x0040) && (curCh < 0x01B1))
  1937.         {
  1938.             tone_mark = mmi_viet_tone_mark(nextCharUCS2);
  1939.             if (VIET_TONE_NONE != tone_mark)
  1940.             {
  1941.                 viet_vowel = mmi_viet_vowel_letter(curCh);
  1942.                 if (VIET_VOWEL_NONE != viet_vowel)
  1943.                 {
  1944.                     curCh = mmi_viet_combine_vowel_tone(viet_vowel, tone_mark);
  1945.                     String += 2;
  1946.                 }
  1947.             }
  1948.         }
  1949.     #endif /* defined(__MMI_LANG_VIETNAMESE__) */ 
  1951.     #if defined(__MMI_HINDI_ALG__)
  1952.         NumChar = GetFontdata(curCh, Font, &CharData, &nWidth, &nDWidth, &nHgt);
  1953.         get_text_x(&iX, curCh, iY, nDWidth, nWidth);
  1954.     #else /* defined(__MMI_HINDI_ALG__) */ 
  1955.         NumChar = GetFontdata(curCh, Font, &CharData, &nWidth, &nHgt);
  1956.     #endif /* defined(__MMI_HINDI_ALG__) */ 
  1958.         /* check if current character is in Thai character ranges */
  1959.         if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  1960.         {
  1961.             /* Base line character, can combinate with above vowels,bottom vowels, tone mark, and sign */
  1962.             if (IsThaiBaseLineChar(curCh))
  1963.             {
  1964.                 //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  1965.                 //moved ahead to let the circyle sign on the top of previous or previous2 character
  1966.                 if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  1967.                 {
  1968.                     iX -= 4;
  1969.                 }
  1970.                 CurrentX = (iX + (S32) nWidth + interLeaving);
  1971.             }
  1972.             /* For Thai digits and base line sign, the only thing we have to do is moving cursor */
  1973.             else if (IsThaiDigitChar(curCh) || IsThaiBaseSignChar(curCh))
  1974.             {
  1975.                 CurrentX = (iX + (S32) nWidth + interLeaving);
  1976.             }
  1977.             else if (IsThaiAboveLineChar(curCh))
  1978.             {
  1979.                 /* Above line characters */
  1980.                 iY -= 1;    /* Reserver 1 pixtel vertical interleaving */
  1981.                 if (IsThaiBaseLineChar(preCh))
  1982.                 {
  1983.                     /* Process the X coordinate when combining with other base line characters */
  1984.                     iX -= ((S32) nWidth + interLeaving);
  1985.                     if (IsThaiLongTailChar(preCh))  /* move ahead 3 pixels, */
  1986.                     {
  1987.                         iX -= 3;
  1988.                     }
  1989.                     else if (preCh == 0x0E0A || preCh == 0x0E0B)
  1990.                     {
  1991.                         iX -= 2;
  1992.                     }
  1993.                     else if (preCh == 0x0E2C)   /* move ahead 6 pixels */
  1994.                     {
  1995.                         iX -= 6;
  1996.                     }
  1997.                 }
  1998.             }
  1999.             else if (IsThaiBottomLineChar(curCh))
  2000.             {
  2001.                 /* Bottom line characters */
  2002.                 iY += interLeaving;
  2003.                 if (IsThaiBaseLineChar(preCh))
  2004.                 {
  2005.                     iX -= ((S32) nWidth + interLeaving);
  2006.                     if (preCh == 0x0E2C)
  2007.                     {
  2008.                         iX -= 2;    /* move ahead for 2 pixels */
  2009.                     }
  2010.                 }
  2011.             }
  2012.             else if (IsThaiToneMark(curCh))
  2013.             {
  2014.                 /* Tone marks */
  2015.                 iY -= 1;
  2016.                 if (IsThaiBaseLineChar(preCh))
  2017.                 {
  2018.                     iX -= ((S32) nWidth + interLeaving);
  2019.                     if (preCh == 0x0E33)
  2020.                     {
  2021.                         iY -= 3;    /* move tone mark higher */
  2022.                         if (IsThaiBaseLineChar(pre2Ch))
  2023.                         {
  2024.                             iX -= 7;    /* Move tone mark ahead across the width of */
  2025.                         }
  2026.                     }
  2027.                     else if (nextCharUCS2 == 0x0E33)
  2028.                     {
  2029.                         iY -= 3;    /* move tone mark higher */
  2030.                     }
  2031.                     else if (IsThaiLongTailChar(preCh))
  2032.                     {
  2033.                         iX -= 3;    /* move tone mark ahead for 3 pixel */
  2034.                     }
  2035.                     else if (preCh == 0x0E0A || preCh == 0x0E0B)
  2036.                     {
  2037.                         iX -= 2;
  2038.                     }
  2039.                     else if (preCh == 0x0E2C)
  2040.                     {
  2041.                         iX -= 6;
  2042.                     }
  2043.                 }
  2044.                 else if (IsThaiAboveLineChar(preCh))
  2045.                 {
  2046.                     iY -= 3;
  2047.                     iX -= ((S32) nWidth + interLeaving);
  2048.                     if (IsThaiLongTailChar(pre2Ch))
  2049.                     {
  2050.                         iX -= 3;
  2051.                     }
  2052.                     else if (pre2Ch == 0x0E0A || pre2Ch == 0x0E0B)
  2053.                     {
  2054.                         iX -= 2;
  2055.                     }
  2056.                     else if (pre2Ch == 0x0E2C)
  2057.                     {
  2058.                         iX -= 6;
  2059.                     }
  2060.                 }
  2061.                 else if (IsThaiBottomLineChar(preCh))
  2062.                 {
  2063.                     iX -= ((S32) nWidth + interLeaving);
  2064.                     if (IsThaiLongTailChar(pre2Ch))
  2065.                     {
  2066.                         iX -= 3;
  2067.                     }
  2068.                 }
  2069.                 else if (preCh == 0x0E47 || preCh == 0x0E4C)
  2070.                 {
  2071.                     /* move the tone mark to next character space */
  2072.                     iX += ((S32) nWidth + interLeaving);
  2073.                     CurrentX += ((S32) nWidth + interLeaving);
  2074.                 }
  2075.                 else
  2076.                 {
  2077.                     CurrentX += ((S32) nWidth + interLeaving);
  2078.                 }
  2079.             }
  2080.             iY += (str_height - nHgt);
  2081.             ShowCharFuncDispatch(LineHeight, nWidth, nHgt, iX, iY, Font, BackGround, CharData, NumChar, Bordered);
  2082.         }
  2083.         else    /* non-Thai char */
  2084.         {
  2085.             if (r2lMMIFlag
  2086.         #ifdef __MMI_HINDI_ALG__
  2087.                 && (!cancelWidth)
  2088.         #endif 
  2089.                 )
  2090.             {
  2091.             #ifdef __MMI_HINDI_ALG__
  2092.                 if (UI_HINDI_CHARACTER_UCS2_RANGE(curCh))
  2093.                 {
  2094.                     /* PMT START MAUI_00223197 */
  2095.                     if ((preCh != S_VISARGA) && UI_HINDI_SIGN_RANGE(preCh))
  2096.                         /* PMT END MAUI_00223197 */
  2097.                     {
  2098.                         CurrentX -= 0;
  2099.                     }
  2100.                     /* PMT START MAUI_00223197 */
  2101.                     else if ((curCh != S_VISARGA) && UI_HINDI_SIGN_RANGE(curCh))
  2102.                         /* PMT END MAUI_00223197 */
  2103.                     {
  2104.                         CurrentX -= nWidth;
  2105.                     }
  2106.                     else
  2107.                     {
  2108.                         CurrentX -= nDWidth;
  2109.                     }
  2110.                 }
  2111.                 else
  2112.             #endif /* __MMI_HINDI_ALG__ */ 
  2113.                 if (!has_thai_char)
  2114.                 {
  2115.                     CurrentX -= nWidth;
  2116.                 }
  2117.             }
  2118.             /* PMT FARHAD START 20050708 */
  2119.         #ifndef __MMI_HINDI_ALG__
  2120.             iX = CurrentX;
  2121.         #endif 
  2122.             /* PMT FARHAD END 20050708 */
  2123.             iY += (str_height - nHgt);
  2124.             ShowCharFuncDispatch(LineHeight, nWidth, nHgt, iX, iY, Font, BackGround, CharData, NumChar, Bordered);
  2126.             if (!r2lMMIFlag || has_thai_char)
  2127.             {
  2128.                 CurrentX += nWidth;
  2129.             }
  2130.         }
  2131.         nHgt = (U8) LineHeight;
  2132.         pre2Ch = preCh;
  2133.         preCh = curCh;
  2134.         String += 2;
  2135.         /* W05.50 Skip unnecessary action when the character is out of clip */
  2136.         if ((iX > clip_x2) && !r2lMMIFlag)
  2137.         {
  2138.             break;
  2139.         }
  2140.     }
  2141.     gdi_font_end();
  2143.     return CurrentX;
  2144.     //GDI_RETURN(CurrentX);
  2145.     //GDI_EXIT_CRITICAL_SECTION(ShowStackedString)
  2146. }
  2149. /*****************************************************************************
  2150.  * FUNCTION
  2151.  *  ShowStackedChar
  2152.  * DESCRIPTION
  2153.  *  
  2154.  * PARAMETERS
  2155.  *  CurrentX        [IN]        
  2156.  *  CurrentY        [IN]        
  2157.  *  Font            [IN]        
  2158.  *  BackGround      [IN]        
  2159.  *  curCh           [IN]        
  2160.  *  LineHeight      [IN]        
  2161.  *  Bordered        [IN]        
  2162.  *  pre2Ch          [IN]        
  2163.  *  preCh           [IN]        
  2164.  * RETURNS
  2165.  *  void
  2166.  *****************************************************************************/
  2167. void ShowStackedChar(
  2168.         S32 CurrentX,
  2169.         S32 CurrentY,
  2170.         stFontAttribute Font,
  2171.         U8 BackGround,
  2172.         U16 curCh,
  2173.         U32 LineHeight,
  2174.         U32 Bordered,
  2175.         U16 pre2Ch,
  2176.         U16 preCh)
  2177. {
  2178.     /*----------------------------------------------------------------*/
  2179.     /* Local Variables                                                */
  2180.     /*----------------------------------------------------------------*/
  2181.     /* GDI_ENTER_CRITICAL_SECTION(ShowStackedChar) */
  2182.     U8 *CharData;
  2183.     U32 NumChar;
  2184.     U16 nHgt;
  2185.     U16 nWidth;
  2187. #ifdef __MMI_HINDI_ALG__
  2188.     U16 nDWidth;
  2189. #endif 
  2190.     S32 interLeaving = gThaiFontInterSpace;
  2191.     S32 iX = CurrentX;
  2192.     S32 iY = CurrentY;
  2193.     gdi_color border_color = 0, text_color;
  2194.     U8 font_attr = 0;
  2196.     /*----------------------------------------------------------------*/
  2197.     /* Code Body                                                      */
  2198.     /*----------------------------------------------------------------*/
  2199.     if (gnCurrentFontAttrib & FONTATTRIB_ITALIC)
  2200.     {
  2201.         font_attr |= FONTATTRIB_ITALIC;
  2202.     }
  2203.     else if (gnCurrentFontAttrib & FONTATTRIB_OBLIQUE)
  2204.     {
  2205.         font_attr |= FONTATTRIB_OBLIQUE;
  2206.     }
  2208.     if (Font.underline)
  2209.     {
  2210.         font_attr |= FONTATTRIB_UNDERLINE;
  2211.     }
  2213.     {
  2214.         if (Bordered)
  2215.         {
  2216.             border_color = gdi_act_color_from_rgb(0xff, UI_text_border_color.r, UI_text_border_color.g, UI_text_border_color.b);
  2217.         }
  2219.         text_color = gdi_act_color_from_rgb(0xff, UI_current_text_color.r, UI_current_text_color.g, UI_current_text_color.b);
  2221.     }
  2223. #ifdef __MMI_SUPPORT_DUMP_SCREEN_STRING__
  2224. mmi_trace_screen_char(CurrentX, CurrentY, curCh, 0, Bordered);
  2225. #endif
  2227.     if (FONT_TEST_CONTROL_CHAR(curCh))
  2228.     {
  2229.         curCh = 0x20;
  2230.     }
  2232. #ifdef __MMI_HINDI_ALG__
  2233.     NumChar = GetFontdata(curCh, Font, &CharData, &nWidth, &nDWidth, &nHgt);
  2234. #else 
  2235.     NumChar = GetFontdata(curCh, Font, &CharData, &nWidth, &nHgt);
  2236. #endif 
  2238.     gdi_font_begin(text_color, font_attr);
  2240.     /* adjust iX and iY for Thai characters */
  2241.     if (curCh >= 0x0E01 && curCh <= 0x0E7F)
  2242.     {
  2243.         if (IsThaiBaseLineChar(curCh))
  2244.         {
  2245.             if (IsThaiLongTailChar(curCh))
  2246.             {
  2247.                 iX += 1;
  2248.             }
  2249.             //if the current character is 0x0E33 and previous or previous 2 character is base line character, 0x0E33 shall be
  2250.             //moved ahead to let the circyle sign on the top of previous or previous2 character
  2251.             if (curCh == 0x0E33 && (IsThaiBaseLineChar(preCh) || IsThaiBaseLineChar(pre2Ch)))
  2252.             {
  2253.                 iX -= 1;
  2254.             }
  2256.         }
  2257.         else if (IsThaiAboveLineChar(curCh))
  2258.         {
  2259.             /* Above line characters */
  2260.             iY -= 1;    /* Reserver 1 pixtel vertical interleaving */
  2261.             if (IsThaiBaseLineChar(preCh))
  2262.             {
  2263.                 /* Process the X coordinate when combining with other base line characters */
  2264.                 iX -= ((S32) nWidth + interLeaving);
  2265.                 if (IsThaiLongTailChar(preCh))  /* move ahead 3 pixels, */
  2266.                 {
  2267.                     iX -= 3;
  2268.                 }
  2269.                 else if (preCh == 0x0E0A || preCh == 0x0E0B)
  2270.                 {
  2271.                     iX -= 2;
  2272.                 }
  2273.                 else if (preCh == 0x0E2C)   /* move ahead 6 pixels */
  2274.                 {
  2275.                     iX -= 6;
  2276.                 }
  2277.             }
  2279.         }
  2280.         else if (IsThaiBottomLineChar(curCh))
  2281.         {
  2282.             /* Bottom line characters */
  2283.             iY += interLeaving;
  2284.             if (IsThaiBaseLineChar(preCh))
  2285.             {
  2286.                 iX -= ((S32) nWidth + interLeaving);
  2287.                 if (preCh == 0x0E2C)
  2288.                 {
  2289.                     iX -= 2;    /* move ahead for 2 pixels */
  2290.                 }
  2291.             }
  2292.         }
  2293.         else if (IsThaiToneMark(curCh))
  2294.         {
  2295.             /* Tone marks */
  2296.             iY -= 1;
  2297.             if (IsThaiBaseLineChar(preCh))
  2298.             {
  2299.                 iX -= ((S32) nWidth + interLeaving);
  2300.                 if (preCh == 0x0E33)
  2301.                 {
  2302.                     iY -= 3;    /* move tone mark higher */
  2303.                     if (IsThaiBaseLineChar(pre2Ch))
  2304.                     {
  2305.                         iX -= 7;    /* Move tone mark ahead across the width of */
  2306.                     }
  2308.                 }
  2309.                 //else if(nextCharUCS2 == 0x0E33)
  2310.                 //       iY -= 3;//move tone mark higher
  2311.                 else if (IsThaiLongTailChar(preCh))
  2312.                 {
  2313.                     iX -= 3;    /* move tone mark ahead for 3 pixel */
  2314.                 }
  2315.                 else if (preCh == 0x0E0A || preCh == 0x0E0B)
  2316.                 {
  2317.                     iX -= 2;
  2318.                 }
  2319.                 else if (preCh == 0x0E2C)
  2320.                 {
  2321.                     iX -= 6;
  2322.                 }
  2323.             }
  2324.             else if (IsThaiAboveLineChar(preCh))
  2325.             {
  2326.                 iY -= 3;
  2327.                 iX -= ((S32) nWidth + interLeaving);
  2328.                 if (IsThaiLongTailChar(pre2Ch))
  2329.                 {
  2330.                     iX -= 3;
  2331.                 }
  2332.                 else if (pre2Ch == 0x0E0A || pre2Ch == 0x0E0B)
  2333.                 {
  2334.                     iX -= 2;
  2335.                 }
  2336.                 else if (pre2Ch == 0x0E2C)
  2337.                 {
  2338.                     iX -= 6;
  2339.                 }
  2340.             }
  2341.             else if (IsThaiBottomLineChar(preCh))
  2342.             {
  2343.                 iX -= ((S32) nWidth + interLeaving);
  2344.                 if (IsThaiLongTailChar(pre2Ch))
  2345.                 {
  2346.                     iX -= 3;
  2347.                 }
  2348.             }
  2349.             else if (preCh == 0x0E47 || preCh == 0x0E4C)
  2350.             {
  2351.                 /* move the tone mark to next character space */
  2352.                 iX += ((S32) nWidth + interLeaving);
  2353.             }
  2355.         }
  2356.         //(1)Other cases: For Thai digits and base line sign, the only thing we have to do is moving cursor
  2357.         //(2)Show Characters
  2358.         ShowCharFuncDispatch(LineHeight, nWidth, nHgt, iX, iY, Font, BackGround, CharData, NumChar, Bordered);
  2360.     }
  2361.     else    /* non-Thai char */
  2362.     {
  2363.         ShowCharFuncDispatch(LineHeight, nWidth, nHgt, iX, iY, Font, BackGround, CharData, NumChar, Bordered);
  2364.     }
  2365.     gdi_font_end();
  2366.     /* GDI_EXIT_CRITICAL_SECTION(ShowStackedChar) */
  2367. }
  2369. const L2RLangSSC l2RLangSSC[] = 
  2370. {
  2371.     /* PMT START GR_HE_CZ_FI_DA_HU 20051007 */
  2372.     SSC_ARABIC,
  2373.     SSC_PERSIAN,
  2374.     SSC_HEBREW
  2375.         /* PMT END GR_HE_CZ_FI_DA_HU 20051007 */
  2376. };
  2379. /*****************************************************************************
  2380.  * FUNCTION
  2381.  *  IsL2RMMIStyle
  2382.  * DESCRIPTION
  2383.  *  
  2384.  * PARAMETERS
  2385.  *  void
  2386.  * RETURNS
  2387.  *  
  2388.  *****************************************************************************/
  2389. BOOL IsL2RMMIStyle(void)
  2390. {
  2391.     /*----------------------------------------------------------------*/
  2392.     /* Local Variables                                                */
  2393.     /*----------------------------------------------------------------*/
  2394.     U16 index = 0;
  2395.     U8 temp_str1[30];
  2396.     U8 temp_str2[30];
  2398.     /*----------------------------------------------------------------*/
  2399.     /* Code Body                                                      */
  2400.     /*----------------------------------------------------------------*/
  2401.     AnsiiToUnicodeString((S8*) temp_str1, (S8*) gLanguageArray[gCurrLangIndex].aLangSSC);
  2403.     for (index = 0; index < (sizeof(l2RLangSSC) / sizeof(l2RLangSSC[0])); index++)
  2404.     {
  2405.         AnsiiToUnicodeString((S8*) temp_str2, (S8*) l2RLangSSC[index].sscString);
  2406.         /* pTemp = (U8 *) temp_str; */
  2408.         if (UCS2Strcmp((const S8*)temp_str1, (const S8*)temp_str2) == 0)
  2409.         {
  2410.             return MMI_TRUE;
  2411.         }
  2413.     }
  2415.     return MMI_FALSE;
  2417. }
  2420. /*****************************************************************************
  2421.  * FUNCTION
  2422.  *  ShowDebugString
  2423.  * DESCRIPTION
  2424.  *  
  2425.  * PARAMETERS
  2426.  *  x               [IN]        
  2427.  *  y               [IN]        
  2428.  *  Font            [IN]        
  2429.  *  String          [?]         
  2430.  *  len             [IN]        
  2431.  *  LineHeight      [IN]        
  2432.  *  Bordered        [IN]        
  2433.  * RETURNS
  2434.  *  
  2435.  *****************************************************************************/
  2436. U32 ShowDebugString(S32 x, S32 y, stFontAttribute Font, U8 *String, S32 len, U32 LineHeight, U32 Bordered)
  2437. {
  2438.     /*----------------------------------------------------------------*/
  2439.     /* Local Variables                                                */
  2440.     /*----------------------------------------------------------------*/
  2441.     /* GDI_ENTER_CRITICAL_SECTION(ShowDebugString) */
  2442.     U8 *CharData;
  2444.     U32 NumChar;
  2445.     U32 Counter = 0;
  2446.     S32 CurrentX;
  2447.     U16 nHgt;
  2448.     U16 nWidth;
  2449.     S32 nXOffset;
  2450.     S32 nYOffset;
  2451.     S32 yy;
  2452.     U16 unicode = 0;
  2454. #ifdef __MMI_HINDI_ALG__
  2455.     U16 nDWidth = 0;
  2456. #endif 
  2458.     U8 font_attr = 0;
  2459.     gdi_color border_color = 0, text_color;
  2461.     /*----------------------------------------------------------------*/
  2462.     /* Code Body                                                      */
  2463.     /*----------------------------------------------------------------*/
  2464.     if (gnCurrentFontAttrib & FONTATTRIB_ITALIC)
  2465.     {
  2466.         font_attr |= FONTATTRIB_ITALIC;
  2467.     }
  2468.     else if (gnCurrentFontAttrib & FONTATTRIB_OBLIQUE)
  2469.     {
  2470.         font_attr |= FONTATTRIB_OBLIQUE;
  2471.     }
  2473.     if (Font.underline)
  2474.     {
  2475.         font_attr |= FONTATTRIB_UNDERLINE;
  2476.     }
  2478.     {
  2479.         if (Bordered)
  2480.         {
  2481.             border_color = gdi_act_color_from_rgb(0xff, UI_text_border_color.r, UI_text_border_color.g, UI_text_border_color.b);
  2482.         }
  2484.         text_color = gdi_act_color_from_rgb(0xff, UI_current_text_color.r, UI_current_text_color.g, UI_current_text_color.b);
  2486.     }
  2488.     gdi_font_begin(text_color, font_attr);
  2490.     CurrentX = x;
  2491.     while (len != 0)
  2492.     {
  2493.         if ((String[0] == '') && (String[1] == ''))
  2494.         {
  2495.             break;
  2496.         }
  2497.         len--;
  2499.         unicode = String[0];
  2500.         unicode |= (String[1] << 8);
  2502.         if (FONT_TEST_CONTROL_CHAR(unicode))
  2503.         {
  2504.             unicode = 0x20;
  2505.         }
  2507.     #ifdef __MMI_HINDI_ALG__
  2508.         NumChar = GetFontdata(unicode, Font, &CharData, &nWidth, &nDWidth, &nHgt);
  2509.     #else 
  2510.         NumChar = GetFontdata(unicode, Font, &CharData, &nWidth, &nHgt);
  2511.     #endif 
  2513.         Counter++;
  2515.         if (LineHeight > 0)
  2516.         {
  2517.             yy = y + LineHeight - nHgt;
  2518.         }
  2519.         else
  2520.         {
  2521.             yy = y;
  2522.         }
  2524.         nXOffset = CurrentX + nWidth;
  2525.         nYOffset = yy + nHgt;
  2527.         if (Bordered)
  2528.         {
  2529.             gdi_show_char_bordered(CurrentX, yy, text_color, border_color, CharData, NumChar, nWidth, nHgt, font_attr);
  2530.         }
  2531.         else if (!
  2532.                  (gnCurrentFontAttrib & FONTATTRIB_BOLD &&
  2533.                   gpCurrentFont->pFontType[gnCurrentFont][gbFontType] & FONTATTRIB_BOLD) ||
  2534.                  !(gpCurrentFont->pFontType[gnCurrentFont][gbFontType] & FONTATTRIB_NORMAL))
  2535.         {
  2536.             gdi_show_char(CurrentX, yy, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  2537.         }
  2538.         else
  2539.         {
  2540.             gdi_show_char(CurrentX + 1, yy, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  2541.             gdi_show_char(CurrentX, yy, text_color, CharData, NumChar, nWidth, nHgt, font_attr);
  2542.         }
  2544.         CurrentX += nWidth;
  2546.         nHgt = (U8) LineHeight;
  2547.         String += 2;
  2548.     }
  2549.     gdi_font_end();
  2551.     return CurrentX;
  2552.     /* GDI_RETURN (CurrentX); */
  2554.     /* GDI_EXIT_CRITICAL_SECTION(ShowDebugString) */
  2556. }
  2558. /*-----------------------------------------------------------------------*/
  2559. /*--------------------------- *** End *** -------------------------------*/
  2560. /*-----------------------------------------------------------------------*/