gdkevents-win32.c

linux下电话本所依赖的一些图形库

static char *
event_mask_string (GdkEventMask mask)
{
  static char bfr[500];
  char *p = bfr;

  *p = '\0';
#define BIT(x) \
  if (mask & GDK_##x##_MASK) \
    p += g_sprintf (p, "%s" #x, (p > bfr ? " " : ""))
  BIT (EXPOSURE);
  BIT (POINTER_MOTION);
  BIT (POINTER_MOTION_HINT);
  BIT (BUTTON_MOTION);
  BIT (BUTTON1_MOTION);
  BIT (BUTTON2_MOTION);
  BIT (BUTTON3_MOTION);
  BIT (BUTTON_PRESS);
  BIT (BUTTON_RELEASE);
  BIT (KEY_PRESS);
  BIT (KEY_RELEASE);
  BIT (ENTER_NOTIFY);
  BIT (LEAVE_NOTIFY);
  BIT (FOCUS_CHANGE);
  BIT (STRUCTURE);
  BIT (PROPERTY_CHANGE);
  BIT (VISIBILITY_NOTIFY);
  BIT (PROXIMITY_IN);
  BIT (PROXIMITY_OUT);
  BIT (SUBSTRUCTURE);
  BIT (SCROLL);
#undef BIT

  return bfr;
}

GdkGrabStatus
gdk_pointer_grab (GdkWindow    *window,
		  gboolean	owner_events,
		  GdkEventMask	event_mask,
		  GdkWindow    *confine_to,
		  GdkCursor    *cursor,
		  guint32	time)
{
  HCURSOR hcursor;
  GdkCursorPrivate *cursor_private;
  gint return_val = GDK_GRAB_SUCCESS;

  g_return_val_if_fail (window != NULL, 0);
  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
  g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
  
  cursor_private = (GdkCursorPrivate*) cursor;
  
  if (!cursor)
    hcursor = NULL;
  else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)
    WIN32_API_FAILED ("CopyCursor");

  return_val = _gdk_input_grab_pointer (window,
					owner_events,
					event_mask,
					confine_to,
					time);

  if (return_val == GDK_GRAB_SUCCESS)
    {
      if (!GDK_WINDOW_DESTROYED (window))
	{
	  GDK_NOTE (EVENTS, g_print ("%sgdk_pointer_grab: %p %s %p %s%s",
				     (debug_indent > 0 ? "\n" : ""),
				     GDK_WINDOW_HWND (window),
				     (owner_events ? "TRUE" : "FALSE"),
				     hcursor,
				     event_mask_string (event_mask),
				     (debug_indent == 0 ? "\n" : "")));

	  p_grab_mask = event_mask;
	  p_grab_owner_events = owner_events;
	  p_grab_automatic = FALSE;
	  
	  SetCapture (GDK_WINDOW_HWND (window));
	  return_val = GDK_GRAB_SUCCESS;
	}
      else
	return_val = GDK_GRAB_ALREADY_GRABBED;
    }
  
  if (return_val == GDK_GRAB_SUCCESS)
    {
      GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
      p_grab_window = window;

      if (p_grab_cursor != NULL)
	{
	  if (GetCursor () == p_grab_cursor)
	    SetCursor (NULL);
	  DestroyCursor (p_grab_cursor);
	}

      p_grab_cursor = hcursor;

      if (p_grab_cursor != NULL)
	SetCursor (p_grab_cursor);
      else if (impl->hcursor != NULL)
	SetCursor (impl->hcursor);
      else
	SetCursor (LoadCursor (NULL, IDC_ARROW));

      if (confine_to != NULL)
	{
	  gint x, y, width, height;
	  RECT rect;

	  gdk_window_get_origin (confine_to, &x, &y);
	  gdk_drawable_get_size (confine_to, &width, &height);

	  rect.left = x;
	  rect.top = y;
	  rect.right = x + width;
	  rect.bottom = y + height;
	  API_CALL (ClipCursor, (&rect));
	  p_grab_confine_to = confine_to;
	}

      /* FIXME: Generate GDK_CROSSING_GRAB events */
    }
  
  return return_val;
}

void
gdk_display_pointer_ungrab (GdkDisplay *display,
                            guint32     time)
{
  g_return_if_fail (display == gdk_display_get_default ());

  GDK_NOTE (EVENTS, g_print ("%sgdk_display_pointer_ungrab%s",
			     (debug_indent > 0 ? "\n" : ""),
			     (debug_indent == 0 ? "\n" : "")));

  _gdk_input_ungrab_pointer (time);

  if (GetCapture () != NULL)
    ReleaseCapture ();

  /* FIXME: Generate GDK_CROSSING_UNGRAB events */

  p_grab_window = NULL;
  if (p_grab_cursor != NULL)
    {
      if (GetCursor () == p_grab_cursor)
	SetCursor (NULL);
      DestroyCursor (p_grab_cursor);
      p_grab_cursor = NULL;
    }

  if (p_grab_confine_to != NULL)
    {
      API_CALL (ClipCursor, (NULL));
      p_grab_confine_to = NULL;
    }
}

static GdkWindow *
find_real_window_for_grabbed_mouse_event (GdkWindow* reported_window,
					  MSG*       msg)
{
  HWND hwnd;
  POINTS points;
  POINT pt;
  GdkWindow* other_window = NULL;

  points = MAKEPOINTS (msg->lParam);
  pt.x = points.x;
  pt.y = points.y;
  ClientToScreen (msg->hwnd, &pt);

  hwnd = WindowFromPoint (pt);

  if (hwnd != NULL)
    {
      RECT rect;

      GetClientRect (hwnd, &rect);
      ScreenToClient (hwnd, &pt);
      if (!PtInRect (&rect, pt))
	return _gdk_parent_root;

      other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
    }

  if (other_window == NULL)
    return _gdk_parent_root;

  return other_window;
}

static GdkWindow* 
find_window_for_mouse_event (GdkWindow* reported_window,
			     MSG*       msg)
{
  if (p_grab_window == NULL || !p_grab_owner_events)
    return reported_window;
  else
    return find_real_window_for_grabbed_mouse_event (reported_window, msg);
}

gboolean
gdk_display_pointer_is_grabbed (GdkDisplay *display)
{
  g_return_val_if_fail (display == gdk_display_get_default (), FALSE);
  GDK_NOTE (EVENTS, g_print ("gdk_pointer_is_grabbed: %s\n",
			     p_grab_window != NULL ? "TRUE" : "FALSE"));
  return p_grab_window != NULL;
}

gboolean
gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
				   GdkWindow **grab_window,
				   gboolean   *owner_events)
{
  g_return_val_if_fail (display == gdk_display_get_default (), FALSE);

  if (p_grab_window != NULL)
    {
      if (grab_window)
        *grab_window = p_grab_window;
      if (owner_events)
        *owner_events = p_grab_owner_events;

      return TRUE;
    }
  else
    return FALSE;
}

GdkGrabStatus
gdk_keyboard_grab (GdkWindow *window,
		   gboolean   owner_events,
		   guint32    time)
{
  GdkWindow *real_focus_window, *grab_focus_window;

  gint return_val;
  
  g_return_val_if_fail (window != NULL, 0);
  g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
  
  GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %p\n",
			     GDK_WINDOW_HWND (window)));

  if (!GDK_WINDOW_DESTROYED (window))
    {
      k_grab_owner_events = owner_events != 0;
      return_val = GDK_GRAB_SUCCESS;
    }
  else
    return_val = GDK_GRAB_ALREADY_GRABBED;

  if (return_val == GDK_GRAB_SUCCESS)
    {
      k_grab_window = window;

      if (!k_grab_owner_events)
	{
	  real_focus_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) GetFocus ());
	  if (real_focus_window)
	    real_focus_window = gdk_window_get_toplevel (real_focus_window);
	  grab_focus_window = gdk_window_get_toplevel (k_grab_window);
	  if (real_focus_window != grab_focus_window)
	    {
	      /* Generate events for focus change from the window that really
	       * has focus to the grabber.
	       */
	      if (real_focus_window && !GDK_WINDOW_DESTROYED (real_focus_window)
		  && (((GdkWindowObject *) real_focus_window)->event_mask
		      & GDK_FOCUS_CHANGE_MASK))
		generate_focus_event (real_focus_window, FALSE);

	      if (((GdkWindowObject *) grab_focus_window)->event_mask 
		  & GDK_FOCUS_CHANGE_MASK)
		generate_focus_event (grab_focus_window, TRUE);
	    }
	}
    }
  
  return return_val;
}

void
gdk_display_keyboard_ungrab (GdkDisplay *display,
                             guint32 time)
{
  GdkWindow *real_focus_window, *grab_focus_window;

  g_return_if_fail (display == gdk_display_get_default ());

  GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));

  if (k_grab_window && !k_grab_owner_events)
    {
      real_focus_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) GetFocus ());
      if (real_focus_window)
	real_focus_window = gdk_window_get_toplevel (real_focus_window);
      if (!GDK_WINDOW_DESTROYED (k_grab_window))
	grab_focus_window = gdk_window_get_toplevel (k_grab_window);
      else
	grab_focus_window = NULL;
      if (real_focus_window != grab_focus_window)
	{
	  /* Generate events for focus change from grabber to the window that
	   * really has focus. Important for example if a new window is created
	   * while focus is grabbed.
	   */
	  if (grab_focus_window
	      && (((GdkWindowObject *) grab_focus_window)->event_mask
		  & GDK_FOCUS_CHANGE_MASK))
	    generate_focus_event (grab_focus_window, FALSE);

	  if (real_focus_window && !GDK_WINDOW_DESTROYED (real_focus_window)
	      && (((GdkWindowObject *) real_focus_window)->event_mask
		  & GDK_FOCUS_CHANGE_MASK))
	    generate_focus_event (real_focus_window, TRUE);
	}
    }

  k_grab_window = NULL;
}

gboolean
gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,
				    GdkWindow **grab_window,
				    gboolean   *owner_events)
{
  g_return_val_if_fail (display == gdk_display_get_default (), FALSE);

  if (k_grab_window)
    {
      if (grab_window)
        *grab_window = k_grab_window;
      if (owner_events)
        *owner_events = k_grab_owner_events;

      return TRUE;
    }
  else
    return FALSE;
}

static GdkFilterReturn
gdk_event_apply_filters (MSG      *msg,
			 GdkEvent *event,
			 GList    *filters)
{
  GdkEventFilter *filter;
  GList *tmp_list;
  GdkFilterReturn result;
  
  tmp_list = filters;
  
  while (tmp_list)
    {
      filter = (GdkEventFilter *) tmp_list->data;
      
      result = (*filter->function) (msg, event, filter->data);
      if (result !=  GDK_FILTER_CONTINUE)
	return result;
      
      tmp_list = tmp_list->next;
    }
  
  return GDK_FILTER_CONTINUE;
}

void 
gdk_display_add_client_message_filter (GdkDisplay   *display,
				       GdkAtom       message_type,
				       GdkFilterFunc func,
				       gpointer      data)
{
  /* XXX */
  gdk_add_client_message_filter (message_type, func, data);
}

void 
gdk_add_client_message_filter (GdkAtom       message_type,
			       GdkFilterFunc func,
			       gpointer      data)
{
  GdkClientFilter *filter = g_new (GdkClientFilter, 1);

  filter->type = message_type;
  filter->function = func;
  filter->data = data;
  
  client_filters = g_list_append (client_filters, filter);
}

static void
build_key_event_state (GdkEvent *event,
		       BYTE     *key_state)
{
  event->key.state = 0;

  if (key_state[VK_SHIFT] & 0x80)
    event->key.state |= GDK_SHIFT_MASK;

  if (key_state[VK_CAPITAL] & 0x01)
    event->key.state |= GDK_LOCK_MASK;

  if (key_state[VK_LBUTTON] & 0x80)
    event->key.state |= GDK_BUTTON1_MASK;
  if (key_state[VK_MBUTTON] & 0x80)
    event->key.state |= GDK_BUTTON2_MASK;
  if (key_state[VK_RBUTTON] & 0x80)
    event->key.state |= GDK_BUTTON3_MASK;
  if (key_state[VK_XBUTTON1] & 0x80)
    event->key.state |= GDK_BUTTON4_MASK;
  if (key_state[VK_XBUTTON2] & 0x80)
    event->key.state |= GDK_BUTTON5_MASK;

  /* Win9x doesn't distinguish between left and right Control and Alt
   * in the keyboard state as returned by GetKeyboardState(), so we
   * have to punt, and accept either Control + either Alt to be AltGr.
   *
   * Alternatively, we could have some state saved when the Control
   * and Alt keys messages come in, as the KF_EXTENDED bit in lParam
   * does indicate correctly whether it is the right Control or Alt
   * key. But that would be a bit messy.
   */
  if (!G_WIN32_IS_NT_BASED () &&
      _gdk_keyboard_has_altgr &&
      key_state[VK_CONTROL] & 0x80 &&
      key_state[VK_MENU] & 0x80)
    key_state[VK_LCONTROL] = key_state[VK_RMENU] = 0x80;

  if (_gdk_keyboard_has_altgr &&
      (key_state[VK_LCONTROL] & 0x80) &&
      (key_state[VK_RMENU] & 0x80))
    {
      event->key.group = 1;
      event->key.state |= GDK_MOD2_MASK;
      if (key_state[VK_RCONTROL] & 0x80)
	event->key.state |= GDK_CONTROL_MASK;
      if (key_state[VK_LMENU] & 0x80)
	event->key.state |= GDK_MOD1_MASK;
    }
  else
    {
      event->key.group = 0;
      if (key_state[VK_CONTROL] & 0x80)
	event->key.state |= GDK_CONTROL_MASK;
      if (key_state[VK_MENU] & 0x80)
	event->key.state |= GDK_MOD1_MASK;
    }
}

static gint
build_pointer_event_state (MSG *msg)
{
  gint state;
  
  state = 0;

  if (msg->wParam & MK_CONTROL)
    state |= GDK_CONTROL_MASK;

  if ((msg->message != WM_LBUTTONDOWN &&
       (msg->wParam & MK_LBUTTON)) ||
      msg->message == WM_LBUTTONUP)
    state |= GDK_BUTTON1_MASK;

  if ((msg->message != WM_MBUTTONDOWN &&
       (msg->wParam & MK_MBUTTON)) ||
      msg->message == WM_MBUTTONUP)
    state |= GDK_BUTTON2_MASK;

  if ((msg->message != WM_RBUTTONDOWN &&
       (msg->wParam & MK_RBUTTON)) ||
      msg->message == WM_RBUTTONUP)
    state |= GDK_BUTTON3_MASK;

  if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON1) &&
       (msg->wParam & MK_XBUTTON1)) ||
      (msg->message == WM_XBUTTONUP && HIWORD (msg->wParam) == XBUTTON1))
    state |= GDK_BUTTON4_MASK;

  if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON2) &&
       (msg->wParam & MK_XBUTTON2)) ||