lcd13xx.c

lpc2478+ucosII+ucgui源码

        Mask = 0xffff;
      }
      Mask &= EndMask;
      READ_MEM(Off,Data);
      Data ^= Mask; 
      WRITE_MEM(Off++,Data);
    } else {                                  /* Clear pixels in line */
      int NumWords = Word1-iWord;
      if (COLOR==0) {
        if (NumWords) {
          READ_MEM(Off,Data);
          Data &= ~Mask;
          WRITE_MEM(Off++,Data);
          NumWords--;
          /* Fill Words in 2 loops for speed reasons ... */
          for (; NumWords>=4; NumWords-=4) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
            LCD_WRITE_MEM(Off++,0);
          }
          for (; NumWords; NumWords--) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0);
          }
          Mask = 0xffff;
        }
        Mask &= EndMask;
        READ_MEM(Off, Data);
        Data &= ~Mask; 
        WRITE_MEM(Off++,Data);
      } else {                                  /* Set pixels in line */
        if (NumWords) {
          READ_MEM(Off, Data); 
          Data |= Mask; 
          WRITE_MEM(Off++,Data);
          NumWords--;
        /* Fill Words in 2 loops for speed reasons ... */
          for (; NumWords>=4; NumWords-=4) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
            LCD_WRITE_MEM(Off++,0xffff);
          }
          for (; NumWords; NumWords--) {
            /* swapping can be ignored, so use faster LCD_WRITE_MEM */
            LCD_WRITE_MEM(Off++,0xffff);
          }
          Mask = 0xffff;
        }
        Mask &= EndMask;
        READ_MEM(Off, Data); 
        Data |= Mask; 
        WRITE_MEM(Off++,Data);
      }
    }
  }
}

/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          8 bit bus, 8 bpp                             *
        *                                                       *
        *********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (LCD_BUSWIDTH==8)      \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 8)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
  #else
    #define X0 x0
  #endif
  #if LCD_MIRROR_Y
    y = LCD_YSIZE - 1 - y;
  #endif
  if (x0>x1) return;
  {
    register tOff Off = XY2OFF(X0,y);
    register int Rem = x1-x0+1;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; (--Rem)>=0; Off++) {
        U16 c;
        READ_MEM(Off,c);
        c ^= 0xff; 
        WRITE_MEM(Off,c);
      }
    } else {
      for (;Rem>=4;Off+=4,Rem-=4) {
        WRITE_MEM(Off,COLOR);
        WRITE_MEM(Off+1,COLOR);
        WRITE_MEM(Off+2,COLOR);
        WRITE_MEM(Off+3,COLOR);
	  }
      for (; (--Rem)>=0; Off++) {
        WRITE_MEM(Off,COLOR);
      }
    }
  }
  #undef X0
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          8 bit bus, 4 bpp                            *
        *                                                       *
        *********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_Y)         \
      && (LCD_BUSWIDTH==8)       \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 4)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
  #else
    #define X0 x0
  #endif
  if (x0>x1) return;
  {
    register tOff Off;
    register int Rem;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (;  (x0&1)      &&(x0<=x1); x0++) XORPIXEL(x0, y);
      for (; ((x1&1)!=1)  &&(x0<=x1); x1--) XORPIXEL(x1, y);
      Off = XY2OFF(X0,y);
      Rem = (x1-x0+2)>>1;
      for (; Rem--; Off++) {
        U16 c;
        READ_MEM(Off,c);
        c ^= 0xff; 
        WRITE_MEM(Off,c);
      }
    } else {
      U8 col = COLOR+(COLOR<<4);
      /* Draw pixels left of fill area */
      for (; (x0&1) && (x0<=x1); x0++)   SETPIXEL(x0, y, COLOR);
      /* Draw pixels right of fill area */
      for (; ((x1+1)&1)&&(x0<=x1); x1--) SETPIXEL(x1, y, COLOR);
      Off = XY2OFF(X0,y);
      Rem = (x1-x0+2)>>1;
      for (; Rem--; Off++) {
        WRITE_MEM(Off,col);
      }
    }
  }
  #undef X0
}


/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine optimized                      *
        *                                                       *
        *          8 bit bus, 1 bpp                             *
        *                                                       *
        *********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_Y)         \
      && (!LCD_MIRROR_X)         \
      && (LCD_BUSWIDTH==8)       \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 1)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  register tOff Off = XY2OFF(x0,y);
  int iByte = x0>>3;
  int Byte1 = x1>>3;
  U8 Mask =    0xff   >> (x0&7);
  U8 EndMask = 0xff80 >> (x1&7);
  U8 Data;
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    for (; iByte<Byte1; iByte++) {
      READ_MEM(Off,Data);
      Data ^= Mask; 
      WRITE_MEM(Off,Data);
      Mask = 0xff;
      Off++;
    }
    Mask &= EndMask;
    READ_MEM(Off,Data);
    Data ^= Mask; 
    WRITE_MEM(Off,Data);
  } else {                                  /* Clear pixels in line */
    int NumBytes = Byte1-iByte;
    if (COLOR==0) {
      if (NumBytes) {
        READ_MEM(Off,Data);
        Data &= (~Mask);
        WRITE_MEM(Off,Data);
        Off++; NumBytes--;
      /* Fill bytes in 2 loops for speed reasons ... */
        for (; NumBytes>=4; NumBytes-=4, Off+=4) {
          WRITE_MEM(Off,0);
          WRITE_MEM(Off+1,0);
          WRITE_MEM(Off+2,0);
          WRITE_MEM(Off+3,0);
        }
        for (; NumBytes; NumBytes--, Off++) {
          WRITE_MEM(Off,0);
        }
        Mask = 0xff;
      }
      Mask &= EndMask;
      READ_MEM(Off,Data);
      Data &= ~Mask; 
      WRITE_MEM(Off,Data);
    } else {                                  /* Set pixels in line */
      if (NumBytes) {
        READ_MEM(Off,Data); 
        Data |= Mask;
        WRITE_MEM(Off,Data);
        Off++; NumBytes--;
      /* Fill bytes in 2 loops for speed reasons ... */
        for (; NumBytes>=4; NumBytes-=4, Off+=4) {
          WRITE_MEM(Off,  0xff);
          WRITE_MEM(Off+1,0xff);
          WRITE_MEM(Off+2,0xff);
          WRITE_MEM(Off+3,0xff);
        }
        for (; NumBytes; NumBytes--, Off++) {
          WRITE_MEM(Off,0xff);
        }
        Mask = 0xff;
      }
      Mask &= EndMask;
      READ_MEM(Off,Data);
      Data |= Mask;
      WRITE_MEM(Off,Data);
    }
  }
}




/*
        *********************************************************
        *                                                       *
        *          LCD_L0_DrawHLine unoptimized                    *
        *                                                       *
        *********************************************************
*/

#else  /* Unoptimized variant */

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (x0 <= x1) {
      XORPIXEL(x0, y);
      x0++;
    }
  } else {
    while (x0 <= x1) {
      SETPIXEL(x0, y, COLOR);
      x0++;
    }
  }
}

#endif


/********************************************************
*
*          LCD_L0_DrawVLine optimized
*
*          16 bit bus, using BITBLT
*
*********************************************************
*/

#if (LCD_USE_BITBLT)           \
    && (!LCD_SWAP_XY)          \
    && (LCD_BUSWIDTH==16)      \
    && (!defined (LCD_LUT_COM))   \
    && (!defined (LCD_LUT_SEG))   \
    && ((LCD_CONTROLLER == 1356)||(LCD_CONTROLLER == 13806))

void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x))
  #else
    #define X0 x
  #endif
  #if LCD_MIRROR_Y
    #define Y0 (LCD_YSIZE-1-(y1))
    #define Y1 (LCD_YSIZE-1-(y0))
  #else
    #define Y0 y0
    #define Y1 y1
  #endif
  if (y0>y1) return;
  LCD_FillRectBB(X0,Y0,X0,Y1);
  #undef X0
  #undef Y0
  #undef Y1
}

/********************************************************
*
*          LCD_L0_DrawVLine optimized
*
*          8 bit bus, 4 bpp, SWAP_XY, MIRROR_Y
*
*********************************************************
*/

#elif (LCD_OPTIMIZE)             \
      && (LCD_SWAP_XY)          \
      && (LCD_MIRROR_Y)         \
      && (LCD_BUSWIDTH==8)       \
      && (!defined (LCD_LUT_COM))   \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 4)
      
void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  #if !LCD_MIRROR_X
    int y_P = x;
  #else
    int y_P = (LCD_XSIZE-1-(x1));
  #endif
  #if !LCD_MIRROR_Y
    int x0_P = y0;
    int x1_P = y1;
  #else
    int x0_P = (LCD_YSIZE-1-(y1));
    int x1_P = (LCD_YSIZE-1-(y0));
  #endif
  register tOff Off = XY2OFF(x0_P, y_P);
  register int Rem;
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    if (x0_P & 3)
      while (x0_P <=