/* GObject - GLib Type, Object, Parameter and Signal Library

 * Copyright (C) 2000 Red Hat, Inc.

 * 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.

 */

#include <stdlib.h>

#include "gtypeplugin.h"

#include "gtypemodule.h"

#include "gobjectalias.h"

#ifdef __SYMBIAN32__

#include <gobject_wsd.h>

#endif /* __SYMBIAN32__ */

typedef struct _ModuleTypeInfo ModuleTypeInfo;

typedef struct _ModuleInterfaceInfo ModuleInterfaceInfo;

struct _ModuleTypeInfo 

{

  gboolean  loaded;

  GType     type;

  GType     parent_type;

  GTypeInfo info;

};

struct _ModuleInterfaceInfo 

{

  gboolean       loaded;

  GType          instance_type;

  GType          interface_type;

  GInterfaceInfo info;

};

static void g_type_module_use_plugin              (GTypePlugin     *plugin);

static void g_type_module_complete_type_info      (GTypePlugin     *plugin,

						   GType            g_type,

						   GTypeInfo       *info,

						   GTypeValueTable *value_table);

static void g_type_module_complete_interface_info (GTypePlugin     *plugin,

						   GType            instance_type,

						   GType            interface_type,

						   GInterfaceInfo  *info);

#if EMULATOR

PLS(parent_class ,gtypemodule,gpointer)

#define parent_class  (*FUNCTION_NAME(parent_class,gtypemodule)())

#else

static gpointer parent_class = NULL;

#endif /* EMULATOR*/

static void

g_type_module_dispose (GObject *object)

{

  GTypeModule *module = G_TYPE_MODULE (object);

  if (module->type_infos || module->interface_infos)

    {

      g_warning (G_STRLOC ": unsolicitated invocation of g_object_dispose() on GTypeModule");

      g_object_ref (object);

    }

  G_OBJECT_CLASS (parent_class)->dispose (object);

}

static void

g_type_module_finalize (GObject *object)

{

  GTypeModule *module = G_TYPE_MODULE (object);

  g_free (module->name);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

g_type_module_class_init (GTypeModuleClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (class));

  gobject_class->dispose = g_type_module_dispose;

  gobject_class->finalize = g_type_module_finalize;

}

static void

g_type_module_iface_init (GTypePluginClass *iface)

{

  iface->use_plugin = g_type_module_use_plugin;

  iface->unuse_plugin = (void (*) (GTypePlugin *))g_type_module_unuse;

  iface->complete_type_info = g_type_module_complete_type_info;

  iface->complete_interface_info = g_type_module_complete_interface_info;

}

#if EMULATOR

PLS(type_module_type,g_type_module_get_type ,GType)

#define type_module_type (*FUNCTION_NAME(type_module_type,g_type_module_get_type )())

#endif /* EMULATOR */

EXPORT_C GType

g_type_module_get_type (void)

{

  #if !(EMULATOR)

  static GType type_module_type = 0;

  #endif /* EMULATOR */

  if (!type_module_type)

    {

      static const GTypeInfo type_module_info = {

        sizeof (GTypeModuleClass),

        NULL,           /* base_init */

        NULL,           /* base_finalize */

        (GClassInitFunc) g_type_module_class_init,

        NULL,           /* class_finalize */

        NULL,           /* class_data */

        sizeof (GTypeModule),

        0,              /* n_preallocs */

        NULL,           /* instance_init */

      };

      static const GInterfaceInfo iface_info = {

        (GInterfaceInitFunc) g_type_module_iface_init,

        NULL,               /* interface_finalize */

        NULL,               /* interface_data */

      };

      type_module_type = g_type_register_static (G_TYPE_OBJECT, g_intern_static_string ("GTypeModule"), &type_module_info, G_TYPE_FLAG_ABSTRACT);

      g_type_add_interface_static (type_module_type, G_TYPE_TYPE_PLUGIN, &iface_info);

    }

  return type_module_type;

}

#if EMULATOR

#undef  type_module_type

#endif /* EMULATOR */

EXPORT_C void

g_type_module_set_name (GTypeModule  *module,

			const gchar  *name)

{

  g_return_if_fail (G_IS_TYPE_MODULE (module));

  g_free (module->name);

  module->name = g_strdup (name);

}

static ModuleTypeInfo *

g_type_module_find_type_info (GTypeModule *module,

			      GType        type)

{

  GSList *tmp_list = module->type_infos;

  while (tmp_list)

    {

      ModuleTypeInfo *type_info = tmp_list->data;

      if (type_info->type == type)

	return type_info;

      tmp_list = tmp_list->next;

    }

  return NULL;

}

static ModuleInterfaceInfo *

g_type_module_find_interface_info (GTypeModule *module,

				   GType        instance_type,

				   GType        interface_type)

{

  GSList *tmp_list = module->interface_infos;

  while (tmp_list)

    {

      ModuleInterfaceInfo *interface_info = tmp_list->data;

      if (interface_info->instance_type == instance_type &&

	  interface_info->interface_type == interface_type)

	return interface_info;

      tmp_list = tmp_list->next;

    }

  return NULL;

}

EXPORT_C gboolean

g_type_module_use (GTypeModule *module)

{

  g_return_val_if_fail (G_IS_TYPE_MODULE (module), FALSE);

  module->use_count++;

  if (module->use_count == 1)

    {

      GSList *tmp_list;

      if (!G_TYPE_MODULE_GET_CLASS (module)->load (module))

	{

	  module->use_count--;

	  return FALSE;

	}

      tmp_list = module->type_infos;

      while (tmp_list)

	{

	  ModuleTypeInfo *type_info = tmp_list->data;

	  if (!type_info->loaded)

	    {

	      g_warning ("plugin '%s' failed to register type '%s'\n",

			 module->name ? module->name : "(unknown)",

			 g_type_name (type_info->type));

	      return FALSE;

	    }

	  tmp_list = tmp_list->next;

	}

    }

  return TRUE;

}

EXPORT_C void

g_type_module_unuse (GTypeModule *module)

{

  g_return_if_fail (G_IS_TYPE_MODULE (module));

  g_return_if_fail (module->use_count > 0);

  module->use_count--;

  if (module->use_count == 0)

    {

      GSList *tmp_list;

      G_TYPE_MODULE_GET_CLASS (module)->unload (module);

      tmp_list = module->type_infos;

      while (tmp_list)

	{

	  ModuleTypeInfo *type_info = tmp_list->data;

	  type_info->loaded = FALSE;

	  tmp_list = tmp_list->next;

	}

    }

}

static void

g_type_module_use_plugin (GTypePlugin *plugin)

{

  GTypeModule *module = G_TYPE_MODULE (plugin);

  if (!g_type_module_use (module))

    {

      g_warning ("Fatal error - Could not reload previously loaded plugin '%s'\n",

		 module->name ? module->name : "(unknown)");

      exit (1);

    }

}

static void

g_type_module_complete_type_info (GTypePlugin     *plugin,

				  GType            g_type,

				  GTypeInfo       *info,

				  GTypeValueTable *value_table)

{

  GTypeModule *module = G_TYPE_MODULE (plugin);

  ModuleTypeInfo *module_type_info = g_type_module_find_type_info (module, g_type);

  *info = module_type_info->info;

  if (module_type_info->info.value_table)

    *value_table = *module_type_info->info.value_table;

}

static void 

g_type_module_complete_interface_info (GTypePlugin    *plugin,

				       GType           instance_type,

				       GType           interface_type,

				       GInterfaceInfo *info)

{

  GTypeModule *module = G_TYPE_MODULE (plugin);

  ModuleInterfaceInfo *module_interface_info = g_type_module_find_interface_info (module, instance_type, interface_type);

  *info = module_interface_info->info;

}

EXPORT_C GType

g_type_module_register_type (GTypeModule     *module,

			     GType            parent_type,

			     const gchar     *type_name,

			     const GTypeInfo *type_info,

			     GTypeFlags       flags)

{

  ModuleTypeInfo *module_type_info = NULL;

  GType type;

  g_return_val_if_fail (module != NULL, 0);

  g_return_val_if_fail (type_name != NULL, 0);

  g_return_val_if_fail (type_info != NULL, 0);

  type = g_type_from_name (type_name);

  if (type)

    {

      GTypePlugin *old_plugin = g_type_get_plugin (type);

      if (old_plugin != G_TYPE_PLUGIN (module))

	{

	  g_warning ("Two different plugins tried to register '%s'.", type_name);

	  return 0;

	}

    }

  if (type)

    {

      module_type_info = g_type_module_find_type_info (module, type);

      if (module_type_info->parent_type != parent_type)

	{

	  const gchar *parent_type_name = g_type_name (parent_type);

	  g_warning ("Type '%s' recreated with different parent type.\n"

		     "(was '%s', now '%s')", type_name,

		     g_type_name (module_type_info->parent_type),

		     parent_type_name ? parent_type_name : "(unknown)");

	  return 0;

	}

      if (module_type_info->info.value_table)

	g_free ((GTypeValueTable *) module_type_info->info.value_table);

    }

  else

    {

      module_type_info = g_new (ModuleTypeInfo, 1);

      module_type_info->parent_type = parent_type;

      module_type_info->type = g_type_register_dynamic (parent_type, type_name, G_TYPE_PLUGIN (module), flags);

      module->type_infos = g_slist_prepend (module->type_infos, module_type_info);

    }

  module_type_info->loaded = TRUE;

  module_type_info->info = *type_info;

  if (type_info->value_table)

    module_type_info->info.value_table = g_memdup (type_info->value_table,

						   sizeof (type_info->value_table));

  return module_type_info->type;

}

EXPORT_C void

g_type_module_add_interface (GTypeModule          *module,

			     GType                 instance_type,

			     GType                 interface_type,

			     const GInterfaceInfo *interface_info)

{

  ModuleInterfaceInfo *module_interface_info = NULL;

  g_return_if_fail (module != NULL);

  g_return_if_fail (interface_info != NULL);

  if (g_type_is_a (instance_type, interface_type))

    {

      GTypePlugin *old_plugin = g_type_interface_get_plugin (instance_type,

							     interface_type);

      if (!old_plugin)

	{

	  g_warning ("Interface '%s' for '%s' was previously registered statically or for a parent type.",

		     g_type_name (interface_type), g_type_name (instance_type));

	  return;

	}

      else if (old_plugin != G_TYPE_PLUGIN (module))

	{

	  g_warning ("Two different plugins tried to register interface '%s' for '%s'.",

		     g_type_name (interface_type), g_type_name (instance_type));

	  return;

	}

      module_interface_info = g_type_module_find_interface_info (module, instance_type, interface_type);

      g_assert (module_interface_info);

    }

  else

    {

      module_interface_info = g_new (ModuleInterfaceInfo, 1);

      module_interface_info->instance_type = instance_type;

      module_interface_info->interface_type = interface_type;

      g_type_add_interface_dynamic (instance_type, interface_type, G_TYPE_PLUGIN (module));

      module->interface_infos = g_slist_prepend (module->interface_infos, module_interface_info);

    }

  module_interface_info->loaded = TRUE;

  module_interface_info->info = *interface_info;

}

EXPORT_C GType

g_type_module_register_enum (GTypeModule      *module,

                             const gchar      *name,

                             const GEnumValue *const_static_values)

{

  GTypeInfo enum_type_info = { 0, };

  g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);

  g_return_val_if_fail (name != NULL, 0);

  g_return_val_if_fail (const_static_values != NULL, 0);

  g_enum_complete_type_info (G_TYPE_ENUM,

                             &enum_type_info, const_static_values);

  return g_type_module_register_type (G_TYPE_MODULE (module),

                                      G_TYPE_ENUM, name, &enum_type_info, 0);

}

EXPORT_C GType

g_type_module_register_flags (GTypeModule      *module,

                             const gchar       *name,

                             const GFlagsValue *const_static_values)

{

  GTypeInfo flags_type_info = { 0, };

  g_return_val_if_fail (G_IS_TYPE_MODULE (module), 0);

  g_return_val_if_fail (name != NULL, 0);

  g_return_val_if_fail (const_static_values != NULL, 0);

  g_flags_complete_type_info (G_TYPE_FLAGS,

                             &flags_type_info, const_static_values);

  return g_type_module_register_type (G_TYPE_MODULE (module),

                                      G_TYPE_FLAGS, name, &flags_type_info, 0);

}

#define __G_TYPE_MODULE_C__

#include "gobjectaliasdef.c"