gnu_java_awt_peer_gtk_gtkevents.c

来自「Mac OS X 10.4.9 for x86 Source Code gcc」· C语言 代码 · 共 1,177 行 · 第 1/3 页

      if (event->key.string[0] == 13)
        return VK_ENTER;
      else
        return event->key.string[0];
    }
  else
    {
      switch (event->key.keyval)
        {
        case GDK_BackSpace:
          return VK_BACK_SPACE;
        case GDK_Tab:
          return VK_TAB;
        case GDK_Delete:
        case GDK_KP_Delete:
          return VK_DELETE;
        default:
          return AWT_KEY_CHAR_UNDEFINED;
        }
    }
}

void
awt_event_handler (GdkEvent *event)
{
  /* keep synthetic AWT events from being processed recursively */
  if (event->type & SYNTHETIC_EVENT_MASK && event->type != GDK_NOTHING)
    {
      event->type ^= SYNTHETIC_EVENT_MASK;
    }

  gtk_main_do_event (event);
}

gboolean
pre_event_handler (GtkWidget *widget, GdkEvent *event, jobject peer)
{
  GtkWidget *event_widget;
  static guint32 button_click_time = 0;
  static GdkWindow *button_window = NULL;
  static guint button_number = -1;
  static jint click_count = 1;
  static int hasBeenDragged;
  union widget_union w;

  /* If it is not a focus change event, the widget must be realized already.
     If not, ignore the event (Gtk+ will do the same). */
  if (!(event->type == GDK_FOCUS_CHANGE || GTK_WIDGET_REALIZED(widget)))
    return FALSE;

  /* Do not handle propagated events.  AWT has its own propagation rules */
  w.widget = &event_widget;
  gdk_window_get_user_data (event->any.window, w.void_widget);
  if (event_widget != widget)
    return FALSE;

  /* We only care about input events */    
  if (!(event->type == GDK_BUTTON_PRESS
       || event->type == GDK_BUTTON_RELEASE
       || event->type == GDK_ENTER_NOTIFY
       || event->type == GDK_LEAVE_NOTIFY
       || event->type == GDK_CONFIGURE
       || event->type == GDK_EXPOSE
       || event->type == GDK_KEY_PRESS
       || event->type == GDK_KEY_RELEASE
       || event->type == GDK_FOCUS_CHANGE
       || event->type == GDK_MOTION_NOTIFY))
    {
      return FALSE;
    }
  /* g_print("event %u widget %s peer %p\n",
            event->type, gtk_widget_get_name (widget), peer); */

  /* If it has no jobject associated we can send no AWT event */
  if (!peer)
    return FALSE;

  /* for all input events, which have a window with a jobject attached,
     send the AWT input event corresponding to the Gtk event off to Java  */

  /* keep track of clickCount ourselves, since the AWT allows more
     than a triple click to occur */
  if (event->type == GDK_BUTTON_PRESS)
    {
      if ((event->button.time < (button_click_time + MULTI_CLICK_TIME))
	  && (event->button.window == button_window)
	  && (event->button.button == button_number))
	click_count++;
      else
	click_count = 1;
      
      button_click_time = event->button.time;
      button_window = event->button.window;
      button_number = event->button.button;
    }

  switch (event->type)
    {
    case GDK_BUTTON_PRESS:
      gdk_threads_leave ();
      (*gdk_env())->CallVoidMethod (gdk_env(), peer,
                                  postMouseEventID,
				  AWT_MOUSE_PRESSED, 
				  (jlong)event->button.time,
                                  state_to_awt_mods (event->button.state)
                                  | button_to_awt_mods (event->button.button),
				  (jint)event->button.x,
				  (jint)event->button.y, 
				  click_count, 
				  (event->button.button == 3) ? JNI_TRUE :
				                                JNI_FALSE);
      gdk_threads_enter ();
      hasBeenDragged = FALSE;
      break;
    case GDK_BUTTON_RELEASE:
      {
	int width, height;

	gdk_threads_leave ();
	(*gdk_env())->CallVoidMethod (gdk_env(), peer,
				    postMouseEventID,
				    AWT_MOUSE_RELEASED, 
				    (jlong)event->button.time,
                                    state_to_awt_mods (event->button.state)
                                    | button_to_awt_mods (event->button.button),
				    (jint)event->button.x,
				    (jint)event->button.y, 
				    click_count,
				    JNI_FALSE);
	gdk_threads_enter ();

	/* Generate an AWT click event only if the release occured in the
	   window it was pressed in, and the mouse has not been dragged since
	   the last time it was pressed. */
	gdk_window_get_size (event->any.window, &width, &height);
	if (! hasBeenDragged
	    && event->button.x >= 0
            && event->button.y >= 0
	    && event->button.x <= width 
	    && event->button.y <= height)
          {
	    gdk_threads_leave ();
	    (*gdk_env())->CallVoidMethod (gdk_env(), peer,
				        postMouseEventID,
				        AWT_MOUSE_CLICKED, 
				        (jlong)event->button.time,
				        state_to_awt_mods (event->button.state)
                                        | button_to_awt_mods (event->button.button),
				        (jint)event->button.x,
				        (jint)event->button.y, 
				        click_count,
				        JNI_FALSE);
	    gdk_threads_enter ();
          }
      }
      break;
    case GDK_MOTION_NOTIFY:
      if (event->motion.state & (GDK_BUTTON1_MASK
				 | GDK_BUTTON2_MASK
				 | GDK_BUTTON3_MASK
				 | GDK_BUTTON4_MASK
				 | GDK_BUTTON5_MASK))
	{
	  gdk_threads_leave ();
	  (*gdk_env())->CallVoidMethod (gdk_env(), peer,
			              postMouseEventID,
				      AWT_MOUSE_DRAGGED,
				      (jlong)event->motion.time,
				      state_to_awt_mods_with_button_states (event->motion.state),
				      (jint)event->motion.x,
				      (jint)event->motion.y,
				      0,
				      JNI_FALSE);
	  gdk_threads_enter ();
	  hasBeenDragged = TRUE;
	}
      else
	{
	  gdk_threads_leave ();
	  (*gdk_env())->CallVoidMethod (gdk_env(), peer, postMouseEventID,
					AWT_MOUSE_MOVED,
					(jlong)event->motion.time,
					state_to_awt_mods (event->motion.state),
					(jint)event->motion.x,
					(jint)event->motion.y,
					0,
					JNI_FALSE);
	  gdk_threads_enter ();
	}

      break;
    case GDK_ENTER_NOTIFY:
      /* We are not interested in enter events that are due to
         grab/ungrab and not to actually crossing boundaries */
      if (event->crossing.mode == GDK_CROSSING_NORMAL)
	{
	  gdk_threads_leave ();	  
	  (*gdk_env())->CallVoidMethod (gdk_env(), peer, postMouseEventID,
					AWT_MOUSE_ENTERED, 
					(jlong)event->crossing.time,
					state_to_awt_mods_with_button_states (event->crossing.state), 
					(jint)event->crossing.x,
					(jint)event->crossing.y, 
					0,
					JNI_FALSE);
	  gdk_threads_enter ();
	}
      break;
    case GDK_LEAVE_NOTIFY:
      /* We are not interested in leave events that are due to
         grab/ungrab and not to actually crossing boundaries */
      if (event->crossing.mode == GDK_CROSSING_NORMAL)
	{
	  gdk_threads_leave ();	  
	  (*gdk_env())->CallVoidMethod (gdk_env(), peer,
					postMouseEventID,
					AWT_MOUSE_EXITED, 
					(jlong)event->crossing.time,
					state_to_awt_mods_with_button_states (event->crossing.state),
					(jint)event->crossing.x,
					(jint)event->crossing.y, 
					0,
					JNI_FALSE);
	  gdk_threads_enter ();	  
	}
      break;
    case GDK_CONFIGURE:
      {
        /* Only send configure events to visible top-level windows. */
	if (widget && GTK_WIDGET_TOPLEVEL (widget)
            && GTK_WIDGET_VISIBLE (widget))
	  {
	    /* Configure events are not posted to the AWT event
	       queue, and as such, the gdk/gtk peer functions will
	       be called back before postConfigureEvent
	       returns. */
	    gdk_threads_leave ();

 	    (*gdk_env())->CallVoidMethod (gdk_env(), peer,
					postConfigureEventID,
					(jint) event->configure.x,
					(jint) event->configure.y,
					(jint) event->configure.width,
					(jint) event->configure.height);
	    gdk_threads_enter ();
	  }
      }
      break;
    case GDK_EXPOSE:
      gdk_threads_leave ();
      (*gdk_env())->CallVoidMethod (gdk_env(), peer,
                                  postExposeEventID,
                                  (jint)event->expose.area.x,
                                  (jint)event->expose.area.y,
                                  (jint)event->expose.area.width,
                                  (jint)event->expose.area.height);
      gdk_threads_enter ();
      break;

    case GDK_FOCUS_CHANGE:
      gdk_threads_leave ();
      (*gdk_env())->CallVoidMethod (gdk_env(), peer,
				  postFocusEventID,
				  (jint) (event->focus_change.in) ?
				  AWT_FOCUS_GAINED : AWT_FOCUS_LOST,
				  JNI_FALSE);
      gdk_threads_enter ();
      break;
    case GDK_KEY_PRESS:
        if (GTK_IS_WINDOW (widget))
          {
            /*            GdkEventKey *keyevent = (GdkEventKey *) event; */
            /*            g_printerr ("key press event: sent: %d  time: %d  state: %d  keyval: %d  length: %d  string: %s  hardware_keycode: %d  group: %d\n", keyevent->send_event, keyevent->time, keyevent->state, keyevent->keyval, keyevent->length, keyevent->string, keyevent->hardware_keycode, keyevent->group); */

	    gdk_threads_leave ();
            (*gdk_env())->CallVoidMethod (gdk_env(), peer,
                                        postKeyEventID,
                                        (jint) AWT_KEY_PRESSED,
                                        (jlong) event->key.time,
                                        keyevent_state_to_awt_mods (event),
                                        keysym_to_awt_keycode (event),
                                        keyevent_to_awt_keychar (event),
                                        keysym_to_awt_keylocation (event));
	    gdk_threads_enter ();
            /* FIXME: generation of key typed events needs to be moved
               to GtkComponentPeer.postKeyEvent.  If the key in a key
               press event is not an "action" key
               (KeyEvent.isActionKey) and is not a modifier key, then
               it should generate a key typed event. */
            return TRUE;
          }
        else
          return FALSE;
        break;
    case GDK_KEY_RELEASE:
      if (GTK_IS_WINDOW (widget))
        {
	    gdk_threads_leave ();
            (*gdk_env())->CallVoidMethod (gdk_env(), peer,
                                        postKeyEventID,
                                        (jint) AWT_KEY_RELEASED,
                                        (jlong) event->key.time,
                                        keyevent_state_to_awt_mods (event),
                                        keysym_to_awt_keycode (event),
                                        keyevent_to_awt_keychar (event),
                                        keysym_to_awt_keylocation (event));
	    gdk_threads_enter ();
            return TRUE;
        }
      else
        return FALSE;
      break;
    default:
      break;
    }
  
  return FALSE;
}

static void
attach_jobject (GdkWindow *window, jobject *obj)
{
  GdkAtom addr_atom = gdk_atom_intern ("_GNU_GTKAWT_ADDR", FALSE);
  GdkAtom type_atom = gdk_atom_intern ("CARDINAL", FALSE);

  gdk_window_set_events (window, 
			 gdk_window_get_events (window)
			 | GDK_POINTER_MOTION_MASK
			 | GDK_BUTTON_MOTION_MASK
			 | GDK_BUTTON_PRESS_MASK
			 | GDK_BUTTON_RELEASE_MASK
			 | GDK_KEY_PRESS_MASK
			 | GDK_KEY_RELEASE_MASK
			 | GDK_ENTER_NOTIFY_MASK
			 | GDK_LEAVE_NOTIFY_MASK
			 | GDK_STRUCTURE_MASK
			 | GDK_KEY_PRESS_MASK
			 | GDK_FOCUS_CHANGE_MASK);

  gdk_property_change (window,
		       addr_atom,
		       type_atom,
		       8,
		       GDK_PROP_MODE_REPLACE,
		       (guchar *)obj,
		       sizeof (jobject));
}

void
connect_awt_hook (JNIEnv *env, jobject peer_obj, int nwindows, ...)
{
  va_list ap;
  jobject *obj;

  obj = NSA_GET_GLOBAL_REF (env, peer_obj);
  g_assert (obj);

  va_start (ap, nwindows);
  {
  int i;
  for (i = 0; i < nwindows; i++)
    {
      GdkWindow* attach = (va_arg (ap, GdkWindow *));
      attach_jobject(attach, obj);
    }
  }
  va_end (ap);
}

/*
 * Attach a Java object that is backed by widget.  This callback is
 * called after the widget's window has been realized.  That way, we
 * can be sure that widget->window is non-NULL, and so can have data
 * connected to it.
 */
void connect_awt_hook_cb (GtkWidget *widget __attribute__((unused)),
			  jobject peer)
{
  void *ptr;

  ptr = NSA_GET_PTR (gdk_env(), peer);

  connect_awt_hook (gdk_env(), peer, 1, GTK_WIDGET (ptr)->window);

  gdk_threads_leave ();

  (*gdk_env())->CallVoidMethod (gdk_env(), peer, setCursorID);

  gdk_threads_enter ();
}