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

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

MTK

开发平台：

C/C++

Calculator.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * Calculator.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  * MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  * This file implements Calculator application.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * removed!
  112.  *
  113.  * removed!
  114.  * removed!
  115.  * removed!
  116.  *
  117.  * removed!
  118.  * removed!
  119.  * removed!
  120.  *
  121.  * removed!
  122.  * removed!
  123.  * removed!
  124.  *
  125.  * removed!
  126.  * removed!
  127.  * removed!
  128.  *
  129.  * removed!
  130.  * removed!
  131.  * removed!
  132.  *
  133.  * removed!
  134.  * removed!
  135.  * removed!
  136.  *
  137.  * removed!
  138.  * removed!
  139.  * removed!
  140.  *
  141.  * removed!
  142.  * removed!
  143.  * removed!
  144.  *
  145.  * removed!
  146.  * removed!
  147.  * removed!
  148.  *
  149.  * removed!
  150.  * removed!
  151.  * removed!
  152.  *
  153.  * removed!
  154.  * removed!
  155.  * removed!
  156.  *
  157.  * removed!
  158.  * removed!
  159.  * removed!
  160.  *
  161.  * removed!
  162.  * removed!
  163.  * removed!
  164.  *
  165.  * removed!
  166.  * removed!
  167.  * removed!
  168.  *
  169.  * removed!
  170.  * removed!
  171.  * removed!
  172.  *
  173.  * removed!
  174.  * removed!
  175.  * removed!
  176.  *
  177.  * removed!
  178.  * removed!
  179.  * removed!
  180.  *
  181.  * removed!
  182.  * removed!
  183.  * removed!
  184.  *
  185.  * removed!
  186.  * removed!
  187.  * removed!
  188.  *
  189.  * removed!
  190.  * removed!
  191.  * removed!
  192.  *
  193.  * removed!
  194.  * removed!
  195.  * removed!
  196.  *
  197.  * removed!
  198.  * removed!
  199.  * removed!
  200.  *
  201.   * Dec 11 2005 mtk01215
  202.  * removed!
  203.  * removed!
  204.  *
  205.  * removed!
  206.  * removed!
  207.  * removed!
  208.  *
  209.  * removed!
  210.  * removed!
  211.  * removed!
  212.  * removed!
  213.  *
  214.  * removed!
  215.  * removed!
  216.  * removed!
  217.  *
  218.  * removed!
  219.  * removed!
  220.  * removed!
  221.  *
  222.  * removed!
  223.  * removed!
  224.  * removed!
  225.  *
  226.  * removed!
  227.  * removed!
  228.  * removed!
  229.  *
  230.  * removed!
  231.  * removed!
  232.  * removed!
  233.  *
  234.  * removed!
  235.  * removed!
  236.  * removed!
  237.  *
  238.  * removed!
  239.  * removed!
  240.  * removed!
  241.  *
  242.  *------------------------------------------------------------------------------
  243.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  244.  *============================================================================
  245.  ****************************************************************************/
  246.  /**
  247.  * Copyright Notice
  248.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  249.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  250.  *  (It is illegal to remove this copyright notice from this software or any
  251.  *  portion of it)
  252.  */
  253. /**********************************************************************************
  254.    Filename:      Calculator.c
  255.    Author:        manju
  256.    Date Created:  June-21-2003
  257.    Contains:      Calculator
  258. **********************************************************************************/
  260. #ifndef _MMI_CALCULATOR_C
  261. #define _MMI_CALCULATOR_C
  263. #include "MMI_features.h"
  264. #include "PixtelDataTypes.h"
  265. #include "Unicodexdcl.h"
  266. #ifdef __MMI_TOUCH_CALCULATOR__
  267. /* start vijay 20050301 foe calculator */
  268. #include "gdi_include.h"
  269. #include "wgui.h"
  270. /* end vijay */
  271. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  273. #include "gui.h"
  274. #include "Calculator.h"
  275. #include "SettingProfile.h"
  276. #include "ProfileGprots.h"
  278. #ifdef __MMI_CALCULATOR__
  279. #include "Globaldefs.h"
  280. #include "CustDataRes.h"
  281. #include "gui_themes.h"
  282. #include "wgui_categories.h"
  283. #include "wgui_softkeys.h"
  284. #include "HistoryGprot.h"
  285. #include "OrganizerDef.h"
  286. #endif /* __MMI_CALCULATOR__ */ 
  288. /* MTK Elvis for R2L characters */
  289. extern BOOL r2lMMIFlag;
  291. /* MTK end */
  293. /* 
  294.  * Define
  295.  */
  296. /* Images for the calculator: Currently hardcoded */
  297. #define CALC_MAX_DIGITS          12
  298. #define CALC_MAX_BUFF_LEN        30
  300. #ifdef __MMI_CALCULATOR__
  301. #define CALC_NUM_BUTTONS         9
  303. #define CALC_SCR_X               0
  304. #define CALC_SCR_WIDTH           UI_device_width
  305. #define CALC_SCR_HEIGHT          (CALC_NUM_HEIGHT * 3 + 1)
  307. #if defined (__MMI_MAINLCD_128X128__) || defined (__MMI_MAINLCD_128X160__)
  308. #if defined (__MMI_MAINLCD_128X128__)
  309. #define CALC_NUM_HEIGHT 13
  310. #define CALC_KEYPAD_Y (CALC_NUM_HEIGHT * 3 + 2)
  311. #else
  312. #define CALC_NUM_HEIGHT 15
  313. #define CALC_KEYPAD_Y (CALC_NUM_HEIGHT * 3 + 15)
  314. #endif
  315. #ifdef __MMI_SLIM_CALCULATOR__
  316. #define CALC_KEYPAD_X            19
  317. #else 
  318. #define CALC_KEYPAD_X            21
  319. #endif 
  320. #define CALC_SCR_Y               0
  321. #else /* defined (__MMI_MAINLCD_128X128__) || defined (__MMI_MAINLCD_128X160__) */ 
  323. #if defined (__MMI_MAINLCD_176X220__)
  324. #define CALC_NUM_HEIGHT 15
  325. #define MAP_IMG_WIDTH 176
  326. #else /* defined (__MMI_MAINLCD_176X220__) */ 
  327. #define MAP_IMG_WIDTH   240
  328. #define CALC_NUM_HEIGHT 22
  329. #endif /* defined (__MMI_MAINLCD_176X220__) */ 
  331. #define CALC_KEYPAD_Y            (CALC_SCR_Y + CALC_NUM_HEIGHT * 3 + 15)
  332. #define CALC_KEYPAD_X            ((CALC_SCR_WIDTH - MAP_IMG_WIDTH)/2)   /* 0 */
  333. #define CALC_SCR_Y               0 + MMI_status_bar_height + MMI_TITLE_HEIGHT
  334. #endif /* defined (__MMI_MAINLCD_128X128__) || defined (__MMI_MAINLCD_128X160__) */ 
  336. #define CALC_OPERAND1_Y          (CALC_SCR_Y + CALC_NUM_HEIGHT)
  337. #define CALC_OPERAND2_Y          (CALC_SCR_Y + CALC_NUM_HEIGHT * 2)
  339. #define CALC_KEYPAD_WIDTH        86
  340. #define CALC_KEYPAD_HEIGHT       63
  342. #define CALC_OPERATOR_X          5
  343. #define CALC_OPERATOR_Y          CALC_OPERAND2_Y
  344. #define CALC_MEM_X1              2
  345. #define CALC_MEM_Y1              CALC_SCR_Y+1
  346. #define CALC_MEM_X2              CALC_SCR_WIDTH - 2
  347. #define CALC_MEM_Y2              CALC_OPERAND1_Y - 1
  349. #define RESULT_NOT_EXCEED        0
  350. #define RESULT_EXCEED            1
  352. #define CALC_RSK_BACK            0
  353. #define CALC_RSK_CLEAR           1
  354. #define CALC_ZEOR_LEN            1
  355. #define CALC_ZEOR_DOT_LEN           3
  357. #define CALC_SYM_ERROR     (UI_character_type)'E'
  358. #define CALC_SYM_EQUAL     (UI_character_type)'='
  359. #define CALC_SYM_PLUS      (UI_character_type)'+'
  360. #define CALC_SYM_MINUS     (UI_character_type)'-'
  361. #define CALC_SYM_MUL    (UI_character_type)'x'
  362. #define CALC_SYM_DIV    (UI_character_type)'/'
  363. #define CALC_SYM_DOT    (UI_character_type)'.'
  364. #define CALC_SYM_ZERO      (UI_character_type)'0'
  365. #define CALC_SYM_NULL      (UI_character_type)''
  367. #define CALC_RESERVED_SPACE_FOR_OPERATOR     20
  369. /* 
  370.  * Typedef 
  371.  */
  372. typedef struct
  373. {
  374.     S32 x;
  375.     S32 y;
  376.     PU8 image;
  377. } calc_img_struct;
  379. typedef struct
  380. {
  381.     DOUBLE Operand1;
  382.     DOUBLE Operand2;
  383. #ifndef __MMI_SLIM_CALCULATOR__
  384.     DOUBLE MemValue;
  385. #endif 
  386.     calc_img_struct OperatorImg[CALC_NUM_BUTTONS];
  387.     UI_character_type Operand1Buf[CALC_MAX_DIGITS + 2];
  388.     UI_character_type Operand2Buf[CALC_MAX_DIGITS + 2];
  389.     U8 Operand1Len;
  390.     U8 Operand2Len;
  391.     U8 Operator;
  392.     U8 CurrHilite;
  393.     U8 ResultState;
  394.     U8 RSKState;
  395.     U8 ExecFlag;    /* if just after execution */
  396.     U8 OpToExecute; /* operator to execute */
  397.     U8 IsRSKPress;
  398.     U8 ComputeType;
  399. } calc_context_struct;
  401. typedef enum
  402. {
  403.     CALC_OP_PLUS = 0,
  404.     CALC_OP_MINUS,
  405.     CALC_OP_MULT,
  406.     CALC_OP_DIV,
  407.     CALC_OP_EQUAL,
  408. #ifndef __MMI_SLIM_CALCULATOR__
  409.     CALC_OP_MP,
  410.     CALC_OP_MM,
  411.     CALC_OP_MC,
  412.     CALC_OP_MR,
  413. #endif /* __MMI_SLIM_CALCULATOR__ */ 
  414.     CALC_OP_NONE
  415. } CALC_OPER_ENUM;
  417. #ifdef __MMI_TOUCH_CALCULATOR__
  419. typedef enum
  420. {
  421.     TOUCH_CALC_KEY0 = 0,
  422.     TOUCH_CALC_KEY1,
  423.     TOUCH_CALC_KEY2,
  424.     TOUCH_CALC_KEY3,
  425.     TOUCH_CALC_KEY4,
  426.     TOUCH_CALC_KEY5,
  427.     TOUCH_CALC_KEY6,
  428.     TOUCH_CALC_KEY7,
  429.     TOUCH_CALC_KEY8,
  430.     TOUCH_CALC_KEY9,
  431.     TOUCH_CALC_KEY_DOT = 20 /* pound key or hash key */
  432. } TOUCH_CALC_NUM_KEY_ENUM;
  434. typedef enum
  435. {
  436.     TOUCH_CALC_OP_PLUS = CALC_OP_PLUS,
  437.     TOUCH_CALC_OP_MINUS = CALC_OP_MINUS,
  438.     TOUCH_CALC_OP_MULT = CALC_OP_MULT,
  439.     TOUCH_CALC_OP_DIV = CALC_OP_DIV,
  440.     TOUCH_CALC_OP_MP = CALC_OP_MP,
  441.     TOUCH_CALC_OP_MM = CALC_OP_MM,
  442.     TOUCH_CALC_OP_MC = CALC_OP_MC,
  443.     TOUCH_CALC_OP_MR = CALC_OP_MR,
  444.     TOUCH_CALC_OP_EQUAL = CALC_OP_EQUAL
  445. } TOUCH_CALC_SYM_KEY_ENUM;
  447. typedef enum
  448. {
  449.     TOUCH_CALC_PEN_NONE,
  450.     TOUCH_CALC_PEN_LSK,
  451.     TOUCH_CALC_PEN_RSK,
  452.     TOUCH_CALC_PEN_NUM_KEY
  453. } touch_calc_pen_state_enum;
  455. const S32 TouchCalcKeys[CALC_TOUCH_NROWS][CALC_TOUCH_NCOLUMNS] = 
  456. {
  457.     {TOUCH_CALC_OP_MP, TOUCH_CALC_OP_MM, TOUCH_CALC_OP_MR, TOUCH_CALC_OP_MC},
  458.     {TOUCH_CALC_KEY7, TOUCH_CALC_KEY8, TOUCH_CALC_KEY9, TOUCH_CALC_OP_DIV},
  459.     {TOUCH_CALC_KEY4, TOUCH_CALC_KEY5, TOUCH_CALC_KEY6, TOUCH_CALC_OP_MULT},
  460.     {TOUCH_CALC_KEY1, TOUCH_CALC_KEY2, TOUCH_CALC_KEY3, TOUCH_CALC_OP_MINUS},
  461.     {TOUCH_CALC_KEY0, TOUCH_CALC_KEY_DOT, TOUCH_CALC_OP_EQUAL, TOUCH_CALC_OP_PLUS}
  462. };
  464. const MMI_ID_TYPE calculator_key_image[] = 
  465. {
  466.     IMG_ID_TOUCH_CALC_MP,
  467.     IMG_ID_TOUCH_CALC_MM,
  468.     IMG_ID_TOUCH_CALC_MR,
  469.     IMG_ID_TOUCH_CALC_MC,
  470.     IMG_ID_TOUCH_CALC_KEY7,
  471.     IMG_ID_TOUCH_CALC_KEY8,
  472.     IMG_ID_TOUCH_CALC_KEY9,
  473.     IMG_ID_TOUCH_CALC_DIVIDE,
  474.     IMG_ID_TOUCH_CALC_KEY4,
  475.     IMG_ID_TOUCH_CALC_KEY5,
  476.     IMG_ID_TOUCH_CALC_KEY6,
  477.     IMG_ID_TOUCH_CALC_MULTIPLY,
  478.     IMG_ID_TOUCH_CALC_KEY1,
  479.     IMG_ID_TOUCH_CALC_KEY2,
  480.     IMG_ID_TOUCH_CALC_KEY3,
  481.     IMG_ID_TOUCH_CALC_MINUS,
  482.     IMG_ID_TOUCH_CALC_KEY0,
  483.     IMG_ID_TOUCH_CALC_KEY_DOT,
  484.     IMG_ID_TOUCH_CALC_KEY_EQUAL,
  485.     IMG_ID_TOUCH_CALC_PLUS
  486. };
  487. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  489. /* 
  490.  * Local Variable
  491.  */
  493. const color gCalcResultScrColor = {255, 234, 182, 100};
  494. const color gCalcResultBorderColor = {255, 186, 64, 100};
  495. const color gCalcTextColor = {0, 0, 0, 100};
  497. #ifdef __MMI_TOUCH_CALCULATOR__
  498. /* start vijay 20050305 */
  499. const color gTouchCalcResultScrColor = {209, 232, 254, 100};
  501. /* end vijay */
  502. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  503. extern const U8 gCalcImgCoor[][2];
  505. extern U8 matrix_main_menu_highlight_bitmap_data[]; /* 041205 Calvin added image cache buffer for calculator */
  507. /* 
  508.  * Local Function
  509.  */
  510. #ifdef __MMI_TOUCH_CALCULATOR__
  511. void mmi_touchcalc_pen_down_hdlr(mmi_pen_point_struct point);
  512. void mmi_touchcalc_pen_up_hdlr(mmi_pen_point_struct point);
  513. void mmi_touchcalc_pen_move_hdlr(mmi_pen_point_struct point);
  514. void mmi_touchcalc_pen_repeat_hdlr(mmi_pen_point_struct point);
  515. void mmi_touchcalc_pen_long_tap_hdlr(mmi_pen_point_struct point);
  516. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  517. U8 mmi_calc_del_scr_callback(void *p);
  519. /* 
  520.  * Global Variable
  521.  */
  522. calc_context_struct *g_calc_cntx = NULL;
  524. #ifdef __MMI_TOUCH_CALCULATOR__
  525. calculator_keypad_struct calculator_keypad;
  526. touch_calc_pen_state_enum calc_pen_on_object = TOUCH_CALC_PEN_NONE;
  528. #define CALC_PEN_DOWN_ON_KEYPAD     0x0001
  529. BOOL TOUCH_CALC_SELECT_KEY = TRUE;
  530. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  532. /* 
  533.  * Global Function
  534.  */
  536. /* Button co-ordinates for the on screen calculator keypad */
  538. #endif /* __MMI_CALCULATOR__ */ 
  539. #define CALC_UTILITY
  542. /*****************************************************************************
  543.  * FUNCTION
  544.  *  CalcDouble2String
  545.  * DESCRIPTION
  546.  *  
  547.  * PARAMETERS
  548.  *  num         [IN]        
  549.  *  result      [?]         
  550.  *  digits      [IN]        
  551.  * RETURNS
  552.  *  void
  553.  *****************************************************************************/
  554. void CalcDouble2String(DOUBLE num, S8 *result, U8 digits)
  555. {
  556.     /*----------------------------------------------------------------*/
  557.     /* Local Variables                                                */
  558.     /*----------------------------------------------------------------*/
  559.     S32 precision;
  561.     /*----------------------------------------------------------------*/
  562.     /* Code Body                                                      */
  563.     /*----------------------------------------------------------------*/
  564.     precision = CalcComputePrecision(num, digits);
  565.     gui_float_string(num, precision, result);
  566. }
  569. /*****************************************************************************
  570.  * FUNCTION
  571.  *  gui_atof
  572.  * DESCRIPTION
  573.  *  Convert string to float
  574.  * PARAMETERS
  575.  *  s       [IN]        String to be converted
  576.  * RETURNS
  577.  *  float value of the string
  578.  *****************************************************************************/
  579. DOUBLE gui_atof(UI_string_type s)
  580. {
  581.     /*----------------------------------------------------------------*/
  582.     /* Local Variables                                                */
  583.     /*----------------------------------------------------------------*/
  584.     S8 ansii_str[CALC_MAX_BUFF_LEN];
  586.     /*----------------------------------------------------------------*/
  587.     /* Code Body                                                      */
  588.     /*----------------------------------------------------------------*/
  589.     UnicodeToAnsii((S8*) ansii_str, (S8*) s);
  590.     return atof(ansii_str);
  591. }
  594. /*****************************************************************************
  595.  * FUNCTION
  596.  *  gui_float_string
  597.  * DESCRIPTION
  598.  *  Convert float to string
  599.  * PARAMETERS
  600.  *  dob_val         [IN]            Value to be converted.
  601.  *  prec_val        [IN]            Number of precision.
  602.  *  out_buffer      [IN/OUT]        Pointer to the result string
  603.  * RETURNS
  604.  *  void
  605.  *****************************************************************************/
  606. void gui_float_string(DOUBLE dob_val, S32 prec_val, S8 *out_buffer)
  607. {
  608.     /*----------------------------------------------------------------*/
  609.     /* Local Variables                                                */
  610.     /*----------------------------------------------------------------*/
  611.     S8 ansii_str[CALC_MAX_BUFF_LEN];
  612.     S8 fmt[8];
  613.     U8 i;
  615.     /*----------------------------------------------------------------*/
  616.     /* Code Body                                                      */
  617.     /*----------------------------------------------------------------*/
  618.     memset(ansii_str, 0, CALC_MAX_BUFF_LEN);
  619.     memset(fmt, 0, 8);
  621.     sprintf(fmt, "%%.%df", prec_val);
  622.     sprintf(ansii_str, fmt, dob_val);
  624.     /* to prevent 123.250000 */
  625.     if (prec_val > 0)
  626.     {
  627.         for (i = CALC_MAX_BUFF_LEN - 1; i != 0; i--)
  628.         {
  629.             if (ansii_str[i] == 0)
  630.             {
  631.                 continue;
  632.             }
  633.             else if (ansii_str[i] == '0')
  634.             {
  635.                 ansii_str[i] = 0;
  636.             }
  637.             else
  638.             {
  639.                 break;
  640.             }
  641.         }
  642.     }
  644.     /* to prevent -0 */
  645.     if (strlen(ansii_str) == 2 && ansii_str[0] == '-' && ansii_str[1] == '0')
  646.     {
  647.         ansii_str[0] = '0';
  648.         ansii_str[1] = 0;
  649.     }
  650.     AnsiiToUnicodeString(out_buffer, ansii_str);
  651. }
  654. /*****************************************************************************
  655.  * FUNCTION
  656.  *  CalcComputePrecision
  657.  * DESCRIPTION
  658.  *  To retrive the length of precision part of a given number.
  659.  * PARAMETERS
  660.  *  result          [IN]        The number to be computed.
  661.  *  max_digits      [IN]        Maximum digits of the number
  662.  * RETURNS
  663.  *  void
  664.  *****************************************************************************/
  665. S32 CalcComputePrecision(DOUBLE result, S16 max_digits)
  666. {
  667.     /*----------------------------------------------------------------*/
  668.     /* Local Variables                                                */
  669.     /*----------------------------------------------------------------*/
  670.     S32 prec_val = 0;
  671.     U8 str[CALC_MAX_BUFF_LEN];
  672.     S8 fmt[8];
  673.     S8 decimal_length = 0;
  675.     /*----------------------------------------------------------------*/
  676.     /* Code Body                                                      */
  677.     /*----------------------------------------------------------------*/
  678.     if (result < 0)
  679.     {
  680.         result = -(result);
  681.     }
  682.     /*
  683.      * str[]        = x.xxxxxxxxxxxe+/-xxx
  684.      * ex: 0.0000000001 = 1.00000000000e-010
  685.      * 646464646464 = 6.46464646464e+011
  686.      */
  687.     memset(fmt, 0, 8);
  688.     sprintf(fmt, "%%%d.%de", max_digits, (max_digits - 2));
  690.     memset(str, '', CALC_MAX_BUFF_LEN);
  691.     sprintf((S8*) str, fmt, result);
  693.     if (str[max_digits] == 'e')
  694.     {
  695.         S32 j;
  697.         memset(fmt, 0, 8);
  698.         memcpy(fmt, str + (max_digits + 2), 3);
  699.         prec_val = atoi(fmt);
  701.         /* Out of boundary */
  702.         if (prec_val >= max_digits - 1)
  703.         {
  704.             return 0;
  705.         }
  707.         if (str[max_digits + 1] == '-')
  708.         {
  709.             j = (max_digits - 1) - prec_val;
  710.         }
  711.         else
  712.         {
  713.             j = max_digits - 1;
  714.         }
  716.         for (; j > 1; j--)
  717.         {
  718.             if (str[j] != '0')
  719.             {
  720.                 decimal_length = (j - 1);
  721.                 break;
  722.             }
  723.         }
  724.         /* |result| < 1 */
  725.         if (str[max_digits + 1] == '-')
  726.         {
  727.             prec_val += decimal_length;
  728.         }
  729.         /* |result| >= 1 */
  730.         else if (str[max_digits + 1] == '+')
  731.         {
  732.             if (decimal_length > prec_val)
  733.             {
  734.                 prec_val = decimal_length - prec_val;
  735.             }
  736.             else
  737.             {
  738.                 prec_val = 0;
  739.             }
  740.         }
  741.     }
  743.     return prec_val;
  745. }
  747. #ifdef __MMI_CALCULATOR__
  749. #define CALC_INITIALIZE
  752. /*****************************************************************************
  753.  * FUNCTION
  754.  *  HighlightCalcMenu
  755.  * DESCRIPTION
  756.  *  Highlight handler of Calculator menu item.
  757.  *  Register key handlers.
  758.  * PARAMETERS
  759.  *  void
  760.  * RETURNS
  761.  *  void
  762.  *****************************************************************************/
  763. void HighlightCalcMenu(void)
  764. {
  765.     /*----------------------------------------------------------------*/
  766.     /* Local Variables                                                */
  767.     /*----------------------------------------------------------------*/
  769.     /*----------------------------------------------------------------*/
  770.     /* Code Body                                                      */
  771.     /*----------------------------------------------------------------*/
  772.     SetLeftSoftkeyFunction(CalcPreEntryApp, KEY_EVENT_UP);
  773.     SetKeyHandler(CalcPreEntryApp, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  774.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  775.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  776. }
  779. /*****************************************************************************
  780.  * FUNCTION
  781.  *  CalcInit
  782.  * DESCRIPTION
  783.  *  Initialize highlight handler and global vairables.
  784.  * PARAMETERS
  785.  *  void
  786.  * RETURNS
  787.  *  void
  788.  *****************************************************************************/
  789. void CalcInit(void)
  790. {
  791.     /*----------------------------------------------------------------*/
  792.     /* Local Variables                                                */
  793.     /*----------------------------------------------------------------*/
  795.     /*----------------------------------------------------------------*/
  796.     /* Code Body                                                      */
  797.     /*----------------------------------------------------------------*/
  798.     SetHiliteHandler(EXTRA_CALCULATOR_MENU, HighlightCalcMenu);
  799. }
  802. /*****************************************************************************
  803.  * FUNCTION
  804.  *  CalcDeInit
  805.  * DESCRIPTION
  806.  *  Free dynamic memory.
  807.  * PARAMETERS
  808.  *  void
  809.  * RETURNS
  810.  *  void
  811.  *****************************************************************************/
  812. void CalcDeInit(void)
  813. {
  814.     /*----------------------------------------------------------------*/
  815.     /* Local Variables                                                */
  816.     /*----------------------------------------------------------------*/
  818.     /*----------------------------------------------------------------*/
  819.     /* Code Body                                                      */
  820.     /*----------------------------------------------------------------*/
  821.     if (g_calc_cntx)
  822.     {
  823.         OslMfree(g_calc_cntx);
  824.         g_calc_cntx = NULL;
  825.     }
  826. }
  829. /*****************************************************************************
  830.  * FUNCTION
  831.  *  mmi_calc_del_scr_callback
  832.  * DESCRIPTION
  833.  *  Callback function of delete calculator screen
  834.  * PARAMETERS
  835.  *  p       [?]     
  836.  * RETURNS
  837.  *  void
  838.  *****************************************************************************/
  839. U8 mmi_calc_del_scr_callback(void *p)
  840. {
  841.     /*----------------------------------------------------------------*/
  842.     /* Local Variables                                                */
  843.     /*----------------------------------------------------------------*/
  845.     /*----------------------------------------------------------------*/
  846.     /* Code Body                                                      */
  847.     /*----------------------------------------------------------------*/
  848.     CalcDeInit();
  849.     return MMI_FALSE;
  850. }
  853. /*****************************************************************************
  854.  * FUNCTION
  855.  *  CalcFreeMemAndBack
  856.  * DESCRIPTION
  857.  *  Free memory and exit calculator application.
  858.  * PARAMETERS
  859.  *  void
  860.  * RETURNS
  861.  *  void
  862.  *****************************************************************************/
  863. void CalcFreeMemAndBack(void)
  864. {
  865.     /*----------------------------------------------------------------*/
  866.     /* Local Variables                                                */
  867.     /*----------------------------------------------------------------*/
  869.     /*----------------------------------------------------------------*/
  870.     /* Code Body                                                      */
  871.     /*----------------------------------------------------------------*/
  872.     if (g_calc_cntx->IsRSKPress)
  873.     {
  874.         g_calc_cntx->IsRSKPress = FALSE;
  875.         SetRightSoftkeyFunction(NULL, KEY_EVENT_LONG_PRESS);
  876.     }
  877.     else
  878.     {
  879.         /* CalcDeInit(); */
  880.         GoBackHistory();
  881.     }
  882. }
  885. /*****************************************************************************
  886.  * FUNCTION
  887.  *  CalcSetRSKClear
  888.  * DESCRIPTION
  889.  *  Change RSK to "Clear"
  890.  * PARAMETERS
  891.  *  void
  892.  * RETURNS
  893.  *  void
  894.  *****************************************************************************/
  895. void CalcSetRSKClear(void)
  896. {
  897.     /*----------------------------------------------------------------*/
  898.     /* Local Variables                                                */
  899.     /*----------------------------------------------------------------*/
  901.     /*----------------------------------------------------------------*/
  902.     /* Code Body                                                      */
  903.     /*----------------------------------------------------------------*/
  904.     ChangeRightSoftkey(STR_GLOBAL_CLEAR, IMG_GLOBAL_CLEAR);
  905.     SetRightSoftkeyFunction(CalcHandleRSKLongPress, KEY_LONG_PRESS);
  906.     SetRightSoftkeyFunction(CalcHandleClearKey, KEY_EVENT_UP);
  907. }
  910. /*****************************************************************************
  911.  * FUNCTION
  912.  *  CalcSetRSKBack
  913.  * DESCRIPTION
  914.  *  Change RSK to "Back"
  915.  * PARAMETERS
  916.  *  void
  917.  * RETURNS
  918.  *  void
  919.  *****************************************************************************/
  920. void CalcSetRSKBack(void)
  921. {
  922.     /*----------------------------------------------------------------*/
  923.     /* Local Variables                                                */
  924.     /*----------------------------------------------------------------*/
  926.     /*----------------------------------------------------------------*/
  927.     /* Code Body                                                      */
  928.     /*----------------------------------------------------------------*/
  929.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_OK);
  930.     SetRightSoftkeyFunction(CalcFreeMemAndBack, KEY_EVENT_UP);
  931. }
  934. /*****************************************************************************
  935.  * FUNCTION
  936.  *  CalcResetResultValue
  937.  * DESCRIPTION
  938.  *  Reset memory related variables
  939.  * PARAMETERS
  940.  *  void
  941.  * RETURNS
  942.  *  void
  943.  *****************************************************************************/
  944. void CalcResetResultValue(void)
  945. {
  946.     /*----------------------------------------------------------------*/
  947.     /* Local Variables                                                */
  948.     /*----------------------------------------------------------------*/
  950.     /*----------------------------------------------------------------*/
  951.     /* Code Body                                                      */
  952.     /*----------------------------------------------------------------*/
  953.     g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  954.     g_calc_cntx->Operator = CALC_OP_NONE;
  955.     g_calc_cntx->Operand1 = 0;
  957.     g_calc_cntx->Operand2Buf[0] = CALC_SYM_NULL;
  958.     g_calc_cntx->Operand1Buf[0] = CALC_SYM_NULL;
  960.     memset(g_calc_cntx->Operand2Buf, 0, sizeof(g_calc_cntx->Operand2Buf));
  961.     memset(g_calc_cntx->Operand1Buf, 0, sizeof(g_calc_cntx->Operand1Buf));
  963.     g_calc_cntx->Operand2Len = 1;
  964.     g_calc_cntx->Operand1Len = 1;
  966.     g_calc_cntx->OpToExecute = CALC_OP_NONE;
  967.     g_calc_cntx->RSKState = CALC_RSK_BACK;
  968.     g_calc_cntx->ExecFlag = FALSE;
  970.     g_calc_cntx->ResultState = RESULT_NOT_EXCEED;
  972. }
  975. /*****************************************************************************
  976.  * FUNCTION
  977.  *  CalcResetMemValue
  978.  * DESCRIPTION
  979.  *  Reset memory related variables
  980.  * PARAMETERS
  981.  *  void
  982.  * RETURNS
  983.  *  void
  984.  *****************************************************************************/
  985. #ifndef __MMI_SLIM_CALCULATOR__
  986. void CalcResetMemValue(void)
  987. {
  988.     /*----------------------------------------------------------------*/
  989.     /* Local Variables                                                */
  990.     /*----------------------------------------------------------------*/
  992.     /*----------------------------------------------------------------*/
  993.     /* Code Body                                                      */
  994.     /*----------------------------------------------------------------*/
  995.     g_calc_cntx->ResultState = RESULT_NOT_EXCEED;
  996.     g_calc_cntx->MemValue = 0;
  997. }
  998. #endif /* __MMI_SLIM_CALCULATOR__ */ 
  1001. /*****************************************************************************
  1002.  * FUNCTION
  1003.  *  CalcResetContext
  1004.  * DESCRIPTION
  1005.  *  Reset all values to default.
  1006.  * PARAMETERS
  1007.  *  void
  1008.  * RETURNS
  1009.  *  void
  1010.  *****************************************************************************/
  1011. void CalcResetContext()
  1012. {
  1013.     /*----------------------------------------------------------------*/
  1014.     /* Local Variables                                                */
  1015.     /*----------------------------------------------------------------*/
  1017.     /*----------------------------------------------------------------*/
  1018.     /* Code Body                                                      */
  1019.     /*----------------------------------------------------------------*/
  1020.     CalcResetResultValue();
  1021. #ifndef __MMI_SLIM_CALCULATOR__
  1022.     CalcResetMemValue();
  1023. #endif 
  1024. }
  1026. #define CALC_DRAW_FUNC
  1029. /*****************************************************************************
  1030.  * FUNCTION
  1031.  *  CalcShowKeypad
  1032.  * DESCRIPTION
  1033.  *  Draw keypad of calculator.
  1034.  * PARAMETERS
  1035.  *  void
  1036.  * RETURNS
  1037.  *  void
  1038.  *****************************************************************************/
  1039. void CalcShowKeypad(void)
  1040. {
  1041.     /*----------------------------------------------------------------*/
  1042.     /* Local Variables                                                */
  1043.     /*----------------------------------------------------------------*/
  1045.     /*----------------------------------------------------------------*/
  1046.     /* Code Body                                                      */
  1047.     /*----------------------------------------------------------------*/
  1048.     gui_reset_clip();
  1050.     gui_show_image(CALC_KEYPAD_X, CALC_KEYPAD_Y, (PU8) GetImage(IMG_ID_CALC_MAIN));
  1052.     gui_show_transparent_image(
  1053.         CALC_KEYPAD_X + g_calc_cntx->OperatorImg[g_calc_cntx->CurrHilite].x,
  1054.         CALC_KEYPAD_Y + g_calc_cntx->OperatorImg[g_calc_cntx->CurrHilite].y,
  1055.         (PU8) g_calc_cntx->OperatorImg[g_calc_cntx->CurrHilite].image,
  1056.         0);
  1057. #if(UI_DOUBLE_BUFFER_SUPPORT)
  1058.     gui_BLT_double_buffer(CALC_KEYPAD_X, CALC_KEYPAD_Y, UI_device_width - 1, UI_device_height - 1);
  1059. #endif 
  1060. }
  1063. /*****************************************************************************
  1064.  * FUNCTION
  1065.  *  CalcShowResultScreen
  1066.  * DESCRIPTION
  1067.  *  Draw result screen area.
  1068.  * PARAMETERS
  1069.  *  void
  1070.  * RETURNS
  1071.  *  void
  1072.  *****************************************************************************/
  1073. void CalcShowResultScreen()
  1074. {
  1075.     /*----------------------------------------------------------------*/
  1076.     /* Local Variables                                                */
  1077.     /*----------------------------------------------------------------*/
  1078.     UI_character_type op = CALC_SYM_ERROR;
  1079.     S32 w;
  1080.     S8 uni_s[64];
  1081.     S32 temp_int;
  1083.     DOUBLE temp_res = 0;
  1084.     S8 ansii_str[CALC_MAX_BUFF_LEN];
  1086. #ifndef __MMI_SLIM_CALCULATOR__
  1087.     S8 uni_memory[64];
  1088. #endif 
  1090.     /*----------------------------------------------------------------*/
  1091.     /* Code Body                                                      */
  1092.     /*----------------------------------------------------------------*/
  1093. #if(UI_DOUBLE_BUFFER_SUPPORT)
  1094.     gui_lock_double_buffer();
  1095. #endif 
  1097. #if defined(__MMI_TOUCH_CALCULATOR__)
  1098.     gui_set_font(&MMI_large_font);
  1099.     gui_set_text_color(gCalcTextColor);
  1100.     gui_reset_clip();
  1101.     gui_reset_text_clip();
  1102.     gui_fill_rectangle(
  1103.         calculator_keypad.result_area_x,
  1104.         calculator_keypad.result_area_y,
  1105.         calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - 1,
  1106.         calculator_keypad.result_area_y + CALC_TOUCH_RESULT_AREA_HEIGHT - 1,
  1107.         gTouchCalcResultScrColor);
  1108. #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1109.     gui_set_font(&MMI_medium_font);
  1110.     gui_set_text_color(gCalcTextColor);
  1112.     /* screen background */
  1113.     gui_reset_clip();
  1114.     gui_reset_text_clip();
  1115.     gui_fill_rectangle(
  1116.         CALC_SCR_X,
  1117.         CALC_SCR_Y,
  1118.         CALC_SCR_X + CALC_SCR_WIDTH - 1,
  1119.         CALC_SCR_Y + CALC_SCR_HEIGHT - 1,
  1120.         gCalcResultScrColor);
  1121.     gui_draw_rectangle(
  1122.         CALC_SCR_X,
  1123.         CALC_SCR_Y,
  1124.         CALC_SCR_X + CALC_SCR_WIDTH - 1,
  1125.         CALC_SCR_Y + CALC_SCR_HEIGHT - 1,
  1126.         gCalcResultBorderColor);
  1127.     gui_draw_rectangle(
  1128.         CALC_SCR_X + 1,
  1129.         CALC_SCR_Y + 1,
  1130.         CALC_SCR_X + CALC_SCR_WIDTH - 2,
  1131.         CALC_SCR_Y + CALC_SCR_HEIGHT - 2,
  1132.         gCalcResultBorderColor);
  1133. #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ /* end of __MMI_TOUCH_CALCULATOR__ */
  1134. #if !defined(__MMI_TOUCH_CALCULATOR__) && !defined(__MMI_SLIM_CALCULATOR__)     /* 050905 Sophie modified */
  1135.     /* memory filed */
  1136.     if (r2lMMIFlag)
  1137.     {
  1138.         w = gui_get_character_width((UI_character_type) '[');
  1139.         gui_move_text_cursor(CALC_MEM_X1 + w, CALC_MEM_Y1);
  1140.     }
  1141.     else
  1142.     {
  1143.         gui_move_text_cursor(CALC_MEM_X1, CALC_MEM_Y1);
  1144.     }
  1146.     gui_print_character((UI_character_type) '[');
  1148.     if (r2lMMIFlag)
  1149.     {
  1150.         w = gui_get_character_width((UI_character_type) ']');
  1151.         gui_move_text_cursor(CALC_MEM_X2 - 6 + w, CALC_MEM_Y1);
  1152.     }
  1153.     else
  1154.     {
  1155.         gui_move_text_cursor(CALC_MEM_X2 - 6, CALC_MEM_Y1);
  1156.     }
  1158.     gui_print_character((UI_character_type) ']');
  1159. #endif /* !defined(__MMI_TOUCH_CALCULATOR__) && !defined(__MMI_SLIM_CALCULATOR__) */ 
  1160.     if (g_calc_cntx->ResultState == RESULT_EXCEED)
  1161.     {
  1162.         op = CALC_SYM_ERROR;
  1164.         w = gui_get_character_width(CALC_SYM_ZERO);
  1166.         if (r2lMMIFlag)
  1167.         {
  1168.             gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR, CALC_OPERAND2_Y);
  1169.         }
  1170.     #if defined(__MMI_TOUCH_CALCULATOR__)
  1171.         else
  1172.         {
  1173.             gui_move_text_cursor(
  1174.                 calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1175.                 calculator_keypad.operand2_y);
  1176.         }
  1177.     #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1178.         else
  1179.         {
  1180.             gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1181.         }
  1182.     #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1183.         gui_print_character(CALC_SYM_ZERO);
  1184.     }
  1185.     else
  1186.     {
  1187.         if (g_calc_cntx->Operator == CALC_OP_EQUAL)
  1188.         {
  1189.             op = CALC_SYM_EQUAL;
  1191.             temp_int = (S32) g_calc_cntx->Operand1;
  1192.             if (temp_int == g_calc_cntx->Operand1)
  1193.             {
  1194.                 sprintf(ansii_str, "%d", temp_int);
  1195.                 AnsiiToUnicodeString((S8*) uni_s, (S8*) ansii_str);
  1196.             }
  1197.             else
  1198.             {
  1199.                 CalcDouble2String(g_calc_cntx->Operand1, uni_s, CALC_MAX_DIGITS);
  1200.                 g_calc_cntx->Operand1 = gui_atof((UI_string_type) uni_s);
  1201.             }
  1202.             w = gui_get_string_width((UI_string_type) uni_s);
  1204.             if (r2lMMIFlag)
  1205.             {
  1206.                 gui_move_text_cursor(
  1207.                     CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1208.                     CALC_OPERAND2_Y);
  1209.             }
  1210.         #if defined(__MMI_TOUCH_CALCULATOR__)
  1211.             else
  1212.             {
  1213.                 gui_move_text_cursor(
  1214.                     calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1215.                     calculator_keypad.operand2_y);
  1216.             }
  1217.         #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1218.             else
  1219.             {
  1220.                 gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1221.             }
  1222.         #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1223.             gui_print_text((UI_string_type) uni_s);
  1224.         }
  1225.         else if (g_calc_cntx->Operator == CALC_OP_NONE)
  1226.         {
  1227.             if (g_calc_cntx->CurrHilite < CALC_OP_EQUAL)    /* +,-,*,/ */
  1228.             {
  1229.                 switch (g_calc_cntx->CurrHilite)
  1230.                 {
  1231.                     case CALC_OP_PLUS:
  1232.                         op = CALC_SYM_PLUS;
  1233.                         break;
  1234.                     case CALC_OP_MINUS:
  1235.                         op = CALC_SYM_MINUS;
  1236.                         break;
  1237.                     case CALC_OP_MULT:
  1238.                         op = CALC_SYM_MUL;
  1239.                         break;
  1240.                     case CALC_OP_DIV:
  1241.                         op = CALC_SYM_DIV;
  1242.                         break;
  1243.                     default:
  1244.                         break;
  1245.                 }
  1247.                 temp_res = gui_atof((UI_string_type) g_calc_cntx->Operand2Buf);
  1248.                 CalcDouble2String(temp_res, uni_s, CALC_MAX_DIGITS);
  1250.                 w = gui_get_string_width((UI_string_type) uni_s);
  1252.                 if (r2lMMIFlag)
  1253.                 {
  1254.                     gui_move_text_cursor(
  1255.                         CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1256.                         CALC_OPERAND1_Y);
  1257.                 }
  1258.             #if defined(__MMI_TOUCH_CALCULATOR__)
  1259.                 else
  1260.                 {
  1261.                     gui_move_text_cursor(
  1262.                         calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1263.                         calculator_keypad.operand2_y);
  1264.                 }
  1265.             #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1266.                 else
  1267.                 {
  1268.                     gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND1_Y);
  1269.                 }
  1270.             #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1271.                 gui_print_text((UI_string_type) uni_s);
  1273.                 w = gui_get_character_width(CALC_SYM_ZERO);
  1275.                 if (r2lMMIFlag)
  1276.                 {
  1277.                     gui_move_text_cursor(
  1278.                         CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1279.                         CALC_OPERAND2_Y);
  1280.                 }
  1281.             #if defined(__MMI_TOUCH_CALCULATOR__)
  1282.                 else
  1283.                 {
  1284.                     gui_move_text_cursor(
  1285.                         calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1286.                         calculator_keypad.operand2_y);
  1287.                 }
  1288.             #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1289.                 else
  1290.                 {
  1291.                     gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1292.                 }
  1293.             #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1295.                 gui_print_character(CALC_SYM_ZERO);
  1296.             }
  1297.             else
  1298.             {
  1299.                 op = CALC_SYM_NULL;
  1300.                 if (g_calc_cntx->Operand2Buf[0] == CALC_SYM_NULL)
  1301.                 {
  1302.                     w = gui_get_character_width(CALC_SYM_ZERO);
  1304.                     if (r2lMMIFlag)
  1305.                     {
  1306.                         gui_move_text_cursor(
  1307.                             CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1308.                             CALC_OPERAND2_Y);
  1309.                     }
  1310.                 #if defined(__MMI_TOUCH_CALCULATOR__)
  1311.                     else
  1312.                     {
  1313.                         gui_move_text_cursor(
  1314.                             calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1315.                             calculator_keypad.operand2_y);
  1316.                     }
  1317.                 #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1318.                     else
  1319.                     {
  1320.                         gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1321.                     }
  1322.                 #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1323.                     gui_print_character(CALC_SYM_ZERO);
  1324.                 }
  1325.                 else
  1326.                 {
  1327.                     w = gui_get_string_width(g_calc_cntx->Operand2Buf);
  1329.                     if (r2lMMIFlag)
  1330.                     {
  1331.                         gui_move_text_cursor(
  1332.                             CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1333.                             CALC_OPERAND2_Y);
  1334.                     }
  1335.                 #if defined(__MMI_TOUCH_CALCULATOR__)
  1336.                     else
  1337.                     {
  1338.                         gui_move_text_cursor(
  1339.                             calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1340.                             calculator_keypad.operand2_y);
  1341.                     }
  1342.                 #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1343.                     else
  1344.                     {
  1345.                         gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1346.                     }
  1347.                 #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1348.                     gui_print_text(g_calc_cntx->Operand2Buf);
  1349.                 }
  1350.             }
  1351.         }
  1352.         else
  1353.         {
  1354.             switch (g_calc_cntx->Operator)
  1355.             {
  1356.                 case CALC_OP_PLUS:
  1357.                     op = CALC_SYM_PLUS;
  1358.                     break;
  1359.                 case CALC_OP_MINUS:
  1360.                     op = CALC_SYM_MINUS;
  1361.                     break;
  1362.                 case CALC_OP_MULT:
  1363.                     op = CALC_SYM_MUL;
  1364.                     break;
  1365.                 case CALC_OP_DIV:
  1366.                     op = CALC_SYM_DIV;
  1367.                     break;
  1368.                 default:
  1369.                     break;
  1370.             }
  1372.             CalcDouble2String(g_calc_cntx->Operand1, uni_s, CALC_MAX_DIGITS);
  1373.             g_calc_cntx->Operand1 = gui_atof((UI_string_type) uni_s);
  1375.             w = gui_get_string_width((UI_string_type) uni_s);
  1376.             if (r2lMMIFlag)
  1377.             {
  1378.                 gui_move_text_cursor(
  1379.                     CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1380.                     CALC_OPERAND1_Y);
  1381.             }
  1382.         #if defined(__MMI_TOUCH_CALCULATOR__)
  1383.             else
  1384.             {
  1385.                 gui_move_text_cursor(
  1386.                     calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1387.                     calculator_keypad.operand1_y);
  1388.             }
  1389.         #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1390.             else
  1391.             {
  1392.                 gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND1_Y);
  1393.             }
  1394.         #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1395.             gui_print_text((UI_string_type) uni_s);
  1397.             w = gui_get_string_width(g_calc_cntx->Operand2Buf);
  1398.             if (g_calc_cntx->Operand2Buf[0] == CALC_SYM_NULL)
  1399.             {
  1400.                 w = gui_get_character_width(CALC_SYM_ZERO);
  1401.                 if (r2lMMIFlag)
  1402.                 {
  1403.                     gui_move_text_cursor(
  1404.                         CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1405.                         CALC_OPERAND2_Y);
  1406.                 }
  1407.             #if defined(__MMI_TOUCH_CALCULATOR__)
  1408.                 else
  1409.                 {
  1410.                     gui_move_text_cursor(
  1411.                         calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1412.                         calculator_keypad.operand2_y);
  1413.                 }
  1414.             #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1415.                 else
  1416.                 {
  1417.                     gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1418.                 }
  1419.             #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1421.                 gui_print_character(CALC_SYM_ZERO);
  1422.             }
  1423.             else
  1424.             {
  1425.                 if (r2lMMIFlag)
  1426.                 {
  1427.                     gui_move_text_cursor(
  1428.                         CALC_SCR_X + CALC_SCR_WIDTH - 4 - CALC_RESERVED_SPACE_FOR_OPERATOR,
  1429.                         CALC_OPERAND2_Y);
  1430.                 }
  1431.             #if defined(__MMI_TOUCH_CALCULATOR__)
  1432.                 else
  1433.                 {
  1434.                     gui_move_text_cursor(
  1435.                         calculator_keypad.result_area_x + CALC_TOUCH_RESULT_AREA_WIDTH - w - 4,
  1436.                         calculator_keypad.operand2_y);
  1437.                 }
  1438.             #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1439.                 else
  1440.                 {
  1441.                     gui_move_text_cursor(CALC_SCR_X + CALC_SCR_WIDTH - w - 4, CALC_OPERAND2_Y);
  1442.                 }
  1443.             #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1444.                 gui_print_text(g_calc_cntx->Operand2Buf);
  1445.             }
  1446.         }
  1447.     #ifndef __MMI_SLIM_CALCULATOR__
  1448.         /* memory field */
  1449.         CalcDouble2String(g_calc_cntx->MemValue, uni_memory, CALC_MAX_DIGITS);
  1450.         g_calc_cntx->MemValue = gui_atof((UI_string_type) uni_memory);
  1451.         pfnUnicodeStrcat((S8*) uni_memory, (S8*) (L" "));
  1452.         w = gui_get_string_width((UI_string_type) uni_memory);
  1453.         if (r2lMMIFlag)
  1454.         {
  1455.             gui_move_text_cursor(CALC_SCR_X + CALC_MEM_X2 - 4, CALC_MEM_Y1);
  1456.         }
  1457.     #if defined(__MMI_TOUCH_CALCULATOR__)
  1458.         else
  1459.         {
  1460.             gui_move_text_cursor(
  1461.                 calculator_keypad.result_area_x + calculator_keypad.mem_x1 - w - 4,
  1462.                 calculator_keypad.mem_y1);
  1463.         }
  1464.     #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1465.         else
  1466.         {
  1467.             gui_move_text_cursor(CALC_SCR_X + CALC_MEM_X2 - w - 4, CALC_MEM_Y1);
  1468.         }
  1469.     #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1470.         gui_print_text((UI_string_type) uni_memory);
  1471.     #endif /* __MMI_SLIM_CALCULATOR__ */ 
  1472.     }   /* if(g_calc_cntx->ResultState == RESULT_EXCEED) */
  1474.     /* operator */
  1475.     if (r2lMMIFlag)
  1476.     {
  1477.         gui_move_text_cursor(CALC_SCR_WIDTH - 4, CALC_OPERATOR_Y);
  1478.     }
  1479. #if defined(__MMI_TOUCH_CALCULATOR__)
  1480.     else
  1481.     {
  1482.         gui_move_text_cursor(calculator_keypad.operator_x, calculator_keypad.operator_y);
  1483.     }
  1484. #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1485.     else
  1486.     {
  1487.         gui_move_text_cursor(CALC_OPERATOR_X, CALC_OPERATOR_Y);
  1488.     }
  1489. #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1490.     gui_print_character((UI_character_type) op);
  1492.     if (g_calc_cntx->RSKState == CALC_RSK_CLEAR)
  1493.     {
  1494.         CalcSetRSKClear();
  1495.     }
  1496.     else
  1497.     {
  1498.         CalcSetRSKBack();
  1499.     }
  1501.     show_softkey_background();
  1502.     show_left_softkey();
  1503.     show_right_softkey();
  1505.     gui_unlock_double_buffer();
  1506. #if defined(__MMI_TOUCH_CALCULATOR__)
  1507.     gui_BLT_double_buffer(
  1508.         TOUCH_CALC_SCREEN_X,
  1509.         TOUCH_CALC_SCREEN_Y,
  1510.         TOUCH_CALC_SCREEN_X + TOUCH_CALC_SCREEN_WIDTH - 1,
  1511.         TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  1512. #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1513.     gui_BLT_double_buffer(CALC_SCR_X, CALC_SCR_Y, CALC_SCR_X + CALC_SCR_WIDTH - 1, CALC_SCR_Y + CALC_SCR_HEIGHT - 1);
  1514. #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1515. }
  1517. /* 041205 Calvin added */
  1518. #if defined(__MMI_TOUCH_CALCULATOR__) /* && defined(__MMI_MAINLCD_240X320__) */ /* 060105 Calvin modified */
  1519. extern MMI_ID_TYPE idle_screen_wallpaper_ID;
  1520. extern gdi_handle wgui_base_layer;
  1521. extern gdi_handle wgui_layer_1;
  1522. #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1523. /* Calvin end */
  1526. /*****************************************************************************
  1527.  * FUNCTION
  1528.  *  CalcRedraw
  1529.  * DESCRIPTION
  1530.  *  Redraw calculator screen
  1531.  * PARAMETERS
  1532.  *  void
  1533.  * RETURNS
  1534.  *  void
  1535.  *****************************************************************************/
  1536. void CalcRedraw(void)
  1537. {
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1542.     /*----------------------------------------------------------------*/
  1543.     /* Code Body                                                      */
  1544.     /*----------------------------------------------------------------*/
  1545.     gui_lock_double_buffer();
  1546.     gui_reset_clip();
  1548.     clear_screen();
  1549.     clear_category_screen_key_handlers();
  1550.     clear_left_softkey();
  1551.     clear_right_softkey();
  1552.     /* start vijay 20050302 */
  1553. #if defined(__MMI_TOUCH_CALCULATOR__)
  1554.     /* 052405 Calvin added */
  1555.     /* if ( gui_is_entry_new_screen()==MMI_TRUE ) */
  1556.     if (gui_is_entry_new_screen() == MMI_TRUE && wgui_is_wallpaper_on_bottom() == MMI_TRUE)
  1557.     {
  1558.         gui_set_entry_new_screen(MMI_FALSE);
  1560.         gdi_layer_multi_layer_enable();
  1561.         gdi_layer_get_base_handle(&wgui_base_layer);
  1562.         gui_layer_transparent(
  1563.             wgui_base_layer,
  1564.             UI_SUBMENU_OPACITY_BASED_LAYER,
  1565.             0,
  1566.             0,
  1567.             UI_DEVICE_WIDTH - 1,
  1568.             UI_DEVICE_HEIGHT - 1);
  1569.         if (wgui_layer_1 == GDI_LAYER_EMPTY_HANDLE)
  1570.         {
  1571.             gdi_layer_create(0, 0, UI_DEVICE_WIDTH, UI_DEVICE_HEIGHT, &wgui_layer_1);
  1572.         }
  1574.         gdi_layer_set_active(wgui_layer_1);
  1575.         gdi_layer_lock_frame_buffer();
  1577.         gdi_layer_push_clip();
  1578.         gdi_layer_reset_clip();
  1580.         gdi_layer_set_source_key(TRUE, GDI_COLOR_TRANSPARENT);
  1581.         gdi_layer_set_opacity(TRUE, 200);
  1582.         gdi_image_draw(0, 0, get_image(idle_screen_wallpaper_ID));
  1584.         gdi_layer_pop_clip();
  1586.         gdi_layer_unlock_frame_buffer();
  1587.         gdi_layer_restore_base_active();
  1589.         gdi_layer_set_blt_layer(wgui_layer_1, wgui_base_layer, 0, 0);
  1590.         gdi_layer_blt_previous(0, 0, UI_DEVICE_WIDTH - 1, UI_DEVICE_HEIGHT - 1);
  1592.         gdi_layer_set_active(wgui_base_layer);
  1593.         gdi_draw_solid_rect(0, 0, UI_DEVICE_WIDTH - 1, UI_DEVICE_HEIGHT - 1, GDI_COLOR_TRANSPARENT);
  1594.     }
  1595.     else
  1596.     {
  1597.         //Leo removed
  1598.         //              gdi_layer_get_base_handle(&wgui_base_layer);
  1599.         //              gui_layer_transparent(wgui_base_layer, UI_SUBMENU_OPACITY_BASED_LAYER, 0, 0, UI_DEVICE_WIDTH-1, UI_DEVICE_HEIGHT-1);
  1600.         //              gdi_layer_set_active(wgui_base_layer);
  1601.         //              gdi_draw_solid_rect(0, 0, UI_DEVICE_WIDTH-1, UI_DEVICE_HEIGHT-1,GDI_COLOR_TRANSPARENT);
  1603.     }
  1604.     /* Calvin end */
  1606.     setup_calculator_keypad(&calculator_keypad, TOUCH_CALC_SCREEN_X, TOUCH_CALC_SCREEN_Y);
  1607.     MMI_menu_shortcut_number = -1;
  1608.     /* 053005 Calvin modified */
  1609.     /* Leo 20050705 start */
  1610.     show_title_status_icon();
  1611.     //show_status_icons();
  1612.     //Leo 20050705 end
  1613.     /* Calvin end */
  1614.     ChangeTitleString((U8*) get_string(STR_ID_CALC_MENU));
  1615.     draw_title();
  1616.     show_touch_calculator_screen(
  1617.         TOUCH_CALC_SCREEN_X,
  1618.         TOUCH_CALC_SCREEN_Y,
  1619.         TOUCH_CALC_SCREEN_WIDTH,
  1620.         TOUCH_CALC_SCREEN_HEIGHT);
  1621.     CalcShowResultScreen();
  1622. #else /* defined(__MMI_TOUCH_CALCULATOR__) */ 
  1623. #if defined (__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  1624.     MMI_disable_title_shortcut_display = 1;
  1625.     show_title_status_icon();
  1626.     ChangeTitleString((U8*) get_string(STR_ID_CALC_MENU));
  1627.     ChangeTitleIcon(GetRootTitleIcon(EXTRA_CALCULATOR_MENU));
  1628.     draw_title();
  1629. #endif /* defined (__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  1630.     CalcShowKeypad();
  1631.     CalcShowResultScreen();
  1632. #endif /* defined(__MMI_TOUCH_CALCULATOR__) */ /* end __MMI_TOUCH_CALCULATOR__ */
  1633.     /* end vijay */
  1634.     show_softkey_background();
  1635.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  1636.     show_left_softkey();
  1637.     show_right_softkey();
  1638.     gui_unlock_double_buffer();
  1639.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  1640. }
  1643. /*****************************************************************************
  1644.  * FUNCTION
  1645.  *  CalcSearchDecimal
  1646.  * DESCRIPTION
  1647.  *  To search if there is a decimal point in current operand.
  1648.  * PARAMETERS
  1649.  *  void
  1650.  * RETURNS
  1651.  *  TRUE if decimal exists; otherwise, FALSE.
  1652.  *****************************************************************************/
  1653. U8 CalcSearchDecimal(void)
  1654. {
  1655.     /*----------------------------------------------------------------*/
  1656.     /* Local Variables                                                */
  1657.     /*----------------------------------------------------------------*/
  1658.     U8 index;
  1660.     /*----------------------------------------------------------------*/
  1661.     /* Code Body                                                      */
  1662.     /*----------------------------------------------------------------*/
  1663.     if (g_calc_cntx->Operand2Len > 1)
  1664.     {
  1665.         for (index = 0; index < g_calc_cntx->Operand2Len; index++)
  1666.         {
  1667.             if (g_calc_cntx->Operand2Buf[index] == CALC_SYM_DOT)
  1668.             {
  1669.                 return TRUE;
  1670.             }
  1671.         }
  1672.     }
  1673.     return FALSE;
  1674. }
  1677. /*****************************************************************************
  1678.  * FUNCTION
  1679.  *  CalcInsertChar
  1680.  * DESCRIPTION
  1681.  *  Insert a character to result screen.
  1682.  * PARAMETERS
  1683.  *  c       [IN]        
  1684.  * RETURNS
  1685.  *  void
  1686.  *****************************************************************************/
  1687. void CalcInsertChar(UI_character_type c)
  1688. {
  1689.     /*----------------------------------------------------------------*/
  1690.     /* Local Variables                                                */
  1691.     /*----------------------------------------------------------------*/
  1693.     /*----------------------------------------------------------------*/
  1694.     /* Code Body                                                      */
  1695.     /*----------------------------------------------------------------*/
  1696.     g_calc_cntx->ComputeType = CALC_OP_NONE;
  1697.     /* if operand2 = -(12 digit) || (12 digit) */
  1698.     if ((g_calc_cntx->Operand2Buf[0] == CALC_SYM_MINUS && g_calc_cntx->Operand2Len >= (CALC_MAX_DIGITS + 2)) ||
  1699.         (g_calc_cntx->Operand2Buf[0] != CALC_SYM_MINUS && g_calc_cntx->Operand2Len >= (CALC_MAX_DIGITS + 1)))
  1700.     {
  1701.         playRequestedTone(ERROR_TONE);
  1702.         return;
  1703.     }
  1705.     if (g_calc_cntx->Operand2Len == CALC_ZEOR_LEN && c == CALC_SYM_ZERO)
  1706.     {
  1707.         CalcShowResultScreen();
  1708.         return;
  1709.     }
  1711.     if (g_calc_cntx->Operator == CALC_OP_EQUAL)
  1712.     {
  1713.         g_calc_cntx->Operator = CALC_OP_NONE;
  1714.         g_calc_cntx->Operand1 = 0;
  1715.         g_calc_cntx->Operand2 = 0;
  1716.         g_calc_cntx->Operand2Len = 1;
  1717.         g_calc_cntx->Operand2Buf[0] = CALC_SYM_NULL;
  1718.         g_calc_cntx->OpToExecute = CALC_OP_NONE;
  1719.     }
  1721.     if (c == CALC_SYM_DOT && g_calc_cntx->Operand2Len == CALC_ZEOR_LEN) /* insert "." after zero */
  1722.     {
  1723.         g_calc_cntx->Operand2Buf[0] = CALC_SYM_ZERO;
  1724.         g_calc_cntx->Operand2Len++;
  1725.     }
  1727.     g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len - 1] = (UI_character_type) c;
  1728.     g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len] = CALC_SYM_NULL;
  1729.     g_calc_cntx->Operand2Len++;
  1730.     g_calc_cntx->RSKState = CALC_RSK_CLEAR;
  1732.     CalcShowResultScreen();
  1733. }
  1736. /*****************************************************************************
  1737.  * FUNCTION
  1738.  *  CalcExecMR
  1739.  * DESCRIPTION
  1740.  *  Execute MR operator.
  1741.  * PARAMETERS
  1742.  *  void
  1743.  * RETURNS
  1744.  *  void
  1745.  *****************************************************************************/
  1746. #ifndef __MMI_SLIM_CALCULATOR__
  1747. void CalcExecMR(void)
  1748. {
  1749.     /*----------------------------------------------------------------*/
  1750.     /* Local Variables                                                */
  1751.     /*----------------------------------------------------------------*/
  1753.     /*----------------------------------------------------------------*/
  1754.     /* Code Body                                                      */
  1755.     /*----------------------------------------------------------------*/
  1756.     CalcResetResultValue();
  1758.     CalcDouble2String(g_calc_cntx->MemValue, (S8*) g_calc_cntx->Operand2Buf, CALC_MAX_DIGITS);
  1760.     g_calc_cntx->Operand2Len = pfnUnicodeStrlen((S8*) g_calc_cntx->Operand2Buf) + 1;
  1761.     /* start vijay 20050616...no need to change the RSK on pressing MR button for touch panel */
  1762. #ifndef __MMI_TOUCH_CALCULATOR__
  1763.     if (g_calc_cntx->Operand2Len > 1)
  1764.     {
  1765.         g_calc_cntx->RSKState = CALC_RSK_CLEAR;
  1766.     }
  1767.     else
  1768.     {
  1769.         g_calc_cntx->RSKState = CALC_RSK_BACK;
  1770.     }
  1771. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  1772.     /* end vijay */
  1773. }
  1776. /*****************************************************************************
  1777.  * FUNCTION
  1778.  *  CalcExecMP
  1779.  * DESCRIPTION
  1780.  *  Execute M+ operator.
  1781.  * PARAMETERS
  1782.  *  void
  1783.  * RETURNS
  1784.  *  void
  1785.  *****************************************************************************/
  1786. void CalcExecMP(void)
  1787. {
  1788.     /*----------------------------------------------------------------*/
  1789.     /* Local Variables                                                */
  1790.     /*----------------------------------------------------------------*/
  1791.     DOUBLE temp_res;
  1793.     /*----------------------------------------------------------------*/
  1794.     /* Code Body                                                      */
  1795.     /*----------------------------------------------------------------*/
  1796.     if (g_calc_cntx->Operand2Buf[0] != CALC_SYM_NULL)
  1797.     {
  1798.         temp_res = gui_atof((UI_string_type) g_calc_cntx->Operand2Buf);
  1800.         g_calc_cntx->MemValue += temp_res;
  1802.         if (!mmi_calc_check_boundary(g_calc_cntx->MemValue))
  1803.         {
  1804.             g_calc_cntx->ResultState = RESULT_EXCEED;
  1805.             playRequestedTone(ERROR_TONE);
  1806.             g_calc_cntx->MemValue = 0;
  1807.         }
  1809.     }
  1810. }
  1813. /*****************************************************************************
  1814.  * FUNCTION
  1815.  *  CalcExecMM
  1816.  * DESCRIPTION
  1817.  *  Execute M- operator.
  1818.  * PARAMETERS
  1819.  *  void
  1820.  * RETURNS
  1821.  *  void
  1822.  *****************************************************************************/
  1823. void CalcExecMM(void)
  1824. {
  1825.     /*----------------------------------------------------------------*/
  1826.     /* Local Variables                                                */
  1827.     /*----------------------------------------------------------------*/
  1828.     DOUBLE temp_res;
  1830.     /*----------------------------------------------------------------*/
  1831.     /* Code Body                                                      */
  1832.     /*----------------------------------------------------------------*/
  1833.     if (g_calc_cntx->Operand2Buf[0] != CALC_SYM_NULL)
  1834.     {
  1835.         temp_res = gui_atof((UI_string_type) g_calc_cntx->Operand2Buf);
  1837.         g_calc_cntx->MemValue -= temp_res;
  1838.         if (!mmi_calc_check_boundary(g_calc_cntx->MemValue))
  1839.         {
  1840.             g_calc_cntx->ResultState = RESULT_EXCEED;
  1841.             playRequestedTone(ERROR_TONE);
  1842.             g_calc_cntx->MemValue = 0;
  1843.         }
  1844.     }
  1845. }
  1846. #endif /* __MMI_SLIM_CALCULATOR__ */ 
  1849. /*****************************************************************************
  1850.  * FUNCTION
  1851.  *  CalcGetCurrOperand
  1852.  * DESCRIPTION
  1853.  *  Convert the string of operand 1 to number
  1854.  * PARAMETERS
  1855.  *  void
  1856.  * RETURNS
  1857.  *  void
  1858.  *****************************************************************************/
  1859. void CalcGetCurrOperand(void)
  1860. {
  1861.     /*----------------------------------------------------------------*/
  1862.     /* Local Variables                                                */
  1863.     /*----------------------------------------------------------------*/
  1865.     /*----------------------------------------------------------------*/
  1866.     /* Code Body                                                      */
  1867.     /*----------------------------------------------------------------*/
  1868.     if (g_calc_cntx->Operand2Buf[0] == CALC_SYM_NULL)
  1869.     {
  1870.         g_calc_cntx->Operand1 = 0;
  1871.     }
  1872.     else
  1873.     {
  1874.         g_calc_cntx->Operand1 = gui_atof((UI_string_type) g_calc_cntx->Operand2Buf);
  1875.         /* 06/01/11, for bug of displaying "-0" */
  1876.         if (g_calc_cntx->Operand1 == -0)
  1877.         {
  1878.             g_calc_cntx->Operand1 = 0;
  1879.         }
  1880.     }
  1881. }
  1884. /*****************************************************************************
  1885.  * FUNCTION
  1886.  *  CalcGetPreOperand
  1887.  * DESCRIPTION
  1888.  *  Convert the string of operand 2 to number
  1889.  * PARAMETERS
  1890.  *  void
  1891.  * RETURNS
  1892.  *  void
  1893.  *****************************************************************************/
  1894. void CalcGetPreOperand(void)
  1895. {
  1896.     /*----------------------------------------------------------------*/
  1897.     /* Local Variables                                                */
  1898.     /*----------------------------------------------------------------*/
  1900.     /*----------------------------------------------------------------*/
  1901.     /* Code Body                                                      */
  1902.     /*----------------------------------------------------------------*/
  1903.     if (g_calc_cntx->Operand2Buf[0] == CALC_SYM_NULL)
  1904.     {
  1905.         g_calc_cntx->Operand2 = 0;
  1906.     }
  1907.     else
  1908.     {
  1909.         g_calc_cntx->Operand2 = gui_atof((UI_string_type) g_calc_cntx->Operand2Buf);
  1910.     }
  1911. }
  1914. /*****************************************************************************
  1915.  * FUNCTION
  1916.  *  mmi_calc_check_boundary
  1917.  * DESCRIPTION
  1918.  *  Check the boundary of the calculated result.
  1919.  * PARAMETERS
  1920.  *  value       [IN]        Value to be checked
  1921.  * RETURNS
  1922.  *  0  out of the boundary
  1923.  *  1  within the boundary
  1924.  *****************************************************************************/
  1925. U8 mmi_calc_check_boundary(DOUBLE value)
  1926. {
  1927.     /*----------------------------------------------------------------*/
  1928.     /* Local Variables                                                */
  1929.     /*----------------------------------------------------------------*/
  1930.     S8 uni_s[64];
  1931.     S8 ansii_str[CALC_MAX_BUFF_LEN];
  1933.     /*----------------------------------------------------------------*/
  1934.     /* Code Body                                                      */
  1935.     /*----------------------------------------------------------------*/
  1936.     memset(uni_s, 0, sizeof(uni_s));
  1937.     memset(ansii_str, 0, CALC_MAX_BUFF_LEN);
  1938.     if (value < 0)
  1939.     {
  1940.         value = -(value);
  1941.     }
  1942.     CalcDouble2String(value, uni_s, CALC_MAX_DIGITS);
  1943.     UnicodeToAnsii((S8*) ansii_str, (S8*) uni_s);
  1944.     if (strlen(ansii_str) > CALC_MAX_DIGITS)
  1945.     {
  1946.         return RESULT_NOT_EXCEED;
  1947.     }
  1948.     else
  1949.     {
  1950.         return RESULT_EXCEED;
  1951.     }
  1952. }
  1955. /*****************************************************************************
  1956.  * FUNCTION
  1957.  *  CalcExecOperator
  1958.  * DESCRIPTION
  1959.  *  Execute current computation operation.
  1960.  * PARAMETERS
  1961.  *  op1     [IN]        
  1962.  *  op2     [IN]        
  1963.  * RETURNS
  1964.  *  void
  1965.  *****************************************************************************/
  1966. DOUBLE CalcExecOperator(DOUBLE op1, DOUBLE op2)
  1967. {
  1968.     /*----------------------------------------------------------------*/
  1969.     /* Local Variables                                                */
  1970.     /*----------------------------------------------------------------*/
  1971.     DOUBLE result = 0;
  1973.     /*----------------------------------------------------------------*/
  1974.     /* Code Body                                                      */
  1975.     /*----------------------------------------------------------------*/
  1976.     CalcSetRSKClear();
  1978.     switch (g_calc_cntx->OpToExecute)
  1979.     {
  1980.         case CALC_OP_PLUS:
  1981.             result = op1 + op2;
  1982.             break;
  1983.         case CALC_OP_MINUS:
  1984.             result = op1 - op2;
  1985.             break;
  1986.         case CALC_OP_MULT:
  1987.             result = op1 * op2;
  1988.             break;
  1989.         case CALC_OP_DIV:
  1990.             if (op2 > 0)
  1991.             {
  1992.                 result = (DOUBLE) op1 / op2;
  1993.             }
  1994.             break;
  1995.         default:
  1996.             return 0;
  1997.     }
  1999.     if (!mmi_calc_check_boundary(result))
  2000.     {
  2001.         g_calc_cntx->ResultState = RESULT_EXCEED;
  2002.         playRequestedTone(ERROR_TONE);
  2003.         return 0;
  2004.     }
  2006.     return (result);
  2007. }
  2010. /*****************************************************************************
  2011.  * FUNCTION
  2012.  *  CalcComputeResult
  2013.  * DESCRIPTION
  2014.  *  
  2015.  * PARAMETERS
  2016.  *  void
  2017.  * RETURNS
  2018.  *  void
  2019.  *****************************************************************************/
  2020. void CalcComputeResult(void)
  2021. {
  2022.     /*----------------------------------------------------------------*/
  2023.     /* Local Variables                                                */
  2024.     /*----------------------------------------------------------------*/
  2026.     /*----------------------------------------------------------------*/
  2027.     /* Code Body                                                      */
  2028.     /*----------------------------------------------------------------*/
  2029.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2030.     {
  2031.         switch (g_calc_cntx->CurrHilite)
  2032.         {
  2033.         #ifndef __MMI_SLIM_CALCULATOR__
  2034.             case CALC_OP_MR:
  2035.             {
  2036.                 CalcExecMR();
  2037.                 g_calc_cntx->Operator = CALC_OP_NONE;
  2038.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2039.                 g_calc_cntx->ComputeType = CALC_OP_MR;
  2041.                 break;
  2042.             }
  2043.             case CALC_OP_MC:
  2044.             {
  2045.                 CalcResetMemValue();
  2046.                 g_calc_cntx->Operator = CALC_OP_NONE;
  2047.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2048.                 g_calc_cntx->ComputeType = CALC_OP_MC;
  2050.                 break;
  2051.             }
  2052.             case CALC_OP_MP:
  2053.             {
  2054.                 CalcExecMP();
  2056.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2057.                 g_calc_cntx->Operator = CALC_OP_NONE;
  2058.                 g_calc_cntx->ComputeType = CALC_OP_MP;
  2060.                 break;
  2061.             }
  2062.             case CALC_OP_MM:
  2063.             {
  2064.                 CalcExecMM();
  2066.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2067.                 g_calc_cntx->Operator = CALC_OP_NONE;
  2068.                 g_calc_cntx->ComputeType = CALC_OP_MM;
  2070.                 break;
  2071.             }
  2072.         #endif /* __MMI_SLIM_CALCULATOR__ */ 
  2073.             default:
  2074.             {
  2075.                 if (g_calc_cntx->Operator != CALC_OP_NONE)
  2076.                 {
  2077.                     g_calc_cntx->ComputeType = g_calc_cntx->Operator;
  2078.                     g_calc_cntx->Operator = CALC_OP_EQUAL;
  2080.                     CalcGetPreOperand();
  2081.                     if ((g_calc_cntx->Operand2 == 0) && (g_calc_cntx->OpToExecute == CALC_OP_DIV))
  2082.                     {
  2083.                         g_calc_cntx->ResultState = RESULT_EXCEED;
  2084.                         CalcSetRSKClear();
  2085.                         g_calc_cntx->Operator = CALC_OP_NONE;
  2086.                         playRequestedTone(ERROR_TONE);
  2087.                     }
  2088.                     else
  2089.                     {
  2090.                         if (g_calc_cntx->OpToExecute != CALC_OP_NONE)
  2091.                         {
  2092.                             g_calc_cntx->Operand1 = CalcExecOperator(g_calc_cntx->Operand1, g_calc_cntx->Operand2);
  2093.                             g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2094.                             g_calc_cntx->OpToExecute = CALC_OP_NONE;
  2095.                         }
  2096.                     }
  2097.                 }
  2098.                 else
  2099.                 {
  2100.                     g_calc_cntx->ComputeType = CALC_OP_EQUAL;
  2101.                     g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2102.                 }
  2103.                 break;
  2104.             }
  2105.         }
  2106.         g_calc_cntx->ExecFlag = TRUE;
  2107.     }
  2108.     else
  2109.     {
  2110.         playRequestedTone(ERROR_TONE);
  2111.     }
  2113. #if !defined(__MMI_TOUCH_CALCULATOR__)
  2114.     CalcShowKeypad();
  2115. #endif 
  2116.     CalcShowResultScreen();
  2118. }
  2120. #define CALC_KEY_HILITE_HANDLER
  2123. /*****************************************************************************
  2124.  * FUNCTION
  2125.  *  CalcHandleHiliteMemoryButton
  2126.  * DESCRIPTION
  2127.  *  Highlight handler of memory button.
  2128.  *  Move operand to result filed and clear all others.
  2129.  * PARAMETERS
  2130.  *  void
  2131.  * RETURNS
  2132.  *  void
  2133.  *****************************************************************************/
  2134. void CalcHandleHiliteMemoryButton(void)
  2135. {
  2136.     /*----------------------------------------------------------------*/
  2137.     /* Local Variables                                                */
  2138.     /*----------------------------------------------------------------*/
  2140.     /*----------------------------------------------------------------*/
  2141.     /* Code Body                                                      */
  2142.     /*----------------------------------------------------------------*/
  2143.     CalcDouble2String(g_calc_cntx->Operand1, (S8*) g_calc_cntx->Operand2Buf, CALC_MAX_DIGITS);
  2145.     g_calc_cntx->Operator = CALC_OP_NONE;
  2147.     if (g_calc_cntx->Operand1 != 0)
  2148.     {
  2149.         g_calc_cntx->Operand2Len = pfnUnicodeStrlen((S8*) g_calc_cntx->Operand2Buf) + 1;
  2150.     }
  2151.     else
  2152.     {
  2153.         g_calc_cntx->Operand2Len = CALC_ZEOR_LEN;
  2154.     }
  2156. }
  2159. /*****************************************************************************
  2160.  * FUNCTION
  2161.  *  CalcHandleHiliteOperator
  2162.  * DESCRIPTION
  2163.  *  Execute correspoding operation when highlighting on opeartor.
  2164.  *  Dislpay operator, calculator reslut, and add new operand.
  2165.  * PARAMETERS
  2166.  *  void
  2167.  * RETURNS
  2168.  *  void
  2169.  *****************************************************************************/
  2170. void CalcHandleHiliteOperator(void)
  2171. {
  2172.     /*----------------------------------------------------------------*/
  2173.     /* Local Variables                                                */
  2174.     /*----------------------------------------------------------------*/
  2175.     U8 PreOperator = g_calc_cntx->Operator;
  2177.     /*----------------------------------------------------------------*/
  2178.     /* Code Body                                                      */
  2179.     /*----------------------------------------------------------------*/
  2180.     g_calc_cntx->ExecFlag = FALSE;
  2182.     g_calc_cntx->Operator = g_calc_cntx->CurrHilite;
  2183.     /* start vijay 20050616.......RSK should not be changed to CLEAR key when pressed these buttons */
  2184. #ifdef __MMI_TOUCH_CALCULATOR__
  2185.     if (!(g_calc_cntx->Operator == CALC_OP_MP || g_calc_cntx->Operator == CALC_OP_MM ||
  2186.           g_calc_cntx->Operator == CALC_OP_MR || g_calc_cntx->Operator == CALC_OP_MC))
  2187.     {
  2188.         g_calc_cntx->RSKState = CALC_RSK_CLEAR;
  2189.     }
  2190. #else /* __MMI_TOUCH_CALCULATOR__ */ 
  2191.     g_calc_cntx->RSKState = CALC_RSK_CLEAR;
  2192. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  2193.     /* end vijay */
  2194.     switch (PreOperator)
  2195.     {
  2196.         case CALC_OP_PLUS:
  2197.         case CALC_OP_MINUS:
  2198.         case CALC_OP_MULT:
  2199.         case CALC_OP_DIV:
  2200.             if (g_calc_cntx->Operand2Buf[0] != CALC_SYM_NULL)
  2201.             {
  2202.                 g_calc_cntx->OpToExecute = PreOperator;
  2203.                 CalcGetPreOperand();
  2204.                 g_calc_cntx->Operand1 = CalcExecOperator(g_calc_cntx->Operand1, g_calc_cntx->Operand2);
  2205.                 /* g_calc_cntx->OpToExecute = g_calc_cntx->Operator; */
  2206.                 break;
  2207.             }
  2208.             else
  2209.             {
  2210.                 g_calc_cntx->OpToExecute = g_calc_cntx->Operator;
  2211.                 return;
  2212.             }
  2213.         #ifndef __MMI_SLIM_CALCULATOR__
  2214.         case CALC_OP_MP:
  2215.         case CALC_OP_MM:
  2216.         case CALC_OP_MR:
  2217.         case CALC_OP_MC:
  2218.         #endif /* __MMI_SLIM_CALCULATOR__ */ 
  2219.         case CALC_OP_NONE:
  2220.             CalcGetCurrOperand();
  2221.         default:
  2222.             break;
  2223.     }
  2225.     g_calc_cntx->OpToExecute = g_calc_cntx->Operator;
  2226.     memcpy(g_calc_cntx->Operand1Buf, g_calc_cntx->Operand2Buf, sizeof(g_calc_cntx->Operand1Buf));
  2227.     g_calc_cntx->Operand1Len = g_calc_cntx->Operand2Len;
  2229.     g_calc_cntx->Operand2 = 0;
  2230.     g_calc_cntx->Operand2Len = CALC_ZEOR_LEN;
  2231.     g_calc_cntx->Operand2Buf[0] = CALC_SYM_NULL;
  2232. }
  2235. /*****************************************************************************
  2236.  * FUNCTION
  2237.  *  CalcHandleLeftKey
  2238.  * DESCRIPTION
  2239.  *  Left arrow key handler.
  2240.  * PARAMETERS
  2241.  *  void
  2242.  * RETURNS
  2243.  *  void
  2244.  *****************************************************************************/
  2245. void CalcHandleLeftKey(void)
  2246. {
  2247.     /*----------------------------------------------------------------*/
  2248.     /* Local Variables                                                */
  2249.     /*----------------------------------------------------------------*/
  2251.     /*----------------------------------------------------------------*/
  2252.     /* Code Body                                                      */
  2253.     /*----------------------------------------------------------------*/
  2254.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2255.     {
  2256.         switch (g_calc_cntx->CurrHilite)
  2257.         {
  2258.                 /* start Sophie 050904 */
  2259.         #ifdef __MMI_SLIM_CALCULATOR__
  2260.             case CALC_OP_MULT:
  2261.                 return;
  2262.         #else /* __MMI_SLIM_CALCULATOR__ */ 
  2263.             case CALC_OP_MC:
  2264.                 return;
  2265.             case CALC_OP_MR:
  2266.             {
  2267.                 g_calc_cntx->CurrHilite = CALC_OP_DIV;
  2268.                 CalcHandleHiliteOperator();
  2269.                 break;
  2270.             }
  2271.             case CALC_OP_MULT:
  2272.             {
  2273.                 g_calc_cntx->CurrHilite = CALC_OP_MC;
  2274.                 CalcHandleHiliteMemoryButton();
  2275.                 break;
  2276.             }
  2277.             case CALC_OP_MP:
  2278.             case CALC_OP_MM:
  2279.         #endif /* __MMI_SLIM_CALCULATOR__ */ /* end of ifdef __MMI_SLIM_CALCULATOR__ */
  2280.                 /* end Sophie */
  2281.             case CALC_OP_PLUS:
  2282.             case CALC_OP_MINUS:
  2283.             case CALC_OP_EQUAL:
  2284.             case CALC_OP_DIV:
  2285.             {
  2286.                 g_calc_cntx->CurrHilite = CALC_OP_MULT;
  2287.                 CalcHandleHiliteOperator();
  2288.                 break;
  2289.             }
  2290.             default:
  2291.             {
  2292.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2293.                 break;
  2294.             }
  2295.         }
  2296.     }
  2297.     else
  2298.     {
  2299.         playRequestedTone(ERROR_TONE);
  2300.     }
  2302.     CalcShowKeypad();
  2303.     CalcShowResultScreen();
  2304. }
  2307. /*****************************************************************************
  2308.  * FUNCTION
  2309.  *  CalcHandleRightKey
  2310.  * DESCRIPTION
  2311.  *  Right arrow key handler.
  2312.  * PARAMETERS
  2313.  *  void
  2314.  * RETURNS
  2315.  *  void
  2316.  *****************************************************************************/
  2317. void CalcHandleRightKey(void)
  2318. {
  2319.     /*----------------------------------------------------------------*/
  2320.     /* Local Variables                                                */
  2321.     /*----------------------------------------------------------------*/
  2323.     /*----------------------------------------------------------------*/
  2324.     /* Code Body                                                      */
  2325.     /*----------------------------------------------------------------*/
  2326.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2327.     {
  2328.         switch (g_calc_cntx->CurrHilite)
  2329.         {
  2330.                 /* start Sophie 050904 */
  2331.         #ifdef __MMI_SLIM_CALCULATOR__
  2332.             case CALC_OP_DIV:
  2333.                 return;
  2334.         #else /* __MMI_SLIM_CALCULATOR__ */ 
  2335.             case CALC_OP_MR:
  2336.                 return;
  2337.             case CALC_OP_MC:
  2338.             {
  2339.                 g_calc_cntx->CurrHilite = CALC_OP_MULT;
  2340.                 CalcHandleHiliteOperator();
  2341.                 break;
  2342.             }
  2343.             case CALC_OP_DIV:
  2344.             {
  2345.                 g_calc_cntx->CurrHilite = CALC_OP_MR;
  2346.                 CalcHandleHiliteMemoryButton();
  2347.                 break;
  2348.             }
  2349.             case CALC_OP_MP:
  2350.             case CALC_OP_MM:
  2351.         #endif /* __MMI_SLIM_CALCULATOR__ */ /* end of ifdef __MMI_SLIM_CALCULATOR__ */
  2352.                 /* end Sophie */
  2353.             case CALC_OP_PLUS:
  2354.             case CALC_OP_MINUS:
  2355.             case CALC_OP_MULT:
  2356.             case CALC_OP_EQUAL:
  2357.             {
  2358.                 g_calc_cntx->CurrHilite = CALC_OP_DIV;
  2359.                 CalcHandleHiliteOperator();
  2360.                 break;
  2361.             }
  2362.             default:
  2363.             {
  2364.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2365.                 break;
  2366.             }
  2367.         }
  2368.     }
  2369.     else
  2370.     {
  2371.         playRequestedTone(ERROR_TONE);
  2372.     }
  2374.     CalcShowKeypad();
  2375.     CalcShowResultScreen();
  2376. }
  2379. /*****************************************************************************
  2380.  * FUNCTION
  2381.  *  CalcHandleUpKey
  2382.  * DESCRIPTION
  2383.  *  Up arrow key handler.
  2384.  * PARAMETERS
  2385.  *  void
  2386.  * RETURNS
  2387.  *  void
  2388.  *****************************************************************************/
  2389. void CalcHandleUpKey(void)
  2390. {
  2391.     /*----------------------------------------------------------------*/
  2392.     /* Local Variables                                                */
  2393.     /*----------------------------------------------------------------*/
  2395.     /*----------------------------------------------------------------*/
  2396.     /* Code Body                                                      */
  2397.     /*----------------------------------------------------------------*/
  2398.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2399.     {
  2400.         switch (g_calc_cntx->CurrHilite)
  2401.         {
  2402.                 /* start Sophie 050904 */
  2403.         #ifdef __MMI_SLIM_CALCULATOR__
  2404.             case CALC_OP_PLUS:
  2405.                 return;
  2406.         #else /* __MMI_SLIM_CALCULATOR__ */ 
  2407.             case CALC_OP_MP:
  2408.                 return;
  2409.             case CALC_OP_MM:
  2410.             {
  2411.                 g_calc_cntx->CurrHilite = CALC_OP_MINUS;
  2412.                 CalcHandleHiliteOperator();
  2413.                 break;
  2414.             }
  2415.             case CALC_OP_PLUS:
  2416.             {
  2417.                 g_calc_cntx->CurrHilite = CALC_OP_MP;
  2418.                 CalcHandleHiliteMemoryButton();
  2419.                 break;
  2420.             }
  2421.             case CALC_OP_MR:
  2422.             case CALC_OP_MC:
  2423.         #endif /* __MMI_SLIM_CALCULATOR__ */ /* end of ifdef __MMI_SLIM_CALCULATOR__ */
  2424.                 /* end Sophie */
  2425.             case CALC_OP_DIV:
  2426.             case CALC_OP_MULT:
  2427.             case CALC_OP_EQUAL:
  2428.             case CALC_OP_MINUS:
  2429.             {
  2430.                 g_calc_cntx->CurrHilite = CALC_OP_PLUS;
  2431.                 CalcHandleHiliteOperator();
  2432.                 break;
  2433.             }
  2434.             default:
  2435.             {
  2436.                 g_calc_cntx->CurrHilite = CALC_OP_PLUS;
  2437.                 break;
  2438.             }
  2439.         }
  2440.     }
  2441.     else
  2442.     {
  2443.         playRequestedTone(ERROR_TONE);
  2444.     }
  2446.     CalcShowKeypad();
  2447.     CalcShowResultScreen();
  2448. }
  2451. /*****************************************************************************
  2452.  * FUNCTION
  2453.  *  CalcHandleDownKey
  2454.  * DESCRIPTION
  2455.  *  Down arrow key handler.
  2456.  * PARAMETERS
  2457.  *  void
  2458.  * RETURNS
  2459.  *  void
  2460.  *****************************************************************************/
  2461. void CalcHandleDownKey(void)
  2462. {
  2463.     /*----------------------------------------------------------------*/
  2464.     /* Local Variables                                                */
  2465.     /*----------------------------------------------------------------*/
  2467.     /*----------------------------------------------------------------*/
  2468.     /* Code Body                                                      */
  2469.     /*----------------------------------------------------------------*/
  2470.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2471.     {
  2472.         switch (g_calc_cntx->CurrHilite)
  2473.         {
  2474.                 /* start Sophie 050904 */
  2475.         #ifdef __MMI_SLIM_CALCULATOR__
  2476.             case CALC_OP_MINUS:
  2477.                 return;
  2478.         #else /* __MMI_SLIM_CALCULATOR__ */ 
  2479.             case CALC_OP_MM:
  2480.                 return;
  2481.             case CALC_OP_MP:
  2482.             {
  2483.                 g_calc_cntx->CurrHilite = CALC_OP_PLUS;
  2484.                 CalcHandleHiliteOperator();
  2485.                 break;
  2486.             }
  2487.             case CALC_OP_MINUS:
  2488.             {
  2489.                 g_calc_cntx->CurrHilite = CALC_OP_MM;
  2490.                 CalcHandleHiliteMemoryButton();
  2491.                 break;
  2492.             }
  2493.             case CALC_OP_MR:
  2494.             case CALC_OP_MC:
  2495.         #endif /* __MMI_SLIM_CALCULATOR__ */ 
  2496.                 /* end Sophie */
  2497.             case CALC_OP_DIV:
  2498.             case CALC_OP_MULT:
  2499.             case CALC_OP_EQUAL:
  2500.             case CALC_OP_PLUS:
  2501.             {
  2502.                 g_calc_cntx->CurrHilite = CALC_OP_MINUS;
  2503.                 CalcHandleHiliteOperator();
  2504.                 break;
  2505.             }
  2506.             default:
  2507.             {
  2508.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2509.                 break;
  2510.             }
  2511.         }
  2512.     }
  2513.     else
  2514.     {
  2515.         playRequestedTone(ERROR_TONE);
  2516.     }
  2518.     CalcShowKeypad();
  2519.     CalcShowResultScreen();
  2520. }
  2523. /*****************************************************************************
  2524.  * FUNCTION
  2525.  *  CalcHandleNumKey
  2526.  * DESCRIPTION
  2527.  *  Handle number key input
  2528.  * PARAMETERS
  2529.  *  key_code        [IN]        
  2530.  * RETURNS
  2531.  *  void
  2532.  *****************************************************************************/
  2533. void CalcHandleNumKey(S32 key_code)
  2534. {
  2535.     /*----------------------------------------------------------------*/
  2536.     /* Local Variables                                                */
  2537.     /*----------------------------------------------------------------*/
  2539.     /*----------------------------------------------------------------*/
  2540.     /* Code Body                                                      */
  2541.     /*----------------------------------------------------------------*/
  2542.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2543.     {
  2544.         if (g_calc_cntx->ExecFlag)
  2545.         {
  2546.             CalcResetResultValue();
  2547.         }
  2549.         if (g_calc_cntx->CurrHilite <= CALC_OP_EQUAL)   /* operators */
  2550.         {
  2551.             g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2552.         #if !defined(__MMI_TOUCH_CALCULATOR__)
  2553.             CalcShowKeypad();
  2554.         #endif 
  2555.         }
  2557.         CalcInsertChar((UI_character_type) ('0' + key_code));
  2558.     }
  2559.     else
  2560.     {
  2561.         playRequestedTone(ERROR_TONE);
  2562.     }
  2563. }
  2566. /*****************************************************************************
  2567.  * FUNCTION
  2568.  *  CalcHandlePoundKey
  2569.  * DESCRIPTION
  2570.  *  Pound key handler.
  2571.  * PARAMETERS
  2572.  *  void
  2573.  * RETURNS
  2574.  *  void
  2575.  *****************************************************************************/
  2576. void CalcHandlePoundKey(void)
  2577. {
  2578.     /*----------------------------------------------------------------*/
  2579.     /* Local Variables                                                */
  2580.     /*----------------------------------------------------------------*/
  2582.     /*----------------------------------------------------------------*/
  2583.     /* Code Body                                                      */
  2584.     /*----------------------------------------------------------------*/
  2585.     if (g_calc_cntx->ResultState == RESULT_NOT_EXCEED)
  2586.     {
  2587.         if (g_calc_cntx->ExecFlag)
  2588.         {
  2589.             CalcResetResultValue();
  2590.         }
  2592.         if (g_calc_cntx->Operand2Len == 1)
  2593.         {
  2594.             CalcInsertChar(CALC_SYM_DOT);
  2595.         }
  2596.         else if (!CalcSearchDecimal())
  2597.         {
  2598.             CalcInsertChar(CALC_SYM_DOT);
  2599.         }
  2600.     }
  2601.     else
  2602.     {
  2603.         playRequestedTone(ERROR_TONE);
  2604.     }
  2605. }
  2608. /*****************************************************************************
  2609.  * FUNCTION
  2610.  *  CalcHandleEndKey
  2611.  * DESCRIPTION
  2612.  *  End key handler of calculator
  2613.  * PARAMETERS
  2614.  *  void
  2615.  * RETURNS
  2616.  *  void
  2617.  *****************************************************************************/
  2618. void CalcHandleEndKey(void)
  2619. {
  2620.     /*----------------------------------------------------------------*/
  2621.     /* Local Variables                                                */
  2622.     /*----------------------------------------------------------------*/
  2624.     /*----------------------------------------------------------------*/
  2625.     /* Code Body                                                      */
  2626.     /*----------------------------------------------------------------*/
  2627.     /* CalcDeInit(); */
  2628.     DisplayIdleScreen();
  2629. }
  2632. /*****************************************************************************
  2633.  * FUNCTION
  2634.  *  CalcHandleClearKey
  2635.  * DESCRIPTION
  2636.  *  Clear key handler of calculator
  2637.  * PARAMETERS
  2638.  *  void
  2639.  * RETURNS
  2640.  *  void
  2641.  *****************************************************************************/
  2642. void CalcHandleClearKey(void)
  2643. {
  2644.     /*----------------------------------------------------------------*/
  2645.     /* Local Variables                                                */
  2646.     /*----------------------------------------------------------------*/
  2648.     /*----------------------------------------------------------------*/
  2649.     /* Code Body                                                      */
  2650.     /*----------------------------------------------------------------*/
  2651.     if (g_calc_cntx->ResultState == RESULT_EXCEED)
  2652.     {
  2653.         CalcResetContext();
  2654.     }
  2655.     else if (g_calc_cntx->Operator != CALC_OP_NONE)
  2656.     {
  2657.         if (g_calc_cntx->Operator != CALC_OP_EQUAL)
  2658.         {
  2659.             if (g_calc_cntx->Operand2Len > CALC_ZEOR_LEN)
  2660.             {
  2661.                 g_calc_cntx->Operand2Len--;
  2662.                 /* '0.x' || '-x' */
  2663.                 if ((g_calc_cntx->Operand2Len == CALC_ZEOR_DOT_LEN &&
  2664.                      (g_calc_cntx->Operand2Buf[1] == CALC_SYM_DOT && g_calc_cntx->Operand2Buf[0] == CALC_SYM_ZERO)) ||
  2665.                     (g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len - 2] == CALC_SYM_MINUS))
  2666.                 {
  2667.                     g_calc_cntx->Operand2Len = CALC_ZEOR_LEN;
  2668.                 }
  2669.                 g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len - 1] = '';
  2671.             }
  2672.             else
  2673.             {
  2674.                 g_calc_cntx->Operator = CALC_OP_NONE;
  2675.                 g_calc_cntx->CurrHilite = CALC_OP_EQUAL;
  2677.                 if (g_calc_cntx->Operand1 == 0)
  2678.                 {
  2679.                     CalcResetResultValue();
  2680.                 }
  2681.                 else
  2682.                 {
  2683.                     CalcDouble2String(g_calc_cntx->Operand1, (S8*) g_calc_cntx->Operand2Buf, CALC_MAX_DIGITS);
  2684.                     g_calc_cntx->Operand2Len = pfnUnicodeStrlen((S8*) g_calc_cntx->Operand2Buf) + 1;
  2685.                 }
  2686.             }
  2687.         }
  2688.         else    /* display result after calculator, operator == equal */
  2689.         {
  2690.             CalcResetResultValue();
  2691.         }
  2692.     }
  2693.     else
  2694.     {
  2695.         if (g_calc_cntx->ComputeType >= CALC_OP_EQUAL && g_calc_cntx->ComputeType < CALC_OP_NONE)       /* Move to Mx and press LSK */
  2696.         {
  2697.             CalcResetResultValue();
  2698.         }
  2699.         else    /* Move to Mx */
  2700.         {
  2701.             g_calc_cntx->Operand2Len--;
  2703.             /* current operand == "0.x" || "-x" */
  2704.             if ((g_calc_cntx->Operand2Len == CALC_ZEOR_DOT_LEN) &&
  2705.                 ((g_calc_cntx->Operand2Buf[1] == CALC_SYM_DOT) && (g_calc_cntx->Operand2Buf[0] == CALC_SYM_ZERO))
  2706.                 || (g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len - 2] == CALC_SYM_MINUS))
  2708.             {
  2709.                 g_calc_cntx->Operand2Len = CALC_ZEOR_LEN;
  2710.             }
  2711.             else
  2712.             {
  2713.                 g_calc_cntx->Operand2Buf[g_calc_cntx->Operand2Len - 1] = '';
  2714.             }
  2716.             if (g_calc_cntx->Operand2Len <= 1)
  2717.             {
  2718.                 CalcResetResultValue();
  2719.             }
  2720.         }
  2722.     }
  2724.     if (g_calc_cntx->Operand2Buf[0] == CALC_SYM_ZERO && g_calc_cntx->Operand2Buf[1] == CALC_SYM_NULL)
  2725.     {
  2726.         g_calc_cntx->Operand2Len = CALC_ZEOR_LEN;
  2727.     }
  2728.     /* start vijay 20050307 */
  2729. #if !defined(__MMI_TOUCH_CALCULATOR__)
  2730.     CalcShowKeypad();
  2731. #endif 
  2732.     /* end vijay */
  2733.     CalcShowResultScreen();
  2734. }
  2737. /*****************************************************************************
  2738.  * FUNCTION
  2739.  *  CalcHandleRSKLongPress
  2740.  * DESCRIPTION
  2741.  *  Reset calculator to defualt state
  2742.  * PARAMETERS
  2743.  *  void
  2744.  * RETURNS
  2745.  *  void
  2746.  *****************************************************************************/
  2747. void CalcHandleRSKLongPress(void)
  2748. {
  2749.     /*----------------------------------------------------------------*/
  2750.     /* Local Variables                                                */
  2751.     /*----------------------------------------------------------------*/
  2753.     /*----------------------------------------------------------------*/
  2754.     /* Code Body                                                      */
  2755.     /*----------------------------------------------------------------*/
  2756.     g_calc_cntx->IsRSKPress = TRUE;
  2757.     CalcResetResultValue();
  2758. #ifndef __MMI_TOUCH_CALCULATOR__
  2759.     CalcShowKeypad();
  2760. #endif 
  2761.     CalcShowResultScreen();
  2762. }
  2764. #ifndef __MTK_TARGET__
  2767. /*****************************************************************************
  2768.  * FUNCTION
  2769.  *  CalWin32NumKeyHandler
  2770.  * DESCRIPTION
  2771.  *  Key handler on Win 32
  2772.  * PARAMETERS
  2773.  *  keyc        [IN]        
  2774.  * RETURNS
  2775.  *  void
  2776.  *****************************************************************************/
  2777. void CalWin32NumKeyHandler(S32 keyc)
  2778. {
  2779.     /*----------------------------------------------------------------*/
  2780.     /* Local Variables                                                */
  2781.     /*----------------------------------------------------------------*/
  2783.     /*----------------------------------------------------------------*/
  2784.     /* Code Body                                                      */
  2785.     /*----------------------------------------------------------------*/
  2786.     if (keyc >= '0' && keyc <= '9')
  2787.     {
  2788.         CalcInsertChar((UI_character_type) keyc);
  2789.     }
  2790.     else if (keyc == 0x08)
  2791.     {
  2792.         CalcHandleClearKey();
  2793.     }
  2794.     else if (keyc == 0x1b); /* Esc   */
  2795.     else if (keyc == 0x0d); /* Tab   */
  2796. }
  2799. /*****************************************************************************
  2800.  * FUNCTION
  2801.  *  CalWin32ArrowKeyHandler
  2802.  * DESCRIPTION
  2803.  *  Key handler on Win 32
  2804.  * PARAMETERS
  2805.  *  vkey_code       [IN]        
  2806.  *  key_state       [IN]        
  2807.  * RETURNS
  2808.  *  void
  2809.  *****************************************************************************/
  2810. void CalWin32ArrowKeyHandler(S32 vkey_code, S32 key_state)
  2811. {
  2812. #if(MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32)
  2813.     /*----------------------------------------------------------------*/
  2814.     /* Local Variables                                                */
  2815.     /*----------------------------------------------------------------*/
  2817.     /*----------------------------------------------------------------*/
  2818.     /* Code Body                                                      */
  2819.     /*----------------------------------------------------------------*/
  2820.     if (key_state)
  2821.     {
  2822.         switch (vkey_code)
  2823.         {
  2824.             case 37:
  2825.                 CalcHandleLeftKey();
  2826.                 break;
  2827.             case 39:
  2828.                 CalcHandleRightKey();
  2829.                 break;
  2830.             case 38:
  2831.                 CalcHandleUpKey();
  2832.                 break;
  2833.             case 40:
  2834.                 CalcHandleDownKey();
  2835.                 break;
  2836.         }
  2837.     }
  2838. #else /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  2839.     UI_UNUSED_PARAMETER(vkey_code);
  2840.     UI_UNUSED_PARAMETER(key_state);
  2841. #endif /* (MMI_BUILD_TYPE == BUILD_TYPE_X86WIN32) */ 
  2842. }
  2843. #endif /* __MTK_TARGET__ */ 
  2846. /*****************************************************************************
  2847.  * FUNCTION
  2848.  *  CalcRegisterKeyHandler
  2849.  * DESCRIPTION
  2850.  *  Register key handler of calculator
  2851.  * PARAMETERS
  2852.  *  void
  2853.  * RETURNS
  2854.  *  void
  2855.  *****************************************************************************/
  2856. void CalcRegisterKeyHandler(void)
  2857. {
  2858.     /*----------------------------------------------------------------*/
  2859.     /* Local Variables                                                */
  2860.     /*----------------------------------------------------------------*/
  2862.     /*----------------------------------------------------------------*/
  2863.     /* Code Body                                                      */
  2864.     /*----------------------------------------------------------------*/
  2865. #ifndef __MMI_TOUCH_CALCULATOR__
  2866.     SetKeyHandler(CalcHandleLeftKey, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  2867.     SetKeyHandler(CalcHandleRightKey, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  2868.     SetKeyHandler(CalcHandleUpKey, KEY_UP_ARROW, KEY_EVENT_DOWN);
  2869.     SetKeyHandler(CalcHandleDownKey, KEY_DOWN_ARROW, KEY_EVENT_DOWN);
  2870.     SetLeftSoftkeyFunction(CalcComputeResult, KEY_EVENT_UP);
  2871.     SetKeyHandler(CalcHandleEndKey, KEY_END, KEY_EVENT_DOWN);
  2872. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  2873.     SetKeyHandler(CalcHandlePoundKey, KEY_POUND, KEY_EVENT_UP);
  2874.     /* start vijay 20050603...moved outside the ifdefs for soft key's implementation */
  2875.     SetLeftSoftkeyFunction(CalcComputeResult, KEY_EVENT_UP);
  2876.     /* end vijay */
  2877.     if (g_calc_cntx->RSKState == CALC_RSK_BACK)
  2878.     {
  2879.         CalcSetRSKBack();
  2880.     }
  2881.     else
  2882.     {
  2883.         CalcSetRSKClear();
  2884.     }
  2886. #ifndef __MTK_TARGET__
  2887.     register_keyboard_key_handler(CalWin32ArrowKeyHandler);
  2888.     register_keyboard_input_handler(CalWin32NumKeyHandler);
  2889. #endif /* __MTK_TARGET__ */ 
  2891.     register_MMI_key_input_handler();
  2892.     register_key_down_handler(CalcHandleNumKey);
  2893. }
  2896. /*****************************************************************************
  2897.  * FUNCTION
  2898.  *  ExitCalcApp
  2899.  * DESCRIPTION
  2900.  *  Exit function of calculator application
  2901.  * PARAMETERS
  2902.  *  void
  2903.  * RETURNS
  2904.  *  void
  2905.  *****************************************************************************/
  2906. void ExitCalcApp(void)
  2907. {
  2908.     /*----------------------------------------------------------------*/
  2909.     /* Local Variables                                                */
  2910.     /*----------------------------------------------------------------*/
  2912.     /*----------------------------------------------------------------*/
  2913.     /* Code Body                                                      */
  2914.     /*----------------------------------------------------------------*/
  2915.     MMI_disable_title_shortcut_display = 0;
  2916. }
  2919. /*****************************************************************************
  2920.  * FUNCTION
  2921.  *  EntryCalcApp
  2922.  * DESCRIPTION
  2923.  *  Entry function of calculator application
  2924.  * PARAMETERS
  2925.  *  void
  2926.  * RETURNS
  2927.  *  void
  2928.  *****************************************************************************/
  2929. void EntryCalcApp(void)
  2930. {
  2931.     /*----------------------------------------------------------------*/
  2932.     /* Local Variables                                                */
  2933.     /*----------------------------------------------------------------*/
  2935.     /*----------------------------------------------------------------*/
  2936.     /* Code Body                                                      */
  2937.     /*----------------------------------------------------------------*/
  2938.     EntryNewScreen(SCR_ID_CALC_APP, ExitCalcApp, EntryCalcApp, NULL);
  2939.     SetDelScrnIDCallbackHandler(SCR_ID_CALC_APP, (HistoryDelCBPtr) mmi_calc_del_scr_callback);
  2940. #ifndef __MMI_TOUCH_CALCULATOR__
  2941. #if !defined (__MMI_MAINLCD_176X220__) && !defined (__MMI_MAINLCD_240X320__)
  2942.     entry_full_screen();
  2943. #endif 
  2944. #else /* __MMI_TOUCH_CALCULATOR__ */ 
  2945. #if defined(__MMI_MAINLCD_240X320__)
  2946. #ifdef __MMI_WALLPAPER_ON_BOTTOM__
  2947.     wgui_set_wallpaper_on_bottom(MMI_TRUE);
  2948.     dm_set_scr_bg_redraw(MMI_TRUE);
  2949. #endif /* __MMI_WALLPAPER_ON_BOTTOM__ */ 
  2950. #endif /* defined(__MMI_MAINLCD_240X320__) */ 
  2951. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  2952.     CalcRedraw();
  2953.     CalcRegisterKeyHandler();
  2954.     register_left_softkey_handler();
  2955.     register_right_softkey_handler();
  2956.     register_default_hide_softkeys();
  2957. #ifdef __MMI_TOUCH_CALCULATOR__
  2958.     mmi_pen_register_down_handler(mmi_touchcalc_pen_down_hdlr);
  2959.     mmi_pen_register_up_handler(mmi_touchcalc_pen_up_hdlr);
  2960.     mmi_pen_register_move_handler(mmi_touchcalc_pen_move_hdlr);
  2961.     mmi_pen_register_repeat_handler(mmi_touchcalc_pen_repeat_hdlr);
  2962.     mmi_pen_register_long_tap_handler(mmi_touchcalc_pen_long_tap_hdlr);
  2963. #endif /* __MMI_TOUCH_CALCULATOR__ */ 
  2965. #if defined(__MMI_WITH_C_KEY__)
  2966.     SetKeyHandler(CalcHandleClearKey, KEY_CLEAR, KEY_EVENT_DOWN);
  2967.     SetKeyHandler(CalcHandleRSKLongPress, KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  2968. #endif /* defined(__MMI_WITH_C_KEY__) */ 
  2970.     RedrawCategoryFunction = CalcRedraw;
  2971. }
  2974. /*****************************************************************************
  2975.  * FUNCTION
  2976.  *  CalcPreEntryApp
  2977.  * DESCRIPTION
  2978.  *  Initialize data before entry calculator.
  2979.  * PARAMETERS
  2980.  *  void
  2981.  * RETURNS
  2982.  *  void
  2983.  *****************************************************************************/
  2984. void CalcPreEntryApp(void)
  2985. {
  2986.     /*----------------------------------------------------------------*/
  2987.     /* Local Variables                                                */
  2988.     /*----------------------------------------------------------------*/
  2989.     S32 i;
  2991.     /*----------------------------------------------------------------*/
  2992.     /* Code Body                                                      */
  2993.     /*----------------------------------------------------------------*/
  2994.     if (g_calc_cntx == NULL)
  2995.     {
  2996.         g_calc_cntx = OslMalloc(sizeof(calc_context_struct));
  2997.     }
  2999.     memset(g_calc_cntx, 0, sizeof(calc_context_struct));
  3001.     /* initialize image */
  3002.     /* 050905 Sophie modified start */
  3003. #ifdef __MMI_SLIM_CALCULATOR__
  3004.     for (i = CALC_OP_PLUS; i <= CALC_OP_EQUAL; i++)
  3005. #else 
  3006.     for (i = CALC_OP_PLUS; i < CALC_OP_NONE; i++)
  3007. #endif 
  3008.         /* 050905 Sophie modified end  */
  3009.     {
  3010.         g_calc_cntx->OperatorImg[i].x = gCalcImgCoor[i][0];
  3011.         g_calc_cntx->OperatorImg[i].y = gCalcImgCoor[i][1];
  3012.         g_calc_cntx->OperatorImg[i].image = (PU8) GetImage((U16) (IMG_ID_CALC_PLUS + i));
  3013.     }
  3015.     /* initialize keys */
  3016.     CalcResetContext();
  3017.     EntryCalcApp();
  3018. }
  3020. #ifdef __MMI_TOUCH_CALCULATOR__
  3023. /*****************************************************************************
  3024.  * FUNCTION
  3025.  *  mmi_touchcalc_pen_down_hdlr
  3026.  * DESCRIPTION
  3027.  *  
  3028.  * PARAMETERS
  3029.  *  point       [IN]        
  3030.  * RETURNS
  3031.  *  void
  3032.  *****************************************************************************/
  3033. void mmi_touchcalc_pen_down_hdlr(mmi_pen_point_struct point)
  3034. {
  3035.     /*----------------------------------------------------------------*/
  3036.     /* Local Variables                                                */
  3037.     /*----------------------------------------------------------------*/
  3038.     MMI_BOOL ret = MMI_FALSE;
  3039.     gui_calc_pen_enum calc_menu_event;
  3040.     gui_button_pen_enum button_event;
  3042.     /*----------------------------------------------------------------*/
  3043.     /* Code Body                                                      */
  3044.     /*----------------------------------------------------------------*/
  3045.     ret = translate_softkey_pen_event(MMI_LEFT_SOFTKEY, MMI_PEN_EVENT_DOWN, point.x, point.y, &button_event);
  3046.     if (ret)
  3047.     {
  3048.         calc_pen_on_object = TOUCH_CALC_PEN_LSK;
  3049.         if (button_event == GUI_BUTTON_PEN_DOWN)
  3050.         {
  3051.             execute_softkey_function(KEY_EVENT_DOWN, MMI_LEFT_SOFTKEY);
  3052.         }
  3053.     }
  3054.     ret = translate_softkey_pen_event(MMI_RIGHT_SOFTKEY, MMI_PEN_EVENT_DOWN, point.x, point.y, &button_event);
  3055.     if (ret)
  3056.     {
  3057.         calc_pen_on_object = TOUCH_CALC_PEN_RSK;
  3058.         if (button_event == GUI_BUTTON_PEN_DOWN)
  3059.         {
  3060.             execute_softkey_function(KEY_EVENT_DOWN, MMI_RIGHT_SOFTKEY);
  3061.         }
  3062.     }
  3063.     ret = gui_calculator_translate_pen_event(&calculator_keypad, point.x, point.y, &calc_menu_event, MMI_PEN_EVENT_DOWN);
  3064.     if (ret)
  3065.     {
  3066.         calc_pen_on_object = TOUCH_CALC_PEN_NUM_KEY;
  3067.         if (calc_menu_event == GUI_CALC_PEN_HIGHLIGHT_CHANGED)
  3068.         {
  3069.             gui_BLT_double_buffer(
  3070.                 TOUCH_CALC_SCREEN_X,
  3071.                 TOUCH_CALC_SCREEN_Y,
  3072.                 UI_device_width - 1,
  3073.                 TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  3074.         }
  3075.     }
  3076. }
  3079. /*****************************************************************************
  3080.  * FUNCTION
  3081.  *  mmi_touchcalc_pen_up_hdlr
  3082.  * DESCRIPTION
  3083.  *  
  3084.  * PARAMETERS
  3085.  *  point       [IN]        
  3086.  * RETURNS
  3087.  *  void
  3088.  *****************************************************************************/
  3089. void mmi_touchcalc_pen_up_hdlr(mmi_pen_point_struct point)
  3090. {
  3091.     /*----------------------------------------------------------------*/
  3092.     /* Local Variables                                                */
  3093.     /*----------------------------------------------------------------*/
  3094.     gui_button_pen_enum button_event;
  3095.     gui_calc_pen_enum calc_menu_event;
  3097.     /*----------------------------------------------------------------*/
  3098.     /* Code Body                                                      */
  3099.     /*----------------------------------------------------------------*/
  3100.     switch (calc_pen_on_object)
  3101.     {
  3102.         case TOUCH_CALC_PEN_NUM_KEY:
  3103.             gui_calculator_translate_pen_event(
  3104.                 &calculator_keypad,
  3105.                 point.x,
  3106.                 point.y,
  3107.                 &calc_menu_event,
  3108.                 MMI_PEN_EVENT_UP);
  3109.             if (calc_menu_event == GUI_CALC_PEN_HIGHLIGHT_CHANGED)
  3110.             {
  3111.                 gui_BLT_double_buffer(
  3112.                     TOUCH_CALC_SCREEN_X,
  3113.                     TOUCH_CALC_SCREEN_Y,
  3114.                     UI_device_width - 1,
  3115.                     TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  3116.             }
  3117.             break;
  3118.         case TOUCH_CALC_PEN_LSK:
  3119.             translate_softkey_pen_event(MMI_LEFT_SOFTKEY, MMI_PEN_EVENT_UP, point.x, point.y, &button_event);
  3120.             if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  3121.             {
  3122.                 execute_softkey_function(KEY_EVENT_UP, MMI_LEFT_SOFTKEY);
  3123.             }
  3124.             break;
  3125.         case TOUCH_CALC_PEN_RSK:
  3126.             translate_softkey_pen_event(MMI_RIGHT_SOFTKEY, MMI_PEN_EVENT_UP, point.x, point.y, &button_event);
  3127.             if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  3128.             {
  3129.                 execute_softkey_function(KEY_EVENT_UP, MMI_RIGHT_SOFTKEY);
  3130.             }
  3131.             break;
  3132.     }
  3133.     calc_pen_on_object = TOUCH_CALC_PEN_NONE;
  3134. }
  3137. /*****************************************************************************
  3138.  * FUNCTION
  3139.  *  mmi_touchcalc_pen_move_hdlr
  3140.  * DESCRIPTION
  3141.  *  
  3142.  * PARAMETERS
  3143.  *  point       [IN]        
  3144.  * RETURNS
  3145.  *  void
  3146.  *****************************************************************************/
  3147. void mmi_touchcalc_pen_move_hdlr(mmi_pen_point_struct point)
  3148. {
  3149.     /*----------------------------------------------------------------*/
  3150.     /* Local Variables                                                */
  3151.     /*----------------------------------------------------------------*/
  3152.     S16 x1, x2, y1, y2;
  3153.     gui_calc_pen_enum calc_menu_event;
  3154.     gui_button_pen_enum button_event;
  3156.     /*----------------------------------------------------------------*/
  3157.     /* Code Body                                                      */
  3158.     /*----------------------------------------------------------------*/
  3159.     switch (calc_pen_on_object)
  3160.     {
  3161.         case TOUCH_CALC_PEN_NUM_KEY:
  3162.             gui_calculator_translate_pen_event(
  3163.                 &calculator_keypad,
  3164.                 point.x,
  3165.                 point.y,
  3166.                 &calc_menu_event,
  3167.                 MMI_PEN_EVENT_MOVE);
  3168.             if (calc_menu_event == GUI_CALC_PEN_HIGHLIGHT_CHANGED)
  3169.             {
  3170.                 TOUCH_CALC_SELECT_KEY = FALSE;
  3171.                 x1 = calculator_keypad.selected_key_x;
  3172.                 y1 = calculator_keypad.selected_key_y;
  3173.                 x2 = x1 + calculator_keypad.key_width;
  3174.                 y2 = y1 + calculator_keypad.key_height;
  3175.                 gdi_layer_push_clip();
  3176.                 gdi_layer_set_clip(x1, y1, x2, y2);
  3177.                 gdi_image_cache_bmp_draw(x1, y1, &calculator_keypad.selected_key_bitmap);
  3178.                 gdi_layer_pop_clip();
  3179.                 gui_BLT_double_buffer(
  3180.                     TOUCH_CALC_SCREEN_X,
  3181.                     TOUCH_CALC_SCREEN_Y,
  3182.                     UI_device_width - 1,
  3183.                     TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  3184.             }
  3185.             gui_BLT_double_buffer(
  3186.                 TOUCH_CALC_SCREEN_X,
  3187.                 TOUCH_CALC_SCREEN_Y,
  3188.                 UI_device_width - 1,
  3189.                 TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  3190.             break;
  3191.         case TOUCH_CALC_PEN_LSK:
  3192.             translate_softkey_pen_event(MMI_LEFT_SOFTKEY, MMI_PEN_EVENT_MOVE, point.x, point.y, &button_event);
  3193.             break;
  3194.         case TOUCH_CALC_PEN_RSK:
  3195.             translate_softkey_pen_event(MMI_RIGHT_SOFTKEY, MMI_PEN_EVENT_MOVE, point.x, point.y, &button_event);
  3196.             break;
  3197.     }
  3198. }
  3201. /*****************************************************************************
  3202.  * FUNCTION
  3203.  *  mmi_touchcalc_pen_repeat_hdlr
  3204.  * DESCRIPTION
  3205.  *  
  3206.  * PARAMETERS
  3207.  *  point       [IN]        
  3208.  * RETURNS
  3209.  *  void
  3210.  *****************************************************************************/
  3211. void mmi_touchcalc_pen_repeat_hdlr(mmi_pen_point_struct point)
  3212. {
  3213.     /*----------------------------------------------------------------*/
  3214.     /* Local Variables                                                */
  3215.     /*----------------------------------------------------------------*/
  3216.     gui_calc_pen_enum calc_menu_event;
  3218.     /*----------------------------------------------------------------*/
  3219.     /* Code Body                                                      */
  3220.     /*----------------------------------------------------------------*/
  3221.     if (calculator_keypad.flag == CALC_PEN_DOWN_ON_KEYPAD)
  3222.     {
  3223.         gui_calculator_translate_pen_event(
  3224.             &calculator_keypad,
  3225.             point.x,
  3226.             point.y,
  3227.             &calc_menu_event,
  3228.             MMI_PEN_EVENT_REPEAT);
  3229.         if (calc_menu_event == GUI_CALC_PEN_HIGHLIGHT_CHANGED)
  3230.         {
  3231.             gui_BLT_double_buffer(
  3232.                 TOUCH_CALC_SCREEN_X,
  3233.                 TOUCH_CALC_SCREEN_Y,
  3234.                 UI_device_width - 1,
  3235.                 TOUCH_CALC_SCREEN_Y + TOUCH_CALC_SCREEN_HEIGHT - 1);
  3236.         }
  3237.     }
  3238. }
  3241. /*****************************************************************************
  3242.  * FUNCTION
  3243.  *  mmi_touchcalc_pen_long_tap_hdlr
  3244.  * DESCRIPTION
  3245.  *  
  3246.  * PARAMETERS
  3247.  *  point       [IN]        
  3248.  * RETURNS
  3249.  *  void
  3250.  *****************************************************************************/
  3251. void mmi_touchcalc_pen_long_tap_hdlr(mmi_pen_point_struct point)
  3252. {
  3253.     /*----------------------------------------------------------------*/
  3254.     /* Local Variables                                                */
  3255.     /*----------------------------------------------------------------*/
  3256.     gui_button_pen_enum button_event;
  3258.     /*----------------------------------------------------------------*/
  3259.     /* Code Body                                                      */
  3260.     /*----------------------------------------------------------------*/
  3261.     if (calc_pen_on_object == TOUCH_CALC_PEN_RSK)
  3262.     {
  3263.         translate_softkey_pen_event(MMI_RIGHT_SOFTKEY, MMI_PEN_EVENT_LONG_TAP, point.x, point.y, &button_event);
  3264.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  3265.         {
  3266.             execute_softkey_function(KEY_LONG_PRESS, MMI_RIGHT_SOFTKEY);
  3267.         }
  3268.     }
  3270. }
  3273. /*****************************************************************************
  3274.  * FUNCTION
  3275.  *  setup_calculator_keypad
  3276.  * DESCRIPTION
  3277.  *  
  3278.  * PARAMETERS
  3279.  *  calculator_keypad       [?]         
  3280.  *  x                       [IN]        
  3281.  *  y                       [IN]        
  3282.  * RETURNS
  3283.  *  void
  3284.  *****************************************************************************/
  3285. void setup_calculator_keypad(calculator_keypad_struct *calculator_keypad, S16 x, S16 y)
  3286. {
  3287.     /*----------------------------------------------------------------*/
  3288.     /* Local Variables                                                */
  3289.     /*----------------------------------------------------------------*/
  3291.     /*----------------------------------------------------------------*/
  3292.     /* Code Body                                                      */
  3293.     /*----------------------------------------------------------------*/
  3294.     calculator_keypad->result_area_x = x + CALC_TOUCH_RESULT_AREA_X;
  3295.     calculator_keypad->result_area_y = y + CALC_TOUCH_RESULT_AREA_Y;
  3297.     calculator_keypad->keypad_x = calculator_keypad->result_area_x;
  3298.     calculator_keypad->keypad_y = calculator_keypad->result_area_y + CALC_TOUCH_RESULT_AREA_HEIGHT + CALC_TOUCH_RESULT_KEYPAD_GAP;      /* 041205 Calvin modified */
  3299.     calculator_keypad->keypad_width = CALC_TOUCH_KEYPAD_WIDTH;
  3300.     calculator_keypad->keypad_height = CALC_TOUCH_KEYPAD_HEIGHT;
  3301.     calculator_keypad->key_width = CALC_TOUCH_KEY_WIDTH;
  3302.     calculator_keypad->key_height = CALC_TOUCH_KEY_HEIGHT;
  3303.     calculator_keypad->key_type = MMI_CALC_KEY_NONE;
  3304.     calculator_keypad->horizontal_gap = CALC_TOUCH_HORIZONTAL_GAP;
  3305.     calculator_keypad->vertical_gap = CALC_TOUCH_VERTICAL_GAP;
  3306.     calculator_keypad->n_column = CALC_TOUCH_NCOLUMNS;
  3307.     calculator_keypad->n_rows = CALC_TOUCH_NROWS;
  3308.     calculator_keypad->operand1_y = calculator_keypad->result_area_y + CALC_TOUCH_OPERAND1_Y;
  3309.     calculator_keypad->operand2_y = calculator_keypad->result_area_y + CALC_TOUCH_OPERAND2_Y;
  3310.     calculator_keypad->operator_x = calculator_keypad->result_area_x + CALC_TOUCH_OPERATOR_X;
  3311.     calculator_keypad->operator_y = calculator_keypad->operand2_y;
  3312.     calculator_keypad->mem_x1 = calculator_keypad->result_area_x + TOUCH_CALC_MEM_X1;
  3313.     calculator_keypad->mem_y1 = calculator_keypad->result_area_y + TOUCH_CALC_MEM_Y1;
  3314.     calculator_keypad->flag = 0;
  3316. }
  3319. /*****************************************************************************
  3320.  * FUNCTION
  3321.  *  show_touch_calculator_screen
  3322.  * DESCRIPTION
  3323.  *  
  3324.  * PARAMETERS
  3325.  *  x1          [IN]        
  3326.  *  y1          [IN]        
  3327.  *  width       [IN]        
  3328.  *  height      [IN]        
  3329.  * RETURNS
  3330.  *  void
  3331.  *****************************************************************************/
  3332. void show_touch_calculator_screen(S32 x1, S32 y1, S32 width, S32 height)
  3333. {
  3334.     /*----------------------------------------------------------------*/
  3335.     /* Local Variables                                                */
  3336.     /*----------------------------------------------------------------*/
  3338.     S32 x2, y2;
  3340.     /*----------------------------------------------------------------*/
  3341.     /* Code Body                                                      */
  3342.     /*----------------------------------------------------------------*/
  3343.     x2 = x1 + width - 1;
  3344.     y2 = y1 + height - 1;
  3345.     gdi_layer_push_clip();
  3346.     gdi_layer_set_clip(x1, y1, x2, y2);
  3347.     gui_show_image(x1, y1, (PU8) GetImage(IMG_ID_TOUCH_CALC_MAIN));
  3348.     gdi_layer_pop_clip();
  3349.     gui_BLT_double_buffer(x1, y1, x2, y2);
  3350. }
  3353. /*****************************************************************************
  3354.  * FUNCTION
  3355.  *  gui_calculator_translate_pen_position
  3356.  * DESCRIPTION
  3357.  *  
  3358.  * PARAMETERS
  3359.  *  calculator_keypad       [?]         
  3360.  *  x                       [IN]        
  3361.  *  y                       [IN]        
  3362.  *  item_index              [?]         
  3363.  *  key_variable            [?]         
  3364.  * RETURNS
  3365.  *  void
  3366.  *****************************************************************************/
  3367. void gui_calculator_translate_pen_position(
  3368.         calculator_keypad_struct *calculator_keypad,
  3369.         S32 x,
  3370.         S32 y,
  3371.         S32 *item_index,
  3372.         S32 *key_variable)
  3373. {
  3374.     /*----------------------------------------------------------------*/
  3375.     /* Local Variables                                                */
  3376.     /*----------------------------------------------------------------*/
  3377.     S32 total_height = 0, total_width = 0;
  3378.     S32 i, j;
  3380.     /*----------------------------------------------------------------*/
  3381.     /* Code Body                                                      */
  3382.     /*----------------------------------------------------------------*/
  3383.     total_height = 0;
  3384.     total_width = 0;
  3386.     x = x - calculator_keypad->keypad_x + 1;
  3387.     y = y - calculator_keypad->keypad_y + 1;
  3389.     for (i = 0; i < calculator_keypad->n_rows; i++)
  3390.     {
  3391.         total_height += calculator_keypad->key_height;
  3392.         if (total_height >= y)
  3393.         {
  3394.             for (j = 0; j < calculator_keypad->n_column; j++)
  3395.             {
  3396.                 total_width += calculator_keypad->key_width;
  3397.                 if (total_width >= x)
  3398.                 {
  3399.                     *item_index = i * calculator_keypad->n_column + j + 1;
  3400.                     *key_variable = TouchCalcKeys[i][j];
  3401.                     calculator_keypad->selected_key_x =
  3402.                         calculator_keypad->keypad_x + (calculator_keypad->key_width) * j +
  3403.                         (calculator_keypad->horizontal_gap) * j;
  3404.                     calculator_keypad->selected_key_y =
  3405.                         calculator_keypad->keypad_y + (calculator_keypad->key_height) * i +
  3406.                         (calculator_keypad->vertical_gap) * i;
  3407.                     if (i == 0 || j == (calculator_keypad->n_column - 1) ||
  3408.                         (*key_variable == TOUCH_CALC_OP_EQUAL && i == calculator_keypad->n_rows - 1))
  3409.                     {
  3410.                         calculator_keypad->key_type = MMI_CALC_SYM_KEY;
  3411.                     }
  3412.                     else
  3413.                     {
  3414.                         calculator_keypad->key_type = MMI_CALC_NUM_KEY;
  3415.                     }
  3416.                     break;
  3417.                 }
  3418.                 else
  3419.                 {
  3420.                     total_width += calculator_keypad->horizontal_gap;
  3421.                     if (total_width >= x)
  3422.                     {
  3423.                         *item_index = -1;
  3424.                         return;
  3425.                     }
  3426.                 }
  3428.             }
  3429.             break;
  3430.         }
  3431.         else
  3432.         {
  3433.             total_height += calculator_keypad->vertical_gap;
  3434.             if (total_height >= y)
  3435.             {
  3436.                 *item_index = -1;
  3437.                 return;
  3438.             }
  3439.         }
  3440.     }
  3441. }
  3444. /*****************************************************************************
  3445.  * FUNCTION
  3446.  *  gui_calculator_key_select
  3447.  * DESCRIPTION
  3448.  *  
  3449.  * PARAMETERS
  3450.  *  calculator_keypad       [?]         
  3451.  *  item_index              [IN]        
  3452.  * RETURNS
  3453.  *  void
  3454.  *****************************************************************************/
  3455. void gui_calculator_key_select(calculator_keypad_struct *calculator_keypad, S32 item_index)
  3456. {
  3457.     /*----------------------------------------------------------------*/
  3458.     /* Local Variables                                                */
  3459.     /*----------------------------------------------------------------*/
  3460.     S32 x1, y1, x2, y2;
  3461.     S32 width, height;
  3462.     MMI_ID_TYPE image_id;
  3464.     /*----------------------------------------------------------------*/
  3465.     /* Code Body                                                      */
  3466.     /*----------------------------------------------------------------*/
  3467.     x1 = calculator_keypad->selected_key_x;
  3468.     y1 = calculator_keypad->selected_key_y;
  3470.     x2 = x1 + calculator_keypad->key_width - 1;
  3471.     y2 = y1 + calculator_keypad->key_height - 1;
  3473.     calculator_keypad->selected_key_bitmap.buf_ptr = (U8*) matrix_main_menu_highlight_bitmap_data;
  3475.     memset(
  3476.         calculator_keypad->selected_key_bitmap.buf_ptr,
  3477.         0,
  3478.         (calculator_keypad->key_width) * (calculator_keypad->key_height) * 2);
  3479.     gdi_layer_push_clip();
  3480.     gdi_layer_set_clip(x1, y1, x2, y2);
  3481.     gdi_image_cache_bmp_get(x1, y1, x2, y2, &calculator_keypad->selected_key_bitmap);
  3482.     gdi_layer_pop_clip();
  3484.     gdi_layer_push_clip();
  3485.     gdi_layer_set_clip(x1, y1, x2, y2);
  3486.     image_id = calculator_key_image[item_index - 1];
  3487.     gui_measure_image(get_image(image_id), &width, &height);
  3488.     x1 = x1 + ((calculator_keypad->key_width >> 1) - (width >> 1));
  3489.     y1 = y1 + ((calculator_keypad->key_height >> 1) - (height >> 1));
  3490.     gui_show_image(x1, y1, get_image(image_id));
  3491.     gdi_layer_pop_clip();
  3492. }
  3495. /*****************************************************************************
  3496.  * FUNCTION
  3497.  *  gui_calculator_key_unselect
  3498.  * DESCRIPTION
  3499.  *  
  3500.  * PARAMETERS
  3501.  *  calculator_keypad       [?]     
  3502.  * RETURNS
  3503.  *  void
  3504.  *****************************************************************************/
  3505. void gui_calculator_key_unselect(calculator_keypad_struct *calculator_keypad)
  3506. {
  3507.     /*----------------------------------------------------------------*/
  3508.     /* Local Variables                                                */
  3509.     /*----------------------------------------------------------------*/
  3510.     S16 x1, x2, y1, y2;
  3512.     /*----------------------------------------------------------------*/
  3513.     /* Code Body                                                      */
  3514.     /*----------------------------------------------------------------*/
  3515.     x1 = calculator_keypad->selected_key_x;
  3516.     y1 = calculator_keypad->selected_key_y;
  3517.     x2 = x1 + calculator_keypad->key_width - 1;
  3518.     y2 = y1 + calculator_keypad->key_height - 1;
  3520.     gdi_layer_push_clip();
  3521.     gdi_layer_set_clip(x1, y1, x2, y2);
  3522.     gdi_image_cache_bmp_draw(x1, y1, &calculator_keypad->selected_key_bitmap);
  3523.     calculator_keypad->selected_key_x = 0;
  3524.     calculator_keypad->selected_key_y = 0;
  3525.     gdi_layer_pop_clip();
  3526. }
  3529. /*****************************************************************************
  3530.  * FUNCTION
  3531.  *  gui_calculator_translate_pen_event
  3532.  * DESCRIPTION
  3533.  *  
  3534.  * PARAMETERS
  3535.  *  calculator_keypad       [?]         
  3536.  *  x                       [IN]        
  3537.  *  y                       [IN]        
  3538.  *  menu_event              [?]         
  3539.  *  pen_event               [IN]        
  3540.  * RETURNS
  3541.  *  
  3542.  *****************************************************************************/
  3543. BOOL gui_calculator_translate_pen_event(
  3544.         calculator_keypad_struct *calculator_keypad,
  3545.         S32 x,
  3546.         S32 y,
  3547.         gui_calc_pen_enum *menu_event,
  3548.         mmi_pen_event_type_enum pen_event)
  3549. {
  3550.     /*----------------------------------------------------------------*/
  3551.     /* Local Variables                                                */
  3552.     /*----------------------------------------------------------------*/
  3553.     S32 x1, y1;
  3554.     BOOL ret;
  3555.     S32 item_index, key_variable;
  3557.     /*----------------------------------------------------------------*/
  3558.     /* Code Body                                                      */
  3559.     /*----------------------------------------------------------------*/
  3560.     x1 = calculator_keypad->keypad_x;
  3561.     y1 = calculator_keypad->keypad_y;
  3563.     ret = TRUE;
  3564.     *menu_event = GUI_CALC_PEN_NONE;
  3565.     switch (pen_event)
  3566.     {
  3567.         case MMI_PEN_EVENT_DOWN:
  3568.             if (PEN_CHECK_BOUND(x, y, x1, y1, calculator_keypad->keypad_width, calculator_keypad->keypad_height))
  3569.             {
  3570.                 gui_calculator_translate_pen_position(calculator_keypad, x, y, &item_index, &key_variable);
  3571.                 if (item_index > MMI_CALC_KEY_START && item_index <= MMI_CALC_KEY_END)
  3572.                 {
  3573.                     calculator_keypad->flag |= CALC_PEN_DOWN_ON_KEYPAD;
  3574.                     gui_calculator_key_select(calculator_keypad, item_index);
  3575.                     if (calculator_keypad->key_type == MMI_CALC_NUM_KEY)
  3576.                     {
  3577.                         *menu_event = GUI_CALC_PEN_HIGHLIGHT_CHANGED;
  3578.                         if (key_variable == TOUCH_CALC_KEY_DOT && g_calc_cntx->ResultState == RESULT_NOT_EXCEED)        /* should not be called if result is exceded..no change on pressing Dot */
  3579.                         {
  3580.                             CalcHandlePoundKey();
  3581.                         }
  3582.                         else
  3583.                         {
  3584.                             CalcHandleNumKey(key_variable);
  3585.                         }
  3586.                     }
  3587.                     else if (calculator_keypad->key_type == MMI_CALC_SYM_KEY)
  3588.                     {
  3589.                         *menu_event = GUI_CALC_PEN_HIGHLIGHT_CHANGED;
  3590.                         g_calc_cntx->CurrHilite = key_variable;
  3591.                         if (key_variable == TOUCH_CALC_OP_EQUAL)
  3592.                         {
  3593.                             CalcComputeResult();
  3594.                         }
  3595.                         else if (key_variable >= TOUCH_CALC_OP_MP && key_variable <= TOUCH_CALC_OP_MR && g_calc_cntx->ResultState == RESULT_NOT_EXCEED) /* should not be called if result is exceded..no change on pressing these buttons */
  3596.                         {
  3597.                             if (g_calc_cntx->OpToExecute < CALC_OP_EQUAL)
  3598.                             {
  3599.                                 CalcGetPreOperand();
  3600.                                 if ((g_calc_cntx->Operand2 == 0) && (g_calc_cntx->OpToExecute == CALC_OP_DIV))
  3601.                                 {
  3602.                                     g_calc_cntx->ResultState = RESULT_EXCEED;
  3603.                                     CalcSetRSKClear();
  3604.                                     g_calc_cntx->Operator = CALC_OP_NONE;
  3605.                                     playRequestedTone(ERROR_TONE);
  3606.                                 }
  3607.                                 else
  3608.                                 {
  3609.                                     g_calc_cntx->Operand1 = CalcExecOperator(g_calc_cntx->Operand1, g_calc_cntx->Operand2);
  3610.                                     g_calc_cntx->OpToExecute = CALC_OP_NONE;
  3611.                                 }
  3612.                             }
  3613.                             else
  3614.                             {
  3615.                                 CalcHandleHiliteOperator();
  3616.                             }
  3618.                             CalcHandleHiliteMemoryButton();
  3619.                             if (g_calc_cntx->ResultState == RESULT_EXCEED)
  3620.                             {
  3621.                                 playRequestedTone(ERROR_TONE);
  3622.                             }
  3623.                             CalcComputeResult();
  3624.                         }
  3625.                         else
  3626.                         {
  3627.                             CalcHandleHiliteOperator();
  3628.                             if (g_calc_cntx->ResultState == RESULT_EXCEED)
  3629.                             {
  3630.                                 playRequestedTone(ERROR_TONE);
  3631.                             }
  3632.                             CalcShowResultScreen();
  3633.                         }
  3634.                     }
  3635.                 }
  3636.                 else
  3637.                 {
  3638.                     ret = FALSE;
  3639.                 }
  3640.             }
  3641.             else
  3642.             {
  3643.                 ret = FALSE;
  3644.             }
  3645.             break;
  3647.         case MMI_PEN_EVENT_UP:
  3648.             calculator_keypad->flag &= ~CALC_PEN_DOWN_ON_KEYPAD;
  3649.             TOUCH_CALC_SELECT_KEY = TRUE;
  3650.             if (PEN_CHECK_BOUND
  3651.                 (x, y, calculator_keypad->selected_key_x, calculator_keypad->selected_key_y,
  3652.                  calculator_keypad->key_width, calculator_keypad->key_height))
  3653.             {
  3654.                 *menu_event = GUI_CALC_PEN_HIGHLIGHT_CHANGED;
  3655.                 gui_calculator_key_unselect(calculator_keypad);
  3656.             }
  3657.             else if (TOUCH_CALC_SELECT_KEY)
  3658.             {
  3659.                 gui_calculator_key_unselect(calculator_keypad);
  3660.             }
  3661.             break;
  3662.         case MMI_PEN_EVENT_MOVE:
  3663.             if ((!PEN_CHECK_BOUND
  3664.                  (x, y, calculator_keypad->selected_key_x, calculator_keypad->selected_key_y,
  3665.                   calculator_keypad->key_width, calculator_keypad->key_height)))
  3666.             {
  3667.                 *menu_event = GUI_CALC_PEN_HIGHLIGHT_CHANGED;
  3668.                 TOUCH_CALC_SELECT_KEY = FALSE;
  3669.             }
  3670.             else if (PEN_CHECK_BOUND
  3671.                      (x, y, calculator_keypad->selected_key_x, calculator_keypad->selected_key_y,
  3672.                       calculator_keypad->key_width, calculator_keypad->key_height))
  3673.             {
  3674.                 gui_calculator_translate_pen_position(calculator_keypad, x, y, &item_index, &key_variable);
  3675.                 if (!TOUCH_CALC_SELECT_KEY)
  3676.                 {
  3677.                     gui_calculator_key_select(calculator_keypad, item_index);
  3678.                 }
  3679.                 TOUCH_CALC_SELECT_KEY = TRUE;
  3680.             }
  3681.             break;
  3682.         case MMI_PEN_EVENT_LONG_TAP:
  3683.             break;
  3684.         case MMI_PEN_EVENT_REPEAT:
  3685.             if (PEN_CHECK_BOUND
  3686.                 (x, y, calculator_keypad->selected_key_x, calculator_keypad->selected_key_y,
  3687.                  calculator_keypad->key_width, calculator_keypad->key_height))
  3688.             {
  3689.                 gui_calculator_translate_pen_position(calculator_keypad, x, y, &item_index, &key_variable);
  3690.                 if (calculator_keypad->key_type == MMI_CALC_NUM_KEY)
  3691.                 {
  3692.                     *menu_event = GUI_CALC_PEN_HIGHLIGHT_CHANGED;
  3693.                     if (key_variable == TOUCH_CALC_KEY_DOT)
  3694.                     {
  3695.                         CalcHandlePoundKey();
  3696.                     }
  3697.                     else
  3698.                     {
  3699.                         CalcHandleNumKey(key_variable);
  3700.                     }
  3701.                 }
  3702.             }
  3703.             break;
  3704.     }
  3705.     return ret;
  3706. }
  3707. #endif /* __MMI_TOUCH_CALCULATOR__ */ /* __MMI_TOUCH_SCREEN */
  3708. #endif /* __MMI_CALCULATOR__ */ 
  3710. #endif /* _MMI_CALCULATOR_C */ // #ifndef _MMI_CALCULATOR_C