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

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

MTK

开发平台：

C/C++

wgui_status_icons.c：源码内容
  1.  * DESCRIPTION
  2.  *  set status icons display state (MAINLCD_ONLY, SUBLCD_ONLY, DEFAULT_BOTH)
  3.  * PARAMETERS
  4.  *  state       [IN]        
  5.  * RETURNS
  6.  *  void
  7.  *****************************************************************************/
  8. void set_status_icon_display(S32 state)
  9. {
  10.     /*----------------------------------------------------------------*/
  11.     /* Local Variables                                                */
  12.     /*----------------------------------------------------------------*/
  14.     /*----------------------------------------------------------------*/
  15.     /* Code Body                                                      */
  16.     /*----------------------------------------------------------------*/
  17.     status_icon_display_area = state;
  18. }
  21. /*****************************************************************************
  22.  * FUNCTION
  23.  *  reset_status_icon_display
  24.  * DESCRIPTION
  25.  *  reset status icons display to DEFAULT_BOTH
  26.  * PARAMETERS
  27.  *  void
  28.  * RETURNS
  29.  *  void
  30.  *****************************************************************************/
  31. void reset_status_icon_display(void)
  32. {
  33.     /*----------------------------------------------------------------*/
  34.     /* Local Variables                                                */
  35.     /*----------------------------------------------------------------*/
  37.     /*----------------------------------------------------------------*/
  38.     /* Code Body                                                      */
  39.     /*----------------------------------------------------------------*/
  40.     status_icon_display_area = DEFAULT_BOTH;
  41. }
  44. /*****************************************************************************
  45.  * FUNCTION
  46.  *  show_status_icons
  47.  * DESCRIPTION
  48.  *  show all three status bar
  49.  * PARAMETERS
  50.  *  void
  51.  * RETURNS
  52.  *  void
  53.  *****************************************************************************/
  54. extern idle_context_struct g_idle_context;
  55. void show_status_icons(void)
  56. {
  57.     /*----------------------------------------------------------------*/
  58.     /* Local Variables                                                */
  59.     /*----------------------------------------------------------------*/
  60.     S32 i, j, id, sbx, sby;
  61.     U8 blink_animate_flag = 0;
  62.     S32 x1, y1, x2, y2;
  63.     S32 ix1, iy1;
  65.     /* backup active lcd */
  66.     bitmap *saved_graphics_context = current_LCD_device_bitmap;
  68.     /* 101804 MTK Calvin added to avoid to update signal level status icon during g_pwr_context.PowerOnTillIdleApp */
  69.     U8 old_signal_state_main = 0;   /* 111605 warning Calvin */
  71. #ifdef __MMI_SUBLCD__
  72.     U8 old_signal_state_sub = 0;
  73. #endif 
  75.     /* PMT VIKAS START 20050707 */
  76. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  77.     /* for handling the shuffling of status bar on idle screen. */
  78.     S32 initial, increment;
  80.     /*----------------------------------------------------------------*/
  81.     /* Code Body                                                      */
  82.     /*----------------------------------------------------------------*/
  83.     if (is_status_bar_shuffled == 1)
  84.     {
  85.         initial = MAX_STATUS_ICON_BARS - 1;
  86.         increment = -1;
  87.     }
  88.     else
  89.     {
  90.         initial = 0;
  91.         increment = 1;
  92.     }
  93. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  94.     /* PMT VIKAS END 20050707 */
  95.     if (mmi_bootup_is_in_security_check() == MMI_TRUE)
  96.     {
  97.         old_signal_state_main = MMI_status_icons[STATUS_ICON_SIGNAL_STRENGTH].state;
  98.         MMI_status_icons[STATUS_ICON_SIGNAL_STRENGTH].state = 0;
  99.     #ifdef __MMI_SUBLCD__
  100.         old_signal_state_sub = MMI_status_icons[STATUS_ICON_SUBLCD_SIGNAL_STRENGTH].state;
  101.         MMI_status_icons[STATUS_ICON_SUBLCD_SIGNAL_STRENGTH].state = 0;
  102.     #endif /* __MMI_SUBLCD__ */ 
  103.     }
  104.     /* MTK Calvin end */
  106.     /* 050205 Calvin added */
  107.     if (IsReArrangeNeeded)
  108.     {
  109.         arrange_status_icons();
  110.         IsReArrangeNeeded = 0;
  111.     }
  112.     /* Calvin end */
  114.     /* MTK Leo add, change clip region when drawing layer is set */
  115.     //      gui_push_clip();
  116.     //      gui_reset_clip();
  117.     /* MTK Leo end */
  119.     /* PMT VIKAS START 20050707 */
  120. #if (defined __MMI_MAINLCD_176X220__) && (defined __MMI_UI_DALMATIAN_STATUSBAR__)
  121.     if (background_fill == 1)
  122.     {
  123.         if ((MMI_status_icon_bars[0].flags & STATUS_ICON_BAR_DISPLAY)
  124.             || (MMI_status_icon_bars[1].flags & STATUS_ICON_BAR_DISPLAY))
  125.             if (GetActiveScreenId() != IDLE_SCREEN_ID)
  126.             {
  127.                 show_mainlcd_status_bar_background(0, 0, UI_device_width - 1, MMI_STATUS_BAR_HEIGHT - 1);
  128.             }
  129.     }
  130. #endif /* (defined __MMI_MAINLCD_176X220__) && (defined __MMI_UI_DALMATIAN_STATUSBAR__) */ 
  131. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  132.     for (j = initial; j >= 0 && j < MAX_STATUS_ICON_BARS; j += increment)
  133. #else 
  134.     for (j = 0; j < MAX_STATUS_ICON_BARS; j++)
  135. #endif 
  136.         /* PMT VIKAS END 20050707 */
  137.     {
  138.         if (MMI_status_icon_bars[j].flags & STATUS_ICON_BAR_DISPLAY)
  139.         {
  140.             if (MMI_status_icon_bars[j].graphics_context == &main_LCD_device_bitmap)
  141.             {
  142.                 if (status_icon_display_area == SUBLCD_ONLY)
  143.                 {
  144.                     continue;
  145.                 }
  146.                 UI_set_main_LCD_graphics_context(); /* set graphic context to main lcd */
  147.                 //if (!g_idle_context.IsOnIdleScreen)//092206 network search
  148.                 if ((!mmi_idle_is_on_idle_screen()) || (mmi_idle_is_on_idle_screen() && (!mmi_bootup_is_idle_screen_reached())))
  149.                 {
  150.                     /* 061506 double buffer Start */
  151.                     if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  152.                     {
  153.                         gdi_layer_push_and_set_active(get_status_icon_bar_layer((U8)j));
  154.                     }
  155.                     /* 061506 double buffer End */
  156.                     MMI_hide_status_icon_bars[j] ();    /* call hide function of status bar */
  157.                     /* 061506 double buffer Start */
  158.                     if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  159.                     {
  160.                         gdi_layer_pop_and_restore_active();
  161.                     }
  162.                     /* 061506 double buffer End */
  163.                 }
  164.             }
  165.             else if (MMI_status_icon_bars[j].graphics_context == &sub_LCD_device_bitmap)
  166.             {
  167.                 if (status_icon_display_area == MAINLCD_ONLY)
  168.                 {
  169.                     continue;
  170.                 }
  171.                 /* if ( ! g_idle_context.IsOnIdleScreen ) */
  172.                 /* 061506 double buffer Start */
  173.                 if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  174.                 {
  175.                     gdi_layer_push_and_set_active(get_status_icon_bar_layer((U8)j));
  176.                 }
  177.                 /* 061506 double buffer End */
  178.                 MMI_hide_status_icon_bars[j] ();    /* call hide function of sub lcd status bar */
  179.                 /* 061506 double buffer Start */
  180.                 if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  181.                 {
  182.                     gdi_layer_pop_and_restore_active();
  183.                 }
  184.                 /* 061506 double buffer End */
  185.                 UI_set_sub_LCD_graphics_context();  /* set grahic context to sub lcd */
  186.             }
  188.             /* 061506 double buffer Start */
  189.             if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  190.             {
  191.                 gdi_layer_push_and_set_active(get_status_icon_bar_layer((U8)j));
  192.             }
  193.             /* 061506 double buffer End */
  194.             
  195.             /* MTK Leo add, change clip region when drawing layer is set */
  196.             gui_push_clip();
  197.             gui_reset_clip();
  198.             /* MTK Leo end */
  200.             /* store coordinates of status icon bar */
  201.             x1 = MMI_status_icon_bars[j].x1;
  202.             y1 = MMI_status_icon_bars[j].y1;
  203.             x2 = MMI_status_icon_bars[j].x2;
  204.             y2 = MMI_status_icon_bars[j].y2;
  206.             /* set clip region */
  207.             gui_set_clip(x1, y1, x2, y2);
  209.             /* PMT HIMANSHU START 20050625 */
  210.         #if defined(__MMI_UI_TECHNO_STATUS_ICON__)
  211.             if (j == 0)
  212.             {
  213.                 //PMT HIMANSHU START 20050721
  214.                 //PMT VIKAS START 20051202
  215.                 if (is_on_idlescreen() == 1);   /* do nothing */
  216.                 //PMT VIKAS END 20051202
  217.                 //                                      gui_fill_rectangle(x1, y1, x2, y2,
  218.                 //                                                      (current_MMI_theme->formatted_inputbox_normal_filler->border_color));
  219.                 //PMT HIMANSHU END 20050721
  220.                 else if (GetActiveScreenId() == MAIN_MENU_SCREENID)
  221.                 {
  222.                     gui_fill_rectangle(
  223.                         x1,
  224.                         y1,
  225.                         x2,
  226.                         y2,
  227.                         /* PMT VIKAS START 20050718 */ current_UI_theme->window_title_theme->active_filler->c);
  228.                 }
  229.                 /* PMT VIKAS END 20050718 */
  230.                 else
  231.                 {
  232.                     gui_fill_rectangle(x1, y1, x2, y2, *(current_MMI_theme->statusbar0_background_color));
  233.                 }
  234.             }
  235.         #endif /* defined(__MMI_UI_TECHNO_STATUS_ICON__) */ 
  237.             //PMT HIMANSHU END
  238.             //PMT VIKAS START 20050707
  239.         #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  240.             /* gui_draw_filled_area(x1, y1, x2, y2, MMI_status_icon_bars[j].normal_bar_filler); */
  241.             if (j == 0)
  242.             {
  243.                 UI_filled_area Dalmatiian_LSK_up;
  245.                 Dalmatiian_LSK_up = *current_MMI_theme->LSK_up_filler;
  246.                 Dalmatiian_LSK_up.flags |= UI_FILLED_AREA_RIGHT_ROUNDED_BORDER;
  247.                 gui_draw_filled_area(x1, y1, x2, y2, &Dalmatiian_LSK_up);
  248.             }
  249.             else if (j == 1)
  250.             {
  251.                 UI_filled_area Dalmatiian_RSK_up;
  253.                 Dalmatiian_RSK_up = *current_MMI_theme->RSK_up_filler;
  254.                 Dalmatiian_RSK_up.flags |= UI_FILLED_AREA_LEFT_ROUNDED_BORDER;
  255.                 gui_draw_filled_area(x1, y1, x2, y2, &Dalmatiian_RSK_up);
  256.             }
  257.         #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  258.             /* PMT VIKAS END 20050707 */
  259.             /* store icon offset coordinates */
  260.             sbx = MMI_status_icon_bars[j].x;
  261.             sby = MMI_status_icon_bars[j].y;
  263.             if (MMI_status_icon_bars[j].icon_list != NULL)
  264.             {
  265.                 for (i = 0; i < MMI_status_icon_bars[j].n_icons; i++)
  266.                 {
  267.                     id = MMI_status_icon_bars[j].icon_list[i];
  268.                     if (MMI_status_icons[id].icon_ID != IMAGE_ID_NULL)
  269.                     {
  270.                     #ifdef __MMI_DOWNLOADABLE_THEMES_SUPPORT__
  272.                         if (mmi_tm_does_theme_have_alt_image())
  273.                         {
  274.                             if (mmi_tm_is_theme_dirty_bit_set(GetImageIndex(MMI_status_icons[id].icon_ID)))
  275.                             {
  276.                                 MMI_status_icons[id].icon_data = get_image(MMI_status_icons[id].icon_ID);
  277.                                 /* No need to calculate Image width, height and frames as they will not change */
  278.                             }
  279.                         }
  280.                     #endif /* __MMI_DOWNLOADABLE_THEMES_SUPPORT__ */ 
  282.                         if (MMI_status_icons[id].flags & STATUS_ICON_REVERSE_ANIMATE)
  283.                         {
  284.                             /* do nothing */
  285.                         }
  286.                         else if (MMI_status_icons[id].flags & STATUS_ICON_FORWARD_ANIMATE)
  287.                         {
  288.                             /* do nothing */
  289.                         }
  290.                         else if (MMI_status_icons[id].flags & STATUS_ICON_ANIMATE)
  291.                         {
  292.                             blink_animate_flag = 1;
  294.                             /* store position of the icon */
  295.                             ix1 = MMI_status_icons[id].x + sbx;
  296.                             iy1 = MMI_status_icons[id].y + sby;
  298.                             gui_show_transparent_animated_image_frame(
  299.                                 ix1,
  300.                                 iy1,
  301.                                 MMI_status_icons[id].icon_data,
  302.                                 0,
  303.                                 MMI_status_icons[id].current_frame);
  305.                             /* 091505 bettery Calvin removed to status_icon_timer_callback */
  306.                         #if 0
  307. /* under construction !*/
  308. /* under construction !*/
  309. /* under construction !*/
  310. /* under construction !*/
  311. /* under construction !*/
  312.                         #endif /* 0 */ 
  313.                             /* 091505 bettery Calvin end */
  314.                         }
  315.                         else if (MMI_status_icons[id].flags & STATUS_ICON_BLINK)
  316.                         {
  317.                             blink_animate_flag = 1;
  318.                             if (MMI_status_icons_blink_animate_ON_state)
  319.                             {
  320.                                 /* store position of the icon */
  321.                                 ix1 = MMI_status_icons[id].x + sbx;
  322.                                 iy1 = MMI_status_icons[id].y + sby;
  324.                                 gui_show_transparent_image(ix1, iy1, MMI_status_icons[id].icon_data, 0);
  325.                             }
  326.                         }
  327.                         else if (MMI_status_icons[id].flags & STATUS_ICON_DISPLAY)
  328.                         {
  329.                             /* store position of the icon */
  330.                             ix1 = MMI_status_icons[id].x + sbx;
  331.                             iy1 = MMI_status_icons[id].y + sby;
  333.                             if (MMI_status_icons[id].state > 0)
  334.                             {
  335.                                 gui_show_transparent_animated_image_frame(
  336.                                     ix1,
  337.                                     iy1,
  338.                                     MMI_status_icons[id].icon_data,
  339.                                     0,
  340.                                     MMI_status_icons[id].state);
  341.                             }
  342.                             else
  343.                             {
  344.                                 gui_show_transparent_image(ix1, iy1, MMI_status_icons[id].icon_data, 0);
  345.                             }
  346.                         }
  347.                     }
  348.                 }
  349.             }
  350.             /* MTK Leo add, change clip region when drawing layer is set */
  351.             gui_pop_clip();
  352.             /* MTK Leo end */
  353.             
  354.             /* 061506 double buffer Start */
  355.             if(get_status_icon_bar_layer((U8)j)!=GDI_ERROR_HANDLE)
  356.             {
  357.                 gdi_layer_pop_and_restore_active();
  358.             }
  359.             /* 061506 double buffer End */
  360.         }
  361.     }
  363.     /* 101804 MTK Calvin added to avoid to update signal level status icon during g_pwr_context.PowerOnTillIdleApp */
  364.     if (mmi_bootup_is_in_security_check() == MMI_TRUE)
  365.     {
  366.         MMI_status_icons[STATUS_ICON_SIGNAL_STRENGTH].state = old_signal_state_main;
  367.     #ifdef __MMI_SUBLCD__
  368.         MMI_status_icons[STATUS_ICON_SUBLCD_SIGNAL_STRENGTH].state = old_signal_state_sub;
  369.     #endif 
  370.     }
  371.     /* MTK Calvin end */
  373.     status_icon_display_ON = 1;
  374.     /* PMT VIKAS START 20050707 */
  375. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  376.     /* PMT VIKAS START 20051202 */
  377.     if (is_on_idlescreen() == 1)
  378.         /* PMT VIKAS END 20051202 */
  379.     {
  380.         if ((MMI_status_icons[STATUS_ICON_SIGNAL_STRENGTH].flags & STATUS_ICON_ANIMATE)
  381.             || (MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].flags & STATUS_ICON_ANIMATE))
  382.         {
  383.             blink_animate_flag = 1;
  384.         }
  385.     }
  386. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  387.     /* PMT VIKAS END 20050707 */
  388.     if (blink_animate_flag) /* if icon is animated */
  389.     {
  390.         if (status_icon_blink_animate_ON == 0)
  391.         {
  392.             setup_status_icon_blink_animate();
  393.         }
  394.         status_icon_blink_animate_ON = 1;
  395.     }
  396.     else
  397.     {
  398.         if (status_icon_blink_animate_ON == 1)
  399.         {
  400.             setup_status_icon_blink_animate();
  401.         }
  402.         status_icon_blink_animate_ON = 0;
  403.     }
  404.     /* MTK Leo add, change clip region when drawing layer is set */
  405.     /* gui_pop_clip(); */
  406.     /* MTK Leo end */
  408.     /* restore active lcd according to backuped lcd */
  409.     if (saved_graphics_context == &main_LCD_device_bitmap)
  410.     {
  411.         UI_set_main_LCD_graphics_context();
  412.     }
  413.     else if (saved_graphics_context == &sub_LCD_device_bitmap)
  414.     {
  415.         UI_set_sub_LCD_graphics_context();
  416.     }
  417. }
  420. /*****************************************************************************
  421.  * FUNCTION
  422.  *  hide_status_icons
  423.  * DESCRIPTION
  424.  *  set the flag of all icons to hide
  425.  * PARAMETERS
  426.  *  void
  427.  * RETURNS
  428.  *  void
  429.  *****************************************************************************/
  430. void hide_status_icons(void)
  431. {
  432.     /*----------------------------------------------------------------*/
  433.     /* Local Variables                                                */
  434.     /*----------------------------------------------------------------*/
  435.     S32 i;
  436.     U8 flag = 1;
  438.     /*----------------------------------------------------------------*/
  439.     /* Code Body                                                      */
  440.     /*----------------------------------------------------------------*/
  441.     for (i = 0; i < MAX_STATUS_ICON_BARS; i++)
  442.     {
  443.         if (MMI_status_icon_bars[i].flags & STATUS_ICON_BAR_DISPLAY)
  444.         {
  445.             if (MMI_status_icon_bars[i].graphics_context == current_LCD_device_bitmap)
  446.             {
  447.                 /* call hide fuction of status bar */
  448.                 MMI_hide_status_icon_bars[i] ();
  450.                 /* set the flag of bar to disable */
  451.                 MMI_status_icon_bars[i].flags &= ~STATUS_ICON_BAR_DISPLAY;
  452.             }
  453.             else if (MMI_status_icon_bars[i].flags & STATUS_ICON_BAR_DISPLAY)
  454.             {
  455.                 flag = 0;
  456.             }
  457.         }
  458.     }
  459.     if (flag)
  460.     {
  461.         status_icon_display_ON = 0;
  462.         if (status_icon_blink_animate_ON)
  463.         {
  464.             status_icon_blink_animate_ON = 0;
  465.             gui_cancel_timer(status_icon_timer_callback);
  466.         }
  467.     }
  468. }
  471. /*****************************************************************************
  472.  * FUNCTION
  473.  *  close_status_icons
  474.  * DESCRIPTION
  475.  *  set statu sicon bar flag to not to display,clear status bar hide function s
  476.  * PARAMETERS
  477.  *  void
  478.  * RETURNS
  479.  *  void
  480.  *****************************************************************************/
  481. void close_status_icons(void)
  482. {
  483.     /*----------------------------------------------------------------*/
  484.     /* Local Variables                                                */
  485.     /*----------------------------------------------------------------*/
  486.     S32 i;
  487.     U8 flag = 1;
  489.     /*----------------------------------------------------------------*/
  490.     /* Code Body                                                      */
  491.     /*----------------------------------------------------------------*/
  492. #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)       /* 041205 Calvin modieid */
  493.     /* if ( if_full_screen_hide_status_icons()== MMI_FALSE ) */
  494. //KP Jerry add for KP-Style 12-Matrix mainmenu on 2007-3-19 start
  495. #ifdef  __MMI_KP_STYLE_MAIN_MENU_MATRIX__
  496.     if(GetActiveScreenId() != MAIN_MENU_SCREENID)
  497. #endif
  498. //KP Jerry add for KP-Style 12-Matrix mainmenu on 2007-3-19 end
  499.     return;
  500. #endif /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  501.     for (i = 0; i < MAX_STATUS_ICON_BARS; i++)
  502.     {
  503.         if (MMI_status_icon_bars[i].graphics_context == current_LCD_device_bitmap)
  504.         {
  505.             MMI_status_icon_bars[i].flags &= ~STATUS_ICON_BAR_DISPLAY;
  506.         }
  507.         else if (MMI_status_icon_bars[i].flags & STATUS_ICON_BAR_DISPLAY)
  508.         {
  509.             flag = 0;
  510.         }
  511.     }
  512.     if (flag)
  513.     {
  514.         status_icon_display_ON = 0;
  515.         if (status_icon_blink_animate_ON)
  516.         {
  517.             status_icon_blink_animate_ON = 0;
  518.             gui_cancel_timer(status_icon_timer_callback);
  519.         }
  520.     }
  521.     clear_hide_status_icon_bars();  /* clear function handlers of hide function */
  522.     gui_hide_animations();          /* stop animation of icons */
  523.     //status_icon_display_locked=0;// set the valeu of lock variable of staus icon to zero //030705 Calvin removed
  524.     //PMT VIKAS START 20050707
  525. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  526.     gui_cancel_timer(shuffle_status_bars);
  527. #endif 
  528.     /* PMT VIKAS END 20050707 */
  529. }
  532. /*****************************************************************************
  533.  * FUNCTION
  534.  *  status_icon_timer_callback
  535.  * DESCRIPTION
  536.  *  timer call back of animated icon
  537.  * PARAMETERS
  538.  *  void
  539.  * RETURNS
  540.  *  void
  541.  *****************************************************************************/
  542. void status_icon_timer_callback(void)
  543. {
  544.     /*----------------------------------------------------------------*/
  545.     /* Local Variables                                                */
  546.     /*----------------------------------------------------------------*/
  547.     S32 i;
  549.     /*----------------------------------------------------------------*/
  550.     /* Code Body                                                      */
  551.     /*----------------------------------------------------------------*/
  552.     /* 091505 bettery Calvin moved here from show and refresh functions */
  553.     for (i = 0; i < MAX_STATUS_ICONS; i++)
  554.     {
  555.         if (MMI_status_icons[i].flags & STATUS_ICON_ANIMATE)
  556.         {
  557.             MMI_status_icons[i].current_frame++;
  558.             if (MMI_status_icons[i].current_frame >= MMI_status_icons[i].n_frames)
  559.             {
  560.                 MMI_status_icons[i].current_frame = 0;
  561.             }
  562.         }
  563.     }
  564.     /* 091505 bettery Calvin end */
  566.     /* PMT HIMANSHU START 20050625 */
  567. #if defined(__MMI_UI_TECHNO_STATUS_ICON__)
  568.     if ((MMI_status_icons[STATUS_ICON_SIGNAL_STRENGTH].flags & STATUS_ICON_ANIMATE)
  569.         || (MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].flags & STATUS_ICON_ANIMATE))
  570.     {
  571.         status_icon_blink_animate_ON = 1;
  572.         /* PMT VIKAS START 20051202 */
  573.         if (is_on_idlescreen() == 1 || GetActiveScreenId() == MAIN_MENU_SCREENID)
  574.             /* PMT VIKAS END 20051202 */
  575.         {
  576.             refresh_fixed_status_icon(STATUS_ICON_BATTERY_STRENGTH, 0);
  577.         }
  578.     }
  579. #endif /* defined(__MMI_UI_TECHNO_STATUS_ICON__) */ 
  580.     /* PMT HIMANSHU END */
  581.     /* cancel the timaer call back of animated icon */
  582.     if (!status_icon_blink_animate_ON)
  583.     {
  584.         gui_cancel_timer(status_icon_timer_callback);
  585.     }
  587.     if (!status_icon_display_ON)
  588.     {
  589.         return;
  590.     }
  592.     if (MMI_status_icons_blink_animate_ON_state)
  593.     {
  594.         MMI_status_icons_blink_animate_ON_state = 0;
  595.     }
  596.     else
  597.     {
  598.         MMI_status_icons_blink_animate_ON_state = 1;
  599.     }
  601.     /* PMT VIKAS START 20050707 */
  602. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  603.     disable_statusbar_fill_background();
  604. #endif 
  605.     /* PMT VIKAS END 20050707 */
  606.     /* redraw the status icons */
  607.     refresh_status_icon_display();
  608.     /* PMT VIKAS START 20050707 */
  609. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  610.     /* PMT VIKAS START 20051202 */
  611.     if (is_on_idlescreen() == 1)
  612.         /* PMT VIKAS END 20051202 */
  613.     {
  614.         enable_statusbar_fill_background();
  615.         if (MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].flags & STATUS_ICON_ANIMATE)
  616.         {
  617.             refresh_fixed_status_icon(STATUS_ICON_BATTERY_STRENGTH, 1);
  618.         }
  619.     }
  620. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  621.     /* PMT VIKAS END 20050707 */
  623.     if (status_icon_blink_animate_ON)
  624.     {
  625.         gui_start_timer(STATUS_ICON_TIMER_RATE, status_icon_timer_callback);
  626.     }
  627. }
  630. /*****************************************************************************
  631.  * FUNCTION
  632.  *  setup_status_icon_blink_animate
  633.  * DESCRIPTION
  634.  *  timer call back of blinking icon
  635.  * PARAMETERS
  636.  *  void
  637.  * RETURNS
  638.  *  void
  639.  *****************************************************************************/
  640. void setup_status_icon_blink_animate(void)
  641. {
  642.     /*----------------------------------------------------------------*/
  643.     /* Local Variables                                                */
  644.     /*----------------------------------------------------------------*/
  645.     S32 i;
  646.     U8 blink_animate_flag = 0;
  648.     /*----------------------------------------------------------------*/
  649.     /* Code Body                                                      */
  650.     /*----------------------------------------------------------------*/
  651.     /* PMT HIMANSHU START 20050625 */
  652. #if(!defined(__MMI_UI_TECHNO_STATUS_ICON__))
  653.     if (!status_icon_display_ON)
  654.     {
  655.         return;
  656.     }
  657. #endif /* (!defined(__MMI_UI_TECHNO_STATUS_ICON__)) */ 
  658.     /* PMT HIMANSHU END */
  660.     for (i = 0; i < MAX_STATUS_ICONS; i++)
  661.     {
  662.         if ((MMI_status_icons[i].flags & STATUS_ICON_BLINK) || (MMI_status_icons[i].flags & STATUS_ICON_ANIMATE))
  663.         {
  664.             blink_animate_flag = 1;
  665.             break;
  666.         }
  667.     }
  669.     if (blink_animate_flag)
  670.         /* start timer for blinking icon */
  671.     {
  672.         gui_start_timer(STATUS_ICON_TIMER_RATE, status_icon_timer_callback);
  673.     }
  674.     else
  675.         /* stop timer for blinking icon */
  676.     {
  677.         gui_cancel_timer(status_icon_timer_callback);
  678.     }
  679. }
  682. /*****************************************************************************
  683.  * FUNCTION
  684.  *  show_status_icon_bar
  685.  * DESCRIPTION
  686.  *  set the display flag of status bar
  687.  * PARAMETERS
  688.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  689.  *  horizontal(?)       [IN]        Bar sub lcd
  690.  *  vertical(?)         [IN]        Bar main lcd
  691.  * RETURNS
  692.  *  void
  693.  *****************************************************************************/
  694. void show_status_icon_bar(U8 status_bar_ID)
  695. {
  696. #ifdef __MMI_SUBLCD_SHOW_ANALOG_CLOCK__
  697.     /*----------------------------------------------------------------*/
  698.     /* Local Variables                                                */
  699.     /*----------------------------------------------------------------*/
  701.     /*----------------------------------------------------------------*/
  702.     /* Code Body                                                      */
  703.     /*----------------------------------------------------------------*/
  704.     if (status_bar_ID == 2)
  705.     {
  706.         return;
  707.     }
  708. #endif /* __MMI_SUBLCD_SHOW_ANALOG_CLOCK__ */ 
  709.     /* set teh flag of bar id to display */
  710.     MMI_status_icon_bars[status_bar_ID].flags |= STATUS_ICON_BAR_DISPLAY;
  711. }
  714. /*****************************************************************************
  715.  * FUNCTION
  716.  *  hide_status_icon_bar
  717.  * DESCRIPTION
  718.  *  hide the status bar
  719.  * PARAMETERS
  720.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  721.  *  horizontal(?)       [IN]        Bar sub lcd
  722.  *  vertical(?)         [IN]        Bar main lcd
  723.  * RETURNS
  724.  *  void
  725.  *****************************************************************************/
  726. void hide_status_icon_bar(U8 status_bar_ID)
  727. {
  728.     /*----------------------------------------------------------------*/
  729.     /* Local Variables                                                */
  730.     /*----------------------------------------------------------------*/
  732.     /*----------------------------------------------------------------*/
  733.     /* Code Body                                                      */
  734.     /*----------------------------------------------------------------*/
  735.     MMI_status_icon_bars[status_bar_ID].flags &= ~STATUS_ICON_BAR_DISPLAY;
  736. }
  739. /*****************************************************************************
  740.  * FUNCTION
  741.  *  set_status_icon_bar_type
  742.  * DESCRIPTION
  743.  *  hide the status bar
  744.  * PARAMETERS
  745.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  746.  *  flags               [IN]        
  747.  *  horizontal(?)       [IN]        Bar sub lcd
  748.  *  vertical(?)         [IN]        Bar main lcd
  749.  * RETURNS
  750.  *  void
  751.  *****************************************************************************/
  752. void set_status_icon_bar_type(U8 status_bar_ID, U32 flags)
  753. {
  754. #ifdef __MMI_SUBLCD_SHOW_ANALOG_CLOCK__
  755.     /*----------------------------------------------------------------*/
  756.     /* Local Variables                                                */
  757.     /*----------------------------------------------------------------*/
  759.     /*----------------------------------------------------------------*/
  760.     /* Code Body                                                      */
  761.     /*----------------------------------------------------------------*/
  762.     if (status_bar_ID == 2)
  763.     {
  764.         return;
  765.     }
  766. #endif /* __MMI_SUBLCD_SHOW_ANALOG_CLOCK__ */ 
  767.     MMI_status_icon_bars[status_bar_ID].flags = flags;
  768. }
  771. /* 061306 dummy category Start */
  772. /*****************************************************************************
  773.  * FUNCTION
  774.  *  get_status_icon_bar_type
  775.  * DESCRIPTION
  776.  *  hide the status bar
  777.  * PARAMETERS
  778.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  779.  * RETURNS
  780.  *  
  781.  *****************************************************************************/
  782. U32 get_status_icon_bar_type(U8 status_bar_ID)
  783. {
  784.     /*----------------------------------------------------------------*/
  785.     /* Local Variables                                                */
  786.     /*----------------------------------------------------------------*/
  788.     /*----------------------------------------------------------------*/
  789.     /* Code Body                                                      */
  790.     /*----------------------------------------------------------------*/
  791.     return MMI_status_icon_bars[status_bar_ID].flags;
  792. }
  793. /* 061306 dummy category End */
  796. /*****************************************************************************
  797.  * FUNCTION
  798.  *  get_status_icon_bar_clip
  799.  * DESCRIPTION
  800.  *  get teh clipping valeu sof particaular status bar
  801.  * PARAMETERS
  802.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  803.  *  x1                  [IN]        Start x position
  804.  *  y1                  [IN]        Start y position
  805.  *  x2                  [IN]        End x position
  806.  *  y2                  [IN]        End y position
  807.  *  horizontal(?)       [IN]        Bar sub lcd
  808.  *  vertical(?)         [IN]        Bar main lcd
  809.  * RETURNS
  810.  *  void
  811.  *****************************************************************************/
  812. void get_status_icon_bar_clip(U8 status_bar_ID, S32 *x1, S32 *y1, S32 *x2, S32 *y2)
  813. {
  814.     /*----------------------------------------------------------------*/
  815.     /* Local Variables                                                */
  816.     /*----------------------------------------------------------------*/
  818.     /*----------------------------------------------------------------*/
  819.     /* Code Body                                                      */
  820.     /*----------------------------------------------------------------*/
  821.     *x1 = MMI_status_icon_bars[status_bar_ID].x1;
  822.     *y1 = MMI_status_icon_bars[status_bar_ID].y1;
  823.     *x2 = MMI_status_icon_bars[status_bar_ID].x2;
  824.     *y2 = MMI_status_icon_bars[status_bar_ID].y2;
  825. }
  828. /*****************************************************************************
  829.  * FUNCTION
  830.  *  set_status_icon_bar_clip
  831.  * DESCRIPTION
  832.  *  set teh clipping valeu sof particaular status bar
  833.  * PARAMETERS
  834.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  835.  *  x1                  [IN]        Start x position
  836.  *  y1                  [IN]        Start y position
  837.  *  x2                  [IN]        End x position
  838.  *  y2                  [IN]        End y position
  839.  *  horizontal(?)       [IN]        Bar sub lcd
  840.  *  vertical(?)         [IN]        Bar main lcd
  841.  * RETURNS
  842.  *  void
  843.  *****************************************************************************/
  844. void set_status_icon_bar_clip(U8 status_bar_ID, S32 x1, S32 y1, S32 x2, S32 y2)
  845. {
  846.     /*----------------------------------------------------------------*/
  847.     /* Local Variables                                                */
  848.     /*----------------------------------------------------------------*/
  850.     /*----------------------------------------------------------------*/
  851.     /* Code Body                                                      */
  852.     /*----------------------------------------------------------------*/
  853.     MMI_status_icon_bars[status_bar_ID].x1 = x1;
  854.     MMI_status_icon_bars[status_bar_ID].y1 = y1;
  855.     MMI_status_icon_bars[status_bar_ID].x2 = x2;
  856.     MMI_status_icon_bars[status_bar_ID].y2 = y2;
  857.     /* PMT VIKAS START 20050707 */
  858. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  859.     MMI_status_icon_bars[status_bar_ID].x = x1;
  860.     MMI_status_icon_bars[status_bar_ID].y = y1;
  861. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  862.     /* PMT VIKAS END 20050707 */
  863. }
  865. /* 061506 double buffer Start */
  866. /*****************************************************************************
  867.  * FUNCTION
  868.  *  set_status_icon_bar_layer
  869.  * DESCRIPTION
  870.  *  set gdi layer handle
  871.  * PARAMETERS
  872.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  873.  *  gdi_layer               [IN]        
  874.  *  horizontal(?)       [IN]        Bar sub lcd
  875.  *  vertical(?)         [IN]        Bar main lcd
  876.  * RETURNS
  877.  *  void
  878.  *****************************************************************************/
  879. void set_status_icon_bar_layer(U8 status_bar_ID, GDI_HANDLE gdi_layer)
  880. {
  881. #ifdef __MMI_SUBLCD_SHOW_ANALOG_CLOCK__
  882.     /*----------------------------------------------------------------*/
  883.     /* Local Variables                                                */
  884.     /*----------------------------------------------------------------*/
  886.     /*----------------------------------------------------------------*/
  887.     /* Code Body                                                      */
  888.     /*----------------------------------------------------------------*/
  889.     if (status_bar_ID == 2)
  890.     {
  891.         return;
  892.     }
  893. #endif /* __MMI_SUBLCD_SHOW_ANALOG_CLOCK__ */ 
  894.     MMI_status_icon_bars[status_bar_ID].layer_handle= gdi_layer;
  895. }
  898. /*****************************************************************************
  899.  * FUNCTION
  900.  *  get_status_icon_bar_layer
  901.  * DESCRIPTION
  902.  *  get gdi layer handle
  903.  * PARAMETERS
  904.  *  status_bar_ID       [IN]        0 -horizontal bar main lcd
  905.  * RETURNS
  906.  *  
  907.  *****************************************************************************/
  908. U32 get_status_icon_bar_layer(U8 status_bar_ID)
  909. {
  910.     /*----------------------------------------------------------------*/
  911.     /* Local Variables                                                */
  912.     /*----------------------------------------------------------------*/
  914.     /*----------------------------------------------------------------*/
  915.     /* Code Body                                                      */
  916.     /*----------------------------------------------------------------*/
  917.     return MMI_status_icon_bars[status_bar_ID].layer_handle;
  918. }
  919. /* 061506 double buffer End */
  922. /*****************************************************************************
  923.  * FUNCTION
  924.  *  reset_status_icons
  925.  * DESCRIPTION
  926.  *  Function to be used by wgui_categories.
  927.  *  This must be called in the exit function of the category
  928.  *  screens that have displayed status icons and / or registered
  929.  *  functions for hiding them.
  930.  * PARAMETERS
  931.  *  void
  932.  * RETURNS
  933.  *  void
  934.  *****************************************************************************/
  935. void reset_status_icons(void)
  936. {
  937.     /*----------------------------------------------------------------*/
  938.     /* Local Variables                                                */
  939.     /*----------------------------------------------------------------*/
  941.     /*----------------------------------------------------------------*/
  942.     /* Code Body                                                      */
  943.     /*----------------------------------------------------------------*/
  944.     hide_status_icons();
  945.     clear_hide_status_icon_bars();
  946. }
  949. /*****************************************************************************
  950.  * FUNCTION
  951.  *  initialize_status_icons
  952.  * DESCRIPTION
  953.  *  Called once during bootup to initialize Status icons
  954.  * PARAMETERS
  955.  *  void
  956.  * RETURNS
  957.  *  void
  958.  *****************************************************************************/
  959. //Moved up
  960. //extern S32 MAIN_LCD_device_width;
  961. //extern S32 MAIN_LCD_device_height;
  963. #ifdef __MMI_SUBLCD__
  964. extern S32 SUB_LCD_device_width;
  965. extern S32 SUB_LCD_device_height;
  966. #endif /* __MMI_SUBLCD__ */ 
  968. void initialize_status_icons(void)
  969. {
  970.     /*----------------------------------------------------------------*/
  971.     /* Local Variables                                                */
  972.     /*----------------------------------------------------------------*/
  973.     S32 i;
  975.     /*----------------------------------------------------------------*/
  976.     /* Code Body                                                      */
  977.     /*----------------------------------------------------------------*/
  978.     /* PMT HIMANSHU START 20050625 */
  979. #if defined(__MMI_UI_TECHNO_STATUS_ICON__)
  980.     MMI_status_icon_bars[0].x = 0;
  981.     MMI_status_icon_bars[0].y = 0;
  982.     MMI_status_icon_bars[0].x1 = 0;
  983.     MMI_status_icon_bars[0].y1 = 0;
  984.     MMI_status_icon_bars[0].x2 = MAIN_LCD_device_width - 1;
  985.     MMI_status_icon_bars[0].y2 = MMI_status_bar_height - 1;
  987.     /* set the cliping values of vertical status bar of main lcd */
  988.     MMI_status_icon_bars[1].x = 0;
  989.     MMI_status_icon_bars[1].y = 0;
  990.     MMI_status_icon_bars[1].x1 = 0;
  991.     MMI_status_icon_bars[1].y1 = 0;
  992.     MMI_status_icon_bars[1].x2 = 0;
  993.     MMI_status_icon_bars[1].y2 = 0;
  994.     /* PMT VIKAS START 20050707 */
  995. #elif defined( __MMI_UI_DALMATIAN_STATUSBAR__)
  996.     MMI_status_icon_bars[0].x = 0;
  997.     MMI_status_icon_bars[0].y = MMI_TITLE_HEIGHT + STATUS_TITLE_GAP;
  998.     MMI_status_icon_bars[0].x1 = 0;
  999.     MMI_status_icon_bars[0].y1 = MMI_TITLE_HEIGHT + STATUS_TITLE_GAP;
  1000.     MMI_status_icon_bars[0].x2 = MMI_STATUS_BAR_WIDTH - 1;
  1001.     MMI_status_icon_bars[0].y2 = MMI_status_icon_bars[0].y1 + MMI_SINGLE_STATUS_BAR_HEIGHT - 1;
  1003.     MMI_status_icon_bars[1].x = MAIN_LCD_device_width - MMI_STATUS_BAR_WIDTH;
  1004.     MMI_status_icon_bars[1].y = MMI_TITLE_HEIGHT + MMI_STATUS_BAR_HEIGHT
  1005.         - MMI_SINGLE_STATUS_BAR_HEIGHT + STATUS_TITLE_GAP;
  1006.     MMI_status_icon_bars[1].x1 = MAIN_LCD_device_width - MMI_STATUS_BAR_WIDTH;
  1007.     MMI_status_icon_bars[1].y1 = MMI_TITLE_HEIGHT + MMI_STATUS_BAR_HEIGHT
  1008.         - MMI_SINGLE_STATUS_BAR_HEIGHT + STATUS_TITLE_GAP;
  1009.     MMI_status_icon_bars[1].x2 = MAIN_LCD_device_width - 1;
  1010.     MMI_status_icon_bars[1].y2 = MMI_status_icon_bars[1].y1 + MMI_STATUS_BAR_HEIGHT - 1;
  1012.     /* PMT VIKAS END 20050707 */
  1013. #else /* set the cliping values of horizontal status bar of main lcd */
  1014.     MMI_status_icon_bars[0].x = 0;
  1015.     MMI_status_icon_bars[0].y = 0;
  1016.     MMI_status_icon_bars[0].x1 = 0;
  1017.     MMI_status_icon_bars[0].y1 = 0;
  1018.     MMI_status_icon_bars[0].x2 = MAIN_LCD_device_width - 1;
  1019.     MMI_status_icon_bars[0].y2 = MMI_status_bar_height - 1;
  1021.     /* set the cliping values of vertical status bar of main lcd */
  1022.     MMI_status_icon_bars[1].x = MAIN_LCD_device_width - 17;
  1023.     MMI_status_icon_bars[1].y = MMI_status_bar_height;
  1024.     MMI_status_icon_bars[1].x1 = MAIN_LCD_device_width - 17;
  1025.     MMI_status_icon_bars[1].y1 = MMI_status_bar_height;
  1026.     MMI_status_icon_bars[1].x2 = MAIN_LCD_device_width - 1;
  1027.     /* 070905 Calvin Start */
  1028. #ifdef __MMI_KLG__
  1029.     MMI_status_icon_bars[1].y2 = MAIN_LCD_device_height >> 1;
  1030. #else 
  1031.     MMI_status_icon_bars[1].y2 = MAIN_LCD_device_height - MMI_button_bar_height - 1;
  1032. #endif 
  1033.     /* 070905 Calvin End */
  1035. #endif 
  1036.     /* PMT HIMANSHU END */
  1038.     /* set the hide functions of statuas bar to dummy function  */
  1039.     for (i = 0; i < MAX_STATUS_ICON_BARS; i++)
  1040.     {
  1041.         MMI_hide_status_icon_bars[i] = UI_dummy_function;
  1042.         /* PMT VIKAS START 20050707 */
  1043.     #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  1044.         /* MMI_status_icon_bars[i].normal_bar_filler = NULL; */
  1045.     #endif 
  1046.         /* PMT VIKAS END 20050707 */
  1047.     }
  1049.     for (i = 0; i < MAX_STATUS_ICONS; i++)
  1050.     {
  1051.         MMI_status_icons[i].icon_data = get_image(MMI_status_icons[i].icon_ID);
  1052.         MMI_status_icons[i].n_frames = (S16) gui_image_n_frames(MMI_status_icons[i].icon_data);
  1053.         gui_measure_image(MMI_status_icons[i].icon_data, &MMI_status_icons[i].width, &MMI_status_icons[i].height);
  1054.     }
  1055.     /* PMT VIKAS START 20050707 */
  1056. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  1057.     MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].x = (MAIN_LCD_device_width - 1)
  1058.         - MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].width - MMI_status_icon_bars[1].x;
  1059. #else /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  1061.     /* set the start x position of battery icon of horizontal man lcd status bar */
  1062.     MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].x =
  1063.         MAIN_LCD_device_width - 1 - MMI_status_icons[STATUS_ICON_BATTERY_STRENGTH].width;
  1065. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  1066.     /* PMT VIKAS END 20050707 */
  1067. #ifdef __MMI_SUBLCD__
  1068.     /* set the cliping values of horizontal status bar of sub lcd */
  1069.     MMI_status_icon_bars[2].x = 0;
  1070.     MMI_status_icon_bars[2].y = 0;
  1071.     MMI_status_icon_bars[2].x1 = 0;
  1072.     MMI_status_icon_bars[2].y1 = 0;
  1073.     MMI_status_icon_bars[2].x2 = SUB_LCD_device_width - 1;
  1074.     MMI_status_icon_bars[2].y2 = 14;
  1075.     MMI_status_icons[STATUS_ICON_SUBLCD_SIGNAL_STRENGTH].x = 1;
  1076.     MMI_status_icons[STATUS_ICON_SUBLCD_BATTERY_STRENGTH].x =
  1077.         SUB_LCD_device_width - 1 - MMI_status_icons[STATUS_ICON_SUBLCD_BATTERY_STRENGTH].width;
  1078. #endif /* __MMI_SUBLCD__ */ 
  1079. }
  1081. /* 030705 Calvin removed */
  1082. #if 0
  1083. /* under construction !*/
  1084. /* under construction !*/
  1085. /* under construction !*/
  1086. /* under construction !*/
  1087. /* under construction !*/
  1088. /* under construction !*/
  1089. /* under construction !*/
  1090. /* under construction !*/
  1091. /* under construction !*/
  1092. /* under construction !*/
  1093. /* under construction !*/
  1094. /* under construction !*/
  1095. /* under construction !*/
  1096. /* under construction !*/
  1097. /* under construction !*/
  1098. /* under construction !*/
  1099. /* under construction !*/
  1100. /* under construction !*/
  1101. /* under construction !*/
  1102. /* under construction !*/
  1103. /* under construction !*/
  1104. /* under construction !*/
  1105. #endif /* 0 */ 
  1106. /* Calvin end */
  1109. /*****************************************************************************
  1110.  * FUNCTION
  1111.  *  ShowStatusIcon
  1112.  * DESCRIPTION
  1113.  *  show particular icon
  1114.  * PARAMETERS
  1115.  *  icon_ID     [IN]        
  1116.  * RETURNS
  1117.  *  void
  1118.  *****************************************************************************/
  1119. void ShowStatusIcon(S16 icon_ID)
  1120. {
  1121.     /*----------------------------------------------------------------*/
  1122.     /* Local Variables                                                */
  1123.     /*----------------------------------------------------------------*/
  1125.     /*----------------------------------------------------------------*/
  1126.     /* Code Body                                                      */
  1127.     /*----------------------------------------------------------------*/
  1128.     if ((icon_ID < 0) || (icon_ID >= MAX_STATUS_ICONS))
  1129.     {
  1130.         return;
  1131.     }
  1133.     /* 2005/10/20 Hide status icon in flight mode */
  1134. #ifdef __FLIGHT_MODE_SUPPORT__
  1135. #ifdef __MMI_WLAN_FEATURES__
  1136.     if (mmi_bootup_get_active_flight_mode() == 1 || mmi_netset_get_active_preferred_mode() == 1 || mmi_bootup_is_sim_valid() == MMI_FALSE)
  1137. #else
  1138.     if (mmi_bootup_get_active_flight_mode() == 1 || mmi_bootup_is_sim_valid() == MMI_FALSE)
  1139. #endif
  1140.     {
  1141.         pBOOL rtn = PhnsetFlightModeHideButSaveStatusIcon(icon_ID, MMI_status_icons[icon_ID].flags | STATUS_ICON_DISPLAY);
  1142.         if (rtn == MMI_TRUE && (gPowerOnWithFlightMode == MMI_TRUE || mmi_bootup_is_sim_valid() == MMI_FALSE))
  1143.         {
  1144.             return;
  1145.         }
  1146.     }
  1147. #else /* __FLIGHT_MODE_SUPPORT__ */ 
  1148.     if (mmi_bootup_is_sim_valid() == MMI_FALSE)
  1149.     {
  1150.         if (PhnsetFlightModeHideButSaveStatusIcon(icon_ID, MMI_status_icons[icon_ID].flags | STATUS_ICON_DISPLAY) ==
  1151.             MMI_TRUE)
  1152.         {
  1153.             return;
  1154.         }
  1155.     }
  1156. #endif /* __FLIGHT_MODE_SUPPORT__ */ 
  1158.     /* set the flag of icon to display on */
  1159.     MMI_status_icons[icon_ID].flags |= STATUS_ICON_DISPLAY;
  1161.     /* set rearrange flag on */
  1162.     IsReArrangeNeeded = 1;
  1163. }
  1166. /*****************************************************************************
  1167.  * FUNCTION
  1168.  *  HideStatusIcon
  1169.  * DESCRIPTION
  1170.  *  hide particular icon
  1171.  * PARAMETERS
  1172.  *  icon_ID     [IN]        
  1173.  * RETURNS
  1174.  *  void
  1175.  *****************************************************************************/
  1176. void HideStatusIcon(S16 icon_ID)
  1177. {
  1178.     /*----------------------------------------------------------------*/
  1179.     /* Local Variables                                                */
  1180.     /*----------------------------------------------------------------*/
  1182.     /*----------------------------------------------------------------*/
  1183.     /* Code Body                                                      */
  1184.     /*----------------------------------------------------------------*/
  1185.     if ((icon_ID < 0) || (icon_ID >= MAX_STATUS_ICONS))
  1186.     {
  1187.         return;
  1188.     }
  1190.     /* set teh flag of icon to hide ...defualt value */
  1191.     MMI_status_icons[icon_ID].flags = 0;
  1193.     /* set rearrange flag on */
  1194.     IsReArrangeNeeded = 1;
  1196.     /* 2005/10/20 Hide status icon in flight mode */
  1197. #ifdef __FLIGHT_MODE_SUPPORT__
  1198. #ifdef __MMI_WLAN_FEATURES__
  1199.     if (mmi_bootup_get_active_flight_mode() == 1 || mmi_netset_get_active_preferred_mode() == 1)
  1200. #else
  1201.     if (mmi_bootup_get_active_flight_mode() == 1)
  1202. #endif
  1203.     {
  1204.         PhnsetFlightModeHideButSaveStatusIcon(icon_ID, 0);
  1205.     }
  1206. #endif /* __FLIGHT_MODE_SUPPORT__ */ 
  1207. }
  1210. /*****************************************************************************
  1211.  * FUNCTION
  1212.  *  UpdateStatusIcons
  1213.  * DESCRIPTION
  1214.  *  rearrange and refresh status icons
  1215.  * PARAMETERS
  1216.  *  void
  1217.  * RETURNS
  1218.  *  void
  1219.  *****************************************************************************/
  1220. void UpdateStatusIcons(void)
  1221. {
  1222.     /*----------------------------------------------------------------*/
  1223.     /* Local Variables                                                */
  1224.     /*----------------------------------------------------------------*/
  1226.     /*----------------------------------------------------------------*/
  1227.     /* Code Body                                                      */
  1228.     /*----------------------------------------------------------------*/
  1229.     if (IsReArrangeNeeded)
  1230.     {
  1231.         arrange_status_icons();
  1232.         IsReArrangeNeeded = 0;
  1233.     }
  1235.     refresh_status_icon_display();
  1236. }
  1239. /*****************************************************************************
  1240.  * FUNCTION
  1241.  *  UpdateSubLCDStatusIcons
  1242.  * DESCRIPTION
  1243.  *  rearrange and refresh SubLCD status icons
  1244.  * PARAMETERS
  1245.  *  void
  1246.  * RETURNS
  1247.  *  void
  1248.  *****************************************************************************/
  1249. void UpdateSubLCDStatusIcons(void)
  1250. {
  1251.     /*----------------------------------------------------------------*/
  1252.     /* Local Variables                                                */
  1253.     /*----------------------------------------------------------------*/
  1255.     /*----------------------------------------------------------------*/
  1256.     /* Code Body                                                      */
  1257.     /*----------------------------------------------------------------*/
  1258.     set_status_icon_display(SUBLCD_ONLY);
  1259.     UpdateStatusIcons();
  1260.     reset_status_icon_display();
  1261. }
  1264. /*****************************************************************************
  1265.  * FUNCTION
  1266.  *  ChangeStatusIconLevel
  1267.  * DESCRIPTION
  1268.  *  change the level of status icon like battery icon ,signal icon
  1269.  * PARAMETERS
  1270.  *  icon_ID                 [IN]        
  1271.  *  level_percentage        [IN]        Level of increase
  1272.  * RETURNS
  1273.  *  void
  1274.  *****************************************************************************/
  1275. void ChangeStatusIconLevel(S16 icon_ID, U8 level_percentage)
  1276. {
  1277.     /*----------------------------------------------------------------*/
  1278.     /* Local Variables                                                */
  1279.     /*----------------------------------------------------------------*/
  1280.     S32 n_frames = MMI_status_icons[icon_ID].n_frames;
  1281.     S32 frame_number;
  1283.     /*----------------------------------------------------------------*/
  1284.     /* Code Body                                                      */
  1285.     /*----------------------------------------------------------------*/
  1286.     if (n_frames <= 1)
  1287.     {
  1288.         return;
  1289.     }
  1291.     frame_number = (level_percentage * (n_frames)) / 100;
  1293.     /* check frame number not bigger than frames of icons */
  1294.     if (frame_number > (n_frames - 1))
  1295.     {
  1296.         frame_number = n_frames - 1;
  1297.     }
  1299.     /* check frame number more than 0 */
  1300.     if (frame_number < 0)
  1301.     {
  1302.         frame_number = 0;
  1303.     }
  1305.     /* if level is the same, no need to refresh the icon */
  1306.     if (frame_number == MMI_status_icons[icon_ID].state)
  1307.     {
  1308.         return;
  1309.     }
  1311.     if (mmi_bootup_is_in_security_check() == MMI_TRUE)
  1312.     {
  1313.         /* 030705 Calvin removed */
  1314.         /* status_icon_display_locked=1; */
  1315.         if ((icon_ID == STATUS_ICON_BATTERY_STRENGTH) || (icon_ID == STATUS_ICON_SUBLCD_BATTERY_STRENGTH))
  1316.         {
  1317.             set_status_icon_state(icon_ID, (U8) frame_number);
  1318.         }
  1319.         /* Calvin end */
  1320.     }
  1321.     else
  1322.     {
  1323.         //set the state of icon when MMI in not in power on procedure.
  1324.         //status_icon_display_locked=0;//030705 Calvin removed
  1325.         set_status_icon_state(icon_ID, (U8) frame_number);
  1326.     }
  1327.     /* if(status_icon_display_locked<=0)//030705 Calvin modified */
  1328.     if (mmi_bootup_is_in_security_check() == MMI_FALSE)
  1329.     {
  1330.         /* PMT VIKAS START 20050707 */
  1331.     #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  1332.         if (icon_ID == STATUS_ICON_SIGNAL_STRENGTH)
  1333.         {
  1334.             refresh_fixed_status_icon(icon_ID, 0);
  1335.         }
  1336.         else if (icon_ID == STATUS_ICON_BATTERY_STRENGTH)
  1337.         {
  1338.             refresh_fixed_status_icon(icon_ID, 1);
  1339.         }
  1340.     #else /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  1341.         if ((icon_ID == STATUS_ICON_SIGNAL_STRENGTH) || (icon_ID == STATUS_ICON_BATTERY_STRENGTH))
  1342.         {
  1343.             refresh_fixed_status_icon(icon_ID, 0);
  1344.         }
  1345.     #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  1346.         /* PMT VIKAS END 20050707 */
  1347.         else if ((icon_ID == STATUS_ICON_SUBLCD_SIGNAL_STRENGTH) || (icon_ID == STATUS_ICON_SUBLCD_BATTERY_STRENGTH))
  1348.         {
  1349.             refresh_fixed_status_icon(icon_ID, 2);
  1350.         }
  1351.         else
  1352.             /* Before entry idlescreen, only signal and battery should be udpated. */
  1353.     #ifndef __MMI_SHOW_ALL_STATUS_ICONS_B4_IDLE___
  1354.         if (mmi_bootup_is_in_security_check() == MMI_FALSE)
  1355.     #endif 
  1356.             refresh_status_icon_display();
  1357.     }
  1358. }
  1360. /* 022505 Calvin added */
  1363. /*****************************************************************************
  1364.  * FUNCTION
  1365.  *  ChangeStatusIconImage
  1366.  * DESCRIPTION
  1367.  *  change the image of status icon like signal icon with line switch
  1368.  * PARAMETERS
  1369.  *  icon_ID         [IN]        
  1370.  *  image_ID        [IN]        
  1371.  * RETURNS
  1372.  *  void
  1373.  *****************************************************************************/
  1374. void ChangeStatusIconImage(S16 icon_ID, U16 image_ID)
  1375. {
  1376.     /*----------------------------------------------------------------*/
  1377.     /* Local Variables                                                */
  1378.     /*----------------------------------------------------------------*/
  1380.     /*----------------------------------------------------------------*/
  1381.     /* Code Body                                                      */
  1382.     /*----------------------------------------------------------------*/
  1383.     /* HideStatusIcon(icon_ID); */
  1384.     MMI_status_icons[icon_ID].icon_data = get_image(image_ID);
  1385.     MMI_status_icons[icon_ID].n_frames = (S16) gui_image_n_frames(MMI_status_icons[icon_ID].icon_data);
  1386.     gui_measure_image(
  1387.         MMI_status_icons[icon_ID].icon_data,
  1388.         &MMI_status_icons[icon_ID].width,
  1389.         &MMI_status_icons[icon_ID].height);
  1390.     MMI_status_icons[icon_ID].icon_ID = image_ID;
  1391.     /* ShowStatusIcon(icon_ID); */
  1393.     /* set rearrange flag on */
  1394.     IsReArrangeNeeded = 1;
  1396.     /* update status icon */
  1397.     /* UpdateStatusIcons();//101805 ChangeStatusIconImage Calvin: status icon will always be shown if redrawcategory */
  1398. }
  1400. /* Calvin end */
  1401. /* PMT HIMANSHU START 20050625 */
  1402. #if defined(__MMI_UI_TECHNO_STATUS_ICON__)
  1405. /*****************************************************************************
  1406.  * FUNCTION
  1407.  *  ChangeStatusIconImageWithoutReArrange
  1408.  * DESCRIPTION
  1409.  *  
  1410.  * PARAMETERS
  1411.  *  icon_ID         [IN]        
  1412.  *  image_ID        [IN]        
  1413.  * RETURNS
  1414.  *  void
  1415.  *****************************************************************************/
  1416. void ChangeStatusIconImageWithoutReArrange(S16 icon_ID, U16 image_ID)
  1417. {
  1418.     /*----------------------------------------------------------------*/
  1419.     /* Local Variables                                                */
  1420.     /*----------------------------------------------------------------*/
  1422.     /*----------------------------------------------------------------*/
  1423.     /* Code Body                                                      */
  1424.     /*----------------------------------------------------------------*/
  1425.     MMI_status_icons[icon_ID].icon_data = get_image(image_ID);
  1426.     MMI_status_icons[icon_ID].n_frames = (S16) gui_image_n_frames(MMI_status_icons[icon_ID].icon_data);
  1427.     gui_measure_image(
  1428.         MMI_status_icons[icon_ID].icon_data,
  1429.         &MMI_status_icons[icon_ID].width,
  1430.         &MMI_status_icons[icon_ID].height);
  1431.     MMI_status_icons[icon_ID].icon_ID = image_ID;
  1432. }
  1433. #endif /* defined(__MMI_UI_TECHNO_STATUS_ICON__) */ 
  1434. /* PMT HIMANSHU END */
  1437. /*****************************************************************************
  1438.  * FUNCTION
  1439.  *  AnimateStatusIcon
  1440.  * DESCRIPTION
  1441.  *  animate particular icon
  1442.  * PARAMETERS
  1443.  *  icon_ID     [IN]        
  1444.  * RETURNS
  1445.  *  void
  1446.  *****************************************************************************/
  1447. void AnimateStatusIcon(S16 icon_ID)
  1448. {
  1449.     /*----------------------------------------------------------------*/
  1450.     /* Local Variables                                                */
  1451.     /*----------------------------------------------------------------*/
  1453.     /*----------------------------------------------------------------*/
  1454.     /* Code Body                                                      */
  1455.     /*----------------------------------------------------------------*/
  1456.     ShowStatusIcon(icon_ID);
  1458.     /* animate the icon */
  1459.     animate_status_icon(icon_ID);
  1460. }
  1463. /*****************************************************************************
  1464.  * FUNCTION
  1465.  *  BlinkStatusIcon
  1466.  * DESCRIPTION
  1467.  *  blink particular icon
  1468.  * PARAMETERS
  1469.  *  icon_ID     [IN]        
  1470.  * RETURNS
  1471.  *  void
  1472.  *****************************************************************************/
  1473. void BlinkStatusIcon(S16 icon_ID)
  1474. {
  1475.     /*----------------------------------------------------------------*/
  1476.     /* Local Variables                                                */
  1477.     /*----------------------------------------------------------------*/
  1479.     /*----------------------------------------------------------------*/
  1480.     /* Code Body                                                      */
  1481.     /*----------------------------------------------------------------*/
  1482.     ShowStatusIcon(icon_ID);
  1484.     /* blink the icon */
  1485.     blink_status_icon(icon_ID);
  1486. }
  1489. /*****************************************************************************
  1490.  * FUNCTION
  1491.  *  arrange_status_icons_sublcd
  1492.  * DESCRIPTION
  1493.  *  arrange status icon of sub lcd
  1494.  * PARAMETERS
  1495.  *  void
  1496.  * RETURNS
  1497.  *  void
  1498.  *****************************************************************************/
  1499. void arrange_status_icons_sublcd(void)
  1500. {
  1501.     /*----------------------------------------------------------------*/
  1502.     /* Local Variables                                                */
  1503.     /*----------------------------------------------------------------*/
  1504.     S32 i, j, k = 0, group_ID;
  1505.     U8 done = 0, inner_done, display_flag;
  1507. #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1508.     S32 cy;
  1509. #endif 
  1511.     /*----------------------------------------------------------------*/
  1512.     /* Code Body                                                      */
  1513.     /*----------------------------------------------------------------*/
  1514. #ifdef __MMI_SUBLCD_SHOW_ANALOG_CLOCK__
  1515.     return;
  1516. #endif 
  1517.     GDI_LOCK;
  1518.     MMI_status_icon_bars[2].n_icons = 0;
  1519.     MMI_status_icons_list3[0] = STATUS_ICON_SUBLCD_SIGNAL_STRENGTH;
  1520.     MMI_status_icons_list3[1] = STATUS_ICON_SUBLCD_BATTERY_STRENGTH;
  1522. #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1523.     cy = MMI_status_icon_bars[2].y2 - MMI_status_icon_bars[2].y1 - 1;
  1524. #endif 
  1526.     done = 0;
  1527.     i = 0;
  1528.     while (!done)
  1529.     {
  1530.         display_flag = 0;
  1531.         j = MMI_status_icons_pool2[i];
  1532.         i++;
  1533.         if (i >= MMI_N_STATUS_ICONS_POOL2)
  1534.         {
  1535.             break;
  1536.         }
  1537.         if (TEST_STATUS_ICON_DISPLAY_ON(MMI_status_icons[j].flags))
  1538.         {
  1539.             k = j;
  1540.             display_flag = 1;
  1541.         }
  1542.         if ((MMI_status_icons[j].group_ID > 0))
  1543.         {
  1544.             group_ID = MMI_status_icons[j].group_ID;
  1545.             j++;
  1546.             inner_done = 0;
  1547.             while (!inner_done)
  1548.             {
  1549.                 if (group_ID != MMI_status_icons[j].group_ID)
  1550.                 {
  1551.                     break;
  1552.                 }
  1553.                 if ((!display_flag) && TEST_STATUS_ICON_DISPLAY_ON(MMI_status_icons[j].flags))
  1554.                 {
  1555.                     display_flag = 1;
  1556.                     k = j;
  1557.                 }
  1558.                 else
  1559.                 {
  1560.                     i++;
  1561.                     j++;
  1562.                 }
  1563.             }
  1564.         }
  1566.         if (display_flag)
  1567.         {
  1568.             MMI_status_icons_list3[MMI_status_icon_bars[2].n_icons] = (S16) k;
  1569.             MMI_status_icon_bars[2].n_icons++;
  1570.         #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1571.             MMI_status_icons[k].y = cy - MMI_status_icons[k].height;
  1572.         #endif 
  1573.         }
  1574.     }
  1575.     GDI_UNLOCK;
  1576. }
  1579. /*****************************************************************************
  1580.  * FUNCTION
  1581.  *  arrange_status_icons1
  1582.  * DESCRIPTION
  1583.  *  arrange status icon horizontal and vertical staus bar of main lcd
  1584.  * PARAMETERS
  1585.  *  void
  1586.  * RETURNS
  1587.  *  void
  1588.  *****************************************************************************/
  1589. void arrange_status_icons1(void)
  1590. {
  1591.     /*----------------------------------------------------------------*/
  1592.     /* Local Variables                                                */
  1593.     /*----------------------------------------------------------------*/
  1594.     S32 x1, y1, x2, y2, x, y, cy;
  1595.     S32 i, j, k = 0, group_ID;
  1596.     U8 done = 0, inner_done, display_flag;
  1597.     S32 old_i;  /* 122004 Calvin added */
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Code Body                                                      */
  1601.     /*----------------------------------------------------------------*/
  1602.     /* Status bar 1: Horizontal bar  */
  1604.     MMI_status_icons_list1[0] = STATUS_ICON_SIGNAL_STRENGTH;
  1605.     MMI_status_icons_list1[1] = STATUS_ICON_BATTERY_STRENGTH;
  1606.     MMI_status_icon_bars[0].n_icons = 2;
  1608.     x1 = MMI_status_icon_bars[0].x1;    /* store start x position of horizontal stats bar of main lcd */
  1609.     y1 = MMI_status_icon_bars[0].y1;    /* store start y position of horizontal stats bar of main lcd */
  1610.     x2 = MMI_status_icon_bars[0].x2;    /* store end x position of horizontal stats bar of main lcd */
  1611.     y2 = MMI_status_icon_bars[0].y2;    /* store end y position of horizontal stats bar of main lcd */
  1613.     /* Shift x1,x2 assuming signal strength and battery strength icons are at either ends  */
  1614.     x1 += MMI_status_icons[MMI_status_icons_list1[0]].width - 1 + STATUS_ICON_X_GAP;
  1615.     x2 = MMI_status_icons[MMI_status_icons_list1[1]].x - STATUS_ICON_X_GAP;
  1616. #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1617.     cy = y2 - y1 - 1;
  1618. #else 
  1619.     cy = (y2 - y1 + 1) >> 1;
  1620. #endif 
  1622. #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1623.     MMI_status_icons[0].y = cy - MMI_status_icons[0].height;
  1624.     MMI_status_icons[1].y = cy - MMI_status_icons[1].height;
  1625. #else /* (STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE) */ 
  1626.     MMI_status_icons[0].y = cy - (MMI_status_icons[0].height >> 1);
  1627.     MMI_status_icons[1].y = cy - (MMI_status_icons[1].height >> 1);
  1628. #endif /* (STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE) */ 
  1630.     i = 2;
  1631.     x = x1 + STATUS_ICON_X_GAP;
  1632.     while (!done)
  1633.     {
  1634.         display_flag = 0;
  1635.         j = MMI_status_icons_pool1[i];
  1636.         old_i = i;  /* 122004 Calvin added */
  1637.         i++;
  1638.         if (i > MMI_N_STATUS_ICONS_POOL1)
  1639.         {
  1640.             break;
  1641.         }
  1642.         if (TEST_STATUS_ICON_DISPLAY_ON(MMI_status_icons[j].flags))
  1643.         {
  1644.             k = j;
  1645.             display_flag = 1;
  1646.         }
  1647.         if ((MMI_status_icons[j].group_ID > 0))
  1648.         {
  1649.             group_ID = MMI_status_icons[j].group_ID;
  1650.             j++;
  1651.             inner_done = 0;
  1652.             while (!inner_done)
  1653.             {
  1654.                 if (group_ID != MMI_status_icons[j].group_ID)
  1655.                 {
  1656.                     break;
  1657.                 }
  1658.                 if ((!display_flag) && TEST_STATUS_ICON_DISPLAY_ON(MMI_status_icons[j].flags))
  1659.                 {
  1660.                     display_flag = 1;
  1661.                     k = j;
  1662.                 }
  1663.                 else
  1664.                 {
  1665.                     i++;
  1666.                     j++;
  1667.                 }
  1668.             }
  1669.         }
  1670.         if (display_flag)
  1671.         {
  1672.             if ((x + MMI_status_icons[k].width + STATUS_ICON_X_GAP) > x2)
  1673.             {               /* i--; */
  1674.                 i = old_i;  /* 122004 Calvin changed */
  1675.                 break;
  1676.             }
  1677.         #if(STATUS_ICONS_DRAW_FROM_BOTTOM_BASELINE)
  1678.             y = cy - MMI_status_icons[k].height;
  1679.         #else 
  1680.             y = cy - (MMI_status_icons[k].height >> 1);
  1681.         #endif 
  1682.             MMI_status_icons[k].x = x;  /* store x position of ion */
  1683.             MMI_status_icons[k].y = y;  /* stor y position of icon */
  1684.             x += MMI_status_icons[k].width + STATUS_ICON_X_GAP;
  1685.             MMI_status_icons_list1[MMI_status_icon_bars[0].n_icons] = (S16) k;
  1686.             MMI_status_icon_bars[0].n_icons++;
  1687.         }
  1688.     }
  1690. }
  1693. /*****************************************************************************
  1694.  * FUNCTION
  1695.  *  show_status_icon1
  1696.  * DESCRIPTION
  1697.  *  set teh flag of icon to show
  1698.  * PARAMETERS
  1699.  *  icon_ID     [IN]        
  1700.  * RETURNS
  1701.  *  void
  1702.  *****************************************************************************/
  1703. void show_status_icon1(S16 icon_ID)
  1704. {
  1705.     /*----------------------------------------------------------------*/
  1706.     /* Local Variables                                                */
  1707.     /*----------------------------------------------------------------*/
  1709.     /*----------------------------------------------------------------*/
  1710.     /* Code Body                                                      */
  1711.     /*----------------------------------------------------------------*/
  1712.     if ((icon_ID < 0) || (icon_ID >= MAX_STATUS_ICONS))
  1713.     {
  1714.         return;
  1715.     }
  1717.     MMI_status_icons[icon_ID].flags |= STATUS_ICON_DISPLAY;
  1718.     arrange_status_icons1();
  1719. }
  1721. /* MTK added by JL 040302 for sublcd background display. */
  1724. /*****************************************************************************
  1725.  * FUNCTION
  1726.  *  show_sublcd_status_background
  1727.  * DESCRIPTION
  1728.  *  Displays the SUBLCD background screen
  1729.  * PARAMETERS
  1730.  *  start_x             [IN]        Left top position
  1731.  *  start_y             [IN]        Left top position
  1732.  *  end_x               [IN]        Right bottom position
  1733.  *  end_y               [IN]        Right bottom position
  1734.  *  is_status_bar       [IN]        Is status bar to draw or not.
  1735.  * RETURNS
  1736.  *  void
  1737.  *****************************************************************************/
  1738. extern S32 Sub_lcd_title_height;
  1739. void show_sublcd_status_background(S32 start_x, S32 start_y, S32 end_x, S32 end_y, U8 is_status_bar)
  1740. {
  1741.     /*----------------------------------------------------------------*/
  1742.     /* Local Variables                                                */
  1743.     /*----------------------------------------------------------------*/
  1745.     /*----------------------------------------------------------------*/
  1746.     /* Code Body                                                      */
  1747.     /*----------------------------------------------------------------*/
  1748.     /* MTK added by JL to draw all screen of background display. */
  1749. #if defined(__MMI_SUBLCD__)
  1750.     GDI_LOCK;
  1751. #if (defined (__MMI_SUBLCD_COLOR__) || defined (__MMI_FULL_SUBLCD_COLOR__))
  1753.     if (!is_status_bar)
  1754.     {
  1755.     #ifdef __MMI_KLG__
  1756.         UI_filled_area f = *current_MMI_theme->list_selected_item_filler;
  1758.         f.c.r = f.c.g = f.c.b = 0;
  1759.     #else /* __MMI_KLG__ */ 
  1760.         UI_filled_area f = *current_MMI_theme->list_selected_item_filler;
  1762.         f.c.alpha = SUBLCD_ALPHA_VALUE;
  1763.         f.c.r = ((f.c.r * f.c.alpha) + (255 * (100 - f.c.alpha))) / 100;
  1764.         f.c.g = ((f.c.g * f.c.alpha) + (255 * (100 - f.c.alpha))) / 100;
  1765.         f.c.b = ((f.c.b * f.c.alpha) + (255 * (100 - f.c.alpha))) / 100;
  1766.     #endif /* __MMI_KLG__ */ 
  1767.     #if defined(__MMI_SUBLCD_COLOR__)
  1768.         start_y = (U16) Sub_lcd_title_height;
  1769.     #endif 
  1770.         gui_push_clip();
  1771.         gui_set_clip(start_x, start_y, end_x, end_y);
  1773.         /* MTK Leo, always draw color, not draw filled area */
  1774.         /* gui_draw_filled_area(start_x, start_y, end_x, end_y, &f); */
  1775.         gui_fill_rectangle(start_x, start_y, end_x, end_y, f.c);
  1776.         gui_pop_clip();
  1777.     }
  1778.     else
  1779.     {
  1780.         /* No process for status basr */
  1781.     #ifdef __MMI_KLG__
  1782.         color c = gui_color(0, 0, 0);
  1783.     #else 
  1784.         color c = gui_color(255, 255, 255);
  1785.     #endif 
  1786.         gui_push_clip();
  1787.         gui_set_clip(start_x, start_y, end_x, end_y);
  1788.         gui_fill_rectangle(start_x, start_y, end_x, end_y, c);
  1789.         gui_pop_clip();
  1790.     }
  1791. #else /* (defined (__MMI_SUBLCD_COLOR__) || defined (__MMI_FULL_SUBLCD_COLOR__)) */ 
  1792.     {
  1793.         color c = gui_color(255, 255, 255);
  1795.         gui_push_clip();
  1796.         gui_set_clip(start_x, start_y, end_x, end_y);
  1797.         gui_fill_rectangle(start_x, start_y, end_x, end_y, c);
  1798.         gui_pop_clip();
  1799.     }
  1800. #endif /* (defined (__MMI_SUBLCD_COLOR__) || defined (__MMI_FULL_SUBLCD_COLOR__)) */ 
  1801.     GDI_UNLOCK;
  1802. #endif /* defined(__MMI_SUBLCD__) */ 
  1804. }
  1807. /*****************************************************************************
  1808.  * FUNCTION
  1809.  *  show_mainlcd_status_bar_background
  1810.  * DESCRIPTION
  1811.  *  
  1812.  * PARAMETERS
  1813.  *  start_x     [IN]        
  1814.  *  start_y     [IN]        
  1815.  *  end_x       [IN]        
  1816.  *  end_y       [IN]        
  1817.  * RETURNS
  1818.  *  void
  1819.  *****************************************************************************/
  1820. void show_mainlcd_status_bar_background(U16 start_x, U16 start_y, U16 end_x, U16 end_y)
  1821. /* Only for status icon bar 0 */
  1822. {
  1823.     /*----------------------------------------------------------------*/
  1824.     /* Local Variables                                                */
  1825.     /*----------------------------------------------------------------*/
  1826.     color c = {255, 255, 255, 100};
  1828.     /*----------------------------------------------------------------*/
  1829.     /* Code Body                                                      */
  1830.     /*----------------------------------------------------------------*/
  1831.     gdi_layer_push_clip();
  1832.     gui_set_clip_preset(start_x, start_y, end_x, end_y);
  1833.     gui_fill_rectangle(start_x, start_y, end_x, end_y, c);
  1834.     gdi_layer_pop_clip();
  1835. }
  1838. /*****************************************************************************
  1839.  * FUNCTION
  1840.  *  set_status_icons_display
  1841.  * DESCRIPTION
  1842.  *  
  1843.  * PARAMETERS
  1844.  *  state       [IN]        
  1845.  * RETURNS
  1846.  *  void
  1847.  *****************************************************************************/
  1848. void set_status_icons_display(MMI_BOOL state)
  1849. {
  1850.     /*----------------------------------------------------------------*/
  1851.     /* Local Variables                                                */
  1852.     /*----------------------------------------------------------------*/
  1854.     /*----------------------------------------------------------------*/
  1855.     /* Code Body                                                      */
  1856.     /*----------------------------------------------------------------*/
  1857.     if (state)
  1858.     {
  1859.         U8 blink_animate_flag = 0;
  1860.         S32 i;
  1862.         status_icon_display_ON = 1;
  1864.         for (i = 0; i < MAX_STATUS_ICONS; i++)
  1865.         {
  1866.             if ((MMI_status_icons[i].flags & STATUS_ICON_BLINK) || (MMI_status_icons[i].flags & STATUS_ICON_ANIMATE))
  1867.             {
  1868.                 blink_animate_flag = 1;
  1869.                 break;
  1870.             }
  1871.         }
  1873.         if (blink_animate_flag == 1)
  1874.         {
  1875.             gui_start_timer(STATUS_ICON_TIMER_RATE, status_icon_timer_callback);        /* start timer for blinking icon */
  1876.         }
  1877.     }
  1878.     else
  1879.     {
  1880.         status_icon_display_ON = 0;
  1881.         gui_cancel_timer(status_icon_timer_callback);
  1882.     }
  1883. }
  1885. /* PMT VIKAS START 20050707 */
  1886. #ifdef __MMI_UI_DALMATIAN_STATUSBAR__
  1889. /*****************************************************************************
  1890.  * FUNCTION
  1891.  *  shuffle_status_bars
  1892.  * DESCRIPTION
  1893.  *  sets the status bar filler to currently selected theme.
  1894.  * PARAMETERS
  1895.  *  void
  1896.  *  pointer(?)      [IN]        To a UI_status_bar_theme
  1897.  * RETURNS
  1898.  *  void
  1899.  *****************************************************************************/
  1900. /*
  1901.  * void gui_set_status_bar_theme(MMI_status_icon_bar *b, UI_status_bar_theme *t)
  1902.  * {
  1903.  * b->normal_bar_filler = t->normal_bar_filler;
  1904.  * }
  1905.  */
  1906. /* function for shuffling the status bars on idle screen. */
  1907. void shuffle_status_bars(void)
  1908. {
  1909.     /*----------------------------------------------------------------*/
  1910.     /* Local Variables                                                */
  1911.     /*----------------------------------------------------------------*/
  1913.     /*----------------------------------------------------------------*/
  1914.     /* Code Body                                                      */
  1915.     /*----------------------------------------------------------------*/
  1916.     if (is_status_bar_shuffled == 0)
  1917.     {
  1918.         is_status_bar_shuffled = 1;
  1919.     }
  1920.     else
  1921.     {
  1922.         is_status_bar_shuffled = 0;
  1923.     }
  1924.     swap_status_bar_positions(&MMI_status_icon_bars[0].y, &MMI_status_icon_bars[1].y);
  1925.     swap_status_bar_positions(&MMI_status_icon_bars[0].y1, &MMI_status_icon_bars[1].y1);
  1926.     swap_status_bar_positions(&MMI_status_icon_bars[0].y2, &MMI_status_icon_bars[1].y2);
  1927.     IsReArrangeNeeded = 1;
  1928.     gui_lock_double_buffer();
  1929.     gui_push_clip();
  1930.     gui_set_clip(
  1931.         0,
  1932.         MMI_title_height + STATUS_TITLE_GAP,
  1933.         UI_device_width - 1,
  1934.         MMI_title_height + STATUS_TITLE_GAP + MMI_status_bar_height - 1);
  1935.     draw_wallpaper();
  1936.     UpdateStatusIcons();
  1937.     gui_pop_clip();
  1938.     gui_unlock_double_buffer();
  1939.     gui_BLT_double_buffer(
  1940.         0,
  1941.         MMI_title_height + STATUS_TITLE_GAP,
  1942.         UI_device_width - 1,
  1943.         MMI_title_height + STATUS_TITLE_GAP + MMI_status_bar_height);
  1944.     // PMT VIKAS START 20050312
  1945.     //gui_start_timer(STATUS_BAR_SHUFFLE_TIMER, shuffle_status_bars);
  1946.     //   PMT VIKAS END
  1947. }
  1950. /*****************************************************************************
  1951.  * FUNCTION
  1952.  *  swap_status_bar_positions
  1953.  * DESCRIPTION
  1954.  *  
  1955.  * PARAMETERS
  1956.  *  x       [?]     
  1957.  *  y       [?]     
  1958.  * RETURNS
  1959.  *  void
  1960.  *****************************************************************************/
  1961. void swap_status_bar_positions(S32 *x, S32 *y)
  1962. {
  1963.     /*----------------------------------------------------------------*/
  1964.     /* Local Variables                                                */
  1965.     /*----------------------------------------------------------------*/
  1966.     S32 temp;
  1968.     /*----------------------------------------------------------------*/
  1969.     /* Code Body                                                      */
  1970.     /*----------------------------------------------------------------*/
  1971.     temp = *x;
  1972.     *x = *y;
  1973.     *y = temp;
  1974. }
  1977. /*****************************************************************************
  1978.  * FUNCTION
  1979.  *  enable_statusbar_fill_background
  1980.  * DESCRIPTION
  1981.  *  enables the flag for showing the background of status bar.
  1982.  * PARAMETERS
  1983.  *  void
  1984.  * RETURNS
  1985.  *  void
  1986.  *****************************************************************************/
  1987. void enable_statusbar_fill_background(void)
  1988. {
  1989.     /*----------------------------------------------------------------*/
  1990.     /* Local Variables                                                */
  1991.     /*----------------------------------------------------------------*/
  1993.     /*----------------------------------------------------------------*/
  1994.     /* Code Body                                                      */
  1995.     /*----------------------------------------------------------------*/
  1996.     /* PMT VIKAS START 20051202 */
  1997.     if (is_on_idlescreen() == 1)
  1998.         /* PMT VIKAS END 20051202 */
  1999.     {
  2000.         background_fill = 1;
  2001.     }
  2002. }
  2005. /*****************************************************************************
  2006.  * FUNCTION
  2007.  *  disable_statusbar_fill_background
  2008.  * DESCRIPTION
  2009.  *  disables the flag for showing the background of status bar.
  2010.  * PARAMETERS
  2011.  *  void
  2012.  * RETURNS
  2013.  *  void
  2014.  *****************************************************************************/
  2015. void disable_statusbar_fill_background(void)
  2016. {
  2017.     /*----------------------------------------------------------------*/
  2018.     /* Local Variables                                                */
  2019.     /*----------------------------------------------------------------*/
  2021.     /*----------------------------------------------------------------*/
  2022.     /* Code Body                                                      */
  2023.     /*----------------------------------------------------------------*/
  2024.     /* PMT VIKAS START 20051202 */
  2025.     if (is_on_idlescreen() == 1)
  2026.         /* PMT VIKAS END 20051202 */
  2027.     {
  2028.         background_fill = 0;
  2029.     }
  2030. }
  2031. #endif /* __MMI_UI_DALMATIAN_STATUSBAR__ */ 
  2032. /* PMT VIKAS END 20050707 */
  2034. /* PMT HIMANSHU START 20050625 */
  2035. #if defined(__MMI_UI_TECHNO_STATUS_ICON__)
  2038. /*****************************************************************************
  2039.  * FUNCTION
  2040.  *  NumberOfDisplayedIcons
  2041.  * DESCRIPTION
  2042.  *  
  2043.  * PARAMETERS
  2044.  *  void
  2045.  * RETURNS
  2046.  *  
  2047.  *****************************************************************************/
  2048. S32 NumberOfDisplayedIcons(void)
  2049. {
  2050.     /*----------------------------------------------------------------*/
  2051.     /* Local Variables                                                */
  2052.     /*----------------------------------------------------------------*/
  2053.     S32 i;
  2054.     S32 icondisplayed = 0;
  2056.     /*----------------------------------------------------------------*/
  2057.     /* Code Body                                                      */
  2058.     /*----------------------------------------------------------------*/
  2059.     for (i = 2; i < MAX_STATUS_ICONS - 10; i++)
  2060.     {
  2061.         if (TEST_STATUS_ICON_DISPLAY_ON(MMI_status_icons[i].flags))
  2062.         {
  2063.             icondisplayed++;
  2064.         }
  2065.     }
  2066.     return (icondisplayed);
  2067. }
  2068. #endif /* defined(__MMI_UI_TECHNO_STATUS_ICON__) */ 
  2069. /* PMT HIMANSHU END */
  2071. #ifdef __MMI_TOUCH_SCREEN__
  2072. MMI_BOOL gIsHandleStatusIconPenEvent = MMI_FALSE;
  2075. /*****************************************************************************
  2076.  * FUNCTION
  2077.  *  wgui_register_status_icon_pen_event_hdlr
  2078.  * DESCRIPTION
  2079.  *  register pen event handlers for status icons.
  2080.  * PARAMETERS
  2081.  *  icon_id         [IN]        Id of icon
  2082.  *  event_type      [IN]        
  2083.  *  f               [IN]        Event handler
  2084.  * RETURNS
  2085.  *  BOOL        if any status icon is touched(?)
  2086.  *****************************************************************************/
  2087. void wgui_register_status_icon_pen_event_hdlr(S16 icon_id, wgui_status_icon_bar_pen_enum event_type, FuncPtr f)
  2088. {
  2089.     /*----------------------------------------------------------------*/
  2090.     /* Local Variables                                                */
  2091.     /*----------------------------------------------------------------*/
  2093.     /*----------------------------------------------------------------*/
  2094.     /* Code Body                                                      */
  2095.     /*----------------------------------------------------------------*/
  2096.     MMI_status_icon_pen_event_hdlr[icon_id][event_type] = f;
  2097.     gIsHandleStatusIconPenEvent = MMI_TRUE;
  2098. }
  2101. /*****************************************************************************
  2102.  * FUNCTION
  2103.  *  wgui_execute_status_icon_pen_event_hdlr
  2104.  * DESCRIPTION
  2105.  *  execute pen event handlers for status icons.
  2106.  * PARAMETERS
  2107.  *  icon_id         [IN]        Id of icon
  2108.  *  event_type      [IN]        
  2109.  * RETURNS
  2110.  *  BOOL        if event handler exists
  2111.  *****************************************************************************/
  2112. MMI_BOOL wgui_execute_status_icon_pen_event_hdlr(S16 icon_id, wgui_status_icon_bar_pen_enum event_type)
  2113. {
  2114.     /*----------------------------------------------------------------*/
  2115.     /* Local Variables                                                */
  2116.     /*----------------------------------------------------------------*/
  2118.     /*----------------------------------------------------------------*/
  2119.     /* Code Body                                                      */
  2120.     /*----------------------------------------------------------------*/
  2121.     if (MMI_status_icon_pen_event_hdlr[icon_id][event_type] != NULL)
  2122.     {
  2123.         MMI_status_icon_pen_event_hdlr[icon_id][event_type] ();
  2124.         return MMI_TRUE;
  2125.     }
  2126.     else
  2127.     {
  2128.         return MMI_FALSE;
  2129.     }
  2130. }
  2133. /*****************************************************************************
  2134.  * FUNCTION
  2135.  *  wgui_reset_status_icon_pen_event_hdlr
  2136.  * DESCRIPTION
  2137.  *  Reset pen event handlers for status icons.
  2138.  * PARAMETERS
  2139.  *  void
  2140.  * RETURNS
  2141.  *  void
  2142.  *****************************************************************************/
  2143. void wgui_reset_status_icon_pen_event_hdlr(void)
  2144. {
  2145.     /*----------------------------------------------------------------*/
  2146.     /* Local Variables                                                */
  2147.     /*----------------------------------------------------------------*/
  2148.     U8 icon_id = 0, event_type = 0;
  2150.     /*----------------------------------------------------------------*/
  2151.     /* Code Body                                                      */
  2152.     /*----------------------------------------------------------------*/
  2153.     for (event_type = 0; event_type < WGUI_STATUS_ICON_BAR_PEN_EVENT_MAX; event_type++)
  2154.         for (icon_id = 0; icon_id < MAX_STATUS_ICONS; icon_id++)
  2155.         {
  2156.             MMI_status_icon_pen_event_hdlr[icon_id][event_type] = NULL;
  2157.         }
  2159.     gIsHandleStatusIconPenEvent = MMI_FALSE;
  2160. }
  2163. /*****************************************************************************
  2164.  * FUNCTION
  2165.  *  wgui_status_icon_translate_pen_position
  2166.  * DESCRIPTION
  2167.  *  Translate pen position for status icons.
  2168.  * PARAMETERS
  2169.  *  x       [IN]        Pen x-coordinate
  2170.  *  y       [IN]        Pen y-coordinate
  2171.  * RETURNS
  2172.  *  S16         icon_index
  2173.  *****************************************************************************/
  2174. S16 wgui_status_icon_translate_pen_position(S16 x, S16 y)
  2175. {
  2176.     /*----------------------------------------------------------------*/
  2177.     /* Local Variables                                                */
  2178.     /*----------------------------------------------------------------*/
  2179.     U8 i = 0;
  2180.     S16 x1, y1, x2, y2;
  2181.     S16 icon_idx = -1, bar_idx = 0;
  2183.     /*----------------------------------------------------------------*/
  2184.     /* Code Body                                                      */
  2185.     /*----------------------------------------------------------------*/
  2186.     for (bar_idx = 0; bar_idx < MAX_STATUS_ICON_BARS; bar_idx++)
  2187.     {
  2188.         if (MMI_status_icon_bars[bar_idx].flags & STATUS_ICON_BAR_DISPLAY &&
  2189.             MMI_status_icon_bars[bar_idx].icon_list != NULL)
  2190.         {
  2191.             x1 = MMI_status_icon_bars[bar_idx].x1;
  2192.             y1 = MMI_status_icon_bars[bar_idx].y1;
  2193.             x2 = MMI_status_icon_bars[bar_idx].x2;
  2194.             y2 = MMI_status_icon_bars[bar_idx].y2;
  2195.             if (x >= x1 && x <= x2 && y >= y1 && y <= y2)   /* inside status icon bar */
  2196.             {
  2197.                 for (i = 0; i < MMI_status_icon_bars[bar_idx].n_icons; i++)
  2198.                 {
  2199.                     icon_idx = MMI_status_icon_bars[bar_idx].icon_list[i];
  2200.                     if (MMI_status_icons[icon_idx].icon_ID != IMAGE_ID_NULL &&
  2201.                         MMI_status_icons[icon_idx].flags & STATUS_ICON_DISPLAY)
  2202.                     {
  2203.                         x1 = MMI_status_icons[icon_idx].x;
  2204.                         x2 = x1 + MMI_status_icons[icon_idx].width - 1;
  2205.                         y1 = MMI_status_icons[icon_idx].y;
  2206.                         y2 = y1 + MMI_status_icons[icon_idx].height - 1;
  2207.                         if (x >= x1 && x <= x2 && y >= y1 && y <= y2)   /* pen on status icon */
  2208.                         {
  2209.                             return icon_idx;
  2210.                         }
  2211.                     }
  2212.                 }
  2213.             }
  2214.         }
  2215.     }
  2216.     return -1;
  2217. }
  2220. /*****************************************************************************
  2221.  * FUNCTION
  2222.  *  wgui_status_icon_translate_pen_event
  2223.  * DESCRIPTION
  2224.  *  Translate pen events for status icons.
  2225.  * PARAMETERS
  2226.  *  pen_event       [IN]            Type of pen event
  2227.  *  x               [IN]            Pen x-coordinate
  2228.  *  y               [IN]            Pen y-coordinate
  2229.  *  icon_id         [IN/OUT]        Id of icon be touched
  2230.  *  event_type      [?]             
  2231.  * RETURNS
  2232.  *  BOOL        if any status icon is touched
  2233.  *****************************************************************************/
  2234. BOOL wgui_status_icon_translate_pen_event(
  2235.         mmi_pen_event_type_enum pen_event,
  2236.         S16 x,
  2237.         S16 y,
  2238.         S16 *icon_id,
  2239.         wgui_status_icon_bar_pen_enum *event_type)
  2240. {
  2241.     /*----------------------------------------------------------------*/
  2242.     /* Local Variables                                                */
  2243.     /*----------------------------------------------------------------*/
  2244.     gui_wait_longpress_enum w;
  2246.     /*----------------------------------------------------------------*/
  2247.     /* Code Body                                                      */
  2248.     /*----------------------------------------------------------------*/
  2249.     *event_type = WGUI_STATUS_ICON_BAR_PEN_NONE;
  2250.     *icon_id = -1;
  2252.     if (gIsHandleStatusIconPenEvent == MMI_FALSE)
  2253.     {
  2254.         return FALSE;
  2255.     }
  2257.     if (pen_down_status_icon_id < 0 && pen_event != MMI_PEN_EVENT_DOWN)
  2258.     {
  2259.         return FALSE;
  2260.     }
  2262.     if (pen_event == MMI_PEN_EVENT_DOWN)
  2263.     {
  2264.         pen_down_status_icon_id = wgui_status_icon_translate_pen_position(x, y);
  2266.         if (pen_down_status_icon_id < 0)
  2267.         {
  2268.             return FALSE;
  2269.         }
  2270.     }
  2272.     *icon_id = pen_down_status_icon_id;
  2274.     if (MMI_status_icon_pen_event_hdlr[pen_down_status_icon_id][WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON] != NULL)
  2275.     {
  2276.         w = gui_pen_wait_longpress(pen_event, x, y);
  2277.         if (w == GUI_WAIT_LONGPRESS_READY)
  2278.         {
  2279.             *event_type = WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON;
  2280.         }
  2281.     }
  2283.     if (pen_event == MMI_PEN_EVENT_UP && *event_type == WGUI_STATUS_ICON_BAR_PEN_NONE)
  2284.     {
  2285.         if (pen_down_status_icon_id == wgui_status_icon_translate_pen_position(x, y))
  2286.         {
  2287.             *event_type = WGUI_STATUS_ICON_BAR_PEN_SELECT_ICON;
  2288.         }
  2289.     }
  2291.     return TRUE;
  2292. }
  2294. #endif /* __MMI_TOUCH_SCREEN__ */ 
  2296. /* diamond, 2005/09/20 get/set flag of a status icon */
  2299. /*****************************************************************************
  2300.  * FUNCTION
  2301.  *  get_status_icon_flag
  2302.  * DESCRIPTION
  2303.  *  
  2304.  * PARAMETERS
  2305.  *  icon_ID     [IN]        
  2306.  * RETURNS
  2307.  *  
  2308.  *****************************************************************************/
  2309. U32 get_status_icon_flag(S16 icon_ID)
  2310. {
  2311.     /*----------------------------------------------------------------*/
  2312.     /* Local Variables                                                */
  2313.     /*----------------------------------------------------------------*/
  2315.     /*----------------------------------------------------------------*/
  2316.     /* Code Body                                                      */
  2317.     /*----------------------------------------------------------------*/
  2318.     return MMI_status_icons[icon_ID].flags;
  2319. }
  2322. /*****************************************************************************
  2323.  * FUNCTION
  2324.  *  set_status_icon_flag
  2325.  * DESCRIPTION
  2326.  *  
  2327.  * PARAMETERS
  2328.  *  icon_ID     [IN]        
  2329.  *  value       [IN]        
  2330.  * RETURNS
  2331.  *  void
  2332.  *****************************************************************************/
  2333. void set_status_icon_flag(S16 icon_ID, U32 value)
  2334. {
  2335.     /*----------------------------------------------------------------*/
  2336.     /* Local Variables                                                */
  2337.     /*----------------------------------------------------------------*/
  2339.     /*----------------------------------------------------------------*/
  2340.     /* Code Body                                                      */
  2341.     /*----------------------------------------------------------------*/
  2342.     if ((icon_ID < 0) || (icon_ID >= MAX_STATUS_ICONS))
  2343.     {
  2344.         return;
  2345.     }
  2347.     /* set the flag to the specific value */
  2348.     MMI_status_icons[icon_ID].flags = value;
  2350.     /* set rearrange flag on */
  2351.     IsReArrangeNeeded = 1;
  2352. }
  2354. /* end, diamond */
  2357. /*****************************************************************************
  2358.  * FUNCTION
  2359.  *  wgui_status_icon_set_display_layer
  2360.  * DESCRIPTION
  2361.  *  
  2362.  * PARAMETERS
  2363.  *  display_layer       [IN]        
  2364.  * RETURNS
  2365.  *  void
  2366.  *****************************************************************************/
  2367. void wgui_status_icon_set_display_layer(GDI_HANDLE display_layer)
  2368. {
  2369.     /*----------------------------------------------------------------*/
  2370.     /* Local Variables                                                */
  2371.     /*----------------------------------------------------------------*/
  2373.     /*----------------------------------------------------------------*/
  2374.     /* Code Body                                                      */
  2375.     /*----------------------------------------------------------------*/
  2376.     wgui_status_icon_display_layer = display_layer;
  2377. }
  2380. /*****************************************************************************
  2381.  * FUNCTION
  2382.  *  wgui_status_icon_get_display_layer
  2383.  * DESCRIPTION
  2384.  *  
  2385.  * PARAMETERS
  2386.  *  void
  2387.  * RETURNS
  2388.  *  
  2389.  *****************************************************************************/
  2390. GDI_HANDLE wgui_status_icon_get_display_layer(void)
  2391. {
  2392.     /*----------------------------------------------------------------*/
  2393.     /* Local Variables                                                */
  2394.     /*----------------------------------------------------------------*/
  2396.     /*----------------------------------------------------------------*/
  2397.     /* Code Body                                                      */
  2398.     /*----------------------------------------------------------------*/
  2399.     return wgui_status_icon_display_layer;
  2400. }
  2403. /*****************************************************************************
  2404.  * FUNCTION
  2405.  *  wgui_status_icon_reset_display_layer
  2406.  * DESCRIPTION
  2407.  *  
  2408.  * PARAMETERS
  2409.  *  void
  2410.  * RETURNS
  2411.  *  void
  2412.  *****************************************************************************/
  2413. void wgui_status_icon_reset_display_layer(void)
  2414. {
  2415.     /*----------------------------------------------------------------*/
  2416.     /* Local Variables                                                */
  2417.     /*----------------------------------------------------------------*/
  2419.     /*----------------------------------------------------------------*/
  2420.     /* Code Body                                                      */
  2421.     /*----------------------------------------------------------------*/
  2422.     wgui_status_icon_display_layer = GDI_LAYER_EMPTY_HANDLE;
  2423. }