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

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

uCOS

开发平台：

C/C++

LCDMemC.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        : LCDMem.C
  16. Purpose     : Driver for LCDs using internal memory
  17. ----------------------------------------------------------------------
  18. Version-Date---Author-Explanation
  19. ----------------------------------------------------------------------
  20. 2.01a   010927 JE     a) Reworked to work with LCD_MIRROR_...
  21.                          and LCD_SWAP_XY
  22. 2.01    010814 JE     a) Support for 6bpp added,
  23.                          HLine & 1bpp optimized
  24. 2.00    010402 RS     a) LCD_GetDevCaps removed from driver
  25.                          (now LCD.c)
  26. 0.92    000122 RS     _GetPixel functionality written
  27. 0.91    000121 RS     Default for LCD_VRAMTYPE defined
  28. 0.90    991205 RS     Driver accelerated
  29. 0.00    990118 RS     First release. 
  30. ----------------------------------------------------------------------
  31. Known problems or limitations with current version
  32. ----------------------------------------------------------------------
  33. None.
  34. ---------------------------LIST OF CONFIG SWITCHES--------------------
  35. The following is a list of additional configuration switches for this
  36. driver. These switches might not be listed in the manual, because
  37. the manual mainly covers the general config switches which are
  38. supported by all drivers.
  39. ----------------------------------------------------------------------
  40. define ----------------------Explanation------------------------------
  41. LCD_LSB_SHIFT                Support for both big and little endian
  42.                              systems.
  43.                              0 for little endian (default),
  44.                              8 for big endian.
  45. LCD_OPTIMIZE                 Controls the use of optimized routines.
  46.                              If 1, several (speed) optimizations are used.
  47.                              Default: ON (1)
  48. LCD_VRAMTYPE                 Controls storage area of VRAM
  49. ---------------------------END-OF-HEADER------------------------------
  50. */
  52. #define LCDMEMC_C
  54. #include <string.h>             /* for memset */
  55. #include <stddef.h>           /* needed for definition of NULL */
  56. #include "LCD_Private.h"      /* private modul definitions & config */
  57. #include "GUI_Private.h"
  58. #include "GUIDebug.h"
  59. #include "LCD_0.h"            /* Defines for first display */
  61. #ifndef LCD_VRAMTYPE
  62.   #define LCD_VRAMTYPE
  63. #endif
  67. #if (LCD_CONTROLLER   == 0) && ((LCD_FIXEDPALETTE == 111) || (LCD_FIXEDPALETTE == 222)) 
  68.       && (!defined(WIN32) | defined(LCD_SIMCONTROLLER))
  72.    /* Generate code only if selected ! */
  74. #define LCD_BYTESPERLINE (3*(((LCD_VXSIZE_PHYS)+7)/8))
  76. #ifndef WIN32
  77.   #if   (LCD_BITSPERPIXEL == 3)
  78.     LCD_VRAMTYPE U8 LCD_VRam[LCD_BITSPERPIXEL/3][LCD_VYSIZE_PHYS * LCD_BYTESPERLINE];
  79.   #elif (LCD_BITSPERPIXEL == 6)
  80.     LCD_VRAMTYPE U8 LCD_VRam_0[LCD_VYSIZE_PHYS * LCD_BYTESPERLINE];
  81.     LCD_VRAMTYPE U8 LCD_VRam_1[LCD_VYSIZE_PHYS * LCD_BYTESPERLINE];
  82.   #endif
  83. #else
  84.   U8* GetpVRam(int);
  85.   #if   (LCD_BITSPERPIXEL == 3)
  86.     U8* pVRam;
  87.   #elif (LCD_BITSPERPIXEL == 6)
  88.     U8* pVRam_0;
  89.     U8* pVRam_1;
  90.   #endif
  91. #endif
  95. /*
  96.   ********************************************************************
  97.   *                                                                  *
  98.   *            Defaults for configuration                            *
  99.   *                                                                  *
  100.   ********************************************************************
  102. Please be aware that not all configuration errors can be captured !
  104. */
  105. #ifndef LCD_VERIFY
  106.   #define LCD_VERIFY (0)
  107. #endif
  109. /* Switch for support of multiple pages.
  110.  Only available with certain LCD-controllers */
  111. #ifndef LCD_SUPPORT_PAGING
  112.   #define LCD_SUPPORT_PAGING            (0)
  113. #endif
  115. /* Switch for support of run-time inversion of display. */
  116. #ifndef LCD_SUPPORT_REVERSEMODE
  117.   #define LCD_SUPPORT_REVERSEMODE       (0)
  118. #endif
  120. /* Switch support for the LCD_SetOrg function of the driver */
  121. #ifndef LCD_SUPPORT_SETORG
  122.   #define LCD_SUPPORT_SETORG            (1)
  123. #endif
  125. #ifndef LCD_SUPPORT_PALETTE
  126.   #define LCD_SUPPORT_PALETTE            (1)
  127. #endif
  129. #ifndef LCD_SCHEDULE_CNT
  130.   #define LCD_SCHEDULE_CNT        (0)
  131. #endif
  133. #ifndef LCD_ISRDATA
  134.   #define LCD_ISRDATA
  135. #endif
  136.   
  137. /* Bit position of least sig. byte when accessing words */
  138. #ifndef LCD_LSB_SHIFT
  139.   #define LCD_LSB_SHIFT                 (0)
  140. #endif
  142. #ifndef LCD_OPTIMIZE
  143.   #define LCD_OPTIMIZE                (1)
  144. #endif
  146. /*
  147.   ********************************************************************
  148.   *                                                                  *
  149.   *                Support for Segment/COMLUTs                       *
  150.   *                                                                  *
  151.   ********************************************************************
  152. */
  154. /* For compatibility with older configs, define defaults */
  155. #ifndef LCD_SUPPORT_COMTRANS
  156.   #define LCD_SUPPORT_COMTRANS 0
  157. #endif
  158. #ifndef LCD_SUPPORT_SEGTRANS
  159.   #define LCD_SUPPORT_SEGTRANS 0
  160. #endif
  162. #if LCD_SUPPORT_COMTRANS
  163.   extern U8 LCD__aLine2Com0[LCD_LASTCOM0-LCD_FIRSTCOM0+1];
  164. #endif
  166. #if LCD_SUPPORT_SEGTRANS
  167.   extern U8 LCD__aRow2Seg0[LCD_LASTSEG0-LCD_FIRSTSEG0+1];
  168. #endif
  171. /*
  172.   ********************************************************************
  173.   *                                                                  *
  174.   *                 Macro calculations                               *
  175.   *                                                                  *
  176.   ********************************************************************
  177. */
  179. /* Define number of used coms/segments per controller */
  180. #define LCD_NUM_SEGS0 (LCD_LASTSEG0-LCD_FIRSTSEG0+1)
  181. #define LCD_NUM_COMS0 (LCD_LASTCOM0-LCD_FIRSTCOM0+1)
  182. /* Define total number of used coms/segments */
  183. #define LCD_NUM_SEGS LCD_NUM_SEGS0
  184. #define LCD_NUM_COMS LCD_NUM_COMS0
  186. #define BKCOLOR LCD_BKCOLORINDEX
  187. #define   COLOR LCD_COLORINDEX
  189. /*
  190.   ********************************************************************
  191.   *                                                                  *
  192.   *            Configuration switch checking                         *
  193.   *                                                                  *
  194.   ********************************************************************
  196. Please be aware that not all configuration errors can be captured !
  198. */
  200. #if (LCD_BITSPERPIXEL != 3) && (LCD_BITSPERPIXEL != 6)
  201.   #error this value for LCD_BITSPERPIXEL not yet supported
  202. #endif
  204. /* Check if number of segments / coms equals resolution */
  205. #if (LCD_NUM_SEGS < LCD_XSIZE_PHYS)
  206. /*  #error Please check segment setup of controller 0 and X/YSIZE !!!*/
  207. #endif
  208. #if (LCD_NUM_COMS < LCD_YSIZE_PHYS)
  209. /*  #error Please check com setup of controller 0 and X/YSIZE !!!*/
  210. #endif
  213. /*
  214.   ********************************************************************
  215.   *                                                                  *
  216.   *       EXPORTs for ISR                                            *
  217.   *                                                                  *
  218.   ********************************************************************
  219. */
  221. #ifndef LCD_TIMERINIT1
  222.   #define LCD_TIMERINIT1  1599
  223. #endif
  224. #ifndef LCD_TIMERINIT0
  225.   #define LCD_TIMERINIT0  1065
  226. #endif
  228. LCD_ISRDATA U16 LCD__BitsPerPixel = LCD_BITSPERPIXEL/3;
  229. LCD_ISRDATA U8 LCD_VRAMTYPE* LCD__apVRam[LCD_BITSPERPIXEL/3];
  230. LCD_ISRDATA U16 LCD__aTimerReload[LCD_BITSPERPIXEL/3] = {
  231.   LCD_TIMERINIT0
  232.   #if LCD_BITSPERPIXEL/3 >1
  233. ,LCD_TIMERINIT1
  234.   #endif
  235. };
  237. /*
  238.   ********************************************************************
  239.   *
  240.   *                  ID translation table
  241.   *
  242.   ********************************************************************
  244. This table contains 0, 1, 2, ... and serves as translation table for DDBs
  246. */
  248. #define INTS(Base)  Base+0,Base+1,Base+2,Base+3,Base+4,Base+5,   
  249.                     Base+6,Base+7,Base+8,Base+9,Base+10,Base+11, 
  250.                     Base+12,Base+13,Base+14,Base+15
  252. static const LCD_PIXELINDEX aID[] = {
  253.   INTS(0),
  254.   #if LCD_MAX_LOG_COLORS > 0x10
  255.     INTS(0x10),
  256.   #endif
  257.   #if LCD_MAX_LOG_COLORS > 0x20
  258.     INTS(0x20),
  259.     INTS(0x30),
  260.   #endif
  261.   #if LCD_MAX_LOG_COLORS > 0x40
  262.     INTS(0x40),
  263.     INTS(0x50),
  264.     INTS(0x60),
  265.     INTS(0x70),
  266.   #endif
  267.   #if LCD_MAX_LOG_COLORS > 0x80
  268.     INTS(0x80),
  269.     INTS(0x90),
  270.     INTS(0xa0),
  271.     INTS(0xb0),
  272.     INTS(0xc0),
  273.     INTS(0xd0),
  274.     INTS(0xe0),
  275.     INTS(0xf0)
  276.   #endif
  277. };
  280. /*
  281.         *********************************************************
  282.         *                                                       *
  283.         *       Macros for internal use                         *
  284.         *                                                       *
  285.         *********************************************************
  286. */
  288. #if (LCD_SUPPORT_COMTRANS)
  289.   #if (LCD_MIRROR_Y)
  290.     #error LCD_MIRROR_Y not supported with COMTrans !
  291.   #endif
  292.   #if (LCD_MIRROR_X)
  293.     #error LCD_MIRROR_X not supported with COMTrans !
  294.   #endif
  295. #endif
  297. #if (!LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  298.   #if   (!LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  299.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((x), (y), (c))
  300.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((x), (y), (c))
  301.     #define GETPIXEL(x, y)         GetPixel            ((x), (y))
  302.     #define XORPIXEL(x, y)         XorPixel            ((x), (y))
  303.   #elif (!LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  304.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((y), (x), (c))
  305.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((y), (x), (c))
  306.     #define GETPIXEL(x, y)         GetPixel            ((y), (x))
  307.     #define XORPIXEL(x, y)         XorPixel            ((y), (x))
  308.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  309.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((x), (LCD_YSIZE-1-(y)), (c))
  310.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((x), (LCD_YSIZE-1-(y)), (c))
  311.     #define GETPIXEL(x, y)         GetPixel            ((x), (LCD_YSIZE-1-(y)))
  312.     #define XORPIXEL(x, y)         XorPixel            ((x), (LCD_YSIZE-1-(y)))
  313.   #elif (!LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  314.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((LCD_YSIZE-1-(y)), (x), (c))
  315.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((LCD_YSIZE-1-(y)), (x), (c))
  316.     #define GETPIXEL(x, y)         GetPixel            ((LCD_YSIZE-1-(y)), (x))
  317.     #define XORPIXEL(x, y)         XorPixel            ((LCD_YSIZE-1-(y)), (x))
  318.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y && !LCD_SWAP_XY) 
  319.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((LCD_XSIZE-1-(x)), (y), (c))
  320.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((LCD_XSIZE-1-(x)), (y), (c))
  321.     #define GETPIXEL(x, y)         GetPixel            ((LCD_XSIZE-1-(x)), (y))
  322.     #define XORPIXEL(x, y)         XorPixel            ((LCD_XSIZE-1-(x)), (y))
  323.   #elif ( LCD_MIRROR_X && !LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  324.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((y), (LCD_XSIZE-1-(x)), (c))
  325.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((y), (LCD_XSIZE-1-(x)), (c))
  326.     #define GETPIXEL(x, y)         GetPixel            ((y), (LCD_XSIZE-1-(x)))
  327.     #define XORPIXEL(x, y)         XorPixel            ((y), (LCD_XSIZE-1-(x)))
  328.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y && !LCD_SWAP_XY) 
  329.     #define SETPIXEL(x, y, c)      SETPIXELPHYS        ((LCD_XSIZE-1-(x)), (LCD_YSIZE-1-(y)), (c))
  330.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS        ((LCD_XSIZE-1-(x)), (LCD_YSIZE-1-(y)), (c))
  331.     #define GETPIXEL(x, y)         GetPixel            ((LCD_XSIZE-1-(x)), (LCD_YSIZE-1-(y)))
  332.     #define XORPIXEL(x, y)         XorPixel            ((LCD_XSIZE-1-(x)), (LCD_YSIZE-1-(y)))
  333.   #elif ( LCD_MIRROR_X &&  LCD_MIRROR_Y &&  LCD_SWAP_XY) 
  334.     #error This combination of mirroring/swapping not yet supported
  335.   #endif
  336. #elif (LCD_SUPPORT_COMTRANS && !LCD_SUPPORT_SEGTRANS)
  337.   #if (!LCD_SWAP_XY)
  338.     #define SETPIXEL(x, y, c)      SetPixelPhys(x,LCD__aLine2Com0[y], c)
  339.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS(x,LCD__aLine2Com0[y], c)
  340.     #define GETPIXEL(x, y)     LCD_L0_GetPixelIndex(x,LCD__aLine2Com0[y])
  341.     #define XORPIXEL(x, y)      XorPixel(x,LCD__aLine2Com0[y])
  342.   #else
  343.     #define SETPIXEL(x, y, c)      SetPixelPhys(y,LCD__aLine2Com0[x], c)
  344.     #define SETPIXELFAST(x, y, c)  SETPIXELPHYS(y,LCD__aLine2Com0[x], c)
  345.     #define GETPIXEL(x, y)     LCD_L0_GetPixelIndex(y,LCD__aLine2Com0[x])
  346.     #define XORPIXEL(x, y)      XorPixel(y,LCD__aLine2Com0[x])
  347.   #endif
  348. #else
  349.   #error This combination of switches not yet supported
  350. #endif
  352. #define XY2OFF(x,y) (y*LCD_BYTESPERLINE+3*(x>>3))
  354. #ifndef WIN32
  355.   #if   (LCD_BITSPERPIXEL == 3)
  356.     #define OFF2PTR(Off) &LCD_VRam[0][Off]
  357.   #elif (LCD_BITSPERPIXEL == 6)
  358.     #define OFF2PTR_0(Off) &LCD_VRam_0[Off]
  359.     #define OFF2PTR_1(Off) &LCD_VRam_1[Off]
  360.   #endif
  361. #else
  362.   #if   (LCD_BITSPERPIXEL == 3)
  363.     #define OFF2PTR(Off) (pVRam+Off)
  364.   #elif (LCD_BITSPERPIXEL == 6)
  365.     #define OFF2PTR_0(Off) (pVRam_0+Off)
  366.     #define OFF2PTR_1(Off) (pVRam_1+Off)
  367.   #endif
  368. #endif
  374. /*
  375.         *********************************************************
  376.         *                                                       *
  377.         *       Internal set pixel routines                     *
  378.         *                                                       *
  379.         *********************************************************
  380. */
  382. #if (LCD_BITSPERPIXEL == 3)
  384. #define SETPIXELPHYS(x,y,c)                       
  385. {                                                 
  386.    U8 LCD_VRAMTYPE* p = OFF2PTR(XY2OFF(x,y));     
  387.   switch (x&7) {                                  
  388.   case 0:                                         
  389.     *p = (*p&~(7<<5))|(c<<5);                     
  390.     break;                                        
  391.   case 1:                                         
  392.     *p = (*p&~(7<<2))|(c<<2);                     
  393.     break;                                        
  394.   case 2:                                         
  395.     *p   = (*p&~(3))|(c>>1);                      
  396.     p++;                                          
  397.     *p = (*p &~(1<<7))|(c<<7);                    
  398.     break;                                        
  399.   case 3:                                         
  400.     p++;                                          
  401.     *p = (*p&~(7<<4))|(c<<4);                     
  402.     break;                                        
  403.   case 4:                                         
  404.     p++;                                          
  405.     *p = (*p&~(7<<1))|(c<<1);                     
  406.     break;                                        
  407.   case 5:                                         
  408.     p++;                                          
  409.     *p   = (*p&~(1))|(c>>2);                      
  410.     p++;                                          
  411.     *p = (*p &~(3<<6))|(c<<6);                    
  412.     break;                                        
  413.   case 6:                                         
  414.     p+=2;                                         
  415.     *p = (*p&~(7<<3))|(c<<3);                     
  416.     break;                                        
  417.   case 7:                                         
  418.     p+=2;                                         
  419.     *p = (*p&~(7<<0))|(c);                        
  420.     break;                                        
  421.   }                                               
  422. }
  424. #elif (LCD_BITSPERPIXEL == 6)
  426. void SetPixelPhys222(int x, int y, LCD_PIXELINDEX c) {
  427.   U8 LCD_VRAMTYPE* p0 = OFF2PTR_0(XY2OFF(x,y));
  428.   U8 LCD_VRAMTYPE* p1 = OFF2PTR_1(XY2OFF(x,y));
  429.   U8 c0 = ((c & 0x20) >> 3) + ((c & 0x08) >> 2) + ((c & 0x02) >> 1);
  430.   U8 c1 = ((c & 0x10) >> 2) + ((c & 0x04) >> 1) +  (c & 0x01);
  431.   switch (x&7) {
  432.   case 0:
  433.     *p0 = (*p0&~(7<<5))|(c0<<5);
  434.     *p1 = (*p1&~(7<<5))|(c1<<5);
  435.     break;
  436.   case 1:
  437.     *p0 = (*p0&~(7<<2))|(c0<<2);
  438.     *p1 = (*p1&~(7<<2))|(c1<<2);
  439.     break;
  440.   case 2:
  441.     *p0   = (*p0&~(3))|(c0>>1);
  442.     *p1   = (*p1&~(3))|(c1>>1);
  443.     p0++;
  444.     p1++;
  445.     *p0 = (*p0 &~(1<<7))|(c0<<7);
  446.     *p1 = (*p1 &~(1<<7))|(c1<<7);
  447.     break;
  448.   case 3:
  449.     p0++;
  450.     p1++;
  451.     *p0 = (*p0&~(7<<4))|(c0<<4);
  452.     *p1 = (*p1&~(7<<4))|(c1<<4);
  453.     break;
  454.   case 4:
  455.     p0++;
  456.     p1++;
  457.     *p0 = (*p0&~(7<<1))|(c0<<1);
  458.     *p1 = (*p1&~(7<<1))|(c1<<1);
  459.     break;
  460.   case 5:
  461.     p0++;
  462.     p1++;
  463.     *p0   = (*p0&~(1))|(c0>>2);
  464.     *p1   = (*p1&~(1))|(c1>>2);
  465.     p0++;
  466.     p1++;
  467.     *p0 = (*p0 &~(3<<6))|(c0<<6);
  468.     *p1 = (*p1 &~(3<<6))|(c1<<6);
  469.     break;
  470.   case 6:
  471.     p0+=2;
  472.     p1+=2;
  473.     *p0 = (*p0&~(7<<3))|(c0<<3);
  474.     *p1 = (*p1&~(7<<3))|(c1<<3);
  475.     break;
  476.   case 7:
  477.     p0+=2;
  478.     p1+=2;
  479.     *p0 = (*p0&~(7<<0))|(c0);
  480.     *p1 = (*p1&~(7<<0))|(c1);
  481.     break;
  482.   }
  483. }
  485. #define SETPIXELPHYS(x,y,c) SetPixelPhys222(x,y,c) 
  487. #endif
  489. static void SetPixelPhys(int x, int y, LCD_PIXELINDEX c) {
  490.   SETPIXELPHYS(x,y,c);
  491. }
  494. /*
  495.         *********************************************************
  496.         *                                                       *
  497.         *       Next pixel routines, optimized for 3bpp
  498.         *                                                       *
  499.         *********************************************************
  500. */
  502. #if      (LCD_OPTIMIZE)             
  503.       && (!LCD_MIRROR_X)            
  504.       && (!LCD_MIRROR_Y)            
  505.       && (!LCD_SWAP_XY)             
  506.       && (!LCD_SUPPORT_COMTRANS)    
  507.       && (!LCD_SUPPORT_SEGTRANS)    
  508.       && (LCD_BITSPERPIXEL == 3)
  510. static int CurPosX;
  511. static U8 LCD_VRAMTYPE* pCurPos;
  513. static void SetPosXY(int x, int y) {
  514.   CurPosX = x;
  515.   pCurPos = OFF2PTR(XY2OFF(x,y));
  516.   switch (x&7) {
  517.   case 3:
  518.   case 4:
  519.   case 5:
  520.     pCurPos++; break;
  521.   case 6:
  522.   case 7:
  523.     pCurPos+=2;
  524.   }
  525. }
  527. static void SetNextPixel(LCD_PIXELINDEX c) {
  528.   switch (CurPosX&7) {
  529.   case 0: *pCurPos = (*pCurPos&~(7<<5))|(c<<5); break;
  530.   case 1: *pCurPos = (*pCurPos&~(7<<2))|(c<<2); break;
  531.   case 2: *pCurPos = (*pCurPos&~(3))|(c>>1);
  532.            pCurPos++;
  533.           *pCurPos = (*pCurPos &~(1<<7))|(c<<7);
  534.            break;
  535.   case 3: *pCurPos = (*pCurPos&~(7<<4))|(c<<4); break;
  536.   case 4: *pCurPos = (*pCurPos&~(7<<1))|(c<<1); break;
  537.   case 5: *pCurPos = (*pCurPos&~(1))|(c>>2);
  538.            pCurPos++;
  539.           *pCurPos = (*pCurPos &~(3<<6))|(c<<6);
  540.            break;
  541.   case 6: *pCurPos = (*pCurPos&~(7<<3))|(c<<3); break;
  542.   case 7: *pCurPos = (*pCurPos&~(7<<0))|(c);
  543.            pCurPos++;
  544.            break;
  545.   }
  546.   CurPosX++;
  547. }
  549. /*
  550.         *********************************************************
  551.         *                                                       *
  552.         *       Next pixel routines, optimized for 6bpp
  553.         *                                                       *
  554.         *********************************************************
  555. */
  557. #elif    (LCD_OPTIMIZE)             
  558.       && (!LCD_MIRROR_X)            
  559.       && (!LCD_MIRROR_Y)            
  560.       && (!LCD_SWAP_XY)             
  561.       && (!LCD_SUPPORT_COMTRANS)    
  562.       && (!LCD_SUPPORT_SEGTRANS)    
  563.       && (LCD_BITSPERPIXEL == 6)
  565. static int CurPosX;
  566. static U8 LCD_VRAMTYPE* pCurPos_0;
  567. static U8 LCD_VRAMTYPE* pCurPos_1;
  569. static void SetPosXY(int x, int y) {
  570.   CurPosX = x;
  571.   pCurPos_0 = OFF2PTR_0(XY2OFF(x,y));
  572.   pCurPos_1 = OFF2PTR_1(XY2OFF(x,y));
  573.   switch (x&7) {
  574.   case 3:
  575.   case 4:
  576.   case 5:
  577.     pCurPos_0++;
  578.     pCurPos_1++;
  579.     break;
  580.   case 6:
  581.   case 7:
  582.     pCurPos_0+=2;
  583.     pCurPos_1+=2;
  584.   }
  585. }
  587. static void SetNextPixel(LCD_PIXELINDEX c) {
  588.   U8 c0 = ((c & 0x20) >> 3) + ((c & 0x08) >> 2) + ((c & 0x02) >> 1);
  589.   U8 c1 = ((c & 0x10) >> 2) + ((c & 0x04) >> 1) +  (c & 0x01);
  590.   switch (CurPosX&7) {
  591.   case 0: 
  592.     *pCurPos_0 = (*pCurPos_0&~(7<<5))|(c0<<5); 
  593.     *pCurPos_1 = (*pCurPos_1&~(7<<5))|(c1<<5); 
  594.     break;
  595.   case 1: 
  596.     *pCurPos_0 = (*pCurPos_0&~(7<<2))|(c0<<2); 
  597.     *pCurPos_1 = (*pCurPos_1&~(7<<2))|(c1<<2); 
  598.     break;
  599.   case 2: 
  600.     *pCurPos_0 = (*pCurPos_0&~(3))|(c0>>1);
  601.     *pCurPos_1 = (*pCurPos_1&~(3))|(c1>>1);
  602.     pCurPos_0++;
  603.     pCurPos_1++;
  604.     *pCurPos_0 = (*pCurPos_0 &~(1<<7))|(c0<<7);
  605.     *pCurPos_1 = (*pCurPos_1 &~(1<<7))|(c1<<7);
  606.     break;
  607.   case 3: 
  608.     *pCurPos_0 = (*pCurPos_0&~(7<<4))|(c0<<4); 
  609.     *pCurPos_1 = (*pCurPos_1&~(7<<4))|(c1<<4); 
  610.     break;
  611.   case 4: 
  612.     *pCurPos_0 = (*pCurPos_0&~(7<<1))|(c0<<1); 
  613.     *pCurPos_1 = (*pCurPos_1&~(7<<1))|(c1<<1); 
  614.     break;
  615.   case 5: 
  616.     *pCurPos_0 = (*pCurPos_0&~(1))|(c0>>2);
  617.     *pCurPos_1 = (*pCurPos_1&~(1))|(c1>>2);
  618.     pCurPos_0++;
  619.     pCurPos_1++;
  620.     *pCurPos_0 = (*pCurPos_0 &~(3<<6))|(c0<<6);
  621.     *pCurPos_1 = (*pCurPos_1 &~(3<<6))|(c1<<6);
  622.     break;
  623.   case 6: 
  624.     *pCurPos_0 = (*pCurPos_0&~(7<<3))|(c0<<3); 
  625.     *pCurPos_1 = (*pCurPos_1&~(7<<3))|(c1<<3); 
  626.     break;
  627.   case 7: 
  628.     *pCurPos_0 = (*pCurPos_0&~(7<<0))|(c0);
  629.     *pCurPos_1 = (*pCurPos_1&~(7<<0))|(c1);
  630.     pCurPos_0++;
  631.     pCurPos_1++;
  632.     break;
  633.   }
  634.   CurPosX++;
  635. }
  637. #endif
  639. #if (LCD_BITSPERPIXEL == 3)
  641. unsigned int GetPixel(int x, int y) {
  642.   U8 LCD_VRAMTYPE* p = OFF2PTR(XY2OFF(x,y));
  643.   switch(x&7) {
  644.     case 0: return (*p>>5);
  645.     case 1: return (*p>>2)&7;
  646.     case 2: return ((*p&(3   )) <<1)|(*(p+1)>>7);
  647.     case 3: return (*(p+1)>>4) &7;
  648.     case 4: return (*(p+1)>>1) &7;
  649.     case 5: return ((*(p+1)&(1)) <<2)|(*(p+2)>>6);
  650.     case 6: return (*(p+2)&(7<<3)) >>3;
  651.   }
  652.   return (*(p+2)&(7<<0)) >>0;
  653. }
  655. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  656.   return GETPIXEL(x, y);
  657. }
  659. #elif (LCD_BITSPERPIXEL == 6)
  661. unsigned int GetPixel(int x, int y) {
  662.   U8 LCD_VRAMTYPE* p0 = OFF2PTR_0(XY2OFF(x,y));
  663.   U8 LCD_VRAMTYPE* p1 = OFF2PTR_1(XY2OFF(x,y));
  664.   U8 c0, c1;
  665.   switch(x&7) {
  666.     case 0: 
  667.       c0 = (*p0>>5);
  668.       c1 = (*p1>>5);
  669.       break;
  670.     case 1: 
  671.       c0 = (*p0>>2)&7;
  672.       c1 = (*p1>>2)&7;
  673.       break;
  674.     case 2: 
  675.       c0 = ((*p0&3)<<1)|(*(p0+1)>>7);
  676.       c1 = ((*p1&3)<<1)|(*(p1+1)>>7);
  677.       break;
  678.     case 3: 
  679.       c0 = (*(p0+1)>>4) &7;
  680.       c1 = (*(p1+1)>>4) &7;
  681.       break;
  682.     case 4: 
  683.       c0 = (*(p0+1)>>1) &7;
  684.       c1 = (*(p1+1)>>1) &7;
  685.       break;
  686.     case 5: 
  687.       c0 = ((*(p0+1)&(1)) <<2)|(*(p0+2)>>6);
  688.       c1 = ((*(p1+1)&(1)) <<2)|(*(p1+2)>>6);
  689.       break;
  690.     case 6: 
  691.       c0 = (*(p0+2)&(7<<3)) >>3;
  692.       c1 = (*(p1+2)&(7<<3)) >>3;
  693.       break;
  694.     case 7: 
  695.       c0 = (*(p0+2)&(7<<0)) >>0;
  696.       c1 = (*(p1+2)&(7<<0)) >>0;
  697.       break;
  698.   }
  699.   return ((c0 & 0x04) << 3) + ((c0 & 0x02) << 2) + ((c0 & 0x01) << 1)
  700.        + ((c1 & 0x04) << 2) + ((c1 & 0x02) << 1) +  (c1 & 0x01);
  701. }
  703. unsigned int LCD_L0_GetPixelIndex(int x, int y) {
  704.   return GETPIXEL(x, y);
  705. }
  707. #endif
  710. static void XorPixel   (int x, int y) {
  711.   LCD_PIXELINDEX Index = GetPixel(x,y);
  712.   Index = LCD_NUM_COLORS-1-Index;
  713.   SetPixelPhys(x,y,Index);
  714. }
  716. void LCD_L0_XorPixel   (int x, int y) {
  717.   XORPIXEL(x,y);
  718. }
  720. void LCD_L0_SetPixelIndex   (int x, int y, int ColorIndex) {
  721.   SETPIXELFAST(x,y,ColorIndex);
  722. }
  726. /*
  727.         *********************************************************
  728.         *                                                       *
  729.         *          LCD_DrawHLine optimized                      *
  730.         *                                                       *
  731.         *          Normal display, 3 Bpp                        *
  732.         *                                                       *
  733.         *********************************************************
  734. */
  736. #if      (LCD_OPTIMIZE)             
  737.       && (!LCD_MIRROR_X)            
  738.       && (!LCD_MIRROR_Y)            
  739.       && (!LCD_SWAP_XY)             
  740.       && (!LCD_SUPPORT_COMTRANS)    
  741.       && (!LCD_SUPPORT_SEGTRANS)    
  742.       && (LCD_BITSPERPIXEL == 3)
  744. static U8 MaskLeft[8][3] = {
  745.   { 0xff, 0xff, 0xff},
  746.   { 0x1f, 0xff, 0xff},
  747.   { 0x03, 0xff, 0xff},
  748.   { 0x00, 0x7f, 0xff},
  749.   { 0x00, 0x0f, 0xff},
  750.   { 0x00, 0x01, 0xff},
  751.   { 0x00, 0x00, 0x3f},
  752.   { 0x00, 0x00, 0x07}/*!!!0x0e*/
  753. };
  755. static U8 MaskRight[8][3] = {
  756.   { 0xe0, 0x00, 0x00},
  757.   { 0xfc, 0x00, 0x00},
  758.   { 0xff, 0x80, 0x00},
  759.   { 0xff, 0xf0, 0x00},
  760.   { 0xff, 0xfe, 0x00},
  761.   { 0xff, 0xff, 0xc0},
  762.   { 0xff, 0xff, 0xf8},
  763.   { 0xff, 0xff, 0xff}
  764. };
  766. static U8* GetMaskRight(int x) { return &MaskRight[(x&7)][0]; }
  767. static U8* GetMaskLeft (int x) { return &MaskLeft[(x&7)][0]; }
  769. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  770.   if (x0>x1) return;  /* Check if nothing to draw */
  771.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  772.     while (x0 <= x1) {
  773.       XORPIXEL(x0, y);
  774.       x0++;
  775.     }
  776.   } else {
  777.     int i;
  778.     U8 LCD_VRAMTYPE* p = OFF2PTR(XY2OFF(x0,y));
  779.     U8* pMask = GetMaskLeft(x0);
  780.     U8 aData[3];
  781.     U8 aDataMasked[3];
  782.     aData[0] = (COLOR<<5)|(COLOR<<2)|(COLOR>>1);            /* hhhgggff */
  783.     aData[1] = (COLOR<<7)|(COLOR<<4)|(COLOR<<1)|(COLOR>>2); /* feeedddc */
  784.     aData[2] = (COLOR<<6)|(COLOR<<3)|(COLOR);               /* ccbbbaaa */
  785.     for (i=0; i<3; i++, pMask++) {
  786.       aDataMasked[i] = (*(p+i) &~*pMask) | (aData[i] &*pMask);
  787.     }
  788.     if ((x0&~7) == (x1&~7)) {    /* Do we have to clip left and right side ? */
  789.       U8* pMask = GetMaskRight(x1);
  790. #if 0
  791.       for (i=0; i<3; i++, pMask++) {
  792.         *(p+i) = (*(p+i) &~*pMask) | (aDataMasked[i]&*pMask);
  793.       }
  794. #else
  795.       *(p+0) = (*(p+0) &~*(pMask+0)) | (aDataMasked[0]&*(pMask+0));
  796.       *(p+1) = (*(p+1) &~*(pMask+1)) | (aDataMasked[1]&*(pMask+1));
  797.       *(p+2) = (*(p+2) &~*(pMask+2)) | (aDataMasked[2]&*(pMask+2));
  798. #endif
  799.       return;
  800.     }
  801.     *p = aDataMasked[0];
  802.     *(p+1) = aDataMasked[1];
  803.     *(p+2) = aDataMasked[2];
  804.     p+=3;
  805.     x0 = (x0&~7)+8;
  806. /* Draw optimized portion */
  807.     {
  808.       int Len = (x1-x0+1)>>3;
  809.       if (Len >0) {
  810.         x0 += Len<<3;
  811.         do {
  812.           *p     = aData[0];
  813.           *(p+1) = aData[1];
  814.           *(p+2) = aData[2];
  815.           p+=3;
  816.         } while (--Len);
  817.       }
  818.     }
  819.     /* Draw right portion */
  820.     if ((x1&7)!=7) {
  821.       U8* pMask = GetMaskRight(x1);
  822.       for (i=0; i<3; i++, pMask++) {
  823.         *(p+i) = (*(p+i) &~*pMask) | (aData[i]&*pMask);
  824.       }
  825.     }
  826.     
  827.   }
  828. }
  830. /*
  831.         *********************************************************
  832.         *                                                       *
  833.         *          LCD_DrawHLine optimized                      *
  834.         *                                                       *
  835.         *          Normal display, 6 Bpp                        *
  836.         *                                                       *
  837.         *********************************************************
  838. */
  840. #elif    (LCD_OPTIMIZE)             
  841.       && (!LCD_MIRROR_X)            
  842.       && (!LCD_MIRROR_Y)            
  843.       && (!LCD_SWAP_XY)             
  844.       && (!LCD_SUPPORT_COMTRANS)    
  845.       && (!LCD_SUPPORT_SEGTRANS)    
  846.       && (LCD_BITSPERPIXEL == 6)
  848. static U8 MaskLeft[8][3] = {
  849.   { 0xff, 0xff, 0xff},
  850.   { 0x1f, 0xff, 0xff},
  851.   { 0x03, 0xff, 0xff},
  852.   { 0x00, 0x7f, 0xff},
  853.   { 0x00, 0x0f, 0xff},
  854.   { 0x00, 0x01, 0xff},
  855.   { 0x00, 0x00, 0x3f},
  856.   { 0x00, 0x00, 0x07}/*!!!0x0e*/
  857. };
  859. static U8 MaskRight[8][3] = {
  860.   { 0xe0, 0x00, 0x00},
  861.   { 0xfc, 0x00, 0x00},
  862.   { 0xff, 0x80, 0x00},
  863.   { 0xff, 0xf0, 0x00},
  864.   { 0xff, 0xfe, 0x00},
  865.   { 0xff, 0xff, 0xc0},
  866.   { 0xff, 0xff, 0xf8},
  867.   { 0xff, 0xff, 0xff}
  868. };
  870. static U8* GetMaskRight(int x) { return &MaskRight[(x&7)][0]; }
  871. static U8* GetMaskLeft (int x) { return &MaskLeft[(x&7)][0]; }
  873. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  874.   if (x0>x1) return;  /* Check if nothing to draw */
  875.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  876.     while (x0 <= x1) {
  877.       XORPIXEL(x0, y);
  878.       x0++;
  879.     }
  880.   } else {
  881.     int i;
  882.     U8 LCD_VRAMTYPE* p0 = OFF2PTR_0(XY2OFF(x0,y));
  883.     U8 LCD_VRAMTYPE* p1 = OFF2PTR_1(XY2OFF(x0,y));
  884.     U8* pMask = GetMaskLeft(x0);
  885.     U8 aData[2][3];
  886.     U8 aDataMasked[2][3];
  887.     U8 c0 = ((COLOR & 0x20) >> 3) + ((COLOR & 0x08) >> 2) + ((COLOR & 0x02) >> 1);
  888.     U8 c1 = ((COLOR & 0x10) >> 2) + ((COLOR & 0x04) >> 1) +  (COLOR & 0x01);
  889.     aData[0][0] = (c0<<5)|(c0<<2)|(c0>>1);         /* hhhgggff */
  890.     aData[0][1] = (c0<<7)|(c0<<4)|(c0<<1)|(c0>>2); /* feeedddc */
  891.     aData[0][2] = (c0<<6)|(c0<<3)|(c0);            /* ccbbbaaa */
  892.     aData[1][0] = (c1<<5)|(c1<<2)|(c1>>1);         /* hhhgggff */
  893.     aData[1][1] = (c1<<7)|(c1<<4)|(c1<<1)|(c1>>2); /* feeedddc */
  894.     aData[1][2] = (c1<<6)|(c1<<3)|(c1);            /* ccbbbaaa */
  895.     for (i=0; i<3; i++, pMask++) {
  896.       aDataMasked[0][i] = (*(p0+i) &~*pMask) | (aData[0][i] &*pMask);
  897.       aDataMasked[1][i] = (*(p1+i) &~*pMask) | (aData[1][i] &*pMask);
  898.     }
  899.     if ((x0&~7) == (x1&~7)) {    /* Do we have to clip left and right side ? */
  900.       U8* pMask = GetMaskRight(x1);
  901.       *(p0+0) = (*(p0+0) &~*(pMask+0)) | (aDataMasked[0][0]&*(pMask+0));
  902.       *(p0+1) = (*(p0+1) &~*(pMask+1)) | (aDataMasked[0][1]&*(pMask+1));
  903.       *(p0+2) = (*(p0+2) &~*(pMask+2)) | (aDataMasked[0][2]&*(pMask+2));
  904.       *(p1+0) = (*(p1+0) &~*(pMask+0)) | (aDataMasked[1][0]&*(pMask+0));
  905.       *(p1+1) = (*(p1+1) &~*(pMask+1)) | (aDataMasked[1][1]&*(pMask+1));
  906.       *(p1+2) = (*(p1+2) &~*(pMask+2)) | (aDataMasked[1][2]&*(pMask+2));
  907.       return;
  908.     }
  909.     *p0     = aDataMasked[0][0];
  910.     *(p0+1) = aDataMasked[0][1];
  911.     *(p0+2) = aDataMasked[0][2];
  912.     p0+=3;
  913.     *p1     = aDataMasked[1][0];
  914.     *(p1+1) = aDataMasked[1][1];
  915.     *(p1+2) = aDataMasked[1][2];
  916.     p1+=3;
  917.     x0 = (x0&~7)+8;
  918. /* Draw optimized portion */
  919.     {
  920.       int Len = (x1-x0+1)>>3;
  921.       if (Len >0) {
  922.         x0 += Len<<3;
  923.         do {
  924.           *p0     = aData[0][0];
  925.           *(p0+1) = aData[0][1];
  926.           *(p0+2) = aData[0][2];
  927.           p0+=3;
  928.           *p1     = aData[1][0];
  929.           *(p1+1) = aData[1][1];
  930.           *(p1+2) = aData[1][2];
  931.           p1+=3;
  932.         } while (--Len);
  933.       }
  934.     }
  935.     /* Draw right portion */
  936.     if ((x1&7)!=7) {
  937.       U8* pMask = GetMaskRight(x1);
  938.       for (i=0; i<3; i++, pMask++) {
  939.         *(p0+i) = (*(p0+i) &~*pMask) | (aData[0][i]&*pMask);
  940.         *(p1+i) = (*(p1+i) &~*pMask) | (aData[1][i]&*pMask);
  941.       }
  942.     }
  943.   }
  944. }
  946. /*
  947.         *********************************************************
  948.         *                                                       *
  949.         *          LCD_DrawHLine                                *
  950.         *                                                       *
  951.         *          Unoptimized                                  *
  952.         *                                                       *
  953.         *********************************************************
  954. */
  956. #else
  957. void LCD_L0_DrawHLine(int x0, int y,  int x1) {
  958.   if (x0>x1) return;  /* Check if nothing to draw */
  959.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  960.     while (x0 <= x1) {
  961.       XORPIXEL(x0, y);
  962.       x0++;
  963.     }
  964.   } else {
  965.     while (x0 <= x1) {
  966.       SETPIXEL(x0, y, COLOR);
  967.       x0++;
  968.     }
  969.   }
  970. }
  971. #endif
  974. /*
  975.         *********************************************************
  976.         *                                                       *
  977.         *          LCD_DrawVLine                                *
  978.         *                                                       *
  979.         *          Unoptimized                                  *
  980.         *                                                       *
  981.         *********************************************************
  982. */
  984. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  985.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  986.     while (y0 <= y1) {
  987.       XORPIXEL(x, y0);
  988.       y0++;
  989.     }
  990.   } else {
  991.     while (y0 <= y1) {
  992.       SETPIXEL(x, y0, COLOR);
  993.       y0++;
  994.     }
  995.   }
  996. }
  998. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  999.   for (; y0 <= y1; y0++) {
  1000.     LCD_L0_DrawHLine(x0,y0, x1);
  1001.   }
  1002. }
  1005. /*
  1006.   ***************************************************************
  1007.   *                                                             *
  1008.   *            Internal bitmap routines                         *
  1009.   *                                                             *
  1010.   ***************************************************************
  1012. */
  1015. /*
  1016.     *********************************************
  1017.     *                                           *
  1018.     *      Draw Bitmap 1 BPP                    *
  1019.     *                                           *
  1020.     *********************************************
  1021. */
  1023. static void  DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1024.   LCD_PIXELINDEX pixels;
  1025.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  1026.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  1027. /*
  1028. // Jump to right entry point
  1029. */
  1030.   pixels = *p;
  1031.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  1032.   case 0:
  1033. #if      (LCD_OPTIMIZE)             
  1034.       && (!LCD_MIRROR_X)            
  1035.       && (!LCD_MIRROR_Y)            
  1036.       && (!LCD_SWAP_XY)             
  1037.       && (!LCD_SUPPORT_COMTRANS)    
  1038.       && (!LCD_SUPPORT_SEGTRANS)    
  1039.       && ((LCD_BITSPERPIXEL == 3) || (LCD_BITSPERPIXEL == 6))
  1040.     SetPosXY(x+(Diff&7),y);
  1041. #endif
  1042.     switch (Diff&7) {
  1043.     case 0:   
  1044.       goto WriteBit0;
  1045.     case 1:   
  1046.       goto WriteBit1;
  1047.     case 2:
  1048.       goto WriteBit2;
  1049.     case 3:
  1050.       goto WriteBit3;
  1051.     case 4:
  1052.       goto WriteBit4;
  1053.     case 5:   
  1054.       goto WriteBit5;
  1055.     case 6:   
  1056.       goto WriteBit6;
  1057.     case 7:   
  1058.       goto WriteBit7;
  1059.     }
  1060.     break;
  1061.   case LCD_DRAWMODE_TRANS:
  1062.     switch (Diff&7) {
  1063.     case 0:
  1064.       goto WriteTBit0;
  1065.     case 1:
  1066.       goto WriteTBit1;
  1067.     case 2:
  1068.       goto WriteTBit2;
  1069.     case 3:
  1070.       goto WriteTBit3;
  1071.     case 4:
  1072.       goto WriteTBit4;
  1073.     case 5:   
  1074.       goto WriteTBit5;
  1075.     case 6:   
  1076.       goto WriteTBit6;
  1077.     case 7:   
  1078.       goto WriteTBit7;
  1079.     }
  1080.     break;
  1081.   case LCD_DRAWMODE_XOR:
  1082.     switch (Diff&7) {
  1083.     case 0:   
  1084.       goto WriteXBit0;
  1085.     case 1:   
  1086.       goto WriteXBit1;
  1087.     case 2:
  1088.       goto WriteXBit2;
  1089.     case 3:
  1090.       goto WriteXBit3;
  1091.     case 4:
  1092.       goto WriteXBit4;
  1093.     case 5:   
  1094.       goto WriteXBit5;
  1095.     case 6:   
  1096.       goto WriteXBit6;
  1097.     case 7:   
  1098.       goto WriteXBit7;
  1099.     }
  1100.   }
  1101. /*
  1102.         Write with transparency
  1103. */
  1104.   WriteTBit0:
  1105.     if (pixels&(1<<7)) SETPIXEL(x+0, y, Index1);
  1106.     if (!--xsize)
  1107.       return;
  1108.   WriteTBit1:
  1109.     if (pixels&(1<<6)) SETPIXEL(x+1, y, Index1);
  1110.     if (!--xsize)
  1111.       return;
  1112.   WriteTBit2:
  1113.     if (pixels&(1<<5)) SETPIXEL(x+2, y, Index1);
  1114.     if (!--xsize)
  1115.       return;
  1116.   WriteTBit3:
  1117.     if (pixels&(1<<4)) SETPIXEL(x+3, y, Index1);
  1118.     if (!--xsize)
  1119.       return;
  1120.   WriteTBit4:
  1121.     if (pixels&(1<<3)) SETPIXEL(x+4, y, Index1);
  1122.     if (!--xsize)
  1123.       return;
  1124.   WriteTBit5:
  1125.     if (pixels&(1<<2)) SETPIXEL(x+5, y, Index1);
  1126.     if (!--xsize)
  1127.       return;
  1128.   WriteTBit6:
  1129.     if (pixels&(1<<1)) SETPIXEL(x+6, y, Index1);
  1130.     if (!--xsize)
  1131.       return;
  1132.   WriteTBit7:
  1133.     if (pixels&(1<<0)) SETPIXEL(x+7, y, Index1);
  1134.     if (!--xsize)
  1135.       return;
  1136.     x+=8;
  1137.     pixels = *(++p);
  1138.     goto WriteTBit0;
  1140. /*
  1141.         Write without transparency
  1142. */
  1143. #if      (LCD_OPTIMIZE)             
  1144.       && (!LCD_MIRROR_X)            
  1145.       && (!LCD_MIRROR_Y)            
  1146.       && (!LCD_SWAP_XY)             
  1147.       && (!LCD_SUPPORT_COMTRANS)    
  1148.       && (!LCD_SUPPORT_SEGTRANS)    
  1149.       && ((LCD_BITSPERPIXEL == 3) || (LCD_BITSPERPIXEL == 6))
  1151.   WriteBit0:
  1152.     SetNextPixel((pixels&(1<<7)) ? Index1 : Index0);
  1153.     if (!--xsize) return;
  1154.   WriteBit1:
  1155.     SetNextPixel((pixels&(1<<6)) ? Index1 : Index0);
  1156.     if (!--xsize) return;
  1157.   WriteBit2:
  1158.     SetNextPixel((pixels&(1<<5)) ? Index1 : Index0);
  1159.     if (!--xsize) return;
  1160.   WriteBit3:
  1161.     SetNextPixel((pixels&(1<<4)) ? Index1 : Index0);
  1162.     if (!--xsize) return;
  1163.   WriteBit4:
  1164.     SetNextPixel((pixels&(1<<3)) ? Index1 : Index0);
  1165.     if (!--xsize) return;
  1166.   WriteBit5:
  1167.     SetNextPixel((pixels&(1<<2)) ? Index1 : Index0);
  1168.     if (!--xsize) return;
  1169.   WriteBit6:
  1170.     SetNextPixel((pixels&(1<<1)) ? Index1 : Index0);
  1171.     if (!--xsize) return;
  1172.   WriteBit7:
  1173.     SetNextPixel((pixels&(1<<0)) ? Index1 : Index0);
  1174.     if (!--xsize) return;
  1175.     x+=8;
  1176.     pixels = *(++p);
  1177.     goto WriteBit0;
  1178. #else
  1179.   WriteBit0:
  1180.     SETPIXEL(x+0, y, (pixels&(1<<7)) ? Index1 : Index0);
  1181.     if (!--xsize)
  1182.       return;
  1183.   WriteBit1:
  1184.     SETPIXEL(x+1, y, (pixels&(1<<6)) ? Index1 : Index0);
  1185.     if (!--xsize)
  1186.       return;
  1187.   WriteBit2:
  1188.     SETPIXEL(x+2, y, (pixels&(1<<5)) ? Index1 : Index0);
  1189.     if (!--xsize)
  1190.       return;
  1191.   WriteBit3:
  1192.     SETPIXEL(x+3, y, (pixels&(1<<4)) ? Index1 : Index0);
  1193.     if (!--xsize)
  1194.       return;
  1195.   WriteBit4:
  1196.     SETPIXEL(x+4, y, (pixels&(1<<3)) ? Index1 : Index0);
  1197.     if (!--xsize)
  1198.       return;
  1199.   WriteBit5:
  1200.     SETPIXEL(x+5, y, (pixels&(1<<2)) ? Index1 : Index0);
  1201.     if (!--xsize)
  1202.       return;
  1203.   WriteBit6:
  1204.     SETPIXEL(x+6, y, (pixels&(1<<1)) ? Index1 : Index0);
  1205.     if (!--xsize)
  1206.       return;
  1207.   WriteBit7:
  1208.     SETPIXEL(x+7, y, (pixels&(1<<0)) ? Index1 : Index0);
  1209.     if (!--xsize)
  1210.       return;
  1211.     x+=8;
  1212.     pixels = *(++p);
  1213.     goto WriteBit0;
  1214. #endif
  1215. /*
  1216.         Write XOR mode
  1217. */
  1218.   WriteXBit0:
  1219.     if (pixels&(1<<7))
  1220.       XORPIXEL(x+0, y);
  1221.     if (!--xsize)
  1222.       return;
  1223.   WriteXBit1:
  1224.     if (pixels&(1<<6))
  1225.       XORPIXEL(x+1, y);
  1226.     if (!--xsize)
  1227.       return;
  1228.   WriteXBit2:
  1229.     if (pixels&(1<<5))
  1230.       XORPIXEL(x+2, y);
  1231.     if (!--xsize)
  1232.       return;
  1233.   WriteXBit3:
  1234.     if (pixels&(1<<4))
  1235.       XORPIXEL(x+3, y);
  1236.     if (!--xsize)
  1237.       return;
  1238.   WriteXBit4:
  1239.     if (pixels&(1<<3))
  1240.       XORPIXEL(x+4, y);
  1241.     if (!--xsize)
  1242.       return;
  1243.   WriteXBit5:
  1244.     if (pixels&(1<<2))
  1245.       XORPIXEL(x+5, y);
  1246.     if (!--xsize)
  1247.       return;
  1248.   WriteXBit6:
  1249.     if (pixels&(1<<1))
  1250.       XORPIXEL(x+6, y);
  1251.     if (!--xsize)
  1252.       return;
  1253.   WriteXBit7:
  1254.     if (pixels&(1<<0))
  1255.       XORPIXEL(x+7, y);
  1256.     if (!--xsize)
  1257.       return;
  1258.     x+=8;
  1259.     pixels = *(++p);
  1260.     goto WriteXBit0;
  1261. }
  1264. /*
  1265.     *********************************************
  1266.     *                                           *
  1267.     *      Draw Bitmap 2 BPP                    *
  1268.     *                                           *
  1269.     *********************************************
  1270. */
  1272. #if (LCD_MAX_LOG_COLORS > 2)
  1273. static void  DrawBitLine2BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1274.   LCD_PIXELINDEX pixels;
  1275. /*
  1276. // Jump to right entry point
  1277. */
  1278.   pixels = *p;
  1279.   if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1280.     switch (Diff&3) {
  1281.     case 0:
  1282.       goto WriteTBit0;
  1283.     case 1:
  1284.       goto WriteTBit1;
  1285.     case 2:
  1286.       goto WriteTBit2;
  1287.     default:
  1288.       goto WriteTBit3;
  1289.     }
  1290.   } else {
  1291.     switch (Diff&3) {
  1292.     case 0:
  1293.       goto WriteBit0;
  1294.     case 1:
  1295.       goto WriteBit1;
  1296.     case 2:
  1297.       goto WriteBit2;
  1298.     default:
  1299.       goto WriteBit3;
  1300.     }
  1301.   }
  1302. /*
  1303.         Write without transparency
  1304. */
  1305. WriteBit0:
  1306.   SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1307.   if (!--xsize)
  1308.     return;
  1309. WriteBit1:
  1310.   SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1311.   if (!--xsize)
  1312.     return;
  1313. WriteBit2:
  1314.   SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1315.   if (!--xsize)
  1316.     return;
  1317. WriteBit3:
  1318.   SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1319.   if (!--xsize)
  1320.     return;
  1321.   pixels = *(++p);
  1322.   x+=4;
  1323.   goto WriteBit0;
  1324. /*
  1325.         Write with transparency
  1326. */
  1327. WriteTBit0:
  1328.   if (pixels&(3<<6))
  1329.     SETPIXEL(x+0, y, *(pTrans+(pixels>>6)));
  1330.   if (!--xsize)
  1331.     return;
  1332. WriteTBit1:
  1333.   if (pixels&(3<<4))
  1334.     SETPIXEL(x+1, y, *(pTrans+(3&(pixels>>4))));
  1335.   if (!--xsize)
  1336.     return;
  1337. WriteTBit2:
  1338.   if (pixels&(3<<2))
  1339.     SETPIXEL(x+2, y, *(pTrans+(3&(pixels>>2))));
  1340.   if (!--xsize)
  1341.     return;
  1342. WriteTBit3:
  1343.   if (pixels&(3<<0))
  1344.     SETPIXEL(x+3, y, *(pTrans+(3&(pixels))));
  1345.   if (!--xsize)
  1346.     return;
  1347.   pixels = *(++p);
  1348.   x+=4;
  1349.   goto WriteTBit0;
  1350. }
  1351. #endif
  1354. /*
  1355.     *********************************************
  1356.     *                                           *
  1357.     *      Draw Bitmap 4 BPP                    *
  1358.     *                                           *
  1359.     *********************************************
  1360. */
  1362. #if (LCD_MAX_LOG_COLORS > 4)
  1363. static void  DrawBitLine4BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  1364.   LCD_PIXELINDEX pixels;
  1365. /*
  1366. // Jump to right entry point
  1367. */
  1368.   pixels = *p;
  1369.    if (GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) {
  1370.      if ((Diff&1) ==0) {
  1371.        goto WriteTBit0;
  1372.      } else {
  1373.         goto WriteTBit1;
  1374.      }
  1375.    } else {
  1376.      if ((Diff&1) ==0) {
  1377.        goto WriteBit0;
  1378.      } else {
  1379.         goto WriteBit1;
  1380.      }
  1381.    }
  1382. /*
  1383.         Write without transparency
  1384. */
  1385. WriteBit0:
  1386.   SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1387.   if (!--xsize)
  1388.     return;
  1389. WriteBit1:
  1390.   SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1391.   if (!--xsize)
  1392.     return;
  1393.   x+=2;
  1394.   pixels = *(++p);
  1395.   goto WriteBit0;
  1396. /*
  1397.         Write with transparency
  1398. */
  1399. WriteTBit0:
  1400.   if (pixels>>4)
  1401.     SETPIXEL(x+0, y, *(pTrans+(pixels>>4)));
  1402.   if (!--xsize)
  1403.     return;
  1404. WriteTBit1:
  1405.   if (pixels&0xf)
  1406.     SETPIXEL(x+1, y, *(pTrans+(pixels&0xf)));
  1407.   if (!--xsize)
  1408.     return;
  1409.   x+=2;
  1410.   pixels = *(++p);
  1411.   goto WriteTBit0;
  1412. }
  1413. #endif
  1416. /*
  1417.     *********************************************
  1418.     *                                           *
  1419.     *      Draw Bitmap 8 BPP  (256 colors)      *
  1420.     *                                           *
  1421.     *********************************************
  1422. */
  1424. #if (LCD_MAX_LOG_COLORS > 16)
  1425. static void  DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  1426.   LCD_PIXELINDEX pixels;
  1427.   do {
  1428.     pixels = *p;
  1429.     SETPIXEL(x+0, y, *(pTrans+pixels));
  1430.     x++;
  1431.     p++;
  1432.   } while (--xsize);
  1433. }
  1434. #endif
  1437. /*
  1438.     **********************************************************************
  1439.     *                                                                    *
  1440.     *             Universal draw Bitmap routine                          *
  1441.     *                                                                    *
  1442.     **********************************************************************
  1443. */
  1445. void LCD_L0_DrawBitmap   (int x0, int y0,
  1446.                        int xsize, int ysize,
  1447.                        int BitsPerPixel, 
  1448.                        int BytesPerLine,
  1449.                        const U8* pData, int Diff,
  1450.                        const LCD_PIXELINDEX* pTrans)
  1451. {
  1452.   int i;
  1453.   /* Use aID for bitmaps without palette */
  1454.   if (!pTrans) {
  1455.     pTrans = aID;
  1456.   }
  1457.   /* Use DrawBitLineXBPP */
  1458.   for (i=0; i<ysize; i++) {
  1459.     switch (BitsPerPixel) {
  1460.     case 1:
  1461.       DrawBitLine1BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1462.       break;
  1463.     #if (LCD_MAX_LOG_COLORS > 2)
  1464.       case 2:
  1465.         DrawBitLine2BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1466.         break;
  1467.     #endif
  1468.     #if (LCD_MAX_LOG_COLORS > 4)
  1469.       case 4:
  1470.         DrawBitLine4BPP(x0, i+y0, pData, Diff, xsize, pTrans);
  1471.         break;
  1472.     #endif
  1473.       case 8:
  1474.     #if (LCD_MAX_LOG_COLORS > 16)
  1475.         DrawBitLine8BPP(x0, i+y0, pData, xsize, pTrans);
  1476.     #else
  1477.         DEBUG_WARN("nCan not display 8bpp bitmaps, please #define LCD_MAX_LOG_COLORS 256");
  1478.     #endif
  1479.     }
  1480.     pData += BytesPerLine;
  1481.   }
  1482. }
  1485. /*
  1486.         *********************************************************
  1487.         *                                                       *
  1488.         *       LCD_L0_SetOrg                                   *
  1489.         *                                                       *
  1490.         *********************************************************
  1492. Purpose:        Sets the original position of the virtual display.
  1493.                 Has no function at this point with the PC-driver.
  1494. */
  1496. #if LCD_SUPPORT_SETORG
  1498. void LCD_L0_SetOrg(int x, int y) {
  1499.   int Off;
  1500.   if (y>(LCD_VYSIZE_PHYS-LCD_YSIZE_PHYS))
  1501.   y = LCD_VYSIZE_PHYS-LCD_YSIZE_PHYS;
  1502.   Off = y*LCD_BYTESPERLINE+(x>>3);
  1503.   #if   (LCD_BITSPERPIXEL == 3)
  1504.   {
  1505.     int i;
  1506.     for (i=0; i<LCD_BITSPERPIXEL/3; i++) {
  1507.       #ifndef WIN32
  1508.         LCD__apVRam[i] = &LCD_VRam[i][0] +Off;
  1509.       #endif
  1510.     }
  1511.   }
  1512.   #elif (LCD_BITSPERPIXEL == 6)
  1513.     #ifndef WIN32
  1514.       LCD__apVRam[0] = &LCD_VRam_0[0] +Off;
  1515.       LCD__apVRam[1] = &LCD_VRam_1[0] +Off;
  1516.     #endif
  1517.   #endif
  1518. }
  1519. #endif
  1522.   /*
  1523.         *********************************************************
  1524.         *                                                       *
  1525.         *           Support for verification                    *
  1526.         *                                                       *
  1527.         *********************************************************
  1529. The following routines are implemented, but have no functionility
  1530. at this point. The reason is that these functions are supposed
  1531. to supervise the hardware, which for obvious reasons can not be
  1532. done in a simulation.
  1534. */
  1536. #if LCD_VERIFY
  1537. int  LCD_GetErrStat(void) {
  1538.   return 0;
  1539. }
  1540. void LCD_ClrErrStat(void) {
  1541. }
  1542. int  LCD_GetErrCnt (void) {
  1543.   return 0;
  1544. }
  1545. #endif  
  1549. /*
  1550.         *********************************************************
  1551.         *                                                       *
  1552.         *       LCD_On                                          *
  1553.         *       LCD_Off                                         *
  1554.         *                                                       *
  1555.         *********************************************************
  1556. These funtions are not implemented for this driver, they
  1557. have to be in the external modul which refreshes the LCD
  1558. regularily.
  1559. */
  1561. #ifndef WIN32
  1562. void LCD_Off          (void) {
  1563. #ifdef LCD_OFF
  1564.     LCD_OFF(); 
  1565. #endif
  1566. }
  1567. #endif
  1569. #ifndef WIN32
  1570. void LCD_On           (void) {
  1571. #ifdef LCD_ON
  1572.     LCD_ON(); 
  1573. #endif
  1574. }
  1575. #endif
  1577. /*
  1578.         *********************************************************
  1579.         *                                                       *
  1580.         *       LCD_ReInit : Re-Init the display                *
  1581.         *                                                       *
  1582.         *********************************************************
  1584. ReInit contains all of the code that can be re-executed at any point without
  1585. changing or even disturbing what can be seen on the LCD.
  1586. Note that it is also used as a subroutine by LCD_Init().
  1588. */
  1590. void  LCD_ReInit(void) {
  1591. }
  1594. /*
  1595.         *********************************************************
  1596.         *                                                       *
  1597.         *       LCD_Init : Init the display                     *
  1598.         *                                                       *
  1599.         *********************************************************
  1600. */
  1602. int  LCD_L0_Init(void) {
  1603. #ifdef WIN32
  1604.   #if   (LCD_BITSPERPIXEL == 3)
  1605.     pVRam = GetpVRam(LCD_VYSIZE_PHYS*LCD_BYTESPERLINE);
  1606.   #elif (LCD_BITSPERPIXEL == 6)
  1607.     pVRam_0 = GetpVRam(LCD_VYSIZE_PHYS*LCD_BYTESPERLINE);
  1608.     pVRam_1 = pVRam_0 + LCD_VYSIZE_PHYS * LCD_BYTESPERLINE;
  1609.   #endif
  1610. #endif
  1611.   LCD_Off();
  1612.   LCD_ReInit();
  1613.   LCD_L0_SetOrg(0,0);
  1614.   /* Clear entire video RAM */
  1615.   LCD_SetDrawMode(LCD_DRAWMODE_REV);
  1616.   LCD_FillRect(0,0,4095,4095);
  1617.   LCD_SetDrawMode(0);
  1618.   LCD_On();
  1619.   return 0;
  1620. }
  1623. /*
  1624.         *********************************************************
  1625.         *                                                       *
  1626.         *       LCD_L0_CheckInit                                   *
  1627.         *                                                       *
  1628.         *  Check if display controller(s) is/are still          *
  1629.         *  properly initialized                                 *
  1630.         *                                                       *
  1631.         *********************************************************
  1633. Return value: 0 => No error, init is O.K.
  1634. */
  1636. int LCD_L0_CheckInit(void) {
  1637.     return 0;
  1638. }
  1641. /*
  1642.         *********************************************************
  1643.         *                                                       *
  1644.         *                   LCD_L0_SetLUTEntry                  *
  1645.         *                                                       *
  1646.         *********************************************************
  1648. */
  1650. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  1651.   LCD_USE_PARA(Pos);
  1652.   LCD_USE_PARA(color);
  1653. }
  1656. #endif  /*(LCD_CONTROLLER/100 == 0) */
  1658. void LCDMemC(void) { } /* avoid empty object files */