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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
LCD159A.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：34k
源码类别：

uCOS

开发平台：

C/C++

LCD159A.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/GUI
  4. *                        Universal graphic software for embedded applications
  5. *
  6. *                       (c) Copyright 2002, Micrium Inc., Weston, FL
  7. *                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
  8. *
  9. *              礐/GUI is protected by international copyright laws. Knowledge of the
  10. *              source code may not be used to write a similar product. This file may
  11. *              only be used in accordance with a license and should not be redistributed
  12. *              in any way. We appreciate your understanding and fairness.
  13. *
  14. ----------------------------------------------------------------------
  15. File        : LCD159A.C
  16. Purpose     : Driver for LCDs using a Seiko Epson SED159A controller
  17. ----------------------------------------------------------------------   
  18. Version-Date---Author-Explanation                                        
  19. ----------------------------------------------------------------------   
  20. 1.00b   020204 JE     a) Hardwareinterface routines renamed:
  21.                          ...DATA -> ...A1, ...CMD -> ...A0
  22. 1.00a   010926 JE     a) Support for LCD_SWAPXY added
  23. 1.00.00 010710 JE     a) Speed optimizations added
  24. 0.90.00 010709 JE     a) First release
  25. ---------------------------LIST OF CONFIG SWITCHES--------------------
  26. The following is a list of additional configuration switches for this
  27. driver. These switches might not be listed in the manual, because
  28. the manual mainly covers the general config switches which are
  29. supported by all drivers.
  30. ----------------------------------------------------------------------
  31. define ----------------------Explanation------------------------------
  32. LCD_OPTIMIZE                 Controls the use of optimized routines.
  33.                              If 1, several (speed) optimizations are used.
  34.                              Default: ON (1)
  35. ----------------------------------------------------------------------
  36. Known problems or limitations with current version
  37. ----------------------------------------------------------------------
  38. a) Cache not supported yet, becuse RAM requirement would be 
  39.    to large. LCD_CACHE must be set to 0
  40. ----------------------------------------------------------------------
  41. Open issues
  42. ----------------------------------------------------------------------
  43. none
  44. ---------------------------END-OF-HEADER------------------------------
  45. */
  47. #include <string.h>             /* for memset */
  48. #include <stddef.h>           /* needed for definition of NULL */
  49. #include "LCD_Private.h"      /* private modul definitions & config */
  50. #include "GUI_Private.h"
  51. #include "GUIDebug.h"
  52. #include "LCD_0.h"            /* Defines for first display */
  54. #if      (LCD_CONTROLLER == 0x159A) 
  55.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  58. /*
  59.         *********************************************************
  60.         *
  61.         *           Defaults for config switches
  62.         *
  63.         *********************************************************
  65. */
  67. #ifndef LCD_OPTIMIZE
  68.   #define LCD_OPTIMIZE                (1)
  69. #endif
  71. #ifndef LCD_CACHE
  72.   #define  LCD_CACHE                  (0)
  73. #endif
  75. /*
  76.         *********************************************************
  77.         *
  78.         *           Defines for simulation
  79.         *
  80.         *********************************************************
  81. */
  83. #ifdef WIN32
  84.   #undef LCD_WRITE_A0
  85.   #undef LCD_WRITE_A1
  86.   #undef LCD_READ_A0
  87.   #undef LCD_READ_A1
  88.   void SIM_WriteA1C0(U8 Byte);
  89.   void SIM_WriteA0C0(U8 Byte);
  90.   U8   SIM_ReadA1C0(void);
  91.   U8   SIM_ReadA0C0(void);
  92.   #define LCD_WRITE_A1(Byte) SIM_WriteA1C0(Byte) 
  93.   #define LCD_WRITE_A0(Byte) SIM_WriteA0C0(Byte)
  94.   #define LCD_READ_A1(Byte)  Byte = SIM_ReadA1C0()
  95.   #define LCD_READ_A0(Byte)  Byte = SIM_ReadA0C0()
  96. #endif
  98. /*
  99.         *********************************************************
  100.         *
  101.         *          Remap ...A0, ...A1 -> ...CMD, ...DATA
  102.         *
  103.         *********************************************************
  104. */
  106. #define LCD_READCMD0    LCD_READ_A0
  107. #define LCD_READDATA0   LCD_READ_A1
  108. #define LCD_WRITECMD0   LCD_WRITE_A0
  109. #define LCD_WRITEDATA0  LCD_WRITE_A1
  111. /*
  112.         *********************************************************
  113.         *
  114.         *           Macro calculations
  115.         *
  116.         *********************************************************
  117. */
  119. /*
  120.         *********************************************************
  121.         *
  122.         *           Configuration switch checking
  123.         *
  124.         *********************************************************
  125. */
  127. #if (LCD_BITSPERPIXEL != 8)
  128.   #error This controller can handle only 8bpp displays
  129. #endif
  131. /*
  132.         *********************************************************
  133.         *
  134.         *           Macros, standard
  135.         *
  136.         *********************************************************
  138. These macros can be found in any LCD-driver as they serve purposes
  139. that can be found in any class of LCD-driver (Like clipping).
  141. */
  143. #if (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  144.   #define LOG2PHYS(x, y) x, y
  145. #elif (!LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  146.   #define LOG2PHYS(x, y) x, LCD_YSIZE_PHYS - 1 - (y)
  147. #elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  148.   #define LOG2PHYS(x, y) LCD_XSIZE_PHYS - 1 - (x), y
  149. #elif (!LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  150.   #define LOG2PHYS(x, y) LCD_XSIZE_PHYS - 1 - (x), LCD_YSIZE_PHYS - 1 - (y)
  151. #elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  152.   #define LOG2PHYS(x, y) y, x
  153. #elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (!LCD_MIRROR_Y)
  154.   #define LOG2PHYS(x, y) y, LCD_XSIZE - 1 - (x)
  155. #elif (LCD_SWAP_XY) && (!LCD_MIRROR_X) && (LCD_MIRROR_Y)
  156.   #define LOG2PHYS(x, y) LCD_YSIZE - 1 - (y), x
  157. #elif (LCD_SWAP_XY) && (LCD_MIRROR_X) && (LCD_MIRROR_Y)
  158.   #define LOG2PHYS(x, y) LCD_YSIZE - 1 - (y), LCD_XSIZE - 1 - (x)
  159. #else
  160.   #error unsupported configuration
  161. #endif
  163. #define BKCOLOR LCD_BKCOLORINDEX
  164. #define   COLOR LCD_COLORINDEX
  166. /*
  167.         *********************************************************
  168.         *
  169.         *           Static variables for driver
  170.         *
  171.         *********************************************************
  172. */
  174. #if LCD_CACHE
  175.   static U8 VRam[LCD_YSIZE_PHYS][LCD_XSIZE_PHYS];
  176. #endif
  178. static int CurrentX, CurrentY, StartPage, StartColumn, RAM_Mode;
  180. /*
  181.         *********************************************************
  182.         *
  183.         *           Hardware access
  184.         *
  185.         *********************************************************
  186. */
  188. /*
  189.         *****************************************
  190.         *
  191.         *           Low level macros
  192.         *
  193.         *****************************************
  194. */
  196. #define RAM_WRITE (0x5c)
  197. #define RAM_READ  (0x5d)
  199. #define INCREMENT_CURSOR() 
  200.   CurrentX++; 
  201.   if (CurrentX >= LCD_XSIZE_PHYS) { 
  202.     CurrentX = StartColumn; 
  203.     CurrentY++; 
  204.     if (CurrentY >= LCD_YSIZE_PHYS) 
  205.       CurrentY = StartPage; 
  206.   }
  208. #define RESET_CURSOR() 
  209.   CurrentX = StartColumn; 
  210.   CurrentY = StartPage
  212. #define SET_RAMMODE(Mode) 
  213.   RAM_Mode = Mode; 
  214.   LCD_WRITECMD0 (Mode); 
  215.   RESET_CURSOR()
  217. #define PASET(y) 
  218.   RAM_Mode = 0; 
  219.   LCD_WRITECMD0 (0x75); 
  220.   LCD_WRITEDATA0(y); 
  221.   LCD_WRITEDATA0(LCD_YSIZE_PHYS - 1); 
  222.   StartPage = y
  223.   
  224. #define CASET(x) 
  225.   RAM_Mode = 0; 
  226.   LCD_WRITECMD0 (0x15); 
  227.   LCD_WRITEDATA0(x); 
  228.   LCD_WRITEDATA0(LCD_XSIZE_PHYS - 1); 
  229.   StartColumn = x
  231. #define LCD_ON() 
  232.   LCD_WRITECMD0 (0xaf); 
  233.   SET_RAMMODE(RAM_WRITE)
  235. #define LCD_OFF() 
  236.   LCD_WRITECMD0 (0xae); 
  237.   SET_RAMMODE(RAM_WRITE)
  239. #define DUMMYREAD(Data) 
  240.   LCD_READDATA0(Data)
  242. #if (LCD_OPTIMIZE)
  243.   
  244.   #define SET_RECT(x1, y1, x2, y2) 
  245.     CurrentX = CurrentY = 0xfff; 
  246.     LCD_WRITECMD0 (0x15); 
  247.     LCD_WRITEDATA0(x1); 
  248.     LCD_WRITEDATA0(x2); 
  249.     LCD_WRITECMD0 (0x75); 
  250.     LCD_WRITEDATA0(y1); 
  251.     LCD_WRITEDATA0(y2); 
  252.     LCD_WRITECMD0 (0x5c)
  254.   #define WRITEDATA_DIRECT(Data) 
  255.     LCD_WRITEDATA0(Data)
  257. #endif
  259. #if LCD_CACHE
  261.   #define WRITEDATA(Data) 
  262.     if (VRam[CurrentX][CurrentY] != Data) { 
  263.       VRam[CurrentX][CurrentY] = Data; 
  264.       LCD_WRITEDATA0(Data); 
  265.     } 
  266.     INCREMENT_CURSOR()
  268.   #define READDATA(Data) 
  269.     Data = VRam[CurrentX][CurrentY]
  271. #else
  273.   #define WRITEDATA(Data) 
  274.     LCD_WRITEDATA0(Data); 
  275.     INCREMENT_CURSOR()
  277.   #define READDATA(Data) 
  278.     LCD_READDATA0(Data); 
  279.     INCREMENT_CURSOR()
  281. #endif
  283. /*
  284.         *****************************************
  285.         *
  286.         *           GotoXY
  287.         *
  288.         *****************************************
  289. */
  291. void GotoXY(int x, int y, int Mode) {
  292.   if ((CurrentX != x) || (CurrentY != y)) {
  293.     CASET(x);
  294.     PASET(y);
  295.   }
  296.   if (RAM_Mode != Mode) {
  297.     SET_RAMMODE(Mode);
  298.   }
  299. }
  301. #define GOTOXY(x, y, Mode) GotoXY(x, y, Mode)
  303. /*
  304.         *********************************************************
  305.         *
  306.         *           Drawing routines, internal
  307.         *
  308.         *********************************************************
  309. */
  311. /*
  312.         *****************************************
  313.         *
  314.         *           SET pixel
  315.         *
  316.         *****************************************
  317. */
  319. static void SetPixel(int x, int y, U8 Color) {
  320.   GOTOXY(x, y, RAM_WRITE);
  321.   WRITEDATA(Color);
  322. }
  324. /*
  325.         *****************************************
  326.         *
  327.         *           GET pixel
  328.         *
  329.         *****************************************
  330. */
  332. static U8 GetPixel(int x, int y) {
  333.   U8 Color;
  334.   CASET(x);
  335.   PASET(y);
  336.   SET_RAMMODE(RAM_READ);
  337.   DUMMYREAD(Color);
  338.   READDATA(Color);
  339.   return Color;
  340. }
  342. /*
  343.         *****************************************
  344.         *
  345.         *           XOR pixel
  346.         *
  347.         *****************************************
  348. */
  350. static void XorPixel(int x, int y) {
  351.   U8 Color = GetPixel(x, y);
  352.   Color ^= 0xff;
  353.   SET_RAMMODE(RAM_WRITE);
  354.   WRITEDATA(Color);
  355. }
  357. /*
  358.         *********************************************************
  359.         *
  360.         *           Access macros for pixel access
  361.         *
  362.         *********************************************************
  364. Use only this macros for pixel access
  366. */
  368. #define XORPIXEL(x, y) 
  369.   XorPixel(LOG2PHYS(x, y));
  371. #define SETPIXEL(x, y, Color) 
  372.   SetPixel(LOG2PHYS(x, y), Color);
  374. #define GETPIXEL(x, y, Color) 
  375.   Color = GetPixel(LOG2PHYS(x, y));
  377. /*
  378.         *********************************************************
  379.         *
  380.         *           Exported routines
  381.         *
  382.         *********************************************************
  383. */
  385. /*
  386.         *****************************************
  387.         *
  388.         *           LCD_L0_XorPixel
  389.         *
  390.         *****************************************
  392. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  393.           display.
  395. */
  397. void LCD_L0_XorPixel(int x, int y) {
  398.   XORPIXEL(x, y);
  399. }
  401. /*
  402.         *****************************************
  403.         *
  404.         *           LCD_L0_SetPixelIndex
  405.         *
  406.         *****************************************
  408. Purpose:  This routine is called by emWin. It writes 1 pixel into the
  409.           display.
  411. */
  413. void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  414.   SETPIXEL(x, y, ColorIndex);
  415. }
  417. /*
  418.         *****************************************
  419.         *
  420.         *           LCD_L0_GetPixelIndex
  421.         *
  422.         *****************************************
  423. */
  425. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  426.   U8 ColorIndex;
  427.   GETPIXEL(x, y, ColorIndex);
  428.   return ColorIndex;
  429. }
  431. /*
  432.         *****************************************
  433.         *
  434.         *           LCD_L0_DrawPixel
  435.         *
  436.         *****************************************
  437. */
  439. void LCD_L0_DrawPixel(int x, int y) {
  440.   SETPIXEL(x, y, COLOR);
  441. }
  443. /*
  444.         ****************************************
  445.         *
  446.         *           LCD_DrawHLine
  447.         *
  448.         ****************************************
  449. */
  451. #if  (LCD_OPTIMIZE)  
  452.   && (!LCD_MIRROR_X) 
  453.   && (!LCD_MIRROR_Y) 
  454.   && (!LCD_SWAP_XY)
  456. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  457.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  458.     while (x0 <= x1) {
  459.       XORPIXEL(x0, y);
  460.       x0++;
  461.     }
  462.   } else {
  463.     SET_RECT(x0, y, x1, y);
  464.     while (x0++ <= x1) {
  465.       WRITEDATA_DIRECT(COLOR);
  466.     }
  467.   }
  468. }
  470. #else
  472. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  473.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  474.     while (x0 <= x1) {
  475.       XORPIXEL(x0, y);
  476.       x0++;
  477.     }
  478.   } else {
  479.     while (x0 <= x1) {
  480.       SETPIXEL(x0, y, COLOR);
  481.       x0++;
  482.     }
  483.   }
  484. }
  486. #endif
  488. /*
  489.         ****************************************
  490.         *
  491.         *           LCD_DrawVLine
  492.         *
  493.         ****************************************
  494. */
  496. #if  (LCD_OPTIMIZE)  
  497.   && (!LCD_MIRROR_X) 
  498.   && (!LCD_MIRROR_Y) 
  499.   && (!LCD_SWAP_XY)
  501. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  502.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  503.     while (y0 <= y1) {
  504.       XORPIXEL(x, y0);
  505.       y0++;
  506.     }
  507.   } else {
  508.     SET_RECT(x, y0, x, y1);
  509.     while (y0++ <= y1) {
  510.       WRITEDATA_DIRECT(COLOR);
  511.     }
  512.   }
  513. }
  515. #else
  517. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  518.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  519.     while (y0 <= y1) {
  520.       XORPIXEL(x, y0);
  521.       y0++;
  522.     }
  523.   } else {
  524.     while (y0 <= y1) {
  525.       SETPIXEL(x, y0, COLOR);
  526.       y0++;
  527.     }
  528.   }
  529. }
  531. #endif
  533. /*
  534.         *****************************************
  535.         *
  536.         *           LCD_L0_FillRect
  537.         *
  538.         *****************************************
  540. */
  542. #if  (LCD_OPTIMIZE)  
  543.   && (!LCD_MIRROR_X) 
  544.   && (!LCD_MIRROR_Y) 
  545.   && (!LCD_SWAP_XY)
  547. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  548.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  549.     for (; y0 <= y1; y0++) {
  550.       LCD_L0_DrawHLine(x0, y0, x1);
  551.     }
  552.   } else {
  553.     int Bytes = (y1 - y0 + 1) * (x1 - x0 + 1);
  554.     SET_RECT(x0, y0, x1, y1);
  555.     while (Bytes--) {
  556.       WRITEDATA_DIRECT(COLOR);
  557.     }
  558.   }
  559. }
  561. #else
  563. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  564.   for (; y0 <= y1; y0++) {
  565.     LCD_L0_DrawHLine(x0, y0, x1);
  566.   }
  567. }
  569. #endif
  571. /*
  572.         *****************************************
  573.         *
  574.         *           Draw Bitmap 1 BPP
  575.         *           optimized
  576.         *
  577.         *****************************************
  578. */
  580. #if  (LCD_OPTIMIZE)  
  581.   && (!LCD_MIRROR_X) 
  582.   && (!LCD_MIRROR_Y) 
  583.   && (!LCD_SWAP_XY)
  585. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  586.   LCD_PIXELINDEX pixels;
  587.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  588.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  589. /*
  590. // Jump to right entry point
  591. */
  592.   pixels = *p;
  593.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  594.   case 0:
  595.     switch (Diff&7) {
  596.     case 0:   
  597.       goto WriteBit0;
  598.     case 1:   
  599.       goto WriteBit1;
  600.     case 2:
  601.       goto WriteBit2;
  602.     case 3:
  603.       goto WriteBit3;
  604.     case 4:
  605.       goto WriteBit4;
  606.     case 5:   
  607.       goto WriteBit5;
  608.     case 6:   
  609.       goto WriteBit6;
  610.     case 7:   
  611.       goto WriteBit7;
  612.     }
  613.     break;
  614.   case LCD_DRAWMODE_TRANS:
  615.     switch (Diff&7) {
  616.     case 0:
  617.       goto WriteTBit0;
  618.     case 1:
  619.       goto WriteTBit1;
  620.     case 2:
  621.       goto WriteTBit2;
  622.     case 3:
  623.       goto WriteTBit3;
  624.     case 4:
  625.       goto WriteTBit4;
  626.     case 5:   
  627.       goto WriteTBit5;
  628.     case 6:   
  629.       goto WriteTBit6;
  630.     case 7:   
  631.       goto WriteTBit7;
  632.     }
  633.     break;
  634.   case LCD_DRAWMODE_XOR:
  635.     switch (Diff&7) {
  636.     case 0:   
  637.       goto WriteXBit0;
  638.     case 1:   
  639.       goto WriteXBit1;
  640.     case 2:
  641.       goto WriteXBit2;
  642.     case 3:
  643.       goto WriteXBit3;
  644.     case 4:
  645.       goto WriteXBit4;
  646.     case 5:   
  647.       goto WriteXBit5;
  648.     case 6:   
  649.       goto WriteXBit6;
  650.     case 7:   
  651.       goto WriteXBit7;
  652.     }
  653.   }
  654. /*
  655.         Write with transparency
  656. */
  657.   WriteTBit0:
  658.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  659.     if (!--xsize)
  660.       return;
  661.   WriteTBit1:
  662.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  663.     if (!--xsize)
  664.       return;
  665.   WriteTBit2:
  666.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  667.     if (!--xsize)
  668.       return;
  669.   WriteTBit3:
  670.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  671.     if (!--xsize)
  672.       return;
  673.   WriteTBit4:
  674.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  675.     if (!--xsize)
  676.       return;
  677.   WriteTBit5:
  678.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  679.     if (!--xsize)
  680.       return;
  681.   WriteTBit6:
  682.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  683.     if (!--xsize)
  684.       return;
  685.   WriteTBit7:
  686.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  687.     if (!--xsize)
  688.       return;
  689.     x+=8;
  690.     pixels = *(++p);
  691.     goto WriteTBit0;
  692. /*
  693.         Write without transparency
  694. */
  695.   WriteBit0:
  696.     WRITEDATA_DIRECT((pixels&(1<<7)) ? Index1 : Index0);
  697.     if (!--xsize)
  698.       return;
  699.   WriteBit1:
  700.     WRITEDATA_DIRECT((pixels&(1<<6)) ? Index1 : Index0);
  701.     if (!--xsize)
  702.       return;
  703.   WriteBit2:
  704.     WRITEDATA_DIRECT((pixels&(1<<5)) ? Index1 : Index0);
  705.     if (!--xsize)
  706.       return;
  707.   WriteBit3:
  708.     WRITEDATA_DIRECT((pixels&(1<<4)) ? Index1 : Index0);
  709.     if (!--xsize)
  710.       return;
  711.   WriteBit4:
  712.     WRITEDATA_DIRECT((pixels&(1<<3)) ? Index1 : Index0);
  713.     if (!--xsize)
  714.       return;
  715.   WriteBit5:
  716.     WRITEDATA_DIRECT((pixels&(1<<2)) ? Index1 : Index0);
  717.     if (!--xsize)
  718.       return;
  719.   WriteBit6:
  720.     WRITEDATA_DIRECT((pixels&(1<<1)) ? Index1 : Index0);
  721.     if (!--xsize)
  722.       return;
  723.   WriteBit7:
  724.     WRITEDATA_DIRECT((pixels&(1<<0)) ? Index1 : Index0);
  725.     if (!--xsize)
  726.       return;
  727.     x+=8;
  728.     pixels = *(++p);
  729.     goto WriteBit0;
  730. /*
  731.         Write XOR mode
  732. */
  733.   WriteXBit0:
  734.     if (pixels&(1<<7))
  735.       XORPIXEL(x+0, y);
  736.     if (!--xsize)
  737.       return;
  738.   WriteXBit1:
  739.     if (pixels&(1<<6))
  740.       XORPIXEL(x+1, y);
  741.     if (!--xsize)
  742.       return;
  743.   WriteXBit2:
  744.     if (pixels&(1<<5))
  745.       XORPIXEL(x+2, y);
  746.     if (!--xsize)
  747.       return;
  748.   WriteXBit3:
  749.     if (pixels&(1<<4))
  750.       XORPIXEL(x+3, y);
  751.     if (!--xsize)
  752.       return;
  753.   WriteXBit4:
  754.     if (pixels&(1<<3))
  755.       XORPIXEL(x+4, y);
  756.     if (!--xsize)
  757.       return;
  758.   WriteXBit5:
  759.     if (pixels&(1<<2))
  760.       XORPIXEL(x+5, y);
  761.     if (!--xsize)
  762.       return;
  763.   WriteXBit6:
  764.     if (pixels&(1<<1))
  765.       XORPIXEL(x+6, y);
  766.     if (!--xsize)
  767.       return;
  768.   WriteXBit7:
  769.     if (pixels&(1<<0))
  770.       XORPIXEL(x+7, y);
  771.     if (!--xsize)
  772.       return;
  773.     x+=8;
  774.     pixels = *(++p);
  775.     goto WriteXBit0;
  776. }
  778. #else
  780. /*
  781.         *****************************************
  782.         *
  783.         *           Draw Bitmap 1 BPP
  784.         *           no optimizations
  785.         *
  786.         *****************************************
  787. */
  789. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  790.   LCD_PIXELINDEX pixels;
  791.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  792.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  793. /*
  794. // Jump to right entry point
  795. */
  796.   pixels = *p;
  797.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  798.   case 0:
  799.     switch (Diff&7) {
  800.     case 0:   
  801.       goto WriteBit0;
  802.     case 1:   
  803.       goto WriteBit1;
  804.     case 2:
  805.       goto WriteBit2;
  806.     case 3:
  807.       goto WriteBit3;
  808.     case 4:
  809.       goto WriteBit4;
  810.     case 5:   
  811.       goto WriteBit5;
  812.     case 6:   
  813.       goto WriteBit6;
  814.     case 7:   
  815.       goto WriteBit7;
  816.     }
  817.     break;
  818.   case LCD_DRAWMODE_TRANS:
  819.     switch (Diff&7) {
  820.     case 0:
  821.       goto WriteTBit0;
  822.     case 1:
  823.       goto WriteTBit1;
  824.     case 2:
  825.       goto WriteTBit2;
  826.     case 3:
  827.       goto WriteTBit3;
  828.     case 4:
  829.       goto WriteTBit4;
  830.     case 5:   
  831.       goto WriteTBit5;
  832.     case 6:   
  833.       goto WriteTBit6;
  834.     case 7:   
  835.       goto WriteTBit7;
  836.     }
  837.     break;
  838.   case LCD_DRAWMODE_XOR:
  839.     switch (Diff&7) {
  840.     case 0:   
  841.       goto WriteXBit0;
  842.     case 1:   
  843.       goto WriteXBit1;
  844.     case 2:
  845.       goto WriteXBit2;
  846.     case 3:
  847.       goto WriteXBit3;
  848.     case 4:
  849.       goto WriteXBit4;
  850.     case 5:   
  851.       goto WriteXBit5;
  852.     case 6:   
  853.       goto WriteXBit6;
  854.     case 7:   
  855.       goto WriteXBit7;
  856.     }
  857.   }
  858. /*
  859.         Write with transparency
  860. */
  861.   WriteTBit0:
  862.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  863.     if (!--xsize)
  864.       return;
  865.   WriteTBit1:
  866.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  867.     if (!--xsize)
  868.       return;
  869.   WriteTBit2:
  870.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  871.     if (!--xsize)
  872.       return;
  873.   WriteTBit3:
  874.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  875.     if (!--xsize)
  876.       return;
  877.   WriteTBit4:
  878.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  879.     if (!--xsize)
  880.       return;
  881.   WriteTBit5:
  882.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  883.     if (!--xsize)
  884.       return;
  885.   WriteTBit6:
  886.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  887.     if (!--xsize)
  888.       return;
  889.   WriteTBit7:
  890.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  891.     if (!--xsize)
  892.       return;
  893.     x+=8;
  894.     pixels = *(++p);
  895.     goto WriteTBit0;
  896. /*
  897.         Write without transparency
  898. */
  899.   WriteBit0:
  900.     SETPIXEL(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  901.     if (!--xsize)
  902.       return;
  903.   WriteBit1:
  904.     SETPIXEL(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  905.     if (!--xsize)
  906.       return;
  907.   WriteBit2:
  908.     SETPIXEL(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  909.     if (!--xsize)
  910.       return;
  911.   WriteBit3:
  912.     SETPIXEL(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  913.     if (!--xsize)
  914.       return;
  915.   WriteBit4:
  916.     SETPIXEL(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  917.     if (!--xsize)
  918.       return;
  919.   WriteBit5:
  920.     SETPIXEL(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  921.     if (!--xsize)
  922.       return;
  923.   WriteBit6:
  924.     SETPIXEL(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  925.     if (!--xsize)
  926.       return;
  927.   WriteBit7:
  928.     SETPIXEL(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  929.     if (!--xsize)
  930.       return;
  931.     x+=8;
  932.     pixels = *(++p);
  933.     goto WriteBit0;
  934. /*
  935.         Write XOR mode
  936. */
  937.   WriteXBit0:
  938.     if (pixels&(1<<7))
  939.       XORPIXEL(x+0, y);
  940.     if (!--xsize)
  941.       return;
  942.   WriteXBit1:
  943.     if (pixels&(1<<6))
  944.       XORPIXEL(x+1, y);
  945.     if (!--xsize)
  946.       return;
  947.   WriteXBit2:
  948.     if (pixels&(1<<5))
  949.       XORPIXEL(x+2, y);
  950.     if (!--xsize)
  951.       return;
  952.   WriteXBit3:
  953.     if (pixels&(1<<4))
  954.       XORPIXEL(x+3, y);
  955.     if (!--xsize)
  956.       return;
  957.   WriteXBit4:
  958.     if (pixels&(1<<3))
  959.       XORPIXEL(x+4, y);
  960.     if (!--xsize)
  961.       return;
  962.   WriteXBit5:
  963.     if (pixels&(1<<2))
  964.       XORPIXEL(x+5, y);
  965.     if (!--xsize)
  966.       return;
  967.   WriteXBit6:
  968.     if (pixels&(1<<1))
  969.       XORPIXEL(x+6, y);
  970.     if (!--xsize)
  971.       return;
  972.   WriteXBit7:
  973.     if (pixels&(1<<0))
  974.       XORPIXEL(x+7, y);
  975.     if (!--xsize)
  976.       return;
  977.     x+=8;
  978.     pixels = *(++p);
  979.     goto WriteXBit0;
  980. }
  982. #endif
  984. /*
  985.         *****************************************
  986.         *
  987.         *           Draw Bitmap 2 BPP
  988.         *           optimized
  989.         *
  990.         *****************************************
  991. */
  993. #if (LCD_MAX_LOG_COLORS > 2)
  995. #if  (LCD_OPTIMIZE)  
  996.   && (!LCD_MIRROR_X) 
  997.   && (!LCD_MIRROR_Y) 
  998.   && (!LCD_SWAP_XY)
  1000. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1001.   LCD_PIXELINDEX pixels;
  1002. /*
  1003. // Jump to right entry point
  1004. */
  1005.   pixels = *p;
  1006.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  1007.   case 0:
  1008.     goto WriteTBit0;
  1009.   case 1:
  1010.     goto WriteTBit1;
  1011.   case 2:
  1012.     goto WriteTBit2;
  1013.   default:
  1014.     goto WriteTBit3;
  1015.   } else switch (Diff&3) {
  1016.   case 0:
  1017.     goto WriteBit0;
  1018.   case 1:
  1019.     goto WriteBit1;
  1020.   case 2:
  1021.     goto WriteBit2;
  1022.   default:
  1023.     goto WriteBit3;
  1024.   }
  1025. /*
  1026.         Write without transparency
  1027. */
  1028. WriteBit0:
  1029.   WRITEDATA_DIRECT(*(pTrans+(pixels>>6)));
  1030.   if (!--xsize)
  1031.     return;
  1032. WriteBit1:
  1033.   WRITEDATA_DIRECT(*(pTrans+(3&(pixels>>4))));
  1034.   if (!--xsize)
  1035.     return;
  1036. WriteBit2:
  1037.   WRITEDATA_DIRECT(*(pTrans+(3&(pixels>>2))));
  1038.   if (!--xsize)
  1039.     return;
  1040. WriteBit3:
  1041.   WRITEDATA_DIRECT(*(pTrans+(3&(pixels))));
  1042.   if (!--xsize)
  1043.     return;
  1044.   pixels = *(++p);
  1045.   x+=4;
  1046.   goto WriteBit0;
  1047. /*
  1048.         Write with transparency
  1049. */
  1050. WriteTBit0:
  1051.   if (pixels&(3<<6))
  1052.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1053.   if (!--xsize)
  1054.     return;
  1055. WriteTBit1:
  1056.   if (pixels&(3<<4))
  1057.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1058.   if (!--xsize)
  1059.     return;
  1060. WriteTBit2:
  1061.   if (pixels&(3<<2))
  1062.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1063.   if (!--xsize)
  1064.     return;
  1065. WriteTBit3:
  1066.   if (pixels&(3<<0))
  1067.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1068.   if (!--xsize)
  1069.     return;
  1070.   pixels = *(++p);
  1071.   x+=4;
  1072.   goto WriteTBit0;
  1073. }
  1075. #else
  1077. /*
  1078.         *****************************************
  1079.         *
  1080.         *           Draw Bitmap 2 BPP
  1081.         *           no optimizations
  1082.         *
  1083.         *****************************************
  1084. */
  1086. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1087.   LCD_PIXELINDEX pixels;
  1088. /*
  1089. // Jump to right entry point
  1090. */
  1091.   pixels = *p;
  1092.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) switch (Diff&3) {
  1093.   case 0:
  1094.     goto WriteTBit0;
  1095.   case 1:
  1096.     goto WriteTBit1;
  1097.   case 2:
  1098.     goto WriteTBit2;
  1099.   default:
  1100.     goto WriteTBit3;
  1101.   } else switch (Diff&3) {
  1102.   case 0:
  1103.     goto WriteBit0;
  1104.   case 1:
  1105.     goto WriteBit1;
  1106.   case 2:
  1107.     goto WriteBit2;
  1108.   default:
  1109.     goto WriteBit3;
  1110.   }
  1111. /*
  1112.         Write without transparency
  1113. */
  1114. WriteBit0:
  1115.   SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1116.   if (!--xsize)
  1117.     return;
  1118. WriteBit1:
  1119.   SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1120.   if (!--xsize)
  1121.     return;
  1122. WriteBit2:
  1123.   SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1124.   if (!--xsize)
  1125.     return;
  1126. WriteBit3:
  1127.   SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1128.   if (!--xsize)
  1129.     return;
  1130.   pixels = *(++p);
  1131.   x+=4;
  1132.   goto WriteBit0;
  1133. /*
  1134.         Write with transparency
  1135. */
  1136. WriteTBit0:
  1137.   if (pixels&(3<<6))
  1138.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1139.   if (!--xsize)
  1140.     return;
  1141. WriteTBit1:
  1142.   if (pixels&(3<<4))
  1143.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1144.   if (!--xsize)
  1145.     return;
  1146. WriteTBit2:
  1147.   if (pixels&(3<<2))
  1148.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1149.   if (!--xsize)
  1150.     return;
  1151. WriteTBit3:
  1152.   if (pixels&(3<<0))
  1153.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1154.   if (!--xsize)
  1155.     return;
  1156.   pixels = *(++p);
  1157.   x+=4;
  1158.   goto WriteTBit0;
  1159. }
  1161. #endif
  1163. #endif
  1165. /*
  1166.         *****************************************
  1167.         *
  1168.         *           Draw Bitmap 4 BPP
  1169.         *           optimized
  1170.         *
  1171.         *****************************************
  1172. */
  1174. #if (LCD_MAX_LOG_COLORS > 4)
  1176. #if  (LCD_OPTIMIZE)  
  1177.   && (!LCD_MIRROR_X) 
  1178.   && (!LCD_MIRROR_Y) 
  1179.   && (!LCD_SWAP_XY)
  1181. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1182.   LCD_PIXELINDEX pixels;
  1183. /*
  1184. // Jump to right entry point
  1185. */
  1186.   pixels = *p;
  1187.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1188.     if ((Diff&1) ==0)
  1189.       goto WriteTBit0;
  1190.     goto WriteTBit1;
  1191.   } else {
  1192.     if ((Diff&1) ==0)
  1193.       goto WriteBit0;
  1194.     goto WriteBit1;
  1195.   }
  1196. /*
  1197.         Write without transparency
  1198. */
  1199. WriteBit0:
  1200.   WRITEDATA_DIRECT(*(pTrans+(pixels>>4)));
  1201.   if (!--xsize)
  1202.     return;
  1203. WriteBit1:
  1204.   WRITEDATA_DIRECT(*(pTrans+(pixels&0xf)));
  1205.   if (!--xsize)
  1206.     return;
  1207.   x+=2;
  1208.   pixels = *(++p);
  1209.   goto WriteBit0;
  1210. /*
  1211.         Write with transparency
  1212. */
  1213. WriteTBit0:
  1214.   if (pixels>>4)
  1215.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1216.   if (!--xsize)
  1217.     return;
  1218. WriteTBit1:
  1219.   if (pixels&0xf)
  1220.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1221.   if (!--xsize)
  1222.     return;
  1223.   x+=2;
  1224.   pixels = *(++p);
  1225.   goto WriteTBit0;
  1226. }
  1228. #else
  1230. /*
  1231.         *****************************************
  1232.         *
  1233.         *           Draw Bitmap 4 BPP
  1234.         *           no optimizations
  1235.         *
  1236.         *****************************************
  1237. */
  1239. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1240.   LCD_PIXELINDEX pixels;
  1241. /*
  1242. // Jump to right entry point
  1243. */
  1244.   pixels = *p;
  1245.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1246.     if ((Diff&1) ==0)
  1247.       goto WriteTBit0;
  1248.     goto WriteTBit1;
  1249.   } else {
  1250.     if ((Diff&1) ==0)
  1251.       goto WriteBit0;
  1252.     goto WriteBit1;
  1253.   }
  1254. /*
  1255.         Write without transparency
  1256. */
  1257. WriteBit0:
  1258.   SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1259.   if (!--xsize)
  1260.     return;
  1261. WriteBit1:
  1262.   SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1263.   if (!--xsize)
  1264.     return;
  1265.   x+=2;
  1266.   pixels = *(++p);
  1267.   goto WriteBit0;
  1268. /*
  1269.         Write with transparency
  1270. */
  1271. WriteTBit0:
  1272.   if (pixels>>4)
  1273.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1274.   if (!--xsize)
  1275.     return;
  1276. WriteTBit1:
  1277.   if (pixels&0xf)
  1278.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1279.   if (!--xsize)
  1280.     return;
  1281.   x+=2;
  1282.   pixels = *(++p);
  1283.   goto WriteTBit0;
  1284. }
  1286. #endif
  1288. #endif
  1290. /*
  1291.         *****************************************
  1292.         *
  1293.         *           Draw Bitmap 8 BPP
  1294.         *           optimized
  1295.         *
  1296.         *****************************************
  1297. */
  1299. #if (LCD_MAX_LOG_COLORS > 16)
  1301. #if  (LCD_OPTIMIZE)  
  1302.   && (!LCD_MIRROR_X) 
  1303.   && (!LCD_MIRROR_Y) 
  1304.   && (!LCD_SWAP_XY)
  1306. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  1307.   LCD_PIXELINDEX pixel;
  1308.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  1309.     if (pTrans) {
  1310.       for (;xsize > 0; xsize--,x++,p++) {
  1311.         pixel = *p;
  1312.         WRITEDATA_DIRECT(*(pTrans+pixel));
  1313.       }
  1314.     } else {
  1315.       for (;xsize > 0; xsize--,x++,p++) {
  1316.         WRITEDATA_DIRECT(*p);
  1317.       }
  1318.     }
  1319.   } else {   /* Handle transparent bitmap */
  1320.     if (pTrans) {
  1321.       for (; xsize > 0; xsize--, x++, p++) {
  1322.         pixel = *p;
  1323.         if (pixel) {
  1324.           SETPIXEL(x+0, y, *(pTrans+pixel));
  1325.         }
  1326.       }
  1327.     } else {
  1328.       for (; xsize > 0; xsize--, x++, p++) {
  1329.         pixel = *p;
  1330.         if (pixel) {
  1331.           SETPIXEL(x+0, y, pixel);
  1332.         }
  1333.       }
  1334.     }
  1335.   }
  1336. }
  1338. #else
  1340. /*
  1341.         *****************************************
  1342.         *
  1343.         *           Draw Bitmap 8 BPP
  1344.         *           no optimizations
  1345.         *
  1346.         *****************************************
  1347. */
  1349. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  1350.   LCD_PIXELINDEX pixel;
  1351.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
  1352.     if (pTrans) {
  1353.       for (;xsize > 0; xsize--,x++,p++) {
  1354.         pixel = *p;
  1355.         SETPIXEL(x, y, *(pTrans+pixel));
  1356.       }
  1357.     } else {
  1358.       for (;xsize > 0; xsize--,x++,p++) {
  1359.         SETPIXEL(x, y, *p);
  1360.       }
  1361.     }
  1362.   } else {   /* Handle transparent bitmap */
  1363.     if (pTrans) {
  1364.       for (; xsize > 0; xsize--, x++, p++) {
  1365.         pixel = *p;
  1366.         if (pixel) {
  1367.           SETPIXEL(x+0, y, *(pTrans+pixel));
  1368.         }
  1369.       }
  1370.     } else {
  1371.       for (; xsize > 0; xsize--, x++, p++) {
  1372.         pixel = *p;
  1373.         if (pixel) {
  1374.           SETPIXEL(x+0, y, pixel);
  1375.         }
  1376.       }
  1377.     }
  1378.   }
  1379. }
  1381. #endif
  1383. #endif
  1385. /*
  1386.         *********************************************************
  1387.         *
  1388.         *           Universal draw Bitmap routine
  1389.         *
  1390.         *********************************************************
  1391. */
  1393. void LCD_L0_DrawBitmap   (int x0, int y0,
  1394.                        int xsize, int ysize,
  1395.                        int BitsPerPixel, 
  1396.                        int BytesPerLine,
  1397.                        const U8* pData, int Diff,
  1398.                        const LCD_PIXELINDEX* pTrans)
  1399. {
  1400.   int i;
  1401.   #if  (LCD_OPTIMIZE)  
  1402.     && (!LCD_MIRROR_X) 
  1403.     && (!LCD_MIRROR_Y) 
  1404.     && (!LCD_SWAP_XY)
  1405.     SET_RECT(x0 + Diff, y0, x0 + Diff + xsize - 1, y0 + ysize - 1);
  1406.   #endif
  1407.   /*
  1408.      Use DrawBitLineXBPP
  1409.   */
  1410.   for (i=0; i<ysize; i++) {
  1411.     switch (BitsPerPixel) {
  1412.     case 1:
  1413.       DrawBitLine1BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1414.       break;
  1415.     #if (LCD_MAX_LOG_COLORS > 2)
  1416.       case 2:
  1417.         DrawBitLine2BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1418.         break;
  1419.     #endif
  1420.     #if (LCD_MAX_LOG_COLORS > 4)
  1421.       case 4:
  1422.         DrawBitLine4BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1423.         break;
  1424.     #endif
  1425.     #if (LCD_MAX_LOG_COLORS > 16)
  1426.       case 8:
  1427.         DrawBitLine8BPP(x0, i + y0, pData, xsize, pTrans);
  1428.         break;
  1429.     #endif
  1430.     }
  1431.     pData += BytesPerLine;
  1432.   }
  1433. }
  1435. /********************************************************
  1436. *
  1437. *       LCD_L0_SetOrg
  1438. *
  1439. *********************************************************
  1441. Purpose:        Sets the original position of the virtual display.
  1442.                 Has no function at this point with the PC-driver.
  1443. */
  1445. int OrgX, OrgY;
  1446. void LCD_L0_SetOrg(int x, int y) {
  1447.   OrgX = x;
  1448.   OrgY = y;
  1449. }
  1451. /*
  1452.         *****************************************
  1453.         *
  1454.         *           LCD_On, LCD_Off
  1455.         *
  1456.         *****************************************
  1458. Sets the original position of the virtual display.
  1459. Has no function at this point with the PC-driver.
  1461. */
  1463. void LCD_Off          (void) {
  1464. #ifdef LCD_OFF
  1465.   LCD_OFF();
  1466. #endif
  1467. }
  1469. void LCD_On           (void) {
  1470. #ifdef LCD_ON
  1471.   LCD_ON();
  1472. #endif
  1473. }
  1475. /*
  1476.         *****************************************
  1477.         *
  1478.         *           LCD_L0_Init
  1479.         *
  1480.         *****************************************
  1481. */
  1483. int  LCD_L0_Init(void) {
  1484.   int i;
  1485.   GUI_DEBUG_LOG("nLCD_Init()");
  1486.   LCD_INIT_CONTROLLER();
  1487.   /* set cursor to illegal value */
  1488.   CurrentX = CurrentY = 0xfff;
  1489.   /* clear LCD */
  1490.   GOTOXY(0, 0, RAM_WRITE);
  1491.   for (i = 0; i < LCD_XSIZE_PHYS * LCD_YSIZE_PHYS; i++) {
  1492.     LCD_WRITEDATA0(0);
  1493.   }
  1494.   GOTOXY(0, 0, RAM_WRITE);
  1495.   /* clear VRam */
  1496.   #if LCD_CACHE
  1497.     memset(VRam, 0, sizeof(VRam));
  1498.   #endif
  1499.   LCD_Off();
  1500.   return 0;
  1501. }
  1503. /*
  1504.         *****************************************
  1505.         *
  1506.         *           LCD_L0_SetLUTEntry
  1507.         *
  1508.         *****************************************
  1510. This function is only a dummy
  1512. */
  1514. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR Color) {
  1515.   Pos = Pos;
  1516.   Color = Color;
  1517. }
  1519. #else
  1521. void LCD159A(void) { } /* avoid empty object files */
  1523. #endif  /* (LCD_CONTROLLER == 0x159A) */