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

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

uCOS

开发平台：

C/C++

LCDPage1bpp.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        : LCDPage1bpp.C
  16. Purpose     : Driver for page-organized LCD-controllers with 1bpp
  17. ----------------------------------------------------------------------   
  18. Version-Date---Author-Explanation                                        
  19. ----------------------------------------------------------------------   
  20. 1.00.08 020820 JE     a) Optimized:
  21.                          _DrawBitLine1BPP, _DrawBitLine8BPP
  22. 1.00.06 020814 JE     a) Support for PCF8535 added
  23. 1.00.04 020510 JE     a) Bugfix in LCD_L0_FillRect
  24. 1.00.02 020425 JE     a) LCD_WRITEM_A1 used in optimized routines
  25. 1.00.02 020424 JE     a) Optimized routines added:
  26.                          _DrawBitLine1BPP, LCD_L0_DrawHLine
  27.                          LCD_L0_DrawVLine, LCD_L0_FillRect
  28. 1.00.00 020422 JE     a) First release
  29. ---------------------------END-OF-HEADER------------------------------
  30. */
  32. #include <string.h>           /* memset */
  33. #include "LCD_Private.h"      /* private modul definitions & config */
  34. #include "GUI_Private.h"
  35. #include "GUIDebug.h"
  36. #include "LCD_0.h"            /* Defines for first display */
  38. #if (LCD_CONTROLLER == 8811) || (LCD_CONTROLLER == 8535)
  39.     && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  41. /*********************************************************************
  42. *
  43. *       Defines
  44. *
  45. **********************************************************************
  46. */
  48. #ifndef LCD_INIT_CONTROLLER
  49.   #define LCD_INIT_CONTROLLER()
  50. #endif
  52. #ifndef LCD_OPTIMIZE
  53.   #define LCD_OPTIMIZE 1
  54. #endif
  56. #ifndef LCD_CACHE
  57.   #define  LCD_CACHE 1
  58. #endif
  60. /*********************************************
  61. *
  62. *       Macros for MIRROR_, SWAP_ and LUT_
  63. *
  64. **********************************************
  65. */
  67. #if (!defined (LCD_LUT_COM) && !defined(LCD_LUT_SEG))
  68.   #if   (!LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  69.     #define LOG2PHYS_X(x, y) (x)
  70.     #define LOG2PHYS_Y(x, y) (y)
  71.   #elif (!LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  72.     #define LOG2PHYS_X(x, y) (y)
  73.     #define LOG2PHYS_Y(x, y) (x)
  74.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  75.     #define LOG2PHYS_X(x, y) (x)
  76.     #define LOG2PHYS_Y(x, y) (LCD_YSIZE - 1 - (y))
  77.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  78.     #define LOG2PHYS_X(x, y) (LCD_YSIZE - 1 - (y))
  79.     #define LOG2PHYS_Y(x, y) (x)
  80.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  81.     #define LOG2PHYS_X(x, y) (LCD_XSIZE - 1 - (x))
  82.     #define LOG2PHYS_Y(x, y) (y)
  83.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  84.     #define LOG2PHYS_X(x, y) (LCD_YSIZE - 1 - (y))
  85.     #define LOG2PHYS_Y(x, y) (x)
  86.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  87.     #define LOG2PHYS_X(x, y) (LCD_XSIZE - 1 - (x))
  88.     #define LOG2PHYS_Y(x, y) (LCD_YSIZE - 1 - (y))
  89.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  90.     #error This combination of mirroring/swapping not yet supported
  91.   #endif
  92. #else
  93.   #if   ( defined (LCD_LUT_COM) && !defined(LCD_LUT_SEG))
  94.     #define LOG2PHYS_X(x, y) (x)
  95.     #define LOG2PHYS_Y(x, y) LCD__aLine2Com0[y]
  96.   #elif (!defined (LCD_LUT_COM) &&  defined(LCD_LUT_SEG))
  97.     #define LOG2PHYS_X(x, y) LCD__aCol2Seg0[x]
  98.     #define LOG2PHYS_Y(x, y) (y)
  99.   #elif ( defined (LCD_LUT_COM) &&  defined(LCD_LUT_SEG))
  100.     #define LOG2PHYS_X(x, y) LCD__aCol2Seg0[x]
  101.     #define LOG2PHYS_Y(x, y) LCD__aLine2Com0[y]
  102.   #endif
  103. #endif
  105. /*********************************************
  106. *
  107. *       Macros for simulation
  108. *
  109. **********************************************
  110. */
  112. #ifdef WIN32
  113.   #undef LCD_WRITE_A0
  114.   #undef LCD_WRITE_A1
  115.   #undef LCD_WRITEM_A1
  116.   #undef LCD_READ_A0
  117.   #undef LCD_READ_A1
  118.   void SIM_WriteA1C0(U8 Data);
  119.   void SIM_WriteMA1C0(U8 * pData, int NumberOfBytes);
  120.   void SIM_WriteA0C0(U8 cmd);
  121.   U8   SIM_ReadA1C0(void);
  122.   U8   SIM_ReadA0C0(void);
  123.   #define LCD_WRITE_A1(Byte)                  SIM_WriteA1C0(Byte)
  124.   #define LCD_WRITEM_A1(pData, NumberOfBytes) SIM_WriteMA1C0(pData, NumberOfBytes)
  125.   #define LCD_WRITE_A0(Byte)                  SIM_WriteA0C0(Byte)
  126.   #define LCD_READ_A1()                       SIM_ReadA1C0()
  127.   #define LCD_READ_A0()                       SIM_ReadA0C0()
  128. #endif
  130. /*********************************************
  131. *
  132. *       Hardware access macros
  133. *
  134. **********************************************
  135. */
  137. #ifndef LCD_CHECK_BUSY
  138.   #define LCD_CHECK_BUSY 0
  139. #endif
  141. #ifndef LCD_XOFF
  142.   #define LCD_XOFF 0
  143. #endif
  145. #if LCD_CHECK_BUSY
  146.   #define CHECK_BUSY() WAIT_WHILE_BUSY()
  147. #else
  148.   #define CHECK_BUSY()
  149. #endif
  151. #ifdef LCD_CACHE
  152.   #if !LCD_CACHE
  153.     #error Using this driver a cache must be defined!
  154.   #endif
  155. #else
  156.   #define LCD_CACHE 1
  157. #endif
  159. #if (LCD_CONTROLLER == 8811) /* PCF8811 */
  161.   #define MAX_PAGE             10
  162.   #define MAX_OFFSET           128
  163.   #define WAIT_WHILE_BUSY()    { U8 Status; do { LCD_READ_A0(Status); } while (Status & (1 << 7)); }
  164.   #define WRITE_DATA(Data)     CHECK_BUSY(); LCD_WRITE_A1(Data); _VRam[_Page][_Offset] = Data
  165.   #define LCD_ON()             CHECK_BUSY(); LCD_WRITE_A0(0xAF)
  166.   #define LCD_OFF()            CHECK_BUSY(); LCD_WRITE_A0(0xAE)
  167.   #define SET_PAGE(Page)       CHECK_BUSY(); LCD_WRITE_A0(Page + 0xB0)
  168.   #define SET_OFFSET(Offset)   CHECK_BUSY(); LCD_WRITE_A0(0x10 + (Offset >> 4)); 
  169.                                CHECK_BUSY(); LCD_WRITE_A0(0x00 + (Offset & 0x0F))
  170.   #ifndef LCD_AUTOINC_Y
  171.     #define LCD_AUTOINC_Y      MAX_OFFSET
  172.   #endif
  174.   #define INCREMENT_XY_VOLATILE
  176. #elif (LCD_CONTROLLER == 8535) /* PCF8535 */
  178.   static U8 _aMirror[256] = {
  179.     ________, X_______, _X______, XX______, __X_____, X_X_____, _XX_____, XXX_____,
  180.     ___X____, X__X____, _X_X____, XX_X____, __XX____, X_XX____, _XXX____, XXXX____,
  181.     ____X___, X___X___, _X__X___, XX__X___, __X_X___, X_X_X___, _XX_X___, XXX_X___,
  182.     ___XX___, X__XX___, _X_XX___, XX_XX___, __XXX___, X_XXX___, _XXXX___, XXXXX___,
  183.     _____X__, X____X__, _X___X__, XX___X__, __X__X__, X_X__X__, _XX__X__, XXX__X__,
  184.     ___X_X__, X__X_X__, _X_X_X__, XX_X_X__, __XX_X__, X_XX_X__, _XXX_X__, XXXX_X__,
  185.     ____XX__, X___XX__, _X__XX__, XX__XX__, __X_XX__, X_X_XX__, _XX_XX__, XXX_XX__,
  186.     ___XXX__, X__XXX__, _X_XXX__, XX_XXX__, __XXXX__, X_XXXX__, _XXXXX__, XXXXXX__,
  187.     ______X_, X_____X_, _X____X_, XX____X_, __X___X_, X_X___X_, _XX___X_, XXX___X_,
  188.     ___X__X_, X__X__X_, _X_X__X_, XX_X__X_, __XX__X_, X_XX__X_, _XXX__X_, XXXX__X_,
  189.     ____X_X_, X___X_X_, _X__X_X_, XX__X_X_, __X_X_X_, X_X_X_X_, _XX_X_X_, XXX_X_X_,
  190.     ___XX_X_, X__XX_X_, _X_XX_X_, XX_XX_X_, __XXX_X_, X_XXX_X_, _XXXX_X_, XXXXX_X_,
  191.     _____XX_, X____XX_, _X___XX_, XX___XX_, __X__XX_, X_X__XX_, _XX__XX_, XXX__XX_,
  192.     ___X_XX_, X__X_XX_, _X_X_XX_, XX_X_XX_, __XX_XX_, X_XX_XX_, _XXX_XX_, XXXX_XX_,
  193.     ____XXX_, X___XXX_, _X__XXX_, XX__XXX_, __X_XXX_, X_X_XXX_, _XX_XXX_, XXX_XXX_,
  194.     ___XXXX_, X__XXXX_, _X_XXXX_, XX_XXXX_, __XXXXX_, X_XXXXX_, _XXXXXX_, XXXXXXX_,
  195.     _______X, X______X, _X_____X, XX_____X, __X____X, X_X____X, _XX____X, XXX____X,
  196.     ___X___X, X__X___X, _X_X___X, XX_X___X, __XX___X, X_XX___X, _XXX___X, XXXX___X,
  197.     ____X__X, X___X__X, _X__X__X, XX__X__X, __X_X__X, X_X_X__X, _XX_X__X, XXX_X__X,
  198.     ___XX__X, X__XX__X, _X_XX__X, XX_XX__X, __XXX__X, X_XXX__X, _XXXX__X, XXXXX__X,
  199.     _____X_X, X____X_X, _X___X_X, XX___X_X, __X__X_X, X_X__X_X, _XX__X_X, XXX__X_X,
  200.     ___X_X_X, X__X_X_X, _X_X_X_X, XX_X_X_X, __XX_X_X, X_XX_X_X, _XXX_X_X, XXXX_X_X,
  201.     ____XX_X, X___XX_X, _X__XX_X, XX__XX_X, __X_XX_X, X_X_XX_X, _XX_XX_X, XXX_XX_X,
  202.     ___XXX_X, X__XXX_X, _X_XXX_X, XX_XXX_X, __XXXX_X, X_XXXX_X, _XXXXX_X, XXXXXX_X,
  203.     ______XX, X_____XX, _X____XX, XX____XX, __X___XX, X_X___XX, _XX___XX, XXX___XX,
  204.     ___X__XX, X__X__XX, _X_X__XX, XX_X__XX, __XX__XX, X_XX__XX, _XXX__XX, XXXX__XX,
  205.     ____X_XX, X___X_XX, _X__X_XX, XX__X_XX, __X_X_XX, X_X_X_XX, _XX_X_XX, XXX_X_XX,
  206.     ___XX_XX, X__XX_XX, _X_XX_XX, XX_XX_XX, __XXX_XX, X_XXX_XX, _XXXX_XX, XXXXX_XX,
  207.     _____XXX, X____XXX, _X___XXX, XX___XXX, __X__XXX, X_X__XXX, _XX__XXX, XXX__XXX,
  208.     ___X_XXX, X__X_XXX, _X_X_XXX, XX_X_XXX, __XX_XXX, X_XX_XXX, _XXX_XXX, XXXX_XXX,
  209.     ____XXXX, X___XXXX, _X__XXXX, XX__XXXX, __X_XXXX, X_X_XXXX, _XX_XXXX, XXX_XXXX,
  210.     ___XXXXX, X__XXXXX, _X_XXXXX, XX_XXXXX, __XXXXXX, X_XXXXXX, _XXXXXXX, XXXXXXXX
  211.   };
  213.   #define MAX_PAGE             9
  214.   #define MAX_OFFSET           133
  215.   #define WAIT_WHILE_BUSY()    { U8 Status; do { LCD_READ_A0(Status); } while (Status & (1 << 7)); }
  216.   #define WRITE_DATA(Data)     CHECK_BUSY();                 
  217.                                LCD_WRITE_A1(_aMirror[Data]); 
  218.                                _VRam[_Page][_Offset] = Data
  219.   #define LCD_ON()
  220.   #define LCD_OFF()
  221.   #define SET_PAGE(Page)       CHECK_BUSY(); LCD_WRITE_A0(0x40 + Page)
  222.   #define SET_OFFSET(Offset)   CHECK_BUSY();                                             
  223.                                LCD_WRITE_A0(0x20 + (((Offset + LCD_XOFF) & 0x80) >> 5)); 
  224.                                LCD_WRITE_A0(0x80 +  ((Offset + LCD_XOFF) & 0x7F))
  226. #endif
  228. #define SET_PAGE_IF_NEEDED(Page)          _SetPageIfNeeded(Page)     /* Function call only in debug version */
  229. #define SET_OFFSET_IF_NEEDED(Offset)      _SetOffsetIfNeeded(Offset) /* Function call only in debug version */
  230. #define WRITE_DATA1(Data)                 _WriteData1(Data)          /* Function call only in debug version */
  231. #define WRITE_DATAM(pData, NumberOfBytes) _WriteDataM(pData, NumberOfBytes)
  232. #define GET_CURRENT_BYTE()                _VRam[_Page][_Offset]
  233. #define GET_BYTE(Page, Offset)            _VRam[Page][Offset]
  235. #if !LCD_CACHE
  236.   #error Not yet supported!
  237. #endif
  239. /*********************************************************************
  240. *
  241. *       Static data
  242. *
  243. **********************************************************************
  244. */
  246. static int _Page, _Offset;
  247. #if LCD_CACHE
  248.   static U8 _VRam[MAX_PAGE][MAX_OFFSET];
  249. #endif
  250. static const LCD_PIXELINDEX _ConversionTable[2] = {0, 1};
  252. /*********************************************************************
  253. *
  254. *       Static functions
  255. *
  256. **********************************************************************
  257. */
  259. #if defined(INCREMENT_XY_VOLATILE)
  261. static int _VolatileOffset, _VolatilePage;
  263. static void _SetPageIfNeeded(int Page) {
  264.   if (_Page == Page)
  265.     return;
  266.   _Page = Page;
  267.   SET_PAGE(_Page);
  268.   _VolatilePage = 0;
  269.   if (_VolatileOffset) {
  270.     SET_OFFSET(_Offset);
  271.     _VolatileOffset = 0;
  272.   }
  273. }
  275. static void _SetOffsetIfNeeded(int Offset) {
  276.   if (_Offset == Offset)
  277.     return;
  278.   _Offset = Offset;
  279.   SET_OFFSET(_Offset);
  280.   _VolatileOffset = 0;
  281.   if (_VolatilePage) {
  282.     SET_PAGE(_Page);
  283.     _VolatilePage = 0;
  284.   }
  285. }
  287. static void _WriteData1(U8 Data) {
  288.   WRITE_DATA(Data);
  289.   _Offset++;
  290.   _VolatileOffset = 1;
  291.   if (_Offset == MAX_OFFSET) {
  292.     _Offset = 0;
  293.     _VolatilePage = 1;
  294.     if (_Page < (MAX_PAGE - 1)) {
  295.       ++_Page;
  296.     } else {
  297.       _Page = 0;
  298.     }
  299.   }
  300. }
  302. static void _WriteDataM(U8 * pData, int NumberOfBytes) {
  303.   LCD_WRITEM_A1(pData, NumberOfBytes);
  304.   _Offset += NumberOfBytes;
  305.   _VolatileOffset = 1;
  306.   if (_Offset == MAX_OFFSET) {
  307.     _Offset = 0;
  308.     _VolatilePage = 1;
  309.     if (_Page < (MAX_PAGE - 1)) {
  310.       ++_Page;
  311.     } else {
  312.       _Page = 0;
  313.     }
  314.   }
  315. }
  317. #elif defined(INCREMENT_XY)
  319. static void _SetPageIfNeeded(int Page) {
  320.   if (_Page == Page)
  321.     return;
  322.   _Page = Page;
  323.   SET_PAGE(_Page);
  324. }
  326. static void _SetOffsetIfNeeded(int Offset) {
  327.   if (_Offset == Offset)
  328.     return;
  329.   _Offset = Offset;
  330.   SET_OFFSET(_Offset);
  331. }
  333. static void _WriteData1(U8 Data) {
  334.   WRITE_DATA(Data);
  335.   _Offset++;
  336.   if (_Offset == MAX_OFFSET) {
  337.     _Offset = 0;
  338.     if (_Page < (MAX_PAGE - 1)) {
  339.       ++_Page;
  340.     } else {
  341.       _Page = 0;
  342.     }
  343.   }
  344. }
  346. static void _WriteDataM(U8 * pData, int NumberOfBytes) {
  347.   LCD_WRITEM_A1(pData, NumberOfBytes);
  348.   _Offset += NumberOfBytes;
  349.   if (_Offset == MAX_OFFSET) {
  350.     _Offset = 0;
  351.     if (_Page < (MAX_PAGE - 1)) {
  352.       ++_Page;
  353.     } else {
  354.       _Page = 0;
  355.     }
  356.   }
  357. }
  359. #else
  361. static void _SetPageIfNeeded(int Page) {
  362.   _Page = Page;
  363.   SET_PAGE(_Page);
  364. }
  366. static void _SetOffsetIfNeeded(int Offset) {
  367.   _Offset = Offset;
  368.   SET_OFFSET(_Offset);
  369. }
  371. static void _WriteData1(U8 Data) {
  372.   WRITE_DATA(Data);
  373. }
  375. static void _WriteDataM(U8 * pData, int NumberOfBytes) {
  376.   while(NumberOfBytes) {
  377.     WRITE_DATA(*pData);
  378.     if (--NumberOfBytes) {
  379.       pData++;
  380.       _Offset++;
  381.       SET_OFFSET(_Offset);
  382.     }
  383.   }
  384. }
  386. #endif
  388. /*********************************************
  389. *
  390. *       Draw Bitmap 1 BPP (optimized)
  391. *
  392. **********************************************
  393. */
  395. #if LCD_OPTIMIZE 
  396.   && !LCD_SWAP_XY 
  397.   && !LCD_MIRROR_X 
  398.   && !LCD_MIRROR_Y
  400. static void _DrawBitLine1BPP(int x, int y, U8 const * pData, int ysize, const LCD_PIXELINDEX * pTrans, int BytesPerLine, U8 DataMask) {
  401.   LCD_PIXELINDEX Index0 = *(pTrans + 0);
  402.   LCD_PIXELINDEX Index1 = *(pTrans + 1);
  403.   U8 PixelMask = 1 << (y & 7);
  404.   int Page = y >> 3;
  405.   U8 Data;
  406.   Data = _VRam[Page][x];
  407.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  408.     case 0:
  409.       while(ysize--) {
  410.         if (*pData & DataMask) {
  411.           if (Index1) {
  412.             Data |= PixelMask;
  413.           } else {
  414.             Data &= ~PixelMask;
  415.           }
  416.         } else {
  417.           if (Index0) {
  418.             Data |= PixelMask;
  419.           } else {
  420.             Data &= ~PixelMask;
  421.           }
  422.         }
  423.         pData += BytesPerLine;
  424.         PixelMask <<= 1;
  425.         if (!PixelMask || !ysize) {
  426.           _VRam[Page][x] = Data;
  427.           if (ysize) {
  428.             PixelMask = 1;
  429.             Data = _VRam[++Page][x];
  430.           }
  431.         }
  432.       }
  433.       break;
  434.     case LCD_DRAWMODE_TRANS:
  435.       while(ysize--) {
  436.         if (*pData & DataMask) {
  437.           if (Index1) {
  438.             Data |= PixelMask;
  439.           } else {
  440.             Data &= ~PixelMask;
  441.           }
  442.         }
  443.         pData += BytesPerLine;
  444.         PixelMask <<= 1;
  445.         if (!PixelMask || !ysize) {
  446.           _VRam[Page][x] = Data;
  447.           if (ysize) {
  448.             PixelMask = 1;
  449.             Data = _VRam[++Page][x];
  450.           }
  451.         }
  452.       }
  453.       break;
  454.     case LCD_DRAWMODE_XOR:
  455.       while(ysize--) {
  456.         if (*pData & DataMask) {
  457.           Data ^= PixelMask;
  458.         }
  459.         pData += BytesPerLine;
  460.         PixelMask <<= 1;
  461.         if (!PixelMask || !ysize) {
  462.           _VRam[Page][x] = Data;
  463.           if (ysize) {
  464.             PixelMask = 1;
  465.             Data = _VRam[++Page][x];
  466.           }
  467.         }
  468.       }
  469.       break;
  470. }
  471. }
  473. /*********************************************
  474. *
  475. *       Draw Bitmap 1 BPP (not optimized)
  476. *
  477. **********************************************
  478. */
  480. #else
  482. static void _DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  483.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  484.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  485.   x += Diff;
  486.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  487.     case 0:
  488.       do {
  489.         LCD_L0_SetPixelIndex(x++, y, (*p & (0x80 >> Diff)) ? Index1 : Index0);
  490.   if (++Diff == 8) {
  491.           Diff = 0;
  492.   p++;
  493.   }
  494.   } while (--xsize);
  495.       break;
  496.     case LCD_DRAWMODE_TRANS:
  497.       do {
  498.      if (*p & (0x80 >> Diff))
  499.           LCD_L0_SetPixelIndex(x, y, Index1);
  500.         x++;
  501.   if (++Diff == 8) {
  502.           Diff = 0;
  503.   p++;
  504.   }
  505.   } while (--xsize);
  506.       break;
  507.     case LCD_DRAWMODE_XOR:;
  508.       do {
  509.      if (*p & (0x80 >> Diff)) {
  510.           int Pixel = LCD_L0_GetPixelIndex(x, y);
  511.           LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - 1 - Pixel);
  512.         }
  513.         x++;
  514.   if (++Diff == 8) {
  515.           Diff = 0;
  516.   p++;
  517.   }
  518.   } while (--xsize);
  519.       break;
  520. }
  521. }
  523. #endif
  525. /*********************************************
  526. *
  527. *       Draw Bitmap 2 BPP
  528. *
  529. **********************************************
  530. */
  532. #if (LCD_MAX_LOG_COLORS > 2)
  533. static void _DrawBitLine2BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  534.   LCD_PIXELINDEX Pixels = *p;
  535.   int CurrentPixel = Diff;
  536.   x += Diff;
  537.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  538.     case 0:
  539.       do {
  540.         int Shift = (3 - CurrentPixel) << 1;
  541.         int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
  542.         LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  543.         LCD_L0_SetPixelIndex(x++, y, PixelIndex);
  544.         if (++CurrentPixel == 4) {
  545.           CurrentPixel = 0;
  546.           Pixels = *(++p);
  547.         }
  548.   } while (--xsize);
  549.       break;
  550.     case LCD_DRAWMODE_TRANS:
  551.       do {
  552.         int Shift = (3 - CurrentPixel) << 1;
  553.         int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
  554.         if (Index) {
  555.           LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  556.           LCD_L0_SetPixelIndex(x, y, PixelIndex);
  557.         }
  558.         x++;
  559.         if (++CurrentPixel == 4) {
  560.           CurrentPixel = 0;
  561.           Pixels = *(++p);
  562.         }
  563.   } while (--xsize);
  564.       break;
  565.   }
  566. }
  567. #endif
  569. /*********************************************
  570. *
  571. *       Draw Bitmap 4 BPP
  572. *
  573. **********************************************
  574. */
  576. #if (LCD_MAX_LOG_COLORS > 4)
  577. static void _DrawBitLine4BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  578.   LCD_PIXELINDEX Pixels = *p;
  579.   int CurrentPixel = Diff;
  580.   x += Diff;
  581.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  582.     case 0:
  583.       do {
  584.         int Shift = (1 - CurrentPixel) << 2;
  585.         int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
  586.         LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  587.         LCD_L0_SetPixelIndex(x++, y, PixelIndex);
  588.         if (++CurrentPixel == 2) {
  589.           CurrentPixel = 0;
  590.           Pixels = *(++p);
  591.         }
  592.   } while (--xsize);
  593.       break;
  594.     case LCD_DRAWMODE_TRANS:
  595.       do {
  596.         int Shift = (1 - CurrentPixel) << 2;
  597.         int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
  598.         if (Index) {
  599.           LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  600.           LCD_L0_SetPixelIndex(x, y, PixelIndex);
  601.         }
  602.         x++;
  603.         if (++CurrentPixel == 2) {
  604.           CurrentPixel = 0;
  605.           Pixels = *(++p);
  606.         }
  607.   } while (--xsize);
  608.       break;
  609.   }
  610. }
  611. #endif
  613. /*********************************************
  614. *
  615. *       Draw Bitmap 8 BPP (optimized)
  616. *
  617. **********************************************
  618. */
  620. #if (LCD_MAX_LOG_COLORS > 16)
  622. #if LCD_OPTIMIZE 
  623.   && !LCD_SWAP_XY 
  624.   && !LCD_MIRROR_X 
  625.   && !LCD_MIRROR_Y
  627. static void _DrawBitLine8BPP(int x, int y, U8 const * pData, int ysize, const LCD_PIXELINDEX * pTrans, int BytesPerLine) {
  628.   U8 PixelMask = 1 << (y & 7);
  629.   int Page = y >> 3;
  630.   U8 Data = _VRam[Page][x];
  631.   if (!pTrans)
  632.     pTrans = _ConversionTable;
  633.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  634.     case 0:
  635.       while(ysize--) {
  636.         if (*(pTrans + *pData)) {
  637.           Data |= PixelMask;
  638.         } else {
  639.           Data &= ~PixelMask;
  640.         }
  641.         pData += BytesPerLine;
  642.         PixelMask <<= 1;
  643.         if (!PixelMask || !ysize) {
  644.           _VRam[Page][x] = Data;
  645.           if (ysize) {
  646.             PixelMask = 1;
  647.             Data = _VRam[++Page][x];
  648.           }
  649.         }
  650.       }
  651.       break;
  652.     case LCD_DRAWMODE_TRANS:
  653.       while(ysize--) {
  654.         LCD_PIXELINDEX Pixel = *pData;
  655.         if (Pixel) {
  656.           if (*(pTrans + Pixel)) {
  657.             Data |= PixelMask;
  658.           } else {
  659.             Data &= ~PixelMask;
  660.           }
  661.         }
  662.         pData += BytesPerLine;
  663.         PixelMask <<= 1;
  664.         if (!PixelMask || !ysize) {
  665.           _VRam[Page][x] = Data;
  666.           if (ysize) {
  667.             PixelMask = 1;
  668.             Data = _VRam[++Page][x];
  669.           }
  670.         }
  671.       }
  672.       break;
  673. }
  674. }
  676. /*********************************************
  677. *
  678. *       Draw Bitmap 8 BPP (not optimized)
  679. *
  680. **********************************************
  681. */
  683. #else
  685. static void _DrawBitLine8BPP(int x, int y, U8 const * p, int xsize, const LCD_PIXELINDEX * pTrans) {
  686.   LCD_PIXELINDEX Pixel;
  687.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  688.     case 0:
  689.       if (pTrans) {
  690.         for (; xsize > 0; xsize--, x++, p++) {
  691.           Pixel = *p;
  692.           LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  693.         }
  694.       } else {
  695.         for (; xsize > 0; xsize--, x++, p++) {
  696.           LCD_L0_SetPixelIndex(x, y, *p);
  697.         }
  698.       }
  699.       break;
  700.     case LCD_DRAWMODE_TRANS:
  701.       if (pTrans) {
  702.         for (; xsize > 0; xsize--, x++, p++) {
  703.           Pixel = *p;
  704.           if (Pixel) {
  705.             LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  706.           }
  707.         }
  708.       } else {
  709.         for (; xsize > 0; xsize--, x++, p++) {
  710.           Pixel = *p;
  711.           if (Pixel) {
  712.             LCD_L0_SetPixelIndex(x, y, Pixel);
  713.           }
  714.         }
  715.       }
  716.       break;
  717.   }
  718. }
  719. #endif
  721. #endif
  723. /*********************************************
  724. *
  725. *       Draw Bitmap 16 BPP
  726. *
  727. **********************************************
  728. */
  730. #if (LCD_BITSPERPIXEL > 8)
  731. static void _DrawBitLine16BPP(int x, int y, U16 const * p, int xsize, const LCD_PIXELINDEX * pTrans) {
  732.   LCD_PIXELINDEX Pixel;
  733.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  734.     case 0:
  735.       if (pTrans) {
  736.         for (; xsize > 0; xsize--, x++, p++) {
  737.           Pixel = *p;
  738.           LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  739.         }
  740.       } else {
  741.         for (; xsize > 0; xsize--, x++, p++) {
  742.           LCD_L0_SetPixelIndex(x, y, *p);
  743.         }
  744.       }
  745.       break;
  746.     case LCD_DRAWMODE_TRANS:
  747.       if (pTrans) {
  748.         for (; xsize > 0; xsize--, x++, p++) {
  749.           Pixel = *p;
  750.           if (Pixel) {
  751.             LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  752.           }
  753.         }
  754.       } else {
  755.         for (; xsize > 0; xsize--, x++, p++) {
  756.           Pixel = *p;
  757.           if (Pixel) {
  758.             LCD_L0_SetPixelIndex(x, y, Pixel);
  759.           }
  760.         }
  761.       }
  762.       break;
  763.   }
  764. }
  765. #endif
  767. /*********************************************************************
  768. *
  769. *       Exported functions
  770. *
  771. **********************************************************************
  772. */
  774. /*********************************************
  775. *
  776. *       LCD_L0_SetPixelIndex
  777. *
  778. **********************************************
  779. */
  781. void LCD_L0_SetPixelIndex(int x, int y, int PixelIndex) {
  782.   /* Convert logical into physical coordinates (Dep. on LCDConf.h) */
  783.   #if LCD_SWAP_XY | LCD_MIRROR_X | LCD_MIRROR_Y
  784.     int xPhys = LOG2PHYS_X(x, y);
  785.     int yPhys = LOG2PHYS_Y(x, y);
  786.   #else
  787.     #define xPhys x
  788.     #define yPhys y
  789.   #endif
  790.   /* Write into hardware */
  791.   {
  792.     U8 Data = GET_BYTE(yPhys >> 3, xPhys);
  793.     U8 AndMask = ~(1 << (yPhys & 7));
  794.     U8 OrMask  = PixelIndex << (yPhys & 7);
  795.     Data &= AndMask;
  796.     Data |= OrMask;
  797.     SET_PAGE_IF_NEEDED(yPhys >> 3);
  798.     SET_OFFSET_IF_NEEDED(xPhys);
  799.     WRITE_DATA1(Data);
  800.   }
  801. }
  803. /*********************************************
  804. *
  805. *       LCD_L0_GetPixelIndex
  806. *
  807. **********************************************
  808. */
  810. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  811.   /* Convert logical into physical coordinates (Dep. on LCDConf.h) */
  812.   #if LCD_SWAP_XY | LCD_MIRROR_X| LCD_MIRROR_Y
  813.     int xPhys = LOG2PHYS_X(x, y);
  814.     int yPhys = LOG2PHYS_Y(x, y);
  815.   #else
  816.     #define xPhys x
  817.     #define yPhys y
  818.   #endif
  819.   /* Read from hardware */
  820.   {
  821.     U8 Data = GET_BYTE(yPhys >> 3, xPhys);
  822.     return (Data & (1 << (yPhys & 7))) ? 1 : 0;
  823.   }
  824. }
  826. /*********************************************
  827. *
  828. *       LCD_L0_XorPixel
  829. *
  830. **********************************************
  831. */
  833. void LCD_L0_XorPixel(int x, int y) {
  834.   LCD_PIXELINDEX PixelIndex = LCD_L0_GetPixelIndex(x, y);
  835.   LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - PixelIndex - 1);
  836. }
  838. /*********************************************
  839. *
  840. *       LCD_L0_DrawHLine (optimized)
  841. *
  842. **********************************************
  843. */
  845. #if LCD_OPTIMIZE 
  846.   && !LCD_SWAP_XY 
  847.   && !LCD_MIRROR_X 
  848.   && !LCD_MIRROR_Y
  850. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  851.   #if LCD_CACHE
  852.     U8 Mask = 1 << (y & 7);
  853.     int Page = y >> 3;
  854.     U8 * pData = &_VRam[Page][x0];
  855.     int NumberOfBytes = x1 - x0 + 1;
  856.     SET_PAGE_IF_NEEDED(Page);
  857.     SET_OFFSET_IF_NEEDED(x0);
  858.     for (; x0 <= x1; x0++) {
  859.       if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  860.         _VRam[Page][x0] ^= Mask;
  861.       } else {
  862.         if (LCD_COLORINDEX) {
  863.           _VRam[Page][x0] |= Mask;
  864.         } else {
  865.           _VRam[Page][x0] &= ~Mask;
  866.         }
  867.       }
  868.     }
  869.     WRITE_DATAM(pData, NumberOfBytes);
  870.   #else
  871.     U8 Mask = 1 << (y & 7);
  872.     SET_PAGE_IF_NEEDED(y >> 3);
  873.     SET_OFFSET_IF_NEEDED(x0);
  874.     for (; x0 <= x1; x0++) {
  875.       U8 Data = GET_CURRENT_BYTE();
  876.       if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  877.         WRITE_DATA1(Data ^ Mask);
  878.       } else {
  879.         WRITE_DATA1((LCD_COLORINDEX) ? Data | Mask : Data & ~Mask);
  880.       }
  881.     }
  882.   #endif
  883. }
  885. /*********************************************
  886. *
  887. *       LCD_L0_DrawHLine (not optimized)
  888. *
  889. **********************************************
  890. */
  892. #else
  894. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  895.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  896.     for (; x0 <= x1; x0++) {
  897.       LCD_L0_XorPixel(x0, y);
  898.     }
  899.   } else {
  900.     for (; x0 <= x1; x0++) {
  901.       LCD_L0_SetPixelIndex(x0, y, LCD_COLORINDEX);
  902.     }
  903.   }
  904. }
  906. #endif
  908. /*********************************************
  909. *
  910. *       LCD_L0_DrawVLine (optimized)
  911. *
  912. **********************************************
  913. */
  915. #if LCD_OPTIMIZE 
  916.   && !LCD_SWAP_XY 
  917.   && !LCD_MIRROR_X 
  918.   && !LCD_MIRROR_Y
  920. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  921.   int y0_ = y0 & 7;
  922.   int y1_ = (y1 + 1) & 7;
  923.   if (y0_) {
  924.     U8 Data = GET_BYTE(y0 >> 3, x);
  925.     U8 Mask = 0xff << y0_;
  926.     if ((y0 >> 3) == (y1 >> 3)) {
  927.       Mask &= 0xff >> (7 - (y1 & 7));
  928.     }
  929.     SET_PAGE_IF_NEEDED(y0 >> 3);
  930.     SET_OFFSET_IF_NEEDED(x);
  931.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  932.       WRITE_DATA1(Data ^ Mask);
  933.     } else {
  934.       WRITE_DATA1((LCD_COLORINDEX) ? Data | Mask : Data & ~Mask);
  935.     }
  936.     if ((y0 & 0xfff8) == (y1 & 0xfff8)) {
  937.       return;
  938.     }
  939.   }
  940.   {
  941.     int Page     =  ((y0 + 7) & 0xfff8) >> 3;
  942.     int NumPages = (((y1 + 1) & 0xfff8) >> 3) - Page;
  943.     if (NumPages) {
  944.       while (NumPages--) {
  945.         SET_PAGE_IF_NEEDED(Page++);
  946.         SET_OFFSET_IF_NEEDED(x);
  947.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  948.           WRITE_DATA1(GET_CURRENT_BYTE() ^ 0xff);
  949.         } else {
  950.           WRITE_DATA1((LCD_COLORINDEX) ? 0xff : 0x00);
  951.         }
  952.       }
  953.     }
  954.   }
  955.   if (y1_) {
  956.     U8 Data = GET_BYTE(y1 >> 3, x);
  957.     U8 Mask = 0xff >> (8 - y1_);
  958.     SET_PAGE_IF_NEEDED(y1 >> 3);
  959.     SET_OFFSET_IF_NEEDED(x);
  960.     if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  961.       WRITE_DATA1(Data ^ Mask);
  962.     } else {
  963.       WRITE_DATA1((LCD_COLORINDEX) ? Data | Mask : Data & ~Mask);
  964.     }
  965.   }
  966. }
  968. /*********************************************
  969. *
  970. *       LCD_L0_DrawVLine (not optimized)
  971. *
  972. **********************************************
  973. */
  975. #else
  977. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  978.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  979.     for (; y0 <= y1; y0++) {
  980.       LCD_L0_XorPixel(x, y0);
  981.     }
  982.   } else {
  983.     for (; y0 <= y1; y0++) {
  984.       LCD_L0_SetPixelIndex(x, y0, LCD_COLORINDEX);
  985.     }
  986.   }
  987. }
  989. #endif
  991. /*********************************************
  992. *
  993. *       LCD_L0_FillRect (optimized)
  994. *
  995. **********************************************
  996. */
  998. #if LCD_OPTIMIZE 
  999.   && !LCD_SWAP_XY 
  1000.   && !LCD_MIRROR_X 
  1001.   && !LCD_MIRROR_Y
  1003. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  1004.   #if LCD_CACHE
  1005.     int y0_ = y0 & 7;
  1006.     int y1_ = (y1 + 1) & 7;
  1007.     int NumberOfBytes = x1 - x0 + 1;
  1008.     if (y0_) {
  1009.       U8 * pData;
  1010.       int x0_ = x0;
  1011.       U8 Mask = 0xff << y0_;
  1012.       int Page = y0 >> 3;
  1013.       if ((y0 & 0xfff8) == ((y1 + 1) & 0xfff8)) {
  1014.         Mask &= 0xff >> (8 - y1_);
  1015.       }
  1016.       SET_PAGE_IF_NEEDED(Page);
  1017.       SET_OFFSET_IF_NEEDED(x0);
  1018.       pData = &_VRam[_Page][_Offset];
  1019.       for (; x0_ <= x1; x0_++) {
  1020.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1021.           _VRam[Page][x0_] ^= Mask;
  1022.         } else {
  1023.           if (LCD_COLORINDEX) {
  1024.             _VRam[Page][x0_] |= Mask;
  1025.           } else {
  1026.             _VRam[Page][x0_] &= ~Mask;
  1027.           }
  1028.         }
  1029.       }
  1030.       WRITE_DATAM(pData, NumberOfBytes);
  1031.       if ((y0 & 0xfff8) == (y1 & 0xfff8)) {
  1032.         return;
  1033.       }
  1034.     }
  1035.     {
  1036.       int Page     =  ((y0 + 7) & 0xfff8) >> 3;
  1037.       int NumPages = (((y1 + 1) & 0xfff8) >> 3) - Page;
  1038.       if (NumPages) {
  1039.         while (NumPages--) {
  1040.           U8 * pData;
  1041.           int x0_ = x0;
  1042.           SET_PAGE_IF_NEEDED(Page++);
  1043.           SET_OFFSET_IF_NEEDED(x0);
  1044.           pData = &_VRam[_Page][_Offset];
  1045.           for (; x0_ <= x1; x0_++) {
  1046.             if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1047.               _VRam[_Page][x0_] ^= 0xff;
  1048.             } else {
  1049.               if (LCD_COLORINDEX) {
  1050.                 _VRam[_Page][x0_] = 0xff;
  1051.               } else {
  1052.                 _VRam[_Page][x0_] = 0x00;
  1053.               }
  1054.             }
  1055.           }
  1056.           WRITE_DATAM(pData, NumberOfBytes);
  1057.         }
  1058.       }
  1059.     }
  1060.     if (y1_) {
  1061.       U8 * pData;
  1062.       int x0_ = x0;
  1063.       U8 Mask = 0xff >> (8 - y1_);
  1064.       int Page = y1 >> 3;
  1065.       SET_PAGE_IF_NEEDED(Page);
  1066.       SET_OFFSET_IF_NEEDED(x0);
  1067.       pData = &_VRam[Page][_Offset];
  1068.       for (; x0_ <= x1; x0_++) {
  1069.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1070.           _VRam[Page][x0_] ^= Mask;
  1071.         } else {
  1072.           if (LCD_COLORINDEX) {
  1073.             _VRam[Page][x0_] |= Mask;
  1074.           } else {
  1075.             _VRam[Page][x0_] &= ~Mask;
  1076.           }
  1077.         }
  1078.       }
  1079.       WRITE_DATAM(pData, NumberOfBytes);
  1080.     }
  1081.   #else
  1082.     int y0_ = y0 & 7;
  1083.     int y1_ = (y1 + 1) & 7;
  1084.     if (y0_) {
  1085.       int x0_ = x0;
  1086.       U8 Mask = 0xff << y0_;
  1087.       if ((y0 & 0xfff8) == (y1 & 0xfff8)) {
  1088.         Mask &= 0xff >> (8 - y1_);
  1089.       }
  1090.       SET_PAGE_IF_NEEDED(y0 >> 3);
  1091.       SET_OFFSET_IF_NEEDED(x0);
  1092.       for (; x0_ <= x1; x0_++) {
  1093.         U8 Data = GET_CURRENT_BYTE();
  1094.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1095.           WRITE_DATA1(Data ^ Mask);
  1096.         } else {
  1097.           WRITE_DATA1((LCD_COLORINDEX) ? Data | Mask : Data & ~Mask);
  1098.         }
  1099.       }
  1100.       if ((y0 & 0xfff8) == (y1 & 0xfff8)) {
  1101.         return;
  1102.       }
  1103.     }
  1104.     {
  1105.       int Page     =  ((y0 + 7) & 0xfff8) >> 3;
  1106.       int NumPages = (((y1 + 1) & 0xfff8) >> 3) - Page;
  1107.       if (NumPages) {
  1108.         while (NumPages--) {
  1109.           int x0_ = x0;
  1110.           SET_PAGE_IF_NEEDED(Page++);
  1111.           SET_OFFSET_IF_NEEDED(x0);
  1112.           for (; x0_ <= x1; x0_++) {
  1113.             if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1114.               WRITE_DATA1(GET_CURRENT_BYTE() ^ 0xff);
  1115.             } else {
  1116.               WRITE_DATA1((LCD_COLORINDEX) ? 0xff : 0x00);
  1117.             }
  1118.           }
  1119.         }
  1120.       }
  1121.     }
  1122.     if (y1_) {
  1123.       int x0_ = x0;
  1124.       U8 Mask = 0xff >> (8 - y1_);
  1125.       SET_PAGE_IF_NEEDED(y1 >> 3);
  1126.       SET_OFFSET_IF_NEEDED(x0);
  1127.       for (; x0_ <= x1; x0_++) {
  1128.         U8 Data = GET_CURRENT_BYTE();
  1129.         if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  1130.           WRITE_DATA1(Data ^ Mask);
  1131.         } else {
  1132.           WRITE_DATA1((LCD_COLORINDEX) ? Data | Mask : Data & ~Mask);
  1133.         }
  1134.       }
  1135.     }
  1136.   #endif
  1137. }
  1139. /*********************************************
  1140. *
  1141. *       LCD_L0_FillRect (not optimized)
  1142. *
  1143. **********************************************
  1144. */
  1146. #else
  1148. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  1149.   for (; y0 <= y1; y0++) {
  1150.     LCD_L0_DrawHLine(x0, y0, x1);
  1151.   }
  1152. }
  1154. #endif
  1156. /*********************************************
  1157. *
  1158. *       LCD_L0_DrawBitmap
  1159. *
  1160. **********************************************
  1161. */
  1163. void LCD_L0_DrawBitmap(int x0, int y0,
  1164.                        int xsize, int ysize,
  1165.                        int BitsPerPixel, 
  1166.                        int BytesPerLine,
  1167.                        const U8* pData, int Diff,
  1168.                        const LCD_PIXELINDEX* pTrans)
  1169. {
  1170.   int i;
  1171.   #if LCD_OPTIMIZE 
  1172.     && !LCD_SWAP_XY 
  1173.     && !LCD_MIRROR_X 
  1174.     && !LCD_MIRROR_Y
  1175.     int Page0 = y0 >> 3;
  1176.     int Page1 = (y0 + ysize - 1) >> 3;
  1177.     int Opt = 0;
  1178.     switch (BitsPerPixel) {
  1179.       case 1:
  1180.         Opt = 1;
  1181.         xsize += Diff & 7;
  1182.         for (i = Diff; i < xsize; i++) {
  1183.           _DrawBitLine1BPP(x0 + i, y0, pData + (i >> 3), ysize, pTrans, BytesPerLine, 0x80 >> (i & 7));
  1184.         }
  1185.         break;
  1186.       case 8:
  1187.         Opt = 1;
  1188.         for (i = Diff; i < xsize; i++) {
  1189.           _DrawBitLine8BPP(x0 + i, y0, pData + i, ysize, pTrans, BytesPerLine);
  1190.         }
  1191.         break;
  1192.     }
  1193.     if (Opt) {
  1194.       for (; Page0 <= Page1; Page0++) {
  1195.         U8 * p = &_VRam[Page0][x0];
  1196.         SET_PAGE_IF_NEEDED(Page0);
  1197.         SET_OFFSET_IF_NEEDED(x0);
  1198.         WRITE_DATAM(p, xsize);
  1199.       }
  1200.       return;
  1201.     }
  1202.   #endif
  1203.   /* Use _DrawBitLineXBPP */
  1204.   for (i=0; i<ysize; i++) {
  1205.     switch (BitsPerPixel) {
  1206.       #if !LCD_OPTIMIZE 
  1207.         || LCD_SWAP_XY 
  1208.         || LCD_MIRROR_X 
  1209.         || LCD_MIRROR_Y
  1210.         case 1:
  1211.           _DrawBitLine1BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1212.           break;
  1213.       #endif
  1214.       #if (LCD_MAX_LOG_COLORS > 2)
  1215.         case 2:
  1216.           _DrawBitLine2BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1217.           break;
  1218.       #endif
  1219.       #if (LCD_MAX_LOG_COLORS > 4)
  1220.         case 4:
  1221.           _DrawBitLine4BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  1222.           break;
  1223.       #endif
  1224.       #if (LCD_MAX_LOG_COLORS > 16)
  1225.         #if !LCD_OPTIMIZE 
  1226.           || LCD_SWAP_XY 
  1227.           || LCD_MIRROR_X 
  1228.           || LCD_MIRROR_Y
  1229.           case 8:
  1230.             _DrawBitLine8BPP(x0, i + y0, pData, xsize, pTrans);
  1231.             break;
  1232.         #endif
  1233.       #endif
  1234.       #if (LCD_BITSPERPIXEL > 8)
  1235.         case 16:
  1236.           _DrawBitLine16BPP(x0, i + y0, (const U16 *)pData, xsize, pTrans);
  1237.           break;
  1238.       #endif
  1239.     }
  1240.     pData += BytesPerLine;
  1241.   }
  1242. }
  1244. /*********************************************
  1245. *
  1246. *       LCD_L0_SetOrg
  1247. *
  1248. **********************************************
  1249. */
  1251. void LCD_L0_SetOrg(int x, int y) {
  1252.   GUI_USE_PARA(x);
  1253.   GUI_USE_PARA(y);
  1254. }
  1256. /*********************************************
  1257. *
  1258. *       LCD_On / LCD_Off
  1259. *
  1260. **********************************************
  1261. */
  1263. void LCD_On (void) {
  1264. #ifdef LCD_ON
  1265.   LCD_ON();
  1266. #endif
  1267. }
  1269. void LCD_Off (void) {
  1270. #ifdef LCD_OFF
  1271.   LCD_OFF();
  1272. #endif
  1273. }
  1275. /*********************************************
  1276. *
  1277. *       LCD_L0_Init
  1278. *
  1279. **********************************************
  1280. Purpose:
  1281.   Initialises the LCD-controller.
  1282. */
  1284. int  LCD_L0_Init(void) {
  1285.   #if LCD_CACHE
  1286.     memset(_VRam, 0, sizeof(_VRam));
  1287.   #endif
  1288.   LCD_INIT_CONTROLLER();
  1289.   LCD_ON();
  1290.   /* Clear display RAM */
  1291.   {
  1292.     int x, y;
  1293.     U8 Data = 0x00;
  1294.     for (y = 0; y < ((LCD_YSIZE + 7) >> 3); y++) {
  1295.       SET_PAGE(y);
  1296.       for (x = 0; x < LCD_XSIZE; x++) {
  1297.         SET_OFFSET(x);
  1298.         WRITE_DATA(Data);
  1299.       }
  1300.     }
  1301.   }
  1302.   return 0;
  1303. }
  1305. /*********************************************
  1306. *
  1307. *       LCD_L0_SetLUTEntry
  1308. *
  1309. **********************************************
  1310. */
  1312. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR Color) {
  1313.   GUI_USE_PARA(Pos);
  1314.   GUI_USE_PARA(Color);
  1315. }
  1317. #else
  1319. void LCDPage1bpp(void) { } /* avoid empty object files */
  1321. #endif /* (LCD_CONTROLLER undefined) */