lcdlin32.c

ucgui的3.98版本的源代码

        if (++Diff == 8) {
          Diff = 0;
          p++;
        }
      } while (--xsize);
      break;
    }
  }
}

/*********************************************************************
*
*       Draw Bitmap 1 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 8, LCD_SWAP_XY == 1
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 8) && \
    ( LCD_SWAP_XY)
static void _DrawBitLine1BPP_Swap(unsigned x, unsigned y, U8 const GUI_UNI_PTR * pData, int ysize, const U8 * pTrans, int BytesPerLine, U8 Pos) {
  unsigned x0, y0, Off;
  U32 Buffer, Data;
  U8 Index, Pixel, BufferValid, ShiftPos, DataMask;
  #if LCD_MIRROR_Y
    y0 = LCD_XSIZE - x - 1;
  #else
    y0 = x;
  #endif
  #if LCD_MIRROR_X
    x0 = LCD_YSIZE - y - 1;
  #else
    x0 = y;
  #endif
  Off         = XY2OFF(x0, y0);
  BufferValid = 0;
  ShiftPos    = 7 - (Pos & 7);
  DataMask    = 0x80 >> (7 - ShiftPos);
  #if LCD_MIRROR_X
    for (; ysize; ysize--, pData += BytesPerLine, x0--) {
  #else
    for (; ysize; ysize--, pData += BytesPerLine, x0++) {
  #endif
    U8 Shift = (x0 & 0x3) << 3;
    Pixel = (*pData & DataMask) >> ShiftPos;
    if (!BufferValid) {
      Buffer = READ_MEM(Off);
      BufferValid = 1;
    }
    switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
    case 0:
      Buffer &= ~(0xff << Shift);
      Index = *(pTrans + Pixel);
      Data = Index << Shift;
      Buffer |= Data;
      break;
    case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
    case LCD_DRAWMODE_XOR:
      if (Pixel) {
        Buffer ^= (0xff << Shift);
      }
      break;
    case LCD_DRAWMODE_TRANS:
      if (Pixel) {
        Buffer &= ~(0xff << Shift);
        Index = *(pTrans + Pixel);
        Data = Index << Shift;
        Buffer |= Data;
      }
      break;
    }
    #if LCD_MIRROR_X
      if (!(x0 & 0x3)) {
        BufferValid = 0;
        WRITE_MEM(Off--, Buffer);
      }
    #else
      if ((x0 & 0x3) == 0x3) {
        BufferValid = 0;
        WRITE_MEM(Off++, Buffer);
      }
    #endif
  }
  if (BufferValid) {
    WRITE_MEM(Off, Buffer);
  }
}

/*********************************************************************
*
*       Draw Bitmap 1 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 4
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 4) && \
    (!LCD_MIRROR_X) && \
    (!LCD_MIRROR_Y) && \
    (!LCD_SWAP_XY)
static void _DrawBitLine1BPP(unsigned x, unsigned y, U8 const GUI_UNI_PTR * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  U8 Mode;
  LCD_PIXELINDEX Index0 = *(pTrans + 0);
  LCD_PIXELINDEX Index1 = *(pTrans + 1);
  x += Diff;
  Mode = GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR);
  if (Mode == 0) {
    /* Check if filling will do ... */
    if (Index0 == Index1) {
      LCD_PIXELINDEX ColorIndexOld = LCD_COLORINDEX;  /* Save forground color */
      LCD_COLORINDEX = Index0;                        /* Set foreground color */
      LCD_L0_DrawHLine(x, y, x + xsize - 1);
      LCD_COLORINDEX = ColorIndexOld;
    } else { 
      /* O.K., we have to draw ... */
      int Off, NumPixel_0, NumPixel_1, i;
      U32 Data, ColorMask, AndMask;
      Off = y * DWORDS_PER_LINE + x / PIXELS_PER_DWORD;
      NumPixel_0 = x & (PIXELS_PER_DWORD - 1);
      NumPixel_1 = (x + xsize - 1) & (PIXELS_PER_DWORD - 1);
      /* First DWORD */
      if (NumPixel_0) {
        ColorMask = 0;
        AndMask = ~(0xFFFFFFFF << (4 * NumPixel_0));
        if ((8 - NumPixel_0) > xsize) {
          AndMask |= ~(0xFFFFFFFF >> (4 * (7 - NumPixel_1)));
        }
        for (i = NumPixel_0; (i < 8) && xsize; i++, xsize--) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (4 * i);
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
        Off++;
      }
      /* Complete DWORDS */
      while (xsize >= 8) {
        ColorMask = 0;
        for (i = 0; i < 8; i++) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (4 * i);
        }
        WRITE_MEM(Off, ColorMask);
        Off++;
        xsize -= 8;
      }
      /* Last DWORD */
      if (xsize) {
        ColorMask = i = 0;
        AndMask = 0xFFFFFFF0 << (4 * NumPixel_1);
        while (xsize) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (4 * i++);
          xsize--;
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
      }
    }
  } else {
    switch (Mode) {
    case LCD_DRAWMODE_TRANS:
      do {
        if (*p & (0x80 >> Diff)) {
          LCD_L0_SetPixelIndex(x, y, Index1);
        }
        x++;
        if (++Diff == 8) {
          Diff = 0;
          p++;
        }
      } while (--xsize);
      break;
    case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
    case LCD_DRAWMODE_XOR:
      do {
        if (*p & (0x80 >> Diff)) {
          int Pixel = LCD_L0_GetPixelIndex(x, y);
          LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - 1 - Pixel);
        }
        x++;
        if (++Diff == 8) {
          Diff = 0;
          p++;
        }
      } while (--xsize);
      break;
    }
  }
}

/*********************************************************************
*
*       Draw Bitmap 1 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 2
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 2) && \
    (!LCD_MIRROR_X) && \
    (!LCD_MIRROR_Y) && \
    (!LCD_SWAP_XY)
static void _DrawBitLine1BPP(unsigned x, unsigned y, U8 const GUI_UNI_PTR * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  U8 Mode;
  LCD_PIXELINDEX Index0 = *(pTrans + 0);
  LCD_PIXELINDEX Index1 = *(pTrans + 1);
  x += Diff;
  Mode = GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR);
  if (Mode == 0) {
    /* Check if filling will do ... */
    if (Index0 == Index1) {
      LCD_PIXELINDEX ColorIndexOld = LCD_COLORINDEX;  /* Save forground color */
      LCD_COLORINDEX = Index0;                        /* Set foreground color */
      LCD_L0_DrawHLine(x, y, x + xsize - 1);
      LCD_COLORINDEX = ColorIndexOld;
    } else { 
      /* O.K., we have to draw ... */
      int Off, NumPixel_0, NumPixel_1, i;
      U32 Data, ColorMask, AndMask;
      Off = y * DWORDS_PER_LINE + x / PIXELS_PER_DWORD;
      NumPixel_0 = x & (PIXELS_PER_DWORD - 1);
      NumPixel_1 = (x + xsize - 1) & (PIXELS_PER_DWORD - 1);
      /* First DWORD */
      if (NumPixel_0) {
        ColorMask = 0;
        AndMask = ~(0xFFFFFFFF << (2 * NumPixel_0));
        if ((16 - NumPixel_0) > xsize) {
          AndMask |= ~(0xFFFFFFFF >> (2 * (15 - NumPixel_1)));
        }
        for (i = NumPixel_0; (i < 16) && xsize; i++, xsize--) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (2 * i);
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
        Off++;
      }
      /* Complete DWORDS */
      while (xsize >= 16) {
        ColorMask = 0;
        for (i = 0; i < 16; i++) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (2 * i);
        }
        WRITE_MEM(Off, ColorMask);
        Off++;
        xsize -= 16;
      }
      /* Last DWORD */
      if (xsize) {
        ColorMask = i = 0;
        AndMask = 0xFFFFFFFC << (2 * NumPixel_1);
        while (xsize) {
          U8 Index = *p & (0x80 >> Diff) ? Index1 : Index0;
          if (++Diff == 8) {
            Diff = 0;
            p++;
          }
          ColorMask |= Index << (2 * i++);
          xsize--;
        }
        Data = READ_MEM(Off);
        Data &= AndMask;
        Data |= ColorMask;
        WRITE_MEM(Off, Data);
      }
    }
  } else {
    switch (Mode) {
    case LCD_DRAWMODE_TRANS:
      do {
        if (*p & (0x80 >> Diff)) {
          LCD_L0_SetPixelIndex(x, y, Index1);
        }
        x++;
        if (++Diff == 8) {
          Diff = 0;
          p++;
        }
      } while (--xsize);
      break;
    case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
    case LCD_DRAWMODE_XOR:
      do {
        if (*p & (0x80 >> Diff)) {
          int Pixel = LCD_L0_GetPixelIndex(x, y);
          LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - 1 - Pixel);
        }
        x++;
        if (++Diff == 8) {
          Diff = 0;
          p++;
        }
      } while (--xsize);
      break;
    }
  }
}

/*********************************************************************
*
*       Draw Bitmap 1 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 2, LCD_SWAP_XY == 1
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 2) && \
    (LCD_SWAP_XY)
static void _DrawBitLine1BPP_Swap(unsigned x, unsigned y, U8 const GUI_UNI_PTR * pData, int ysize, const U8 * pTrans, int BytesPerLine, U8 Pos) {
  unsigned x0, y0, Off;
  U32 Buffer, Data;
  U8 Index, Pixel, BufferValid, ShiftPos, DataMask;
  #if LCD_MIRROR_Y
    y0 = LCD_XSIZE - x - 1;
  #else
    y0 = x;
  #endif
  #if LCD_MIRROR_X
    x0 = LCD_YSIZE - y - 1;
  #else
    x0 = y;
  #endif
  Off         = XY2OFF(x0, y0);
  BufferValid = 0;
  ShiftPos    = 7 - (Pos & 7);
  DataMask    = 0x80 >> (7 - ShiftPos);
  #if LCD_MIRROR_X
    for (; ysize; ysize--, pData += BytesPerLine, x0--) {
  #else
    for (; ysize; ysize--, pData += BytesPerLine, x0++) {
  #endif
    U8 Shift = (x0 & 0xf) << 1;
    Pixel = (*pData & DataMask) >> ShiftPos;
    if (!BufferValid) {
      Buffer = READ_MEM(Off);
      BufferValid = 1;
    }
    switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
    case 0:
      Buffer &= ~(0x3 << Shift);
      Index = *(pTrans + Pixel);
      Data = Index << Shift;
      Buffer |= Data;
      break;
    case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
    case LCD_DRAWMODE_XOR:
      if (Pixel) {
        Buffer ^= (0x3 << Shift);
      }
      break;
    case LCD_DRAWMODE_TRANS:
      if (Pixel) {
        Buffer &= ~(0x3 << Shift);
        Index = *(pTrans + Pixel);
        Data = Index << Shift;
        Buffer |= Data;
      }
      break;
    }
    #if LCD_MIRROR_X
      if (!(x0 & 0xf)) {
        BufferValid = 0;
        WRITE_MEM(Off--, Buffer);
      }
    #else
      if ((x0 & 0xf) == 0xf) {
        BufferValid = 0;
        WRITE_MEM(Off++, Buffer);
      }
    #endif
  }
  if (BufferValid) {
    WRITE_MEM(Off, Buffer);
  }
}

/*********************************************************************
*
*       Draw Bitmap 1 BPP, optimized for LCD_ENDIAN_BIG == 0, LCD_BITSPERPIXEL == 1
*/
#elif (LCD_ENDIAN_BIG == 0) && \
    (LCD_BITSPERPIXEL == 1) && \
    (!LCD_MIRROR_X) && \
    (!LCD_MIRROR_Y) && \
    (!LCD_SWAP_XY)
static void _DrawBitLine1BPP(unsigned x, unsigned y, U8 const GUI_UNI_PTR * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  U8 Mode;
  LCD_PIXELINDEX Index0, Index1;
  #if (GUI_USE_MEMDEV_1BPP_FOR_SCREEN == 1)
    const LCD_PIXELINDEX aTrans[2] = {0, 1};
    if (!pTrans) {
      pTrans = aTrans;
    }
  #endif
  Index0 = *(pTrans + 0);
  Index1 = *(pTrans + 1);
  x += Diff;
  Mode = GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR);
  if (Mode == 0) {
    /* Check if filling will do ... */
    if (Index0 == Index1) {
      LCD_PIXELINDEX ColorIndexOld = LCD_COLORINDEX;  /* Save forground color */
      LCD_COLORINDEX = Index0;                        /* Set foreground color */
      LCD_L0_DrawHLine(x, y, x + xsize - 1);
      LCD_COLORINDEX = ColorIndexOld;
    } else { 
      /* O.K., we have to draw ... */
      int Off, NumPixel_0, NumPixel_1, i;
      U32 Data, ColorMask, AndMask;
      Off = y * DWORDS_PER_LINE + x / PIXELS_PER_DWORD;
      NumPixel_0 = x & (PIXELS_PER_DWORD - 1);
      NumPixel_1 = (x + xsize - 1) & (PIXELS_PER_DWORD - 1);
      /* First DWORD */
      if (NumPixel_0) {
        ColorMask = 0;