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

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

MTK

开发平台：

C/C++

wgui_softkeys.c：源码内容
  1. /*******************************************************************************
  2. *  Modification Notice:
  3. *  --------------------------
  4. *  This software is modified by MediaTek Inc. and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *******************************************************************************/
  36.  /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  *   wgui_softkeys.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *   Maui_Software
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  softkey related funtions
  48.  *
  49.  * Author:
  50.  * -------
  51.  * -------
  52.  *
  53.  *------------------------------------------------------------------------------
  54.  * $Log$
  55.  *
  56.  * removed!
  57.  * removed!
  58.  * 
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * 
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * 
  67.  *
  68.  * removed!
  69.  * removed!
  70.  * 
  71.  *
  72.  * removed!
  73.  * removed!
  74.  * 
  75.  *
  76.  * removed!
  77.  * removed!
  78.  * 
  79.  *
  80.  * removed!
  81.  * removed!
  82.  * 
  83.  *
  84.  * removed!
  85.  * removed!
  86.  * 
  87.  *
  88.  * removed!
  89.  * removed!
  90.  * 
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * 
  95.  *
  96.  *******************************************************************************/
  97. /**
  98.  * Copyright Notice
  99.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  100.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  101.  *  (It is illegal to remove this copyright notice from this software or any
  102.  *  portion of it)
  103.  */
  105. /**********************************************************************************
  106.    Filename:      wgui_softkeys.c
  107.    Author:        manju
  108.    Date Created:  August-07-2002
  109.    Contains:      PixTel UI wrapper routines for Softkeys
  110. **********************************************************************************/
  111. #include "MMI_features.h"
  112. #include "wgui_softkeys.h"
  113. #include "gui_themes.h"
  114. #include "FrameworkStruct.h"
  115. #include "DebugInitDef.h"
  116. #include "gdi_include.h"
  117. #include "wgui_status_icons.h"//061506 double buffer
  119. /* Globals                 */
  120. #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  121. U8 is_button_bar_shuffled = 0;
  122. extern MMI_white_color;
  123. void (*pixtel_shuffle_draw_background) (void);
  124. #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  126. /* softkey width */
  127. S32 MMI_softkey_width = MMI_SOFTKEY_WIDTH;
  129. /* softkey height */
  130. S32 MMI_softkey_height = MMI_SOFTKEY_HEIGHT;
  132. /* Softkey wrappers        */
  133. icontext_button MMI_softkeys[WGUI_MAX_SOFTKEYS];
  135. #define  MMI_left_softkey  MMI_softkeys[MMI_LEFT_SOFTKEY]
  136. #define  MMI_right_softkey MMI_softkeys[MMI_RIGHT_SOFTKEY]
  138. #ifdef __MMI_WGUI_CSK_ENABLE__
  139. #define  MMI_center_softkey   MMI_softkeys[MMI_CENTER_SOFTKEY]
  140. #endif 
  142. /* LSK key handler */
  143. U8 left_softkey_keyboard_handler_active = 0;
  145. /* RSKk key handler */
  146. U8 right_softkey_keyboard_handler_active = 0;
  148. #ifdef __MMI_WGUI_CSK_ENABLE__
  149. /* CSK key handler */
  150. U8 center_softkey_keyboard_handler_active = 0;
  151. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  153. #define  WGUI_MAX_SOFTKEY_FUNCTIONS 3
  155. void (*softkey_functions[WGUI_MAX_SOFTKEYS][WGUI_MAX_SOFTKEY_FUNCTIONS]) (void);
  157. #define           left_softkey_functions  softkey_functions[MMI_LEFT_SOFTKEY]
  158. #define           right_softkey_functions    softkey_functions[MMI_RIGHT_SOFTKEY]
  159. #define           center_softkey_functions      softkey_functions[MMI_CENTER_SOFTKEY]
  161. /* Functions to hide softkeys */
  162. void (*hide_softkey[WGUI_MAX_SOFTKEYS]) (void);
  164. #ifdef __MMI_T9__
  165. extern void (*t9_inputbox_LSK_function) (void);
  166. #endif 
  168. void softkey_keyboard_handler(S32 vkey_code, S32 key_state);
  170. extern UI_string_type get_string(MMI_ID_TYPE i);
  171. extern PU8 get_image(MMI_ID_TYPE i);
  174. /*****************************************************************************
  175.  * FUNCTION
  176.  *  clear_softkey_button_background_callback
  177.  * DESCRIPTION
  178.  *  Clear the background of softkey. Used of callback function in icontext_button.clear_background_fp
  179.  * PARAMETERS
  180.  *  button_object       [IN]        The target button
  181.  * RETURNS
  182.  *  void
  183.  *****************************************************************************/
  184. void clear_softkey_button_background_callback(void *button_object)
  185. {
  186.     /*----------------------------------------------------------------*/
  187.     /* Local Variables                                                */
  188.     /*----------------------------------------------------------------*/
  189.     S32 i;
  191.     /*----------------------------------------------------------------*/
  192.     /* Code Body                                                      */
  193.     /*----------------------------------------------------------------*/
  194.     for (i = 0; i < WGUI_MAX_SOFTKEYS; i++)
  195.     {
  196.         if (button_object == (void*)&MMI_softkeys[i])
  197.         {
  198.             (hide_softkey[i]) ();
  199.             return;
  200.         }
  201.     }
  202.     MMI_DBG_ASSERT(0);
  203. }
  206. /*****************************************************************************
  207.  * FUNCTION
  208.  *  create_softkeys
  209.  * DESCRIPTION
  210.  *  Creates and set default value of softkeys
  211.  * PARAMETERS
  212.  *  void
  213.  * RETURNS
  214.  *  void
  215.  *****************************************************************************/
  216. void create_softkeys(void)
  217. {
  218.     /*----------------------------------------------------------------*/
  219.     /* Local Variables                                                */
  220.     /*----------------------------------------------------------------*/
  221.     U8 i = 0, key = 0;
  223.     /*----------------------------------------------------------------*/
  224.     /* Code Body                                                      */
  225.     /*----------------------------------------------------------------*/
  226.     /* set theme of LSK */
  227.     set_MMI_LSK_theme();
  228.     /* careate button */
  229.     gui_create_icontext_button(
  230.         &MMI_softkeys[MMI_LEFT_SOFTKEY],
  231.         0,
  232.         UI_device_height - MMI_softkey_height,
  233.         MMI_softkey_width,
  234.         MMI_softkey_height,
  235.         NULL,
  236.         NULL);
  238. #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  239. #if defined(__MMI_UI_TECHNO_SOFTKEYS__)
  240.     MMI_softkeys[MMI_LEFT_SOFTKEY].flags |=
  241.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_LEFT_ALIGN | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_TEXT_X |
  242.          UI_BUTTON_CENTER_ICON_Y | UI_BUTTON_ALIGN_ICON_TEXT);
  243. #elif defined(__MMI_UI_DALMATIAN_SOFTKEYS__)
  244.     MMI_softkeys[MMI_LEFT_SOFTKEY].flags |=
  245.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_ICON_Y |
  246.          UI_BUTTON_ALIGN_ICON_TEXT);
  247. #else 
  248.     MMI_softkeys[MMI_LEFT_SOFTKEY].flags |=
  249.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_LEFT_ALIGN | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  250.          UI_BUTTON_ALIGN_ICON_TEXT | UI_BUTTON_DISABLE_BACKGND_DISPLAY);
  251. #endif 
  252. #else /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  253.     MMI_softkeys[MMI_LEFT_SOFTKEY].flags |=
  254.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  255.          UI_BUTTON_ALIGN_ICON_TEXT);
  256. #endif /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  258.     /* set theme of RSK */
  259.     set_MMI_RSK_theme();
  260.     /* create RK button */
  262. #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  263.     gui_create_icontext_button(
  264.         &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  265.         UI_device_width - MMI_softkey_width,
  266.         UI_device_height - MMI_softkey_height - (MMI_BUTTON_BAR_HEIGHT - MMI_softkey_height),
  267.         MMI_softkey_width,
  268.         MMI_softkey_height,
  269.         NULL,
  270.         NULL);
  271. #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  272.     gui_create_icontext_button(
  273.         &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  274.         UI_device_width - MMI_softkey_width,
  275.         UI_device_height - MMI_softkey_height,
  276.         MMI_softkey_width,
  277.         MMI_softkey_height,
  278.         NULL,
  279.         NULL);
  280. #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  282. #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  283. #if defined(__MMI_UI_TECHNO_SOFTKEYS__)
  284.     MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |=
  285.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_RIGHT_ALIGN | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_TEXT_Y |
  286.          UI_BUTTON_CENTER_ICON_Y | UI_BUTTON_ALIGN_ICON_TEXT);
  287. #elif defined(__MMI_UI_DALMATIAN_SOFTKEYS__)
  288.     MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |=
  289.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  290.          UI_BUTTON_ALIGN_ICON_TEXT);
  291. #else 
  292.     MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |=
  293.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_RIGHT_ALIGN | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  294.          UI_BUTTON_ALIGN_ICON_TEXT | UI_BUTTON_DISABLE_BACKGND_DISPLAY);
  295. #endif 
  296. #else /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  297.     MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |=
  298.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  299.          UI_BUTTON_ALIGN_ICON_TEXT);
  300. #endif /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  302. #ifdef __MMI_WGUI_CSK_ENABLE__
  303.     /* create CSK button */
  304.     gui_create_icontext_button(
  305.         &MMI_softkeys[MMI_CENTER_SOFTKEY],
  306.         MMI_softkey_width + ((UI_device_width - (MMI_softkey_width) * 3) >> 1),
  307.         UI_device_height - MMI_softkey_height,
  308.         MMI_softkey_width,
  309.         MMI_softkey_height,
  310.         NULL,
  311.         NULL);
  312. #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  313.     MMI_center_softkey.flags |=
  314.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_X | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y |
  315.          UI_BUTTON_ALIGN_ICON_TEXT | UI_BUTTON_DISABLE_BACKGND_DISPLAY);
  316. #else /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  317.     MMI_center_softkey.flags |=
  318.         (UI_BUTTON_SHIFT_BUTTON1 | UI_BUTTON_CENTER_TEXT_Y | UI_BUTTON_CENTER_ICON_Y | UI_BUTTON_ALIGN_ICON_TEXT);
  319. #endif /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) */ 
  320. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  322.     /* initilaize softkey functions to dummy func */
  323.     for (key = 0; key < WGUI_MAX_SOFTKEYS; key++)
  324.     {
  325.         MMI_softkeys[key].clear_background_fp = clear_softkey_button_background_callback;
  326.         hide_softkey[key] = UI_dummy_function;
  327.         for (i = 0; i < WGUI_MAX_SOFTKEY_FUNCTIONS; i++)
  328.         {
  329.             softkey_functions[key][i] = UI_dummy_function;
  330.         }
  331.     }
  332.     register_keyboard_global_key_handler(softkey_keyboard_handler);
  333. }
  336. /*****************************************************************************
  337.  * FUNCTION
  338.  *  restore_softkeys
  339.  * DESCRIPTION
  340.  *  set the softkeys to the MMI's default positions and sizes
  341.  * PARAMETERS
  342.  *  void
  343.  * RETURNS
  344.  *  void
  345.  *****************************************************************************/
  346. void restore_softkeys(void)
  347. {
  348.     /*----------------------------------------------------------------*/
  349.     /* Local Variables                                                */
  350.     /*----------------------------------------------------------------*/
  351.     U8 key = 0;
  353.     /*----------------------------------------------------------------*/
  354.     /* Code Body                                                      */
  355.     /*----------------------------------------------------------------*/
  356.     for (key = 0; key < WGUI_MAX_SOFTKEYS; key++)
  357.     {
  358.         gui_resize_icontext_button(&MMI_softkeys[key], MMI_softkey_width, MMI_softkey_height);
  359.         gui_move_icontext_button(&MMI_softkeys[key], 0, UI_device_height - MMI_softkey_height);
  360.         gui_set_icontext_button_current_theme(&MMI_softkeys[key]);
  361.     }
  362. }
  365. /*****************************************************************************
  366.  * FUNCTION
  367.  *  resize_softkey_by_string_length
  368.  * DESCRIPTION
  369.  *  resize the left softkey width according the the string
  370.  * PARAMETERS
  371.  *  s       [IN]        String
  372.  *  key     [IN]        Softkey enum
  373.  * RETURNS
  374.  *  void
  375.  *****************************************************************************/
  376. void resize_softkey_by_string_length(UI_string_type s, WGUI_SOFTKEY_ENUM key)
  377. {
  378.     /*----------------------------------------------------------------*/
  379.     /* Local Variables                                                */
  380.     /*----------------------------------------------------------------*/
  381.     S32 sw, sh;
  383.     /*----------------------------------------------------------------*/
  384.     /* Code Body                                                      */
  385.     /*----------------------------------------------------------------*/
  386.     gui_set_font(MMI_softkeys[key].text_font);
  387.     gui_measure_string(s, &sw, &sh);
  388.     gui_resize_icontext_button(&MMI_softkeys[key], sw + WGUI_SOFTKEY_STRING_GAP, MMI_softkeys[key].height);
  389.     gui_move_icontext_button(&MMI_softkeys[key], 0, UI_device_height - MMI_softkeys[key].height);
  390. }
  393. /*****************************************************************************
  394.  * FUNCTION
  395.  *  set_softkey_label
  396.  * DESCRIPTION
  397.  *  Changes the label of softkeys
  398.  * PARAMETERS
  399.  *  s       [IN]        String
  400.  *  key     [IN]        Softkey enum
  401.  * RETURNS
  402.  *  void
  403.  *****************************************************************************/
  404. void set_softkey_label(UI_string_type s, WGUI_SOFTKEY_ENUM key)
  405. {
  406.     /*----------------------------------------------------------------*/
  407.     /* Local Variables                                                */
  408.     /*----------------------------------------------------------------*/
  410.     /*----------------------------------------------------------------*/
  411.     /* Code Body                                                      */
  412.     /*----------------------------------------------------------------*/
  413.     MMI_softkeys[key].text = s;
  414.     if (MMI_softkeys[key].normal_down_icon == NULL)
  415.     {
  416.         MMI_softkeys[key].flags &= ~UI_BUTTON_CENTER_ICON_X;
  417.     #ifdef __MMI_WGUI_CSK_ENABLE__
  418.         if (key == MMI_CENTER_SOFTKEY)
  419.         {
  420.             MMI_softkeys[key].flags |= UI_BUTTON_CENTER_TEXT_X;
  421.         }
  422.     #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  424.     #if !(defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__))
  425.         MMI_softkeys[key].flags |= UI_BUTTON_CENTER_TEXT_X;
  426.     #endif 
  427.     }
  428.     gui_resize_icontext_button(&MMI_softkeys[key], MMI_softkeys[key].width, MMI_softkeys[key].height);
  429. }
  432. /*****************************************************************************
  433.  * FUNCTION
  434.  *  set_softkey_icon
  435.  * DESCRIPTION
  436.  *  Changes the icon of softkeys
  437.  * PARAMETERS
  438.  *  icon        [IN]        Icon
  439.  *  key         [IN]        Softkey enum
  440.  * RETURNS
  441.  *  void
  442.  *****************************************************************************/
  443. void set_softkey_icon(PU8 icon, WGUI_SOFTKEY_ENUM key)
  444. {
  445.     /*----------------------------------------------------------------*/
  446.     /* Local Variables                                                */
  447.     /*----------------------------------------------------------------*/
  448.     PU8 new_icon = icon;
  450.     /*----------------------------------------------------------------*/
  451.     /* Code Body                                                      */
  452.     /*----------------------------------------------------------------*/
  453.     if ((icon != NULL) && (icon[0] == 0))
  454.     {
  455.         new_icon = NULL;
  456.     }
  458.     if (icon != NULL && icon == MMI_softkeys[key].normal_up_icon)
  459.     {
  460.         return;
  461.     }
  463.     /* set icon of LSK button */
  464.     gui_icontext_button_set_icon(&MMI_softkeys[key], new_icon, gui_transparent_color(0, 0, 0));
  465.     if (MMI_softkeys[key].text == NULL)
  466.     {
  467.     #if !(defined __MMI_UI_TECHNO_SOFTKEYS__ || defined __MMI_UI_DALMATIAN_SOFTKEYS__ )
  468.         MMI_softkeys[key].flags &= ~UI_BUTTON_CENTER_TEXT_X;
  469.     #endif 
  470.         MMI_softkeys[key].flags |= UI_BUTTON_CENTER_ICON_X;
  471.     }
  472.     gui_resize_icontext_button(&MMI_softkeys[key], MMI_softkeys[key].width, MMI_softkeys[key].height);
  473. }
  476. /*****************************************************************************
  477.  * FUNCTION
  478.  *  change_softkey
  479.  * DESCRIPTION
  480.  *  Changes the string and icon of softkeys
  481.  * PARAMETERS
  482.  *  s       [IN]        String
  483.  *  i       [IN]        Icon
  484.  *  key     [IN]        Softkey enum
  485.  * RETURNS
  486.  *  void
  487.  *****************************************************************************/
  488. void change_softkey(U16 s, U16 i, WGUI_SOFTKEY_ENUM key)
  489. {
  490.     /*----------------------------------------------------------------*/
  491.     /* Local Variables                                                */
  492.     /*----------------------------------------------------------------*/
  494.     /*----------------------------------------------------------------*/
  495.     /* Code Body                                                      */
  496.     /*----------------------------------------------------------------*/
  497.     if (s != STRING_ID_NULL)
  498.     {
  499.         UI_string_type str = get_string(s);
  501.         set_softkey_label(str, key);
  502.     }
  503.     else
  504.     {
  505.         set_softkey_label(NULL, key);
  506.     }
  508.     if (i != IMAGE_ID_NULL)
  509.     {
  510.         PU8 img = get_image(i);
  512.         set_softkey_icon(img, key);
  513.     }
  514.     else
  515.     {
  516.         set_softkey_icon(NULL, key);
  517.     }
  518. }
  521. /*****************************************************************************
  522.  * FUNCTION
  523.  *  set_softkey_function
  524.  * DESCRIPTION
  525.  *  Changes the handler of softkeys
  526.  * PARAMETERS
  527.  *  f       [IN]        Handler function
  528.  *  k       [IN]        Key event type
  529.  *  key     [IN]        Softkey enum
  530.  * RETURNS
  531.  *  void
  532.  *****************************************************************************/
  533. void set_softkey_function(void (*f) (void), MMI_key_event_type k, WGUI_SOFTKEY_ENUM key)
  534. {
  535.     /*----------------------------------------------------------------*/
  536.     /* Local Variables                                                */
  537.     /*----------------------------------------------------------------*/
  539.     /*----------------------------------------------------------------*/
  540.     /* Code Body                                                      */
  541.     /*----------------------------------------------------------------*/
  542.     if (k >= WGUI_MAX_SOFTKEY_FUNCTIONS)
  543.     {
  544.         return;
  545.     }
  547.     switch (key)
  548.     {
  549.         case MMI_LEFT_SOFTKEY:
  550.             if (k == KEY_LONG_PRESS)
  551.             {
  552.                 SetKeyHandler(f, KEY_LSK, KEY_LONG_PRESS);
  553.             }
  554.             softkey_functions[key][k] = f;
  555.             break;
  557.         case MMI_RIGHT_SOFTKEY:
  558.             if (k == KEY_LONG_PRESS)
  559.             {
  560.                 SetKeyHandler(f, KEY_RSK, KEY_LONG_PRESS);
  561.             }
  562.             softkey_functions[key][k] = f;
  563.             break;
  565.         #ifdef __MMI_WGUI_CSK_ENABLE__
  566.         case MMI_CENTER_SOFTKEY:
  567.             if (k == KEY_LONG_PRESS)
  568.             {
  569.                 SetKeyHandler(f, KEY_CSK, KEY_LONG_PRESS);
  570.             }
  571.             softkey_functions[key][k] = f;
  572.             break;
  573.         #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  574.     }
  575. }
  578. /*****************************************************************************
  579.  * FUNCTION
  580.  *  get_softkey_function
  581.  * DESCRIPTION
  582.  *  get softkey handlers
  583.  * PARAMETERS
  584.  *  k       [IN]        Key event
  585.  *  key     [IN]        Softkey enum
  586.  * RETURNS
  587.  *  void
  588.  *****************************************************************************/
  589. FuncPtr get_softkey_function(MMI_key_event_type k, WGUI_SOFTKEY_ENUM key)
  590. {
  591.     /*----------------------------------------------------------------*/
  592.     /* Local Variables                                                */
  593.     /*----------------------------------------------------------------*/
  595.     /*----------------------------------------------------------------*/
  596.     /* Code Body                                                      */
  597.     /*----------------------------------------------------------------*/
  598.     if (k >= WGUI_MAX_SOFTKEY_FUNCTIONS)
  599.     {
  600.         return NULL;
  601.     }
  603.     return softkey_functions[key][k];
  604. }
  607. /*****************************************************************************
  608.  * FUNCTION
  609.  *  execute_softkey_function
  610.  * DESCRIPTION
  611.  *  execute softkey handlers
  612.  * PARAMETERS
  613.  *  k       [IN]        Key event
  614.  *  key     [IN]        Softkey enum
  615.  * RETURNS
  616.  *  void
  617.  *****************************************************************************/
  618. void execute_softkey_function(MMI_key_event_type k, WGUI_SOFTKEY_ENUM key)
  619. {
  620.     /*----------------------------------------------------------------*/
  621.     /* Local Variables                                                */
  622.     /*----------------------------------------------------------------*/
  624.     /*----------------------------------------------------------------*/
  625.     /* Code Body                                                      */
  626.     /*----------------------------------------------------------------*/
  627.     if (k >= WGUI_MAX_SOFTKEY_FUNCTIONS)
  628.     {
  629.         return;
  630.     }
  632.     if (softkey_functions[key][k] != NULL)
  633.     {
  634.         softkey_functions[key][k] ();
  635.     }
  636. }
  639. /*****************************************************************************
  640.  * FUNCTION
  641.  *  set_softkey
  642.  * DESCRIPTION
  643.  *  Sets the label and the function to be called for the softkey
  644.  * PARAMETERS
  645.  *  s       [IN]        New string to be used as the softkey label
  646.  *  f       [IN]        Function that is called when a particular softkey event occurs
  647.  *  k       [IN]        Key event
  648.  *  key     [IN]        Softkey enum
  649.  * RETURNS
  650.  *  void
  651.  *****************************************************************************/
  652. void set_softkey(UI_string_type s, void (*f) (void), MMI_key_event_type k, WGUI_SOFTKEY_ENUM key)
  653. {
  654.     /*----------------------------------------------------------------*/
  655.     /* Local Variables                                                */
  656.     /*----------------------------------------------------------------*/
  658.     /*----------------------------------------------------------------*/
  659.     /* Code Body                                                      */
  660.     /*----------------------------------------------------------------*/
  661.     if (k >= WGUI_MAX_SOFTKEY_FUNCTIONS)
  662.     {
  663.         return;
  664.     }
  666.     set_softkey_label(s, key);
  667.     set_softkey_function(f, k, key);
  668. }
  671. /*****************************************************************************
  672.  * FUNCTION
  673.  *  clear_softkey_display_functions
  674.  * DESCRIPTION
  675.  *  Clear the functions of the softkey
  676.  * PARAMETERS
  677.  *  key     [IN]        Softkey enum
  678.  * RETURNS
  679.  *  void
  680.  *****************************************************************************/
  681. void clear_softkey_display_functions(WGUI_SOFTKEY_ENUM key)
  682. {
  683.     /*----------------------------------------------------------------*/
  684.     /* Local Variables                                                */
  685.     /*----------------------------------------------------------------*/
  686.     U8 i = 0;
  688.     /*----------------------------------------------------------------*/
  689.     /* Code Body                                                      */
  690.     /*----------------------------------------------------------------*/
  691.     hide_softkey[key] = UI_dummy_function;
  692.     for (i = 0; i < WGUI_MAX_SOFTKEY_FUNCTIONS; i++)
  693.     {
  694.         softkey_functions[key][i] = UI_dummy_function;
  695.     }
  696. }
  699. /*****************************************************************************
  700.  * FUNCTION
  701.  *  show_softkey
  702.  * DESCRIPTION
  703.  *  Displays softkey
  704.  * PARAMETERS
  705.  *  key     [IN]        Softkey enum
  706.  * RETURNS
  707.  *  void
  708.  *****************************************************************************/
  709. void show_softkey(WGUI_SOFTKEY_ENUM key)
  710. {
  711.     /*----------------------------------------------------------------*/
  712.     /* Local Variables                                                */
  713.     /*----------------------------------------------------------------*/
  715.     /*----------------------------------------------------------------*/
  716.     /* Code Body                                                      */
  717.     /*----------------------------------------------------------------*/
  718.     if ((MMI_softkeys[key].text == NULL) && (MMI_softkeys[key].normal_up_icon == NULL))
  719.     {
  720.         clear_softkey_handler(key);
  721.         return;
  722.     }
  724. #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  725.     switch (key)
  726.     {
  727.         case MMI_LEFT_SOFTKEY:
  729.             gui_show_icontext_button(&MMI_softkeys[key]);
  730.             break;
  732.         case MMI_RIGHT_SOFTKEY:
  733.             /* To show right key bottom aligned */
  734.             if ((MMI_left_softkey.text == NULL) && (MMI_left_softkey.normal_up_icon == NULL))
  735.             {
  736.                 MMI_right_softkey.y = MMI_left_softkey.y;
  737.             }
  738.             gui_show_icontext_button(&MMI_softkeys[key]);
  739.             /*  Reset the right softkey position which is changed whn left is null. */
  740.             if ((MMI_left_softkey.text == NULL) && (MMI_left_softkey.normal_up_icon == NULL))
  741.             {
  742.                 MMI_right_softkey.y =
  743.                     UI_device_height - MMI_softkey_height - (MMI_BUTTON_BAR_HEIGHT - MMI_softkey_height);
  744.             }
  745.             break;
  746.     }
  747. #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  748. #ifndef __MMI_UI_DALMATIAN_SOFTKEYS__
  749.     gui_show_icontext_button(&MMI_softkeys[key]);
  750. #endif 
  751. }
  754. /*****************************************************************************
  755.  * FUNCTION
  756.  *  move_softkey
  757.  * DESCRIPTION
  758.  *  change the position of softkey
  759.  * PARAMETERS
  760.  *  x       [IN]        New x-coordinate of softkey
  761.  *  y       [IN]        New y-coordinate of softkey
  762.  *  key     [IN]        Softkey enum
  763.  * RETURNS
  764.  *  void
  765.  *****************************************************************************/
  766. void move_softkey(S32 x, S32 y, WGUI_SOFTKEY_ENUM key)
  767. {
  768.     /*----------------------------------------------------------------*/
  769.     /* Local Variables                                                */
  770.     /*----------------------------------------------------------------*/
  772.     /*----------------------------------------------------------------*/
  773.     /* Code Body                                                      */
  774.     /*----------------------------------------------------------------*/
  775.     gui_move_icontext_button(&MMI_softkeys[key], x, y);
  776. }
  779. /*****************************************************************************
  780.  * FUNCTION
  781.  *  resize_softkey
  782.  * DESCRIPTION
  783.  *  change the width and height of softkey
  784.  * PARAMETERS
  785.  *  width       [IN]        New width of softkey
  786.  *  height      [IN]        New height of softkey
  787.  *  key         [IN]        Softkey enum
  788.  * RETURNS
  789.  *  void
  790.  *****************************************************************************/
  791. void resize_softkey(S32 width, S32 height, WGUI_SOFTKEY_ENUM key)
  792. {
  793.     /*----------------------------------------------------------------*/
  794.     /* Local Variables                                                */
  795.     /*----------------------------------------------------------------*/
  797.     /*----------------------------------------------------------------*/
  798.     /* Code Body                                                      */
  799.     /*----------------------------------------------------------------*/
  800.     gui_resize_icontext_button(&MMI_softkeys[key], width, height);
  801. }
  804. /*****************************************************************************
  805.  * FUNCTION
  806.  *  redraw_softkey
  807.  * DESCRIPTION
  808.  *  Redraw softkey
  809.  * PARAMETERS
  810.  *  key     [IN]        Softkey enum
  811.  * RETURNS
  812.  *  void
  813.  *****************************************************************************/
  814. void redraw_softkey(WGUI_SOFTKEY_ENUM key)
  815. {
  816.     /*----------------------------------------------------------------*/
  817.     /* Local Variables                                                */
  818.     /*----------------------------------------------------------------*/
  819.     S32 idx = 0;//061506 double buffer
  820. #ifndef __MMI_UI_DALMATIAN_SOFTKEYS__
  822.     /*----------------------------------------------------------------*/
  823.     /* Code Body                                                      */
  824.     /*----------------------------------------------------------------*/
  825.     hide_softkey[key] ();
  826.     show_softkey(key);
  827. #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  829.     switch (key)
  830.     {
  831.         case MMI_LEFT_SOFTKEY:
  832.     #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  833.             if (!is_on_idlescreen())
  834.             {
  835.                 show_softkey_background();
  836.             }
  838.             if ((MMI_left_softkey.text == NULL) && (MMI_left_softkey.normal_up_icon == NULL))
  839.             {
  840.                 /* To draw right softkey always above the left key. */
  841.                 redraw_right_softkey();
  842.                 gdi_layer_blt_previous(MMI_softkeys[MMI_LEFT_SOFTKEY].x, UI_device_height - MMI_BUTTON_BAR_HEIGHT, UI_device_width - 1, UI_device_height - 1);  /* vikas modified 20050331 */
  843.                 return;
  844.             }
  845.             show_softkey(key);
  846.             redraw_right_softkey();
  847.             gdi_layer_blt_previous(MMI_softkeys[MMI_LEFT_SOFTKEY].x, UI_device_height - MMI_BUTTON_BAR_HEIGHT, UI_device_width - 1, UI_device_height - 1);      /* vikas modified 20050331 */
  848.     #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  849.             gdi_layer_blt_previous(
  850.                 MMI_softkeys[MMI_LEFT_SOFTKEY].x,
  851.                 MMI_softkeys[MMI_LEFT_SOFTKEY].y,
  852.                 (MMI_softkeys[MMI_LEFT_SOFTKEY].x + MMI_softkeys[MMI_LEFT_SOFTKEY].width + 2),
  853.                 (MMI_softkeys[MMI_LEFT_SOFTKEY].y + MMI_softkeys[MMI_LEFT_SOFTKEY].height + 2));
  854.     #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  855.             break;
  857.         case MMI_RIGHT_SOFTKEY:
  858.         #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  859.             /* set the right key position to bottom aligned when left is NULL  */
  860.             if ((MMI_left_softkey.text == NULL) && (MMI_left_softkey.normal_up_icon == NULL))
  861.             {
  862.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].y = UI_device_height - MMI_softkey_height;
  863.             }
  864.             show_softkey(key);
  865.             gdi_layer_blt_previous(
  866.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].x,
  867.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].y,
  868.                 (MMI_softkeys[MMI_RIGHT_SOFTKEY].x + MMI_softkeys[MMI_RIGHT_SOFTKEY].width + 2),
  869.                 (MMI_softkeys[MMI_RIGHT_SOFTKEY].y + MMI_softkeys[MMI_RIGHT_SOFTKEY].height + 2));
  870.             /* Reset the right key positions in its original position. */
  871.             if ((MMI_left_softkey.text == NULL) && (MMI_left_softkey.normal_up_icon == NULL))
  872.             {
  873.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].y =
  874.                     UI_device_height - MMI_softkey_height - (MMI_BUTTON_BAR_HEIGHT - MMI_softkey_height);
  875.             }
  876.         #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  877.             gdi_layer_blt_previous(
  878.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].x,
  879.                 MMI_softkeys[MMI_RIGHT_SOFTKEY].y,
  880.                 (MMI_softkeys[MMI_RIGHT_SOFTKEY].x + MMI_softkeys[MMI_RIGHT_SOFTKEY].width + 2),
  881.                 (MMI_softkeys[MMI_RIGHT_SOFTKEY].y + MMI_softkeys[MMI_RIGHT_SOFTKEY].height + 2));
  882.         #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  883.             break;
  884.         #ifdef __MMI_WGUI_CSK_ENABLE__
  885.         case MMI_CENTER_SOFTKEY:
  886.             gdi_layer_blt_previous(
  887.                 MMI_softkeys[MMI_CENTER_SOFTKEY].x,
  888.                 MMI_softkeys[MMI_CENTER_SOFTKEY].y,
  889.                 (MMI_softkeys[MMI_CENTER_SOFTKEY].x + MMI_softkeys[MMI_CENTER_SOFTKEY].width + 2),
  890.                 (MMI_softkeys[MMI_CENTER_SOFTKEY].y + MMI_softkeys[MMI_CENTER_SOFTKEY].height + 2));
  891.             break;
  892.         #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  893.     }
  895.     /* 061506 double buffer Start */
  896.     for (idx=0; idx<MAX_STATUS_ICON_BARS; idx++)
  897.     {
  898.         if(get_status_icon_bar_type((U8)idx)&STATUS_ICON_BAR_ENABLE_DOUBLE_BUFFER)
  899.         {
  900.             gdi_layer_push_and_set_active(get_status_icon_bar_layer((U8)idx));
  901.             gdi_layer_toggle_double();
  902.             gdi_layer_copy_double();//070306 copy double
  903.             gdi_layer_pop_and_restore_active();
  904.         }
  905.     }
  906.     /* 061506 double buffer End */
  907. }
  910. /*****************************************************************************
  911.  * FUNCTION
  912.  *  left_softkey_down
  913.  * DESCRIPTION
  914.  *  Handles left softkey down event
  915.  * PARAMETERS
  916.  *  void
  917.  * RETURNS
  918.  *  void
  919.  *****************************************************************************/
  920. void left_softkey_down(void)
  921. {
  922.     /*----------------------------------------------------------------*/
  923.     /* Local Variables                                                */
  924.     /*----------------------------------------------------------------*/
  926.     /*----------------------------------------------------------------*/
  927.     /* Code Body                                                      */
  928.     /*----------------------------------------------------------------*/
  929.     if (!(MMI_softkeys[MMI_LEFT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED))
  930.     {                                       /* change the state of LSK button */
  931.         MMI_softkeys[MMI_LEFT_SOFTKEY].flags |= UI_BUTTON_STATE_CLICKED;
  932.         MMI_softkeys[MMI_LEFT_SOFTKEY].flags |= UI_BUTTON_STATE_DOWN;
  933.     #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  934.         /* Set status of shuffling on click & call shuffle. */
  935.         is_button_bar_shuffled = 0;
  936.         gui_call_shuffle();
  937.     #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  938.         redraw_softkey(MMI_LEFT_SOFTKEY);   /* redraw LSK */
  939.         /* call function handlers of LSK down */
  940.     #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  941.         execute_softkey_function(KEY_EVENT_DOWN, MMI_LEFT_SOFTKEY);
  942.     }
  943. }
  946. /*****************************************************************************
  947.  * FUNCTION
  948.  *  left_softkey_up
  949.  * DESCRIPTION
  950.  *  Handles left softkey up event
  951.  * PARAMETERS
  952.  *  void
  953.  * RETURNS
  954.  *  void
  955.  *****************************************************************************/
  956. void left_softkey_up(void)
  957. {
  958.     /*----------------------------------------------------------------*/
  959.     /* Local Variables                                                */
  960.     /*----------------------------------------------------------------*/
  962.     /*----------------------------------------------------------------*/
  963.     /* Code Body                                                      */
  964.     /*----------------------------------------------------------------*/
  965.     if (MMI_softkeys[MMI_LEFT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED)
  966.     {   /* change the state of LSK button */
  967.         MMI_softkeys[MMI_LEFT_SOFTKEY].flags &= ~UI_BUTTON_STATE_CLICKED;
  968.         MMI_softkeys[MMI_LEFT_SOFTKEY].flags &= ~UI_BUTTON_STATE_DOWN;
  969.     #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  970.         /* Reset status of shuffling on click & call shuffle. */
  971.         is_button_bar_shuffled = 1;
  972.         gui_call_shuffle();
  973.     #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  974.         redraw_softkey(MMI_LEFT_SOFTKEY);
  975.     #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  977.         /* call function handlers of LSK Up */
  978.         execute_softkey_function(KEY_EVENT_UP, MMI_LEFT_SOFTKEY);
  979.     }
  980. }
  982. /*****************************************************************************
  983.  * FUNCTION
  984.  *  left_softkey_up
  985.  * DESCRIPTION
  986.  *  Handles left softkey up event but no redraw
  987.  * PARAMETERS
  988.  *  void
  989.  * RETURNS
  990.  *  void
  991.  *****************************************************************************/
  992. void update_softkey_state_no_redraw( U16 KeyCode, U16 KeyType)
  993. {
  994. if ( KeyCode == KEY_LSK )
  995. {
  996. if ( KeyType == KEY_EVENT_UP )
  997. {
  998. if (MMI_softkeys[MMI_LEFT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED)
  999. {   /* change the state of LSK button */
  1000. MMI_softkeys[MMI_LEFT_SOFTKEY].flags &= ~UI_BUTTON_STATE_CLICKED;
  1001. MMI_softkeys[MMI_LEFT_SOFTKEY].flags &= ~UI_BUTTON_STATE_DOWN;
  1002. }
  1003. }
  1004. else if ( KeyType == KEY_EVENT_DOWN )
  1005. {
  1006. if (!(MMI_softkeys[MMI_LEFT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED))
  1007. {
  1008. /* change the state of LSK button */
  1009. MMI_softkeys[MMI_LEFT_SOFTKEY].flags |= UI_BUTTON_STATE_CLICKED;
  1010. MMI_softkeys[MMI_LEFT_SOFTKEY].flags |= UI_BUTTON_STATE_DOWN;
  1011. }
  1012. }
  1013. }
  1014. else if ( KeyCode == KEY_RSK )
  1015. {
  1016. if ( KeyType == KEY_EVENT_UP )
  1017. {
  1018. if (MMI_softkeys[MMI_RIGHT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED)
  1019. {   /* change the state of RSK button */
  1020. MMI_softkeys[MMI_RIGHT_SOFTKEY].flags &= ~UI_BUTTON_STATE_CLICKED;
  1021. MMI_softkeys[MMI_RIGHT_SOFTKEY].flags &= ~UI_BUTTON_STATE_DOWN;
  1022. }
  1023. }
  1024. else if ( KeyType == KEY_EVENT_DOWN )
  1025. {
  1026. if (!(MMI_softkeys[MMI_RIGHT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED))
  1027. {
  1028. /* change the state of RSK button */
  1029. MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |= UI_BUTTON_STATE_CLICKED;
  1030. MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |= UI_BUTTON_STATE_DOWN;
  1031. }
  1032. }
  1033. }
  1034. }
  1036. /*****************************************************************************
  1037.  * FUNCTION
  1038.  *  right_softkey_down
  1039.  * DESCRIPTION
  1040.  *  Handles right softkey down event
  1041.  * PARAMETERS
  1042.  *  void
  1043.  * RETURNS
  1044.  *  void
  1045.  *****************************************************************************/
  1046. void right_softkey_down(void)
  1047. {
  1048.     /*----------------------------------------------------------------*/
  1049.     /* Local Variables                                                */
  1050.     /*----------------------------------------------------------------*/
  1052.     /*----------------------------------------------------------------*/
  1053.     /* Code Body                                                      */
  1054.     /*----------------------------------------------------------------*/
  1055.     if (!(MMI_softkeys[MMI_RIGHT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED))
  1056.     {
  1057.         /* change the state of RSK button */
  1058.         MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |= UI_BUTTON_STATE_CLICKED;
  1059.         MMI_softkeys[MMI_RIGHT_SOFTKEY].flags |= UI_BUTTON_STATE_DOWN;
  1060.     #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  1061.         /* Set status of shuffling on click & call shuffle. */
  1062.         is_button_bar_shuffled = 0;
  1063.         gui_call_shuffle(); /* shuffle_softkeys */
  1064.     #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  1065.         redraw_softkey(MMI_RIGHT_SOFTKEY);
  1066.     #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  1067.         execute_softkey_function(KEY_EVENT_DOWN, MMI_RIGHT_SOFTKEY);
  1068.     }
  1069. }
  1072. /*****************************************************************************
  1073.  * FUNCTION
  1074.  *  right_softkey_up
  1075.  * DESCRIPTION
  1076.  *  Handles right softkey up event
  1077.  * PARAMETERS
  1078.  *  void
  1079.  * RETURNS
  1080.  *  void
  1081.  *****************************************************************************/
  1082. void right_softkey_up(void)
  1083. {
  1084.     /*----------------------------------------------------------------*/
  1085.     /* Local Variables                                                */
  1086.     /*----------------------------------------------------------------*/
  1088.     /*----------------------------------------------------------------*/
  1089.     /* Code Body                                                      */
  1090.     /*----------------------------------------------------------------*/
  1091.     if (MMI_softkeys[MMI_RIGHT_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED)
  1092.     {
  1093.         /* change the state of LSK button */
  1094.         MMI_softkeys[MMI_RIGHT_SOFTKEY].flags &= ~UI_BUTTON_STATE_CLICKED;
  1095.         MMI_softkeys[MMI_RIGHT_SOFTKEY].flags &= ~UI_BUTTON_STATE_DOWN;
  1096.     #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  1097.         /* Reset status of shuffling on click & call shuffle. */
  1098.         is_button_bar_shuffled = 1;
  1099.         gui_call_shuffle();
  1100.     #else /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  1101.         redraw_softkey(MMI_RIGHT_SOFTKEY);
  1102.     #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */ 
  1103.         execute_softkey_function(KEY_EVENT_UP, MMI_RIGHT_SOFTKEY);
  1104.     }
  1105. }
  1107. #ifdef __MMI_WGUI_CSK_ENABLE__
  1110. /*****************************************************************************
  1111.  * FUNCTION
  1112.  *  center_softkey_down
  1113.  * DESCRIPTION
  1114.  *  Handles center softkey down event
  1115.  * PARAMETERS
  1116.  *  void
  1117.  * RETURNS
  1118.  *  void
  1119.  *****************************************************************************/
  1120. void center_softkey_down(void)
  1121. {
  1122.     /*----------------------------------------------------------------*/
  1123.     /* Local Variables                                                */
  1124.     /*----------------------------------------------------------------*/
  1126.     /*----------------------------------------------------------------*/
  1127.     /* Code Body                                                      */
  1128.     /*----------------------------------------------------------------*/
  1129.     if (!(MMI_softkeys[MMI_CENTER_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED))
  1130.     {   /* change the state of LSK button */
  1131.         MMI_softkeys[MMI_CENTER_SOFTKEY].flags |= UI_BUTTON_STATE_CLICKED;
  1132.         MMI_softkeys[MMI_CENTER_SOFTKEY].flags |= UI_BUTTON_STATE_DOWN;
  1133.         redraw_softkey(MMI_CENTER_SOFTKEY);
  1134.         /* call function handlers of LSK down  */
  1135.         execute_softkey_function(KEY_EVENT_DOWN, MMI_CENTER_SOFTKEY);
  1136.     }
  1137. }
  1140. /*****************************************************************************
  1141.  * FUNCTION
  1142.  *  center_softkey_up
  1143.  * DESCRIPTION
  1144.  *  Handles left softkey up event
  1145.  * PARAMETERS
  1146.  *  void
  1147.  * RETURNS
  1148.  *  void
  1149.  *****************************************************************************/
  1150. void center_softkey_up(void)
  1151. {
  1152.     /*----------------------------------------------------------------*/
  1153.     /* Local Variables                                                */
  1154.     /*----------------------------------------------------------------*/
  1156.     /*----------------------------------------------------------------*/
  1157.     /* Code Body                                                      */
  1158.     /*----------------------------------------------------------------*/
  1159.     if (MMI_softkeys[MMI_CENTER_SOFTKEY].flags & UI_BUTTON_STATE_CLICKED)
  1160.     {   /* change the state of LSK button */
  1161.         MMI_softkeys[MMI_CENTER_SOFTKEY].flags &= ~UI_BUTTON_STATE_CLICKED;
  1162.         MMI_softkeys[MMI_CENTER_SOFTKEY].flags &= ~UI_BUTTON_STATE_DOWN;
  1163.         redraw_softkey(MMI_CENTER_SOFTKEY);
  1164.         /* call function handlers of LSK Up */
  1165.         execute_softkey_function(KEY_EVENT_UP, MMI_CENTER_SOFTKEY);
  1166.     }
  1167. }
  1168. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1171. /*****************************************************************************
  1172.  * FUNCTION
  1173.  *  register_softkey_handler
  1174.  * DESCRIPTION
  1175.  *  Register handlers of softkeys
  1176.  * PARAMETERS
  1177.  *  key     [IN]        Softkey enum
  1178.  * RETURNS
  1179.  *  void
  1180.  *****************************************************************************/
  1181. void register_softkey_handler(WGUI_SOFTKEY_ENUM key)
  1182. {
  1183.     /*----------------------------------------------------------------*/
  1184.     /* Local Variables                                                */
  1185.     /*----------------------------------------------------------------*/
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Code Body                                                      */
  1189.     /*----------------------------------------------------------------*/
  1190.     if ((MMI_softkeys[key].text == NULL) && (MMI_softkeys[key].normal_up_icon == NULL))
  1191.     {
  1192.         return;
  1193.     }
  1195.     switch (key)
  1196.     {
  1197.         case MMI_LEFT_SOFTKEY:
  1198.             SetKeyHandler(left_softkey_down, KEY_LSK, KEY_EVENT_DOWN);
  1199.             SetKeyHandler(left_softkey_up, KEY_LSK, KEY_EVENT_UP);
  1200.             left_softkey_keyboard_handler_active = 1;
  1201.             break;
  1203.         case MMI_RIGHT_SOFTKEY:
  1204.             SetKeyHandler(right_softkey_down, KEY_RSK, KEY_EVENT_DOWN);
  1205.             SetKeyHandler(right_softkey_up, KEY_RSK, KEY_EVENT_UP);
  1206.             right_softkey_keyboard_handler_active = 1;
  1207.             break;
  1209.     #ifdef __MMI_WGUI_CSK_ENABLE__
  1210.         case MMI_CENTER_SOFTKEY:
  1211.             SetKeyHandler(center_softkey_down, KEY_CSK, KEY_EVENT_DOWN);
  1212.             SetKeyHandler(center_softkey_up, KEY_CSK, KEY_EVENT_UP);
  1213.             center_softkey_keyboard_handler_active = 1;
  1214.             break;
  1215.     #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1216.     }
  1217. }
  1219. #ifdef __MMI_WGUI_CSK_ENABLE__
  1222. /*****************************************************************************
  1223.  * FUNCTION
  1224.  *  register_center_softkey_to_enter_key
  1225.  * DESCRIPTION
  1226.  *  Register center softkey handlers to enter key
  1227.  * PARAMETERS
  1228.  *  void
  1229.  * RETURNS
  1230.  *  void
  1231.  *****************************************************************************/
  1232. void register_center_softkey_to_enter_key(void)
  1233. {
  1234.     /*----------------------------------------------------------------*/
  1235.     /* Local Variables                                                */
  1236.     /*----------------------------------------------------------------*/
  1238.     /*----------------------------------------------------------------*/
  1239.     /* Code Body                                                      */
  1240.     /*----------------------------------------------------------------*/
  1241.     SetKeyHandler(center_softkey_up, KEY_ENTER, KEY_EVENT_UP);
  1242.     SetKeyHandler(center_softkey_down, KEY_ENTER, KEY_EVENT_DOWN);
  1243. }
  1244. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1247. /*****************************************************************************
  1248.  * FUNCTION
  1249.  *  clear_softkey_handler
  1250.  * DESCRIPTION
  1251.  *  Register handlers of softkeys
  1252.  * PARAMETERS
  1253.  *  key     [IN]        Softkey enum
  1254.  * RETURNS
  1255.  *  void
  1256.  *****************************************************************************/
  1257. void clear_softkey_handler(WGUI_SOFTKEY_ENUM key)
  1258. {
  1259.     /*----------------------------------------------------------------*/
  1260.     /* Local Variables                                                */
  1261.     /*----------------------------------------------------------------*/
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Code Body                                                      */
  1265.     /*----------------------------------------------------------------*/
  1266.     switch (key)
  1267.     {
  1268.         case MMI_LEFT_SOFTKEY:
  1269.             ClearKeyHandler(KEY_LSK, KEY_EVENT_DOWN);
  1270.             ClearKeyHandler(KEY_LSK, KEY_EVENT_UP);
  1271.             left_softkey_keyboard_handler_active = 0;
  1272.             break;
  1274.         case MMI_RIGHT_SOFTKEY:
  1275.             ClearKeyHandler(KEY_RSK, KEY_EVENT_DOWN);
  1276.             ClearKeyHandler(KEY_RSK, KEY_EVENT_UP);
  1277.             right_softkey_keyboard_handler_active = 0;
  1278.             break;
  1280.     #ifdef __MMI_WGUI_CSK_ENABLE__
  1281.         case MMI_CENTER_SOFTKEY:
  1282.             ClearKeyHandler(KEY_CSK, KEY_EVENT_DOWN);
  1283.             ClearKeyHandler(KEY_CSK, KEY_EVENT_UP);
  1284.             center_softkey_keyboard_handler_active = 0;
  1285.             break;
  1286.     #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1287.     }
  1288. }
  1291. /*****************************************************************************
  1292.  * FUNCTION
  1293.  *  softkey_keyboard_handler
  1294.  * DESCRIPTION
  1295.  *  Keyboard handler (Simulator) for softkeys
  1296.  * PARAMETERS
  1297.  *  vkey_code       [IN]        Key type
  1298.  *  key_state       [IN]        Key event type
  1299.  * RETURNS
  1300.  *  void
  1301.  *****************************************************************************/
  1302. void softkey_keyboard_handler(S32 vkey_code, S32 key_state)
  1303. {
  1304.     /*----------------------------------------------------------------*/
  1305.     /* Local Variables                                                */
  1306.     /*----------------------------------------------------------------*/
  1308.     /*----------------------------------------------------------------*/
  1309.     /* Code Body                                                      */
  1310.     /*----------------------------------------------------------------*/
  1311.     if (key_state)
  1312.     {
  1313.         switch (vkey_code)
  1314.         {
  1315.             case 112:
  1316.                 if (left_softkey_keyboard_handler_active)
  1317.                 {
  1318.                     left_softkey_down();
  1319.                 }
  1320.                 break;
  1321.             case 113:
  1322.                 if (right_softkey_keyboard_handler_active)
  1323.                 {
  1324.                     right_softkey_down();
  1325.                 }
  1326.                 break;
  1327.         }
  1328.     }
  1329.     else
  1330.     {
  1331.         switch (vkey_code)
  1332.         {
  1333.             case 112:
  1334.                 if (left_softkey_keyboard_handler_active)
  1335.                 {
  1336.                     left_softkey_up();
  1337.                 }
  1338.                 break;
  1339.             case 113:
  1340.                 if (right_softkey_keyboard_handler_active)
  1341.                 {
  1342.                     right_softkey_up();
  1343.                 }
  1344.                 break;
  1345.         }
  1346.     }
  1347. }
  1350. /*****************************************************************************
  1351.  * FUNCTION
  1352.  *  register_hide_softkey
  1353.  * DESCRIPTION
  1354.  *  Register handlers of hide softkeys
  1355.  * PARAMETERS
  1356.  *  f       [IN]        Callback function to hide softkey
  1357.  *  key     [IN]        Softkey enum
  1358.  * RETURNS
  1359.  *  void
  1360.  *****************************************************************************/
  1361. void register_hide_softkey(void (*f) (void), WGUI_SOFTKEY_ENUM key)
  1362. {
  1363.     /*----------------------------------------------------------------*/
  1364.     /* Local Variables                                                */
  1365.     /*----------------------------------------------------------------*/
  1367.     /*----------------------------------------------------------------*/
  1368.     /* Code Body                                                      */
  1369.     /*----------------------------------------------------------------*/
  1370.     hide_softkey[key] = f;
  1371. }
  1374. /*****************************************************************************
  1375.  * FUNCTION
  1376.  *  reset_softkeys
  1377.  * DESCRIPTION
  1378.  *  Sets the softkey states to normal and clears the hide functions
  1379.  * PARAMETERS
  1380.  *  void
  1381.  * RETURNS
  1382.  *  void
  1383.  *****************************************************************************/
  1384. void reset_softkeys(void)
  1385. {
  1386.     /*----------------------------------------------------------------*/
  1387.     /* Local Variables                                                */
  1388.     /*----------------------------------------------------------------*/
  1389.     U8 i = 0;
  1391.     /*----------------------------------------------------------------*/
  1392.     /* Code Body                                                      */
  1393.     /*----------------------------------------------------------------*/
  1394.     for (i = 0; i < WGUI_MAX_SOFTKEYS; i++)
  1395.     {
  1396.         MMI_softkeys[i].flags &= ~UI_BUTTON_STATE_CLICKED;
  1397.         MMI_softkeys[i].flags &= ~UI_BUTTON_STATE_DOWN;
  1398.         MMI_softkeys[i].flags &= ~UI_BUTTON_STATE_DISABLED;
  1399.         MMI_softkeys[i].flags &= ~UI_BUTTON_ALWAYS_SEND_PEN_UP_INSIDE;
  1400.         MMI_softkeys[i].flags &= ~UI_BUTTON_NO_SHIFT_BUTTON;
  1401.         hide_softkey[i] = UI_dummy_function;
  1402.     }
  1403. }
  1406. /*****************************************************************************
  1407.  * FUNCTION
  1408.  *  reset_softkey
  1409.  * DESCRIPTION
  1410.  *  Sets the softkey states to normal and clears the hide functions
  1411.  * PARAMETERS
  1412.  *  key     [IN]        
  1413.  * RETURNS
  1414.  *  void
  1415.  *****************************************************************************/
  1416. void reset_softkey(WGUI_SOFTKEY_ENUM key)
  1417. {
  1418.     /*----------------------------------------------------------------*/
  1419.     /* Local Variables                                                */
  1420.     /*----------------------------------------------------------------*/
  1422.     /*----------------------------------------------------------------*/
  1423.     /* Code Body                                                      */
  1424.     /*----------------------------------------------------------------*/
  1425.     MMI_softkeys[key].flags &= ~UI_BUTTON_STATE_CLICKED;
  1426.     MMI_softkeys[key].flags &= ~UI_BUTTON_STATE_DOWN;
  1427.     MMI_softkeys[key].flags &= ~UI_BUTTON_STATE_DISABLED;
  1428.     MMI_softkeys[key].flags &= ~UI_BUTTON_ALWAYS_SEND_PEN_UP_INSIDE;
  1429.     /* Do not reset UI_BUTTON_NO_SHIFT_BUTTON and hide_softkey[] */
  1430. }
  1433. /*****************************************************************************
  1434.  * FUNCTION
  1435.  *  disable_softkey_background
  1436.  * DESCRIPTION
  1437.  *  Set some flags to disable background display of softkeys
  1438.  * PARAMETERS
  1439.  *  void
  1440.  * RETURNS
  1441.  *  void
  1442.  *****************************************************************************/
  1443. void disable_softkey_background(void)
  1444. {
  1445.     /*----------------------------------------------------------------*/
  1446.     /* Local Variables                                                */
  1447.     /*----------------------------------------------------------------*/
  1448.     U8 i = 0;
  1450.     /*----------------------------------------------------------------*/
  1451.     /* Code Body                                                      */
  1452.     /*----------------------------------------------------------------*/
  1453.     for (i = 0; i < WGUI_MAX_SOFTKEYS; i++)
  1454.     {
  1455.     #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  1456.         MMI_softkeys[i].flags |= UI_BUTTON_NO_UNDER_BAR;
  1457.     #else 
  1458.         MMI_softkeys[i].flags |= UI_BUTTON_DISABLE_BACKGND_DISPLAY;
  1459.     #endif 
  1460.     }
  1461. }
  1464. /*****************************************************************************
  1465.  * FUNCTION
  1466.  *  enable_softkey_background
  1467.  * DESCRIPTION
  1468.  *  Set some flags to disable background display of softkeys
  1469.  * PARAMETERS
  1470.  *  void
  1471.  * RETURNS
  1472.  *  void
  1473.  *****************************************************************************/
  1474. void enable_softkey_background(void)
  1475. {
  1476.     /*----------------------------------------------------------------*/
  1477.     /* Local Variables                                                */
  1478.     /*----------------------------------------------------------------*/
  1479.     U8 i = 0;
  1481.     /*----------------------------------------------------------------*/
  1482.     /* Code Body                                                      */
  1483.     /*----------------------------------------------------------------*/
  1484.     for (i = 0; i < WGUI_MAX_SOFTKEYS; i++)
  1485.     {
  1486.     #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__)
  1487.         MMI_softkeys[i].flags &= ~UI_BUTTON_NO_UNDER_BAR;
  1488.     #else 
  1489.         MMI_softkeys[i].flags &= ~UI_BUTTON_DISABLE_BACKGND_DISPLAY;
  1490.     #endif 
  1491.     }
  1492. }
  1495. /*****************************************************************************
  1496.  * FUNCTION
  1497.  *  set_softkey_flags_on
  1498.  * DESCRIPTION
  1499.  *  turn on flag of softkeys
  1500.  * PARAMETERS
  1501.  *  flag        [IN]        
  1502.  *  key         [IN]        
  1503.  * RETURNS
  1504.  *  void
  1505.  *****************************************************************************/
  1506. void set_softkey_flags_on(S32 flag, WGUI_SOFTKEY_ENUM key)
  1507. {
  1508.     /*----------------------------------------------------------------*/
  1509.     /* Local Variables                                                */
  1510.     /*----------------------------------------------------------------*/
  1512.     /*----------------------------------------------------------------*/
  1513.     /* Code Body                                                      */
  1514.     /*----------------------------------------------------------------*/
  1515.     MMI_softkeys[key].flags |= flag;
  1516. }
  1519. /*****************************************************************************
  1520.  * FUNCTION
  1521.  *  set_softkey_flags_off
  1522.  * DESCRIPTION
  1523.  *  turn off  flag of softkeys
  1524.  * PARAMETERS
  1525.  *  flag        [IN]        
  1526.  *  key         [IN]        
  1527.  * RETURNS
  1528.  *  void
  1529.  *****************************************************************************/
  1530. void set_softkey_flags_off(S32 flag, WGUI_SOFTKEY_ENUM key)
  1531. {
  1532.     /*----------------------------------------------------------------*/
  1533.     /* Local Variables                                                */
  1534.     /*----------------------------------------------------------------*/
  1536.     /*----------------------------------------------------------------*/
  1537.     /* Code Body                                                      */
  1538.     /*----------------------------------------------------------------*/
  1539.     MMI_softkeys[key].flags &= ~flag;
  1540. }
  1542. #ifdef __MMI_TOUCH_SCREEN__
  1545. /*****************************************************************************
  1546.  * FUNCTION
  1547.  *  translate_softkey_pen_event
  1548.  * DESCRIPTION
  1549.  *  translate low level key events to softkey related events
  1550.  * PARAMETERS
  1551.  *  key                 [IN]            One of value of WGUI_SOFTKEY_ENUM
  1552.  *  pen_event           [IN]            Low level pen event type
  1553.  *  x                   [IN]            X-coordinate of pen event
  1554.  *  y                   [IN]            Y-coordinate of pen event
  1555.  *  button_event        [IN/OUT]        Softkey related event type
  1556.  * RETURNS
  1557.  *  void
  1558.  *****************************************************************************/
  1559. BOOL translate_softkey_pen_event(
  1560.         WGUI_SOFTKEY_ENUM key,
  1561.         mmi_pen_event_type_enum pen_event,
  1562.         S16 x,
  1563.         S16 y,
  1564.         gui_button_pen_enum *button_event)
  1565. {
  1566.     /*----------------------------------------------------------------*/
  1567.     /* Local Variables                                                */
  1568.     /*----------------------------------------------------------------*/
  1570.     /*----------------------------------------------------------------*/
  1571.     /* Code Body                                                      */
  1572.     /*----------------------------------------------------------------*/
  1573.     return gui_icontext_button_translate_pen_event(&MMI_softkeys[key], pen_event, x, y, button_event);
  1574. }
  1575. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1578. /*****************************************************************************
  1579.  * FUNCTION
  1580.  *  wgui_softkey_get_dimension
  1581.  * DESCRIPTION
  1582.  *  get softkey dimenstion
  1583.  * PARAMETERS
  1584.  *  key         [IN]            One of value of WGUI_SOFTKEY_ENUM
  1585.  *  width       [IN/OUT]        Width of softkey
  1586.  *  height      [IN/OUT]        Height of softkey
  1587.  * RETURNS
  1588.  *  void
  1589.  *****************************************************************************/
  1590. void wgui_softkey_get_dimension(WGUI_SOFTKEY_ENUM key, S32 *width, S32 *height)
  1591. {
  1592.     /*----------------------------------------------------------------*/
  1593.     /* Local Variables                                                */
  1594.     /*----------------------------------------------------------------*/
  1596.     /*----------------------------------------------------------------*/
  1597.     /* Code Body                                                      */
  1598.     /*----------------------------------------------------------------*/
  1599.     *width = MMI_softkeys[key].width;
  1600.     *height = MMI_softkeys[key].height;
  1601. }
  1604. /*****************************************************************************
  1605.  * FUNCTION
  1606.  *  wgui_softkey_get_position
  1607.  * DESCRIPTION
  1608.  *  get softkey position
  1609.  * PARAMETERS
  1610.  *  key         [IN]            One of value of WGUI_SOFTKEY_ENUM
  1611.  *  x           [IN/OUT]        X-position of softkey
  1612.  *  y           [?]             
  1613.  *  yx(?)       [IN/OUT]        Y-positino of softkey
  1614.  * RETURNS
  1615.  *  void
  1616.  *****************************************************************************/
  1617. void wgui_softkey_get_position(WGUI_SOFTKEY_ENUM key, S32 *x, S32 *y)
  1618. {
  1619.     /*----------------------------------------------------------------*/
  1620.     /* Local Variables                                                */
  1621.     /*----------------------------------------------------------------*/
  1623.     /*----------------------------------------------------------------*/
  1624.     /* Code Body                                                      */
  1625.     /*----------------------------------------------------------------*/
  1626.     *x = MMI_softkeys[key].x;
  1627.     *y = MMI_softkeys[key].y;
  1628. }
  1630. #ifdef __MMI_UI_DALMATIAN_SOFTKEYS__
  1633. /*****************************************************************************
  1634.  * FUNCTION
  1635.  *  gui_register_button_shuffle
  1636.  * DESCRIPTION
  1637.  *  Registers the function to be called to shuffle the softkeys
  1638.  * PARAMETERS
  1639.  *  f               [IN]        
  1640.  *  function(?)     [IN]        Pointer
  1641.  * RETURNS
  1642.  *  void
  1643.  *****************************************************************************/
  1644. void gui_register_button_shuffle(void (*f) (void))
  1645. {
  1646.     /*----------------------------------------------------------------*/
  1647.     /* Local Variables                                                */
  1648.     /*----------------------------------------------------------------*/
  1650.     /*----------------------------------------------------------------*/
  1651.     /* Code Body                                                      */
  1652.     /*----------------------------------------------------------------*/
  1653.     pixtel_shuffle_draw_background = f;
  1654. }
  1657. /*****************************************************************************
  1658.  * FUNCTION
  1659.  *  gui_call_shuffle
  1660.  * DESCRIPTION
  1661.  *  Called the shuffle Registered function for the softkeys
  1662.  * PARAMETERS
  1663.  *  void
  1664.  * RETURNS
  1665.  *  void
  1666.  *****************************************************************************/
  1667. void gui_call_shuffle(void)
  1668. {
  1669.     /*----------------------------------------------------------------*/
  1670.     /* Local Variables                                                */
  1671.     /*----------------------------------------------------------------*/
  1673.     /*----------------------------------------------------------------*/
  1674.     /* Code Body                                                      */
  1675.     /*----------------------------------------------------------------*/
  1676.     gdi_layer_lock_frame_buffer();
  1677.     gdi_layer_push_clip();
  1678.     gdi_layer_set_clip(0, UI_device_height - MMI_BUTTON_BAR_HEIGHT, UI_device_width - 1, UI_device_height - 1);
  1680.     pixtel_shuffle_draw_background();
  1682.     if (is_button_bar_shuffled == 0)
  1683.     {
  1684.         MMI_right_softkey.y = UI_device_height - MMI_softkey_height;
  1685.         MMI_left_softkey.y = UI_device_height - MMI_softkey_height - (MMI_BUTTON_BAR_HEIGHT - MMI_softkey_height);
  1687.         show_right_softkey();
  1688.         show_left_softkey();
  1690.     }
  1691.     else
  1692.     {
  1693.         MMI_left_softkey.y = UI_device_height - MMI_softkey_height;
  1694.         MMI_right_softkey.y = UI_device_height - MMI_softkey_height - (MMI_BUTTON_BAR_HEIGHT - MMI_softkey_height);
  1695.         show_left_softkey();
  1696.         show_right_softkey();
  1698.     }
  1699.     gdi_layer_pop_clip();
  1700.     gdi_layer_unlock_frame_buffer();
  1701.     gdi_layer_blt_previous(0, UI_device_height - MMI_BUTTON_BAR_HEIGHT, UI_device_width - 1, UI_device_height - 1);
  1702. }
  1705. /*****************************************************************************
  1706.  * FUNCTION
  1707.  *  shuffle_draw_white
  1708.  * DESCRIPTION
  1709.  *  Common Function for draw white background in shuffle
  1710.  * PARAMETERS
  1711.  *  void
  1712.  * RETURNS
  1713.  *  void
  1714.  *****************************************************************************/
  1715. void shuffle_draw_white(void)
  1716. {
  1717.     /*----------------------------------------------------------------*/
  1718.     /* Local Variables                                                */
  1719.     /*----------------------------------------------------------------*/
  1721.     /*----------------------------------------------------------------*/
  1722.     /* Code Body                                                      */
  1723.     /*----------------------------------------------------------------*/
  1724.     gdi_draw_solid_rect(
  1725.         0,
  1726.         UI_device_height - MMI_BUTTON_BAR_HEIGHT,
  1727.         UI_device_width - 1,
  1728.         UI_device_height - 1,
  1729.         GDI_COLOR_WHITE);
  1730. }
  1731. #endif /* __MMI_UI_DALMATIAN_SOFTKEYS__ */