lcd6610.c

Nokia6610 LCD C PROGRAMME

     xs--;
     xe++;
   }
}

void RoundRect(unsigned char x,unsigned char y,unsigned char w,unsigned char h,unsigned char r)
{
char Ox,Oy,rr,xt,yt,rs,zx1,zy1;
int xx;
//if(x<0||y<0)return;

	
if (cbk&0x8000) 
{RGBToChar(cbk);
	
	Ox=x+r;Oy=y+r;
	yt=r;
	rr=r*r+1;			//补偿 1 修正方形
	rs=(yt+(yt>>1))>>1;		//(*0.75)分开1/8圆弧来画

	for (xt=0;xt<=rs;xt++)
	{
		xx=xt*xt;
		while ((yt*yt)>(rr-xx))yt--;
		
		zx=Ox+xt+w-(r*2);		//第一象限
		zx1=zx;
		zy=Oy-yt;
		//point2();
		
//		zy=Oy-yt;
		zx=Ox-xt;		//第二象限

		//point2();if (zy!=y)
			 {
		glcdFillRect(zx1-1,zy,zx+1,zy);
	}
	
		zx1=zx;
			
		zy=Oy+yt+h-(r*2);		//第三象限
		//point2();
		
		zx=Ox+xt+w-(r*2);		//第四象限if (zy!=y+h) 
			{
		glcdFillRect(zx1+1,zy,zx-1,zy);	
	}
//-----------------------------------------
		zx=Ox+yt+w-(r*2);		//第一象限
		zy=Oy-xt;
		//point2();
		
		zx1=zx;
		//zy=Oy-xt;//+w-(r*2);
		zx=Ox-yt;//+h-(r*2);		//第二象限
		//point2();
		

		glcdFillRect(zx1-1,zy,zx+1,zy);

		
		zx1=zx;
		zy=Oy+xt+h-(r*2);		//第三象限
		//point2();
		
		zx=Ox+yt+w-(r*2);		//第四象限
		//point2();
		
		glcdFillRect(zx1+1,zy,zx-1,zy);

	}
	

     	
	glcdFillRect(x+1, y+r+1,x+w-1,y+h-r-1);

	
}
//------------------------------------------

if(cfg&0x8000) 
{
RGBToChar(cfg);
glcdLine(x+r,y,x+w-r,y);
glcdLine(x,y+r,x,y+h-r);
glcdLine(x+w,y+r,x+w,y+h-r);
glcdLine(x+r,y+h,x+w-r,y+h);

	
	Ox=x+r;Oy=y+r;
	yt=r;
	rr=r*r+1;			//补偿 1 修正方形
	rs=(yt+(yt>>1))>>1;		//(*0.75)分开1/8圆弧来画
	
	for (xt=0;xt<=rs;xt++)
	{
		xx=xt*xt;
		while ((yt*yt)>(rr-xx))yt--;
		
		zx=Ox+xt+w-(r*2);		//第一象限
		zy=Oy-yt;
		point2();
		
//		zy=Oy-yt;
		zx=Ox-xt;		//第二象限
		point2();
			
		zy=Oy+yt+h-(r*2);		//第三象限
		point2();
		
		zx=Ox+xt+w-(r*2);		//第四象限
		point2();
		
//-----------------------------------------
		zx=Ox+yt+w-(r*2);		//第一象限
		zy=Oy-xt;
		point2();
		
		//zy=Oy-xt;//+w-(r*2);
		zx=Ox-yt;//+h-(r*2);		//第二象限
		point2();
		
		zy=Oy+xt+h-(r*2);		//第三象限
		point2();
		
		zx=Ox+yt+w-(r*2);		//第四象限
		point2();
		
	}
}
}

/*
void glcdSelectFont(PGM_VOID_P data, glcdFontFunc_t callback) {

    glcd_FontData = (glcdFontData_t)(data);
    glcd_FontRead = callback;
    glcd_FontWidth = glcd_FontRead(glcd_FontData + 2);
    glcd_FontHeight = glcd_FontRead(glcd_FontData + 3);
    glcd_FontBitsPixel = glcd_FontRead(glcd_FontData + 4);
    glcd_FontFirstChar = glcd_FontRead(glcd_FontData + 5);
    glcd_FontLastChar = glcd_FontRead(glcd_FontData + 6);
}

unsigned char glcdFontRead(const glcdFontData_t index) {
    
    return(pgm_read_byte(index));
}

void glcdNewLine(void) {

    glcd_Cursor.X = glcd_Window.X1;
    glcd_Cursor.Y += glcd_FontHeight;
    if (glcd_Cursor.Y + glcd_FontHeight > glcd_Window.Y2) {
   	  glcd_Cursor.Y = glcd_Window.Y1;
    }
}

int glcdDrawChar(char c) {

#define HEADER_SIZE  7

    if (c == '\n') {
      glcdNewLine();
      return(0);
    }
  // ist das Zeichen im Font definiert und auch ein Font selektiert ??
    if ((c < glcd_FontFirstChar) | (c > glcd_FontLastChar) | (glcd_FontData == 0)) {
      return(0);
    }

  // ist das Zeichen im Font deklariert aber nicht definiert ??
    unsigned char charwidth = glcd_FontRead(glcd_FontData + HEADER_SIZE + c - glcd_FontFirstChar);
    if (charwidth == 0) {return(0);}

  // alle Zeichen kleiner #128 haben rechts eine implizite Leerspalte
    unsigned char width = charwidth;
    if (c < 128) {width++;}

  // wenn wir den Zeichensatz mit fester Breite zeichnen sollen dann setze die Width entsprechend
    if ((glcd_Flags.FixedFont == 1) & (width <= glcd_FontWidth)) {
      width = glcd_FontWidth;
    }

  // passt das Zeichen noch in das Zeichen-Fenster ?? falls nein eventuell ein Linefeed einf黦en
    if ((glcd_Flags.AutoLineFeed == 1) & (glcd_Cursor.X + width >= glcd_Window.X2)) {
      glcdNewLine();
    }

  // ist das Zeichen 黚erhaupt noch ansatzweise sichtbar ?
    if ((glcd_Cursor.X > glcd_Clip.X2) | (glcd_Cursor.Y > glcd_Clip.Y2)) {
      return(0);
    }

    unsigned char x = glcd_Cursor.X;
    unsigned char y = glcd_Cursor.Y;
    glcd_Cursor.X += width;

  // ist das Zeichen 黚erhaupt noch ansatzweise sichtbar ?
    if ((x < glcd_Clip.X1) | (y + glcd_FontHeight < glcd_Clip.Y1)) {
      return(0);
    }

    unsigned char i = 0;

  // falls FixedFont m黶sen die Zeichen innerhalb glcd_FontWidth zentriert werden, aber nur
  // wenn das Zeichen schmaler als glcd_FontWidth ist. Wir f黮len dann auch gleich den rechten
  // und linken Rand des Zeichens, ebenfalls nur wenn die Hintergrundfarbe nicht transparent ist.
    if ((glcd_Flags.FixedFont == 1) & (width > charwidth)) {
      i = (width - charwidth) / 2;
      if (glcdBkColor != NONE) {
        glcdDoFillRect(x, y, x + i -1, y + glcd_FontHeight -1, glcdBkColor);
      }
      x += i;
    }
    i = width - charwidth - i;
    if ((i > 0) & (glcdBkColor != NONE)) {
      glcdDoFillRect(x + charwidth, y, x + charwidth + i -1, y + glcd_FontHeight -1, glcdBkColor);
    }

  // m黶sen die eigentlichen Zeichendaten gezeichnet werden ??
    if ((x > glcd_Clip.X2) | (x + charwidth < glcd_Clip.X1)) {
      return(width);
    }

  // berechne nun den Bitindex zu den Bitdaten im Font
    glcdFontData_t data = glcd_FontData + HEADER_SIZE;
    uint32_t index = 0;

    for (i = glcd_FontFirstChar; i < c; i++) {
      index += glcd_FontRead(data++);
    }
    index = (index * glcd_FontHeight) << (glcd_FontBitsPixel -1);

  // positioniere data auf's erste Byte mit Fontdaten zum Zeichen und hole die ersten Bits
    data = glcd_FontData + HEADER_SIZE + glcd_FontLastChar - glcd_FontFirstChar +1 + index / 8;
    unsigned char bitsindex = index % 8;
    unsigned char bits = glcd_FontRead(data++) >> bitsindex;
    unsigned char mask = 0xFF >> (8 - glcd_FontBitsPixel);
    unsigned char invalid = 1;
    glcdColor_t color;

  // wir senden die Bitdaten der einzelnen Pixel jeweils Spaltenweise in Y Richtung
    glcdn_WriteCommand(MEM_CONTROL);
    glcd_MemCtrl ^= (1 << MEM_VW);
    glcdn_WriteData(glcd_MemCtrl);

  // Zeichne nun die charwidth Spalten des Zeichens, ber點ksichtige das Clipping.
  // Diese Loop k鰊nte das Clipping schon in advance durchf黨ren um eine eventuell
  // besssere Performance zu bringen, zZ. belassen wir es aber erstmal.
    for (; charwidth > 0; charwidth--) {
      for (y = glcd_Cursor.Y; y < glcd_Cursor.Y + glcd_FontHeight; y++) {
        if ((x >= glcd_Clip.X1) & (x <= glcd_Clip.X2) & (y >= glcd_Clip.Y1) & (y <= glcd_Clip.Y2)) {
  // falls der Font in der Farbanzahl unterst黷zt wird benutze Farbtabelle ansonsten 1 zu 1
          if (glcd_FontBitsPixel <= COLOR_TABLE_BITS) {
            color = glcd_Colors[bits & mask];
          } else {color = bits & mask;}
          if (color != NONE) {
            if (invalid) {
              glcdn_SetPageArea(x, y, glcd_Cursor.X, glcd_Cursor.Y + glcd_FontHeight -1);
              if (y == glcd_Cursor.Y) {
                invalid = 0;
              }
            }
            glcdPutPixel(color);
          } else {
            invalid = 1;
          }
        } else {
          invalid = 1;
        }

        bits = bits >> glcd_FontBitsPixel;
        bitsindex += glcd_FontBitsPixel;
        if (bitsindex == 8) {
          bits = glcd_FontRead(data++);
          bitsindex = 0;
        }
      }
      x++;
    }

    glcdn_WriteCommand(MEM_CONTROL);
    glcd_MemCtrl ^= (1 << MEM_VW);
    glcdn_WriteData(glcd_MemCtrl);

    return(width);
}

void glcdPrint(char *c) {

    while (*c != 0) {
      glcdDrawChar(*c++);
    }
}

int glcdCharWidth(char c) {

    if ((c < glcd_FontFirstChar) | (c > glcd_FontLastChar) | (glcd_FontData == 0)) {
      return(0); // character not defined
    } else {
      int i = glcd_FontRead(glcd_FontData + HEADER_SIZE + c - glcd_FontFirstChar);
      if (c < 128) {i++;}
      return(i);
    }
}

int glcdCharsWidth(char *c) {

    int i = 0;
    while (*c != 0) {
      i += glcdCharWidth(*c++);
    }
    return(i);
}
*/