toolkit.h

java virtual machince kaffe

jint Java_java_awt_Toolkit_imgGetWidth ( JNIEnv* env, jclass clazz, Image* img);
jint Java_java_awt_Toolkit_imgGetHeight ( JNIEnv* env, jclass clazz, Image* img);
jboolean Java_java_awt_Toolkit_imgIsMultiFrame ( JNIEnv* env, jclass clazz, Image* img);
jint Java_java_awt_Toolkit_imgGetLatency ( JNIEnv* env, jclass clazz, Image* img);
void* Java_java_awt_Toolkit_imgGetNextFrame ( JNIEnv* env, jclass clazz, Image* img);

/* Toolkit */
jint Java_java_awt_Toolkit_tlkProperties ( JNIEnv* env, jclass clazz);
jboolean Java_java_awt_Toolkit_tlkInit ( JNIEnv* env, jclass clazz,
  jstring name);
void Java_java_awt_Toolkit_tlkTerminate ( JNIEnv* env, jclass clazz);
jstring Java_java_awt_Toolkit_tlkVersion ( JNIEnv* env, jclass clazz);
jint Java_java_awt_Toolkit_tlkGetResolution ( JNIEnv* env, jclass clazz);
jint Java_java_awt_Toolkit_tlkGetScreenHeight ( JNIEnv* env, jclass clazz);
jint Java_java_awt_Toolkit_tlkGetScreenWidth ( JNIEnv* env, jclass clazz);
void Java_java_awt_Toolkit_tlkSync ( JNIEnv* env, jclass clazz);
void Java_java_awt_Toolkit_tlkFlush ( JNIEnv* env, jclass clazz);
void Java_java_awt_Toolkit_tlkBeep ( JNIEnv* env, jclass clazz);
void Java_java_awt_Toolkit_tlkDisplayBanner ( JNIEnv* env, jclass clazz,
  jstring banner);

/* Window */
void Java_java_awt_Toolkit_wndSetTitle ( JNIEnv* env, jclass clazz, void* wnd,
  jstring jTitle);
void Java_java_awt_Toolkit_wndSetResizable ( JNIEnv* env, jclass clazz,
  void* wnd, jboolean isResizable, int x, int y, int width, int height);
void* Java_java_awt_Toolkit_wndCreateFrame ( JNIEnv* env, jclass clazz,
  jstring jTitle, jint x, jint y, jint width, jint height,
  jint jCursor, jint clrBack, jboolean isResizable);
void* Java_java_awt_Toolkit_wndCreateWindow ( JNIEnv* env, jclass clazz,
  void* owner, jint x, jint y, jint width, jint height,
  jint jCursor, jint clrBack);
void* Java_java_awt_Toolkit_wndCreateDialog ( JNIEnv* env, jclass clazz,
  void* owner, jstring jTitle, jint x, jint y, jint width, jint height,
  jint jCursor, jint clrBack, jboolean isResizable);
void Java_java_awt_Toolkit_wndDestroyWindow ( JNIEnv* env, jclass clazz,
  void* wnd);
void Java_java_awt_Toolkit_wndRequestFocus ( JNIEnv* env, jclass clazz,
  void* wnd);
void Java_java_awt_Toolkit_wndSetFrameInsets ( JNIEnv* env, jclass clazz,
  jint top, jint left, jint bottom, jint right);
void Java_java_awt_Toolkit_wndSetDialogInsets ( JNIEnv* env, jclass clazz,
  jint top, jint left, jint bottom, jint right);
void Java_java_awt_Toolkit_wndSetBounds ( JNIEnv* env, jclass clazz,
  void* wnd, jint x, jint y, jint width, jint height, jboolean isResizable);
void Java_java_awt_Toolkit_wndRepaint ( JNIEnv* env, jclass clazz, void* wnd,
  jint x, jint y, jint width, jint height);
void Java_java_awt_Toolkit_wndSetIcon ( JNIEnv* env, jclass clazz, void* wnd,
  void* img);
void Java_java_awt_Toolkit_wndSetVisible ( JNIEnv* env, jclass clazz,
  void* wnd, jboolean showIt);
void Java_java_awt_Toolkit_wndToBack ( JNIEnv* env, jclass clazz, void* wnd);
void Java_java_awt_Toolkit_wndToFront ( JNIEnv* env, jclass clazz, void* wnd);
void Java_java_awt_Toolkit_wndSetCursor ( JNIEnv* env, jclass clazz,
  void* wnd, jint jCursor);

/**
 * global data def/decl
 */
#ifdef MAIN

Toolkit   XTk;
Toolkit   *X = &XTk;
jclass  AWTError;
JNIEnv  *JniEnv;

#else

extern Toolkit* X;
extern jclass AWTError;
extern JNIEnv* JniEnv;

#endif /* MAIN */

extern long StdEvents, PopupEvents;


/**
 * heap wrapper macros
 */
static inline void* _awt_malloc_wrapper ( size_t size )
{
  void *adr;
  enterUnsafeRegion();
  adr = malloc( size);
  leaveUnsafeRegion();
  DBG( AWT_MEM, printf("malloc: %ld  -> %p\n", (unsigned long) size, adr));
  return adr;
}

static inline void* _awt_calloc_wrapper ( int n, size_t size )
{
  void *adr;
  enterUnsafeRegion();
  adr = calloc( n, size);
  leaveUnsafeRegion();
  DBG( AWT_MEM, printf("calloc: %ld,%ld  -> %p\n", (unsigned long) n, (unsigned long) size, adr));
  return adr;
}

static inline void _awt_free_wrapper ( void* adr )
{
  DBG( AWT_MEM, printf("free: %p\n", adr));
  enterUnsafeRegion();
  free( adr);
  leaveUnsafeRegion();
}

#define qqDebug(format, args...) \
  do { \
    qDebug("[%s:%d] ", __FILE__, __LINE__); \
    qDebug(format, ## args); \
  } while (0)
 

#define AWT_MALLOC(_n) \
  _awt_malloc_wrapper( _n)

#define AWT_CALLOC(_n,_sz) \
  _awt_calloc_wrapper( _n, _sz)

#define AWT_FREE(_adr) \
  _awt_free_wrapper( _adr);


static inline char* java2CString ( JNIEnv *env, Toolkit* X, const jstring jstr ) {
  jboolean isCopy;
  register unsigned int i;
  unsigned int      n = env->GetStringLength(jstr);
  const jchar    *jc = env->GetStringChars(jstr, &isCopy);

  if ( n >= X->nBuf ) {
	if ( X->buf )
	  AWT_FREE( X->buf);
	X->buf = (char*)AWT_MALLOC( n+1);
	X->nBuf = n+1;
  }

  for ( i=0; i<n; i++ ) X->buf[i] = (char) jc[i];
  X->buf[i] = 0;
  env->ReleaseStringChars( jstr, jc);

  return X->buf;
}

static inline char* jchar2CString ( Toolkit* X, const jchar* jc, int len ) {
  register int i;
  unsigned int n = len+1;
  
  if ( n > X->nBuf ) {
	if ( X->buf )
	  AWT_FREE( X->buf);
	X->buf  = (char*)AWT_MALLOC( n);
	X->nBuf = n;
  }

  for ( i=0; i<len; i++ ) X->buf[i] = (char) jc[i];
  X->buf[i] = 0;

  return X->buf;
}

static inline void* getBuffer ( Toolkit* X, unsigned int nBytes ) {
  if ( nBytes > X->nBuf ) {
	if ( X->buf )
	  AWT_FREE( X->buf);
	X->buf  = (char*)AWT_MALLOC( nBytes);
	X->nBuf = nBytes;
  }
  return X->buf;
}


/**
 * color functions & defines
 */
void initColorMapping ( JNIEnv* env, jclass clazz, Toolkit* X);

#define JRGB(_r,_g,_b)  (_r<<16 | _g<<8 | (_b))
#define JRED(_rgb)      (((_rgb) & 0xff0000) >> 16)
#define JGREEN(_rgb)    (((_rgb) & 0x00ff00) >> 8)
#define JBLUE(_rgb)     ((_rgb) & 0x0000ff)


/**
 * image functions
 */
int needsFullAlpha(Toolkit*, Image*, double);
Image* createImage ( int width, int height);
void createXMaskImage ( Toolkit* X, Image* img );
void createXImage ( Toolkit* X, Image* img );
void createAlphaImage ( Toolkit* X, Image* img );
void initScaledImage ( Toolkit* X, Image *tgt, Image *src,
					   int dx0, int dy0, int dx1, int dy1,
					   int sx0, int sy0, int sx1, int sy1 );

bool reconvertImage(Image* img);

static inline void
PutAlpha ( AlphaImage* img, int col, int row, unsigned char alpha )
{
  img->buf[ row*img->width + col ] = alpha;
}

static inline int
GetAlpha ( AlphaImage* img, int col, int row )
{
  return img->buf[ row*img->width + col];
}

/**
 * clipboard functions
 */
jobject selectionClear ( JNIEnv* env, Toolkit* X );
jobject selectionRequest ( JNIEnv* env, Toolkit* X );


/**
 * file io wrapper macros (for image production)
 */
#define AWT_OPEN(_file)               open(_file, 0)
#define AWT_REWIND(_fd)               lseek(_fd, 0, SEEK_SET)
#define AWT_SETPOS(_fd,_off)          lseek(_fd, _off, SEEK_CUR)
#define AWT_READ(_fd,_buf,_count)     read(_fd,_buf,_count)
#define AWT_CLOSE(_fd)                close(_fd)


/**
 * macros to manage the source table (conversion of X windows to/from indices, which
 * are consistent with the AWTEvent.sources array)
 */
#define WND_FRAME      0x01
#define WND_WINDOW     0x02
#define WND_DIALOG     0x04

#define WND_MAPPED     0x08
#define WND_DESTROYED  0x10

static inline int getFreeSourceIdx ( Toolkit* X, void* wnd ) {
  register int i, n;

  /*
   * we don't use a double hashing here because collisions are very unlikely
   * (window IDs usually already are hashed, so it does not make sense to
   * hash them again - we just could make it worse
   */
  for ( i = (unsigned long)wnd, n=0; n < X->nWindows; i++, n++ ) {
	i %= X->nWindows;
	if ( (long)(X->windows[i].w) <= 0 ) {
	  X->srcIdx = i;
	  X->lastWindow = wnd;

	  return i;
	}
  }

  return 0xffffffff;
}

static inline int getSourceIdx ( Toolkit* X, void* w )
{
  int      n;
  register int i;

  if ( w == X->lastWindow ){
	return X->srcIdx;
  }
  else {
	for ( i = (unsigned long) w, n=0; n < X->nWindows; i++, n++ ) {
	  i %= X->nWindows;
	  if ( X->windows[i].w == w ){
		X->srcIdx = i;
		X->lastWindow = w;
		return X->srcIdx;
	  }
	  else if ( X->windows[i].w == 0 ){
		return 0xffffffff;
	  }
	}
	return 0xffffffff;
  }
}

static inline int checkSource ( Toolkit* X, int idx )
{
  return ( (idx >= 0) && (idx < X->nWindows) && (X->windows[idx].w) );
}


/**
 * focus forwarding
 */
#define FWD_SET    0  /* set focus forwarding */
#define FWD_CLEAR  1  /* reset focus forwarding */
#define FWD_REVERT 2  /* reset focus on owner */

static inline void resetFocusForwarding ( Toolkit* X )
{
  X->fwdIdx = 0xffffffff;
  X->focusFwd = 0;
}


/**
 * Macros to implement keyboard handling for owned windows (which don't ever get
 * the X focus). This is done by means of forwarding and generation of "artificial"
 * focus events (generated from clientMessages.)
 */

#define	USE_POLLING_AWT	1


END_C_DECLS

#endif