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

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

MTK

开发平台：

C/C++

mainlcd.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  *  mainlcd.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *  MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *  define LCD and sub-LCD routines.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  * -------
  54.  *
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  * removed!
  60.  *
  61.  * removed!
  62.  * removed!
  63.  * removed!
  64.  *
  65.  * removed!
  66.  * removed!
  67.  * removed!
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * removed!
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * removed!
  76.  *
  77.  * removed!
  78.  * removed!
  79.  * removed!
  80.  *
  81.  * removed!
  82.  * removed!
  83.  * removed!
  84.  *
  85.  *------------------------------------------------------------------------------
  86.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  87.  *============================================================================
  88.  ****************************************************************************/
  89. #ifndef _MAINLCD_C
  90. #define _MAINLCD_C
  91. #include "mmi_features.h"
  92. #include "kal_non_specific_general_types.h"
  93. #include "gui.h"
  95. /* target    : custom/drv/LCD/XXXXLCM/lcd_sw_inc.h */
  96. /* simulator : plutommi/mmi/DrvSim/DrvSimInc/lcd_sw_inc.h */
  97. #include "lcd_sw.h"
  99. /* interface/Include/lcd_if.h */
  100. #include "lcd_if.h"
  101. #include "gdi_include.h"
  102. #include "KeyMap.h"
  103. #include "lcd_sw_rnd.h"
  105. /***************************************************************************** 
  106. * Define
  107. *****************************************************************************/
  108. #if 0
  109. /* under construction !*/
  110. /* under construction !*/
  111. /* under construction !*/
  112. /* under construction !*/
  113. #endif /* 0 */ 
  115. #define SIMULATOR_LAYER_COUNT       (4)
  117. #define  BUF_PIXEL_DATA(buff_ptr,x , y, width)  (*(buff_ptr + ((y) * width + (x))))
  118. #define  RGB_TO_HW(R, G, B)                     ((((B) & 0xf8) >> 3) | (((G) & 0xfc) << 3) | (((R) & 0xf8) << 8))
  119. #define  HW_TO_RGB_R(VALUE)                     ((U8)(((VALUE) & 0xf800) >> 8))
  120. #define  HW_TO_RGB_G(VALUE)                     ((U8)(((VALUE) & 0x07e0) >> 3))
  121. #define  HW_TO_RGB_B(VALUE)                     ((U8)(((VALUE) & 0x001f) << 3))
  123. #define  LCD_LAYER0_ENABLE    0x80000000
  124. #define  LCD_LAYER1_ENABLE    0x40000000
  125. #define  LCD_LAYER2_ENABLE    0x20000000
  126. #define  LCD_LAYER3_ENABLE    0x10000000
  128. /***************************************************************************** 
  129. * Typedef 
  130. *****************************************************************************/
  131. /* it must be identical to what was defined in MODIS_UI.h */
  132. typedef struct
  133. {
  134.     unsigned int layer_enable;
  135.     unsigned int frame_buffer_address;
  137.     int text_clip_left;
  138.     int text_clip_top;
  139.     int text_clip_right;
  140.     int text_clip_bottom;
  142.     int gfx_clip_left;
  143.     int gfx_clip_top;
  144.     int gfx_clip_right;
  145.     int gfx_clip_bottom;
  147.     int active_layer;
  149.     unsigned short layer_x_offset;
  150.     unsigned short layer_y_offset;
  151.     unsigned short layer_width;
  152.     unsigned short layer_height;
  154.     unsigned short roi_x_offset;
  155.     unsigned short roi_y_offset;
  156.     unsigned short roi_width;
  157.     unsigned short roi_height;
  159.     unsigned char source_key_enable;
  160.     unsigned char opacity_enable;
  161.     unsigned short source_key;
  162.     unsigned char opacity_value;
  163. } MODIS_UI_layer_info_struct;
  165. /***************************************************************************** 
  166. * Local Variable
  167. *****************************************************************************/
  168. /* Main LCD simulator shadow buffer */
  169. U16 simulator_shadow_buffer[LCD_WIDTH * LCD_HEIGHT];
  171. /* Sub LCD simulator shadow buffer */
  172. #ifdef __MMI_SUBLCD__
  173. U16 simulator_sub_shadow_buffer[SUBLCD_WIDTH * SUBLCD_HEIGHT];
  174. #endif 
  176. /* Main LCD frame buffer for bitmap */
  177. unsigned int simulator_frame_buffer[LCD_WIDTH * LCD_HEIGHT];
  179. #ifdef __MMI_SUBLCD__
  180. /* Sub LCD frame buffer for bitmap */
  181. unsigned int sub_simulator_frame_buffer[SUBLCD_WIDTH * SUBLCD_HEIGHT];
  182. #endif /* __MMI_SUBLCD__ */ 
  184. BITMAPINFO bitmap_info;
  185. BITMAPINFO sub_bitmap_info;
  187. T_W32_SCREEN_DEVICE *device;
  189. U16 SIMULATOR_SKIN_LCD_X;
  190. U16 SIMULATOR_SKIN_LCD_Y;
  191. U16 SIMULATOR_SKIN_SUB_LCD_X;
  192. U16 SIMULATOR_SKIN_SUB_LCD_Y;
  194. #ifdef __MMI_SUBLCD__
  195. kal_uint8 SubLCDSetArray[] = 
  196. {
  197.     0x01,   /* 0000 0001 */
  198.     0x02,   /* 0000 0010 */
  199.     0x04,   /* 0000 0100 */
  200.     0x08,   /* 0000 1000 */
  201.     0x10,   /* 0001 0000 */
  202.     0x20,   /* 0010 0000 */
  203.     0x40,   /* 0100 0000 */
  204.     0x80    /* 1000 0000 */
  205. };
  207. kal_uint8 SubLCDReSetArray[] = 
  208. {
  209.     0xFE,   /* 1111 1110 */
  210.     0xFD,   /* 1111 1101 */
  211.     0xFB,   /* 1111 1011 */
  212.     0xF7,   /* 1111 0111 */
  213.     0xEF,   /* 1110 1111 */
  214.     0xDF,   /* 1101 1111 */
  215.     0xBF,   /* 1011 1111 */
  216.     0x7F    /* 0111 1111 */
  217. };
  218. #endif /* __MMI_SUBLCD__ */ 
  220. /* main window */
  221. /* layer_sim_size    layer_sim_main_window; */
  223. /* ROI */
  224. /* layer_sim_offset  layer_sim_ROI_offset; */
  225. /* layer_sim_size    layer_sim_ROI_size; /*
  226.    
  227.    /* layers */
  228. lcd_layer_struct lcd_layer_data[SIMULATOR_LAYER_COUNT];
  230. /* palette look up table */
  231. U16 layer_sim_LUT0[256];
  232. U16 layer_sim_LUT1[256];
  234. BOOL IsLcdFirstInit = TRUE;
  236. HDC hdcMem, hdc;
  238. #ifdef __MMI_SUBLCD__
  239. HDC sub_hdcMem;
  240. HBITMAP sub_hbmp;
  241. #endif /* __MMI_SUBLCD__ */ 
  242. HBITMAP hbmp;
  244. MODIS_UI_layer_info_struct MODIS_UI_layer[SIMULATOR_LAYER_COUNT];
  245. MODIS_UI_layer_info_struct **MODIS_UI_layer_ptr;
  246. MODIS_UI_layer_info_struct *uil_ptr;
  248. unsigned char new_application_flag = 0;
  249. S32 active_layer;
  251. /***************************************************************************** 
  252. * Local Function
  253. *****************************************************************************/
  255. /***************************************************************************** 
  256. * Global Variable
  257. *****************************************************************************/
  258. extern HWND hWnd;
  260. /***************************************************************************** 
  261. * Global Function
  262. *****************************************************************************/
  263. extern T_W32_SCREEN_DEVICE *GetDeviceData();
  264. extern __declspec(dllimport)
  265.      void set_MODIS_UI_layer_data(MODIS_UI_layer_info_struct **layer,
  266.                                   int lcd_width, int lcd_height, int layer_count, unsigned char *new_app_flag);
  269. /*****************************************************************************
  270.  * FUNCTION
  271.  *  assert_lcd_fb_update
  272.  * DESCRIPTION
  273.  *  void
  274.  * PARAMETERS
  275.  *  lcd_id              [IN]        U8
  276.  *  start_x             [IN]        U16
  277.  *  start_y             [IN]        U16
  278.  *  end_x               [IN]        U16
  279.  *  end_y               [IN]        U16
  280.  *  roi_offset_x        [IN]        U16
  281.  *  roi_offset_y        [IN]        U16
  282.  *  update_layer        [IN]        U32
  283.  * RETURNS
  284.  *  void
  285.  *****************************************************************************/
  286.      void assert_lcd_fb_update(
  287.             kal_uint8 lcd_id,
  288.             kal_uint16 start_x,
  289.             kal_uint16 start_y,
  290.             kal_uint16 end_x,
  291.             kal_uint16 end_y,
  292.             kal_uint16 roi_offset_x,
  293.             kal_uint16 roi_offset_y,
  294.             kal_uint32 update_layer)
  295. {
  297.     /*----------------------------------------------------------------*/
  298.     /* Local Variables                                                */
  299.     /*----------------------------------------------------------------*/
  301.     /*----------------------------------------------------------------*/
  302.     /* Code Body                                                      */
  303.     /*----------------------------------------------------------------*/
  304. }   /* end of assert_lcd_fb_update */
  307. /*****************************************************************************
  308.  * FUNCTION
  309.  *  reset_lcd_if
  310.  * DESCRIPTION
  311.  *  void
  312.  * PARAMETERS
  313.  *  void
  314.  * RETURNS
  315.  *  void
  316.  *****************************************************************************/
  317. void reset_lcd_if(void)
  318. {
  319.     /*----------------------------------------------------------------*/
  320.     /* Local Variables                                                */
  321.     /*----------------------------------------------------------------*/
  323.     /*----------------------------------------------------------------*/
  324.     /* Code Body                                                      */
  325.     /*----------------------------------------------------------------*/
  326. }   /* end of reset_lcd_if */
  329. /*****************************************************************************
  330.  * FUNCTION
  331.  *  config_lcd_layer_window
  332.  * DESCRIPTION
  333.  *  void
  334.  * PARAMETERS
  335.  *  lcd_layer       [IN]        Unsigned char
  336.  *  layer_data      [IN]        Lcd_layer_struct
  337.  * RETURNS
  338.  * TRUE
  339.  *****************************************************************************/
  340. BOOL config_lcd_layer_window(unsigned char lcd_layer, lcd_layer_struct *layer_data)
  341. {
  342.     /*----------------------------------------------------------------*/
  343.     /* Local Variables                                                */
  344.     /*----------------------------------------------------------------*/
  346.     /*----------------------------------------------------------------*/
  347.     /* Code Body                                                      */
  348.     /*----------------------------------------------------------------*/
  349.     lcd_layer_data[lcd_layer] = *layer_data;
  351.     return TRUE;
  352. }   /* end of config_lcd_layer_window */
  355. /*****************************************************************************
  356.  * FUNCTION
  357.  *  lcd_dspl_init
  358.  * DESCRIPTION
  359.  *  screen initialization
  360.  * PARAMETERS
  361.  *  void
  362.  * RETURNS
  363.  *  void
  364.  *****************************************************************************/
  365. void lcd_dspl_init()
  366. {
  367.     /*----------------------------------------------------------------*/
  368.     /* Local Variables                                                */
  369.     /*----------------------------------------------------------------*/
  370.     int i;
  372.     /*----------------------------------------------------------------*/
  373.     /* Code Body                                                      */
  374.     /*----------------------------------------------------------------*/
  375.     MODIS_UI_layer_ptr =
  376.         (MODIS_UI_layer_info_struct **) malloc(SIMULATOR_LAYER_COUNT * sizeof(MODIS_UI_layer_info_struct*));
  378.     /* initialize pointer allocation for MODIS_UI_layer */
  379.     for (i = 0; i < SIMULATOR_LAYER_COUNT; i++)
  380.     {
  381.         MODIS_UI_layer_ptr[i] = &MODIS_UI_layer[i];
  382.     }
  384.     /* initialize layout data */
  385.     device = GetDeviceData();
  387.     SIMULATOR_SKIN_LCD_X = device->skin_main_lcd_x;
  388.     SIMULATOR_SKIN_LCD_Y = device->skin_main_lcd_y;
  390. #ifdef __MMI_SUBLCD__
  391.     SIMULATOR_SKIN_SUB_LCD_X = device->skin_sub_lcd_x;
  392.     SIMULATOR_SKIN_SUB_LCD_Y = device->skin_sub_lcd_y;
  393. #endif /* __MMI_SUBLCD__ */ 
  395.     /* adjust the diplaying position for LCD if the skin is bigger than real one */
  396.     if (LCD_WIDTH < device->main_lcd_width)
  397.     {
  398.         SIMULATOR_SKIN_LCD_X = SIMULATOR_SKIN_LCD_X + (device->main_lcd_width - LCD_WIDTH) / 2;
  399.         device->skin_main_lcd_x = SIMULATOR_SKIN_LCD_X;
  400.     }
  401.     if (LCD_HEIGHT < device->main_lcd_height)
  402.     {
  403.         SIMULATOR_SKIN_LCD_Y = SIMULATOR_SKIN_LCD_Y + (device->main_lcd_height - LCD_HEIGHT) / 2;
  404.         device->skin_main_lcd_y = SIMULATOR_SKIN_LCD_Y;
  405.     }
  407. #ifdef __MMI_SUBLCD__
  408.     /* adjust the diplaying position for sub-LCD if the skin is bigger than real one */
  409.     if (SUBLCD_WIDTH < device->sub_lcd_width)
  410.     {
  411.         SIMULATOR_SKIN_SUB_LCD_X = SIMULATOR_SKIN_SUB_LCD_X + (device->sub_lcd_width - SUBLCD_WIDTH) / 2;
  412.         device->skin_sub_lcd_x = SIMULATOR_SKIN_SUB_LCD_X;
  413.     }
  414.     if (SUBLCD_HEIGHT < device->sub_lcd_height)
  415.     {
  416.         SIMULATOR_SKIN_SUB_LCD_Y = SIMULATOR_SKIN_SUB_LCD_Y + (device->sub_lcd_height - SUBLCD_HEIGHT) / 2;
  417.         device->skin_sub_lcd_y = SIMULATOR_SKIN_SUB_LCD_Y;
  418.     }
  419. #endif /* __MMI_SUBLCD__ */ 
  421.     /* set up the bitmap infomation */
  422.     bitmap_info.bmiHeader.biSize = sizeof(bitmap_info.bmiHeader);
  423.     bitmap_info.bmiHeader.biWidth = LCD_WIDTH;
  424.     bitmap_info.bmiHeader.biHeight = LCD_HEIGHT;
  425.     bitmap_info.bmiHeader.biPlanes = 1;
  426.     bitmap_info.bmiHeader.biBitCount = 32;
  427.     bitmap_info.bmiHeader.biCompression = BI_RGB;
  428.     bitmap_info.bmiHeader.biSizeImage = LCD_WIDTH * LCD_HEIGHT * 4;
  429.     bitmap_info.bmiHeader.biClrUsed = 0;
  430.     bitmap_info.bmiHeader.biClrImportant = 0;
  432. #ifdef __MMI_SUBLCD__
  433.     /* set up the sub-bitmap infomation */
  434.     sub_bitmap_info.bmiHeader.biSize = sizeof(sub_bitmap_info.bmiHeader);
  435.     sub_bitmap_info.bmiHeader.biWidth = SUBLCD_WIDTH;
  436.     sub_bitmap_info.bmiHeader.biHeight = SUBLCD_HEIGHT;
  437.     sub_bitmap_info.bmiHeader.biPlanes = 1;
  438.     sub_bitmap_info.bmiHeader.biBitCount = 32;
  439.     sub_bitmap_info.bmiHeader.biCompression = BI_RGB;
  440.     sub_bitmap_info.bmiHeader.biSizeImage = SUBLCD_WIDTH * SUBLCD_HEIGHT * 4;
  441.     sub_bitmap_info.bmiHeader.biClrUsed = 0;
  442.     sub_bitmap_info.bmiHeader.biClrImportant = 0;
  443. #endif /* __MMI_SUBLCD__ */ 
  445.     /* draw to simulator's main LCD region */
  446.     hdc = GetDC(hWnd);
  447.     hdcMem = CreateCompatibleDC(hdc);
  448.     hbmp = CreateCompatibleBitmap(hdc, LCD_WIDTH, LCD_HEIGHT);
  449.     SelectObject(hdcMem, hbmp);
  451. #ifdef __MMI_SUBLCD__
  452.     /* draw to simulator's sub LCD region */
  453.     hdc = GetDC(hWnd);
  454.     sub_hdcMem = CreateCompatibleDC(hdc);
  455.     sub_hbmp = CreateCompatibleBitmap(hdc, SUBLCD_WIDTH, SUBLCD_HEIGHT);
  456.     SelectObject(sub_hdcMem, sub_hbmp);
  457. #endif /* __MMI_SUBLCD__ */ 
  459. }   /* end of lcd_dspl_init */
  462. /*****************************************************************************
  463.  * FUNCTION
  464.  *  set_global_window_handle
  465.  * DESCRIPTION
  466.  *  set global the window handle
  467.  * PARAMETERS
  468.  *  hwnd        [IN]        The input window handle
  469.  * RETURNS
  470.  *  void
  471.  *****************************************************************************/
  472. void set_global_window_handle(HWND hwnd)
  473. {
  474.     /*----------------------------------------------------------------*/
  475.     /* Local Variables                                                */
  476.     /*----------------------------------------------------------------*/
  478.     /*----------------------------------------------------------------*/
  479.     /* Code Body                                                      */
  480.     /*----------------------------------------------------------------*/
  481.     hWnd = hwnd;
  482. }   /* end of set_global_window_handle */
  485. /*****************************************************************************
  486.  * FUNCTION
  487.  *  lcd_screen_init
  488.  * DESCRIPTION
  489.  *  screen initialization
  490.  * PARAMETERS
  491.  *  hWnd            [IN]        
  492.  *  hInstance       [IN]        
  493.  * RETURNS
  494.  *  void
  495.  *****************************************************************************/
  496. void lcd_screen_init(HWND hWnd, HINSTANCE hInstance)
  497. {
  498.     /*----------------------------------------------------------------*/
  499.     /* Local Variables                                                */
  500.     /*----------------------------------------------------------------*/
  502.     /*----------------------------------------------------------------*/
  503.     /* Code Body                                                      */
  504.     /*----------------------------------------------------------------*/
  505.     device = GetDeviceData();
  507.     device->hwnd = hWnd;
  508.     set_global_window_handle(hWnd);
  509.     lcd_dspl_init();
  510. }   /* end of lcd_screen_init */
  513. /*****************************************************************************
  514.  * FUNCTION
  515.  *  update_screen
  516.  * DESCRIPTION
  517.  *  update the screen
  518.  * PARAMETERS
  519.  *  void
  520.  * RETURNS
  521.  *  void
  522.  *****************************************************************************/
  523. void update_screen()
  524. {
  525.     /*----------------------------------------------------------------*/
  526.     /* Local Variables                                                */
  527.     /*----------------------------------------------------------------*/
  529.     /*----------------------------------------------------------------*/
  530.     /* Code Body                                                      */
  531.     /*----------------------------------------------------------------*/
  532.     hdc = GetDC(hWnd);
  533.     hdcMem = CreateCompatibleDC(hdc);
  534.     hbmp = CreateCompatibleBitmap(hdc, LCD_WIDTH, LCD_HEIGHT);
  535.     SelectObject(hdcMem, hbmp);
  537.     if (simulator_frame_buffer != NULL)
  538.     {
  539.         SetDIBits(NULL, hbmp, 0, LCD_HEIGHT, simulator_frame_buffer, &bitmap_info, DIB_RGB_COLORS);
  540.     }
  541.     BitBlt(
  542.         hdc,
  543.         SIMULATOR_SKIN_LCD_X,
  544.         SIMULATOR_SKIN_LCD_Y,
  545.         SIMULATOR_SKIN_LCD_X + LCD_WIDTH,
  546.         SIMULATOR_SKIN_LCD_Y + LCD_HEIGHT,
  547.         hdcMem,
  548.         0,
  549.         0,
  550.         SRCCOPY);
  552.     ReleaseDC(hWnd, hdc);
  553.     DeleteDC(hdcMem);
  554.     DeleteObject(hbmp);
  556. #ifdef __MMI_SUBLCD__
  557.     hdc = GetDC(hWnd);
  558.     sub_hdcMem = CreateCompatibleDC(hdc);
  559.     sub_hbmp = CreateCompatibleBitmap(hdc, SUBLCD_WIDTH, SUBLCD_HEIGHT);
  560.     SelectObject(sub_hdcMem, sub_hbmp);
  562.     if (sub_simulator_frame_buffer != NULL)
  563.     {
  564.         SetDIBits(NULL, sub_hbmp, 0, SUBLCD_HEIGHT, sub_simulator_frame_buffer, &sub_bitmap_info, DIB_RGB_COLORS);
  565.     }
  566.     BitBlt(
  567.         hdc,
  568.         SIMULATOR_SKIN_SUB_LCD_X,
  569.         SIMULATOR_SKIN_SUB_LCD_Y,
  570.         SIMULATOR_SKIN_SUB_LCD_X + SUBLCD_WIDTH,
  571.         SIMULATOR_SKIN_SUB_LCD_Y + SUBLCD_HEIGHT,
  572.         sub_hdcMem,
  573.         0,
  574.         0,
  575.         SRCCOPY);
  577.     ReleaseDC(hWnd, hdc);
  578.     DeleteDC(sub_hdcMem);
  579.     DeleteObject(sub_hbmp);
  580. #endif /* __MMI_SUBLCD__ */ /* end of __MMI_SUBLCD__ */
  581. }   /* end of update_screen */
  584. /*****************************************************************************
  585.  * FUNCTION
  586.  *  win32_ui_set_layer_data
  587.  * DESCRIPTION
  588.  *  set the flag to indicate that a new application starts
  589.  * PARAMETERS
  590.  *  layer_index             [IN]        Index for the layer
  591.  *  lcd_id                  [IN]        Lcd id
  592.  *  text_clip_left          [IN]        Text clipping region info
  593.  *  text_clip_top           [IN]        Text clipping region info
  594.  *  text_clip_right         [IN]        Text clipping region info
  595.  *  text_clip_bottom        [IN]        Text clipping region info
  596.  *  gfx_clip_left           [IN]        Clipping region info
  597.  *  gfx_clip_top            [IN]        Clipping region info
  598.  *  gfx_clip_right          [IN]        Clipping region info
  599.  *  gfx_clip_bottom         [IN]        Clipping region info
  600.  *  current_handle          [IN]        Current lcd handle
  601.  *  active_handle           [IN]        Active lcd handle
  602.  * RETURNS
  603.  *  void
  604.  *****************************************************************************/
  605. void win32_ui_set_layer_data(
  606.         U8 layer_index,
  607.         U8 lcd_id,
  608.         S32 text_clip_left,
  609.         S32 text_clip_top,
  610.         S32 text_clip_right,
  611.         S32 text_clip_bottom,
  612.         S32 gfx_clip_left,
  613.         S32 gfx_clip_top,
  614.         S32 gfx_clip_right,
  615.         S32 gfx_clip_bottom,
  616.         S32 current_handle,
  617.         S32 active_handle)
  618. {
  619.     /*----------------------------------------------------------------*/
  620.     /* Local Variables                                                */
  621.     /*----------------------------------------------------------------*/
  623.     /*----------------------------------------------------------------*/
  624.     /* Code Body                                                      */
  625.     /*----------------------------------------------------------------*/
  626.     if (lcd_id == MAIN_LCD)
  627.     {
  628.         /* UIL := UI Layer */
  629.         uil_ptr = MODIS_UI_layer_ptr[layer_index];
  631.         uil_ptr->text_clip_left = text_clip_left;
  632.         uil_ptr->text_clip_top = text_clip_top;
  633.         uil_ptr->text_clip_right = text_clip_right;
  634.         uil_ptr->text_clip_bottom = text_clip_bottom;
  636.         uil_ptr->gfx_clip_left = gfx_clip_left;
  637.         uil_ptr->gfx_clip_top = gfx_clip_top;
  638.         uil_ptr->gfx_clip_right = gfx_clip_right;
  639.         uil_ptr->gfx_clip_bottom = gfx_clip_bottom;
  641.         if (current_handle == active_handle)
  642.         {
  643.             active_layer = layer_index;
  644.         }
  645.     }
  646. }   /* end of win32_ui_set_layer_data */
  649. /*****************************************************************************
  650.  * FUNCTION
  651.  *  lcd_fb_update
  652.  * DESCRIPTION
  653.  *  void
  654.  * PARAMETERS
  655.  *  lcd_para        [IN]        Lcd_frame_update_struct
  656.  * RETURNS
  657.  *  void
  658.  *****************************************************************************/
  659. void lcd_fb_update(lcd_frame_update_struct *lcd_para)
  660. {
  661.     /*----------------------------------------------------------------*/
  662.     /* Local Variables                                                */
  663.     /*----------------------------------------------------------------*/
  664.     U16 x, y;
  665.     U16 x_layer, y_layer;
  666.     U16 origin_pixel;
  667.     U16 layer_pixel;
  668.     U16 layer_pixel_index;  /* used for LUT */
  669.     U8 *index_ptr;          /* used for LUT, get index value */
  670.     U16 *buffer_ptr;
  671.     U16 *shadow_ptr;
  672.     BOOL source_enable;
  673.     BOOL opacity_enable;
  674.     BOOL LUT_enable;
  675.     U32 r, g, b;
  676.     U8 op_value;            /* opacity value */
  677.     U8 op_value_c;          /* opacity value complement */
  678.     U32 layer_flag_table[4];
  679.     U8 layer_id;
  680.     U8 skip;
  681.     U32 i, j;
  682.     color c;
  683.     U16 y1, y2, x1, x2;
  684.     S32 roi_width;
  685.     S32 roi_height;
  687.     U8 lcd_id;
  688.     U16 start_x;
  689.     U16 start_y;
  690.     U16 end_x;
  691.     U16 end_y;
  692.     U16 roi_offset_x;
  693.     U16 roi_offset_y;
  694.     DWORD update_layer;
  695.     U8 is_first_layer;
  697.     lcd_layer_struct *layer_ptr;    /* use this ptr to make code shorter */
  699.     /*----------------------------------------------------------------*/
  700.     /* Code Body                                                      */
  701.     /*----------------------------------------------------------------*/
  702.     if (IsLcdFirstInit != FALSE)
  703.     {
  704.         /* lcd_screen_init(hWnd, 0); */
  706.         IsLcdFirstInit = FALSE;
  707.     }
  709.     lcd_id = lcd_para->lcd_id;
  710.     start_x = lcd_para->lcm_start_x;
  711.     start_y = lcd_para->lcm_start_y;
  712.     end_x = lcd_para->lcm_end_x;
  713.     end_y = lcd_para->lcm_end_y;
  714.     roi_offset_x = lcd_para->roi_offset_x;
  715.     roi_offset_y = lcd_para->roi_offset_y;
  716.     update_layer = lcd_para->update_layer;
  718.     if (lcd_id == MAIN_LCD)
  719.     {
  720.         shadow_ptr = (U16*) simulator_shadow_buffer;
  721.     }
  722. #ifdef __MMI_SUBLCD__
  723.     else if (lcd_id == SUB_LCD)
  724.     {
  725.         shadow_ptr = (U16*) simulator_sub_shadow_buffer;
  726.     }
  727. #endif /* __MMI_SUBLCD__ */ 
  729.     /* create this table, so we can use for loop to prcess each layer */
  730.     layer_flag_table[0] = LCD_LAYER0_ENABLE;
  731.     layer_flag_table[1] = LCD_LAYER1_ENABLE;
  732.     layer_flag_table[2] = LCD_LAYER2_ENABLE;
  733.     layer_flag_table[3] = LCD_LAYER3_ENABLE;
  735.     roi_width = end_x - start_x;
  736.     roi_height = end_y - start_y;
  737.     /* copy base layer to shadow buffer directly for faster speed */
  738.     /* lcd_layer_data[0].offset_x */
  740.     /* 
  741.      * buffer_ptr = (U16 *)lcd_layer_data[0].frame_buffer_address;
  742.      * memcpy(shadow_ptr, buffer_ptr, LCD_WIDTH * LCD_HEIGHT * 2);
  743.      */
  745.     is_first_layer = 1;
  746.     for (layer_id = 0; layer_id < SIMULATOR_LAYER_COUNT; layer_id++)
  747.     {
  748.         /* set necessary data for MODIS UI displaying */
  749.         /* UIL := UI Layer */
  750.         if (lcd_id == MAIN_LCD)
  751.         {
  752.             uil_ptr = MODIS_UI_layer_ptr[layer_id];
  754.             uil_ptr->layer_x_offset = lcd_layer_data[layer_id].x_offset;
  755.             uil_ptr->layer_y_offset = lcd_layer_data[layer_id].y_offset;
  756.             uil_ptr->layer_width = lcd_layer_data[layer_id].column_number;
  757.             uil_ptr->layer_height = lcd_layer_data[layer_id].row_number;
  759.             uil_ptr->roi_x_offset = roi_offset_x;
  760.             uil_ptr->roi_y_offset = roi_offset_y;
  761.             uil_ptr->roi_width = roi_width;
  762.             uil_ptr->roi_height = roi_height;
  764.             uil_ptr->source_key_enable = lcd_layer_data[layer_id].source_key_enable;
  765.             uil_ptr->opacity_enable = lcd_layer_data[layer_id].opacity_enable;
  766.             uil_ptr->source_key = lcd_layer_data[layer_id].source_key;
  767.             uil_ptr->opacity_value = lcd_layer_data[layer_id].opacity_value;
  769.             uil_ptr->layer_enable = (update_layer & layer_flag_table[layer_id]);
  770.             uil_ptr->frame_buffer_address = lcd_layer_data[layer_id].frame_buffer_address;
  772.             uil_ptr->active_layer = active_layer;
  773.         }
  775.         /* check if this layer need to merge or not */
  776.         if ((update_layer & layer_flag_table[layer_id]) != 0)
  777.         {
  779.             buffer_ptr = (U16*) lcd_layer_data[layer_id].frame_buffer_address;
  780.             index_ptr = (U8*) lcd_layer_data[layer_id].frame_buffer_address;
  781.             layer_ptr = &lcd_layer_data[layer_id];
  782.             source_enable = layer_ptr->source_key_enable;
  783.             opacity_enable = layer_ptr->opacity_enable;
  784.             LUT_enable = layer_ptr->color_palette_enable;
  786.             /* for each pixel within region */
  787.             for (y = roi_offset_y; y <= roi_offset_y + roi_height; y++)
  788.             {
  789.                 for (x = roi_offset_x; x <= roi_offset_x + roi_width; x++)
  790.                 {
  791.                     skip = FALSE;
  792.                /***********************************************************/
  793.                     /* test if within region */
  794.                     if ((x >= layer_ptr->x_offset) &&
  795.                         (y >= layer_ptr->y_offset) &&
  796.                         (x <= layer_ptr->x_offset + layer_ptr->column_number - 1) &&
  797.                         (y <= layer_ptr->y_offset + layer_ptr->row_number - 1))
  798.                     {
  800.                         /* transform to layer's local coordinate */
  801.                         x_layer = x - layer_ptr->x_offset;
  802.                         y_layer = y - layer_ptr->y_offset;
  804.                         /* GDI_ASSERT(x - layer_ptr->x_offset>=0); */
  806.                         /* get original's pixel color */
  807.                         if (is_first_layer)
  808.                         {
  809.                         #ifdef GDI_USING_LAYER_BACKGROUND
  810.                             if (lcd_para->roi_background_color == 0)
  811.                             {
  812.                                 origin_pixel = 0;
  813.                             }
  814.                             else
  815.                             {
  816.                                 origin_pixel = 0xffff;
  817.                             }
  818.                         #else /* GDI_USING_LAYER_BACKGROUND */ 
  819.                             origin_pixel = 0xffff;
  820.                         #endif /* GDI_USING_LAYER_BACKGROUND */ 
  821.                         }
  822.                         else
  823.                         {
  824.                             if (lcd_id == MAIN_LCD)
  825.                             {
  826.                                 origin_pixel = BUF_PIXEL_DATA(
  827.                                                 shadow_ptr,
  828.                                                 x - roi_offset_x + start_x,
  829.                                                 y - roi_offset_y + start_y,
  830.                                                 LCD_WIDTH);
  831.                             }
  832.                         #ifdef __MMI_SUBLCD__
  833.                             else
  834.                             {
  835.                                 origin_pixel = BUF_PIXEL_DATA(
  836.                                                 shadow_ptr,
  837.                                                 x - roi_offset_x + start_x,
  838.                                                 y - roi_offset_y + start_y,
  839.                                                 SUBLCD_WIDTH);
  840.                             }
  841.                         #endif /* __MMI_SUBLCD__ */ 
  842.                         }
  843.                         /* get layer's pixel color, check if it use LUT */
  844.                         if (layer_ptr->color_palette_enable == KAL_TRUE)
  845.                         {
  846.                             /* get index, (U8) */
  847.                             layer_pixel_index = BUF_PIXEL_DATA(index_ptr, x_layer, y_layer, layer_ptr->column_number);
  849.                             /* ingore this error currently. just set index = 0 */
  850.                             if ((layer_pixel_index < 0) || (layer_pixel_index > 255))
  851.                             {
  852.                                 layer_pixel_index = 0;
  853.                             }
  855.                             /* this might contain error. but ignore. palette must be 0 or 1 */
  856.                             if (layer_ptr->color_palette_select == 0)
  857.                             {
  858.                                 layer_pixel = layer_sim_LUT0[layer_pixel_index];
  859.                             }
  860.                             else
  861.                             {
  862.                                 layer_pixel = layer_sim_LUT1[layer_pixel_index];
  863.                             }
  864.                         }
  865.                         else
  866.                         {
  867.                             U8 *b1 = GDI_LAYER.act_buf_ptr;
  868.                             S32 b2 = GDI_LAYER.act_pitch;
  870.                             GDI_LAYER.act_buf_ptr = (U8*) layer_ptr->frame_buffer_address;
  871.                             GDI_LAYER.act_pitch = layer_ptr->column_number;
  873.                             if (lcd_id == MAIN_LCD)
  874.                             {
  875.                                 DRV_MAINLCD_GET_BUFFER_PIXEL(x_layer, y_layer, layer_pixel);
  876.                             }
  877.                         #ifdef __MMI_SUBLCD__
  878.                             else
  879.                             {
  880.                                 DRV_SUBLCD_GET_BUFFER_PIXEL(x_layer, y_layer, layer_pixel);
  881.                             }
  882.                         #endif /* __MMI_SUBLCD__ */ 
  883.                             GDI_LAYER.act_buf_ptr = b1;
  884.                             GDI_LAYER.act_pitch = b2;
  885.                         }
  887.                         /* source key check - tansparency */
  888.                         if (source_enable == KAL_TRUE)
  889.                         {
  890.                             if (layer_ptr->source_key == layer_pixel)
  891.                             {
  892.                                 skip = KAL_TRUE;
  893.                             }
  894.                         }
  896.                         /* opacity check */
  897.                         if (skip == FALSE)
  898.                         {
  899.                             if (opacity_enable == KAL_TRUE)
  900.                             {
  901.                                 /* calc opacity ratio */
  902.                             #ifdef LCD_MAX_OPACITY
  903.                                 op_value = layer_ptr->opacity_value * 255 / LCD_MAX_OPACITY;
  904.                             #else 
  905.                                 op_value = layer_ptr->opacity_value << 3;
  906.                             #endif 
  907.                                 op_value_c = ~op_value;
  909.                                 if (op_value != 0)
  910.                                 {
  911.                                     if (lcd_id == MAIN_LCD)
  912.                                     {
  913.                                         r = HW_TO_RGB_R(origin_pixel) * op_value_c +
  914.                                             DRV_HW_TO_RGB_R(layer_pixel) * op_value;
  915.                                         g = HW_TO_RGB_G(origin_pixel) * op_value_c +
  916.                                             DRV_HW_TO_RGB_G(layer_pixel) * op_value;
  917.                                         b = HW_TO_RGB_B(origin_pixel) * op_value_c +
  918.                                             DRV_HW_TO_RGB_B(layer_pixel) * op_value;
  919.                                     }
  920.                                 #ifdef __MMI_SUBLCD__
  921.                                     else
  922.                                     {
  923.                                         r = HW_TO_RGB_R(origin_pixel) * op_value_c +
  924.                                             HW_FORMAT_TO_SUBMMI_R(layer_pixel) * op_value;
  925.                                         g = HW_TO_RGB_G(origin_pixel) * op_value_c +
  926.                                             HW_FORMAT_TO_SUBMMI_G(layer_pixel) * op_value;
  927.                                         b = HW_TO_RGB_B(origin_pixel) * op_value_c +
  928.                                             HW_FORMAT_TO_SUBMMI_B(layer_pixel) * op_value;
  929.                                     }
  930.                                 #endif /* __MMI_SUBLCD__ */ 
  931.                                     r >>= 8;
  932.                                     g >>= 8;
  933.                                     b >>= 8;
  934.                                     origin_pixel = (U16) RGB_TO_HW(r, g, b);
  935.                                 }
  936.                             }
  937.                             else
  938.                             {
  939.                                 if (lcd_id == MAIN_LCD)
  940.                                 {
  941.                                     r = DRV_HW_TO_RGB_R(layer_pixel);
  942.                                     g = DRV_HW_TO_RGB_G(layer_pixel);
  943.                                     b = DRV_HW_TO_RGB_B(layer_pixel);
  944.                                 }
  945.                             #ifdef __MMI_SUBLCD__
  946.                                 else
  947.                                 {
  948.                                     r = HW_FORMAT_TO_SUBMMI_R(layer_pixel);
  949.                                     g = HW_FORMAT_TO_SUBMMI_G(layer_pixel);
  950.                                     b = HW_FORMAT_TO_SUBMMI_B(layer_pixel);
  951.                                 }
  952.                             #endif /* __MMI_SUBLCD__ */ 
  953.                                 origin_pixel = (U16) RGB_TO_HW(r, g, b);
  954.                             }
  955.                         }
  957.                         /* write back to shadow buffer */
  958.                         if (lcd_id == MAIN_LCD)
  959.                         {
  960.                             BUF_PIXEL_DATA(shadow_ptr, x - roi_offset_x + start_x, y - roi_offset_y + start_y, LCD_WIDTH) = origin_pixel;       /* 040105 JF modified */
  961.                         }
  962.                     #ifdef __MMI_SUBLCD__
  963.                         else
  964.                         {
  965.                             BUF_PIXEL_DATA(shadow_ptr, x - roi_offset_x + start_x, y - roi_offset_y + start_y, SUBLCD_WIDTH) = origin_pixel;    /* 040105 JF modified */
  966.                         }
  967.                     #endif /* __MMI_SUBLCD__ */ 
  968.                   /***********************************************************/
  970.                     }   /* if within region */
  971.                 }       /* for loop  x */
  972.             }           /* for loop - y */
  973.             is_first_layer = 0;
  974.         }               /* if flag */
  975.     }                   /* for each layer */
  977.     /* send the main-lcd information to MODIS_UI for displaying */
  978.     if (lcd_id == MAIN_LCD)
  979.     {
  980.         set_MODIS_UI_layer_data(
  981.             MODIS_UI_layer_ptr,
  982.             LCD_WIDTH,
  983.             LCD_HEIGHT,
  984.             SIMULATOR_LAYER_COUNT,
  985.             &new_application_flag);
  986.     }
  988.     /* draw to dc */
  989.     if (lcd_id == MAIN_LCD)
  990.     {
  991.         /* draw to simulator's main LCD region */
  992.         hdc = GetDC(hWnd);
  993.         hdcMem = CreateCompatibleDC(hdc);
  994.         hbmp = CreateCompatibleBitmap(hdc, LCD_WIDTH, LCD_HEIGHT);
  995.         SelectObject(hdcMem, hbmp);
  997.         y1 = 0;
  998.         y2 = LCD_WIDTH - 1;
  999.         x1 = 0;
  1000.         x2 = LCD_HEIGHT - 1;
  1002.         for (i = 0; i < LCD_HEIGHT; i++)
  1003.         {
  1004.             for (j = 0; j < LCD_WIDTH; j++)
  1005.             {
  1006.                 c.r = HW_TO_RGB_R(simulator_shadow_buffer[i * LCD_WIDTH + j]);
  1007.                 c.g = HW_TO_RGB_G(simulator_shadow_buffer[i * LCD_WIDTH + j]);
  1008.                 c.b = HW_TO_RGB_B(simulator_shadow_buffer[i * LCD_WIDTH + j]);
  1009.                 c.alpha = 100;
  1011.                 /* SetPixel(hdcMem, j, i ,RGB(c.r, c.g, c.b)); */
  1012.                 BUF_PIXEL_DATA(simulator_frame_buffer, j, LCD_HEIGHT - 1 - i, LCD_WIDTH) = RGB(c.b, c.g, c.r);
  1013.             }
  1014.         }
  1016.         SetDIBits(NULL, hbmp, 0, LCD_HEIGHT, simulator_frame_buffer, &bitmap_info, DIB_RGB_COLORS);
  1017.         BitBlt(
  1018.             hdc,
  1019.             SIMULATOR_SKIN_LCD_X,
  1020.             SIMULATOR_SKIN_LCD_Y,
  1021.             SIMULATOR_SKIN_LCD_X + LCD_WIDTH,
  1022.             SIMULATOR_SKIN_LCD_Y + LCD_HEIGHT,
  1023.             hdcMem,
  1024.             0,
  1025.             0,
  1026.             SRCCOPY);
  1028.         ReleaseDC(hWnd, hdc);
  1029.         DeleteDC(hdcMem);
  1030.         DeleteObject(hbmp);
  1031.     }
  1032. #ifdef __MMI_SUBLCD__
  1033.     else if (lcd_id == SUB_LCD)
  1034.     {
  1035.         /* draw to simulator's sub LCD region */
  1036.         hdc = GetDC(hWnd);
  1037.         sub_hdcMem = CreateCompatibleDC(hdc);
  1038.         sub_hbmp = CreateCompatibleBitmap(hdc, SUBLCD_WIDTH, SUBLCD_HEIGHT);
  1039.         SelectObject(sub_hdcMem, sub_hbmp);
  1041.         y1 = 0;
  1042.         y2 = SUBLCD_WIDTH - 1;
  1043.         x1 = 0;
  1044.         x2 = SUBLCD_HEIGHT - 1;
  1046.         for (i = 0; i < SUBLCD_HEIGHT; i++)
  1047.         {
  1048.             for (j = 0; j < SUBLCD_WIDTH; j++)
  1049.             {
  1050.                 c.r = HW_TO_RGB_R(simulator_sub_shadow_buffer[i * SUBLCD_WIDTH + j]);
  1051.                 c.g = HW_TO_RGB_G(simulator_sub_shadow_buffer[i * SUBLCD_WIDTH + j]);
  1052.                 c.b = HW_TO_RGB_B(simulator_sub_shadow_buffer[i * SUBLCD_WIDTH + j]);
  1053.                 c.alpha = 100;
  1055.                 /* SetPixel(sub_hdcMem, j, i ,RGB(c.r, c.g, c.b)); */
  1056.                 BUF_PIXEL_DATA(sub_simulator_frame_buffer, j, SUBLCD_HEIGHT - 1 - i, SUBLCD_WIDTH) = RGB(c.b, c.g, c.r);
  1057.             }
  1058.         }
  1060.         SetDIBits(NULL, sub_hbmp, 0, SUBLCD_HEIGHT, sub_simulator_frame_buffer, &sub_bitmap_info, DIB_RGB_COLORS);
  1061.         BitBlt(
  1062.             hdc,
  1063.             SIMULATOR_SKIN_SUB_LCD_X,
  1064.             SIMULATOR_SKIN_SUB_LCD_Y,
  1065.             SIMULATOR_SKIN_SUB_LCD_X + SUBLCD_WIDTH,
  1066.             SIMULATOR_SKIN_SUB_LCD_Y + SUBLCD_HEIGHT,
  1067.             sub_hdcMem,
  1068.             0,
  1069.             0,
  1070.             SRCCOPY);
  1072.         ReleaseDC(hWnd, hdc);
  1073.         DeleteDC(sub_hdcMem);
  1074.         DeleteObject(sub_hbmp);
  1075.     }
  1076. #endif /* __MMI_SUBLCD__ */ 
  1077. }   /* end of lcd_fb_update */
  1080. /*****************************************************************************
  1081.  * FUNCTION
  1082.  *  config_lcd_roi_window
  1083.  * DESCRIPTION
  1084.  *  void
  1085.  * PARAMETERS
  1086.  *  roi_x_offset        [IN]        U16
  1087.  *  roi_y_offset        [IN]        Kal_uint16
  1088.  *  roi_column          [IN]        Kal_uint16
  1089.  *  roi_row             [IN]        Kal_uint16
  1090.  * RETURNS
  1091.  * TRUE
  1092.  *****************************************************************************/
  1093. kal_bool config_lcd_roi_window(U16 roi_x_offset, kal_uint16 roi_y_offset, kal_uint16 roi_column, kal_uint16 roi_row)
  1094. {
  1095.     /*----------------------------------------------------------------*/
  1096.     /* Local Variables                                                */
  1097.     /*----------------------------------------------------------------*/
  1099.     /*----------------------------------------------------------------*/
  1100.     /* Code Body                                                      */
  1101.     /*----------------------------------------------------------------*/
  1102.     return KAL_TRUE;
  1104. }   /* end of config_lcd_roi_window */
  1107. /*****************************************************************************
  1108.  * FUNCTION
  1109.  *  lcd_init
  1110.  * DESCRIPTION
  1111.  *  void
  1112.  * PARAMETERS
  1113.  *  lcd_id                  [IN]        Kal_uint8
  1114.  *  background_color        [IN]        Kal_uint16
  1115.  * RETURNS
  1116.  *  void
  1117.  *****************************************************************************/
  1118. void lcd_init(kal_uint8 lcd_id, kal_uint16 background_color)
  1119. {
  1120.     /*----------------------------------------------------------------*/
  1121.     /* Local Variables                                                */
  1122.     /*----------------------------------------------------------------*/
  1124.     /*----------------------------------------------------------------*/
  1125.     /* Code Body                                                      */
  1126.     /*----------------------------------------------------------------*/
  1127. }   /* end of lcd_init */
  1130. /*****************************************************************************
  1131.  * FUNCTION
  1132.  *  lcd_sleep_in
  1133.  * DESCRIPTION
  1134.  *  void
  1135.  * PARAMETERS
  1136.  *  lcd_id      [IN]        Kal_uint8
  1137.  * RETURNS
  1138.  *  void
  1139.  *****************************************************************************/
  1140. void lcd_sleep_in(kal_uint8 lcd_id)
  1141. {
  1142.     /*----------------------------------------------------------------*/
  1143.     /* Local Variables                                                */
  1144.     /*----------------------------------------------------------------*/
  1146.     /*----------------------------------------------------------------*/
  1147.     /* Code Body                                                      */
  1148.     /*----------------------------------------------------------------*/
  1149. }   /* end of lcd_sleep_in */
  1152. /*****************************************************************************
  1153.  * FUNCTION
  1154.  *  lcd_sleep_out
  1155.  * DESCRIPTION
  1156.  *  void
  1157.  * PARAMETERS
  1158.  *  lcd_id      [IN]        Kal_uint8
  1159.  * RETURNS
  1160.  *  void
  1161.  *****************************************************************************/
  1162. void lcd_sleep_out(kal_uint8 lcd_id)
  1163. {
  1164.     /*----------------------------------------------------------------*/
  1165.     /* Local Variables                                                */
  1166.     /*----------------------------------------------------------------*/
  1168.     /*----------------------------------------------------------------*/
  1169.     /* Code Body                                                      */
  1170.     /*----------------------------------------------------------------*/
  1171. }   /* end of lcd_sleep_out */
  1174. /*****************************************************************************
  1175.  * FUNCTION
  1176.  *  lcd_partial_on
  1177.  * DESCRIPTION
  1178.  *  void
  1179.  * PARAMETERS
  1180.  *  lcd_id          [IN]        Kal_uint8
  1181.  *  start_line      [IN]        Kal_uint16
  1182.  *  end_line        [IN]        Kal_uint16
  1183.  * RETURNS
  1184.  *  void
  1185.  *****************************************************************************/
  1186. void lcd_partial_on(kal_uint8 lcd_id, kal_uint16 start_line, kal_uint16 end_line)
  1187. {
  1188.     /*----------------------------------------------------------------*/
  1189.     /* Local Variables                                                */
  1190.     /*----------------------------------------------------------------*/
  1192.     /*----------------------------------------------------------------*/
  1193.     /* Code Body                                                      */
  1194.     /*----------------------------------------------------------------*/
  1195. }   /* end of lcd_partial_on */
  1198. /*****************************************************************************
  1199.  * FUNCTION
  1200.  *  lcd_partial_off
  1201.  * DESCRIPTION
  1202.  *  void
  1203.  * PARAMETERS
  1204.  *  lcd_id      [IN]        Kal_uint8
  1205.  * RETURNS
  1206.  *  void
  1207.  *****************************************************************************/
  1208. void lcd_partial_off(kal_uint8 lcd_id)
  1209. {
  1210.     /*----------------------------------------------------------------*/
  1211.     /* Local Variables                                                */
  1212.     /*----------------------------------------------------------------*/
  1214.     /*----------------------------------------------------------------*/
  1215.     /* Code Body                                                      */
  1216.     /*----------------------------------------------------------------*/
  1217. }   /* end of lcd_partial_off */
  1220. /*****************************************************************************
  1221.  * FUNCTION
  1222.  *  lcd_bright_level
  1223.  * DESCRIPTION
  1224.  *  void
  1225.  * PARAMETERS
  1226.  *  lcd_id              [IN]        Kal_uint8
  1227.  *  bright_level        [IN]        Kal_uint8
  1228.  * RETURNS
  1229.  *  void
  1230.  *****************************************************************************/
  1231. void lcd_bright_level(kal_uint8 lcd_id, kal_uint8 bright_level)
  1232. {
  1233.     /*----------------------------------------------------------------*/
  1234.     /* Local Variables                                                */
  1235.     /*----------------------------------------------------------------*/
  1237.     /*----------------------------------------------------------------*/
  1238.     /* Code Body                                                      */
  1239.     /*----------------------------------------------------------------*/
  1240. }   /* end of lcd_bright_level */
  1243. /*****************************************************************************
  1244.  * FUNCTION
  1245.  *  lcd_power_on
  1246.  * DESCRIPTION
  1247.  *  void
  1248.  * PARAMETERS
  1249.  *  lcd_id      [IN]        Kal_uint8
  1250.  *  on          [IN]        Kal_bool
  1251.  * RETURNS
  1252.  *  void
  1253.  *****************************************************************************/
  1254. void lcd_power_on(kal_uint8 lcd_id, kal_bool on)
  1255. {
  1256.     /*----------------------------------------------------------------*/
  1257.     /* Local Variables                                                */
  1258.     /*----------------------------------------------------------------*/
  1260.     /*----------------------------------------------------------------*/
  1261.     /* Code Body                                                      */
  1262.     /*----------------------------------------------------------------*/
  1263. }   /* end of lcd_power_on */
  1266. /*****************************************************************************
  1267.  * FUNCTION
  1268.  *  lcd_screen_on
  1269.  * DESCRIPTION
  1270.  *  void
  1271.  * PARAMETERS
  1272.  *  lcd_id      [IN]        Kal_uint8
  1273.  *  on          [IN]        Kal_bool
  1274.  * RETURNS
  1275.  *  void
  1276.  *****************************************************************************/
  1277. void lcd_screen_on(kal_uint8 lcd_id, kal_bool on)
  1278. {
  1279.     /*----------------------------------------------------------------*/
  1280.     /* Local Variables                                                */
  1281.     /*----------------------------------------------------------------*/
  1283.     /*----------------------------------------------------------------*/
  1284.     /* Code Body                                                      */
  1285.     /*----------------------------------------------------------------*/
  1286. }   /* end of lcd_screen_on */
  1289. /*****************************************************************************
  1290.  * FUNCTION
  1291.  *  lcd_get_parameter
  1292.  * DESCRIPTION
  1293.  *  void
  1294.  * PARAMETERS
  1295.  *  lcd_id      [IN]        Kal_uint8
  1296.  *  type        [IN]        Lcd_func_type
  1297.  * RETURNS
  1298.  *  0
  1299.  *****************************************************************************/
  1300. kal_uint8 lcd_get_parameter(kal_uint8 lcd_id, lcd_func_type type)
  1301. {
  1302.     /*----------------------------------------------------------------*/
  1303.     /* Local Variables                                                */
  1304.     /*----------------------------------------------------------------*/
  1306.     /*----------------------------------------------------------------*/
  1307.     /* Code Body                                                      */
  1308.     /*----------------------------------------------------------------*/
  1309.     return 0;
  1310. }   /* end of lcd_get_parameter */
  1313. /*****************************************************************************
  1314.  * FUNCTION
  1315.  *  lcd_get_size
  1316.  * DESCRIPTION
  1317.  *  void
  1318.  * PARAMETERS
  1319.  *  lcd_id          [IN]        Kal_uint8
  1320.  *  lcd_width       [IN]        Kal_uint16 *
  1321.  *  lcd_height      [IN]        Kal_uint16 *
  1322.  * RETURNS
  1323.  *  void
  1324.  *****************************************************************************/
  1325. void lcd_get_size(kal_uint8 lcd_id, kal_uint16 *lcd_width, kal_uint16 *lcd_height)
  1326. {
  1327.     /*----------------------------------------------------------------*/
  1328.     /* Local Variables                                                */
  1329.     /*----------------------------------------------------------------*/
  1331.     /*----------------------------------------------------------------*/
  1332.     /* Code Body                                                      */
  1333.     /*----------------------------------------------------------------*/
  1334. }   /* end of lcd_get_size */
  1337. /*****************************************************************************
  1338.  * FUNCTION
  1339.  *  lcd_set_bias
  1340.  * DESCRIPTION
  1341.  *  void
  1342.  * PARAMETERS
  1343.  *  lcd_id      [IN]        Kal_uint8
  1344.  *  bias        [IN]        Kal_uint8 *
  1345.  * RETURNS
  1346.  *  void
  1347.  *****************************************************************************/
  1348. void lcd_set_bias(kal_uint8 lcd_id, kal_uint8 *bias)
  1349. {
  1350.     /*----------------------------------------------------------------*/
  1351.     /* Local Variables                                                */
  1352.     /*----------------------------------------------------------------*/
  1354.     /*----------------------------------------------------------------*/
  1355.     /* Code Body                                                      */
  1356.     /*----------------------------------------------------------------*/
  1357. }   /* end of lcd_set_bias */
  1360. /*****************************************************************************
  1361.  * FUNCTION
  1362.  *  lcd_set_contrast
  1363.  * DESCRIPTION
  1364.  *  void
  1365.  * PARAMETERS
  1366.  *  lcd_id          [IN]        Kal_uint8
  1367.  *  contrast        [IN]        Kal_uint8 *
  1368.  * RETURNS
  1369.  *  void
  1370.  *****************************************************************************/
  1371. void lcd_set_contrast(kal_uint8 lcd_id, kal_uint8 *contrast)
  1372. {
  1373.     /*----------------------------------------------------------------*/
  1374.     /* Local Variables                                                */
  1375.     /*----------------------------------------------------------------*/
  1377.     /*----------------------------------------------------------------*/
  1378.     /* Code Body                                                      */
  1379.     /*----------------------------------------------------------------*/
  1380. }   /* end of lcd_set_contrast */
  1383. /*****************************************************************************
  1384.  * FUNCTION
  1385.  *  lcd_set_linerate
  1386.  * DESCRIPTION
  1387.  *  void
  1388.  * PARAMETERS
  1389.  *  lcd_id          [IN]        Kal_uint8
  1390.  *  linereate       [IN]        Kal_uint8 *
  1391.  * RETURNS
  1392.  *  void
  1393.  *****************************************************************************/
  1394. void lcd_set_linerate(kal_uint8 lcd_id, kal_uint8 *linereate)
  1395. {
  1396.     /*----------------------------------------------------------------*/
  1397.     /* Local Variables                                                */
  1398.     /*----------------------------------------------------------------*/
  1400.     /*----------------------------------------------------------------*/
  1401.     /* Code Body                                                      */
  1402.     /*----------------------------------------------------------------*/
  1403. }   /* end of lcd_set_linerate */
  1406. /*****************************************************************************
  1407.  * FUNCTION
  1408.  *  lcd_set_temp_compensate
  1409.  * DESCRIPTION
  1410.  *  void
  1411.  * PARAMETERS
  1412.  *  lcd_id          [IN]        Kal_uint8
  1413.  *  compensate      [IN]        Kal_uint8 *
  1414.  * RETURNS
  1415.  *  void
  1416.  *****************************************************************************/
  1417. void lcd_set_temp_compensate(kal_uint8 lcd_id, kal_uint8 *compensate)
  1418. {
  1419.     /*----------------------------------------------------------------*/
  1420.     /* Local Variables                                                */
  1421.     /*----------------------------------------------------------------*/
  1423.     /*----------------------------------------------------------------*/
  1424.     /* Code Body                                                      */
  1425.     /*----------------------------------------------------------------*/
  1426. }   /* end of lcd_set_temp_compensate */
  1429. /*****************************************************************************
  1430.  * FUNCTION
  1431.  *  lcd_cmd_update
  1432.  * DESCRIPTION
  1433.  *  void
  1434.  * PARAMETERS
  1435.  *  lcd_id              [IN]        Kal_uint8
  1436.  *  start_x             [IN]        Kal_uint16
  1437.  *  start_y             [IN]        Kal_uint16
  1438.  *  end_x               [IN]        Kal_uint16
  1439.  *  end_y               [IN]        Kal_uint16
  1440.  *  roi_offset_x        [IN]        Kal_uint16
  1441.  *  roi_offset_y        [IN]        Kal_uint16
  1442.  *  update_layer        [IN]        Kal_uint32
  1443.  * RETURNS
  1444.  *  void
  1445.  *****************************************************************************/
  1446. void lcd_cmd_update(
  1447.         kal_uint8 lcd_id,
  1448.         kal_uint16 start_x,
  1449.         kal_uint16 start_y,
  1450.         kal_uint16 end_x,
  1451.         kal_uint16 end_y,
  1452.         kal_uint16 roi_offset_x,
  1453.         kal_uint16 roi_offset_y,
  1454.         kal_uint32 update_layer)
  1455. {
  1456.     /*----------------------------------------------------------------*/
  1457.     /* Local Variables                                                */
  1458.     /*----------------------------------------------------------------*/
  1460.     /*----------------------------------------------------------------*/
  1461.     /* Code Body                                                      */
  1462.     /*----------------------------------------------------------------*/
  1463. }   /* end of lcd_cmd_update */
  1466. /*****************************************************************************
  1467.  * FUNCTION
  1468.  *  win32_ui_set_new_application_flag
  1469.  * DESCRIPTION
  1470.  *  set the flag to indicate that a new application starts
  1471.  * PARAMETERS
  1472.  *  void
  1473.  * RETURNS
  1474.  *  void
  1475.  *****************************************************************************/
  1476. void win32_ui_set_new_application_flag()
  1477. {
  1478.     /*----------------------------------------------------------------*/
  1479.     /* Local Variables                                                */
  1480.     /*----------------------------------------------------------------*/
  1482.     /*----------------------------------------------------------------*/
  1483.     /* Code Body                                                      */
  1484.     /*----------------------------------------------------------------*/
  1485.     new_application_flag = 1;
  1486. }   /* end of win32_ui_set_new_application_flag */
  1489. /*****************************************************************************
  1490.  * FUNCTION
  1491.  *  set_lcd_color_palette
  1492.  * DESCRIPTION
  1493.  *  
  1494.  * PARAMETERS
  1495.  *  color_palette_select        [IN]        
  1496.  *  color_palette_addr_ptr      [?]         
  1497.  *  start_index                 [IN]        
  1498.  *  number_of_color             [IN]        
  1499.  * RETURNS
  1500.  *  void
  1501.  *****************************************************************************/
  1502. void set_lcd_color_palette(
  1503.         kal_uint8 color_palette_select,
  1504.         kal_uint32 *color_palette_addr_ptr,
  1505.         kal_uint8 start_index,
  1506.         kal_uint8 number_of_color)
  1507. {
  1508.     /*----------------------------------------------------------------*/
  1509.     /* Local Variables                                                */
  1510.     /*----------------------------------------------------------------*/
  1512.     /*----------------------------------------------------------------*/
  1513.     /* Code Body                                                      */
  1514.     /*----------------------------------------------------------------*/
  1515. }
  1518. /*****************************************************************************
  1519.  * FUNCTION
  1520.  *  config_lcd_output
  1521.  * DESCRIPTION
  1522.  *  
  1523.  * PARAMETERS
  1524.  *  lcd_output      [IN]        
  1525.  * RETURNS
  1526.  *  void
  1527.  *****************************************************************************/
  1528. void config_lcd_output(kal_bool lcd_output)
  1529. {
  1530.     /*----------------------------------------------------------------*/
  1531.     /* Local Variables                                                */
  1532.     /*----------------------------------------------------------------*/
  1534.     /*----------------------------------------------------------------*/
  1535.     /* Code Body                                                      */
  1536.     /*----------------------------------------------------------------*/
  1537. }
  1539. #endif /* _MAINLCD_C */