gtkbindings.c

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

	{
	case  '?':
	  if (!*string)
	    return FALSE;
	  string++;
	  break;
	  
	case  '*':
	  do
	    {
	      ch = *pattern;
	      pattern++;
	      if (ch == '?')
		{
		  if (!*string)
		    return FALSE;
		  string++;
		}
	    }
	  while (ch == '*' || ch == '?');
	  if (!ch)
	    return TRUE;
	  do
	    {
	      while (ch != *string)
		{
		  if (!*string)
		    return FALSE;
		  string++;
		}
	      string++;
	      if (gtk_pattern_ph_match (pattern, string))
		return TRUE;
	    }
	  while (*string);
	  break;
	  
	default:
	  if (ch == *string)
	    string++;
	  else
	    return FALSE;
	  break;
	}
      
      ch = *pattern;
      pattern++;
    }
  
  return *string == 0;
}

gboolean
gtk_pattern_match (GtkPatternSpec	*pspec,
		   guint		 string_length,
		   const gchar		*string,
		   const gchar		*string_reversed)
{
  g_return_val_if_fail (pspec != NULL, FALSE);
  g_return_val_if_fail (string != NULL, FALSE);
  g_return_val_if_fail (string_reversed != NULL, FALSE);
  
  switch (pspec->match_type)
    {
    case  GTK_MATCH_ALL:
      return gtk_pattern_ph_match (pspec->pattern, string);
      
    case  GTK_MATCH_ALL_TAIL:
      return gtk_pattern_ph_match (pspec->pattern_reversed, string_reversed);
      
    case  GTK_MATCH_HEAD:
      if (pspec->pattern_length > string_length)
	return FALSE;
      else if (pspec->pattern_length == string_length)
	return strcmp (pspec->pattern, string) == 0;
      else if (pspec->pattern_length)
	return strncmp (pspec->pattern, string, pspec->pattern_length) == 0;
      else
	return TRUE;
      
    case  GTK_MATCH_TAIL:
      if (pspec->pattern_length > string_length)
	return FALSE;
      else if (pspec->pattern_length == string_length)
	return strcmp (pspec->pattern_reversed, string_reversed) == 0;
      else if (pspec->pattern_length)
	return strncmp (pspec->pattern_reversed,
			string_reversed,
			pspec->pattern_length) == 0;
      else
	return TRUE;
      
    case  GTK_MATCH_EXACT:
      if (pspec->pattern_length != string_length)
	return FALSE;
      else
	return strcmp (pspec->pattern_reversed, string_reversed) == 0;
      
    default:
      g_return_val_if_fail (pspec->match_type < GTK_MATCH_LAST, FALSE);
      return FALSE;
    }
}

void
gtk_pattern_spec_init (GtkPatternSpec	      *pspec,
		       const gchar	      *pattern)
{
  gchar *p;
  
  g_return_if_fail (pspec != NULL);
  
  pspec->match_type = GTK_MATCH_ALL;
  pspec->seq_id = 0;
  pspec->user_data = NULL;
  
  if (!pattern)
    pattern = "";
  
  pspec->pattern = g_strdup (pattern);
  pspec->pattern_length = strlen (pspec->pattern);
  pspec->pattern_reversed = g_strdup (pspec->pattern);
  g_strreverse (pspec->pattern_reversed);
  if (pspec->pattern_reversed[0] != '*')
    pspec->match_type = GTK_MATCH_ALL_TAIL;
  
  if (strchr (pspec->pattern, '?'))
    return;
  
  if (!strchr (pspec->pattern, '*'))
    {
      pspec->match_type = GTK_MATCH_EXACT;
      return;
    }
  
  p = pspec->pattern;
  while (*p == '*')
    p++;
  if (p > pspec->pattern &&
      !strchr (p, '*'))
    {
      gchar *t;
      
      pspec->match_type = GTK_MATCH_TAIL;
      t = pspec->pattern;
      pspec->pattern = g_strdup (p);
      g_free (t);
      g_free (pspec->pattern_reversed);
      pspec->pattern_reversed = g_strdup (pspec->pattern);
      g_strreverse (pspec->pattern_reversed);
      pspec->pattern_length = strlen (pspec->pattern);
      return;
    }
  
  p = pspec->pattern_reversed;
  while (*p == '*')
    p++;
  if (p > pspec->pattern_reversed &&
      !strchr (p, '*'))
    {
      gchar *t;
      
      pspec->match_type = GTK_MATCH_HEAD;
      t = pspec->pattern_reversed;
      pspec->pattern_reversed = g_strdup (p);
      g_free (t);
      g_free (pspec->pattern);
      pspec->pattern = g_strdup (pspec->pattern_reversed);
      g_strreverse (pspec->pattern);
      pspec->pattern_length = strlen (pspec->pattern);
    }
}

gboolean
gtk_pattern_match_string (GtkPatternSpec	*pspec,
			  const gchar		*string)
{
  gchar *string_reversed;
  guint length;
  gboolean ergo;
  
  g_return_val_if_fail (pspec != NULL, FALSE);
  g_return_val_if_fail (string != NULL, FALSE);
  
  length = strlen (string);
  string_reversed = g_strdup (string);
  g_strreverse (string_reversed);
  
  ergo = gtk_pattern_match (pspec, length, string, string_reversed);
  g_free (string_reversed);
  
  return ergo;
}

gboolean
gtk_pattern_match_simple (const gchar		*pattern,
			  const gchar		*string)
{
  GtkPatternSpec pspec;
  gboolean ergo;
  
  g_return_val_if_fail (pattern != NULL, FALSE);
  g_return_val_if_fail (string != NULL, FALSE);
  
  gtk_pattern_spec_init (&pspec, pattern);
  ergo = gtk_pattern_match_string (&pspec, string);
  gtk_pattern_spec_free_segs (&pspec);
  
  return ergo;
}

void
gtk_pattern_spec_free_segs (GtkPatternSpec	*pspec)
{
  g_return_if_fail (pspec != NULL);
  
  g_free (pspec->pattern);
  pspec->pattern = NULL;
  g_free (pspec->pattern_reversed);
  pspec->pattern_reversed = NULL;
}

static guint
gtk_binding_parse_signal (GScanner       *scanner,
			  GtkBindingSet  *binding_set,
			  guint		  keyval,
			  guint		  modifiers)
{
  gchar *signal;
  guint expected_token = 0;
  GSList *args;
  GSList *slist;
  gboolean done;
  gboolean negate;
  gboolean need_arg;
  gboolean seen_comma;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
  
  g_scanner_get_next_token (scanner);
  if (scanner->token != G_TOKEN_STRING)
    return G_TOKEN_STRING;
  g_scanner_peek_next_token (scanner);
  if (scanner->next_token != '(')
    {
      g_scanner_get_next_token (scanner);
      return '(';
    }
  signal = g_strdup (scanner->value.v_string);
  g_scanner_get_next_token (scanner);

  negate = FALSE;
  args = NULL;
  done = FALSE;
  need_arg = TRUE;
  seen_comma = FALSE;
  scanner->config->scan_symbols = FALSE;
  do
    {
      if (need_arg)
	expected_token = G_TOKEN_INT;
      else
	expected_token = ')';
      g_scanner_get_next_token (scanner);
      switch (scanner->token)
	{
	  GtkBindingArg *arg;

	case G_TOKEN_FLOAT:
	  if (need_arg)
	    {
	      need_arg = FALSE;
	      arg = g_new (GtkBindingArg, 1);
	      arg->arg_type = GTK_TYPE_DOUBLE;
	      arg->d.double_data = scanner->value.v_float;
	      if (negate)
		{
		  arg->d.double_data = - arg->d.double_data;
		  negate = FALSE;
		}
	      args = g_slist_prepend (args, arg);
	    }
	  else
	    done = TRUE;
	  break;
	case G_TOKEN_INT:
	  if (need_arg)
	    {
	      need_arg = FALSE;
	      arg = g_new (GtkBindingArg, 1);
	      arg->arg_type = GTK_TYPE_LONG;
	      arg->d.long_data = scanner->value.v_int;
	      if (negate)
		{
		  arg->d.long_data = - arg->d.long_data;
		  negate = FALSE;
		}
	      args = g_slist_prepend (args, arg);
	    }
          else
	    done = TRUE;
	  break;
	case G_TOKEN_STRING:
	  if (need_arg && !negate)
	    {
	      need_arg = FALSE;
	      arg = g_new (GtkBindingArg, 1);
	      arg->arg_type = GTK_TYPE_STRING;
	      arg->d.string_data = g_strdup (scanner->value.v_string);
	      args = g_slist_prepend (args, arg);
	    }
	  else
	    done = TRUE;
	  break;
	case G_TOKEN_IDENTIFIER:
	  if (need_arg && !negate)
	    {
	      need_arg = FALSE;
	      arg = g_new (GtkBindingArg, 1);
	      arg->arg_type = GTK_TYPE_IDENTIFIER;
	      arg->d.string_data = g_strdup (scanner->value.v_identifier);
	      args = g_slist_prepend (args, arg);
	    }
	  else
	    done = TRUE;
	  break;
	case '-':
	  if (!need_arg)
	    done = TRUE;
	  else if (negate)
	    {
	      expected_token = G_TOKEN_INT;
	      done = TRUE;
	    }
	  else
	    negate = TRUE;
	  break;
	case ',':
	  seen_comma = TRUE;
	  if (need_arg)
	    done = TRUE;
	  else
	    need_arg = TRUE;
	  break;
	case ')':
	  if (!(need_arg && seen_comma) && !negate)
	    {
	      args = g_slist_reverse (args);
	      gtk_binding_entry_add_signall (binding_set,
					     keyval,
					     modifiers,
					     signal,
					     args);
	      expected_token = G_TOKEN_NONE;
	    }
	  done = TRUE;
	  break;
	default:
	  done = TRUE;
	  break;
	}
    }
  while (!done);
  scanner->config->scan_symbols = TRUE;
  
  for (slist = args; slist; slist = slist->next)
    {
      GtkBindingArg *arg;

      arg = slist->data;
      if (GTK_FUNDAMENTAL_TYPE (arg->arg_type) == GTK_TYPE_STRING)
	g_free (arg->d.string_data);
      g_free (arg);
    }
  g_slist_free (args);
  g_free (signal);

  return expected_token;
}

static inline guint
gtk_binding_parse_bind (GScanner       *scanner,
			GtkBindingSet  *binding_set)
{
  guint keyval = 0;
  guint modifiers = 0;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
  
  g_scanner_get_next_token (scanner);
  if (scanner->token != GTK_RC_TOKEN_BIND)
    return GTK_RC_TOKEN_BIND;
  g_scanner_get_next_token (scanner);
  if (scanner->token != G_TOKEN_STRING)
    return G_TOKEN_STRING;
  gtk_accelerator_parse (scanner->value.v_string, &keyval, &modifiers);
  modifiers &= BINDING_MOD_MASK ();
  if (keyval == 0)
    return G_TOKEN_STRING;

  g_scanner_get_next_token (scanner);
  if (scanner->token != '{')
    return '{';

  gtk_binding_entry_clear (binding_set, keyval, modifiers);
  
  g_scanner_peek_next_token (scanner);
  while (scanner->next_token != '}')
    {
      switch (scanner->next_token)
	{
	  guint expected_token;

	case G_TOKEN_STRING:
	  expected_token = gtk_binding_parse_signal (scanner,
						     binding_set,
						     keyval,
						     modifiers);
	  if (expected_token != G_TOKEN_NONE)
	    return expected_token;
	  break;
	default:
	  g_scanner_get_next_token (scanner);
	  return '}';
	}
      g_scanner_peek_next_token (scanner);
    }
  g_scanner_get_next_token (scanner);

  return G_TOKEN_NONE;
}

guint
gtk_binding_parse_binding (GScanner       *scanner)
{
  gchar *name;
  GtkBindingSet *binding_set;

  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);

  g_scanner_get_next_token (scanner);
  if (scanner->token != GTK_RC_TOKEN_BINDING)
    return GTK_RC_TOKEN_BINDING;
  g_scanner_get_next_token (scanner);
  if (scanner->token != G_TOKEN_STRING)
    return G_TOKEN_STRING;
  name = g_strdup (scanner->value.v_string);

  g_scanner_get_next_token (scanner);
  if (scanner->token != '{')
    {
      g_free (name);
      return G_TOKEN_STRING;
    }

  binding_set = gtk_binding_set_find (name);
  if (!binding_set)
    binding_set = gtk_binding_set_new (name);
  g_free (name);

  g_scanner_peek_next_token (scanner);
  while (scanner->next_token != '}')
    {
      switch (scanner->next_token)
	{
	  guint expected_token;

	case GTK_RC_TOKEN_BIND:
	  expected_token = gtk_binding_parse_bind (scanner, binding_set);
	  if (expected_token != G_TOKEN_NONE)
	    return expected_token;
	  break;
	default:
	  g_scanner_get_next_token (scanner);
	  return '}';
	}
      g_scanner_peek_next_token (scanner);
    }
  g_scanner_get_next_token (scanner);

  return G_TOKEN_NONE;
}