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

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

MTK

开发平台：

C/C++

TouchScreen.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  *   TouchScreen.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   Low-level Touch Screen API - interface between driver or PC simulator
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * removed!
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * removed!
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * removed!
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * removed!
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * removed!
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  101.  * removed!
  102.  * removed!
  103.  *
  104.  * removed!
  105.  * removed!
  106.  * removed!
  107.  *
  108.  * removed!
  109.  * removed!
  110.  * removed!
  111.  *
  112.  * removed!
  113.  * removed!
  114.  * removed!
  115.  *
  116.  * removed!
  117.  * removed!
  118.  * removed!
  119.  *
  120.  * removed!
  121.  * removed!
  122.  * removed!
  123.  *
  124.  * removed!
  125.  * removed!
  126.  * removed!
  127.  *
  128.  * removed!
  129.  * removed!
  130.  * removed!
  131.  *
  132.  * removed!
  133.  * removed!
  134.  * removed!
  135.  *
  136.  * removed!
  137.  * removed!
  138.  * removed!
  139.  *
  140.  * removed!
  141.  * removed!
  142.  * removed!
  143.  *
  144.  * removed!
  145.  * removed!
  146.  * removed!
  147.  *
  148.  * removed!
  149.  * removed!
  150.  * removed!
  151.  *
  152.  * removed!
  153.  * removed!
  154.  * removed!
  155.  *
  156.  * removed!
  157.  * removed!
  158.  * removed!
  159.  *
  160.  * removed!
  161.  * removed!
  162.  * removed!
  163.  *
  164.  * removed!
  165.  * removed!
  166.  * removed!
  167.  *
  168.  * removed!
  169.  * removed!
  170.  * removed!
  171.  *
  172.  *------------------------------------------------------------------------------
  173.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  174.  *============================================================================
  175.  ****************************************************************************/
  177. #include "MMI_features.h"
  179. /* Save stroke data in filesystem for analysis of recognition rate */
  180. #undef MMI_PEN_SAVE_STROKE_IN_FILE
  182. /*****************************************************************************
  183.  * In case that handwriting area is overlapped with an editor, we need to 
  184.  * define a way to move cursor inside the editor.
  185.  *
  186.  * Three approaches are supported:
  187.  *
  188.  * 1. !defined(MMI_PEN_SUPPORT_STROKE_LONGTAP) and single-block --> (MMI_PEN_STROKE_MIN_OFFSET > 0)
  189.  *
  190.  * In the first stroke (after mmi_pen_begin_strokes_of_character()), 
  191.  * stroke down in handwriting area is translated to Pen Down event first until pen is 
  192.  * moved across predefined distance MMI_PEN_STROKE_MIN_OFFSET.
  193.  *
  194.  * For example, driver events are converted to MMI events in the first stroke like:
  195.  *
  196.  * STROKE_DOWN, STROKE_UP --> MMI_PEN_EVENT_DOWN, MMI_PEN_EVENT_UP
  197.  *       (stroke buffer is empty, handwriting area is reset to default)
  198.  *
  199.  * STROKE_DOWN, STROKE_MOVE (< MMI_PEN_STROKE_MIN_OFFSET), STROKE_UP --> 
  200.  *       MMI_PEN_EVENT_DOWN, MMI_PEN_EVENT_UP
  201.  *       (the STROKE_MOVE before STROKE_UP is dropped, 
  202.  *        stroke buffer is empty, handwriting area is reset to default)
  203.  *
  204.  * STROKE_DOWN, STROKE_MOVE (> MMI_PEN_STROKE_MIN_OFFSET), STROKE_UP -->
  205.  *       MMI_PEN_EVENT_DOWN, MMI_PEN_EVENT_ABORT, MMI_PEN_STROKE_DOWN, 
  206.  *                           MMI_PEN_STROKE_MOVE, MMI_PEN_STROKE_UP
  207.  *       (The original Pen Down event is aborted, and the first stroke is created)
  208.  *
  209.  * 2. !defined(MMI_PEN_SUPPORT_STROKE_LONGTAP) and multi-block --> 
  210.  * 
  211.  * Handwriting area and non-handwriting area are not overlapped. This is the simplest case.
  212.  *
  213.  * Unnecessary to translate driver pen events.
  214.  *
  215.  * 3. defined(MMI_PEN_SUPPORT_STROKE_LONGTAP) --> (MMI_PEN_STROKE_MIN_OFFSET == 0)
  216.  *
  217.  * In the first stroke (after mmi_pen_begin_strokes_of_character()), 
  218.  * stroke down are translated to Stroke Down event directly. However, when pen stays at the 
  219.  * pen down position within MMI_PEN_SKIP_STROKE_LONGTAP_OFFSET after MMI_PEN_STROKE_LONGTAP_TIME,
  220.  * Stroke LongTap event is generated. Editor will interpret the subsequent 
  221.  * Stroke Move events as editor cursor control commands.
  222.  *
  223.  * For example, driver events are converted to MMI events in the first stroke like:
  224.  *
  225.  * STROKE_DOWN, STROKE_UP --> MMI_PEN_STROKE_DOWN, MMI_PEN_STROKE_UP
  226.  *       (The first stroke is created, and stroke buffer is not empty.)
  227.  *
  228.  * STROKE_DOWN, STROKE_MOVE, STROKE_UP --> 
  229.  *       MMI_PEN_STROKE_DOWN, MMI_PEN_STROKE_MOVE, MMI_PEN_STROKE_UP
  230.  *       (The first stroke is created, and stroke buffer is not empty.)
  231.  *
  232.  * STROKE_DOWN, STROKE_MOVE (1st), STROKE_LONGTAP, STROKE_MOVE (2nd), STROKE_UP -->
  233.  *       MMI_PEN_STROKE_DOWN, MMI_PEN_STROKE_MOVE (1st), MMI_PEN_STROKE_LONGTAP, 
  234.  *       MMI_PEN_STROKE_MOVE (2nd), MMI_PEN_STROKE_UP
  235.  *       (The first stroke is aborted, handwriting area is reset to default, 
  236.  *        Stroke buffer is cleared.)
  237.  *       (NOTE: after STROKE_LONGTAP, we decrease the sampling rate to MMI_PEN_SAMPLING_PERIOD_1)
  238.  *
  239.  * Note that after the first stroke is created, STROKE_LONGTAP events generated by driver are ignored.
  240.  *
  241.  ****************************************************************************/
  243. #if ( defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)) && !defined(__MTK_TARGET__)
  245. /*****************************************************************************
  246.  *
  247.  * WIN32 integration 
  248.  * PC Simulator & MODIS
  249.  *
  250.  ****************************************************************************/
  252. #include "stdC.h"
  253. #include "PixtelDataTypes.h"
  254. #include "TimerEvents.h"
  255. #include "KeyBrd.h"
  256. #include "FrameworkStruct.h"
  257. #include "EventsGprot.h"
  258. #include "EventsDcl.h"
  259. #include "EventsDef.h"
  260. #include "gui_data_types.h"
  261. #include "gui.h"
  262. #include "IdleAppProt.h"
  264. #include "kal_non_specific_general_types.h"
  265. #include "TouchScreenGprot.h"
  266. #include "DebugInitDef.h"
  268. #include "lcd_sw_rnd.h" /* LCD width/height */
  269. #include "time.h"       /* time() */
  271. #include "gdi_include.h"
  272. #include "ScreenRotationGprot.h"
  274. #include "touch_panel_custom.h" /* get handwriting pad setting */
  276. #if !defined(MMI_ON_WIN32)
  277. static void mmi_pen_MODIS_start_timer(void);
  278. static void mmi_pen_MODIS_flush_queue(void);
  279. #endif /* !defined(MMI_ON_WIN32) */ 
  281. /***************************************************************************** 
  282. * Define
  283. *****************************************************************************/
  285. #define MMI_PEN_MAX_HANDWRITING_REGION (3)
  287. #undef MMI_PEN_UNIT_TEST
  289. /***************************************************************************** 
  290. * Typedef 
  291. *****************************************************************************/
  293. typedef struct
  294. {
  295.     /* mmi_pen_block() & mmi_pen_unblock() */
  296.     U32 is_blocked:1;
  298.     /* mmi_pen_enable() & mmi_pen_disable() */
  299.     U32 is_enabled:1;
  301.     /* mmi_pen_reset() set 'is_pen_down' to 0 */
  302.     U32 is_pen_down:1;
  304.     /* The current pen down/move/up is a stroke */
  305.     U32 is_stroke_event:1;
  307.     /* Checking offset with g_pen_stroke_min_offset */
  308.     U32 is_pending_stroke_event:1;
  310.     /* A first stroke is created. This flag is cleared in mmi_pen_begin_strokes_of_character() */
  311.     U32 is_stroke_created:1;
  313.     /* Stroke LongTap event is generated. */
  314.     U32 is_stroke_longtap_event_generated:1;
  316.     /* Set in mmi_pen_end_strokes_of_character(), 
  317.        do not enqueue incoming strokes until mmi_pen_begin_strokes_of_character() is invoked again */
  318.     U32 is_all_stroke_finished:1;
  320.     /* wait for 1: pen long-tap 0: pen repeat (event-based) */
  321.     U32 is_waiting_long_tap_event:1;
  323.     /* 
  324.      * Set by mmi_pen_change_handwriting_area() and mmi_pen_stop_capture_strokes().
  325.      * Close stroke and reset touch screen when pen is up. 
  326.      */
  327.     U32 reset_stroke_on_pen_up:1;
  329.     /* The position where pen is tapped down */
  330.     mmi_pen_point_struct pen_down_pos;
  332.     /* Block index of handwriting area */
  333.     S32 stroke_down_block_index;
  335.     /* The current pen position */
  336.     mmi_pen_point_struct pen_current_pos;
  338.     /* For Pen Repeat */
  339.     mmi_pen_point_struct pen_repeat_origin_pos;
  341.     /* For stroke */
  342.     S32 num_points_queued;
  343. } mmi_pen_context_struct;
  345. /***************************************************************************** 
  346. * Local Variable
  347. *****************************************************************************/
  349. static mmi_pen_context_struct g_pen_cntx;
  351. static mmi_pen_hdlr g_pen_event_table[MMI_PEN_EVENT_TYPE_MAX];
  352. static mmi_pen_hdlr g_pen_stroke_table[MMI_PEN_STROKE_TYPE_MAX];
  353. static void (*g_pen_stroke_pre_move) (void);
  354. static void (*g_pen_stroke_post_move) (void);
  356. static int g_pen_num_stroke_area;   /* 0 if stroke area is not enabled */
  357. static mmi_pen_handwriting_area_struct g_pen_stroke_areas[MMI_PEN_MAX_HANDWRITING_REGION];
  358. static mmi_pen_handwriting_area_struct g_pen_ext_stroke_area;
  359. static int g_pen_stroke_min_offset;
  360. static S32 g_pen_stroke_max_points;
  361. static mmi_pen_point_struct *g_pen_stroke_points;
  363. /***************************************************************************** 
  364. * Local Function
  365. *****************************************************************************/
  367. static void mmi_pen_MODIS_tp_ind(void *);
  369. /*****************************************************************************
  370.  * FUNCTION
  371.  *  mmi_pen_simulator_fix_point_bound
  372.  * DESCRIPTION
  373.  *  
  374.  * PARAMETERS
  375.  *  x       [IN/OUT]     
  376.  *  y       [INT/OUT]     
  377.  * RETURNS
  378.  *  void
  379.  *****************************************************************************/
  380. static void mmi_pen_simulator_fix_point_bound(S16 *x, S16 *y, MMI_BOOL check_multi_block)
  381. {
  382.     /*----------------------------------------------------------------*/
  383.     /* Local Variables                                                */
  384.     /*----------------------------------------------------------------*/
  385.     mmi_pen_handwriting_area_struct *block;
  387.     /*----------------------------------------------------------------*/
  388.     /* Code Body                                                      */
  389.     /*----------------------------------------------------------------*/
  390.     if (*x < 0)
  391.     {
  392.         *x = 0;
  393.     }
  394.     else if (*x >= UI_device_width)
  395.     {
  396.         *x = UI_device_width - 1;
  397.     }
  398.     if (*y < 0)
  399.     {
  400.         *y = 0;
  401.     }
  402.     else if (*y >= UI_device_height)
  403.     {
  404.         *y = UI_device_height - 1;
  405.     }
  407.     if (check_multi_block)
  408.     {
  409.         MMI_ASSERT(g_pen_cntx.stroke_down_block_index >= 0 &&
  410.                    g_pen_cntx.stroke_down_block_index < g_pen_num_stroke_area);
  412.         block = &g_pen_stroke_areas[g_pen_cntx.stroke_down_block_index];
  413.         
  414.         if (*x < block->x1)
  415.         {
  416.             *x = block->x1;
  417.         }
  418.         else if (*x > block->x2)
  419.         {
  420.             *x = block->x2;
  421.         }
  422.         
  423.         if (*y < block->y1)
  424.         {
  425.             *y = block->y1;
  426.         }
  427.         else if (*y > block->y2)
  428.         {
  429.             *y = block->y2;
  430.         }
  431.     }
  432. }
  435. /*****************************************************************************
  436.  * FUNCTION
  437.  *  mmi_pen_simulator_pixel_diff
  438.  * DESCRIPTION
  439.  *  
  440.  * PARAMETERS
  441.  *  pos1        [IN]        
  442.  *  pos2        [IN]        
  443.  * RETURNS
  444.  *  
  445.  *****************************************************************************/
  446. static S16 mmi_pen_simulator_pixel_diff(mmi_pen_point_struct pos1, mmi_pen_point_struct pos2)
  447. {
  448.     /*----------------------------------------------------------------*/
  449.     /* Local Variables                                                */
  450.     /*----------------------------------------------------------------*/
  451.     S16 diff_x = pos1.x - pos2.x;
  452.     S16 diff_y = pos1.y - pos2.y;
  454.     /*----------------------------------------------------------------*/
  455.     /* Code Body                                                      */
  456.     /*----------------------------------------------------------------*/
  457.     if (diff_x < 0)
  458.     {
  459.         diff_x = -diff_x;
  460.     }
  461.     if (diff_y < 0)
  462.     {
  463.         diff_y = -diff_y;
  464.     }
  465.     return diff_x + diff_y;
  466. }
  469. /*****************************************************************************
  470.  * FUNCTION
  471.  *  mmi_pen_simulator_in_stroke_area
  472.  * DESCRIPTION
  473.  *  
  474.  * PARAMETERS
  475.  *  x       [IN]        
  476.  *  y       [IN]        
  477.  * RETURNS
  478.  *  The index of block. 0 for block-0 or extended area, -1 if not found.
  479.  *****************************************************************************/
  480. static S32 mmi_pen_simulator_in_stroke_area(S16 x, S16 y)
  481. {
  482.     /*----------------------------------------------------------------*/
  483.     /* Local Variables                                                */
  484.     /*----------------------------------------------------------------*/
  485.     int i;
  487.     /*----------------------------------------------------------------*/
  488.     /* Code Body                                                      */
  489.     /*----------------------------------------------------------------*/
  490.     if (g_pen_cntx.is_stroke_created &&
  491.         (g_pen_ext_stroke_area.x2 >= 0) && /* Test if the extended handwriting area is enabled */
  492.         x >= g_pen_ext_stroke_area.x1 && x <= g_pen_ext_stroke_area.x2 &&
  493.         y >= g_pen_ext_stroke_area.y1 && y <= g_pen_ext_stroke_area.y2)
  494.     {
  495.         return 0;
  496.     }
  498.     for (i = 0; i < g_pen_num_stroke_area; i++)
  499.     {
  500.         if (x >= g_pen_stroke_areas[i].x1 && x <= g_pen_stroke_areas[i].x2 &&
  501.             y >= g_pen_stroke_areas[i].y1 && y <= g_pen_stroke_areas[i].y2)
  502.         {
  503.             return i;
  504.         }
  505.     }
  506.     return -1;
  507. }
  510. /*****************************************************************************
  511.  * FUNCTION
  512.  *  mmi_pen_simulator_push_stroke_point
  513.  * DESCRIPTION
  514.  *  
  515.  * PARAMETERS
  516.  *  x       [IN]        
  517.  *  y       [IN]        
  518.  * RETURNS
  519.  *  void
  520.  *****************************************************************************/
  521. static void mmi_pen_simulator_push_stroke_point(S16 x, S16 y)
  522. {
  523.     /*----------------------------------------------------------------*/
  524.     /* Local Variables                                                */
  525.     /*----------------------------------------------------------------*/
  527.     /*----------------------------------------------------------------*/
  528.     /* Code Body                                                      */
  529.     /*----------------------------------------------------------------*/
  530.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points - 2)
  531.     {
  532.         return;
  533.     }
  534.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = x;
  535.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = y;
  536.     g_pen_cntx.num_points_queued++;
  537. }
  540. /*****************************************************************************
  541.  * FUNCTION
  542.  *  mmi_pen_simulator_push_stroke_end
  543.  * DESCRIPTION
  544.  *  
  545.  * PARAMETERS
  546.  *  void
  547.  * RETURNS
  548.  *  void
  549.  *****************************************************************************/
  550. static void mmi_pen_simulator_push_stroke_end(void)
  551. {
  552.     /*----------------------------------------------------------------*/
  553.     /* Local Variables                                                */
  554.     /*----------------------------------------------------------------*/
  556.     /*----------------------------------------------------------------*/
  557.     /* Code Body                                                      */
  558.     /*----------------------------------------------------------------*/
  559.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points - 1)
  560.     {
  561.         MMI_ASSERT(0);  /* queue full */
  562.         return;
  563.     }
  564. #if defined(__MMI_HANWANG__)
  565.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  566.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  567. #elif defined(__MMI_PENPOWER__)
  568.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  569.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  570. #else 
  571.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  572.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  573. #endif 
  574.     g_pen_cntx.num_points_queued++;
  575. }
  578. /*****************************************************************************
  579.  * FUNCTION
  580.  *  mmi_pen_simulator_push_char_end
  581.  * DESCRIPTION
  582.  *  
  583.  * PARAMETERS
  584.  *  void
  585.  * RETURNS
  586.  *  void
  587.  *****************************************************************************/
  588. static void mmi_pen_simulator_push_char_end(void)
  589. {
  590.     /*----------------------------------------------------------------*/
  591.     /* Local Variables                                                */
  592.     /*----------------------------------------------------------------*/
  594.     /*----------------------------------------------------------------*/
  595.     /* Code Body                                                      */
  596.     /*----------------------------------------------------------------*/
  597.     if (g_pen_cntx.num_points_queued >= g_pen_stroke_max_points)
  598.     {
  599.         MMI_ASSERT(0);  /* queue full */
  600.         return;
  601.     }
  602. #if defined(__MMI_HANWANG__)
  603.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  604.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  605. #elif defined(__MMI_PENPOWER__)
  606.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  607.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = 0;
  608. #else 
  609.     g_pen_stroke_points[g_pen_cntx.num_points_queued].x = -1;
  610.     g_pen_stroke_points[g_pen_cntx.num_points_queued].y = -1;
  611. #endif 
  612.     g_pen_cntx.num_points_queued++;
  613. }
  616. /*****************************************************************************
  617.  * FUNCTION
  618.  *  mmi_pen_simulator_repeat_hdlr
  619.  * DESCRIPTION
  620.  *  
  621.  * PARAMETERS
  622.  *  void
  623.  * RETURNS
  624.  *  void
  625.  *****************************************************************************/
  626. static void mmi_pen_simulator_repeat_hdlr(void)
  627. {
  628.     /*----------------------------------------------------------------*/
  629.     /* Local Variables                                                */
  630.     /*----------------------------------------------------------------*/
  632.     /*----------------------------------------------------------------*/
  633.     /* Code Body                                                      */
  634.     /*----------------------------------------------------------------*/
  635.     MMI_ASSERT(g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down);
  637.     if (g_pen_cntx.is_waiting_long_tap_event)
  638.     {
  639.         if (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP])
  640.         {
  641.             (g_pen_event_table[MMI_PEN_EVENT_LONG_TAP]) (g_pen_cntx.pen_down_pos);
  642.         }
  644.         g_pen_cntx.is_waiting_long_tap_event = 0;
  645.     }
  646.     else
  647.     {
  648.         if (g_pen_event_table[MMI_PEN_EVENT_REPEAT])
  649.         {
  650.             (g_pen_event_table[MMI_PEN_EVENT_REPEAT]) (g_pen_cntx.pen_repeat_origin_pos);
  651.         }
  652.     }
  654.     /* touch screen might be disabled/reset inside pen handler */
  655.     if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down)
  656.     {
  657.         gui_start_timer(MMI_PEN_REPEAT_TIME * 10, mmi_pen_simulator_repeat_hdlr);
  658.     }
  659. }
  662. /*****************************************************************************
  663.  * FUNCTION
  664.  *  mmi_pen_simulator_stroke_longtap_hdlr
  665.  * DESCRIPTION
  666.  *  
  667.  * PARAMETERS
  668.  *  void
  669.  * RETURNS
  670.  *  void
  671.  *****************************************************************************/
  672. static void mmi_pen_simulator_stroke_longtap_hdlr(void)
  673. {
  674.     /*----------------------------------------------------------------*/
  675.     /* Local Variables                                                */
  676.     /*----------------------------------------------------------------*/
  678.     /*----------------------------------------------------------------*/
  679.     /* Code Body                                                      */
  680.     /*----------------------------------------------------------------*/
  681.     MMI_ASSERT(g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down && g_pen_cntx.is_stroke_event);
  683.     g_pen_cntx.is_stroke_longtap_event_generated = 1;
  685.     if (g_pen_stroke_table[MMI_PEN_STROKE_LONGTAP])
  686.     {
  687.         (g_pen_stroke_table[MMI_PEN_STROKE_LONGTAP]) (g_pen_cntx.pen_current_pos);
  688.     }
  689. }
  692. /*****************************************************************************
  693.  * FUNCTION
  694.  *  mmi_pen_simulator_button_down_hdlr
  695.  * DESCRIPTION
  696.  *  
  697.  * PARAMETERS
  698.  *  x       [IN]        
  699.  *  y       [IN]        
  700.  * RETURNS
  701.  *  void
  702.  *****************************************************************************/
  703. void mmi_pen_simulator_button_down_hdlr(S16 x, S16 y)
  704. {
  705.     /*----------------------------------------------------------------*/
  706.     /* Local Variables                                                */
  707.     /*----------------------------------------------------------------*/
  708.     mmi_pen_point_struct pos;
  710.     /*----------------------------------------------------------------*/
  711.     /* Code Body                                                      */
  712.     /*----------------------------------------------------------------*/
  713.     if (!g_pen_cntx.is_enabled || g_pen_cntx.is_all_stroke_finished)
  714.     {
  715.         return;
  716.     }
  718.     MMI_DBG_ASSERT(!g_pen_cntx.is_pen_down);
  720.     mmi_pen_simulator_fix_point_bound(&x, &y, MMI_FALSE);
  721.     pos.x = x;
  722.     pos.y = y;
  723.     g_pen_cntx.pen_down_pos = g_pen_cntx.pen_current_pos = g_pen_cntx.pen_repeat_origin_pos = pos;
  724.     g_pen_cntx.is_pen_down = 1;
  725.     g_pen_cntx.is_stroke_event = 0;
  726.     g_pen_cntx.is_pending_stroke_event = 0;
  727.     g_pen_cntx.is_stroke_longtap_event_generated = 0;
  728.     /* Not reset is_stroke_created */
  729.     g_pen_cntx.is_waiting_long_tap_event = 0;
  731.     if ((g_pen_cntx.stroke_down_block_index = mmi_pen_simulator_in_stroke_area(x, y)) >= 0)
  732.     {
  733.         if (!g_pen_cntx.is_stroke_created && g_pen_stroke_min_offset > 0)
  734.         {
  735.             g_pen_cntx.is_pending_stroke_event = 1;
  737.             /* Fire pen down event. For example, it will display key down on virtual keyboard */
  738.             if (g_pen_event_table[MMI_PEN_EVENT_DOWN])
  739.             {
  740.                 (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (pos);
  741.             }
  742.         }
  743.         else
  744.         {
  745.             if (!g_pen_cntx.is_stroke_created) /* StrokeLongTap is used in the first stroke only */
  746.             {
  747.                 gui_start_timer(MMI_PEN_STROKE_LONGTAP_TIME * 10, mmi_pen_simulator_stroke_longtap_hdlr);
  748.             }
  749.             
  750.             g_pen_cntx.is_stroke_event = 1;
  751.             g_pen_cntx.is_stroke_created = 1;
  753.             if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN])
  754.             {
  755.                 (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (pos);
  756.             }
  758.             /* Put stroke point after stroke down handler because multi-block handwriting may invoke
  759.              * mmi_pen_begin_strokes_of_character() and mmi_pen_end_strokes_of_character() in 
  760.              * Stroke Down handler.
  761.              */
  762.             if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down && g_pen_stroke_max_points > 0)
  763.             {
  764.                 mmi_pen_simulator_push_stroke_point(x, y);
  765.             }
  766.         }
  767.     }
  768.     else
  769.     {
  771.         /* Note that Pen Down handler might call mmi_pen_reset() */
  772.         if (g_pen_event_table[MMI_PEN_EVENT_DOWN])
  773.         {
  774.             (g_pen_event_table[MMI_PEN_EVENT_DOWN]) (pos);
  775.         }
  777.         /* touch screen might be disabled inside pen handler */
  778.         if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down)
  779.         {
  780.             g_pen_cntx.is_waiting_long_tap_event = 1;
  781.             gui_start_timer(MMI_PEN_REPEAT_TIME * 10, mmi_pen_simulator_repeat_hdlr);
  782.         }
  783.     }
  784. }
  787. /*****************************************************************************
  788.  * FUNCTION
  789.  *  mmi_pen_simulator_button_move_hdlr
  790.  * DESCRIPTION
  791.  *  
  792.  * PARAMETERS
  793.  *  x       [IN]        
  794.  *  y       [IN]        
  795.  * RETURNS
  796.  *  void
  797.  *****************************************************************************/
  798. void mmi_pen_simulator_button_move_hdlr(S16 x, S16 y)
  799. {
  800.     /*----------------------------------------------------------------*/
  801.     /* Local Variables                                                */
  802.     /*----------------------------------------------------------------*/
  803.     mmi_pen_point_struct pos;
  804.     BOOL restart_repeat_timer = MMI_FALSE;
  806.     /*----------------------------------------------------------------*/
  807.     /* Code Body                                                      */
  808.     /*----------------------------------------------------------------*/
  809.     if (!g_pen_cntx.is_enabled || !g_pen_cntx.is_pen_down)
  810.     {
  811.         return;
  812.     }
  814.     mmi_pen_simulator_fix_point_bound(&x, &y, g_pen_cntx.is_stroke_event && (g_pen_num_stroke_area > 1));
  815.     pos.x = x;
  816.     pos.y = y;
  817.     g_pen_cntx.pen_current_pos = pos;
  819.     if (g_pen_cntx.is_pending_stroke_event)
  820.     {
  821.         if (mmi_pen_simulator_pixel_diff(pos, g_pen_cntx.pen_down_pos) > g_pen_stroke_min_offset)
  822.         {
  823.             g_pen_cntx.is_pending_stroke_event = 0;
  824.             g_pen_cntx.is_stroke_event = 1;
  825.             g_pen_cntx.is_stroke_created = 1;
  827.             /* Abort previous pen down event */
  828.             if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  829.             {
  830.                 (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (pos);
  831.             }
  833.             mmi_pen_simulator_push_stroke_point(g_pen_cntx.pen_down_pos.x, g_pen_cntx.pen_down_pos.y);
  834.             mmi_pen_simulator_push_stroke_point(x, y);
  836.             if (g_pen_stroke_table[MMI_PEN_STROKE_DOWN])
  837.             {
  838.                 (g_pen_stroke_table[MMI_PEN_STROKE_DOWN]) (g_pen_cntx.pen_down_pos);
  839.             }
  841.             if (g_pen_stroke_pre_move)
  842.             {
  843.                 g_pen_stroke_pre_move();
  844.             }
  846.             if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE])
  847.             {
  848.                 (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
  849.             }
  851.             if (g_pen_stroke_post_move)
  852.             {
  853.                 g_pen_stroke_post_move();
  854.             }
  856.         }
  857.         /* Otherwise, ignore the move event */
  858.     }
  859.     else if (g_pen_cntx.is_stroke_event)
  860.     {
  861.         if (g_pen_stroke_pre_move)
  862.         {
  863.             g_pen_stroke_pre_move();
  864.         }
  866.         if (g_pen_stroke_table[MMI_PEN_STROKE_MOVE])
  867.         {
  868.             (g_pen_stroke_table[MMI_PEN_STROKE_MOVE]) (pos);
  869.         }
  871.         if (g_pen_stroke_post_move)
  872.         {
  873.             g_pen_stroke_post_move();
  874.         }
  876.         mmi_pen_simulator_push_stroke_point(x, y);
  878.         if (mmi_pen_simulator_pixel_diff(pos, g_pen_cntx.pen_down_pos) > MMI_PEN_SKIP_STROKE_LONGTAP_OFFSET)
  879.         {
  880.             gui_cancel_timer(mmi_pen_simulator_stroke_longtap_hdlr);
  881.         }
  882.     }
  883.     else
  884.     {
  885.         if (g_pen_event_table[MMI_PEN_EVENT_MOVE])
  886.         {
  887.             (g_pen_event_table[MMI_PEN_EVENT_MOVE]) (pos);
  888.         }
  890.         if (mmi_pen_simulator_pixel_diff(pos, g_pen_cntx.pen_repeat_origin_pos) > MMI_PEN_SKIP_LONGTAP_OFFSET)
  891.         {
  892.             g_pen_cntx.is_waiting_long_tap_event = 0;   /* Wait Pen Repeat because Pen LongTap only happens at the pen down position */
  893.             g_pen_cntx.pen_repeat_origin_pos = pos;
  894.             gui_cancel_timer(mmi_pen_simulator_repeat_hdlr);
  895.             if (g_pen_cntx.is_enabled && g_pen_cntx.is_pen_down)
  896.             {
  897.                 gui_start_timer(MMI_PEN_REPEAT_TIME * 10, mmi_pen_simulator_repeat_hdlr);
  898.             }
  899.         }
  900.     }
  901. }
  904. /*****************************************************************************
  905.  * FUNCTION
  906.  *  mmi_pen_simulator_button_up_hdlr
  907.  * DESCRIPTION
  908.  *  
  909.  * PARAMETERS
  910.  *  x       [IN]        
  911.  *  y       [IN]        
  912.  * RETURNS
  913.  *  void
  914.  *****************************************************************************/
  915. void mmi_pen_simulator_button_up_hdlr(S16 x, S16 y)
  916. {
  917.     /*----------------------------------------------------------------*/
  918.     /* Local Variables                                                */
  919.     /*----------------------------------------------------------------*/
  920.     mmi_pen_point_struct pos;
  922.     /*----------------------------------------------------------------*/
  923.     /* Code Body                                                      */
  924.     /*----------------------------------------------------------------*/
  925.     if (!g_pen_cntx.is_enabled || !g_pen_cntx.is_pen_down)
  926.     {
  927.         return;
  928.     }
  930.     mmi_pen_simulator_fix_point_bound(&x, &y, g_pen_cntx.is_stroke_event && (g_pen_num_stroke_area > 1));
  931.     pos.x = x;
  932.     pos.y = y;
  933.     g_pen_cntx.pen_current_pos = pos;
  934.     g_pen_cntx.is_pen_down = 0;
  936.     if (g_pen_cntx.is_pending_stroke_event)
  937.     {
  938.         if (g_pen_event_table[MMI_PEN_EVENT_UP])
  939.         {
  940.             (g_pen_event_table[MMI_PEN_EVENT_UP]) (g_pen_cntx.pen_down_pos);
  941.         }
  942.     }
  943.     else if (g_pen_cntx.is_stroke_event)
  944.     {
  945.         if (g_pen_stroke_table[MMI_PEN_STROKE_UP])
  946.         {
  947.             (g_pen_stroke_table[MMI_PEN_STROKE_UP]) (pos);
  948.         }
  949.         mmi_pen_simulator_push_stroke_point(x, y);
  950.         mmi_pen_simulator_push_stroke_end();
  952.         gui_cancel_timer(mmi_pen_simulator_stroke_longtap_hdlr);
  953.         if (g_pen_cntx.is_stroke_longtap_event_generated)
  954.         {
  955.             /* Clear strokes */
  956.             mmi_pen_end_strokes_of_character();
  957.             mmi_pen_begin_strokes_of_character();
  958.         }
  959.     }
  960.     else
  961.     {
  962.         gui_cancel_timer(mmi_pen_simulator_repeat_hdlr);
  964.         if (g_pen_event_table[MMI_PEN_EVENT_UP])
  965.         {
  966.             (g_pen_event_table[MMI_PEN_EVENT_UP]) (pos);
  967.         }
  968.     }
  970.     if (g_pen_cntx.reset_stroke_on_pen_up)
  971.     {
  972.         if (g_pen_stroke_max_points > 0)
  973.         {
  974.             mmi_pen_end_strokes_of_character();
  975.             mmi_pen_reset();
  976.             mmi_pen_begin_strokes_of_character();
  977.         }
  978.         else
  979.         {
  980.             mmi_pen_reset();
  981.         }
  982.     }
  983. }
  985. /***************************************************************************** 
  986. * Global Variable
  987. *****************************************************************************/
  989. /***************************************************************************** 
  990. * Global Function
  991. *****************************************************************************/
  993. /* Dummy pen handler */
  996. /*****************************************************************************
  997.  * FUNCTION
  998.  *  mmi_pen_dummy_hdlr
  999.  * DESCRIPTION
  1000.  *  
  1001.  * PARAMETERS
  1002.  *  pos     [IN]        
  1003.  * RETURNS
  1004.  *  void
  1005.  *****************************************************************************/
  1006. void mmi_pen_dummy_hdlr(mmi_pen_point_struct pos)
  1007. {
  1008.     /*----------------------------------------------------------------*/
  1009.     /* Local Variables                                                */
  1010.     /*----------------------------------------------------------------*/
  1012.     /*----------------------------------------------------------------*/
  1013.     /* Code Body                                                      */
  1014.     /*----------------------------------------------------------------*/
  1015.     UI_UNUSED_PARAMETER(pos);
  1016. }
  1019. /*****************************************************************************
  1020.  * FUNCTION
  1021.  *  mmi_pen_config_sampling_period
  1022.  * DESCRIPTION
  1023.  *  
  1024.  * PARAMETERS
  1025.  *  low         [IN]        
  1026.  *  high        [IN]        
  1027.  * RETURNS
  1028.  *  void
  1029.  *****************************************************************************/
  1030. void mmi_pen_config_sampling_period(kal_uint32 low, kal_uint32 high)
  1031. {
  1032.     /*----------------------------------------------------------------*/
  1033.     /* Local Variables                                                */
  1034.     /*----------------------------------------------------------------*/
  1036.     /*----------------------------------------------------------------*/
  1037.     /* Code Body                                                      */
  1038.     /*----------------------------------------------------------------*/
  1039.     /* DUMMY */
  1040. }
  1043. /*****************************************************************************
  1044.  * FUNCTION
  1045.  *  mmi_pen_config_timeout_period
  1046.  * DESCRIPTION
  1047.  *  
  1048.  * PARAMETERS
  1049.  *  longtap             [IN]        
  1050.  *  repeat              [IN]        
  1051.  *  stroke_longtap      [IN]        
  1052.  * RETURNS
  1053.  *  void
  1054.  *****************************************************************************/
  1055. void mmi_pen_config_timeout_period(kal_uint32 longtap, kal_uint32 repeat, kal_uint32 stroke_longtap)
  1056. {
  1057.     /*----------------------------------------------------------------*/
  1058.     /* Local Variables                                                */
  1059.     /*----------------------------------------------------------------*/
  1061.     /*----------------------------------------------------------------*/
  1062.     /* Code Body                                                      */
  1063.     /*----------------------------------------------------------------*/
  1064.     /* DUMMY */
  1065. }
  1068. /*****************************************************************************
  1069.  * FUNCTION
  1070.  *  mmi_pen_config_move_offset
  1071.  * DESCRIPTION
  1072.  *  
  1073.  * PARAMETERS
  1074.  *  event_based         [IN]        
  1075.  *  stroke_based        [IN]        
  1076.  *  long_tap            [IN]        
  1077.  *  stroke_long_tap     [IN]        
  1078.  * RETURNS
  1079.  *  void
  1080.  *****************************************************************************/
  1081. void mmi_pen_config_move_offset(
  1082.         kal_uint32 event_based,
  1083.         kal_uint32 stroke_based,
  1084.         kal_uint32 long_tap,
  1085.         kal_uint32 stroke_long_tap)
  1086. {
  1087.     /*----------------------------------------------------------------*/
  1088.     /* Local Variables                                                */
  1089.     /*----------------------------------------------------------------*/
  1091.     /*----------------------------------------------------------------*/
  1092.     /* Code Body                                                      */
  1093.     /*----------------------------------------------------------------*/
  1094.     /* DUMMY */
  1095. }
  1098. /*****************************************************************************
  1099.  * FUNCTION
  1100.  *  mmi_pen_init
  1101.  * DESCRIPTION
  1102.  *  Initialize pen system
  1103.  * PARAMETERS
  1104.  *  void
  1105.  * RETURNS
  1106.  *  void
  1107.  *****************************************************************************/
  1108. void mmi_pen_init(void)
  1109. {
  1110.     /*----------------------------------------------------------------*/
  1111.     /* Local Variables                                                */
  1112.     /*----------------------------------------------------------------*/
  1114.     /*----------------------------------------------------------------*/
  1115.     /* Code Body                                                      */
  1116.     /*----------------------------------------------------------------*/
  1117. #ifdef __MMI_HANDWRITING_PAD__
  1118.     mmi_frm_setup_default_pen_handler();
  1119. #endif 
  1120. #if !defined(MMI_ON_WIN32)
  1121.     SetProtocolEventHandler(mmi_pen_MODIS_tp_ind, MSG_ID_TP_EVENT_IND);
  1122. #endif
  1123. }
  1126. /*****************************************************************************
  1127.  * FUNCTION
  1128.  *  mmi_pen_block
  1129.  * DESCRIPTION
  1130.  *  Block pen system
  1131.  *  
  1132.  *  Note: typically used for keypad lock in idle screen
  1133.  * PARAMETERS
  1134.  *  void
  1135.  * RETURNS
  1136.  *  void
  1137.  *****************************************************************************/
  1138. void mmi_pen_block(void)
  1139. {
  1140.     /*----------------------------------------------------------------*/
  1141.     /* Local Variables                                                */
  1142.     /*----------------------------------------------------------------*/
  1144.     /*----------------------------------------------------------------*/
  1145.     /* Code Body                                                      */
  1146.     /*----------------------------------------------------------------*/
  1147.     mmi_pen_disable();
  1148.     g_pen_cntx.is_blocked = 1;
  1149. }
  1152. /*****************************************************************************
  1153.  * FUNCTION
  1154.  *  mmi_pen_unblock
  1155.  * DESCRIPTION
  1156.  *  Unblock pen system
  1157.  *  
  1158.  *  Note: typically used for keypad lock in idle screen
  1159.  * PARAMETERS
  1160.  *  void
  1161.  * RETURNS
  1162.  *  void
  1163.  *****************************************************************************/
  1164. void mmi_pen_unblock(void)
  1165. {
  1166.     /*----------------------------------------------------------------*/
  1167.     /* Local Variables                                                */
  1168.     /*----------------------------------------------------------------*/
  1170.     /*----------------------------------------------------------------*/
  1171.     /* Code Body                                                      */
  1172.     /*----------------------------------------------------------------*/
  1173.     g_pen_cntx.is_blocked = 0;
  1174.     mmi_pen_enable();
  1175. }
  1178. /*****************************************************************************
  1179.  * FUNCTION
  1180.  *  mmi_pen_enable
  1181.  * DESCRIPTION
  1182.  *  Enable pen system
  1183.  *  
  1184.  *  Note: typically on Keypad Up
  1185.  * PARAMETERS
  1186.  *  void
  1187.  * RETURNS
  1188.  *  void
  1189.  *****************************************************************************/
  1190. void mmi_pen_enable(void)
  1191. {
  1192.     /*----------------------------------------------------------------*/
  1193.     /* Local Variables                                                */
  1194.     /*----------------------------------------------------------------*/
  1196.     /*----------------------------------------------------------------*/
  1197.     /* Code Body                                                      */
  1198.     /*----------------------------------------------------------------*/
  1199.     if (g_pen_cntx.is_blocked || g_pen_cntx.is_enabled)
  1200.     {
  1201.         return;
  1202.     }
  1204.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  1205.     g_pen_cntx.is_enabled = 1;
  1207. #if !defined(MMI_ON_WIN32)
  1208.     mmi_pen_MODIS_start_timer();
  1209. #endif 
  1210. }
  1213. /*****************************************************************************
  1214.  * FUNCTION
  1215.  *  mmi_pen_disable
  1216.  * DESCRIPTION
  1217.  *  Disable pen system
  1218.  *  
  1219.  *  Note: typically on Keypad Down because we don't want to use keypad and touch screen
  1220.  *  at the same time
  1221.  * PARAMETERS
  1222.  *  void
  1223.  * RETURNS
  1224.  *  void
  1225.  *****************************************************************************/
  1226. void mmi_pen_disable(void)
  1227. {
  1228.     /*----------------------------------------------------------------*/
  1229.     /* Local Variables                                                */
  1230.     /*----------------------------------------------------------------*/
  1232.     /*----------------------------------------------------------------*/
  1233.     /* Code Body                                                      */
  1234.     /*----------------------------------------------------------------*/
  1235.     if (g_pen_cntx.is_blocked || !g_pen_cntx.is_enabled)
  1236.     {
  1237.         return;
  1238.     }
  1240.     gui_cancel_timer(mmi_pen_simulator_repeat_hdlr);
  1242.     if (g_pen_cntx.is_pen_down)
  1243.     {
  1244.         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  1245.         {
  1246.             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_current_pos);
  1247.         }
  1248.     }
  1250.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  1252. #if !defined(MMI_ON_WIN32)
  1253.     mmi_pen_MODIS_flush_queue();
  1254. #endif 
  1255. }
  1258. /*****************************************************************************
  1259.  * FUNCTION
  1260.  *  mmi_pen_reset
  1261.  * DESCRIPTION
  1262.  *  Reset the status of touch screen
  1263.  *  - Flush event queue
  1264.  *  - If the pen is currently tapped down, ignore all subsequent pen events until the pen is up.
  1265.  *  
  1266.  *  Note: typically on MMI screen switching
  1267.  * PARAMETERS
  1268.  *  void
  1269.  * RETURNS
  1270.  *  void
  1271.  *****************************************************************************/
  1272. void mmi_pen_reset(void)
  1273. {
  1274.     /*----------------------------------------------------------------*/
  1275.     /* Local Variables                                                */
  1276.     /*----------------------------------------------------------------*/
  1278.     /*----------------------------------------------------------------*/
  1279.     /* Code Body                                                      */
  1280.     /*----------------------------------------------------------------*/
  1281.     if (g_pen_cntx.is_blocked || !g_pen_cntx.is_enabled)
  1282.     {
  1283.         return;
  1284.     }
  1286.     gui_cancel_timer(mmi_pen_simulator_repeat_hdlr);
  1288.     if (g_pen_cntx.is_pen_down)
  1289.     {
  1290.         gui_cancel_timer(mmi_pen_simulator_repeat_hdlr);
  1292.         if (g_pen_event_table[MMI_PEN_EVENT_ABORT])
  1293.         {
  1294.             (g_pen_event_table[MMI_PEN_EVENT_ABORT]) (g_pen_cntx.pen_current_pos);
  1295.         }
  1296.     }
  1298.     memset(&g_pen_cntx, 0, sizeof(g_pen_cntx));
  1299.     g_pen_cntx.is_enabled = 1;
  1301. #if !defined(MMI_ON_WIN32)
  1302.     mmi_pen_MODIS_flush_queue();
  1303. #endif 
  1304. }
  1307. /*****************************************************************************
  1308.  * FUNCTION
  1309.  *  mmi_pen_get_state
  1310.  * DESCRIPTION
  1311.  *  Get the current state of touch screen
  1312.  * PARAMETERS
  1313.  *  is_enabled      [OUT]         
  1314.  *  is_pen_down     [OUT]         
  1315.  * RETURNS
  1316.  *  void
  1317.  *****************************************************************************/
  1318. void mmi_pen_get_state(kal_bool *is_enabled, kal_bool *is_pen_down)
  1319. {
  1320.     /*----------------------------------------------------------------*/
  1321.     /* Local Variables                                                */
  1322.     /*----------------------------------------------------------------*/
  1324.     /*----------------------------------------------------------------*/
  1325.     /* Code Body                                                      */
  1326.     /*----------------------------------------------------------------*/
  1327.     if (g_pen_cntx.is_enabled)
  1328.     {
  1329.         *is_enabled = KAL_TRUE;
  1330.         if (g_pen_cntx.is_pen_down)
  1331.         {
  1332.             *is_pen_down = KAL_TRUE;
  1333.         }
  1334.         else
  1335.         {
  1336.             *is_pen_down = KAL_FALSE;
  1337.         }
  1338.     }
  1339.     else
  1340.     {
  1341.         *is_enabled = KAL_FALSE;
  1342.         *is_pen_down = KAL_FALSE;
  1343.     }
  1344. }
  1347. /*****************************************************************************
  1348.  * FUNCTION
  1349.  *  mmi_pen_start_calibration
  1350.  * DESCRIPTION
  1351.  *  Start pen calibration
  1352.  * PARAMETERS
  1353.  *  num         [IN]        Number of calibration points
  1354.  *  points      [IN]        Calibration points
  1355.  * RETURNS
  1356.  *  void
  1357.  * REMARKS
  1358.  *  After mmi_pen_reset(), the calibration process is terminated.
  1359.  *****************************************************************************/
  1360. void mmi_pen_start_calibration(kal_uint16 num, const mmi_pen_point_struct *points)
  1361. {
  1362.     /*----------------------------------------------------------------*/
  1363.     /* Local Variables                                                */
  1364.     /*----------------------------------------------------------------*/
  1366.     /*----------------------------------------------------------------*/
  1367.     /* Code Body                                                      */
  1368.     /*----------------------------------------------------------------*/
  1369.     /* DUMMY */
  1370. }
  1373. /*****************************************************************************
  1374.  * FUNCTION
  1375.  *  mmi_pen_set_calibration_data
  1376.  * DESCRIPTION
  1377.  *  Assign driver calibration data
  1378.  * PARAMETERS
  1379.  *  data        [IN]        
  1380.  * RETURNS
  1381.  *  void
  1382.  * REMARKS
  1383.  *  
  1384.  *****************************************************************************/
  1385. void mmi_pen_set_calibration_data(const mmi_pen_calibration_struct *data)
  1386. {
  1387.     /*----------------------------------------------------------------*/
  1388.     /* Local Variables                                                */
  1389.     /*----------------------------------------------------------------*/
  1391.     /*----------------------------------------------------------------*/
  1392.     /* Code Body                                                      */
  1393.     /*----------------------------------------------------------------*/
  1394.     /* DUMMY */
  1395. }
  1398. /*****************************************************************************
  1399.  * FUNCTION
  1400.  *  mmi_pen_read_calibration_data
  1401.  * DESCRIPTION
  1402.  *  Read the current value of driver calibration data
  1403.  * PARAMETERS
  1404.  *  data        [OUT]       
  1405.  * RETURNS
  1406.  *  void
  1407.  * REMARKS
  1408.  *  
  1409.  *****************************************************************************/
  1410. void mmi_pen_read_calibration_data(mmi_pen_calibration_struct *data)
  1411. {
  1412.     /*----------------------------------------------------------------*/
  1413.     /* Local Variables                                                */
  1414.     /*----------------------------------------------------------------*/
  1416.     /*----------------------------------------------------------------*/
  1417.     /* Code Body                                                      */
  1418.     /*----------------------------------------------------------------*/
  1419.     /* DUMMY */
  1420. }
  1423. /*****************************************************************************
  1424.  * FUNCTION
  1425.  *  mmi_pen_register_down_handler
  1426.  * DESCRIPTION
  1427.  *  Register the Pen Down handler
  1428.  * PARAMETERS
  1429.  *  pen_fp      [IN]        Callback handler
  1430.  * RETURNS
  1431.  *  void
  1432.  *****************************************************************************/
  1433. void mmi_pen_register_down_handler(mmi_pen_hdlr pen_fp)
  1434. {
  1435.     /*----------------------------------------------------------------*/
  1436.     /* Local Variables                                                */
  1437.     /*----------------------------------------------------------------*/
  1439.     /*----------------------------------------------------------------*/
  1440.     /* Code Body                                                      */
  1441.     /*----------------------------------------------------------------*/
  1442.     g_pen_event_table[MMI_PEN_EVENT_DOWN] = pen_fp;
  1443. }
  1446. /*****************************************************************************
  1447.  * FUNCTION
  1448.  *  mmi_pen_register_long_tap_handler
  1449.  * DESCRIPTION
  1450.  *  Register the Pen LongTap handler
  1451.  *  
  1452.  *  LongTap handler is invoked when  the pen is tapped for a period of time
  1453.  *  and stays at the same place where it is tapped down.
  1454.  *  
  1455.  *  It is invoked atmost one time before pen up.
  1456.  * PARAMETERS
  1457.  *  pen_fp      [IN]        Callback handler
  1458.  * RETURNS
  1459.  *  void
  1460.  *****************************************************************************/
  1461. void mmi_pen_register_long_tap_handler(mmi_pen_hdlr pen_fp)
  1462. {
  1463.     /*----------------------------------------------------------------*/
  1464.     /* Local Variables                                                */
  1465.     /*----------------------------------------------------------------*/
  1467.     /*----------------------------------------------------------------*/
  1468.     /* Code Body                                                      */
  1469.     /*----------------------------------------------------------------*/
  1470.     g_pen_event_table[MMI_PEN_EVENT_LONG_TAP] = pen_fp;
  1471. }
  1474. /*****************************************************************************
  1475.  * FUNCTION
  1476.  *  mmi_pen_register_repeat_handler
  1477.  * DESCRIPTION
  1478.  *  Register the Pen Repeat handler.
  1479.  *  
  1480.  *  Repeat handler is invoked after LongTap handler.
  1481.  *  However, unlike LongTap handler, Repeat handler is invoked even if
  1482.  *  it does not stays at the same place as Pen Down.
  1483.  *  
  1484.  *  it might be invoked more than one times before pen up.
  1485.  * PARAMETERS
  1486.  *  pen_fp      [IN]        Callback handler
  1487.  * RETURNS
  1488.  *  void
  1489.  *****************************************************************************/
  1490. void mmi_pen_register_repeat_handler(mmi_pen_hdlr pen_fp)
  1491. {
  1492.     /*----------------------------------------------------------------*/
  1493.     /* Local Variables                                                */
  1494.     /*----------------------------------------------------------------*/
  1496.     /*----------------------------------------------------------------*/
  1497.     /* Code Body                                                      */
  1498.     /*----------------------------------------------------------------*/
  1499.     g_pen_event_table[MMI_PEN_EVENT_REPEAT] = pen_fp;
  1500. }
  1503. /*****************************************************************************
  1504.  * FUNCTION
  1505.  *  mmi_pen_register_move_handler
  1506.  * DESCRIPTION
  1507.  *  Register the Pen Move handler.
  1508.  *  
  1509.  *  The invocation frequency of Pen Move handler is typically less than driver sampling rate.
  1510.  * PARAMETERS
  1511.  *  pen_fp      [IN]        Callback handler
  1512.  * RETURNS
  1513.  *  void
  1514.  *****************************************************************************/
  1515. void mmi_pen_register_move_handler(mmi_pen_hdlr pen_fp)
  1516. {
  1517.     /*----------------------------------------------------------------*/
  1518.     /* Local Variables                                                */
  1519.     /*----------------------------------------------------------------*/
  1521.     /*----------------------------------------------------------------*/
  1522.     /* Code Body                                                      */
  1523.     /*----------------------------------------------------------------*/
  1524.     g_pen_event_table[MMI_PEN_EVENT_MOVE] = pen_fp;
  1525. }
  1528. /*****************************************************************************
  1529.  * FUNCTION
  1530.  *  mmi_pen_register_up_handler
  1531.  * DESCRIPTION
  1532.  *  Register the Pen Up handler.
  1533.  * PARAMETERS
  1534.  *  pen_fp      [IN]        
  1535.  * RETURNS
  1536.  *  void
  1537.  *****************************************************************************/
  1538. void mmi_pen_register_up_handler(mmi_pen_hdlr pen_fp)
  1539. {
  1540.     /*----------------------------------------------------------------*/
  1541.     /* Local Variables                                                */
  1542.     /*----------------------------------------------------------------*/
  1544.     /*----------------------------------------------------------------*/
  1545.     /* Code Body                                                      */
  1546.     /*----------------------------------------------------------------*/
  1547.     g_pen_event_table[MMI_PEN_EVENT_UP] = pen_fp;
  1548. }
  1551. /*****************************************************************************
  1552.  * FUNCTION
  1553.  *  mmi_pen_register_abort_handler
  1554.  * DESCRIPTION
  1555.  *  Register the Pen Abort handler.
  1556.  * PARAMETERS
  1557.  *  pen_fp      [IN]        
  1558.  * RETURNS
  1559.  *  void
  1560.  *****************************************************************************/
  1561. void mmi_pen_register_abort_handler(mmi_pen_hdlr pen_fp)
  1562. {
  1563.     /*----------------------------------------------------------------*/
  1564.     /* Local Variables                                                */
  1565.     /*----------------------------------------------------------------*/
  1567.     /*----------------------------------------------------------------*/
  1568.     /* Code Body                                                      */
  1569.     /*----------------------------------------------------------------*/
  1570.     g_pen_event_table[MMI_PEN_EVENT_ABORT] = pen_fp;
  1571. }
  1574. /*****************************************************************************
  1575.  * FUNCTION
  1576.  *  mmi_pen_start_capture_strokes
  1577.  * DESCRIPTION
  1578.  *  Win32 port of mmi_pen_start_capture_strokes
  1579.  * PARAMETERS
  1580.  *  max_points          [IN]        Maximum number of points can be en-queued.
  1581.  *  point_array         [IN]        Array for storing sampled points in strokes.
  1582.  *  num_regions         [IN]        Number of handwriting regions
  1583.  *  region_array        [IN]        Handwriting regions
  1584.  *  ext_region          [IN]        Handwriting region after the first stroke is generated. (NULL to ignore it)
  1585.  * RETURNS
  1586.  *  void
  1587.  *****************************************************************************/
  1588. void mmi_pen_start_capture_strokes(
  1589.         kal_uint32 max_points,
  1590.         mmi_pen_point_struct *point_array,
  1591.         kal_uint32 num_regions,
  1592.         const mmi_pen_handwriting_area_struct *region_array,
  1593.         const mmi_pen_handwriting_area_struct *ext_region)
  1594. {
  1595.     /*----------------------------------------------------------------*/
  1596.     /* Local Variables                                                */
  1597.     /*----------------------------------------------------------------*/
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Code Body                                                      */
  1601.     /*----------------------------------------------------------------*/
  1602.     /* Multi-block mode does not have extended region. Otherwise, it cannot switch to another 
  1603.        block and multi-block feature is broken. */
  1604.     MMI_ASSERT(ext_region == NULL || num_regions == 1);
  1605.     
  1606.     if (num_regions > MMI_PEN_MAX_HANDWRITING_REGION)
  1607.     {
  1608.         num_regions = MMI_PEN_MAX_HANDWRITING_REGION;
  1609.     }
  1610.     
  1611.     g_pen_num_stroke_area = num_regions;
  1612.     memcpy(g_pen_stroke_areas, region_array, sizeof(mmi_pen_handwriting_area_struct) * num_regions);
  1614.     if (ext_region)
  1615.     {
  1616.         g_pen_ext_stroke_area = *ext_region;
  1617.     }
  1618.     else
  1619.     {
  1620.         g_pen_ext_stroke_area.x1 = -1;
  1621.         g_pen_ext_stroke_area.x2 = -1;
  1622.         g_pen_ext_stroke_area.y1 = -1;
  1623.         g_pen_ext_stroke_area.y2 = -1;
  1624.     }
  1626.     if (num_regions == 1)
  1627.     {
  1628.         g_pen_stroke_min_offset = MMI_PEN_STROKE_MIN_OFFSET;
  1629.     }
  1630.     else
  1631.     {
  1632.         g_pen_stroke_min_offset = 0;
  1633.     }
  1635.     g_pen_stroke_max_points = max_points;
  1636.     g_pen_stroke_points = point_array;
  1637. }
  1640. /*****************************************************************************
  1641.  * FUNCTION
  1642.  *  mmi_pen_change_handwriting_area
  1643.  * DESCRIPTION
  1644.  *  Win32 port of mmi_pen_change_handwriting_area
  1645.  * PARAMETERS
  1646.  *  num_regions         [IN]        Number of handwriting regions
  1647.  *  region_array        [IN]        Handwriting regions
  1648.  *  ext_region          [IN]        Handwriting region after the first stroke is generated. (NULL to ignore it)
  1649.  * RETURNS
  1650.  *  void
  1651.  *****************************************************************************/
  1652. void mmi_pen_change_handwriting_area(
  1653.         kal_uint32 num_regions,
  1654.         const mmi_pen_handwriting_area_struct *region_array,
  1655.         const mmi_pen_handwriting_area_struct *ext_region)
  1656. {
  1657.     /*----------------------------------------------------------------*/
  1658.     /* Local Variables                                                */
  1659.     /*----------------------------------------------------------------*/
  1661.     /*----------------------------------------------------------------*/
  1662.     /* Code Body                                                      */
  1663.     /*----------------------------------------------------------------*/
  1664.     if (g_pen_stroke_max_points == 0) /* Handwriting is not enabled */
  1665.     {
  1666.         /* MMI_DBG_ASSERT(0); */
  1667.         return;
  1668.     }
  1670.     /* Multi-block mode does not have extended region */
  1671.     MMI_ASSERT(ext_region == NULL || num_regions == 1);
  1672.     
  1673.     if (num_regions > MMI_PEN_MAX_HANDWRITING_REGION)
  1674.     {
  1675.         num_regions = MMI_PEN_MAX_HANDWRITING_REGION;
  1676.     }
  1678.     g_pen_num_stroke_area = num_regions;
  1679.     memcpy(g_pen_stroke_areas, region_array, sizeof(mmi_pen_handwriting_area_struct) * num_regions);
  1681.     if (ext_region)
  1682.     {
  1683.         g_pen_ext_stroke_area = *ext_region;
  1684.     }
  1685.     else
  1686.     {
  1687.         g_pen_ext_stroke_area.x1 = -1;
  1688.         g_pen_ext_stroke_area.x2 = -1;
  1689.         g_pen_ext_stroke_area.y1 = -1;
  1690.         g_pen_ext_stroke_area.y2 = -1;
  1691.     }
  1693.     if (num_regions == 1)
  1694.     {
  1695.         g_pen_stroke_min_offset = MMI_PEN_STROKE_MIN_OFFSET;
  1696.     }
  1697.     else
  1698.     {
  1699.         g_pen_stroke_min_offset = 0;
  1700.     }
  1702.     /* 
  1703.      * We will call mmi_pen_reset() *later* on Pen Up or Stroke Up event.
  1704.      *
  1705.      * There might be many pending events in driver queue if MMI task is blocked by 
  1706.      * other time-consuming jobs. If there are pending stroke events in driver queue, 
  1707.      * it is better to flush driver queue.
  1708.      *
  1709.      */
  1710.     if (!g_pen_cntx.is_pen_down)
  1711.     {
  1712.         /* Clear strokes */
  1713.         mmi_pen_end_strokes_of_character();
  1714.         mmi_pen_reset();
  1715.         mmi_pen_begin_strokes_of_character();
  1716.     }
  1717.     else
  1718.     {
  1719.         /* 
  1720.          * NOTE: we *cannot* call mmi_pen_reset().
  1721.          *
  1722.          * For example, assume mmi_pen_change_handwriting_area() is invoked on Button Down.
  1723.          * If we invoke mmi_pen_reset() here, it will send MMI_PEN_EVENT_ABORT and reset the button.
  1724.          */
  1725.         g_pen_cntx.reset_stroke_on_pen_up = 1;
  1726.     }
  1727. }
  1730. /*****************************************************************************
  1731.  * FUNCTION
  1732.  *  mmi_pen_stop_capture_strokes
  1733.  * DESCRIPTION
  1734.  *  Stop capturing stroke
  1735.  *  
  1736.  *  Note: it should be used before mmi_pen_reset() because it does not flush driver pen queue
  1737.  * PARAMETERS
  1738.  *  void
  1739.  * RETURNS
  1740.  *  void
  1741.  *****************************************************************************/
  1742. void mmi_pen_stop_capture_strokes(void)
  1743. {
  1744.     /*----------------------------------------------------------------*/
  1745.     /* Local Variables                                                */
  1746.     /*----------------------------------------------------------------*/
  1748.     /*----------------------------------------------------------------*/
  1749.     /* Code Body                                                      */
  1750.     /*----------------------------------------------------------------*/
  1751.     g_pen_num_stroke_area = 0;
  1752.     g_pen_stroke_max_points = 0;
  1753.     g_pen_stroke_points = NULL;
  1755.     /* 
  1756.      * We will call mmi_pen_reset() *later* on Pen Up or Stroke Up event.
  1757.      *
  1758.      * There might be many pending events in driver queue if MMI task is blocked by 
  1759.      * other time-consuming jobs. If there are pending stroke events in driver queue, 
  1760.      * it is better to flush driver queue.
  1761.      *
  1762.      */
  1763.     if (!g_pen_cntx.is_pen_down)
  1764.     {
  1765.         mmi_pen_reset();
  1766.     }
  1767.     else
  1768.     {
  1769.         /* 
  1770.          * NOTE: we *cannot* call mmi_pen_reset().
  1771.          *
  1772.          * For example, assume mmi_pen_stop_capture_strokes() is invoked when scrollbar of inline editor 
  1773.          * is scrolled on Pen Move event and the highlighed single-line editor is un-highlighted. 
  1774.          * If we invoke mmi_pen_reset() here, it will send MMI_PEN_EVENT_ABORT and reset the scrolling of scrollbar.
  1775.          */
  1776.         g_pen_cntx.reset_stroke_on_pen_up = 1;
  1777.     }
  1778. }
  1781. /*****************************************************************************
  1782.  * FUNCTION
  1783.  *  mmi_pen_register_stroke_down_handler
  1784.  * DESCRIPTION
  1785.  *  Register the Stroke Down handler
  1786.  * PARAMETERS
  1787.  *  pen_fp      [IN]        Callback handler
  1788.  * RETURNS
  1789.  *  void
  1790.  *****************************************************************************/
  1791. void mmi_pen_register_stroke_down_handler(mmi_pen_hdlr pen_fp)
  1792. {
  1793.     /*----------------------------------------------------------------*/
  1794.     /* Local Variables                                                */
  1795.     /*----------------------------------------------------------------*/
  1797.     /*----------------------------------------------------------------*/
  1798.     /* Code Body                                                      */
  1799.     /*----------------------------------------------------------------*/
  1800.     g_pen_stroke_table[MMI_PEN_STROKE_DOWN] = pen_fp;
  1801. }
  1804. /*****************************************************************************
  1805.  * FUNCTION
  1806.  *  mmi_pen_register_stroke_move_handler
  1807.  * DESCRIPTION
  1808.  *  Register the Stroke Move handler
  1809.  * PARAMETERS
  1810.  *  begin_fp        [IN]        
  1811.  *  end_fp          [IN]        
  1812.  *  pen_fp          [IN]        Callback handler
  1813.  * RETURNS
  1814.  *  void
  1815.  *****************************************************************************/
  1816. void mmi_pen_register_stroke_move_handler(void (*begin_fp) (void), void (*end_fp) (void), mmi_pen_hdlr pen_fp)
  1817. {
  1818.     /*----------------------------------------------------------------*/
  1819.     /* Local Variables                                                */
  1820.     /*----------------------------------------------------------------*/
  1822.     /*----------------------------------------------------------------*/
  1823.     /* Code Body                                                      */
  1824.     /*----------------------------------------------------------------*/
  1825.     g_pen_stroke_pre_move = begin_fp;
  1826.     g_pen_stroke_table[MMI_PEN_STROKE_MOVE] = pen_fp;
  1827.     g_pen_stroke_post_move = end_fp;
  1828. }
  1831. /*****************************************************************************
  1832.  * FUNCTION
  1833.  *  mmi_pen_register_stroke_up_handler
  1834.  * DESCRIPTION
  1835.  *  Register the Stroke Up handler
  1836.  * PARAMETERS
  1837.  *  pen_fp      [IN]        Callback handler
  1838.  * RETURNS
  1839.  *  void
  1840.  *****************************************************************************/
  1841. void mmi_pen_register_stroke_up_handler(mmi_pen_hdlr pen_fp)
  1842. {
  1843.     /*----------------------------------------------------------------*/
  1844.     /* Local Variables                                                */
  1845.     /*----------------------------------------------------------------*/
  1847.     /*----------------------------------------------------------------*/
  1848.     /* Code Body                                                      */
  1849.     /*----------------------------------------------------------------*/
  1850.     g_pen_stroke_table[MMI_PEN_STROKE_UP] = pen_fp;
  1851. }
  1854. /*****************************************************************************
  1855.  * FUNCTION
  1856.  *  mmi_pen_register_stroke_longtap_handler
  1857.  * DESCRIPTION
  1858.  *  Register the Stroke Up handler
  1859.  * PARAMETERS
  1860.  *  pen_fp      [IN]        Callback handler
  1861.  * RETURNS
  1862.  *  void
  1863.  *****************************************************************************/
  1864. void mmi_pen_register_stroke_longtap_handler(mmi_pen_hdlr pen_fp)
  1865. {
  1866.     /*----------------------------------------------------------------*/
  1867.     /* Local Variables                                                */
  1868.     /*----------------------------------------------------------------*/
  1870.     /*----------------------------------------------------------------*/
  1871.     /* Code Body                                                      */
  1872.     /*----------------------------------------------------------------*/
  1873.     g_pen_stroke_table[MMI_PEN_STROKE_LONGTAP] = pen_fp;
  1874. }
  1877. /*****************************************************************************
  1878.  * FUNCTION
  1879.  *  mmi_pen_peek_stroke_state
  1880.  * DESCRIPTION
  1881.  *  
  1882.  * PARAMETERS
  1883.  *  has_unfinished_stroke       [OUT]       Whether there are more strokes to come
  1884.  * RETURNS
  1885.  *  void
  1886.  *****************************************************************************/
  1887. void mmi_pen_peek_stroke_state(BOOL *has_unfinished_stroke)
  1888. {
  1889.     /*----------------------------------------------------------------*/
  1890.     /* Local Variables                                                */
  1891.     /*----------------------------------------------------------------*/
  1893.     /*----------------------------------------------------------------*/
  1894.     /* Code Body                                                      */
  1895.     /*----------------------------------------------------------------*/
  1896.     if (g_pen_cntx.is_pen_down && g_pen_cntx.is_stroke_created)
  1897.     {
  1898.         *has_unfinished_stroke = MMI_TRUE;
  1899.     }
  1900.     else
  1901.     {
  1902.         *has_unfinished_stroke = MMI_FALSE;
  1903.     }
  1904. }
  1907. /*****************************************************************************
  1908.  * FUNCTION
  1909.  *  mmi_pen_begin_strokes_of_character
  1910.  * DESCRIPTION
  1911.  *  Start to write a new character
  1912.  *  
  1913.  *  It is typically coupled with mmi_pen_end_strokes_of_character(), which stops en-queueing
  1914.  *  strokes inside 'point_array'.
  1915.  *  In mmi_pen_begin_strokes_of_character(), MMI continue to en-queue strokes from the head of 'point_array'.
  1916.  *  
  1917.  *  (However, simulator does not implement all of these)
  1918.  * PARAMETERS
  1919.  *  void
  1920.  * RETURNS
  1921.  *  void
  1922.  *****************************************************************************/
  1923. void mmi_pen_begin_strokes_of_character(void)
  1924. {
  1925.     /*----------------------------------------------------------------*/
  1926.     /* Local Variables                                                */
  1927.     /*----------------------------------------------------------------*/
  1929.     /*----------------------------------------------------------------*/
  1930.     /* Code Body                                                      */
  1931.     /*----------------------------------------------------------------*/
  1932.     MMI_DBG_ASSERT(g_pen_num_stroke_area > 0);
  1934.     g_pen_cntx.num_points_queued = 0;
  1935.     g_pen_cntx.is_stroke_created = 0;
  1936.     g_pen_cntx.is_all_stroke_finished = 0;
  1937. }
  1940. /*****************************************************************************
  1941.  * FUNCTION
  1942.  *  mmi_pen_end_strokes_of_character
  1943.  * DESCRIPTION
  1944.  *  End a written character.
  1945.  *  
  1946.  *  The following procedures are executed
  1947.  *  o Reset handwriting area to original size
  1948.  *  o Stop en-queueing new strokes inside 'point_array'. (But incoming strokes are still en-queued in driver ring buffer)
  1949.  *  o Append end marker (0xffff, 0xffff) in 'point_array'
  1950.  *  This API should be used only if there is no unfinished stroke (checked by mmi_pen_peek_stroke_state()).
  1951.  *  After it returns, we may pass 'point_array' to handwriting recognition engine.
  1952.  *  
  1953.  *  (However, simulator does not implement all of these)
  1954.  * PARAMETERS
  1955.  *  void
  1956.  * RETURNS
  1957.  *  void
  1958.  *****************************************************************************/
  1959. void mmi_pen_end_strokes_of_character(void)
  1960. {
  1961.     /*----------------------------------------------------------------*/
  1962.     /* Local Variables                                                */
  1963.     /*----------------------------------------------------------------*/
  1965.     /*----------------------------------------------------------------*/
  1966.     /* Code Body                                                      */
  1967.     /*----------------------------------------------------------------*/ 
  1968.     mmi_pen_simulator_push_char_end();
  1969.     g_pen_cntx.is_all_stroke_finished = 1;  /* To block further Pen Down */
  1971. #ifdef MMI_PEN_SAVE_STROKE_IN_FILE
  1972.     {
  1973.         extern void mmi_pen_save_stroke_in_file(mmi_pen_point_struct *, S32);
  1975.         mmi_pen_save_stroke_in_file(g_pen_stroke_points, g_pen_cntx.num_points_queued);
  1976.     }
  1977. #endif /* MMI_PEN_SAVE_STROKE_IN_FILE */ 
  1978. }
  1980. /****************************************************************
  1981.  * 
  1982.  * MODIS support 
  1983.  *
  1984.  * Because the pen handlers might take a long time to execute, race condition is easy to happen.
  1985.  *
  1986.  ***************************************************************/
  1987. #if !defined(MMI_ON_WIN32)
  1989. #define MMI_PEN_MODIS_QUEUE_SIZE 1024
  1991. typedef struct
  1992. {
  1993.     S16 type;   /* 0 down, 1 move, 2 up */
  1994.     S16 x;
  1995.     S16 y;
  1996. } mmi_pen_MODIS_queue_item_struct;
  1998. static volatile int g_mmi_pen_MODIS_qhead;  /* modified by MMI thread */
  1999. static volatile int g_mmi_pen_MODIS_qtail;  /* modified by windows message loop thread */
  2000. static mmi_pen_MODIS_queue_item_struct g_mmi_pen_MODIS_queue[MMI_PEN_MODIS_QUEUE_SIZE];
  2002. static BOOL g_mmi_pen_MODIS_timer_flag;
  2004. /* By Windows main thread */
  2007. /*****************************************************************************
  2008.  * FUNCTION
  2009.  *  mmi_pen_MODIS_enqueue_point
  2010.  * DESCRIPTION
  2011.  *  
  2012.  * PARAMETERS
  2013.  *  type        [IN]        
  2014.  *  x           [IN]        
  2015.  *  y           [IN]        
  2016.  * RETURNS
  2017.  *  void
  2018.  *****************************************************************************/
  2019. static void mmi_pen_MODIS_enqueue_point(S16 type, S16 x, S16 y)
  2020. {
  2021.     /*----------------------------------------------------------------*/
  2022.     /* Local Variables                                                */
  2023.     /*----------------------------------------------------------------*/
  2024.     int tail = g_mmi_pen_MODIS_qtail;
  2026.     /*----------------------------------------------------------------*/
  2027.     /* Code Body                                                      */
  2028.     /*----------------------------------------------------------------*/
  2029.     g_mmi_pen_MODIS_queue[tail].type = type;
  2030.     g_mmi_pen_MODIS_queue[tail].x = x;
  2031.     g_mmi_pen_MODIS_queue[tail].y = y;
  2032.     if (++tail == MMI_PEN_MODIS_QUEUE_SIZE)
  2033.     {
  2034.         tail = 0;
  2035.     }
  2036.     g_mmi_pen_MODIS_qtail = tail;
  2037.     MMI_ASSERT(tail != g_mmi_pen_MODIS_qhead);
  2038. }
  2041. /*****************************************************************************
  2042.  * FUNCTION
  2043.  *  mmi_pen_MODIS_enqueue_down
  2044.  * DESCRIPTION
  2045.  *  Remark: Executed from non-MMI task
  2046.  * PARAMETERS
  2047.  *  x       [IN]        
  2048.  *  y       [IN]        
  2049.  * RETURNS
  2050.  *  void
  2051.  *****************************************************************************/
  2052. void mmi_pen_MODIS_enqueue_down(S16 x, S16 y)
  2053. {
  2054.     /*----------------------------------------------------------------*/
  2055.     /* Local Variables                                                */
  2056.     /*----------------------------------------------------------------*/
  2057.     MYQUEUE message;
  2059.     /*----------------------------------------------------------------*/
  2060.     /* Code Body                                                      */
  2061.     /*----------------------------------------------------------------*/
  2062.     mmi_pen_MODIS_enqueue_point(0, x, y);
  2063.     
  2064.     /* 
  2065.      * Because polling timer is aligned timer, and it will be suspended if 
  2066.      * the backlight is turned off. We need to send primitive MSG_ID_TP_EVENT_IND
  2067.      * to MMI task in order to resume non-aligned timer.
  2068.      */
  2069.     message.oslMsgId = MSG_ID_TP_EVENT_IND;
  2070.     message.oslDataPtr = NULL;
  2071.     message.oslPeerBuffPtr = NULL;
  2072.     message.oslSrcId = MOD_L4C;
  2073.     message.oslDestId = MOD_MMI;
  2074.     OslMsgSendExtQueue(&message);
  2075. }
  2078. /*****************************************************************************
  2079.  * FUNCTION
  2080.  *  mmi_pen_MODIS_enqueue_move
  2081.  * DESCRIPTION
  2082.  *  
  2083.  * PARAMETERS
  2084.  *  x       [IN]        
  2085.  *  y       [IN]        
  2086.  * RETURNS
  2087.  *  void
  2088.  *****************************************************************************/
  2089. void mmi_pen_MODIS_enqueue_move(S16 x, S16 y)
  2090. {
  2091.     /*----------------------------------------------------------------*/
  2092.     /* Local Variables                                                */
  2093.     /*----------------------------------------------------------------*/
  2095.     /*----------------------------------------------------------------*/
  2096.     /* Code Body                                                      */
  2097.     /*----------------------------------------------------------------*/
  2098.     mmi_pen_MODIS_enqueue_point(1, x, y);
  2099. }
  2102. /*****************************************************************************
  2103.  * FUNCTION
  2104.  *  mmi_pen_MODIS_enqueue_up
  2105.  * DESCRIPTION
  2106.  *  
  2107.  * PARAMETERS
  2108.  *  x       [IN]        
  2109.  *  y       [IN]        
  2110.  * RETURNS
  2111.  *  void
  2112.  *****************************************************************************/
  2113. void mmi_pen_MODIS_enqueue_up(S16 x, S16 y)
  2114. {
  2115.     /*----------------------------------------------------------------*/
  2116.     /* Local Variables                                                */
  2117.     /*----------------------------------------------------------------*/
  2119.     /*----------------------------------------------------------------*/
  2120.     /* Code Body                                                      */
  2121.     /*----------------------------------------------------------------*/
  2122.     mmi_pen_MODIS_enqueue_point(2, x, y);
  2123. }
  2125. /* By MMI thread */
  2126. #ifdef __MMI_HANDWRITING_PAD__
  2129. /*****************************************************************************
  2130.  * FUNCTION
  2131.  *  mmi_pen_draw_control_area
  2132.  * DESCRIPTION
  2133.  *  
  2134.  * PARAMETERS
  2135.  *  void
  2136.  * RETURNS
  2137.  *  void
  2138.  *****************************************************************************/
  2139. void mmi_pen_draw_control_area()
  2140. {
  2141.     /*----------------------------------------------------------------*/
  2142.     /* Local Variables                                                */
  2143.     /*----------------------------------------------------------------*/
  2144.     int i;
  2146.     /*----------------------------------------------------------------*/
  2147.     /* Code Body                                                      */
  2148.     /*----------------------------------------------------------------*/
  2149.     gui_lock_double_buffer();
  2150.     for (i = 0; i < TP_AREA_MAX_NUM; i++)
  2151.     {
  2152.         if (IS_ENABLE_FLAG(tp_area_table[i].flag, TP_CONTROL_AREA))
  2153.         {
  2154.             int index = 0;
  2155.             mmi_pen_point_struct pos1, pos2;
  2157.             pos1 = tp_area_table[i].pos[index];
  2158.             index++;
  2159.             while ((tp_area_table[i].pos[index].x != -1) && (tp_area_table[i].pos[index].y != -1))
  2160.             {
  2161.                 pos2 = tp_area_table[i].pos[index];
  2162.                 gdi_draw_line(pos1.x, pos1.y, pos2.x, pos2.y, GDI_COLOR_RED);
  2163.                 pos1 = pos2;
  2164.                 index++;
  2165.             }
  2166.             pos2 = tp_area_table[i].pos[0];
  2167.             gdi_draw_line(pos1.x, pos1.y, pos2.x, pos2.y, GDI_COLOR_RED);
  2169.         }
  2170.         else
  2171.         {
  2172.             /* handwriting area */
  2173.         }
  2174.     }
  2175.     gui_unlock_double_buffer();
  2176.     gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  2178. }
  2179. #endif /* __MMI_HANDWRITING_PAD__ */ 
  2182. /*****************************************************************************
  2183.  * FUNCTION
  2184.  *  mmi_pen_MODIS_timer_hdlr
  2185.  * DESCRIPTION
  2186.  *  
  2187.  * PARAMETERS
  2188.  *  void
  2189.  * RETURNS
  2190.  *  void
  2191.  *****************************************************************************/
  2192. static void mmi_pen_MODIS_timer_hdlr(void)
  2193. {
  2194.     /*----------------------------------------------------------------*/
  2195.     /* Local Variables                                                */
  2196.     /*----------------------------------------------------------------*/
  2197.     mmi_pen_MODIS_queue_item_struct *pt, *pt_end;
  2198.     int new_head, saved_tail;
  2199.     MMI_BOOL has_events = MMI_FALSE;
  2200.     static MMI_BOOL entered = MMI_FALSE;
  2202.     /*----------------------------------------------------------------*/
  2203.     /* Code Body                                                      */
  2204.     /*----------------------------------------------------------------*/
  2205.     if (!g_pen_cntx.is_enabled)
  2206.     {
  2207.         g_mmi_pen_MODIS_qhead = g_mmi_pen_MODIS_qtail = 0;
  2209.         StartTimer(PEN_POLLING_TIMER, 20, mmi_pen_MODIS_timer_hdlr);
  2210.         return;
  2211.     }
  2213.     /* Avoid re-entrance of this function. Typically it's becuase NVRAM routines invoke timer 
  2214.        handler again */
  2215.     if (entered)
  2216.     {
  2217.         return;
  2218.     }
  2219.     entered = MMI_TRUE;
  2221.     g_mmi_pen_MODIS_timer_flag = MMI_TRUE;
  2223.     saved_tail = g_mmi_pen_MODIS_qtail;
  2224.     pt = g_mmi_pen_MODIS_queue + g_mmi_pen_MODIS_qhead;
  2226.     if (saved_tail < g_mmi_pen_MODIS_qhead)
  2227.     {
  2228.         pt_end = g_mmi_pen_MODIS_queue + MMI_PEN_MODIS_QUEUE_SIZE;
  2229.         new_head = 0;
  2230.     }
  2231.     else
  2232.     {
  2233.         pt_end = g_mmi_pen_MODIS_queue + saved_tail;
  2234.         new_head = saved_tail;
  2235.     }
  2237.     if (pt < pt_end)
  2238.     {
  2239.         has_events = MMI_TRUE;
  2240.     }
  2242.     while (pt < pt_end)
  2243.     {
  2244.     #ifdef __MMI_SCREEN_ROTATE__
  2245.         if (mmi_frm_get_screen_rotate() != MMI_FRM_SCREEN_ROTATE_0)
  2246.         {
  2247.             S32 tmp_x = pt->x, tmp_y = pt->y;
  2249.             /* W06.04 Replace functions for GDI LCD Rotate */
  2250.             gdi_rotate_map_absolute_hw_to_lcd(&tmp_x, &tmp_y);
  2251.             /* gdi_layer_map_rotated_coordinates(gdi_layer_get_base_layer_rotation(), &tmp_x, &tmp_y); */
  2252.             pt->x = (S16) tmp_x;
  2253.             pt->y = (S16) tmp_y;
  2254.         }
  2255.     #endif /* __MMI_SCREEN_ROTATE__ */ 
  2257.         switch (pt->type)
  2258.         {
  2259.             case 0:
  2260.                 mmi_pen_simulator_button_down_hdlr(pt->x, pt->y);
  2261.                 break;
  2262.             case 1:
  2263.                 mmi_pen_simulator_button_move_hdlr(pt->x, pt->y);
  2264.                 break;
  2265.             case 2:
  2266.                 mmi_pen_simulator_button_up_hdlr(pt->x, pt->y);
  2267.                 break;
  2268.             default:
  2269.                 ASSERT(0);
  2270.         }
  2271.         pt++;
  2272.         if (!g_mmi_pen_MODIS_timer_flag)
  2273.         {
  2274.             break;  /* mmi_pen_reset was invoked */
  2275.         }
  2276.     }
  2278.     /* Update queue when no mmi_pen_disable() and mmi_pen_reset() inside previous pen handler */
  2279.     if (g_mmi_pen_MODIS_timer_flag)
  2280.     {
  2281.         g_mmi_pen_MODIS_qhead = new_head;
  2282.     }
  2284.     g_mmi_pen_MODIS_timer_flag = MMI_FALSE;
  2286.     if (has_events)
  2287.     {
  2288.         TurnOnBacklight(MMI_TRUE);
  2289.     #ifdef __MMI_LCD_PARTIAL_ON__
  2290.         /* Switch screen and flush pen events */
  2291.         LeavePartialOnScreenSaverIfOk();
  2292.     #endif /* __MMI_LCD_PARTIAL_ON__ */ 
  2293.     }
  2295. #ifdef __MMI_HANDWRITING_PAD__
  2296.     mmi_pen_draw_control_area();
  2297. #endif 
  2299.     StartTimer(PEN_POLLING_TIMER, 20, mmi_pen_MODIS_timer_hdlr);
  2301.     entered = MMI_FALSE;
  2302. }
  2305. /*****************************************************************************
  2306.  * FUNCTION
  2307.  *  mmi_pen_MODIS_flush_queue
  2308.  * DESCRIPTION
  2309.  *  
  2310.  * PARAMETERS
  2311.  *  void
  2312.  * RETURNS
  2313.  *  void
  2314.  *****************************************************************************/
  2315. static void mmi_pen_MODIS_flush_queue(void)
  2316. {
  2317.     /*----------------------------------------------------------------*/
  2318.     /* Local Variables                                                */
  2319.     /*----------------------------------------------------------------*/
  2321.     /*----------------------------------------------------------------*/
  2322.     /* Code Body                                                      */
  2323.     /*----------------------------------------------------------------*/
  2324.     g_mmi_pen_MODIS_qtail = 0;
  2325.     g_mmi_pen_MODIS_qhead = 0;
  2326.     g_mmi_pen_MODIS_timer_flag = MMI_FALSE;
  2327. }
  2330. /*****************************************************************************
  2331.  * FUNCTION
  2332.  *  mmi_pen_MODIS_start_timer
  2333.  * DESCRIPTION
  2334.  *  
  2335.  * PARAMETERS
  2336.  *  void
  2337.  * RETURNS
  2338.  *  void
  2339.  *****************************************************************************/
  2340. static void mmi_pen_MODIS_start_timer(void)
  2341. {
  2342.     /*----------------------------------------------------------------*/
  2343.     /* Local Variables                                                */
  2344.     /*----------------------------------------------------------------*/
  2346.     /*----------------------------------------------------------------*/
  2347.     /* Code Body                                                      */
  2348.     /*----------------------------------------------------------------*/
  2349.     StartTimer(PEN_POLLING_TIMER, 20, mmi_pen_MODIS_timer_hdlr);
  2350. }
  2353. /*****************************************************************************
  2354.  * FUNCTION
  2355.  *  mmi_pen_MODIS_tp_ind
  2356.  * DESCRIPTION
  2357.  *  
  2358.  * PARAMETERS
  2359.  *  param       [IN]        unused
  2360.  * RETURNS
  2361.  *  void
  2362.  *****************************************************************************/
  2363. static void mmi_pen_MODIS_tp_ind(void *param /* unused */ )
  2364. {
  2365.     /*----------------------------------------------------------------*/
  2366.     /* Local Variables                                                */
  2367.     /*----------------------------------------------------------------*/
  2369.     /*----------------------------------------------------------------*/
  2370.     /* Code Body                                                      */
  2371.     /*----------------------------------------------------------------*/
  2372.     mmi_pen_MODIS_timer_hdlr();
  2373. }
  2375. #endif /* !defined(MMI_ON_WIN32) */ 
  2377. /****************************************************************
  2378.  * Unit test
  2379.  ***************************************************************/
  2381. #ifdef MMI_PEN_UNIT_TEST
  2383. /*
  2384.  * The simple drawing application is not efficent in order 
  2385.  * * to follow PC Simualator architecture 
  2386.  */
  2388. #include "wgui_categories.h"
  2389. #include "GlobalDefs.h"
  2390. #include "HistoryGprot.h"
  2392. static mmi_pen_point_struct mmi_pen_test_last_pos;
  2394. static U8 mmi_pen_draw_buffer[LCD_WIDTH * LCD_HEIGHT / 8];