evt.cc

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

	switch ( X->event.xclient.data.l[0] ){
	case FWD_SET:
	  DBG( AWT_EVT, printf("FWD_SET: %lx (%d) %lx\n", X->event.xany.window, X->srcIdx, X->windows[X->srcIdx].owner));

	  if ( (X->srcIdx != X->fwdIdx) && (X->focus == X->windows[X->srcIdx].owner) ){
		X->fwdIdx = X->srcIdx;
		X->focusFwd = X->event.xany.window;
		return env->CallStaticObjectMethod( FocusEvent, getFocusEvent,
											   X->srcIdx, FOCUS_GAINED, JNI_TRUE);
	  }
	  else {
		return 0;
	  }

	case FWD_CLEAR:
	  DBG( AWT_EVT, printf("FWD_CLEAR: %lx (%d) %lx\n", X->event.xany.window, X->srcIdx, X->windows[X->srcIdx].owner));

	  if ( X->fwdIdx >= 0 ) {
		resetFocusForwarding( X);
		return env->CallStaticObjectMethod( FocusEvent, getFocusEvent,
											   X->srcIdx, FOCUS_LOST, JNI_FALSE);
	  }
	  else {
		return 0;
	  }

	case FWD_REVERT:
	  DBG( AWT_EVT, printf("FWD_REVERT: %lx\n", X->event.xany.window));
	  if ( X->event.xany.window == X->focus ) {
		resetFocusForwarding( X);
		return env->CallStaticObjectMethod( FocusEvent, getFocusEvent,
											   X->srcIdx, FOCUS_GAINED, JNI_FALSE);
	  }
	}
  }
  return 0;
#endif
}

static jobject
reparentNotify ( JNIEnv* env, Toolkit* X )
{
  Window    window, parent, root;
  jclass    clazz = 0;
  jmethodID setDecoInsets = 0;
  int       left, top, right, bottom;
  int       x, y, w, h, bw, d;
  int       xc, yc, wc, hc;
  DecoInset *in = 0;
  XSizeHints wmHints;
  long      supHints;

  if ( X->frameInsets.guess || X->dialogInsets.guess ) {
	window = X->event.xreparent.window;
	parent = X->event.xreparent.parent;

	XGetGeometry( X->dsp, parent, &root, &x, &y, &w, &h, &bw, &d);
	XGetGeometry( X->dsp, window, &root, &xc, &yc, &wc, &hc, &bw, &d);

	left   = X->event.xreparent.x;
	top    = X->event.xreparent.y;
	right  = w - wc - left;
	bottom = h - hc - top;

	if ( (X->windows[X->srcIdx].flags & WND_DIALOG) && X->dialogInsets.guess ) {
	  in = &(X->dialogInsets);
	  if ( (left != in->left) || (top != in->top) ||
		   (right != in->right) || (bottom != in->bottom) ){
		clazz = env->FindClass( "java/awt/Dialog");
		setDecoInsets = env->GetStaticMethodID( clazz, "setDecoInsets","(IIIII)V");
	  }
	  in->guess = 0;
	}
	else if ( X->frameInsets.guess ) {
	  in = &(X->frameInsets);
	  if ( (left != in->left) || (top != in->top) ||
		   (right != in->right) || (bottom != in->bottom) ){
		clazz = env->FindClass( "java/awt/Frame");
		setDecoInsets = env->GetStaticMethodID( clazz, "setDecoInsets","(IIIII)V");
	  }
	  in->guess = 0;
	}

	if ( clazz ) {
	  wc -= (left + right) - (in->left + in->right);
	  hc -= (top + bottom) - (in->top + in->bottom);

	  XCheckTypedWindowEvent( X->dsp, window, ConfigureNotify, &X->event);
	  XCheckTypedWindowEvent( X->dsp, window, Expose, &X->event);
	  XResizeWindow( X->dsp, window, wc, hc);

	  in->left = left;
	  in->top = top;
	  in->right = right;
	  in->bottom = bottom;

	  env->CallStaticVoidMethod( clazz, setDecoInsets, 
									in->top, in->left, in->bottom, in->right, X->srcIdx);

	  /* check if this was a resize locked window (which has to be locked again) */
	  XGetWMNormalHints( X->dsp, window, &wmHints, &supHints);
	  if ( wmHints.min_width == wmHints.max_width ){
		wmHints.min_width = wmHints.max_width = wc;
		wmHints.min_height = wmHints.max_height = hc;
		XSetWMNormalHints( X->dsp, window, &wmHints);
	  }
	}
  }

  return NULL;
}

typedef jobject (*EventFunc)(JNIEnv*,Toolkit*);

static EventFunc  processEvent[LASTEvent] = {
  keyNotify,            /* KeyPress                 2 */
  keyNotify,            /* KeyRelease               3 */
  mouseNotify,          /* EnterNotify              7 */
  mouseNotify,          /* LeaveNotify              8 */
  focusNotify,          /* FocusIn                  9 */
  focusNotify,          /* FocusOut                10 */
  destroyNotify,        /* DestroyNotify           17 */
  mapNotify,            /* UnmapNotify             18 */
  mapNotify,            /* MapNotify               19 */
  reparentNotify,       /* ReparentNotify          21 */
  selectionClear,       /* SelectionClear          29 */
  selectionRequest,     /* SelectionRequest        30 */
  clientMessage,        /* ClientMessage           33 */
};
#endif

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

jobject Java_java_awt_Toolkit_evtInit(JNIEnv* env, jclass clazz)
{
  jclass Component;

  AWT_DBG(printf("evtInit\n"));

  if ( ComponentEvent != NULL ){
    AWT_DBG(printf("evtInit called twice\n"));
    return NULL;
  }

  if(qapp == NULL) {
    AWT_DBG(printf("evtInit: qapp not initialized!\n"));
  }

  eventDispatcher = new EventDispatcher();
  qapp->installEventFilter(eventDispatcher);

  ComponentEvent = env->FindClass("java/awt/ComponentEvt");
  MouseEvent     = env->FindClass("java/awt/MouseEvt");
  FocusEvent     = env->FindClass("java/awt/FocusEvt");
  WindowEvent    = env->FindClass("java/awt/WindowEvt");
  KeyEvent       = env->FindClass("java/awt/KeyEvt");
  PaintEvent     = env->FindClass("java/awt/PaintEvt");
  WMEvent        = env->FindClass("java/awt/WMEvent");

  getComponentEvent = env->GetStaticMethodID( ComponentEvent, "getEvent", 
												 "(IIIIII)Ljava/awt/ComponentEvt;");
  getMouseEvent     = env->GetStaticMethodID( MouseEvent, "getEvent",
												 "(IIIII)Ljava/awt/MouseEvt;");
  getFocusEvent     = env->GetStaticMethodID( FocusEvent, "getEvent",
												 "(IIZ)Ljava/awt/FocusEvt;");
  getWindowEvent    = env->GetStaticMethodID( WindowEvent, "getEvent",
												 "(II)Ljava/awt/WindowEvt;");
  getKeyEvent       = env->GetStaticMethodID( KeyEvent, "getEvent",
												 "(IIIII)Ljava/awt/KeyEvt;");
  getPaintEvent     = env->GetStaticMethodID( PaintEvent, "getEvent",
												 "(IIIIII)Ljava/awt/PaintEvt;");
  getWMEvent        = env->GetStaticMethodID( WMEvent, "getEvent",
                              "(II)Ljava/awt/WMEvent;");

  Component = env->FindClass( "java/awt/Component");
  return env->NewObjectArray( X->nWindows, Component, NULL);
}

jobject processEvent(JNIEnv* env, Toolkit* X, QEvent* event, int index)
{

  switch(event->type()) {
    case QEvent::Clipboard: {
      return clearJavaClipboard(env);
    }
    
    case QEvent::Show:
    case QEvent::Hide: {
      int id = 0;

      if (event->type() == QEvent::Show ) {
	if ( (X->windows[X->srcIdx].flags & WND_MAPPED) == 0 ){
	  id = WINDOW_DEICONIFIED;
	  X->windows[X->srcIdx].flags |= WND_MAPPED;
	}
      }
      else {
	if ( (X->windows[X->srcIdx].flags & WND_MAPPED) != 0 ){
	  id = WINDOW_ICONIFIED;
	  X->windows[X->srcIdx].flags &= ~WND_MAPPED;
	}
      }

      if ( id ) {
	return env->CallStaticObjectMethod( WindowEvent, getWindowEvent,
		   X->srcIdx, id);
      }
      else {
	// we do the ComponentEvent show/hide in Java
	return 0;
      }
    }

      

    case QEvent::Destroy: {
      AWT_DBG(printf("processing Destroy: SrcIdx=%d\n", index));
      /*
       * We should get this just for windows which have been destroyed from an
       * external client, since removeNotify() calls evtUnregisterSource() (i.e.
       * removes windows properly from the dispatch table)
       */
      X->windows[X->srcIdx].flags &= ~WND_MAPPED;

      return env->CallStaticObjectMethod( WMEvent, getWMEvent,
        	                 index, WM_KILLED);

    }
    
    case QEvent::Reparent: {
      AWT_DBG(printf("processing Reparent: SrcIdx=%d\n", index));
      return NULL;
    }

    case QEvent::FocusIn:
    case QEvent::FocusOut: {
      AWT_DBG(printf("processing %s: SrcIdx=%d\n",(event->type() == QEvent::FocusIn)?"FocusIn":"FocusOut",index));
      int evtId;
      int et = event->type();
      if ( et == QEvent::FocusIn ) {
	evtId = FOCUS_GAINED;

      }
      else {
	evtId = FOCUS_LOST;
      }

      if (checkSource( X, index) ){
	return env->CallStaticObjectMethod( FocusEvent, getFocusEvent, 
                             index, evtId, JNI_FALSE);
      }
      else {
	return NULL;
      }
    }

    case QEvent::KeyPress:
    case QEvent::KeyRelease: { 
      AWT_DBG(printf("processing %s: SrcIdx=%d\n",(event->type() == QEvent::KeyPress)?"KeyPress":"KeyRelease",index));
      QKeyEvent *keyEvent = (QKeyEvent*)event;
      int             n, keyCode, keyChar, mod;
      
      /*
       * We should eventually support input methods here.
       * Note that 'keysym' is queried separately (with a standard state), to
       * ensure the "one physical key -> one keycode" invariant
      */
      int keysym;
      n = keyEvent->count();
      keysym = keyEvent->key();

      if ( (keysym >= 0x1000) || (n == 0) ) { 
        keyCode = QFKeyCode[keysym & 0xff];
        /*
         * There are some "control keys" that should generate KEY_TYPED events
         * (enter, cancel, backspace, del, tab). This is flagged by a negative
         * value and leads to non-zero keyChars
         */
        if ( keyCode < 0 ){
          keyChar = keyCode = -keyCode;
        }
        else {  /* a "pure" function key */
          keyChar = 0;
        }
   
      }
      else {
   	keyChar = keyEvent->ascii();//(unsigned char)X->buf[0];
   	keyCode = QLKeyCode[keysym & 0xff];
      }


      int evtId = (((QEvent*)keyEvent)->type() == QEvent::KeyPress)? KEY_PRESSED : KEY_RELEASED;
      mod = keyMod(keyEvent->state());
      
      AWT_DBG(printf("KeyEvent: idx=%d keyCode=%d keyChar=%c mod=%d\n", index, keyCode,keyChar,mod));

      return env->CallStaticObjectMethod( KeyEvent, getKeyEvent,
                                          index, evtId, keyCode, keyChar, mod);

    }
    
    case QEvent::MouseButtonPress: {
      AWT_DBG(printf("processing MouseButtonPress Event SrcIdx=%d\n", index));
      QMouseEvent* mouseEvent = (QMouseEvent*)event;
      // check the diff between event.xbutton.button and QMouseEvent::button()
      if (checkSource( X, index) ){
	env->CallStaticObjectMethod( FocusEvent, getFocusEvent, 
                             index, FOCUS_GAINED, JNI_FALSE);
      }
      else {
	return NULL;
      }
      return env->CallStaticObjectMethod(MouseEvent, getMouseEvent,
        index, MOUSE_PRESSED, mapButton(mouseEvent->button()),
        mouseEvent->x(), mouseEvent->y());
    }
    case QEvent::MouseButtonRelease: {
      AWT_DBG(printf("processing MouseButtonRelease Event SrcIdx=%d\n", index));
      QMouseEvent* mouseEvent = (QMouseEvent*)event;
      // check the diff between event.xbutton.button and QMouseEvent::button()
      return env->CallStaticObjectMethod(MouseEvent, getMouseEvent,
        index, MOUSE_RELEASED, mapButton(mouseEvent->button()),
        mouseEvent->x(), mouseEvent->y());
    }
    case QEvent::MouseMove: {
      AWT_DBG(printf("processing MouseMove Event SrcIdx=%d\n", index));
      QMouseEvent* mouseEvent = (QMouseEvent*)event;
      return env->CallStaticObjectMethod(MouseEvent, getMouseEvent,
        index, MOUSE_MOVED, 0,
        mouseEvent->x(), mouseEvent->y());
    }
    case QEvent::Paint: {
      AWT_DBG(printf("processing Paint Event SrcIdx=%d\n", index));
      QPaintEvent* paintEvent = (QPaintEvent*)event;
      QRect rect=paintEvent->rect();
      return env->CallStaticObjectMethod(PaintEvent, getPaintEvent,
        index, UPDATE, rect.x(), rect.y(), rect.width(), rect.height());
    }
    case QEvent::Move: {
      AWT_DBG(printf("processing Move Event SrcIdx=%d\n", index));
      QMoveEvent* moveEvent = (QMoveEvent*)event;
      QPoint pos, data;
      pos = moveEvent->pos();
      data = moveEvent->oldPos();
      return env->CallStaticObjectMethod( ComponentEvent, getComponentEvent,
        index, COMPONENT_RESIZED, pos.x(), pos.y(), data.x(), data.y());
    }
    case QEvent::Resize: {
      AWT_DBG(printf("processing Resize Event SrcIdx=%d\n", index));
      QResizeEvent* resizeEvent = (QResizeEvent*)event;
      QSize size, data;
      size = resizeEvent->size();
      data = resizeEvent->oldSize();
      return env->CallStaticObjectMethod( ComponentEvent, getComponentEvent,
        index, COMPONENT_RESIZED, data.width(), data.height(),
        size.width(), size.height());
    }
  }
  return NULL;
}

jobject Java_java_awt_Toolkit_evtGetNextEvent(JNIEnv* env, jclass clazz)
{
  jobject jEvt = NULL;
  EventPacket *packet;
  QEvent *event;
  int index;

  //AWT_DBG(printf("getNextEvent..\n"));
  pollJavaClipboard(env);

  if (g_event_queue.count()) {
    packet=g_event_queue.dequeue();
    event=packet->getEvent();
    index=packet->getIndex();
    jEvt = processEvent(env, X, event, index);
    delete event;
    delete packet;
  }

//  qapp->processOneEvent();
  qapp->processEvents(10);

  return jEvt;
}

jobject
Java_java_awt_Toolkit_evtPeekEvent ( JNIEnv* env, jclass clazz )
{
  jobject jEvt = NULL;

  AWT_DBG(printf("peekEvent..\n"));
#if 0
  if ( nextEvent( env, clazz, X, False) && ((getSourceIdx( X, (void*)X->event.xany.window) >= 0)) ) {
	if ( (jEvt = (processEvent[X->event.xany.type])( env, X)) )
	  X->preFetched = 1;
  }

  DBG( AWT_EVT, printf("..peekEvent: %s %p, %lx\n", eventStr(X->evtId), jEvt, X->event.xany.window));
#endif
  return jEvt;
}


/*
 * We can't do a XPeekIfEvent here because it would block until such an event
 * comes in
 */
jobject
Java_java_awt_Toolkit_evtPeekEventId ( JNIEnv* env, jclass clazz, jint id )
{
  jobject jEvt;

  if ( (jEvt = Java_java_awt_Toolkit_evtPeekEvent( env, clazz)) && (X->evtId == id) ){
	return jEvt;
  }

  return NULL;
}


/*
 * This is just used to wakeup the getNextEvent call if we are multithreaded,
 * and we post an event from outside the dispatcher thread (which might be blocked
 * in a native getNextEvent). This is a tribute to the fact that we actually have
 * two different queues - the native one, and the queue for self-posted events.
 * We could also do a round trip here, but this would wake up the event dispatcher
 * immediately (i.e. before this func returns), which is probably a crude side effect
 * of postEvent().
 * Using a ClientMessage might be a bit dangerous if Xlib tries to be too smart by
 * just dispatching this to the local queue (without passing to the server)
 */
void Java_java_awt_Toolkit_evtWakeup(JNIEnv* env, jclass clazz)
{
//  XEvent event;

  AWT_DBG(printf("evtWakeup\n"));

/*
  event.xclient.type = ClientMessage; 
  event.xclient.message_type = WAKEUP;
  event.xclient.format = 8;
  event.xclient.window = X->wakeUp;

  XSendEvent( X->dsp, X->wakeUp, False, 0, &event);
  XFlush( X->dsp);
*/
}

/*
 * This is a helper for (IS_DISPATCH_EXCLUSIVE | NATIVE_DISPATCHER_LOOP) windowing
 * systems, where we need to execute certain requests (e.g. window creation) to
 * the native event thread. Not required here
 */
void
Java_java_awt_Toolkit_evtSendWMEvent ( JNIEnv* env, jclass clazz, jobject wmEvt )
{
}


jint Java_java_awt_Toolkit_evtRegisterSource(JNIEnv* env, jclass clazz,
  void* wnd)
{
  /*
   * We have done that already during the various wndCreateXX()
   */
  int i = getSourceIdx( X, wnd);

  AWT_DBG(printf("registerSource( %p) -> %d\n", wnd, i));

  return i;
}


jint Java_java_awt_Toolkit_evtUnregisterSource(JNIEnv* env, jclass clazz,
  void* wnd)
{
  int i = getSourceIdx( X, wnd);

  if ( i >= 0 ){
	X->windows[i].w = (void*)0xffffffff;
	X->windows[i].flags = 0;
	X->windows[i].owner = 0;
  }

  if ( X->lastWindow == wnd )
	X->lastWindow = 0;

  AWT_DBG(printf("unregisterSource( %p) -> %d\n", wnd, i));

  return i;
}