libanjuta/anjuta-glue-factory.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /**
   3  * SECTION:anjuta-glue-factory
   4  * @short_description: Underlying plugin factory
   5  * @see_also:
   6  * @stability: Unstable
   7  * @include: libanjuta/anjuta-glue-factory.h
   8  *
   9  */
  10
  11 #include "anjuta-glue-factory.h"
  12
  13 #include <string.h>
  14
  15 #include "anjuta-plugin.h"
  16
  17 static void anjuta_glue_factory_init       (AnjutaGlueFactory *factory);
  18 static void anjuta_glue_factory_class_init (AnjutaGlueFactoryClass *class);
  19
  20 struct _AnjutaGlueFactory
  21 {
  22   GObject parent;
  23
  24   GList *paths;
  25 };
  26
  27 struct _AnjutaGlueFactoryClass
  28 {
  29   GObjectClass parent_class;
  30 };
  31
  32 GType
  33 anjuta_glue_factory_get_type (void)
  34 {
  35   static GType type = 0;
  36
  37   if (!type)
  38     {
  39       static const GTypeInfo type_info =
  40       {
  41         sizeof (AnjutaGlueFactoryClass),
  42         (GBaseInitFunc) NULL,
  43         (GBaseFinalizeFunc) NULL,
  44         (GClassInitFunc) anjuta_glue_factory_class_init,
  45         (GClassFinalizeFunc) NULL,
  46         NULL,
  47
  48         sizeof (AnjutaGlueFactory),
  49         0, /* n_preallocs */
  50         (GInstanceInitFunc) anjuta_glue_factory_init,
  51       };
  52
  53       type = g_type_register_static (G_TYPE_OBJECT,
  54                                      "AnjutaGlueFactory",
  55                                      &type_info, 0);
  56     }
  57   return type;
  58 }
  59
  60 static void
  61 anjuta_glue_factory_class_init (AnjutaGlueFactoryClass *class)
  62 {
  63 }
  64
  65 static void
  66 anjuta_glue_factory_init (AnjutaGlueFactory *factory)
  67 {
  68 }
  69
  70 AnjutaGlueFactory *
  71 anjuta_glue_factory_new (void)
  72 {
  73   AnjutaGlueFactory *factory;
  74
  75   factory = g_object_new (anjuta_glue_factory_get_type (), NULL);
  76
  77   return factory;
  78 }
  79
  80 gboolean
  81 anjuta_glue_factory_add_path (AnjutaGlueFactory *factory, const gchar *path)
  82 {
  83   GList *p;
  84   PathEntry *entry;
  85
  86   if (!g_file_test (path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
  87     return FALSE;
  88
  89   /* Check if the path has been added */
  90   p = factory->paths;
  91
  92   while (p)
  93     {
  94       PathEntry *entry = p->data;
  95
  96       /* If it's already added we return TRUE */
  97       if (strcmp (path, entry->path) == 0)
  98         return TRUE;
  99
 100       p = p->next;
 101     }
 102
 103   entry = g_new (PathEntry, 1);
 104   entry->path = g_strdup (path);
 105   entry->loaded_plugins = g_hash_table_new_full (NULL, NULL, g_free, g_object_unref);
 106
 107   factory->paths = g_list_prepend (factory->paths, entry);
 108
 109   return TRUE;
 110 }
 111
 112 GList* anjuta_glue_factory_get_path(AnjutaGlueFactory *factory)
 113 {
 114         return factory->paths;
 115 }
 116
 117 static AnjutaGluePlugin *
 118 get_already_loaded_component (AnjutaGlueFactory *factory,
 119                            const gchar *component_name,
 120                            const gchar *type_name)
 121 {
 122         GList *p;
 123
 124         for (p = factory->paths; p != NULL; p = p->next)
 125         {
 126         PathEntry *entry = p->data;
 127         AnjutaGluePlugin *plugin;
 128
 129                 plugin = g_hash_table_lookup (entry->loaded_plugins, component_name);
 130
 131                 if (plugin && anjuta_glue_plugin_get_component_type (plugin, ANJUTA_TYPE_PLUGIN, type_name) != G_TYPE_INVALID)
 132                         return plugin;
 133         }
 134
 135         return NULL;
 136 }
 137
 138 static GType
 139 load_plugin (AnjutaGlueFactory *factory, const gchar *component_name, const gchar *type_name, AnjutaGluePlugin *glue)
 140 {
 141         GList *p;
 142         const gchar *plugin_name;
 143         GList *descs = NULL;
 144         AnjutaPluginDescription *plugin;
 145         gchar *value;
 146
 147     plugin_name = anjuta_glue_plugin_build_component_path (glue, NULL, component_name);
 148         for (p = factory->paths; p != NULL; p = p->next)
 149     {
 150                 const gchar *file_name;
 151         PathEntry *entry = p->data;
 152                 GDir *dir;
 153
 154                 dir = g_dir_open (entry->path, 0, NULL);
 155                 if (dir == NULL) continue;
 156
 157                 /* Search for corresponding file */
 158                 for(file_name = g_dir_read_name (dir); file_name != NULL; file_name = g_dir_read_name (dir))
 159                 {
 160                         if (file_name && strcmp (file_name, plugin_name) == 0)
 161                         {
 162                                 GType type;
 163
 164                                 /* We have found a matching component */
 165                                 anjuta_glue_plugin_build_component_path (glue, entry->path, component_name);
 166
 167                                 /* Load module to check if type really exist */
 168                                 g_type_module_use (G_TYPE_MODULE (glue));
 169                                 type = anjuta_glue_plugin_get_component_type (glue, ANJUTA_TYPE_PLUGIN, type_name);
 170                                 g_type_module_unuse (G_TYPE_MODULE (glue));
 171                                 if (type != G_TYPE_INVALID)
 172                                 {
 173                                         g_hash_table_insert (entry->loaded_plugins,
 174                                                                  (gpointer)strdup (component_name),
 175                                                                  glue);
 176
 177                                         return type;
 178                                 }
 179                                 break;
 180                         }
 181         }
 182         g_dir_close (dir);
 183         }
 184
 185         /* Plugin file not found, free glue object */
 186         g_object_unref (G_OBJECT (glue));
 187
 188         return G_TYPE_INVALID;
 189 }
 190
 191 GType
 192 anjuta_glue_factory_get_object_type (AnjutaGlueFactory  *factory,
 193                               const gchar  *component_name,
 194                               const gchar  *type_name,
 195                               gboolean     resident,
 196                               GType        language)
 197 {
 198         AnjutaGluePlugin *glue;
 199
 200         glue = get_already_loaded_component (factory, component_name, type_name);
 201
 202         if (!glue)
 203         {
 204                 AnjutaGluePlugin *glue;
 205                 GType type;
 206
 207                 glue = (AnjutaGluePlugin *)g_object_new (language, NULL);
 208                 anjuta_glue_plugin_set_resident (glue, resident);
 209         return load_plugin (factory, component_name, type_name, glue);
 210         }
 211         else
 212         {
 213                 return anjuta_glue_plugin_get_component_type (glue, ANJUTA_TYPE_PLUGIN, type_name);
 214         }
 215 }