gtksignal.c

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

	    {
	    case  EMISSION_CONTINUE:
	      break;
	    case  EMISSION_RESTART:
	      goto emission_restart;
	    case  EMISSION_DONE:
	      goto emission_done;
	    }
	}
    }
  
 emission_done:
  if (restart_emissions && signal.signal_flags & GTK_RUN_NO_RECURSE)
    gtk_emission_remove (&restart_emissions, object, signal_id);
  
  gtk_emission_remove (&current_emissions, object, signal_id);
  
  gtk_object_unref (object);
}

guint
gtk_signal_handler_pending (GtkObject		*object,
			    guint		 signal_id,
			    gboolean		 may_be_blocked)
{
  GtkHandler *handlers;
  guint handler_id;
  
  g_return_val_if_fail (object != NULL, 0);
  g_return_val_if_fail (signal_id >= 1, 0);

  if (GTK_OBJECT_CONNECTED (object))
    handlers = gtk_signal_get_handlers (object, signal_id);
  else
    return 0;
  
  handler_id = 0;
  while (handlers && handlers->signal_id == signal_id)
    {
      if (handlers->id > 0 &&
	  (may_be_blocked || handlers->blocked == FALSE))
	{
	  handler_id = handlers->id;
	  break;
	}
      
      handlers = handlers->next;
    }
  
  return handler_id;
}

guint
gtk_signal_handler_pending_by_func (GtkObject           *object,
				    guint                signal_id,
				    gboolean             may_be_blocked,
				    GtkSignalFunc        func,
				    gpointer             data)
{
  GtkHandler *handlers;
  guint handler_id;
  
  g_return_val_if_fail (object != NULL, 0);
  g_return_val_if_fail (func != NULL, 0);
  g_return_val_if_fail (signal_id >= 1, 0);

  if (GTK_OBJECT_CONNECTED (object))
    handlers = gtk_signal_get_handlers (object, signal_id);
  else
    return 0;
  
  handler_id = 0;
  while (handlers && handlers->signal_id == signal_id)
    {
      if (handlers->id > 0 &&
	  handlers->func == func &&
	  handlers->func_data == data &&
	  (may_be_blocked || handlers->blocked == 0))
	{
	  handler_id = handlers->id;
	  break;
	}
      
      handlers = handlers->next;
    }
  
  return handler_id;
}

gint
gtk_signal_handler_pending_by_id (GtkObject *object,
				  guint      handler_id,
				  gboolean   may_be_blocked)
{
  GtkHandler *handlers;
  
  g_return_val_if_fail (object != NULL, FALSE);
  g_return_val_if_fail (handler_id >= 1, FALSE);

  if (GTK_OBJECT_CONNECTED (object))
    handlers = gtk_object_get_data_by_id (object, gtk_handler_quark);
  else
    return FALSE;
  
  while (handlers)
    {
      if (handlers->id == handler_id)
	return may_be_blocked || handlers->blocked == 0;
      
      handlers = handlers->next;
    }
  
  return FALSE;
}

guint
gtk_signal_add_emission_hook (guint           signal_id,
			      GtkEmissionHook hook_func,
			      gpointer        data)
{
  return gtk_signal_add_emission_hook_full (signal_id, hook_func, data, NULL);
}

guint
gtk_signal_add_emission_hook_full (guint           signal_id,
				   GtkEmissionHook hook_func,
				   gpointer        data,
				   GDestroyNotify  destroy)
{
  static guint seq_hook_id = 1;
  GtkSignal *signal;
  GHook *hook;

  g_return_val_if_fail (signal_id > 0, 0);
  g_return_val_if_fail (hook_func != NULL, 0);
  
  signal = LOOKUP_SIGNAL_ID (signal_id);
  g_return_val_if_fail (signal != NULL, 0);
  if (signal->signal_flags & GTK_RUN_NO_HOOKS)
    {
      g_warning ("gtk_signal_add_emission_hook_full(): signal \"%s\" does not support emission hooks",
		 signal->name);
      return 0;
    }

  if (!signal->hook_list)
    {
      signal->hook_list = g_new (GHookList, 1);
      g_hook_list_init (signal->hook_list, sizeof (GHook));
    }

  hook = g_hook_alloc (signal->hook_list);
  hook->data = data;
  hook->func = hook_func;
  hook->destroy = destroy;

  signal->hook_list->seq_id = seq_hook_id;
  g_hook_prepend (signal->hook_list, hook);
  seq_hook_id = signal->hook_list->seq_id;

  return hook->hook_id;
}

void
gtk_signal_remove_emission_hook (guint signal_id,
				 guint hook_id)
{
  GtkSignal *signal;

  g_return_if_fail (signal_id > 0);
  g_return_if_fail (hook_id > 0);

  signal = LOOKUP_SIGNAL_ID (signal_id);
  g_return_if_fail (signal != NULL);

  if (!signal->hook_list || !g_hook_destroy (signal->hook_list, hook_id))
    g_warning ("gtk_signal_remove_emission_hook(): could not find hook (%u)", hook_id);
}

static gboolean
gtk_emission_hook_marshaller (GHook   *hook,
			      gpointer data_p)
{
  GtkEmissionHookData *data = data_p;
  GtkEmissionHook func;

  func = hook->func;

  if (!GTK_OBJECT_DESTROYED (data->object))
    return func (data->object, data->signal_id,
		 data->n_params, data->params,
		 hook->data);
  else
    return TRUE;
}

static guint
gtk_signal_connect_by_type (GtkObject	    *object,
			    guint	     signal_id,
			    GtkSignalFunc    func,
			    gpointer	     func_data,
			    GtkSignalDestroy destroy_func,
			    gint	     object_signal,
			    gint	     after,
			    gint	     no_marshal)
{
  GtkObjectClass *class;
  GtkHandler *handler;
  gint found_it;
  GtkSignal *signal;
 
  g_return_val_if_fail (object != NULL, 0);
  g_return_val_if_fail (object->klass != NULL, 0);
  
  signal = LOOKUP_SIGNAL_ID (signal_id);

  /* Search through the signals for this object and make
   *  sure the one we are adding is valid. We need to perform
   *  the lookup on the objects parents as well. If it isn't
   *  valid then issue a warning and return.
   * As of now (1998-05-27) this lookup shouldn't be neccessarry
   *  anymore since gtk_signal_lookup() has been reworked to only
   *  return correct signal ids per class-branch.
   */
  found_it = FALSE;
  class = object->klass;
  while (class)
    {
      GtkType parent;
      guint *object_signals;
      guint nsignals;
      guint i;
      
      object_signals = class->signals;
      nsignals = class->nsignals;
      
      for (i = 0; i < nsignals; i++)
	if (object_signals[i] == signal_id)
	  {
	    found_it = TRUE;
	    break;
	  }
      
      parent = gtk_type_parent (class->type);
      if (parent)
	class = gtk_type_class (parent);
      else
	class = NULL;
    }
  
  if (!found_it)
    {
      g_warning ("gtk_signal_connect_by_type(): could not find signal id (%u) in the `%s' class ancestry",
		 signal_id,
		 gtk_type_name (object->klass->type));
      return 0;
    }
  
  handler = gtk_signal_handler_new ();
  handler->id = gtk_handler_id++;
  handler->signal_id = signal_id;
  handler->object_signal = object_signal != FALSE;
  handler->func = func;
  handler->func_data = func_data;
  handler->destroy_func = destroy_func;
  handler->after = after != FALSE;
  handler->no_marshal = no_marshal;
  
  gtk_signal_handler_insert (object, handler);
  return handler->id;
}

static GtkEmission*
gtk_emission_new (void)
{
  GtkEmission *emission;
  
  if (!gtk_free_emissions)
    {
      GtkEmission *emission_block;
      guint i;

      emission_block = g_new0 (GtkEmission, EMISSION_BLOCK_SIZE);
      for (i = 1; i < EMISSION_BLOCK_SIZE; i++)
	{
	  (emission_block + i)->next = gtk_free_emissions;
	  gtk_free_emissions = (emission_block + i);
	}

      emission = emission_block;
    }
  else
    {
      emission = gtk_free_emissions;
      gtk_free_emissions = emission->next;
    }

  emission->object = NULL;
  emission->signal_id = 0;
  emission->in_hook = 0;
  emission->next = NULL;
  
  return emission;
}

static void
gtk_emission_add (GtkEmission **emissions,
		  GtkObject    *object,
		  guint	        signal_id)
{
  GtkEmission *emission;
  
  g_return_if_fail (emissions != NULL);
  g_return_if_fail (object != NULL);
  
  emission = gtk_emission_new ();
  emission->object = object;
  emission->signal_id = signal_id;

  emission->next = *emissions;
  *emissions = emission;
}

static void
gtk_emission_remove (GtkEmission **emissions,
		     GtkObject	  *object,
		     guint	   signal_id)
{
  GtkEmission *emission, *last;
  
  g_return_if_fail (emissions != NULL);

  last = NULL;
  emission = *emissions;
  while (emission)
    {
      if (emission->object == object && emission->signal_id == signal_id)
	{
	  if (last)
	    last->next = emission->next;
	  else
	    *emissions = emission->next;

	  emission->next = gtk_free_emissions;
	  gtk_free_emissions = emission;
	  break;
	}

      last = emission;
      emission = last->next;
    }
}

static gint
gtk_emission_check (GtkEmission *emission,
		    GtkObject   *object,
		    guint        signal_id)
{
  while (emission)
    {
      if (emission->object == object && emission->signal_id == signal_id)
	return 1 + emission->in_hook;
      emission = emission->next;
    }
  return FALSE;
}

static gint
gtk_handlers_run (GtkHandler	 *handlers,
		  GtkSignal      *signal,
		  GtkObject      *object,
		  GtkArg	 *params,
		  gint		  after)
{
  /* *signal is a local copy on the stack of gtk_signal_real_emit(),
   * so we don't need to look it up every time we invoked a function.
   */
  while (handlers && handlers->signal_id == signal->signal_id)
    {
      GtkHandler *handlers_next;
      
      gtk_signal_handler_ref (handlers);
      
      if (!handlers->blocked && handlers->after == after)
	{
	  if (handlers->func)
	    {
	      if (handlers->no_marshal)
		(* (GtkCallbackMarshal) handlers->func) (object,
							 handlers->func_data,
							 signal->nparams,
							 params);
	      else if (handlers->object_signal)
		/* don't cast with GTK_OBJECT () */
		(* signal->marshaller) ((GtkObject*) handlers->func_data,
					handlers->func,
					object,
					params);
	      else
		(* signal->marshaller) (object,
					handlers->func,
					handlers->func_data,
					params);
	    }
	  else if (global_marshaller)
	    (* global_marshaller) (object,
				   handlers->func_data,
				   signal->nparams,
				   params,
				   signal->params,
				   signal->return_val);
	  
	  if (stop_emissions && gtk_emission_check (stop_emissions,
						    object,
						    signal->signal_id))
	    {
	      gtk_emission_remove (&stop_emissions, object, signal->signal_id);
	      
	      gtk_signal_handler_unref (handlers, object);

	      return EMISSION_DONE;
	    }
	  else if (restart_emissions &&
		   signal->signal_flags & GTK_RUN_NO_RECURSE &&
		   gtk_emission_check (restart_emissions, object, signal->signal_id))
	    {
	      gtk_emission_remove (&restart_emissions, object, signal->signal_id);

	      gtk_signal_handler_unref (handlers, object);

	      return EMISSION_RESTART;
	    }
	}
      
      handlers_next = handlers->next;
      gtk_signal_handler_unref (handlers, object);
      handlers = handlers_next;
    }
  
  return EMISSION_CONTINUE;
}

static gboolean
gtk_signal_collect_params (GtkArg	       *params,
			   guint		n_params,
			   GtkType	       *param_types,
			   GtkType		return_type,
			   va_list		var_args)
{
  register GtkArg *last_param;
  register gboolean failed = FALSE;

  for (last_param = params + n_params; params < last_param; params++)
    {
      register gchar *error;

      params->name = NULL;
      params->type = *(param_types++);
      GTK_ARG_COLLECT_VALUE (params,
			     var_args,
			     error);
      if (error)
	{
	  failed = TRUE;
	  g_warning ("gtk_signal_collect_params(): %s", error);
	  g_free (error);
	}
    }

  params->type = return_type;
  params->name = NULL;

  return_type = GTK_FUNDAMENTAL_TYPE (return_type);
  if (return_type != GTK_TYPE_NONE)
    {
      if ((return_type >= GTK_TYPE_FLAT_FIRST &&
	   return_type <= GTK_TYPE_FLAT_LAST) ||
	  (return_type == GTK_TYPE_OBJECT))
	{
	  GTK_VALUE_POINTER (*params) = va_arg (var_args, gpointer);
	  
	  if (GTK_VALUE_POINTER (*params) == NULL)
	    {
	      failed = TRUE;
	      g_warning ("gtk_signal_collect_params(): invalid NULL pointer for return argument type `%s'",
			 gtk_type_name (params->type));
	    }
	}
      else
	{
	  failed = TRUE;
	  g_warning ("gtk_signal_collect_params(): unsupported return argument type `%s'",
		     gtk_type_name (params->type));
	}
    }
  else
    GTK_VALUE_POINTER (*params) = NULL;

  return failed;
}