gra.c

linux下建立JAVA虚拟机的源码KAFFE

/**
 * gra.c - 
 *
 * Copyright (c) 1998
 *      Transvirtual Technologies, Inc.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution 
 * of this file. 
 */

#include "config.h"
#include "toolkit.h"

/*******************************************************************************
 *
 */


jobject
Java_java_awt_Toolkit_graInitGraphics ( JNIEnv* env, jclass clazz UNUSED,
					jobject ngr, jobject tgt, jint tgtType,
					jint xOff, jint yOff,
					jint xClip, jint yClip, jint wClip, jint hClip,
					jobject fnt, jint fg, jint bg, jboolean blank )
{
  Graphics *gr = NULL;
  Drawable       drw;
  XGCValues      values;
  XRectangle     rect;
#ifdef KAFFE_I18N
  unsigned long  valueMask = GCForeground | GCBackground | GCFunction;
#else  
  unsigned long  valueMask = GCForeground | GCBackground | GCFont | GCFunction;
#endif  

  if (ngr != NULL)
    gr = UNVEIL_GR(ngr);

  DBG( AWT_GRA, printf("initGraphics: %p (%p, %d) %d,%d  %d,%d - %d,%d  %p %x %x\n",
				 gr, tgt,tgtType, xOff,yOff, xClip,yClip,wClip,hClip, fnt,fg,bg));

  if ( tgt ) {
    void *tgtPtr = JCL_GetRawData(env, tgt);
	switch ( tgtType ) {
	case 0:  drw = (Drawable)tgtPtr; break;          /* Window   */
	case 1:  drw = ((Image*)tgtPtr)->pix; break;     /* Image    */
	case 2:  drw = ((Graphics*)tgtPtr)->drw; break;  /* Graphics */
	default: fprintf( stderr, "illegal Graphics target: %d\n", tgtType);
		 drw = 0;
	}
  }
  else {
	if ( gr )
	  drw = gr->drw;
	else {
	  fprintf( stderr, "attempt to set an uninitialized graphics");
	  drw = 0;
	}
  }

  values.foreground = fg;
  values.background = bg;
#ifndef KAFFE_I18N /* !KAFFE_I18N */ 
  values.font       = UNVEIL_FS(fnt)->fid;
#endif  
  values.function   = GXcopy;
  
  if ( gr ) {
	XChangeGC( X->dsp, gr->gc, valueMask, &values);
  }
  else {
	gr = (Graphics*) AWT_MALLOC( sizeof(Graphics));
	gr->gc = XCreateGC( X->dsp, drw, valueMask, &values);

	ngr = JCL_NewRawDataObject(env, gr);

	DBG( AWT_GRA, printf(" ->gr: %p (%p)\n", gr, gr->gc));
  }

  rect.x      = xClip; 
  rect.y      = yClip;
  rect.width  = (wClip > 0) ? wClip : 0;
  rect.height = (hClip > 0) ? hClip : 0;
  XSetClipRectangles( X->dsp, gr->gc, xOff, yOff, &rect, 1, Unsorted);

  gr->fg   = fg;
  gr->bg   = bg;
  gr->drw  = drw;
  gr->x0   = xOff;
  gr->y0   = yOff;
  gr->xor  = 0;
#ifdef KAFFE_I18N
  gr->oc   = UNVEIL_XOC(fnt);
#endif  

  if ( blank ) {
	XSetForeground( X->dsp, gr->gc, gr->bg);
	XFillRectangle( X->dsp, gr->drw, gr->gc, xOff+xClip, yOff+yClip, wClip, hClip);
	XSetForeground( X->dsp, gr->gc, gr->fg);	
  }

  return ngr;
}


void
Java_java_awt_Toolkit_graFreeGraphics ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("freeGraphics: %p\n", gr));

  XFreeGC( X->dsp, gr->gc);
  AWT_FREE( gr);
}


void
Java_java_awt_Toolkit_graCopyArea ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr, 
				    jint x, jint y, jint width, jint height,
				    jint xDelta, jint yDelta )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("copyArea: %p, %d,%d-%d,%d  %d,%d\n", gr, x,y,width,height, xDelta,yDelta));

  /* some X servers act alleric on that (careless bitblt, again) */
  if ( (width < 0) || (height < 0) )
	return;

  x += gr->x0; y += gr->y0;
  XCopyArea( X->dsp, gr->drw, gr->drw, gr->gc, x, y, width, height, x + xDelta, y + yDelta);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graClearRect ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
				     jint x, jint y, jint width, jint height )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("clearRect: %p, %d,%d-%d,%d\n", gr, x,y,width,height));

  XSetForeground( X->dsp, gr->gc, gr->bg);
  XFillRectangle( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height);
  XSetForeground( X->dsp, gr->gc, gr->fg);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawBytes ( JNIEnv* env, jclass clazz UNUSED,
				     jobject ngr, jbyteArray jBytes, jint offset, jint len, jint x, jint y )
{
  Graphics *gr = UNVEIL_GR(ngr);
  jboolean isCopy;
  int      n;
  jbyte    *jb, *jbo;
#ifdef KAFFE_I18N
  wchar_t *wch;
#endif  

  if ( !jBytes ) return;

  n = (*env)->GetArrayLength( env, jBytes);
  jb = (*env)->GetByteArrayElements( env, jBytes, &isCopy);
  jbo = jb + offset;

  DBG( AWT_GRA, printf("drawBytes: %p, %p,%d,%d  \"%s\"  %d,%d\n", gr,
				 jBytes,offset,len, jb, x,y));

  if ( offset+len > n )
	len = n - offset;

#ifdef KAFFE_I18N
  wch = jbyte2wchar( jbo, len );
  XwcDrawString( X->dsp, gr->drw, gr->oc, gr->gc, x+gr->x0, y+gr->y0, wch,len);
  free((void*) wch);  
#else  
  XDrawString( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, jbo, len);
#endif  

  (*env)->ReleaseByteArrayElements( env, jBytes, jb, JNI_ABORT);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawChars ( JNIEnv* env, jclass clazz UNUSED,
	jobject ngr, jcharArray jChars, jint offset, jint len, jint x, jint y )
{
  Graphics *gr = UNVEIL_GR(ngr);
  jboolean isCopy;
  int      n;
  jchar    *jc, *jco;
#ifdef KAFFE_I18N
  wchar_t *wch;  
#else  
  XChar2b  *b;
#endif  

  if ( !jChars ) return;

  n   = (*env)->GetArrayLength( env, jChars);
  jc = (*env)->GetCharArrayElements( env, jChars, &isCopy);
  jco = jc + offset;

  DBG( AWT_GRA, printf("drawChars: %p, %p,%d,%d  \"%s\"  %d,%d\n", gr, jChars,offset,len,
				 jchar2CString(X,jco,len), x,y));

  if ( offset+len > n )
	len = n - offset;

#ifdef KAFFE_I18N
  wch = jchar2wchar( jco, len );  
  XwcDrawString( X->dsp, gr->drw, gr->oc, gr->gc, x+gr->x0, y+gr->y0, wch,len);
  free((void*) wch);
#else /* !KAFFE_I18N */
	 
#ifndef WORDS_BIGENDIAN
  n = sizeof(XChar2b)*len;
  b = (XChar2b*) getBuffer( X, n);
  swab( (void*)jco, (void*)b, n);
#else
  b = (XChar2b*) jco;
#endif

  XDrawString16( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, b, len);
#endif  

  (*env)->ReleaseCharArrayElements( env, jChars, jc, JNI_ABORT);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawString ( JNIEnv* env, jclass clazz UNUSED,
				      jobject ngr, jstring str, jint x, jint y )
{
  Graphics *gr = UNVEIL_GR(ngr);
  jboolean     isCopy;
  int          len;

#ifndef KAFFE_I18N
  
#ifndef WORDS_BIGENDIAN
  int n;
#endif

#endif
  
  const jchar  *jc;
#ifdef KAFFE_I18N
  wchar_t *wch;  
#else  
  XChar2b      *b;
#endif  

  DBG( AWT_GRA, printf("drawString: %p  \"%s\"  %d,%d\n", gr, java2CString(env,X,str), x,y));

  if ( !str ) return;

  len = (*env)->GetStringLength( env, str);
  jc = (*env)->GetStringChars( env, str, &isCopy);

#ifdef KAFFE_I18N
  wch = jchar2wchar( jc, len );
  XwcDrawString( X->dsp, gr->drw, gr->oc, gr->gc, x+gr->x0, y+gr->y0, wch,len);
  free( (void *)wch );  
#else /* !KAFFE_I18N */
  
#ifndef WORDS_BIGENDIAN
  n = sizeof(XChar2b)*len;
  b = (XChar2b*) getBuffer( X, n);
  swab( jc, b, n);
#else
  b = (XChar2b*) jc;
#endif

  XDrawString16( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, b, len);  
#endif
  
  (*env)->ReleaseStringChars( env, str, jc);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawLine ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
				    jint x1, jint y1, jint x2, jint y2 )
{
  Graphics *gr = UNVEIL_GR(ngr);

  DBG( AWT_GRA, printf("drawLine: %p, %d,%d - %d,%d\n", gr, x1,y1, x2,y2));

  if ( (x1==x2) && (y1==y2) ) {  /* swing gimmick */
	XDrawPoint( X->dsp, gr->drw, gr->gc, x1 +gr->x0, y1 +gr->y0);
  }
  else {
	XDrawLine( X->dsp, gr->drw, gr->gc, x1 + gr->x0, y1 + gr->y0, x2 + gr->x0, y2 + gr->y0);
  }
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawArc ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
								   jint x, jint y, jint width, jint height,
								   jint startAngle, jint arcAngle )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("drawArc: %p, %d,%d-%d,%d  %d,%d\n", gr,
				 x,y,width,height, startAngle,arcAngle));

  XDrawArc( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height,
			startAngle<<6, arcAngle<<6);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graFillArc ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
								   jint x, jint y, jint width, jint height,
								   jint startAngle, jint arcAngle )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("fillArc: %p, %d,%d-%d,%d  %d,%d\n", gr,
				 x,y,width,height, startAngle, arcAngle));

  XFillArc( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height,
			startAngle<<6, arcAngle<<6);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawOval ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
									jint x, jint y, jint width, jint height )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("drawOval: %p, %d,%d - %d,%d\n", gr, x,y,width,height));

  XDrawArc( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height, 0, 23040);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graFillOval ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
									jint x, jint y, jint width, jint height )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("fillOval: %p, %d,%d - %d,%d\n", gr, x,y,width,height));

  XFillArc( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height, 0, 23040);
  XFLUSH( X, False);
}


int jarray2Points ( JNIEnv* env, Toolkit* tk, XPoint** pp, int x0, int y0,
			jintArray xPoints, jintArray yPoints, int nPoints )
{
  register int i;
  int      n;
  jboolean isCopy;
  jint     *jx = (*env)->GetIntArrayElements( env, xPoints, &isCopy);
  jint     *jy = (*env)->GetIntArrayElements( env, yPoints, &isCopy);

  if ( (n = (*env)->GetArrayLength( env, xPoints)) < nPoints ) nPoints = n;
  if ( (n = (*env)->GetArrayLength( env, yPoints)) < nPoints ) nPoints = n;

  *pp = getBuffer( tk, (nPoints+1)*sizeof(XPoint));

  for ( i=0; i<nPoints; i++){
	(*pp)[i].x = jx[i] + x0;
    (*pp)[i].y = jy[i] + y0;
  }

  (*env)->ReleaseIntArrayElements( env, xPoints, jx, JNI_ABORT);
  (*env)->ReleaseIntArrayElements( env, yPoints, jy, JNI_ABORT);

  return nPoints;
}


void
Java_java_awt_Toolkit_graDrawPolygon ( JNIEnv* env, jclass clazz UNUSED,
	jobject ngr, jintArray xPoints, jintArray yPoints, jint nPoints )
{
  Graphics *gr = UNVEIL_GR(ngr);
  int n;
  XPoint   *p;

  DBG( AWT_GRA, printf("drawPolygon: %p, %p,%p  %d\n", gr, xPoints, yPoints, nPoints));

  if ( !xPoints || !yPoints ) return;

  nPoints = jarray2Points( env, X, &p, gr->x0, gr->y0, xPoints, yPoints, nPoints);

  n = nPoints-1;
  if ( (p[0].x != p[n].x) || (p[0].y != p[n].y) ) {
	p[nPoints].x = p[0].x;
	p[nPoints].y = p[0].y;
	nPoints++;
  }

  XDrawLines( X->dsp, gr->drw, gr->gc, p, nPoints, CoordModeOrigin);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawPolyline ( JNIEnv* env, jclass clazz UNUSED, jobject ngr,
					jintArray xPoints, jintArray yPoints, jint nPoints )
{
  Graphics *gr = UNVEIL_GR(ngr);
  XPoint   *p;

  DBG( AWT_GRA, printf("drawPolyline: %p, %p,%p  %d\n", gr, xPoints, yPoints, nPoints));

  if ( !xPoints || !yPoints ) return;

  nPoints = jarray2Points( env, X, &p, gr->x0, gr->y0, xPoints, yPoints, nPoints);
  XDrawLines( X->dsp, gr->drw, gr->gc, p, nPoints, CoordModeOrigin);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graFillPolygon ( JNIEnv* env, jclass clazz UNUSED,
	jobject ngr, jintArray xPoints, jintArray yPoints, jint nPoints )
{
  Graphics *gr = UNVEIL_GR(ngr);
  XPoint   *p;

  DBG( AWT_GRA, printf("fillPolygon: %p, %p,%p  %d\n", gr, xPoints, yPoints, nPoints));

  if ( !xPoints || !yPoints ) return;

  nPoints = jarray2Points( env, X, &p, gr->x0, gr->y0, xPoints, yPoints, nPoints);
  XFillPolygon( X->dsp, gr->drw, gr->gc, p, nPoints, Nonconvex, CoordModeOrigin);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawRect ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
				    jint x, jint y, jint width, jint height )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("drawRect: %p, %d,%d - %d,%d\n", gr, x,y,width,height));

  if ( (width >= 0) && (height >= 0) )
	XDrawRectangle( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graFillRect ( JNIEnv* env UNUSED, jclass clazz UNUSED, jobject ngr,
				    jint x, jint y, jint width, jint height )
{
  Graphics *gr = UNVEIL_GR(ngr);
  DBG( AWT_GRA, printf("fillRect: %p, %d,%d - %d,%d\n", gr, x,y,width,height));

  if ( (width >= 0) && (height >= 0) ) {
	if ( width == 1 ) {   /* some swing gimmicks */
	  XDrawLine( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, x+gr->x0, y +gr->y0 +height -1);
	}
	else if ( height == 1 ){
	  XDrawLine( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, x +gr->x0 +width -1, y+gr->y0);
	}
	else {
	  XFillRectangle( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, width, height);
	}
  }
  XFLUSH( X, False);
}