/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * GHook: Callback maintenance functions

 * Copyright (C) 1998 Tim Janik

 * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

#include "glib.h"

#include "galias.h"

/* --- functions --- */

static void

default_finalize_hook (GHookList *hook_list,

		       GHook     *hook)

{

  GDestroyNotify destroy = hook->destroy;

  if (destroy)

    {

      hook->destroy = NULL;

      destroy (hook->data);

    }

}

EXPORT_C void

g_hook_list_init (GHookList *hook_list,

		  guint	     hook_size)

{

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_size >= sizeof (GHook));

  hook_list->seq_id = 1;

  hook_list->hook_size = hook_size;

  hook_list->is_setup = TRUE;

  hook_list->hooks = NULL;

  hook_list->dummy3 = NULL;

  hook_list->finalize_hook = default_finalize_hook;

  hook_list->dummy[0] = NULL;

  hook_list->dummy[1] = NULL;

}

EXPORT_C void

g_hook_list_clear (GHookList *hook_list)

{

  g_return_if_fail (hook_list != NULL);

  if (hook_list->is_setup)

    {

      GHook *hook;

      hook_list->is_setup = FALSE;

      hook = hook_list->hooks;

      if (!hook)

	{

	  /* destroy hook_list->hook_memchunk */

	}

      else

	do

	  {

	    GHook *tmp;

	    g_hook_ref (hook_list, hook);

	    g_hook_destroy_link (hook_list, hook);

	    tmp = hook->next;

	    g_hook_unref (hook_list, hook);

	    hook = tmp;

	  }

	while (hook);

    }

}

EXPORT_C GHook*

g_hook_alloc (GHookList *hook_list)

{

  GHook *hook;

  g_return_val_if_fail (hook_list != NULL, NULL);

  g_return_val_if_fail (hook_list->is_setup, NULL);

  hook = g_slice_alloc0 (hook_list->hook_size);

  hook->data = NULL;

  hook->next = NULL;

  hook->prev = NULL;

  hook->flags = G_HOOK_FLAG_ACTIVE;

  hook->ref_count = 0;

  hook->hook_id = 0;

  hook->func = NULL;

  hook->destroy = NULL;

  return hook;

}

EXPORT_C void

g_hook_free (GHookList *hook_list,

	     GHook     *hook)

{

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  g_return_if_fail (hook != NULL);

  g_return_if_fail (G_HOOK_IS_UNLINKED (hook));

  g_return_if_fail (!G_HOOK_IN_CALL (hook));

  hook_list->finalize_hook (hook_list, hook);

  g_slice_free1 (hook_list->hook_size, hook);

}

EXPORT_C void

g_hook_destroy_link (GHookList *hook_list,

		     GHook     *hook)

{

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook != NULL);

  hook->flags &= ~G_HOOK_FLAG_ACTIVE;

  if (hook->hook_id)

    {

      hook->hook_id = 0;

      g_hook_unref (hook_list, hook); /* counterpart to g_hook_insert_before */

    }

}

EXPORT_C gboolean

g_hook_destroy (GHookList   *hook_list,

		gulong	     hook_id)

{

  GHook *hook;

  g_return_val_if_fail (hook_list != NULL, FALSE);

  g_return_val_if_fail (hook_id > 0, FALSE);

  hook = g_hook_get (hook_list, hook_id);

  if (hook)

    {

      g_hook_destroy_link (hook_list, hook);

      return TRUE;

    }

  return FALSE;

}

EXPORT_C void

g_hook_unref (GHookList *hook_list,

	      GHook	*hook)

{

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook != NULL);

  g_return_if_fail (hook->ref_count > 0);

  hook->ref_count--;

  if (!hook->ref_count)

    {

      g_return_if_fail (hook->hook_id == 0);

      g_return_if_fail (!G_HOOK_IN_CALL (hook));

      if (hook->prev)

	hook->prev->next = hook->next;

      else

	hook_list->hooks = hook->next;

      if (hook->next)

	{

	  hook->next->prev = hook->prev;

	  hook->next = NULL;

	}

      hook->prev = NULL;

      if (!hook_list->is_setup)

	{

	  hook_list->is_setup = TRUE;

	  g_hook_free (hook_list, hook);

	  hook_list->is_setup = FALSE;

	  if (!hook_list->hooks)

	    {

	      /* destroy hook_list->hook_memchunk */

	    }

	}

      else

	g_hook_free (hook_list, hook);

    }

}

EXPORT_C GHook *

g_hook_ref (GHookList *hook_list,

	    GHook     *hook)

{

  g_return_val_if_fail (hook_list != NULL, NULL);

  g_return_val_if_fail (hook != NULL, NULL);

  g_return_val_if_fail (hook->ref_count > 0, NULL);

  hook->ref_count++;

  return hook;

}

EXPORT_C void

g_hook_prepend (GHookList *hook_list,

		GHook	  *hook)

{

  g_return_if_fail (hook_list != NULL);

  g_hook_insert_before (hook_list, hook_list->hooks, hook);

}

EXPORT_C void

g_hook_insert_before (GHookList *hook_list,

		      GHook	*sibling,

		      GHook	*hook)

{

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  g_return_if_fail (hook != NULL);

  g_return_if_fail (G_HOOK_IS_UNLINKED (hook));

  g_return_if_fail (hook->ref_count == 0);

  hook->hook_id = hook_list->seq_id++;

  hook->ref_count = 1; /* counterpart to g_hook_destroy_link */

  if (sibling)

    {

      if (sibling->prev)

	{

	  hook->prev = sibling->prev;

	  hook->prev->next = hook;

	  hook->next = sibling;

	  sibling->prev = hook;

	}

      else

	{

	  hook_list->hooks = hook;

	  hook->next = sibling;

	  sibling->prev = hook;

	}

    }

  else

    {

      if (hook_list->hooks)

	{

	  sibling = hook_list->hooks;

	  while (sibling->next)

	    sibling = sibling->next;

	  hook->prev = sibling;

	  sibling->next = hook;

	}

      else

	hook_list->hooks = hook;

    }

}

EXPORT_C void

g_hook_list_invoke (GHookList *hook_list,

		    gboolean   may_recurse)

{

  GHook *hook;

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  hook = g_hook_first_valid (hook_list, may_recurse);

  while (hook)

    {

      GHookFunc func;

      gboolean was_in_call;

      func = (GHookFunc) hook->func;

      was_in_call = G_HOOK_IN_CALL (hook);

      hook->flags |= G_HOOK_FLAG_IN_CALL;

      func (hook->data);

      if (!was_in_call)

	hook->flags &= ~G_HOOK_FLAG_IN_CALL;

      hook = g_hook_next_valid (hook_list, hook, may_recurse);

    }

}

EXPORT_C void

g_hook_list_invoke_check (GHookList *hook_list,

			  gboolean   may_recurse)

{

  GHook *hook;

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  hook = g_hook_first_valid (hook_list, may_recurse);

  while (hook)

    {

      GHookCheckFunc func;

      gboolean was_in_call;

      gboolean need_destroy;

      func = (GHookCheckFunc) hook->func;

      was_in_call = G_HOOK_IN_CALL (hook);

      hook->flags |= G_HOOK_FLAG_IN_CALL;

      need_destroy = !func (hook->data);

      if (!was_in_call)

	hook->flags &= ~G_HOOK_FLAG_IN_CALL;

      if (need_destroy)

	g_hook_destroy_link (hook_list, hook);

      hook = g_hook_next_valid (hook_list, hook, may_recurse);

    }

}

EXPORT_C void

g_hook_list_marshal_check (GHookList	       *hook_list,

			   gboolean		may_recurse,

			   GHookCheckMarshaller marshaller,

			   gpointer		data)

{

  GHook *hook;

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  g_return_if_fail (marshaller != NULL);

  hook = g_hook_first_valid (hook_list, may_recurse);

  while (hook)

    {

      gboolean was_in_call;

      gboolean need_destroy;

      was_in_call = G_HOOK_IN_CALL (hook);

      hook->flags |= G_HOOK_FLAG_IN_CALL;

      need_destroy = !marshaller (hook, data);

      if (!was_in_call)

	hook->flags &= ~G_HOOK_FLAG_IN_CALL;

      if (need_destroy)

	g_hook_destroy_link (hook_list, hook);

      hook = g_hook_next_valid (hook_list, hook, may_recurse);

    }

}

EXPORT_C void

g_hook_list_marshal (GHookList		     *hook_list,

		     gboolean		      may_recurse,

		     GHookMarshaller	      marshaller,

		     gpointer		      data)

{

  GHook *hook;

  g_return_if_fail (hook_list != NULL);

  g_return_if_fail (hook_list->is_setup);

  g_return_if_fail (marshaller != NULL);

  hook = g_hook_first_valid (hook_list, may_recurse);

  while (hook)

    {

      gboolean was_in_call;

      was_in_call = G_HOOK_IN_CALL (hook);

      hook->flags |= G_HOOK_FLAG_IN_CALL;

      marshaller (hook, data);

      if (!was_in_call)

	hook->flags &= ~G_HOOK_FLAG_IN_CALL;

      hook = g_hook_next_valid (hook_list, hook, may_recurse);

    }

}

EXPORT_C GHook*

g_hook_first_valid (GHookList *hook_list,

		    gboolean   may_be_in_call)

{

  g_return_val_if_fail (hook_list != NULL, NULL);

  if (hook_list->is_setup)

    {

      GHook *hook;

      hook = hook_list->hooks;

      if (hook)

	{

	  g_hook_ref (hook_list, hook);

	  if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))

	    return hook;

	  else

	    return g_hook_next_valid (hook_list, hook, may_be_in_call);

	}

    }

  return NULL;

}

EXPORT_C GHook*

g_hook_next_valid (GHookList *hook_list,

		   GHook     *hook,

		   gboolean   may_be_in_call)

{

  GHook *ohook = hook;

  g_return_val_if_fail (hook_list != NULL, NULL);

  if (!hook)

    return NULL;

  hook = hook->next;

  while (hook)

    {

      if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook)))

	{

	  g_hook_ref (hook_list, hook);

	  g_hook_unref (hook_list, ohook);

	  return hook;

	}

      hook = hook->next;

    }

  g_hook_unref (hook_list, ohook);

  return NULL;

}

EXPORT_C GHook*

g_hook_get (GHookList *hook_list,

	    gulong     hook_id)

{

  GHook *hook;

  g_return_val_if_fail (hook_list != NULL, NULL);

  g_return_val_if_fail (hook_id > 0, NULL);

  hook = hook_list->hooks;

  while (hook)

    {

      if (hook->hook_id == hook_id)

	return hook;

      hook = hook->next;

    }

  return NULL;

}

EXPORT_C GHook*

g_hook_find (GHookList	  *hook_list,

	     gboolean	   need_valids,

	     GHookFindFunc func,

	     gpointer	   data)

{

  GHook *hook;

  g_return_val_if_fail (hook_list != NULL, NULL);

  g_return_val_if_fail (func != NULL, NULL);

  hook = hook_list->hooks;

  while (hook)

    {

      GHook *tmp;

      /* test only non-destroyed hooks */

      if (!hook->hook_id)

	{

	  hook = hook->next;

	  continue;

	}

      g_hook_ref (hook_list, hook);

      if (func (hook, data) && hook->hook_id && (!need_valids || G_HOOK_ACTIVE (hook)))

	{

	  g_hook_unref (hook_list, hook);

	  return hook;

	}

      tmp = hook->next;

      g_hook_unref (hook_list, hook);

      hook = tmp;

    }

  return NULL;

}

EXPORT_C GHook*

g_hook_find_data (GHookList *hook_list,

		  gboolean   need_valids,

		  gpointer   data)

{

  GHook *hook;

  g_return_val_if_fail (hook_list != NULL, NULL);

  hook = hook_list->hooks;

  while (hook)

    {

      /* test only non-destroyed hooks */

      if (hook->data == data &&

	  hook->hook_id &&

	  (!need_valids || G_HOOK_ACTIVE (hook)))

	return hook;

      hook = hook->next;

    }

  return NULL;