gra.c

kaffe Java 解释器语言,源码,Java的子集系统,开放源代码

/**
 * 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 "toolkit.h"

typedef struct {
  GC        gc;
  Drawable  drw;
  int       fg;
  int       bg;
  char      xor;
  int       xclr;
  int       x0;
  int       y0;
} Graphics;

#define  WINDOW   0
#define  IMAGE    1
#define  GRAPHICS 2

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


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

  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 ) {
	switch ( tgtType ) {
	case 0:  drw = (Drawable)tgt; break;          /* Window   */
	case 1:  drw = ((Image*)tgt)->pix; break;     /* Image    */
	case 2:  drw = ((Graphics*)tgt)->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;
  values.font       = ((XFontStruct*)fnt)->fid;
  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);

	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;

  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 gr;
}


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

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


void
Java_java_awt_Toolkit_graCopyArea ( JNIEnv* env, jclass clazz, Graphics* gr, 
									jint x, jint y, jint width, jint height,
									jint xDelta, jint yDelta )
{
  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, jclass clazz, Graphics* gr,
									 jint x, jint y, jint width, jint height )
{
  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,
	Graphics* gr, jbyteArray jBytes, jint offset, jint len, jint x, jint y )
{
  jboolean isCopy;
  int      n;
  jbyte    *jb, *jbo;

  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;

  XDrawString( X->dsp, gr->drw, gr->gc, x+gr->x0, y+gr->y0, jbo, len);

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


void
Java_java_awt_Toolkit_graDrawChars ( JNIEnv* env, jclass clazz,
	Graphics* gr, jcharArray jChars, jint offset, jint len, jint x, jint y )
{
  jboolean isCopy;
  int      n;
  jchar    *jc, *jco;
  XChar2b  *b;

  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;

#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);  

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


void
Java_java_awt_Toolkit_graDrawString ( JNIEnv* env, jclass clazz,
									  Graphics* gr, jstring str, jint x, jint y )
{
  jboolean     isCopy;
  int          len;
#ifndef WORDS_BIGENDIAN
  int n;
#endif
  const jchar  *jc;
  XChar2b      *b;

  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);

#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);  

  (*env)->ReleaseStringChars( env, str, jc);
  XFLUSH( X, False);
}


void
Java_java_awt_Toolkit_graDrawLine ( JNIEnv* env, jclass clazz, Graphics* gr,
									jint x1, jint y1, jint x2, jint y2 )
{
  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, jclass clazz, Graphics* gr,
								   jint x, jint y, jint width, jint height,
								   jint startAngle, jint arcAngle )
{
  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, jclass clazz, Graphics* gr,
								   jint x, jint y, jint width, jint height,
								   jint startAngle, jint arcAngle )
{
  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, jclass clazz, Graphics* gr,
									jint x, jint y, jint width, jint height )
{
  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, jclass clazz, Graphics* gr,
									jint x, jint y, jint width, jint height )
{
  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* X, 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( X, (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,
	Graphics* gr, jintArray xPoints, jintArray yPoints, jint nPoints )
{
  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, Graphics* gr,
										jintArray xPoints, jintArray yPoints, jint nPoints )
{
  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,
	Graphics* gr, jintArray xPoints, jintArray yPoints, jint nPoints )
{
  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, jclass clazz, Graphics* gr,
									jint x, jint y, jint width, jint height )
{
  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, jclass clazz, Graphics* gr,
									jint x, jint y, jint width, jint height )
{
  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);
}



/*
 * we don't use the Xmu routines here because it would drag the whole Xt libs in
 */
void
Java_java_awt_Toolkit_graDrawRoundRect ( JNIEnv* env, jclass clazz, Graphics* gr,
										 jint x, jint y, jint width, jint height, 
										 jint wArc, jint hArc )
{
  int x1, x2, y1, y2, a, b;

  DBG( AWT_GRA, printf("drawRoundRect: %p, %d,%d - %d,%d  %d,%d\n", gr,
				 x,y,width,height, wArc, hArc));