gnu_java_awt_peer_gtk_gtkcomponentpeer.c

gcc的组建

{
  void *ptr;
  jboolean ret_val;
  
  gdk_threads_enter ();

  ptr = NSA_GET_PTR (env, obj);

  ret_val = GTK_WIDGET_IS_SENSITIVE (GTK_WIDGET (ptr));

  gdk_threads_leave ();

  return ret_val;
}

JNIEXPORT jboolean JNICALL 
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_isRealized
  (JNIEnv *env, jobject obj)
{
  void *ptr;
  jboolean ret_val;

  gdk_threads_enter ();

  ptr = NSA_GET_PTR (env, obj);

  if (ptr == NULL)
    {
      gdk_threads_leave ();
      return FALSE;
    }

  ret_val = GTK_WIDGET_REALIZED (GTK_WIDGET (ptr));

  gdk_threads_leave ();

  return ret_val;
}

JNIEXPORT jboolean JNICALL 
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_modalHasGrab
  (JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)))
{
  GtkWidget *widget;
  jboolean retval;

  gdk_threads_enter ();

  widget = gtk_grab_get_current ();
  retval = (widget && GTK_IS_WINDOW (widget) && GTK_WINDOW (widget)->modal);

  gdk_threads_leave ();

  return retval;
}

JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_connectSignals
  (JNIEnv *env, jobject obj)
{
  void *ptr;
  jobject *gref;

  gdk_threads_enter ();

  ptr = NSA_GET_PTR (env, obj);
  gref = NSA_GET_GLOBAL_REF (env, obj);

  cp_gtk_component_connect_signals (ptr, gref);

  gdk_threads_leave ();
}

JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_setNativeEventMask
  (JNIEnv *env, jobject obj)
{
  void *ptr;

  gdk_threads_enter ();

  ptr = NSA_GET_PTR (env, obj);

  gtk_widget_add_events (GTK_WIDGET (ptr),
                         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_threads_leave ();
}

/* FIXME: these functions should be implemented by overridding the
   appropriate GtkComponentPeer methods. */
static GtkWidget *
find_fg_color_widget (GtkWidget *widget)
{
  GtkWidget *fg_color_widget;

  if (GTK_IS_EVENT_BOX (widget)
      || (GTK_IS_BUTTON (widget)
	  && !GTK_IS_COMBO_BOX (widget)))
    fg_color_widget = gtk_bin_get_child (GTK_BIN(widget));
  else
    fg_color_widget = widget;

  return fg_color_widget;
}

static GtkWidget *
find_bg_color_widget (GtkWidget *widget)
{
  GtkWidget *bg_color_widget;

  bg_color_widget = widget;

  return bg_color_widget;
}

void
cp_gtk_component_connect_expose_signals (GObject *ptr, jobject *gref)
{
  g_signal_connect (G_OBJECT (ptr), "expose-event",
                    G_CALLBACK (component_expose_cb), *gref);
}

void
cp_gtk_component_connect_focus_signals (GObject *ptr, jobject *gref)
{
  g_signal_connect (G_OBJECT (ptr), "focus-in-event",
                    G_CALLBACK (component_focus_in_cb), *gref);
 
  g_signal_connect (G_OBJECT (ptr), "focus-out-event",
                    G_CALLBACK (component_focus_out_cb), *gref);
}

void
cp_gtk_component_connect_mouse_signals (GObject *ptr, jobject *gref)
{
  g_signal_connect (G_OBJECT (ptr), "button-press-event",
                    G_CALLBACK (component_button_press_cb), *gref);
 
  g_signal_connect (G_OBJECT (ptr), "button-release-event",
                    G_CALLBACK (component_button_release_cb), *gref);
 
  g_signal_connect (G_OBJECT (ptr), "enter-notify-event",
                    G_CALLBACK (component_enter_notify_cb), *gref);
 
  g_signal_connect (G_OBJECT (ptr), "leave-notify-event",
                    G_CALLBACK (component_leave_notify_cb), *gref);

  g_signal_connect (G_OBJECT (ptr), "motion-notify-event",
                    G_CALLBACK (component_motion_notify_cb), *gref);
}

void
cp_gtk_component_connect_signals (GObject *ptr, jobject *gref)
{
  cp_gtk_component_connect_expose_signals (ptr, gref);
  cp_gtk_component_connect_focus_signals (ptr, gref);
  cp_gtk_component_connect_mouse_signals (ptr, gref);
}

/* These variables are used to keep track of click counts.  The AWT
   allows more than a triple click to occur but GTK doesn't report
   more-than-triple clicks. */
static jint click_count = 1;
static guint32 button_click_time = 0;
static GdkWindow *button_window = NULL;
static guint button_number = -1;
static int hasBeenDragged;

static gboolean
component_button_press_cb (GtkWidget *widget __attribute__((unused)),
                           GdkEventButton *event,
                           jobject peer)
{
  /* Ignore double and triple click events. */
  if (event->type == GDK_2BUTTON_PRESS
      || event->type == GDK_3BUTTON_PRESS)
    return FALSE;

  if ((event->time < (button_click_time + MULTI_CLICK_TIME))
      && (event->window == button_window)
      && (event->button == button_number))
    click_count++;
  else
    click_count = 1;
      
  button_click_time = event->time;
  button_window = event->window;
  button_number = event->button;

  (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                postMouseEventID,
                                AWT_MOUSE_PRESSED, 
                                (jlong)event->time,
                                cp_gtk_state_to_awt_mods (event->state)
                                | button_to_awt_mods (event->button),
                                (jint)event->x,
                                (jint)event->y, 
                                click_count, 
                                (event->button == 3) ? JNI_TRUE :
                                JNI_FALSE);

  hasBeenDragged = FALSE;

  return FALSE;
}

static gboolean
component_button_release_cb (GtkWidget *widget __attribute__((unused)),
                             GdkEventButton *event,
                             jobject peer)
{
  int width, height;

  (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                postMouseEventID,
                                AWT_MOUSE_RELEASED, 
                                (jlong)event->time,
                                cp_gtk_state_to_awt_mods (event->state)
                                | button_to_awt_mods (event->button),
                                (jint)event->x,
                                (jint)event->y, 
                                click_count,
                                JNI_FALSE);

  /* 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_drawable_get_size (event->window, &width, &height);
  if (! hasBeenDragged
      && event->x >= 0
      && event->y >= 0
      && event->x <= width 
      && event->y <= height)
    {
      (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                    postMouseEventID,
                                    AWT_MOUSE_CLICKED, 
                                    (jlong)event->time,
                                    cp_gtk_state_to_awt_mods (event->state)
                                    | button_to_awt_mods (event->button),
                                    (jint)event->x,
                                    (jint)event->y, 
                                    click_count,
                                    JNI_FALSE);
    }
  return FALSE;
}
 
static gboolean
component_motion_notify_cb (GtkWidget *widget __attribute__((unused)),
                            GdkEventMotion *event,
                            jobject peer)
{
  if (event->state & (GDK_BUTTON1_MASK
                      | GDK_BUTTON2_MASK
                      | GDK_BUTTON3_MASK
                      | GDK_BUTTON4_MASK
                      | GDK_BUTTON5_MASK))
    {
      (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                    postMouseEventID,
                                    AWT_MOUSE_DRAGGED,
                                    (jlong)event->time,
                                    state_to_awt_mods_with_button_states (event->state),
                                    (jint)event->x,
                                    (jint)event->y,
                                    0,
                                    JNI_FALSE);

      hasBeenDragged = TRUE;
    }
  else
    {
      (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, postMouseEventID,
                                    AWT_MOUSE_MOVED,
                                    (jlong)event->time,
                                    cp_gtk_state_to_awt_mods (event->state),
                                    (jint)event->x,
                                    (jint)event->y,
                                    0,
                                    JNI_FALSE);
    }
  return FALSE;
}

static gboolean
component_enter_notify_cb (GtkWidget *widget __attribute__((unused)),
                           GdkEventCrossing *event,
                           jobject peer)
{
  /* We are not interested in enter events that are due to
     grab/ungrab and not to actually crossing boundaries */
  if (event->mode == GDK_CROSSING_NORMAL)
    {
      (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, postMouseEventID,
                                    AWT_MOUSE_ENTERED, 
                                    (jlong)event->time,
                                    state_to_awt_mods_with_button_states (event->state), 
                                    (jint)event->x,
                                    (jint)event->y, 
                                    0,
                                    JNI_FALSE);
    }
  return FALSE;
}

static gboolean
component_leave_notify_cb (GtkWidget *widget __attribute__((unused)),
                           GdkEventCrossing *event,
                           jobject peer)
{
  /* We are not interested in leave events that are due to
     grab/ungrab and not to actually crossing boundaries */
  if (event->mode == GDK_CROSSING_NORMAL)
    {
      (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                    postMouseEventID,
                                    AWT_MOUSE_EXITED, 
                                    (jlong)event->time,
                                    state_to_awt_mods_with_button_states (event->state),
                                    (jint)event->x,
                                    (jint)event->y, 
                                    0,
                                    JNI_FALSE);
    }
  return FALSE;
}

static gboolean
component_expose_cb (GtkWidget *widget __attribute__((unused)),
                     GdkEventExpose *event,
                     jobject peer)
{
  (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                postExposeEventID,
                                (jint)event->area.x,
                                (jint)event->area.y,
                                (jint)event->area.width,
                                (jint)event->area.height);

  return FALSE;
}

static gboolean
component_focus_in_cb (GtkWidget *widget __attribute((unused)),
                       GdkEventFocus *event __attribute((unused)),
                       jobject peer)
{
  (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                postFocusEventID,
                                AWT_FOCUS_GAINED,
                                JNI_FALSE);

  return FALSE;
}

static gboolean
component_focus_out_cb (GtkWidget *widget __attribute((unused)),
                        GdkEventFocus *event __attribute((unused)),
                        jobject peer)
{
  (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
                                postFocusEventID,
                                AWT_FOCUS_LOST,
                                JNI_FALSE);

  return FALSE;
}