lcd13xx.c

在ucos上实现了图形用户接口GUI；值得一看

	*********************************************************
	*                                                       *
	*          LCD_L0_DrawHLine 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_DrawHLine  (int x0, int y,  int x1) {
  int oldcolor=getcolor ();
  setcolor (COLOR);
  line (x0,y,x1,y);
  setcolor (oldcolor);
 /* 
  #if LCD_MIRROR_X
    #define X0 (LCD_XSIZE-1-(x1))
    #define X1 (LCD_XSIZE-1-(x0))
  #else
    #define X0 x0
    #define X1 x1
  #endif
  #if LCD_MIRROR_Y
    #define Y0 (LCD_YSIZE-1-(y))
  #else
    #define Y0 y
  #endif
  if (x0>x1) return;
  LCD_FillRectBB(X0,Y0,X1,Y0);
  #undef X0
  #undef X1
  #undef Y0
*/
}






/*
	*********************************************************
	*                                                       *
	*          LCD_L0_DrawHLine optimized                      *
	*                                                       *
	*          16 bit bus, 16 bpp                           *
	*                                                       *
	*********************************************************
*/
/*
#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (!LCD_MIRROR_Y)         \
      && (LCD_BUSWIDTH==16)      \
      && (!defined (LCD_LUT_COM))   \
      && (!defined (LCD_LUT_SEG))   \
      && ((LCD_BITSPERPIXEL == 16) || (LCD_BITSPERPIXEL == 15))

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 = XY2OFF(X0,y);
    register int Rem = x1-x0+1;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; Rem--; Off++) {
	U16 Data;
	READ_MEM(Off, Data);
	Data = LCD_NUM_COLORS-1-Data;
	WRITE_MEM(Off,Data);
      }
    } else {
      for (; Rem >= 8; Off += 8) {
	WRITE_MEM(Off,COLOR);
	WRITE_MEM(Off+1,COLOR);
	WRITE_MEM(Off+2,COLOR);
	WRITE_MEM(Off+3,COLOR);
	WRITE_MEM(Off+4,COLOR);
	WRITE_MEM(Off+5,COLOR);
	WRITE_MEM(Off+6,COLOR);
	WRITE_MEM(Off+7,COLOR);
	Rem -=8;
      }
      for (; Rem--; Off++) {
	WRITE_MEM(Off,COLOR);
      }
    }
  }
  #undef X0
}
*/





/*
	*********************************************************
	*                                                       *
	*          LCD_L0_DrawHLine optimized                   *
	*                                                       *
	*          16 bit bus, 8 bpp                            *
	*                                                       *
	*********************************************************
*/
/*
#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (LCD_BUSWIDTH==16)      \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 8)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
  {
    int t = (LCD_XSIZE-1-(x0));
    x0 = (LCD_XSIZE-1-(x1));
    x1 = t;
  }
  #endif
  #if LCD_MIRROR_Y
    y = (LCD_YSIZE-1-(y));
  #endif
  {
    register tOff Off = XY2OFF(x0,y);
    // register
    U16 Data;
// XOR mode
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      if (x0&1) {
	READ_MEM(Off, Data);
	Data ^= ((unsigned int)255);
	WRITE_MEM(Off,Data);
	x0++;
	Off++;
      }
      for (; x0<x1; x0+=2, Off++) {
	READ_MEM(Off,Data);
	Data ^= 0xffff;
	WRITE_MEM(Off,Data);
      }
      if ((x1&1)==0) {
	READ_MEM(Off,Data);
	Data ^=  (U16)255<<8;
	WRITE_MEM(Off,Data);
      }
// WRITE mode
    } else {
      if (x0&1) {
	READ_MEM(Off,Data);
	Data = (Data&((U16)0xff<<8)) | (COLOR);
	WRITE_MEM(Off,Data);
	x0++;
	Off++;
      }
      Data = COLOR|((U16)COLOR<<8);
      // Optimization for longer lines ...
      #ifdef LCD_WRITE_MEM32
      if ((x0<x1-4) && (x0&2)) { // Write 16 bits if necessary
	WRITE_MEM(Off,Data);
	x0+=2;
	Off++;
      }
      // write 4 pixels at a time, loop unrolled
      { register U32 Data32 = Data| (Data<<16);
	for (;x0<x1-32-2; x0+=32, Off+=16) {
	  LCD_WRITE_MEM32(Off+0,Data32);
	  LCD_WRITE_MEM32(Off+2,Data32);
	  LCD_WRITE_MEM32(Off+4,Data32);
	  LCD_WRITE_MEM32(Off+6,Data32);
	  LCD_WRITE_MEM32(Off+8,Data32);
	  LCD_WRITE_MEM32(Off+10,Data32);
	  LCD_WRITE_MEM32(Off+12,Data32);
	  LCD_WRITE_MEM32(Off+14,Data32);
	}
      }
      { register U32 Data32 = Data| (Data<<16);
	for (;x0<x1-16-2; x0+=16, Off+=8) {
	  LCD_WRITE_MEM32(Off+0,Data32);
	  LCD_WRITE_MEM32(Off+2,Data32);
	  LCD_WRITE_MEM32(Off+4,Data32);
	  LCD_WRITE_MEM32(Off+6,Data32);
	}
      }
      { register U32 Data32 = Data| (Data<<16);
	for (;x0<x1-8-2; x0+=8, Off+=4) {
	  LCD_WRITE_MEM32(Off+0,Data32);
	  LCD_WRITE_MEM32(Off+2,Data32);
	}
      }
      #else
      for (;x0<x1-10; x0+=12, Off+=6) {
	// swapping can be ignored, so use faster LCD_WRITE_MEM
	LCD_WRITE_MEM(Off,Data);
	LCD_WRITE_MEM(Off+1,Data);
	LCD_WRITE_MEM(Off+2,Data);
	LCD_WRITE_MEM(Off+3,Data);
	LCD_WRITE_MEM(Off+4,Data);
	LCD_WRITE_MEM(Off+5,Data);
      }
      #endif
      // write the last pixels 2 at a time
      for (; x0<x1; x0+=2, Off++) {
	// swapping can be ignored, so use faster LCD_WRITE_MEM
	LCD_WRITE_MEM(Off,Data);
      }
      if ((x1&1)==0) {
	READ_MEM(Off, Data);
	Data = (Data&((unsigned int)0xff)) | ((U16)COLOR<<8);
	WRITE_MEM(Off,Data);
      }
    }
  }
}
*/





/*
	*********************************************************
	*                                                       *
	*          LCD_L0_DrawHLine optimized                   *
	*                                                       *
	*          16 bit bus, 4 bpp                            *
	*                                                       *
        *********************************************************
*/
/*
#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (LCD_BUSWIDTH==16)      \
      && (!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 LCD_MIRROR_Y
    #define Y (LCD_YSIZE - 1 - y)
  #else
    #define Y y
  #endif
  if (x0>x1) return;
  {
    register tOff Off;
    register int Rem;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; (x0&3    )&&(x0<=x1); x0++) XORPIXEL(x0, y);
      for (; ((x1+1)&3)&&(x0<=x1); x1--) XORPIXEL(x1, y);
      Off = XY2OFF(X0,Y);
      Rem = (x1-x0+4)>>2;
      for (; Rem--; Off++) {
	U16 c;
	READ_MEM(Off, c);
	c ^= 0xffff;
	WRITE_MEM(Off,c);
      }
    } else {
      U16 col = COLOR+(COLOR<<4)+(COLOR<<8)+(COLOR<<12);
      for (; (x0&3    )&&(x0<=x1); x0++)
	SETPIXEL(x0, y, COLOR);
      for (; ((x1+1)&3)&&(x0<=x1); x1--)
	SETPIXEL(x1, y, COLOR);
      Off = XY2OFF(X0,Y);
      Rem = (x1-x0+4)>>2;
      for (; Rem--; Off++) {
	// swapping can be ignored, so use faster LCD_WRITE_MEM
	LCD_WRITE_MEM(Off,col);
      }
    }
  }
  #undef X0
}
*/






/*
	*********************************************************
	*                                                       *
	*          LCD_L0_DrawHLine optimized                   *
	*                                                       *
	*          16 bit bus, 1 bpp                            *
	*                                                       *
	*********************************************************
*/
/*
#elif (LCD_OPTIMIZE)             \
      && (!LCD_SWAP_XY)          \
      && (LCD_BUSWIDTH==16)      \
      && (!defined (LCD_LUT_SEG))   \
      && (LCD_BITSPERPIXEL == 1)

void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  #if LCD_MIRROR_X
  {
    int temp = x0;
    x0 = (LCD_XSIZE-1-(x1));
    x1 = (LCD_XSIZE-1-(temp));
  }
  #endif
  #if LCD_MIRROR_Y
  {
    y = (LCD_YSIZE - 1 - y);
  }
  #endif
  {
    register tOff Off = XY2OFF(x0,y);
    int iWord = x0>>4;
    int Word1 = x1>>4;
    U16 Mask   =  0xffff   >> (x0&15);
    U16 EndMask = 0xffff8000 >> (x1&15);
    U16 Data;
    if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
      for (; iWord<Word1; iWord++) {
	READ_MEM(Off,Data);
	Data ^= Mask;
	WRITE_MEM(Off++,Data);
	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)