gra.cpp

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

		jco = jc + offset;
		
		if ( offset+len > n )
			len = n - offset;
		
		cs = jchar2WinString( X, jco, len);
		
		DBG( awt_gra, ("drawChars: %x, %x,%d,%d  \"%s\"  %d,%d\n", gr, jChars,offset,len, cs, x,y));
		gr->drawText( x, y, cs, len);
		
		env->ReleaseCharArrayElements( jChars, jc, JNI_ABORT);
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawString ( JNIEnv* env, jclass clazz,
		Graphics* gr, jstring str, jint x, jint y )
	{
		TCHAR  *jc = java2WinString( env, X, str);
		
		DBG( awt_gra, ("drawString: %x  \"%s\"  %d,%d\n", gr, jc, x,y));
		gr->drawText( x, y, jc, _tcslen( jc));
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawLine ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x1, jint y1, jint x2, jint y2 )
	{
		DBG( awt_gra, ("drawLine: %x, %d,%d - %d,%d\n", gr, x1,y1, x2,y2));
		gr->drawLine( x1, y1, x2, y2);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawArc ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height,
		jint startAngle, jint arcAngle )
	{
#if !defined(UNDER_CE)
		POINT p1, p2;
		
		getArcPoints( x+gr->x0, y+gr->y0, width, height, startAngle, arcAngle, p1, p2);
		
		DBG( awt_gra, ("drawArc: %x, %d,%d-%d,%d  %d,%d\n", gr,
			x,y,width,height, startAngle,arcAngle));
		
		Arc( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0, p1.x, p1.y, p2.x, p2.y);
		GFLUSH();
#endif
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graFillArc ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height,
		jint startAngle, jint arcAngle )
	{
#if !defined(UNDER_CE)
		POINT p1, p2;
		
		getArcPoints( x+gr->x0, y+gr->y0, width, height, startAngle, arcAngle, p1, p2);
		
		DBG( awt_gra, ("fillArc: %x, %d,%d-%d,%d  %d,%d\n", gr,
			x,y,width,height, startAngle, arcAngle));
		
		Pie( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0, p1.x, p1.y, p2.x, p2.y);
		GFLUSH();
#endif
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawOval ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height )
	{
		DBG( awt_gra, ("drawOval: %x, %d,%d - %d,%d\n", gr, x,y,width,height));
		SelectObject( gr->dc, HB_0);
		Ellipse( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0);
		GFLUSH();
		SelectObject( gr->dc, gr->brush);
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graFillOval ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height )
	{
		DBG( awt_gra, ("fillOval: %x, %d,%d - %d,%d\n", gr, x,y,width,height));
		SelectObject( gr->dc, HP_0);
		Ellipse( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0);
		GFLUSH();
		SelectObject( gr->dc, gr->pen);
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawPolygon ( JNIEnv* env, jclass clazz, Graphics* gr,
		jintArray xPoints, jintArray yPoints, jint nPoints )
	{
		int n;
		POINT *p;
		
		DBG( awt_gra, ("drawPolygon: %x, %x,%x  %d\n", gr, xPoints, yPoints, nPoints));
		
		if ( !xPoints || !yPoints ) return;
		
		nPoints = jarray2Points( &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++;
		}
		
		gr->selectNullBrush();
		Polygon( gr->dc, p, nPoints);
		GFLUSH();
		gr->restoreBrush();
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawPolyline ( JNIEnv* env, jclass clazz, Graphics* gr,
		jintArray xPoints, jintArray yPoints, jint nPoints )
	{
		POINT *p;
		DBG( awt_gra, ("drawPolyline: %x, %x,%x  %d\n", gr, xPoints, yPoints, nPoints));
		
		if ( !xPoints || !yPoints ) return;
		
		nPoints = jarray2Points( &p, gr->x0, gr->y0, xPoints, yPoints, nPoints);
		
		gr->selectNullBrush();
		Polygon( gr->dc, p, nPoints);
		GFLUSH();
		gr->restoreBrush();
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graFillPolygon ( JNIEnv* env, jclass clazz, Graphics* gr,
		jintArray xPoints, jintArray yPoints, jint nPoints )
	{
		int n;
		POINT *p;
		
		DBG( awt_gra, ("fillPolygon: %x, %x,%x  %d\n", gr, xPoints, yPoints, nPoints));
		
		if ( !xPoints || !yPoints ) return;
		
		nPoints = jarray2Points( &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++;
		}
		
		Polygon( gr->dc, p, nPoints);
		GFLUSH();
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height )
	{
		DBG( awt_gra, ("drawRect: %x, %d,%d - %d,%d\n", gr, x,y,width,height));
		
		if ( (width >= 0) && (height >= 0) ){
			gr->drawRect( x, y, width, height);
		}
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graFillRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height )
	{
		DBG( awt_gra, ("fillRect: %x, %d,%d - %d,%d\n", gr, x,y,width,height));
		gr->fillRect( x, y, width, height, (int)gr->fgClr);
	}
	
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawRoundRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height, 
		jint wArc, jint hArc )
	{
		
		DBG( awt_gra, ("drawRoundRect: %x, %d,%d - %d,%d  %d,%d\n", gr,
			x,y,width,height, wArc, hArc));
		
		gr->selectNullBrush();
		RoundRect( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0, wArc, hArc);
		GFLUSH();
		gr->restoreBrush();
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graFillRoundRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height, 
		jint wArc, jint hArc )
	{
		
		DBG( awt_gra, ("fillRoundRect: %x, %d,%d - %d,%d  %d,%d\n", gr,
			x,y,width,height, wArc, hArc));
		
		gr->selectNullPen();
		RoundRect( gr->dc, x+gr->x0, y+gr->y0, x+width+gr->x0, y+height+gr->y0, wArc, hArc);
		GFLUSH();
		gr->restorePen();
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDraw3DRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height,
		jboolean raised, jint javargb )
	{
		int     bright, dark;
		HPEN	pb, pd;
		int     xw, yh;
		
		DBG( awt_gra, ("draw3DRect: %x, %d,%d - %d,%d  %d %x\n", gr,
			x,y,width,height, raised, javargb));
		
		/* we should use the same mechanism like ordinary Graphics brighter()/darker() here */
		dark   = (int)ColorJ2N((int)Java_java_awt_Toolkit_clrDark( env, clazz, javargb));
		bright = (int)ColorJ2N((int)Java_java_awt_Toolkit_clrBright( env, clazz, javargb));
		pd = CreatePen( PS_SOLID, 0, dark);
		pb = CreatePen( PS_SOLID, 0, bright);
		
		xw = x + width;
		yh = y + height;
		
		SelectObject( gr->dc, raised ? pb : pd);
		gr->drawLine( x, y, xw-1, y);
		gr->drawLine( x, y, x, yh);
		
		SelectObject( gr->dc, raised ? pd : pb);
		gr->drawLine( x+1, yh, xw, yh);
		gr->drawLine( xw, y, xw, yh);
		
		GFLUSH();
		
		DeleteObject( pb);
		DeleteObject( pd);
		
		SelectObject( gr->dc, gr->pen);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graFill3DRect ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint x, jint y, jint width, jint height,
		jboolean raised, jint javargb )
	{
		
		DBG( awt_gra, ("fill3DRect: %x, %d,%d - %d,%d  %d %x\n", gr,
			x,y,width,height, raised, javargb));	
		gr->fillRect( x+1, y+1, width-2, height-2, ColorJ2N(javargb));
		Java_java_awt_Toolkit_graDraw3DRect( env, clazz, gr, x, y, width-1, height-1, raised, javargb);
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graAddClip ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint xClip, jint yClip, jint wClip, jint hClip )
	{
		DBG( awt_gra, ("addClip: %x, %d,%d - %d,%d\n", gr, xClip, yClip, wClip, hClip));
		gr->setClip( xClip, yClip, wClip, hClip, FALSE);	  
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graSetClip ( JNIEnv* env, jclass clazz, Graphics* gr,
		jint xClip, jint yClip, jint wClip, jint hClip )
	{
		DBG( awt_gra, ("setClip: %x, %d,%d - %d,%d\n", gr, xClip, yClip, wClip, hClip));
		gr->setClip( xClip, yClip, wClip, hClip, TRUE);	  
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetColor ( JNIEnv* env, jclass clazz, Graphics* gr, jint clr )
	{
		DBG( awt_gra, ("setColor: %x, %x\n", gr, clr));
		
		if ( gr->xor )
			clr ^= gr->xclr;
		
		gr->setForeground( clr);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetBackColor ( JNIEnv* env, jclass clazz, Graphics* gr, jint clr )
	{
		DBG( awt_gra, ("setBackColor: %x, %x\n", gr, clr));
		gr->setBackground( clr);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetFont ( JNIEnv* env, jclass clazz, Graphics* gr, jobject fnt )
	{
		DBG( awt_gra, ("setFont: %x, %x\n", gr, fnt));
		gr->setFont( ((Font*)fnt)->fnt);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetOffset ( JNIEnv* env, jclass clazz, Graphics* gr, jint xOff, jint yOff )
	{
		DBG( awt_gra, ("setOffset: %x, %d,%d\n", gr, xOff, yOff));
		gr->translate( xOff, yOff);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetPaintMode ( JNIEnv* env, jclass clazz, Graphics* gr )
	{
		DBG( awt_gra, ("setPaintMode: %x\n", gr));
		gr->setPaintMode();		
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetXORMode ( JNIEnv* env, jclass clazz, Graphics* gr, jint xorClr )
	{
		DBG( awt_gra, ("setXORMode: %x, %x\n", gr, xorClr));
		gr->setXORMode( xorClr);
	}
	
	void __cdecl
		Java_java_awt_Toolkit_graSetVisible ( JNIEnv* env, jclass clazz, Graphics* gr, jint isVisible )
	{
		DBG( awt_gra, ("setVisble: %x  %d\n", gr, isVisible));
		
		/*
		* This is rather a hack to "defuse" a Graphics object, but we don't want to
		* add checks on every draw op to test if the target is invisible
		*/
		
		if ( !isVisible ) {
			if ( gr->y0 >= -10000 ) 
				gr->y0 -= 100000;
		}
		else {
			if ( gr->y0 <= -10000 )
				gr->y0 += 100000;
		}
	}
	
	
	/************************************************************************************
	* image rendering
	*/
	
	void __cdecl
		drawAlphaImage ( Graphics* gr, Image* img,
		jint srcX, jint srcY, jint dstX, jint dstY,
		jint width, jint height, jint bgval )
	{
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawImage ( JNIEnv* env, jclass clazz, Graphics* gr, Image* img,
		jint srcX, jint srcY,
		jint dstX, jint dstY,
		jint width, jint height, jint bgval )
	{
		if ( img ) {
			if ( img->mask) {
				// gr->fillRect( dstX, dstY, width, height, bgval);
#if defined (UNDER_95)
				BitBlt( gr->dc, dstX+gr->x0, dstY+gr->y0, width, height, img->dcMask, srcX, srcY, SRCAND);
				BitBlt( gr->dc, dstX+gr->x0, dstY+gr->y0, width, height, img->dc, srcX, srcY, SRCINVERT);
#else				
				MaskBlt( gr->dc, dstX+gr->x0, dstY+gr->y0, width, height, img->dc, srcX, srcY,
					img->mask, 0, 0, MAKEROP4( SRCPAINT, SRCCOPY));
#endif
			}
			else {
				BitBlt( gr->dc, dstX+gr->x0, dstY+gr->y0, width, height, img->dc, srcX, srcY, SRCCOPY);
			}
		}
		GFLUSH();
	}
	
	
	void __cdecl
		Java_java_awt_Toolkit_graDrawImageScaled ( JNIEnv* env, jclass clazz, Graphics* gr, Image* img,
		jint dx0, jint dy0, jint dx1, jint dy1,
		jint sx0, jint sy0, jint sx1, jint sy1, jint bgval )
	{
		Image* tgt;
		int iw, x0, y0, x1, y1;
		
		iw = img->width;
		
		if ( dx1 > dx0 ) {
			x0 = dx0; x1 = dx1;
		}
		else {
			x0 = dx1; x1 = dx0;
		}
		if ( dy1 > dy0 ) {
			y0 = dy0; y1 = dy1;
		}
		else {
			y0 = dy1; y1 = dy0;
		}
		
		if ( sx0 < 0 ) sx0 = 0;
		if ( sx1 < 0 ) sx1 = 0;
		if ( sx0 >= iw ) sx0 = iw-1;
		if ( sx1 >= iw ) sx1 = iw-1;
		
		tgt = createImage( (x1-x0+1), (y1-y0+1) );
		StretchBlt( tgt->dc, 0, 0, tgt->width, tgt->height,
			img->dc, sx0, sy0, sx1-sx0, sy1-sy0, SRCCOPY);
		
		if ( img->mask) {
			createMaskImage( X, tgt);
			StretchBlt( tgt->dcMask, 0, 0, tgt->width, tgt->height,
				img->dcMask, sx0, sy0, sx1-sx0, sy1-sy0, SRCCOPY);
		}
		
		
		Java_java_awt_Toolkit_graDrawImage ( env, clazz, gr, tgt, 0, 0,
									   x0, y0, tgt->width, tgt->height, bgval);
		freeImage( X, tgt);		
	}
}