gtkbindings.c

gtk是linux一款强大的夸平台的图形化开发工具

}

gboolean
gtk_binding_set_activate (GtkBindingSet	 *binding_set,
			  guint		  keyval,
			  guint		  modifiers,
			  GtkObject	 *object)
{
  GtkBindingEntry *entry;
  
  g_return_val_if_fail (binding_set != NULL, FALSE);
  g_return_val_if_fail (object != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);
  
  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();
  
  if (!GTK_OBJECT_DESTROYED (object))
    {
      entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
      if (entry)
	{
	  gtk_binding_entry_activate (entry, object);
	  
	  return TRUE;
	}
    }
  
  return FALSE;
}

void
gtk_binding_entry_clear (GtkBindingSet	*binding_set,
			 guint		 keyval,
			 guint		 modifiers)
{
  GtkBindingEntry *entry;
  
  g_return_if_fail (binding_set != NULL);
  
  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();
  
  entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
  if (entry)
    binding_entry_destroy (entry);

  entry = binding_entry_new (binding_set, keyval, modifiers);
}

void
gtk_binding_entry_remove (GtkBindingSet	 *binding_set,
			  guint		  keyval,
			  guint		  modifiers)
{
  GtkBindingEntry *entry;
  
  g_return_if_fail (binding_set != NULL);
  
  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();
  
  entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
  if (entry)
    binding_entry_destroy (entry);
}

void
gtk_binding_entry_add_signall (GtkBindingSet  *binding_set,
			       guint	       keyval,
			       guint	       modifiers,
			       const gchar    *signal_name,
			       GSList	      *binding_args)
{
  GtkBindingEntry *entry;
  GtkBindingSignal *signal, **signal_p;
  GSList *slist;
  guint n = 0;
  GtkBindingArg *arg;
  
  g_return_if_fail (binding_set != NULL);
  g_return_if_fail (signal_name != NULL);
  
  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();
  
  signal = binding_signal_new (signal_name, g_slist_length (binding_args));
  
  arg = signal->args;
  for (slist = binding_args; slist; slist = slist->next)
    {
      GtkBindingArg *tmp_arg;
      
      tmp_arg = slist->data;
      if (!tmp_arg)
	{
	  g_warning ("gtk_binding_entry_add_signall(): arg[%u] is `NULL'", n);
	  binding_signal_free (signal);
	  return;
	}
      switch (GTK_FUNDAMENTAL_TYPE (tmp_arg->arg_type))
	{
	case  GTK_TYPE_LONG:
	  arg->arg_type = GTK_TYPE_LONG;
	  arg->d.long_data = tmp_arg->d.long_data;
	  break;
	case  GTK_TYPE_DOUBLE:
	  arg->arg_type = GTK_TYPE_DOUBLE;
	  arg->d.double_data = tmp_arg->d.double_data;
	  break;
	case  GTK_TYPE_STRING:
          if (tmp_arg->arg_type != GTK_TYPE_IDENTIFIER)
	    arg->arg_type = GTK_TYPE_STRING;
	  else
	    arg->arg_type = GTK_TYPE_IDENTIFIER;
	  arg->d.string_data = g_strdup (tmp_arg->d.string_data);
	  if (!arg->d.string_data)
	    {
	      g_warning ("gtk_binding_entry_add_signall(): value of `string' arg[%u] is `NULL'", n);
	      binding_signal_free (signal);
	      return;
	    }
	  break;
	default:
	  g_warning ("gtk_binding_entry_add_signall(): unsupported type `%s' for arg[%u]",
		     gtk_type_name (arg->arg_type), n);
	  binding_signal_free (signal);
	  return;
	}
      arg++;
      n++;
    }
  
  entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
  if (!entry)
    {
      gtk_binding_entry_add (binding_set, keyval, modifiers);
      entry = binding_ht_lookup_entry (binding_set, keyval, modifiers);
    }
  signal_p = &entry->signals;
  while (*signal_p)
    signal_p = &(*signal_p)->next;
  *signal_p = signal;
}

void
gtk_binding_entry_add_signal (GtkBindingSet  *binding_set,
			      guint           keyval,
			      guint           modifiers,
			      const gchar    *signal_name,
			      guint           n_args,
			      ...)
{
  GSList *slist, *free_slist;
  va_list args;
  guint i;

  g_return_if_fail (binding_set != NULL);
  g_return_if_fail (signal_name != NULL);
  
  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();

  va_start (args, n_args);
  slist = NULL;
  for (i = 0; i < n_args; i++)
    {
      GtkBindingArg *arg;

      arg = g_new0 (GtkBindingArg, 1);
      slist = g_slist_prepend (slist, arg);

      arg->arg_type = va_arg (args, GtkType);
      switch (GTK_FUNDAMENTAL_TYPE (arg->arg_type))
	{
	  /* for elaborated commenting about var args collection, take a look
	   * at gtk_arg_collect_value() in gtkargcollector.c
	   */
	case GTK_TYPE_CHAR:
	case GTK_TYPE_UCHAR:
	case GTK_TYPE_INT:
	case GTK_TYPE_UINT:
	case GTK_TYPE_BOOL:
	case GTK_TYPE_ENUM:
	case GTK_TYPE_FLAGS:
	  arg->arg_type = GTK_TYPE_LONG;
	  arg->d.long_data = va_arg (args, gint);
	  break;
	case GTK_TYPE_LONG:
	case GTK_TYPE_ULONG:
	  arg->arg_type = GTK_TYPE_LONG;
	  arg->d.long_data = va_arg (args, glong);
	  break;
	case GTK_TYPE_FLOAT:
	case GTK_TYPE_DOUBLE:
	  arg->arg_type = GTK_TYPE_DOUBLE;
	  arg->d.double_data = va_arg (args, gdouble);
	  break;
	case GTK_TYPE_STRING:
	  if (arg->arg_type != GTK_TYPE_IDENTIFIER)
	    arg->arg_type = GTK_TYPE_STRING;
	  arg->d.string_data = va_arg (args, gchar*);
	  if (!arg->d.string_data)
	    {
	      g_warning ("gtk_binding_entry_add_signal(): type `%s' arg[%u] is `NULL'",
			 gtk_type_name (arg->arg_type),
			 i);
	      i += n_args + 1;
	    }
	  break;
	default:
	  g_warning ("gtk_binding_entry_add_signal(): unsupported type `%s' for arg[%u]",
		     gtk_type_name (arg->arg_type), i);
	  i += n_args + 1;
	  break;
	}
    }
  va_end (args);

  if (i == n_args || i == 0)
    {
      slist = g_slist_reverse (slist);
      gtk_binding_entry_add_signall (binding_set, keyval, modifiers, signal_name, slist);
    }

  free_slist = slist;
  while (slist)
    {
      g_free (slist->data);
      slist = slist->next;
    }
  g_slist_free (free_slist);
}

void
gtk_binding_set_add_path (GtkBindingSet	     *binding_set,
			  GtkPathType	      path_type,
			  const gchar	     *path_pattern,
			  GtkPathPriorityType priority)
{
  GtkPatternSpec *pspec;
  GSList **slist_p, *slist;
  static guint seq_id = 0;
  
  g_return_if_fail (binding_set != NULL);
  g_return_if_fail (path_pattern != NULL);

  priority &= GTK_PATH_PRIO_MASK;
  
  switch (path_type)
    {
    case  GTK_PATH_WIDGET:
      slist_p = &binding_set->widget_path_pspecs;
      break;
    case  GTK_PATH_WIDGET_CLASS:
      slist_p = &binding_set->widget_class_pspecs;
      break;
    case  GTK_PATH_CLASS:
      slist_p = &binding_set->class_branch_pspecs;
      break;
    default:
      g_assert_not_reached ();
      slist_p = NULL;
      break;
    }
  
  pspec = g_new (GtkPatternSpec, 1);
  gtk_pattern_spec_init (pspec, path_pattern);
  pspec->seq_id = seq_id++ & 0x0fffffff;
  pspec->seq_id |= priority << 28;
  pspec->user_data = binding_set;
  
  slist = *slist_p;
  while (slist)
    {
      GtkPatternSpec *tmp_pspec;
      
      tmp_pspec = slist->data;
      slist = slist->next;
      
      if (tmp_pspec->pattern_length == pspec->pattern_length &&
	  g_str_equal (tmp_pspec->pattern_reversed, pspec->pattern_reversed))
	{
	  gtk_pattern_spec_free_segs (pspec);
	  g_free (pspec);
	  pspec = NULL;
	  break;
	}
    }
  if (pspec)
    *slist_p = g_slist_prepend (*slist_p, pspec);
}

static inline gboolean
binding_match_activate (GSList          *pspec_list,
			GtkObject	*object,
			guint	         path_length,
			gchar	        *path,
			gchar	        *path_reversed)
{
  GSList *slist;

  for (slist = pspec_list; slist; slist = slist->next)
    {
      GtkPatternSpec *pspec;

      pspec = slist->data;
      if (gtk_pattern_match (pspec, path_length, path, path_reversed))
	{
	  GtkBindingSet *binding_set;

	  binding_set = pspec->user_data;

	  gtk_binding_entry_activate (binding_set->current, object);

	  return TRUE;
	}
    }

  return FALSE;
}

static gint
gtk_binding_pattern_compare (gconstpointer new_pattern,
			     gconstpointer existing_pattern)
{
  register const GtkPatternSpec *np  = new_pattern;
  register const GtkPatternSpec *ep  = existing_pattern;

  /* walk the list as long as the existing patterns have
   * higher priorities.
   */

  return np->seq_id < ep->seq_id;
}

static inline GSList*
gtk_binding_entries_sort_patterns (GtkBindingEntry    *entries,
				   GtkPathType         path_id)
{
  GSList *patterns;

  patterns = NULL;
  while (entries)
    {
      register GtkBindingSet *binding_set;
      GSList *slist = NULL;

      binding_set = entries->binding_set;
      binding_set->current = entries;

      switch (path_id)
	{
	case GTK_PATH_WIDGET:
	  slist = binding_set->widget_path_pspecs;
	  break;
	case GTK_PATH_WIDGET_CLASS:
	  slist = binding_set->widget_class_pspecs;
	  break;
	case GTK_PATH_CLASS:
	  slist = binding_set->class_branch_pspecs;
	  break;
	}

      for (; slist; slist = slist->next)
	{
	  GtkPatternSpec *pspec;

	  pspec = slist->data;
	  patterns = g_slist_insert_sorted (patterns, pspec, gtk_binding_pattern_compare);
	}

      entries = entries->hash_next;
    }

  return patterns;
}
      

gboolean
gtk_bindings_activate (GtkObject      *object,
		       guint           keyval,
		       guint           modifiers)
{
  GtkBindingEntry *entries;
  GtkWidget *widget;
  gboolean handled = FALSE;

  g_return_val_if_fail (object != NULL, FALSE);
  g_return_val_if_fail (GTK_IS_OBJECT (object), FALSE);

  if (!GTK_IS_WIDGET (object) || GTK_OBJECT_DESTROYED (object))
    return FALSE;

  widget = GTK_WIDGET (object);

  keyval = gdk_keyval_to_lower (keyval);
  modifiers = modifiers & BINDING_MOD_MASK ();

  entries = binding_ht_lookup_list (keyval, modifiers);

  if (!entries)
    return FALSE;

  if (!handled)
    {
      guint path_length;
      gchar *path, *path_reversed;
      GSList *patterns;

      gtk_widget_path (widget, &path_length, &path, &path_reversed);
      patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_WIDGET);
      handled = binding_match_activate (patterns, object, path_length, path, path_reversed);
      g_slist_free (patterns);
      g_free (path);
      g_free (path_reversed);
    }

  if (!handled)
    {
      guint path_length;
      gchar *path, *path_reversed;
      GSList *patterns;

      gtk_widget_class_path (widget, &path_length, &path, &path_reversed);
      patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_WIDGET_CLASS);
      handled = binding_match_activate (patterns, object, path_length, path, path_reversed);
      g_slist_free (patterns);
      g_free (path);
      g_free (path_reversed);
    }

  if (!handled)
    {
      GSList *patterns;
      GtkType class_type;
      
      patterns = gtk_binding_entries_sort_patterns (entries, GTK_PATH_CLASS);
      class_type = GTK_OBJECT_TYPE (object);
      while (class_type && !handled)
	{
	  guint path_length;
	  gchar *path, *path_reversed;
	  
	  path = gtk_type_name (class_type);
	  path_reversed = g_strdup (path);
	  g_strreverse (path_reversed);
	  path_length = strlen (path);
	  handled = binding_match_activate (patterns, object, path_length, path, path_reversed);
	  g_free (path_reversed);

	  class_type = gtk_type_parent (class_type);
	}
      g_slist_free (patterns);
    }

  return handled;
}










/* Patterns
 */

static inline gboolean
gtk_pattern_ph_match (const gchar   *match_pattern,
		      const gchar   *match_string)
{
  register const gchar *pattern, *string;
  register gchar ch;
  
  pattern = match_pattern;
  string = match_string;
  
  ch = *pattern;
  pattern++;
  while (ch)
    {
      switch (ch)