plugins/language-manager/plugin.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * plugin.c
   4  * Copyright (C) Johannes Schmid 2007 <jhs@gnome.org>
   5  *
   6  * plugin.c is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * plugin.c is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16  * See the GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with plugin.c.  If not, write to:
  20  *      The Free Software Foundation, Inc.,
  21  *      51 Franklin Street, Fifth Floor
  22  *      Boston, MA  02110-1301, USA.
  23  */
  24
  25 #include <config.h>
  26 #include <libanjuta/anjuta-shell.h>
  27 #include <libanjuta/anjuta-debug.h>
  28 #include <libanjuta/interfaces/ianjuta-language.h>
  29
  30 #include <libxml/parser.h>
  31 #include <libxml/tree.h>
  32
  33 #include "plugin.h"
  34 #define LANG_FILE PACKAGE_DATA_DIR"/languages.xml"
  35
  36 #define LANGUAGE_MANAGER(o) (LanguageManager*) (o)
  37
  38 typedef struct _Language Language;
  39
  40 struct _Language
  41 {
  42         IAnjutaLanguageId id;
  43         gchar* name;
  44         GList* strings;
  45         GList* mime_types;
  46 };
  47
  48
  49 static gpointer parent_class;
  50
  51
  52 static void
  53 language_destroy (gpointer data)
  54 {
  55         Language* lang = (Language*) data;
  56
  57         g_free(lang->name);
  58         g_list_foreach(lang->strings, (GFunc) g_free, NULL);
  59         g_list_foreach(lang->mime_types, (GFunc) g_free, NULL);
  60
  61         g_free(lang);
  62 }
  63
  64 static void
  65 load_languages (LanguageManager* language_manager)
  66 {
  67         xmlDocPtr doc;
  68         xmlNodePtr root;
  69         xmlNodePtr cur_node;
  70
  71         LIBXML_TEST_VERSION
  72
  73         doc = xmlReadFile (LANG_FILE, NULL, 0);
  74         if (!doc)
  75         {
  76                 DEBUG_PRINT("Could not read language xml file %s!", LANG_FILE);
  77                 return;
  78         }
  79         root = xmlDocGetRootElement (doc);
  80
  81         if (!g_str_equal (root->name, "languages"))
  82         {
  83                 DEBUG_PRINT ("Invalid languages.xml file");
  84         }
  85
  86         for (cur_node = root->children; cur_node != NULL; cur_node = cur_node->next)
  87         {
  88                 Language* lang = g_new0(Language, 1);
  89                 gchar* id;
  90                 gchar* mime_types;
  91                 gchar* strings;
  92
  93                 if (!g_str_equal (cur_node->name, (const xmlChar*) "language"))
  94                         continue;
  95
  96                 id = (gchar*) xmlGetProp (cur_node, (const xmlChar*) "id");
  97                 lang->id = atoi(id);
  98                 lang->name = (gchar*) xmlGetProp(cur_node, (const xmlChar*) "name");
  99                 mime_types = (gchar*) xmlGetProp (cur_node, (const xmlChar*) "mime-types");
 100                 strings = (gchar*) xmlGetProp (cur_node, (const xmlChar*) "strings");
 101                 if (lang->id != 0 && lang->name && mime_types && strings)
 102                 {
 103                         GStrv mime_typesv = g_strsplit(mime_types, ",", -1);
 104                         GStrv stringsv = g_strsplit (strings, ",", -1);
 105                         GStrv type;
 106                         GStrv string;
 107
 108                         for (type = mime_typesv; *type != NULL; type++)
 109                         {
 110                                 lang->mime_types = g_list_append (lang->mime_types, g_strdup(*type));
 111                         }
 112                         g_strfreev(mime_typesv);
 113
 114                         for (string = stringsv; *string != NULL; string++)
 115                         {
 116                                 lang->strings = g_list_append (lang->strings, g_strdup(*string));
 117                         }
 118                         g_strfreev(stringsv);
 119
 120                         g_hash_table_insert (language_manager->languages, GINT_TO_POINTER(lang->id), lang);
 121                 }
 122                 else
 123                 {
 124                         g_free(lang);
 125                 }
 126                 g_free (id);
 127                 g_free (mime_types);
 128                 g_free (strings);
 129         }
 130         xmlFreeDoc(doc);
 131 }
 132
 133 static gboolean
 134 language_manager_activate (AnjutaPlugin *plugin)
 135 {
 136         LanguageManager *language_manager;
 137
 138         DEBUG_PRINT ("LanguageManager: Activating LanguageManager plugin ...");
 139         language_manager = (LanguageManager*) plugin;
 140
 141         load_languages(language_manager);
 142
 143         return TRUE;
 144 }
 145
 146 static gboolean
 147 language_manager_deactivate (AnjutaPlugin *plugin)
 148 {
 149         DEBUG_PRINT ("LanguageManager: Dectivating LanguageManager plugin ...");
 150
 151         return TRUE;
 152 }
 153
 154 static void
 155 language_manager_finalize (GObject *obj)
 156 {
 157         /* Finalization codes here */
 158         GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (obj));
 159 }
 160
 161 static void
 162 language_manager_dispose (GObject *obj)
 163 {
 164         /* Disposition codes */
 165         LanguageManager* lang = LANGUAGE_MANAGER (obj);
 166
 167         g_hash_table_unref (lang->languages);
 168         GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (obj));
 169 }
 170
 171 static void
 172 language_manager_instance_init (GObject *obj)
 173 {
 174         LanguageManager *plugin = (LanguageManager*)obj;
 175         plugin->languages = g_hash_table_new_full (NULL, NULL,
 176                                                                                            NULL, language_destroy);
 177
 178 }
 179
 180 static void
 181 language_manager_class_init (GObjectClass *klass)
 182 {
 183         AnjutaPluginClass *plugin_class = ANJUTA_PLUGIN_CLASS (klass);
 184
 185         parent_class = g_type_class_peek_parent (klass);
 186
 187         plugin_class->activate = language_manager_activate;
 188         plugin_class->deactivate = language_manager_deactivate;
 189         klass->finalize = language_manager_finalize;
 190         klass->dispose = language_manager_dispose;
 191 }
 192
 193 typedef struct
 194 {
 195         LanguageManager* lang;
 196         const gchar* target;
 197         IAnjutaLanguageId result_id;
 198         gboolean found;
 199 } LangData;
 200
 201 static void
 202 language_manager_find_mime_type (gpointer key, Language* language, LangData* data)
 203 {
 204         if (data->found)
 205                 return;
 206         if (g_list_find_custom (language->mime_types, data->target, (GCompareFunc) strcmp))
 207         {
 208                 data->result_id = language->id;
 209                 data->found = TRUE;
 210         }
 211 }
 212
 213 static void
 214 language_manager_find_string (gpointer key, Language* language, LangData* data)
 215 {
 216         if (data->found)
 217                 return;
 218         if (g_list_find_custom (language->strings, data->target, (GCompareFunc) g_ascii_strcasecmp))
 219         {
 220                 DEBUG_PRINT ("Found language %i: %s", language->id, language->name);
 221                 data->result_id = language->id;
 222                 data->found = TRUE;
 223         }
 224 }
 225
 226 static IAnjutaLanguageId
 227 ilanguage_get_from_mime_type (IAnjutaLanguage* ilang, const gchar* mime_type, GError** e)
 228 {
 229         if (!mime_type)
 230                 return 0;
 231         LanguageManager* lang = LANGUAGE_MANAGER(ilang);
 232         LangData* data = g_new0(LangData, 1);
 233         IAnjutaLanguageId ret_id;
 234         data->target = mime_type;
 235         g_hash_table_foreach (lang->languages, (GHFunc)language_manager_find_mime_type, data);
 236         if (data->found)
 237         {
 238                 ret_id = data->result_id;
 239         }
 240         else
 241         {
 242                 DEBUG_PRINT ("Unknown mime-type = %s", mime_type);
 243                 ret_id = 0;
 244         }
 245         g_free(data);
 246         return ret_id;
 247 }
 248
 249 static IAnjutaLanguageId
 250 ilanguage_get_from_string (IAnjutaLanguage* ilang, const gchar* string, GError** e)
 251 {
 252         if (!string)
 253                 return 0;
 254         LanguageManager* lang = LANGUAGE_MANAGER(ilang);
 255         LangData* data = g_new0(LangData, 1);
 256         IAnjutaLanguageId ret_id;
 257         data->target = string;
 258         g_hash_table_foreach (lang->languages, (GHFunc)language_manager_find_string, data);
 259         if (data->found)
 260         {
 261                 ret_id = data->result_id;
 262         }
 263         else
 264         {
 265                 DEBUG_PRINT ("Unknown language string = %s", string);
 266                 ret_id = 0;
 267         }
 268         g_free(data);
 269         return ret_id;
 270 }
 271
 272 static const gchar*
 273 ilanguage_get_name (IAnjutaLanguage* ilang, IAnjutaLanguageId id, GError** e)
 274 {
 275         LanguageManager* lang = LANGUAGE_MANAGER(ilang);
 276         Language* language = g_hash_table_lookup (lang->languages,
 277                                                                                            GINT_TO_POINTER(id));
 278
 279         if (language)
 280         {
 281                 return language->name;
 282                 DEBUG_PRINT ("Found language: %s", language->name);
 283         }
 284         else
 285                 return NULL;
 286 }
 287
 288 static GList*
 289 ilanguage_get_strings (IAnjutaLanguage* ilang, IAnjutaLanguageId id, GError** e)
 290 {
 291         LanguageManager* lang = LANGUAGE_MANAGER(ilang);
 292         Language* language = g_hash_table_lookup (lang->languages,
 293                                                                                            GINT_TO_POINTER(id));
 294         if (language)
 295                 return language->strings;
 296         else
 297                 return NULL;
 298 }
 299
 300 static IAnjutaLanguageId
 301 ilanguage_get_from_editor (IAnjutaLanguage* ilang, IAnjutaEditorLanguage* editor, GError** e)
 302 {
 303         const gchar* language =
 304                         ianjuta_editor_language_get_language (editor, e);
 305
 306         IAnjutaLanguageId id =
 307                         ilanguage_get_from_string (ilang, language, e);
 308
 309         return id;
 310 }
 311
 312 static const gchar*
 313 ilanguage_get_name_from_editor (IAnjutaLanguage* ilang, IAnjutaEditorLanguage* editor, GError** e)
 314 {
 315         return ilanguage_get_name (ilang,
 316                                                            ilanguage_get_from_editor (ilang, editor, e), e);
 317 }
 318
 319 static void
 320 ilanguage_iface_init (IAnjutaLanguageIface* iface)
 321 {
 322         iface->get_from_mime_type = ilanguage_get_from_mime_type;
 323         iface->get_from_string = ilanguage_get_from_string;
 324         iface->get_name = ilanguage_get_name;
 325         iface->get_strings = ilanguage_get_strings;
 326         iface->get_from_editor = ilanguage_get_from_editor;
 327         iface->get_name_from_editor = ilanguage_get_name_from_editor;
 328 };
 329
 330 ANJUTA_PLUGIN_BEGIN (LanguageManager, language_manager);
 331 ANJUTA_PLUGIN_ADD_INTERFACE (ilanguage, IANJUTA_TYPE_LANGUAGE);
 332 ANJUTA_PLUGIN_END
 333
 334 ANJUTA_SIMPLE_PLUGIN (LanguageManager, language_manager);