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

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

MTK

开发平台：

C/C++

TouchScreen.c：源码内容
  1. /*****************************************************************************
  2.  * FUNCTION
  3.  *  mmi_pen_test_clear_screen
  4.  * DESCRIPTION
  5.  *  
  6.  * PARAMETERS
  7.  *  void
  8.  * RETURNS
  9.  *  void
  10.  *****************************************************************************/
  11. static void mmi_pen_test_clear_screen(void)
  12. {
  13.     /*----------------------------------------------------------------*/
  14.     /* Local Variables                                                */
  15.     /*----------------------------------------------------------------*/
  17.     /*----------------------------------------------------------------*/
  18.     /* Code Body                                                      */
  19.     /*----------------------------------------------------------------*/
  20.     memset(mmi_pen_draw_buffer, 0, sizeof(mmi_pen_draw_buffer));
  21. }
  24. /*****************************************************************************
  25.  * FUNCTION
  26.  *  mmi_pen_test_draw_point
  27.  * DESCRIPTION
  28.  *  
  29.  * PARAMETERS
  30.  *  x       [IN]        
  31.  *  y       [IN]        
  32.  * RETURNS
  33.  *  void
  34.  *****************************************************************************/
  35. static void mmi_pen_test_draw_point(S32 x, S32 y)
  36. {
  37.     /*----------------------------------------------------------------*/
  38.     /* Local Variables                                                */
  39.     /*----------------------------------------------------------------*/
  40.     S32 offset;
  42.     /*----------------------------------------------------------------*/
  43.     /* Code Body                                                      */
  44.     /*----------------------------------------------------------------*/
  45.     if (x < 0 || x >= LCD_WIDTH || y < 0 || y >= LCD_HEIGHT)
  46.     {
  47.         return;
  48.     }
  50.     offset = y * LCD_WIDTH + x;
  51.     mmi_pen_draw_buffer[offset >> 3] |= (1 << (offset & 0x07));
  52. }
  55. /*****************************************************************************
  56.  * FUNCTION
  57.  *  mmi_pen_test_draw_from_buffer
  58.  * DESCRIPTION
  59.  *  
  60.  * PARAMETERS
  61.  *  x1      [IN]        
  62.  *  y1      [IN]        
  63.  *  x2      [IN]        
  64.  *  y2      [IN]        
  65.  * RETURNS
  66.  *  void
  67.  *****************************************************************************/
  68. static void mmi_pen_test_draw_from_buffer(S32 x1, S32 y1, S32 x2, S32 y2)
  69. {
  70.     /*----------------------------------------------------------------*/
  71.     /* Local Variables                                                */
  72.     /*----------------------------------------------------------------*/
  73.     S32 x, y;
  74.     S32 offset;
  75.     color c;
  77.     /*----------------------------------------------------------------*/
  78.     /* Code Body                                                      */
  79.     /*----------------------------------------------------------------*/
  80.     c.r = 255;
  81.     c.g = c.b = 0;
  82.     c.alpha = 255;
  83.     gui_push_clip();
  84.     gui_set_clip(x1, y1, x2, y2);
  86.     for (y = y1; y <= y2; y++)
  87.     {
  88.         offset = y * LCD_WIDTH;
  89.         for (x = x1; x <= x2; x++)
  90.         {
  91.             if (mmi_pen_draw_buffer[offset >> 3] & (1 << (offset & 0x07)))
  92.             {
  93.                 gui_putpixel(x, y, c);
  94.             }
  95.             offset++;
  96.         }
  97.     }
  98.     gui_pop_clip();
  99. }
  102. /*****************************************************************************
  103.  * FUNCTION
  104.  *  mmi_pen_test_refresh_screen
  105.  * DESCRIPTION
  106.  *  
  107.  * PARAMETERS
  108.  *  void
  109.  * RETURNS
  110.  *  void
  111.  *****************************************************************************/
  112. static void mmi_pen_test_refresh_screen(void)
  113. {
  114.     /*----------------------------------------------------------------*/
  115.     /* Local Variables                                                */
  116.     /*----------------------------------------------------------------*/
  118.     /*----------------------------------------------------------------*/
  119.     /* Code Body                                                      */
  120.     /*----------------------------------------------------------------*/
  121.     gui_lock_double_buffer();
  122.     mmi_pen_test_draw_from_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  123.     gui_unlock_double_buffer();
  124.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  125. }
  128. /*****************************************************************************
  129.  * FUNCTION
  130.  *  mmi_pen_test_draw_line
  131.  * DESCRIPTION
  132.  *  
  133.  * PARAMETERS
  134.  *  x1      [IN]        
  135.  *  y1      [IN]        
  136.  *  x2      [IN]        
  137.  *  y2      [IN]        
  138.  * RETURNS
  139.  *  void
  140.  *****************************************************************************/
  141. static void mmi_pen_test_draw_line(S16 x1, S16 y1, S16 x2, S16 y2)
  142. {
  143.     /*----------------------------------------------------------------*/
  144.     /* Local Variables                                                */
  145.     /*----------------------------------------------------------------*/
  146.     S16 x_diff = abs(x2 - x1);
  147.     S16 y_diff = abs(y2 - y1);
  148.     S16 x_incr, y_incr;
  150.     /*----------------------------------------------------------------*/
  151.     /* Code Body                                                      */
  152.     /*----------------------------------------------------------------*/
  153.     if (x1 > x2)
  154.     {
  155.         x_incr = -1;
  156.     }
  157.     else
  158.     {
  159.         x_incr = 1;
  160.     }
  161.     if (y1 > y2)
  162.     {
  163.         y_incr = -1;
  164.     }
  165.     else
  166.     {
  167.         y_incr = 1;
  168.     }
  170.     if (x_diff >= y_diff)
  171.     {
  172.         S16 pr_diff = y_diff << 1;
  173.         S16 pru_diff = pr_diff - (x_diff << 1);
  174.         S16 p = pr_diff - x_diff;
  176.         for (; x_diff >= 0; x_diff--)
  177.         {
  178.             mmi_pen_test_draw_point(x1, y1);
  179.             if (p > 0)
  180.             {
  181.                 x1 += x_incr;
  182.                 y1 += y_incr;
  183.                 p += pru_diff;
  184.             }
  185.             else
  186.             {
  187.                 x1 += x_incr;
  188.                 p += pr_diff;
  189.             }
  190.         }
  191.     }
  192.     else
  193.     {
  194.         S16 pr_diff = x_diff << 1;
  195.         S16 pru_diff = pr_diff - (y_diff << 1);
  196.         S16 p = pr_diff - y_diff;
  198.         for (; y_diff >= 0; y_diff--)
  199.         {
  200.             mmi_pen_test_draw_point(x1, y1);
  201.             if (p > 0)
  202.             {
  203.                 x1 += x_incr;
  204.                 y1 += y_incr;
  205.                 p += pru_diff;
  206.             }
  207.             else
  208.             {
  209.                 y1 += y_incr;
  210.                 p += pr_diff;
  211.             }
  212.         }
  213.     }
  214. }
  217. /*****************************************************************************
  218.  * FUNCTION
  219.  *  mmi_pen_test_draw_rectangle
  220.  * DESCRIPTION
  221.  *  
  222.  * PARAMETERS
  223.  *  x1      [IN]        
  224.  *  y1      [IN]        
  225.  *  x2      [IN]        
  226.  *  y2      [IN]        
  227.  * RETURNS
  228.  *  void
  229.  *****************************************************************************/
  230. static void mmi_pen_test_draw_rectangle(S16 x1, S16 y1, S16 x2, S16 y2)
  231. {
  232.     /*----------------------------------------------------------------*/
  233.     /* Local Variables                                                */
  234.     /*----------------------------------------------------------------*/
  236.     /*----------------------------------------------------------------*/
  237.     /* Code Body                                                      */
  238.     /*----------------------------------------------------------------*/
  239.     mmi_pen_test_draw_line(x1, y1, x1, y2);
  240.     mmi_pen_test_draw_line(x1, y2, x2, y2);
  241.     mmi_pen_test_draw_line(x2, y2, x2, y1);
  242.     mmi_pen_test_draw_line(x2, y1, x1, y1);
  243. }
  246. /*****************************************************************************
  247.  * FUNCTION
  248.  *  mmi_pen_test_draw_filled_rectangle
  249.  * DESCRIPTION
  250.  *  
  251.  * PARAMETERS
  252.  *  x1      [IN]        
  253.  *  y1      [IN]        
  254.  *  x2      [IN]        
  255.  *  y2      [IN]        
  256.  * RETURNS
  257.  *  void
  258.  *****************************************************************************/
  259. static void mmi_pen_test_draw_filled_rectangle(S16 x1, S16 y1, S16 x2, S16 y2)
  260. {
  261.     /*----------------------------------------------------------------*/
  262.     /* Local Variables                                                */
  263.     /*----------------------------------------------------------------*/
  264.     S16 x, y;
  266.     /*----------------------------------------------------------------*/
  267.     /* Code Body                                                      */
  268.     /*----------------------------------------------------------------*/
  269.     for (x = x1; x <= x2; x++)
  270.     {
  271.         for (y = y1; y <= y2; y++)
  272.         {
  273.             mmi_pen_test_draw_point(x, y);
  274.         }
  275.     }
  276. }
  279. /*****************************************************************************
  280.  * FUNCTION
  281.  *  mmi_pen_test_down
  282.  * DESCRIPTION
  283.  *  
  284.  * PARAMETERS
  285.  *  pos     [IN]        
  286.  * RETURNS
  287.  *  void
  288.  *****************************************************************************/
  289. static void mmi_pen_test_down(mmi_pen_point_struct pos)
  290. {
  291.     /*----------------------------------------------------------------*/
  292.     /* Local Variables                                                */
  293.     /*----------------------------------------------------------------*/
  295.     /*----------------------------------------------------------------*/
  296.     /* Code Body                                                      */
  297.     /*----------------------------------------------------------------*/
  298.     mmi_pen_test_last_pos = pos;
  299. }
  302. /*****************************************************************************
  303.  * FUNCTION
  304.  *  mmi_pen_test_move
  305.  * DESCRIPTION
  306.  *  
  307.  * PARAMETERS
  308.  *  pos     [IN]        
  309.  * RETURNS
  310.  *  void
  311.  *****************************************************************************/
  312. static void mmi_pen_test_move(mmi_pen_point_struct pos)
  313. {
  314.     /*----------------------------------------------------------------*/
  315.     /* Local Variables                                                */
  316.     /*----------------------------------------------------------------*/
  318.     /*----------------------------------------------------------------*/
  319.     /* Code Body                                                      */
  320.     /*----------------------------------------------------------------*/
  321.     mmi_pen_test_draw_line(mmi_pen_test_last_pos.x, mmi_pen_test_last_pos.y, pos.x, pos.y);
  322.     mmi_pen_test_last_pos = pos;
  324.     mmi_pen_test_refresh_screen();
  325. }
  328. /*****************************************************************************
  329.  * FUNCTION
  330.  *  mmi_pen_test_up
  331.  * DESCRIPTION
  332.  *  
  333.  * PARAMETERS
  334.  *  pos     [IN]        
  335.  * RETURNS
  336.  *  void
  337.  *****************************************************************************/
  338. static void mmi_pen_test_up(mmi_pen_point_struct pos)
  339. {
  340.     /*----------------------------------------------------------------*/
  341.     /* Local Variables                                                */
  342.     /*----------------------------------------------------------------*/
  344.     /*----------------------------------------------------------------*/
  345.     /* Code Body                                                      */
  346.     /*----------------------------------------------------------------*/
  347. }
  350. /*****************************************************************************
  351.  * FUNCTION
  352.  *  mmi_pen_test_long_tap
  353.  * DESCRIPTION
  354.  *  
  355.  * PARAMETERS
  356.  *  pos     [IN]        
  357.  * RETURNS
  358.  *  void
  359.  *****************************************************************************/
  360. static void mmi_pen_test_long_tap(mmi_pen_point_struct pos)
  361. {
  362.     /*----------------------------------------------------------------*/
  363.     /* Local Variables                                                */
  364.     /*----------------------------------------------------------------*/
  366.     /*----------------------------------------------------------------*/
  367.     /* Code Body                                                      */
  368.     /*----------------------------------------------------------------*/
  369.     mmi_pen_test_draw_filled_rectangle((S16) (pos.x - 2), (S16) (pos.y - 2), (S16) (pos.x + 2), (S16) (pos.y + 2));
  370.     mmi_pen_test_refresh_screen();
  371. }
  374. /*****************************************************************************
  375.  * FUNCTION
  376.  *  mmi_pen_test_repeat
  377.  * DESCRIPTION
  378.  *  
  379.  * PARAMETERS
  380.  *  pos     [IN]        
  381.  * RETURNS
  382.  *  void
  383.  *****************************************************************************/
  384. static void mmi_pen_test_repeat(mmi_pen_point_struct pos)
  385. {
  386.     /*----------------------------------------------------------------*/
  387.     /* Local Variables                                                */
  388.     /*----------------------------------------------------------------*/
  390.     /*----------------------------------------------------------------*/
  391.     /* Code Body                                                      */
  392.     /*----------------------------------------------------------------*/
  393.     mmi_pen_test_draw_rectangle((S16) (pos.x - 4), (S16) (pos.y - 4), (S16) (pos.x + 4), (S16) (pos.y + 4));
  394.     mmi_pen_test_refresh_screen();
  395. }
  398. /*****************************************************************************
  399.  * FUNCTION
  400.  *  mmi_exit_pen_test_screen
  401.  * DESCRIPTION
  402.  *  
  403.  * PARAMETERS
  404.  *  void
  405.  * RETURNS
  406.  *  void
  407.  *****************************************************************************/
  408. static void mmi_exit_pen_test_screen(void)
  409. {
  410.     /*----------------------------------------------------------------*/
  411.     /* Local Variables                                                */
  412.     /*----------------------------------------------------------------*/
  414.     /*----------------------------------------------------------------*/
  415.     /* Code Body                                                      */
  416.     /*----------------------------------------------------------------*/
  417.     mmi_pen_reset();
  418. }
  421. /*****************************************************************************
  422.  * FUNCTION
  423.  *  mmi_redraw_pen_test_screen
  424.  * DESCRIPTION
  425.  *  
  426.  * PARAMETERS
  427.  *  void
  428.  * RETURNS
  429.  *  void
  430.  *****************************************************************************/
  431. static void mmi_redraw_pen_test_screen(void)
  432. {
  433.     /*----------------------------------------------------------------*/
  434.     /* Local Variables                                                */
  435.     /*----------------------------------------------------------------*/
  437.     /*----------------------------------------------------------------*/
  438.     /* Code Body                                                      */
  439.     /*----------------------------------------------------------------*/
  440.     gui_lock_double_buffer();
  441.     RedrawCategoryFunction();
  442.     mmi_pen_test_draw_from_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  443.     gui_unlock_double_buffer();
  444.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  445. }
  448. /*****************************************************************************
  449.  * FUNCTION
  450.  *  mmi_entry_pen_test_screen
  451.  * DESCRIPTION
  452.  *  
  453.  * PARAMETERS
  454.  *  void
  455.  * RETURNS
  456.  *  void
  457.  *****************************************************************************/
  458. static void mmi_entry_pen_test_screen(void)
  459. {
  460.     /*----------------------------------------------------------------*/
  461.     /* Local Variables                                                */
  462.     /*----------------------------------------------------------------*/
  464.     /*----------------------------------------------------------------*/
  465.     /* Code Body                                                      */
  466.     /*----------------------------------------------------------------*/
  467.     EntryNewScreen(0, NULL, mmi_exit_pen_test_screen, NULL);
  469.     ShowCategory66Screen(STR_GLOBAL_UNFINISHED, 0, 0, 0, STR_GLOBAL_BACK, 0, (U8*) L"", 0, NULL);
  470.     RedrawCategoryFunction = mmi_redraw_pen_test_screen;    /* For PC simulator architecture */
  472.     mmi_pen_test_clear_screen();
  474.     mmi_pen_register_down_handler(mmi_pen_test_down);
  475.     mmi_pen_register_move_handler(mmi_pen_test_move);
  476.     mmi_pen_register_up_handler(mmi_pen_test_up);
  477.     mmi_pen_register_long_tap_handler(mmi_pen_test_long_tap);
  478.     mmi_pen_register_repeat_handler(mmi_pen_test_repeat);
  480.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  481. }
  484. /*****************************************************************************
  485.  * FUNCTION
  486.  *  mmi_pen_unit_test
  487.  * DESCRIPTION
  488.  *  
  489.  * PARAMETERS
  490.  *  void
  491.  * RETURNS
  492.  *  void
  493.  *****************************************************************************/
  494. void mmi_pen_unit_test(void)
  495. {
  496.     /*----------------------------------------------------------------*/
  497.     /* Local Variables                                                */
  498.     /*----------------------------------------------------------------*/
  500.     /*----------------------------------------------------------------*/
  501.     /* Code Body                                                      */
  502.     /*----------------------------------------------------------------*/
  503.     mmi_entry_pen_test_screen();
  504. }
  506. #endif /* MMI_PEN_UNIT_TEST */ 
  508. #elif ( !defined(__MMI_TOUCH_SCREEN__) || !defined(__MMI_HANDWRITING_PAD__) ) && !defined(__MTK_TARGET__) && !defined(MMI_ON_WIN32)
  510. #include "PixtelDataTypes.h"
  513. /*****************************************************************************
  514.  * FUNCTION
  515.  *  mmi_pen_MODIS_enqueue_down
  516.  * DESCRIPTION
  517.  *  
  518.  * PARAMETERS
  519.  *  x       [IN]        
  520.  *  y       [IN]        
  521.  * RETURNS
  522.  *  void
  523.  *****************************************************************************/
  524. void mmi_pen_MODIS_enqueue_down(S16 x, S16 y)
  525. {
  526.     /*----------------------------------------------------------------*/
  527.     /* Local Variables                                                */
  528.     /*----------------------------------------------------------------*/
  530.     /*----------------------------------------------------------------*/
  531.     /* Code Body                                                      */
  532.     /*----------------------------------------------------------------*/
  533. }
  536. /*****************************************************************************
  537.  * FUNCTION
  538.  *  mmi_pen_MODIS_enqueue_move
  539.  * DESCRIPTION
  540.  *  
  541.  * PARAMETERS
  542.  *  x       [IN]        
  543.  *  y       [IN]        
  544.  * RETURNS
  545.  *  void
  546.  *****************************************************************************/
  547. void mmi_pen_MODIS_enqueue_move(S16 x, S16 y)
  548. {
  549.     /*----------------------------------------------------------------*/
  550.     /* Local Variables                                                */
  551.     /*----------------------------------------------------------------*/
  553.     /*----------------------------------------------------------------*/
  554.     /* Code Body                                                      */
  555.     /*----------------------------------------------------------------*/
  556. }
  559. /*****************************************************************************
  560.  * FUNCTION
  561.  *  mmi_pen_MODIS_enqueue_up
  562.  * DESCRIPTION
  563.  *  
  564.  * PARAMETERS
  565.  *  x       [IN]        
  566.  *  y       [IN]        
  567.  * RETURNS
  568.  *  void
  569.  *****************************************************************************/
  570. void mmi_pen_MODIS_enqueue_up(S16 x, S16 y)
  571. {
  572.     /*----------------------------------------------------------------*/
  573.     /* Local Variables                                                */
  574.     /*----------------------------------------------------------------*/
  576.     /*----------------------------------------------------------------*/
  577.     /* Code Body                                                      */
  578.     /*----------------------------------------------------------------*/
  579. }
  581. #elif ( defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) ) && defined(__MTK_TARGET__)
  583. /*****************************************************************************
  584.  *
  585.  * Target integration 
  586.  *
  587.  ****************************************************************************/
  589. #include "stdC.h"
  590. #include "PixtelDataTypes.h"
  591. #include "TimerEvents.h"
  592. #include "KeyBrd.h"
  593. #include "TaskInit.h"
  594. #include "MMITaskProt.h"
  595. #include "FrameworkStruct.h"
  596. #include "EventsGprot.h"
  597. #include "EventsDcl.h"
  598. #include "EventsDef.h"
  599. #include "gui_data_types.h"
  600. #include "gui.h"
  602. #include "GpioInc.h"
  603. #include "IdleAppProt.h"
  605. #include "TouchScreenGprot.h"
  606. #include "DebugInitDef.h"
  608. #include "Touch_Panel.h"
  610. #include "Drv_Comm.h"   /*  mmi_pen_touch_panel_sendilm() */
  612. #include "gdi_include.h"
  613. #include "ScreenRotationGprot.h"
  615. #include "touch_panel_custom.h" /* get handwriting pad setting */
  617. // TODO: make ext_region as NULL
  619. /***************************************************************************** 
  620. * Define
  621. *****************************************************************************/
  622. /* Time between Pen Long-tap and Pen Repeat */
  624. #define MMI_PEN_POLLING_PERIOD            (4 * 10)      /* ms */
  626. /* Size of look-ahead buffer */
  627. #define MMI_PEN_LOOKAHEAD_BUFFER_SIZE     (25)
  629. /* 
  630.  * Delayed polling period time. (We allow only 5 Pen Down event per sec) 
  631.  * We restrict the frequency of incoming Pen Down events in MMI framework instead of 
  632.  * driver debounce time because driver debounce time needs to be smaller than sampling period. 
  633.  */
  634. #define MMI_PEN_DEBOUNCE_POLLING_DELAY    (1000 / 5 - MMI_PEN_POLLING_PERIOD)
  636. /***************************************************************************** 
  637. * Typedef 
  638. *****************************************************************************/
  639. typedef struct
  640. {
  641.     /* mmi_pen_block() & mmi_pen_unblock() */
  642.     U32 is_blocked:1;
  644.     /* mmi_pen_enable() & mmi_pen_disable() */
  645.     U32 is_enabled:1;
  647.     /* After PEN_DOWN, mmi_pen_reset() set 'is_pen_down' to 0 */
  648.     U32 is_pen_down:1;
  650.     /* Debug only. After STROKE_DOWN, mmi_pen_reset() set 'is_stroke_down' to 0 */
  651.     U32 is_stroke_down:1;
  653.     /* Pen down in hand-writing area, but we still do not know if it is a stroke */
  654.     U32 is_pending_stroke_event:1;
  656.     /* 
  657.      * Set by mmi_pen_change_handwriting_area() and mmi_pen_stop_capture_strokes().
  658.      * Close stroke and reset touch screen when pen is up. 
  659.      */
  660.     U32 reset_stroke_on_pen_up:1;
  662.     /*
  663.      * Reset sampling rate when pen is reset. 
  664.      * This is used when we change the sampling rate temporarily.
  665.      */
  666.     U32 restore_sampling_rate_on_reset:1;
  668.     /* Pen down position */
  669.     mmi_pen_point_struct pen_down_pos;
  671.     /* The current pen position */
  672.     mmi_pen_point_struct pen_current_pos;
  674.     /* Block index of handwriting area */
  675.     S32 stroke_down_block_index;
  677.     /* For stroke */
  678.     S32 num_points_queued;
  680.     /* Number of events in look-ahead buffer */
  681.     S32 num_lookahead_events;
  682. } mmi_pen_context_struct;
  684. /***************************************************************************** 
  685. * Local Variable
  686. *****************************************************************************/
  688. /* Global pen context that is reset in mmi_pen_reset() and mmi_pen_disable() */
  689. static mmi_pen_context_struct g_pen_cntx;
  691. /* Only normal poweron initialize touch screen. Otherwise, touch screen is not initialized */
  692. static kal_bool g_pen_initialized;
  694. /*
  695.  * Whether the timer for mmi_pen_poll_hdlr() is started
  696.  * 
  697.  * 'g_pen_polling_timer_started' is not put inside g_pen_cntx because 
  698.  * 1. We want to restrict the frequency of incoming pen events
  699.  * 2. When polling timer is started, we do not stop it.
  700.  * 3. 'g_pen_polling_timer_started' should not be cleared in mmi_pen_reset() or mmi_pen_disable()
  701.  */
  702. MMI_BOOL g_pen_polling_timer_started;
  704. /* Whether MSG_ID_TP_EVENT_IND is already en-queued in MMI external queue */
  705. /* It is not put inside g_pen_cntx for similar reason like g_pen_polling_timer_started */
  706. U32 g_pen_is_driver_indication_in_queue;
  708. static mmi_pen_hdlr g_pen_event_table[MMI_PEN_EVENT_TYPE_MAX];
  709. static mmi_pen_hdlr g_pen_stroke_table[MMI_PEN_STROKE_TYPE_MAX];
  710. static void (*g_pen_stroke_pre_move) (void);
  711. static void (*g_pen_stroke_post_move) (void);
  713. /* 
  714.  * Stroke buffer 
  715.  */
  716. static S32 g_pen_stroke_max_points;
  717. static mmi_pen_point_struct *g_pen_stroke_points;
  719. /* Used for the new multi-block feature.
  720.    Note: the data can be put into driver, but we do not want to change driver interface 
  721.    because customers may port their driver */
  722. static mmi_pen_handwriting_area_struct g_pen_stroke_areas[HAND_WRITING_AREA_NUM];
  723. static S32 g_pen_num_stroke_area;
  725. /* Minimum square distance (diff_x^2 + diff_y^2)  */
  726. static S16 g_pen_stroke_min_offset_square;
  728. /* 
  729.  * Lookahead buffer  
  730.  */
  731. static TouchPanelEventStruct g_pen_lookahead_buffer[MMI_PEN_LOOKAHEAD_BUFFER_SIZE];
  733. /***************************************************************************** 
  734. * Local Function
  735. *****************************************************************************/
  738. /*****************************************************************************
  739.  * FUNCTION
  740.  *  mmi_pen_get_distance_square
  741.  * DESCRIPTION
  742.  *  
  743.  * PARAMETERS
  744.  *  pos1        [IN]        
  745.  *  pos2        [IN]        
  746.  * RETURNS
  747.  *  
  748.  *****************************************************************************/
  749. static S16 mmi_pen_get_distance_square(mmi_pen_point_struct pos1, mmi_pen_point_struct pos2)
  750. {
  751.     /*----------------------------------------------------------------*/
  752.     /* Local Variables                                                */
  753.     /*----------------------------------------------------------------*/
  754.     S16 diff_x = pos1.x - pos2.x;
  755.     S16 diff_y = pos1.y - pos2.y;
  757.     /*----------------------------------------------------------------*/
  758.     /* Code Body                                                      */
  759.     /*----------------------------------------------------------------*/
  760.     if (diff_x < 0)
  761.     {
  762.         diff_x = -diff_x;
  763.     }
  764.     if (diff_y < 0)
  765.     {
  766.         diff_y = -diff_y;
  767.     }
  768.     return (diff_x * diff_x) + (diff_y * diff_y);
  769. }
  772. /*****************************************************************************
  773.  * FUNCTION
  774.  *  mmi_pen_push_stroke_point
  775.  * DESCRIPTION
  776.  *  
  777.  * PARAMETERS
  778.  *  x       [IN]        
  779.  *  y       [IN]        
  780.  * RETURNS
  781.  *  void
  782.  *****************************************************************************/
  783. static void mmi_pen_push_stroke_point(S16 x, S16 y)
  784. {
  785.     /*----------------------------------------------------------------*/
  786.     /* Local Variables                                                */
  787.     /*----------------------------------------------------------------*/
  789.     /*----------------------------------------------------------------*/
  790.     /* Code Body                                                      */
  791.     /*----------------------------------------------------------------*/
  792.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points - 2)
  793.     {
  794.         /* Leave the last two slots for (-1, 0) and (-1, -1) */
  795.         return;
  796.     }
  797.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = x;
  798.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = y;
  799.     g_pen_cntx.num_points_queued++;
  800. }
  803. /*****************************************************************************
  804.  * FUNCTION
  805.  *  mmi_pen_push_stroke_end
  806.  * DESCRIPTION
  807.  *  
  808.  * PARAMETERS
  809.  *  void
  810.  * RETURNS
  811.  *  void
  812.  *****************************************************************************/
  813. static void mmi_pen_push_stroke_end(void)
  814. {
  815.     /*----------------------------------------------------------------*/
  816.     /* Local Variables                                                */
  817.     /*----------------------------------------------------------------*/
  819.     /*----------------------------------------------------------------*/
  820.     /* Code Body                                                      */
  821.     /*----------------------------------------------------------------*/
  822.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points - 1)
  823.     {
  824.         return;
  825.     }
  826. #if defined(__MMI_HANWANG__)
  827.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  828.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  829. #elif defined(__MMI_PENPOWER__)
  830.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  831.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  832. #else 
  833.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  834.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  835. #endif 
  836.     g_pen_cntx.num_points_queued++;
  837. }
  840. /*****************************************************************************
  841.  * FUNCTION
  842.  *  mmi_pen_push_char_end
  843.  * DESCRIPTION
  844.  *  
  845.  * PARAMETERS
  846.  *  void
  847.  * RETURNS
  848.  *  void
  849.  *****************************************************************************/
  850. static void mmi_pen_push_char_end(void)
  851. {
  852.     /*----------------------------------------------------------------*/
  853.     /* Local Variables                                                */
  854.     /*----------------------------------------------------------------*/
  856.     /*----------------------------------------------------------------*/
  857.     /* Code Body                                                      */
  858.     /*----------------------------------------------------------------*/
  859.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points)
  860.     {
  861.         MMI_DBG_ASSERT(0);  /* queue full */
  862.         return;
  863.     }
  864. #if defined(__MMI_HANWANG__)
  865.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  866.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  867. #elif defined(__MMI_PENPOWER__)
  868.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  869.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  870. #else 
  871.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  872.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  873. #endif 
  874.     g_pen_cntx.num_points_queued++;
  875. }
  878. /*****************************************************************************
  879.  * FUNCTION
  880.  *  mmi_pen_lookup_handwriting_block
  881.  * DESCRIPTION
  882.  *  Search which handwriting block contains a point (multi-block mode)
  883.  * PARAMETERS
  884.  *  x       [IN]
  885.  *  y       [IN]
  886.  * RETURNS
  887.  *  The index of handwriting block. 0 for block-0 or extended area, -1 if not found.
  888.  *****************************************************************************/
  889. static S32 mmi_pen_lookup_handwriting_block(S32 x, S32 y)
  890. {
  891.     /*----------------------------------------------------------------*/
  892.     /* Local Variables                                                */
  893.     /*----------------------------------------------------------------*/
  894.     int i;
  896.     /*----------------------------------------------------------------*/
  897.     /* Code Body                                                      */
  898.     /*----------------------------------------------------------------*/
  899.     for (i = 0; i < g_pen_num_stroke_area; i++)
  900.     {
  901.         if (x >= g_pen_stroke_areas[i].x1 && x <= g_pen_stroke_areas[i].x2 &&
  902.             y >= g_pen_stroke_areas[i].y1 && y <= g_pen_stroke_areas[i].y2)
  903.         {
  904.             return i;
  905.         }
  906.     }
  907.     return -1;
  908. }
  911. /*****************************************************************************
  912.  * FUNCTION
  913.  *  mmi_pen_fix_multi_block_pen_position
  914.  * DESCRIPTION
  915.  *  Restrict stroke position to the current handwriting block
  916.  * PARAMETERS
  917.  *  pos       [IN/OUT]
  918.  * RETURNS
  919.  *  void
  920.  *****************************************************************************/
  921. void mmi_pen_fix_multi_block_pen_position(mmi_pen_point_struct *pos)
  922. {
  923.     /*----------------------------------------------------------------*/
  924.     /* Local Variables                                                */
  925.     /*----------------------------------------------------------------*/
  926.     mmi_pen_handwriting_area_struct *block;
  928.     /*----------------------------------------------------------------*/
  929.     /* Code Body                                                      */
  930.     /*----------------------------------------------------------------*/
  931.     MMI_ASSERT(g_pen_cntx.stroke_down_block_index >= 0 &&
  932.                g_pen_cntx.stroke_down_block_index < g_pen_num_stroke_area);
  934.     block = &g_pen_stroke_areas[g_pen_cntx.stroke_down_block_index];
  935.     
  936.     if (pos->x < block->x1)
  937.     {
  938.         pos->x = block->x1;
  939.     }
  940.     else if (pos->x > block->x2)
  941.     {
  942.         pos->x = block->x2;
  943.     }
  944.     
  945.     if (pos->y < block->y1)
  946.     {
  947.         pos->y = block->y1;
  948.     }
  949.     else if (pos->y > block->y2)
  950.     {
  951.         pos->y = block->y2;
  952.     }    
  953. }
  956. /*
  957.  * Look-ahead buffer of pen events (used in mmi_pen_poll_hdlr())
  958.  *
  959.  * If our MMI is blocked and fails to process incoming pen events fast enough, 
  960.  * it may have unexpected results (e.g. extq full) unless we drop certain pending events.
  961.  */
  963. /* 
  964.  * Fill the data in lookahead buffer. 
  965.  *
  966.  * The sampling rate of pen events (MMI_PEN_SAMPLING_PERIOD_1) is very high,
  967.  * If we find paired Pen Down/Up, it means that MMI is blocked.
  968.  *
  969.  * 1. If there are consecutive Pen Move events, keep the last one.
  970.  * 2. If there are paired "Pen Down ~ Pen Up", drop it.
  971.  *
  972.  * We do not drop stroke events because it is used by handwriting engine.
  973.  */
  976. /*****************************************************************************
  977.  * FUNCTION
  978.  *  mmi_pen_lookahead_buffer_fill_data
  979.  * DESCRIPTION
  980.  *  
  981.  * PARAMETERS
  982.  *  void
  983.  * RETURNS
  984.  *  void
  985.  *****************************************************************************/
  986. static void mmi_pen_lookahead_buffer_fill_data(void)
  987. {
  988.     /*----------------------------------------------------------------*/
  989.     /* Local Variables                                                */
  990.     /*----------------------------------------------------------------*/
  991.     S32 rindex, windex;
  992.     S32 first_down_index, last_up_index;
  993.     TouchPanelEventStruct touch_data;
  995. #ifdef __MMI_SCREEN_ROTATE__
  996.     /* U8 gdi_rotate_value; */
  997.     MMI_BOOL screen_rotated = MMI_FALSE;
  999.     /*----------------------------------------------------------------*/
  1000.     /* Code Body                                                      */
  1001.     /*----------------------------------------------------------------*/
  1002.     if (mmi_frm_get_screen_rotate() != MMI_FRM_SCREEN_ROTATE_0)
  1003.     {
  1004.         /* Even if GDI base layer is rotated, we do not translate pen coordinates 
  1005.            unless mmi_frm_screen_rotate() is invoked. */
  1006.         screen_rotated = MMI_TRUE;
  1007.     }
  1008.     /* gdi_rotate_value = gdi_layer_get_base_layer_rotation(); */
  1009. #endif /* __MMI_SCREEN_ROTATE__ */ 
  1011.     for (windex = g_pen_cntx.num_lookahead_events; windex < MMI_PEN_LOOKAHEAD_BUFFER_SIZE; windex++)
  1012.     {
  1013.         if (!touch_panel_get_event(&touch_data))
  1014.         {
  1015.             break;
  1016.         }
  1018.     #ifdef __MMI_SCREEN_ROTATE__
  1019.         if (screen_rotated)
  1020.         {
  1021.             S32 tmp_x = touch_data.x_adc, tmp_y = touch_data.y_adc;
  1023.             /* W06.04 Replace functions for GDI LCD Rotate */
  1024.             gdi_rotate_map_absolute_hw_to_lcd(&tmp_x, &tmp_y);
  1025.             /* gdi_layer_map_rotated_coordinates(gdi_rotate_value, &tmp_x, &tmp_y); */
  1026.             touch_data.x_adc = (kal_int16) tmp_x;
  1027.             touch_data.y_adc = (kal_int16) tmp_y;
  1028.         }
  1029.     #endif /* __MMI_SCREEN_ROTATE__ */ 
  1031.         g_pen_lookahead_buffer[windex] = touch_data;
  1032.     }
  1033.     g_pen_cntx.num_lookahead_events = windex;
  1035.     if (g_pen_cntx.num_lookahead_events == 0)
  1036.     {
  1037.         return; /* Exit point */
  1038.     }
  1040.     /* Remove paired Pen Down/Up */
  1041.     first_down_index = -1;
  1042.     last_up_index = -1;
  1043.     for (rindex = 1 /* not including the first event */ ; rindex < g_pen_cntx.num_lookahead_events; rindex++)
  1044.     {
  1045.         switch (g_pen_lookahead_buffer[rindex].event)
  1046.         {
  1047.             case PEN_DOWN:
  1048.                 if (first_down_index < 0)
  1049.                 {
  1050.                     first_down_index = rindex;
  1051.                 }
  1052.                 break;
  1054.             case PEN_UP:
  1055.                 last_up_index = rindex;
  1056.                 break;
  1058.             case PEN_MOVE:
  1059.             case PEN_LONGTAP:
  1060.             case PEN_REPEAT:
  1061.                 break;
  1063.             default:
  1064.                 /* Some events can not be dropped */
  1065.                 first_down_index = -1;
  1066.         }
  1067.     }
  1069.     if (first_down_index > 0 && last_up_index > first_down_index)
  1070.     {
  1071.         if (last_up_index < g_pen_cntx.num_lookahead_events - 1)
  1072.         {
  1073.             Trace2(MMI_TRACE_G1_FRM, "[Pen] Drop lookahead buffer (%d - %d) n", first_down_index, last_up_index);
  1074.             memmove(
  1075.                 &g_pen_lookahead_buffer[first_down_index],
  1076.                 &g_pen_lookahead_buffer[last_up_index + 1],
  1077.                 sizeof(TouchPanelEventStruct) * (g_pen_cntx.num_lookahead_events - 1 - last_up_index));
  1078.         }
  1079.         g_pen_cntx.num_lookahead_events -= (last_up_index - first_down_index + 1);
  1080.     }
  1082.     /* 
  1083.      * If there are multiple Pen Move events queued, it means that pen handler can not 
  1084.      * process the events fast enough. We should drop Pen Move events before the last one in queue.
  1085.      */
  1086.     for (windex = 0, rindex = 0; rindex < g_pen_cntx.num_lookahead_events; rindex++)
  1087.     {
  1088.         if (g_pen_lookahead_buffer[rindex].event == PEN_MOVE &&
  1089.             rindex < g_pen_cntx.num_lookahead_events - 1 && g_pen_lookahead_buffer[rindex + 1].event == PEN_MOVE)
  1090.         {
  1091.             /* Drop this Pen Move event. */
  1092.             continue;
  1093.         }
  1095.         if (windex != rindex)
  1096.         {
  1097.             g_pen_lookahead_buffer[windex] = g_pen_lookahead_buffer[rindex];
  1098.         }
  1099.         windex++;
  1100.     }
  1101.     g_pen_cntx.num_lookahead_events = windex;
  1102. }
  1104. /* Buffered version of touch_panel_peek_event() */
  1107. /*****************************************************************************
  1108.  * FUNCTION
  1109.  *  mmi_pen_lookahead_buffer_peek_event
  1110.  * DESCRIPTION
  1111.  *  
  1112.  * PARAMETERS
  1113.  *  touch_data      [OUT]     
  1114.  * RETURNS
  1115.  *  
  1116.  *****************************************************************************/
  1117. static kal_bool mmi_pen_lookahead_buffer_peek_event(TouchPanelEventStruct *touch_data)
  1118. {
  1119.     /*----------------------------------------------------------------*/
  1120.     /* Local Variables                                                */
  1121.     /*----------------------------------------------------------------*/
  1123.     /*----------------------------------------------------------------*/
  1124.     /* Code Body                                                      */
  1125.     /*----------------------------------------------------------------*/
  1126.     if (!g_pen_cntx.num_lookahead_events)
  1127.     {
  1128.         mmi_pen_lookahead_buffer_fill_data();
  1129.     }
  1130.     if (g_pen_cntx.num_lookahead_events)
  1131.     {
  1132.         *touch_data = g_pen_lookahead_buffer[0];
  1133.         return KAL_TRUE;
  1134.     }
  1135.     else
  1136.     {
  1137.         return KAL_FALSE;
  1138.     }
  1139. }
  1141. /* Buffered version of touch_panel_get_event() */
  1144. /*****************************************************************************
  1145.  * FUNCTION
  1146.  *  mmi_pen_lookahead_buffer_get_event
  1147.  * DESCRIPTION
  1148.  *  
  1149.  * PARAMETERS
  1150.  *  touch_data      [OUT]     
  1151.  * RETURNS
  1152.  *  
  1153.  *****************************************************************************/
  1154. static kal_bool mmi_pen_lookahead_buffer_get_event(TouchPanelEventStruct *touch_data)
  1155. {
  1156.     /*----------------------------------------------------------------*/
  1157.     /* Local Variables                                                */
  1158.     /*----------------------------------------------------------------*/
  1159.     S32 i;
  1161.     /*----------------------------------------------------------------*/
  1162.     /* Code Body                                                      */
  1163.     /*----------------------------------------------------------------*/
  1164.     mmi_pen_lookahead_buffer_fill_data();
  1166.     if (g_pen_cntx.num_lookahead_events > 0)
  1167.     {
  1168.         *touch_data = g_pen_lookahead_buffer[0];
  1169.         g_pen_cntx.num_lookahead_events--;
  1170.         for (i = 0; i < g_pen_cntx.num_lookahead_events; i++)
  1171.         {
  1172.             g_pen_lookahead_buffer[i] = g_pen_lookahead_buffer[i + 1];
  1173.         }
  1175.         return KAL_TRUE;
  1176.     }
  1177.     else
  1178.     {
  1179.         return KAL_FALSE;
  1180.     }
  1181. }
  1183. /*
  1184.  * Core polling loop for pen events
  1185.  */
  1188. /*****************************************************************************
  1189.  * FUNCTION
  1190.  *  mmi_pen_poll_hdlr
  1191.  * DESCRIPTION
  1192.  *  
  1193.  * PARAMETERS
  1194.  *  void
  1195.  * RETURNS
  1196.  *  void
  1197.  *****************************************************************************/
  1198. static void mmi_pen_poll_hdlr(void)
  1199. {
  1200.     /*----------------------------------------------------------------*/
  1201.     /* Local Variables                                                */
  1202.     /*----------------------------------------------------------------*/
  1203.     TouchPanelEventStruct data;
  1204.     MMI_BOOL is_stroke_move = MMI_FALSE;
  1205.     MMI_BOOL has_incoming_event = MMI_FALSE;
  1206.     MMI_BOOL delay_polling_timer = MMI_FALSE;
  1208.     /*----------------------------------------------------------------*/
  1209.     /* Code Body                                                      */
  1210.     /*----------------------------------------------------------------*/
  1211.     g_pen_polling_timer_started = MMI_FALSE;
  1213.     Trace2(
  1214.         MMI_TRACE_G1_FRM,
  1215.         "[Pen] mmi_pen_poll_hdlr() - %d %d n",
  1216.         (int)g_pen_cntx.is_enabled,
  1217.         (int)g_pen_cntx.num_lookahead_events);
  1219.     if (!g_pen_cntx.is_enabled)
  1220.     {
  1221.         /* Note: We do not stop polling timer even in mmi_pen_disable() */
  1222.         return;
  1223.     }
  1225.     /* Although pen events (move, repeat) should keep backlight on, 
  1226.        Playing i-melody may turn on/off backlight actively. 
  1227.        We do not call mmi_pen_reset() when pen is down because some apps 
  1228.        may not handle Pen Abort event. */
  1229.     if (!IsBacklightOn() && !g_pen_cntx.is_pen_down)
  1230.     {
  1231.         Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_poll_hdlr() - no backlightn");
  1233.         TurnOnBacklight(MMI_TRUE);
  1234.         mmi_pen_reset();    /* flush queue */
  1235.         return;
  1236.     }
  1238.     while (!delay_polling_timer && mmi_pen_lookahead_buffer_get_event(&data))
  1239.     {
  1240.         mmi_pen_point_struct pos;
  1242.         if (!g_pen_cntx.is_enabled)
  1243.         {
  1244.             /* Previous pen handlers might call mmi_pen_disable(), but
  1245.                we should already flush driver pen queue on mmi_pen_disable() */
  1246.             MMI_DBG_ASSERT(0);
  1247.             break;
  1248.         }
  1250.         pos.x = (S16) data.x_adc;
  1251.         pos.y = (S16) data.y_adc;
  1253.     #if 0
  1254. /* under construction !*/
  1255. /* under construction !*/
  1256. /* under construction !*/
  1257. /* under construction !*/
  1258. /* under construction !*/
  1259. /* under construction !*/
  1260. /* under construction !*/
  1261. /* under construction !*/
  1262. /* under construction !*/
  1263. /* under construction !*/
  1264. /* under construction !*/
  1265. /* under construction !*/
  1266. /* under construction !*/
  1267. /* under construction !*/
  1268. /* under construction !*/
  1269. /* under construction !*/
  1270. /* under construction !*/
  1271. /* under construction !*/
  1272. /* under construction !*/
  1273. /* under construction !*/
  1274. /* under construction !*/
  1275. /* under construction !*/
  1276. /* under construction !*/
  1277. /* under construction !*/
  1278.     #endif /* 0 */ 
  1280.         has_incoming_event = MMI_TRUE;
  1282.         if (is_stroke_move && (data.event != STROKE_MOVE))
  1283.         {
  1284.             is_stroke_move = MMI_FALSE;
  1285.             if (g_pen_stroke_post_move)
  1286.             {
  1287.                 g_pen_stroke_post_move();
  1288.             }
  1289.         }
  1291.         g_pen_cntx.pen_current_pos = pos;
  1293.         switch (data.event)
  1294.         {
  1295.                 /* Call pen handler after setting context variables because pen handler might invoke mmi_pen_reset() */
  1296.             case PEN_DOWN:
  1297.                 MMI_DBG_ASSERT(!g_pen_cntx.is_pen_down);
  1298.                 g_pen_cntx.is_pen_down = 1;
  1299.                 g_pen_cntx.pen_down_pos = pos;
  1300.                 if (g_pen_event_table[MMI_PEN_EVENT_DOWN])
  1301.                 {
  1302.                     (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (pos);
  1303.                 }
  1304.                 break;
  1305.                 
  1306.             case PEN_UP:
  1307.                 MMI_DBG_ASSERT(g_pen_cntx.is_pen_down);
  1308.                 g_pen_cntx.is_pen_down = 0;
  1309.                 if (g_pen_event_table[MMI_PEN_EVENT_UP])
  1310.                 {
  1311.                     (g_pen_event_table[MMI_PEN_EVENT_UP]) (pos);
  1312.                 }
  1314.                 if (g_pen_cntx.reset_stroke_on_pen_up)
  1315.                 {
  1316.                     if (g_pen_stroke_max_points > 0)
  1317.                     {
  1318.                         mmi_pen_end_strokes_of_character();
  1319.                         mmi_pen_reset();
  1320.                         mmi_pen_begin_strokes_of_character();
  1321.                     }
  1322.                     else
  1323.                     {
  1324.                         mmi_pen_reset();
  1325.                     }
  1326.                 }
  1328.                 /* Delay processing futher events */
  1329.                 delay_polling_timer = MMI_TRUE;
  1331.                 break;
  1332.                 
  1333.             case PEN_MOVE:
  1334.                 MMI_DBG_ASSERT(g_pen_cntx.is_pen_down);
  1335.                 if (g_pen_event_table[MMI_PEN_EVENT_MOVE])
  1336.                 {
  1337.                     (g_pen_event_table[MMI_PEN_EVENT_MOVE]) (pos);
  1338.                 }
  1339.                 break;
  1340.                 
  1341.             case PEN_LONGTAP:
  1342.                 MMI_DBG_ASSERT(g_pen_cntx.is_pen_down);
  1343.                 if (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP])
  1344.                 {
  1345.                     (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP]) (pos);
  1346.                 }
  1347.                 break;
  1348.                 
  1349.             case PEN_REPEAT:
  1350.                 MMI_DBG_ASSERT(g_pen_cntx.is_pen_down);
  1351.                 if (g_pen_event_table[MMI_PEN_EVENT_REPEAT])
  1352.                 {
  1353.                     (g_pen_event_table[MMI_PEN_EVENT_REPEAT]) (pos);
  1354.                 }
  1355.                 break;
  1356.                 
  1357.             case PEN_ABORT:
  1358.                 /* Driver queue full */
  1359.                 mmi_pen_reset();
  1360.                 break;
  1361.                 
  1362.             case TP_UNKNOWN_EVENT:
  1363.                 MMI_ASSERT(0);
  1364.                 break;
  1365.                 
  1366.             case STROKE_MOVE:
  1367.                 MMI_DBG_ASSERT(g_pen_cntx.is_stroke_down && g_pen_cntx.is_pen_down);
  1368.                 /* mmi_pen_reset() should be used after mmi_pen_stop_capture_strokes() such that enqueued stroke events are flushed. */
  1369.                 MMI_DBG_ASSERT(g_pen_stroke_max_points > 0);
  1370.                 if (g_pen_cntx.is_pending_stroke_event)
  1371.                 {
  1372.                     if (mmi_pen_get_distance_square(g_pen_cntx.pen_down_pos, pos) > g_pen_stroke_min_offset_square)
  1373.                     {
  1374.                         g_pen_cntx.is_pending_stroke_event = 0;
  1375.                         g_pen_stroke_min_offset_square = 0; /* The next stroke does not have minimum offset */
  1376.                         /* Pen Down -> Pen Move -> Pen Abort -> Stroke Down -> Stroke Move -> Stroke Up 
  1377.                            There is no stroke points queued before the first stroke is created
  1378.                            If we set 'reset_stroke_on_pen_up' in previous Pen Down handler and invoke mmi_pen_reset() in Stroke Up, 
  1379.                            all stroke points in between are discarded */
  1380.                         g_pen_cntx.reset_stroke_on_pen_up = 0;
  1382.                         /* Abort previous Pen Down event */
  1383.                         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  1384.                         {
  1385.                             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_down_pos);
  1386.                         }
  1388.                         /* Handle Stroke Down */
  1389.                         mmi_pen_push_stroke_point(g_pen_cntx.pen_down_pos.x, g_pen_cntx.pen_down_pos.y);
  1390.                         if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN])
  1391.                         {
  1392.                             (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (g_pen_cntx.pen_down_pos);
  1393.                         }
  1395.                         /* Pre-Stroke-Move */
  1396.                         MMI_DBG_ASSERT(!is_stroke_move);
  1397.                         is_stroke_move = MMI_TRUE;
  1398.                         if (g_pen_stroke_pre_move)
  1399.                         {
  1400.                             g_pen_stroke_pre_move();
  1401.                         }
  1403.                         /* Stroke Move */
  1404.                         mmi_pen_push_stroke_point(pos.x, pos.y);
  1405.                         if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE])
  1406.                         {
  1407.                             (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
  1408.                         }
  1409.                     }
  1410.                 }
  1411.                 else
  1412.                 {
  1413.                     if (g_pen_num_stroke_area > 1)
  1414.                     {
  1415.                         mmi_pen_fix_multi_block_pen_position(&pos);
  1416.                     }
  1417.                     
  1418.                     if (!is_stroke_move)
  1419.                     {
  1420.                         is_stroke_move = MMI_TRUE;
  1421.                         if (g_pen_stroke_pre_move)
  1422.                         {
  1423.                             g_pen_stroke_pre_move();
  1424.                         }
  1425.                     }
  1427.                     mmi_pen_push_stroke_point(pos.x, pos.y);
  1428.                     if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE])
  1429.                     {
  1430.                         (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
  1431.                     }
  1432.                 }
  1433.                 break;
  1434.                 
  1435.             case STROKE_DOWN:
  1436.                 MMI_DBG_ASSERT(!g_pen_cntx.is_stroke_down && !g_pen_cntx.is_pen_down);
  1437.                 /* mmi_pen_reset() should be used after mmi_pen_stop_capture_strokes() such that enqueued stroke events are flushed. */
  1438.                 MMI_DBG_ASSERT(g_pen_stroke_max_points > 0);
  1439.                 g_pen_cntx.is_stroke_down = 1;
  1440.                 g_pen_cntx.is_pen_down = 1;
  1441.                 g_pen_cntx.pen_down_pos = pos;
  1443.                 g_pen_cntx.stroke_down_block_index = mmi_pen_lookup_handwriting_block(pos.x, pos.y);
  1444.                 if (g_pen_num_stroke_area > 1 && g_pen_cntx.stroke_down_block_index < 0)
  1445.                 {
  1446.                     /* MMI framework and driver have intergration problem.
  1447.                        Maybe the current driver does not support multi-block, 
  1448.                        or driver does not disable extended handwriting area properly in
  1449.                        multi-block mode. */
  1450.                     MMI_ASSERT(0);
  1451.                 }
  1453.                 if (g_pen_stroke_min_offset_square > 0)
  1454.                 {
  1455.                     g_pen_cntx.is_pending_stroke_event = 1;
  1457.                     /* Fire pen down event. For example, it will display key down on virtual keyboard. */
  1458.                     if (g_pen_event_table[MMI_PEN_EVENT_DOWN])
  1459.                     {
  1460.                         (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (g_pen_cntx.pen_down_pos);
  1461.                     }
  1462.                 }
  1463.                 else
  1464.                 {
  1465.                     g_pen_cntx.is_pending_stroke_event = 0;
  1467.                     if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN])
  1468.                     {
  1469.                         (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (pos);
  1470.                     }
  1471.                     
  1472.                     /* Put stroke point after stroke down handler because multi-block handwriting may invoke
  1473.                      * mmi_pen_begin_strokes_of_character() and mmi_pen_end_strokes_of_character() in 
  1474.                      * Stroke Down handler.
  1475.                      */
  1476.                     if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down && g_pen_stroke_max_points > 0)
  1477.                     {
  1478.                         mmi_pen_push_stroke_point(pos.x, pos.y);
  1479.                     }                    
  1480.                 }
  1481.                 break;
  1482.                 
  1483.             case STROKE_UP:
  1484.                 MMI_DBG_ASSERT(g_pen_cntx.is_stroke_down && g_pen_cntx.is_pen_down);
  1485.                 /* mmi_pen_reset() should be used after mmi_pen_stop_capture_strokes() such that enqueued stroke events are flushed. */
  1486.                 MMI_DBG_ASSERT(g_pen_stroke_max_points > 0);
  1487.                 g_pen_cntx.is_stroke_down = 0;
  1488.                 g_pen_cntx.is_pen_down = 0;
  1490.                 if (g_pen_cntx.is_pending_stroke_event)
  1491.                 {
  1492.                     g_pen_cntx.is_pending_stroke_event = 0;
  1494.                     /*
  1495.                      * Flush driver queue and lookahead buffer:
  1496.                      * Otherwise, it might restore handwriting area (touch_panel_reset_handwriting)
  1497.                      * while stroke-based mode is already entered.
  1498.                      */
  1499.                     g_pen_cntx.reset_stroke_on_pen_up = 1;
  1501.                     /* Note: if pen up handler invokes mmi_pen_reset(), g_pen_cntx.reset_stroke_on_pen_up is cleared */
  1502.                     if (g_pen_event_table[MMI_PEN_EVENT_UP])
  1503.                     {
  1504.                         (g_pen_event_table[MMI_PEN_EVENT_UP]) (g_pen_cntx.pen_down_pos);
  1505.                     }
  1507.                     /* Delay processing further events */
  1508.                     delay_polling_timer = MMI_TRUE;
  1509.                 }
  1510.                 else
  1511.                 {
  1512.                     /* 
  1513.                      * Because touch panel can not detect pen position in Stroke Up event,
  1514.                      * we do not put the point into stroke queue
  1515.                      */
  1516.                     if (g_pen_num_stroke_area > 1)
  1517.                     {
  1518.                         mmi_pen_fix_multi_block_pen_position(&pos);
  1519.                     }
  1520.                     
  1521.                     mmi_pen_push_stroke_end();
  1522.                     if (g_pen_stroke_table[MMI_PEN_STROKE_UP])
  1523.                     {
  1524.                         (g_pen_stroke_table[MMI_PEN_STROKE_UP]) (pos);
  1525.                     }
  1526.                 }
  1528.                 /* Clear strokes and reset handwriting area */
  1529.                 if (g_pen_cntx.reset_stroke_on_pen_up)
  1530.                 {
  1531.                     if (g_pen_stroke_max_points > 0)
  1532.                     {
  1533.                         mmi_pen_end_strokes_of_character();
  1534.                         mmi_pen_reset();
  1535.                         mmi_pen_begin_strokes_of_character();
  1536.                     }
  1537.                     else
  1538.                     {
  1539.                         mmi_pen_reset();
  1540.                     }
  1541.                 }
  1543.                 break;
  1545.             #ifdef MMI_PEN_SUPPORT_STROKE_LONGTAP
  1546.             case STROKE_LONGTAP:
  1547.                 /* 
  1548.                  * 1. degrade sampling rate
  1549.                  * 2. reset strokes on pen on
  1550.                  */
  1551.                 mmi_pen_config_sampling_period(MMI_PEN_SAMPLING_PERIOD_1, MMI_PEN_SAMPLING_PERIOD_1);
  1553.                 g_pen_cntx.reset_stroke_on_pen_up = 1;
  1554.                 g_pen_cntx.restore_sampling_rate_on_reset = 1;
  1555.                 if (g_pen_stroke_table[MMI_PEN_STROKE_LONGTAP])
  1556.                 {
  1557.                     (g_pen_stroke_table[MMI_PEN_STROKE_LONGTAP]) (pos);
  1558.                 }
  1560.                 break;
  1561.             #else /* MMI_PEN_SUPPORT_STROKE_LONGTAP */ 
  1562.             case STROKE_LONGTAP:
  1563.                 break;
  1564.             #endif /* MMI_PEN_SUPPORT_STROKE_LONGTAP */ 
  1566.             default:
  1567.                 MMI_ASSERT(0);
  1568.         }
  1570.         mmi_frm_fetch_msg_from_extQ_to_circularQ();
  1571.     }
  1573.     if (is_stroke_move)
  1574.     {
  1575.         if (g_pen_stroke_post_move)
  1576.         {
  1577.             g_pen_stroke_post_move();
  1578.         }
  1579.     }
  1581.     if (has_incoming_event)
  1582.     {
  1583.         TurnOnBacklight(MMI_TRUE);
  1584.     #ifdef __MMI_LCD_PARTIAL_ON__
  1585.         /* Switch screen and flush pen events */
  1586.         LeavePartialOnScreenSaverIfOk();
  1587.     #endif /* __MMI_LCD_PARTIAL_ON__ */ 
  1588.     }
  1590.     /* Either look-ahead buffer is empty or we need to skip the polling  */
  1591.     MMI_ASSERT(g_pen_cntx.num_lookahead_events == 0 || delay_polling_timer);
  1593.     if (delay_polling_timer)
  1594.     {
  1595.         /* Start a timer even if !g_pen_cntx.is_enabled && !g_pen_cntx.is_pen_down && g_pen_cntx.num_lookahead_events == 0 */
  1596.         StartTimer(PEN_POLLING_TIMER, MMI_PEN_DEBOUNCE_POLLING_DELAY, mmi_pen_poll_hdlr);
  1597.         g_pen_polling_timer_started = MMI_TRUE;
  1599.         Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_poll_hdlr() - delay polling timer n");
  1600.     }
  1601.     else if (g_pen_cntx.is_pen_down)
  1602.     {
  1603.         /* Previous pen handlers might call mmi_pen_disable(), then g_pen_cntx.is_pen_down = 0.  */
  1604.         MMI_DBG_ASSERT(g_pen_cntx.is_enabled);
  1605.         StartTimer(PEN_POLLING_TIMER, MMI_PEN_POLLING_PERIOD, mmi_pen_poll_hdlr);
  1606.         g_pen_polling_timer_started = MMI_TRUE;
  1607.     }
  1608. }
  1610. /*
  1611.  * Refernece: touch_panel_sendilm() 
  1612.  * THIS FUNCTION IS EXECUTED IN DRIVER CONTEXT
  1613.  */
  1616. /*****************************************************************************
  1617.  * FUNCTION
  1618.  *  mmi_pen_touch_panel_sendilm
  1619.  * DESCRIPTION
  1620.  *  
  1621.  * PARAMETERS
  1622.  *  param       [IN]         unused
  1623.  *  state       [IN]        
  1624.  * RETURNS
  1625.  *  void
  1626.  *****************************************************************************/
  1627. static void mmi_pen_touch_panel_sendilm(void *param /* unused */ , Touch_Panel_Event_enum state)
  1628. {
  1629.     /*----------------------------------------------------------------*/
  1630.     /* Local Variables                                                */
  1631.     /*----------------------------------------------------------------*/
  1632.     ilm_struct *tp_ilm;
  1634.     /*----------------------------------------------------------------*/
  1635.     /* Code Body                                                      */
  1636.     /*----------------------------------------------------------------*/
  1637.     /* Dummy function */
  1638.     if (state == PEN_DOWN || state == STROKE_DOWN)
  1639.     {
  1640.         if (!g_pen_is_driver_indication_in_queue)
  1641.         {
  1642.             g_pen_is_driver_indication_in_queue = 1;
  1643.             DRV_BuildPrimitive(tp_ilm, MOD_TP_TASK, MOD_MMI, MSG_ID_TP_EVENT_IND, NULL);
  1644.             msg_send_ext_queue(tp_ilm);
  1645.         }
  1646.     }
  1647. }
  1649. /* Protocol event handler of MSG_ID_TP_EVENT_IND */
  1652. /*****************************************************************************
  1653.  * FUNCTION
  1654.  *  mmi_pen_touch_panel_event_ind
  1655.  * DESCRIPTION
  1656.  *  
  1657.  * PARAMETERS
  1658.  *  param       [IN]     unused
  1659.  * RETURNS
  1660.  *  void
  1661.  *****************************************************************************/
  1662. static void mmi_pen_touch_panel_event_ind(void *param /* unused */ )
  1663. {
  1664.     /*----------------------------------------------------------------*/
  1665.     /* Local Variables                                                */
  1666.     /*----------------------------------------------------------------*/
  1668.     /*----------------------------------------------------------------*/
  1669.     /* Code Body                                                      */
  1670.     /*----------------------------------------------------------------*/
  1671.     Trace2(
  1672.         MMI_TRACE_G1_FRM,
  1673.         "[Pen] mmi_pen_touch_panel_event_in - %d, %dn",
  1674.         (int)g_pen_polling_timer_started,
  1675.         (int)g_pen_cntx.is_enabled);
  1677.     g_pen_is_driver_indication_in_queue = 0;
  1679.     if (!g_pen_polling_timer_started && g_pen_cntx.is_enabled)
  1680.     {
  1681.         mmi_pen_poll_hdlr();
  1682.     }
  1683. }
  1685. /***************************************************************************** 
  1686. * Global Variable
  1687. *****************************************************************************/
  1689. /***************************************************************************** 
  1690. * Global Function
  1691. *****************************************************************************/
  1693. /* Dummy pen handler */
  1696. /*****************************************************************************
  1697.  * FUNCTION
  1698.  *  mmi_pen_dummy_hdlr
  1699.  * DESCRIPTION
  1700.  *  
  1701.  * PARAMETERS
  1702.  *  pos     [IN]        
  1703.  * RETURNS
  1704.  *  void
  1705.  *****************************************************************************/
  1706. void mmi_pen_dummy_hdlr(mmi_pen_point_struct pos)
  1707. {
  1708.     /*----------------------------------------------------------------*/
  1709.     /* Local Variables                                                */
  1710.     /*----------------------------------------------------------------*/
  1712.     /*----------------------------------------------------------------*/
  1713.     /* Code Body                                                      */
  1714.     /*----------------------------------------------------------------*/
  1715.     UI_UNUSED_PARAMETER(pos);
  1716. }
  1719. /*****************************************************************************
  1720.  * FUNCTION
  1721.  *  mmi_pen_init
  1722.  * DESCRIPTION
  1723.  *  Initialize pen system
  1724.  * PARAMETERS
  1725.  *  void
  1726.  * RETURNS
  1727.  *  void
  1728.  *****************************************************************************/
  1729. void mmi_pen_init(void)
  1730. {
  1731.     /*----------------------------------------------------------------*/
  1732.     /* Local Variables                                                */
  1733.     /*----------------------------------------------------------------*/
  1735.     /*----------------------------------------------------------------*/
  1736.     /* Code Body                                                      */
  1737.     /*----------------------------------------------------------------*/
  1738. #ifdef __MMI_HANDWRITING_PAD__
  1739.     mmi_frm_setup_default_pen_handler();
  1740. #endif 
  1742.     g_pen_initialized = KAL_TRUE;
  1744.     mmi_pen_stop_capture_strokes();
  1745.     mmi_pen_config_sampling_period(MMI_PEN_SAMPLING_PERIOD_1, MMI_PEN_SAMPLING_PERIOD_2);
  1746.     mmi_pen_config_timeout_period(MMI_PEN_LONGTAP_TIME, MMI_PEN_REPEAT_TIME, MMI_PEN_STROKE_LONGTAP_TIME);
  1747.     mmi_pen_config_move_offset(
  1748.         MMI_PEN_SKIP_MOVE_OFFSET,
  1749.         MMI_PEN_SKIP_STROKE_MOVE_OFFSET,
  1750.         MMI_PEN_SKIP_LONGTAP_OFFSET,
  1751.         MMI_PEN_SKIP_STROKE_LONGTAP_OFFSET);
  1753.     touch_panel_cb_registration(mmi_pen_touch_panel_sendilm, NULL);
  1754.     SetProtocolEventHandler(mmi_pen_touch_panel_event_ind, MSG_ID_TP_EVENT_IND);
  1755. }
  1758. /*****************************************************************************
  1759.  * FUNCTION
  1760.  *  mmi_pen_block
  1761.  * DESCRIPTION
  1762.  *  Block pen system
  1763.  *  
  1764.  *  Note: typically used for keypad lock in idle screen
  1765.  *  mmi_pen_enable()/mmi_pen_disable() are ignored when pen is blocked.
  1766.  * PARAMETERS
  1767.  *  void
  1768.  * RETURNS
  1769.  *  void
  1770.  *****************************************************************************/
  1771. void mmi_pen_block(void)
  1772. {
  1773.     /*----------------------------------------------------------------*/
  1774.     /* Local Variables                                                */
  1775.     /*----------------------------------------------------------------*/
  1777.     /*----------------------------------------------------------------*/
  1778.     /* Code Body                                                      */
  1779.     /*----------------------------------------------------------------*/
  1780.     mmi_pen_disable();
  1781.     g_pen_cntx.is_blocked = 1;
  1782. }
  1784. //KP Jerry add on 2007-4-11 start
  1785. #ifdef __MMI_PEN_BLOCK_WHEN_KAYPAD_LOCKED__
  1786. /*****************************************************************************
  1787.  * FUNCTION
  1788.  *  mmi_pen_forced_block
  1789.  * DESCRIPTION
  1790.  *  Block pen system forced
  1791.  *  
  1792.  *  Note: typically used for keypad lock in idle screen
  1793.  * PARAMETERS
  1794.  *  void
  1795.  * RETURNS
  1796.  *  void
  1797.  *****************************************************************************/
  1798. void mmi_pen_forced_block(void)
  1799. {
  1800.     /*----------------------------------------------------------------*/
  1801.     /* Local Variables                                                */
  1802.     /*----------------------------------------------------------------*/
  1804.     /*----------------------------------------------------------------*/
  1805.     /* Code Body                                                      */
  1806.     /*----------------------------------------------------------------*/
  1807.     mmi_pen_forced_disable();
  1808.     g_pen_cntx.is_blocked = 1;
  1809. }
  1810. #endif/*__MMI_PEN_BLOCK_WHEN_KAYPAD_LOCKED__*/
  1811. //KP Jerry add on 2007-4-11 end
  1813. /*****************************************************************************
  1814.  * FUNCTION
  1815.  *  mmi_pen_unblock
  1816.  * DESCRIPTION
  1817.  *  Unblock pen system
  1818.  *  
  1819.  *  Note: typically used for keypad lock in idle screen
  1820.  *  mmi_pen_enable()/mmi_pen_disable() are ignored when pen is blocked.
  1821.  * PARAMETERS
  1822.  *  void
  1823.  * RETURNS
  1824.  *  void
  1825.  *****************************************************************************/
  1826. void mmi_pen_unblock(void)
  1827. {
  1828.     /*----------------------------------------------------------------*/
  1829.     /* Local Variables                                                */
  1830.     /*----------------------------------------------------------------*/
  1832.     /*----------------------------------------------------------------*/
  1833.     /* Code Body                                                      */
  1834.     /*----------------------------------------------------------------*/
  1835.     g_pen_cntx.is_blocked = 0;
  1836.     mmi_pen_enable();
  1837. }
  1840. /*****************************************************************************
  1841.  * FUNCTION
  1842.  *  mmi_pen_config_sampling_period
  1843.  * DESCRIPTION
  1844.  *  Config sampling period of Event-based and Stroke-Based
  1845.  * PARAMETERS
  1846.  *  low         [IN]        Sampling period in non-handwriting area (multiple of 10ms)
  1847.  *  high        [IN]        Sampling period in handwriting area (multiple of 10ms)
  1848.  * RETURNS
  1849.  *  void
  1850.  *****************************************************************************/
  1851. void mmi_pen_config_sampling_period(kal_uint32 low, kal_uint32 high)
  1852. {
  1853.     /*----------------------------------------------------------------*/
  1854.     /* Local Variables                                                */
  1855.     /*----------------------------------------------------------------*/
  1857.     /*----------------------------------------------------------------*/
  1858.     /* Code Body                                                      */
  1859.     /*----------------------------------------------------------------*/
  1860.     touch_panle_conf_sample_period(low, high);
  1861. }
  1864. /*****************************************************************************
  1865.  * FUNCTION
  1866.  *  mmi_pen_config_timeout_period
  1867.  * DESCRIPTION
  1868.  *  Config timeout period for LongTap and Repeat
  1869.  * PARAMETERS
  1870.  *  longtap             [IN]        Timeout period for Pen LongTap event (multiple of 10ms).
  1871.  *  repeat              [IN]        Timeout period for Pen Repeat event (multiple of 10ms).
  1872.  *  stroke_longtap      [IN]        Timeout period for Stroke LongTap event (multiple of 10ms).
  1873.  * RETURNS
  1874.  *  void
  1875.  *****************************************************************************/
  1876. void mmi_pen_config_timeout_period(kal_uint32 longtap, kal_uint32 repeat, kal_uint32 stroke_longtap)
  1877. {
  1878.     /*----------------------------------------------------------------*/
  1879.     /* Local Variables                                                */
  1880.     /*----------------------------------------------------------------*/
  1882.     /*----------------------------------------------------------------*/
  1883.     /* Code Body                                                      */
  1884.     /*----------------------------------------------------------------*/
  1885.     touch_panle_conf_timeout_period(longtap, repeat, stroke_longtap);
  1886. }
  1889. /*****************************************************************************
  1890.  * FUNCTION
  1891.  *  mmi_pen_config_move_offset
  1892.  * DESCRIPTION
  1893.  *  Config
  1894.  * PARAMETERS
  1895.  *  event_based         [IN]        Minimum move offset for Pen Move event
  1896.  *  stroke_based        [IN]        Minimum move offset for Stroke Move event
  1897.  *  long_tap            [IN]        Maximum move offset for Pen LongTap event
  1898.  *  stroke_long_tap     [IN]        Maximum move offset for Stroke LongTap event
  1899.  * RETURNS
  1900.  *  void
  1901.  *****************************************************************************/
  1902. void mmi_pen_config_move_offset(
  1903.         kal_uint32 event_based,
  1904.         kal_uint32 stroke_based,
  1905.         kal_uint32 long_tap,
  1906.         kal_uint32 stroke_long_tap)
  1907. {
  1908.     /*----------------------------------------------------------------*/
  1909.     /* Local Variables                                                */
  1910.     /*----------------------------------------------------------------*/
  1912.     /*----------------------------------------------------------------*/
  1913.     /* Code Body                                                      */
  1914.     /*----------------------------------------------------------------*/
  1915.     touch_panel_conf_move_offset(
  1916.         (kal_uint16) event_based,
  1917.         (kal_uint16) stroke_based,
  1918.         (kal_uint16) long_tap,
  1919.         (kal_uint16) stroke_long_tap);
  1920. }
  1923. /*****************************************************************************
  1924.  * FUNCTION
  1925.  *  mmi_pen_enable
  1926.  * DESCRIPTION
  1927.  *  Enable pen system
  1928.  *  
  1929.  *  Note: typically on Keypad Up
  1930.  * PARAMETERS
  1931.  *  void
  1932.  * RETURNS
  1933.  *  void
  1934.  * REMARKS
  1935.  *  If g_pen_initialized is not true, we do not enable touch screen because
  1936.  *  TP task might not be running
  1937.  *****************************************************************************/
  1938. void mmi_pen_enable(void)
  1939. {
  1940.     /*----------------------------------------------------------------*/
  1941.     /* Local Variables                                                */
  1942.     /*----------------------------------------------------------------*/
  1944.     /*----------------------------------------------------------------*/
  1945.     /* Code Body                                                      */
  1946.     /*----------------------------------------------------------------*/
  1947.     Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_enable()n");
  1949.     if (!g_pen_initialized || g_pen_cntx.is_blocked || g_pen_cntx.is_enabled)
  1950.     {
  1951.         return;
  1952.     }
  1954.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  1955.     g_pen_cntx.is_enabled = 1;
  1957.     touch_panel_enable(KAL_TRUE);
  1958. }
  1961. /*****************************************************************************
  1962.  * FUNCTION
  1963.  *  mmi_pen_disable
  1964.  * DESCRIPTION
  1965.  *  Disable pen system
  1966.  *  
  1967.  *  Note: typically on Keypad Down because we don't want to use keypad and touch screen
  1968.  *  at the same time
  1969.  * PARAMETERS
  1970.  *  void
  1971.  * RETURNS
  1972.  *  void
  1973.  *****************************************************************************/
  1974. void mmi_pen_disable(void)
  1975. {
  1976.     /*----------------------------------------------------------------*/
  1977.     /* Local Variables                                                */
  1978.     /*----------------------------------------------------------------*/
  1980.     /*----------------------------------------------------------------*/
  1981.     /* Code Body                                                      */
  1982.     /*----------------------------------------------------------------*/
  1983.     Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_disable()n");
  1985.     if (!g_pen_initialized || g_pen_cntx.is_blocked || !g_pen_cntx.is_enabled)
  1986.     {
  1987.         return;
  1988.     }
  1990.     touch_panel_enable(KAL_FALSE);
  1991.     touch_panel_flush();
  1993.     if (g_pen_cntx.is_pen_down)
  1994.     {
  1995.         /* For both stroke-based and event-based */
  1996.         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  1997.         {
  1998.             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_current_pos);
  1999.         }
  2000.     }
  2002.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  2003. }
  2005. //KP Jerry add on 2007-4-11 start
  2006. #ifdef __MMI_PEN_BLOCK_WHEN_KAYPAD_LOCKED__
  2007. /*****************************************************************************
  2008.  * FUNCTION
  2009.  *  mmi_pen_forced_disable
  2010.  * DESCRIPTION
  2011.  *  Disable pen system
  2012.  *  
  2013.  *  Note: typically on Keypad Down because we don't want to use keypad and touch screen
  2014.  *  at the same time
  2015.  * PARAMETERS
  2016.  *  void
  2017.  * RETURNS
  2018.  *  void
  2019.  *****************************************************************************/
  2020. void mmi_pen_forced_disable(void)
  2021. {
  2022.     /*----------------------------------------------------------------*/
  2023.     /* Local Variables                                                */
  2024.     /*----------------------------------------------------------------*/
  2026.     /*----------------------------------------------------------------*/
  2027.     /* Code Body                                                      */
  2028.     /*----------------------------------------------------------------*/
  2029.     Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_forced_disable()n");
  2031.     if (!g_pen_initialized || g_pen_cntx.is_blocked || !g_pen_cntx.is_enabled)
  2032.     {
  2033.         return;
  2034.     }
  2036.     touch_panel_enable(KAL_FALSE);
  2037.     touch_panel_flush();
  2039.     if (g_pen_cntx.is_pen_down)
  2040.     {
  2041.         /* For both stroke-based and event-based */
  2042.         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  2043.         {
  2044.             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_current_pos);
  2045.         }
  2046.     }
  2047. }
  2048. #endif/*__MMI_PEN_BLOCK_WHEN_KAYPAD_LOCKED__*/
  2049. //KP Jerry add on 2007-4-11 end
  2051. /*****************************************************************************
  2052.  * FUNCTION
  2053.  *  mmi_pen_reset
  2054.  * DESCRIPTION
  2055.  *  Reset the status of touch screen
  2056.  *  - Flush event queue
  2057.  *  - If the pen is currently tapped down, ignore all subsequent pen events until the pen is up.
  2058.  *  
  2059.  *  Note: typically on MMI screen switching
  2060.  * PARAMETERS
  2061.  *  void
  2062.  * RETURNS
  2063.  *  void
  2064.  *****************************************************************************/
  2065. void mmi_pen_reset(void)
  2066. {
  2067.     /*----------------------------------------------------------------*/
  2068.     /* Local Variables                                                */
  2069.     /*----------------------------------------------------------------*/
  2071.     /*----------------------------------------------------------------*/
  2072.     /* Code Body                                                      */
  2073.     /*----------------------------------------------------------------*/
  2074.     Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_reset()n");
  2076.     if (!g_pen_initialized || g_pen_cntx.is_blocked || !g_pen_cntx.is_enabled)
  2077.     {
  2078.         return;
  2079.     }
  2081.     if (g_pen_cntx.restore_sampling_rate_on_reset)
  2082.     {
  2083.         mmi_pen_config_sampling_period(MMI_PEN_SAMPLING_PERIOD_1, MMI_PEN_SAMPLING_PERIOD_2);
  2084.     }
  2086.     if (g_pen_cntx.is_pen_down)
  2087.     {
  2088.         /* For both stroke-based and event-based */
  2089.         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  2090.         {
  2091.             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_current_pos);
  2092.         }
  2093.     }
  2095.     touch_panel_reset(KAL_TRUE);
  2097.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  2098.     g_pen_cntx.is_enabled = 1;
  2099. }
  2102. /*****************************************************************************
  2103.  * FUNCTION
  2104.  *  mmi_pen_get_state
  2105.  * DESCRIPTION
  2106.  *  Get the current state of touch screen
  2107.  * PARAMETERS
  2108.  *  is_enabled      [OUT]         
  2109.  *  is_pen_down     [OUT]         
  2110.  * RETURNS
  2111.  *  void
  2112.  * REMARKS
  2113.  *  It returns the current state *inside MMI task*, real pen state might be changed, but
  2114.  *  the driver indication might not be processed yet.
  2115.  *****************************************************************************/
  2116. void mmi_pen_get_state(kal_bool *is_enabled, kal_bool *is_pen_down)
  2117. {
  2118.     /*----------------------------------------------------------------*/
  2119.     /* Local Variables                                                */
  2120.     /*----------------------------------------------------------------*/
  2122.     /*----------------------------------------------------------------*/
  2123.     /* Code Body                                                      */
  2124.     /*----------------------------------------------------------------*/
  2125.     if (g_pen_cntx.is_enabled)
  2126.     {
  2127.         *is_enabled = KAL_TRUE;
  2128.         if (g_pen_cntx.is_pen_down)
  2129.         {
  2130.             *is_pen_down = KAL_TRUE;
  2131.         }
  2132.         else
  2133.         {
  2134.             *is_pen_down = KAL_FALSE;
  2135.         }
  2136.     }
  2137.     else
  2138.     {
  2139.         *is_enabled = KAL_FALSE;
  2140.         *is_pen_down = KAL_FALSE;
  2141.     }
  2142. }
  2145. /*****************************************************************************
  2146.  * FUNCTION
  2147.  *  mmi_pen_start_calibration
  2148.  * DESCRIPTION
  2149.  *  Start pen calibration
  2150.  * PARAMETERS
  2151.  *  num         [IN]        Number of calibration points
  2152.  *  points      [IN]        Calibration points
  2153.  * RETURNS
  2154.  *  void
  2155.  * REMARKS
  2156.  *  After mmi_pen_reset(), the calibration process is terminated.
  2157.  *****************************************************************************/
  2158. void mmi_pen_start_calibration(kal_uint16 num, const mmi_pen_point_struct *points)
  2159. {
  2160.     /*----------------------------------------------------------------*/
  2161.     /* Local Variables                                                */
  2162.     /*----------------------------------------------------------------*/
  2164.     /*----------------------------------------------------------------*/
  2165.     /* Code Body                                                      */
  2166.     /*----------------------------------------------------------------*/
  2167.     Trace2(MMI_TRACE_G1_FRM, "[Pen] mmi_pen_start_calibration()n");
  2168.     MMI_ASSERT(g_pen_initialized);
  2170.     touch_panel_start_cali((TouchPanelCoordStruct*) points, num);
  2171. }
  2174. /*****************************************************************************
  2175.  * FUNCTION
  2176.  *  mmi_pen_set_calibration_data
  2177.  * DESCRIPTION
  2178.  *  Assign driver calibration data
  2179.  * PARAMETERS
  2180.  *  data        [IN]        
  2181.  * RETURNS
  2182.  *  void
  2183.  * REMARKS
  2184.  *  
  2185.  *****************************************************************************/
  2186. void mmi_pen_set_calibration_data(const mmi_pen_calibration_struct *data)
  2187. {
  2188.     /*----------------------------------------------------------------*/
  2189.     /* Local Variables                                                */
  2190.     /*----------------------------------------------------------------*/
  2191.     TouchPanelCaliStruct cali;
  2193.     /*----------------------------------------------------------------*/
  2194.     /* Code Body                                                      */
  2195.     /*----------------------------------------------------------------*/
  2196.     MMI_DBG_ASSERT(sizeof(mmi_pen_calibration_struct) == sizeof(TouchPanelCaliStruct));
  2197.     memcpy(&cali, data, sizeof(TouchPanelCaliStruct));
  2198.     touch_panel_set_cali(cali);
  2199. }
  2202. /*****************************************************************************
  2203.  * FUNCTION
  2204.  *  mmi_pen_read_calibration_data
  2205.  * DESCRIPTION
  2206.  *  Read the current value of driver calibration data
  2207.  * PARAMETERS
  2208.  *  data        [OUT]       
  2209.  * RETURNS
  2210.  *  void
  2211.  * REMARKS
  2212.  *  
  2213.  *****************************************************************************/
  2214. void mmi_pen_read_calibration_data(mmi_pen_calibration_struct *data)
  2215. {
  2216.     /*----------------------------------------------------------------*/
  2217.     /* Local Variables                                                */
  2218.     /*----------------------------------------------------------------*/
  2219.     TouchPanelCaliStruct cali;
  2221.     /*----------------------------------------------------------------*/
  2222.     /* Code Body                                                      */
  2223.     /*----------------------------------------------------------------*/
  2224.     MMI_DBG_ASSERT(sizeof(mmi_pen_calibration_struct) == sizeof(TouchPanelCaliStruct));
  2225.     touch_panel_read_cali(&cali);
  2226.     memcpy(data, &cali, sizeof(TouchPanelCaliStruct));
  2227. }
  2230. /*****************************************************************************
  2231.  * FUNCTION
  2232.  *  mmi_pen_register_down_handler
  2233.  * DESCRIPTION
  2234.  *  Register the Pen Down handler
  2235.  * PARAMETERS
  2236.  *  pen_fp      [IN]        Callback handler
  2237.  * RETURNS
  2238.  *  void
  2239.  *****************************************************************************/
  2240. void mmi_pen_register_down_handler(mmi_pen_hdlr pen_fp)
  2241. {
  2242.     /*----------------------------------------------------------------*/
  2243.     /* Local Variables                                                */
  2244.     /*----------------------------------------------------------------*/
  2246.     /*----------------------------------------------------------------*/
  2247.     /* Code Body                                                      */
  2248.     /*----------------------------------------------------------------*/
  2249.     g_pen_event_table[MMI_PEN_EVENT_DOWN] = pen_fp;
  2250. }
  2253. /*****************************************************************************
  2254.  * FUNCTION
  2255.  *  mmi_pen_register_long_tap_handler
  2256.  * DESCRIPTION
  2257.  *  Register the Pen LongTap handler
  2258.  *  
  2259.  *  LongTap handler is invoked when  the pen is tapped for a period of time
  2260.  *  and stays at the same place where it is tapped down.
  2261.  *  
  2262.  *  It is invoked atmost one time before pen up.
  2263.  * PARAMETERS
  2264.  *  pen_fp      [IN]        Callback handler
  2265.  * RETURNS
  2266.  *  void
  2267.  *****************************************************************************/
  2268. void mmi_pen_register_long_tap_handler(mmi_pen_hdlr pen_fp)
  2269. {
  2270.     /*----------------------------------------------------------------*/
  2271.     /* Local Variables                                                */
  2272.     /*----------------------------------------------------------------*/
  2274.     /*----------------------------------------------------------------*/
  2275.     /* Code Body                                                      */
  2276.     /*----------------------------------------------------------------*/
  2277.     g_pen_event_table[MMI_PEN_EVENT_LONG_TAP] = pen_fp;
  2278. }
  2281. /*****************************************************************************
  2282.  * FUNCTION
  2283.  *  mmi_pen_register_repeat_handler
  2284.  * DESCRIPTION
  2285.  *  Register the Pen Repeat handler.
  2286.  *  
  2287.  *  Repeat handler is invoked after LongTap handler.
  2288.  *  However, unlike LongTap handler, Repeat handler is invoked even if
  2289.  *  it does not stays at the same place as Pen Down.
  2290.  *  
  2291.  *  it might be invoked more than one times before pen up.
  2292.  * PARAMETERS
  2293.  *  pen_fp      [IN]        Callback handler
  2294.  * RETURNS
  2295.  *  void
  2296.  *****************************************************************************/
  2297. void mmi_pen_register_repeat_handler(mmi_pen_hdlr pen_fp)
  2298. {
  2299.     /*----------------------------------------------------------------*/
  2300.     /* Local Variables                                                */
  2301.     /*----------------------------------------------------------------*/
  2303.     /*----------------------------------------------------------------*/
  2304.     /* Code Body                                                      */
  2305.     /*----------------------------------------------------------------*/
  2306.     g_pen_event_table[MMI_PEN_EVENT_REPEAT] = pen_fp;
  2307. }
  2310. /*****************************************************************************
  2311.  * FUNCTION
  2312.  *  mmi_pen_register_move_handler
  2313.  * DESCRIPTION
  2314.  *  Register the Pen Move handler.
  2315.  *  
  2316.  *  The invocation frequency of Pen Move handler is typically less than driver sampling rate.
  2317.  * PARAMETERS
  2318.  *  pen_fp      [IN]        Callback handler
  2319.  * RETURNS
  2320.  *  void
  2321.  *****************************************************************************/
  2322. void mmi_pen_register_move_handler(mmi_pen_hdlr pen_fp)
  2323. {
  2324.     /*----------------------------------------------------------------*/
  2325.     /* Local Variables                                                */
  2326.     /*----------------------------------------------------------------*/
  2328.     /*----------------------------------------------------------------*/
  2329.     /* Code Body                                                      */
  2330.     /*----------------------------------------------------------------*/
  2331.     g_pen_event_table[MMI_PEN_EVENT_MOVE] = pen_fp;
  2332. }
  2335. /*****************************************************************************
  2336.  * FUNCTION
  2337.  *  mmi_pen_register_up_handler
  2338.  * DESCRIPTION
  2339.  *  Register the Pen Up handler.
  2340.  * PARAMETERS
  2341.  *  pen_fp      [IN]        
  2342.  * RETURNS
  2343.  *  void
  2344.  *****************************************************************************/
  2345. void mmi_pen_register_up_handler(mmi_pen_hdlr pen_fp)
  2346. {
  2347.     /*----------------------------------------------------------------*/
  2348.     /* Local Variables                                                */
  2349.     /*----------------------------------------------------------------*/
  2351.     /*----------------------------------------------------------------*/
  2352.     /* Code Body                                                      */
  2353.     /*----------------------------------------------------------------*/
  2354.     g_pen_event_table[MMI_PEN_EVENT_UP] = pen_fp;
  2355. }
  2358. /*****************************************************************************
  2359.  * FUNCTION
  2360.  *  mmi_pen_register_abort_handler
  2361.  * DESCRIPTION
  2362.  *  Register the Pen Abort handler.
  2363.  * PARAMETERS
  2364.  *  pen_fp      [IN]        
  2365.  * RETURNS
  2366.  *  void
  2367.  *****************************************************************************/
  2368. void mmi_pen_register_abort_handler(mmi_pen_hdlr pen_fp)
  2369. {
  2370.     /*----------------------------------------------------------------*/
  2371.     /* Local Variables                                                */
  2372.     /*----------------------------------------------------------------*/
  2374.     /*----------------------------------------------------------------*/
  2375.     /* Code Body                                                      */
  2376.     /*----------------------------------------------------------------*/
  2377.     g_pen_event_table[MMI_PEN_EVENT_ABORT] = pen_fp;
  2378. }
  2381. /*****************************************************************************
  2382.  * FUNCTION
  2383.  *  mmi_pen_start_capture_strokes
  2384.  * DESCRIPTION
  2385.  *  Start to capture stroke inside the handwriting area.
  2386.  *
  2387.  *  This API is typically used in entry function of editor screen.
  2388.  *
  2389.  *  The points are en-queued in 'point_array' in the following format:
  2390.  * 
  2391.  *  Each point contains two 16-bit integers for x, y coordinates. Two strokes are separated with
  2392.  *  marker (0xffff, 0), and all strokes of one character are ended with (0xffff, 0xffff) by
  2393.  *  mmi_pen_end_strokes_of_character(). The parameter 'max_points' should also include the memory 
  2394.  *  used by markers.
  2395.  *  (x0, y0) (x1, y1)