plugins/file-loader/plugin.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     plugin.c
   4     Copyright (C) 2004 Naba Kumar
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include <config.h>
  22 #include <libgnomevfs/gnome-vfs-mime-utils.h>
  23 #include <libgnomevfs/gnome-vfs-mime-handlers.h>
  24 #include <libgnomevfs/gnome-vfs-ops.h>
  25
  26 #include <libanjuta/anjuta-shell.h>
  27 #include <libanjuta/anjuta-status.h>
  28 #include <libanjuta/anjuta-debug.h>
  29
  30 #include <libanjuta/interfaces/ianjuta-file.h>
  31 #include <libanjuta/interfaces/ianjuta-file-loader.h>
  32 #include <libanjuta/interfaces/ianjuta-document-manager.h>
  33 #include <libanjuta/interfaces/ianjuta-wizard.h>
  34 #include <libegg/menu/egg-submenu-action.h>
  35 #include <libegg/menu/egg-recent-action.h>
  36
  37 #include "plugin.h"
  38 #include "dnd.h"
  39
  40 #define UI_FILE PACKAGE_DATA_DIR"/ui/anjuta-loader-plugin.ui"
  41
  42 static gpointer parent_class;
  43
  44 static int
  45 sort_wizards(gconstpointer wizard1, gconstpointer wizard2)
  46 {
  47         gchar* name1, *name2;
  48         AnjutaPluginDescription* desc1 = (AnjutaPluginDescription*) wizard1;
  49         AnjutaPluginDescription* desc2 = (AnjutaPluginDescription*) wizard2;
  50
  51         if ((anjuta_plugin_description_get_string (desc1, "Wizard",
  52                                                                                                   "Title", &name1) ||
  53                         anjuta_plugin_description_get_string (desc1, "Anjuta Plugin",
  54                                                                                                   "Name", &name1)) &&
  55                 (anjuta_plugin_description_get_string (desc2, "Wizard",
  56                                                                                                   "Title", &name2) ||
  57                         anjuta_plugin_description_get_string (desc2, "Anjuta Plugin",
  58                                                                                                   "Name", &name2)))
  59         {
  60                 return strcmp(name1, name2);
  61         }
  62         else
  63                 return 0;
  64 }
  65
  66 static void
  67 set_recent_file (AnjutaFileLoaderPlugin *plugin, const gchar *uri,
  68                                  const gchar *mime)
  69 {
  70         EggRecentItem *recent_item;
  71         DEBUG_PRINT ("Adding recent item of mimi-type: %s", mime);
  72         recent_item = egg_recent_item_new ();
  73         egg_recent_item_set_uri (recent_item, uri);
  74         egg_recent_item_set_mime_type (recent_item, mime);
  75         if (strcmp (mime, "application/x-anjuta") == 0)
  76         {
  77                 egg_recent_item_add_group (recent_item, "anjuta-projects");
  78                 egg_recent_model_add_full (plugin->recent_files_model_top,
  79                                                                    recent_item);
  80         }
  81         else
  82         {
  83                 egg_recent_item_add_group (recent_item, "anjuta-files");
  84                 egg_recent_model_add_full (plugin->recent_files_model_bottom,
  85                                                                    recent_item);
  86         }
  87 }
  88
  89 static void
  90 launch_application_failure (AnjutaFileLoaderPlugin *plugin,
  91                                                         const gchar *uri,
  92                                                         GnomeVFSResult result)
  93 {
  94         const gchar *errmsg;
  95         GtkWidget *parent;
  96
  97         errmsg = gnome_vfs_result_to_string (result);
  98         parent =
  99                 gtk_widget_get_toplevel (GTK_WIDGET(ANJUTA_PLUGIN (plugin)->shell));
 100         anjuta_util_dialog_error (GTK_WINDOW (parent),
 101                                                           "Can not open \"%s\".\n\n%s",
 102                                                           g_basename (uri), errmsg);
 103 }
 104
 105 static GList *
 106 get_available_plugins_for_mime (AnjutaFileLoaderPlugin* plugin,
 107                                                            const gchar *mime_type)
 108 {
 109         AnjutaPluginManager *plugin_manager;
 110         GList *plugin_descs = NULL;
 111
 112         g_return_val_if_fail (mime_type != NULL, NULL);
 113
 114         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN(plugin)->shell,
 115                                                                                                           NULL);
 116         plugin_descs = anjuta_plugin_manager_query (plugin_manager,
 117                                                                                                 "Anjuta Plugin",
 118                                                                                                 "Interfaces", "IAnjutaFile",
 119                                                                                                 "File Loader",
 120                                                                                                 "SupportedMimeTypes",
 121                                                                                                 mime_type,
 122                                                                                                 NULL);
 123         return plugin_descs;
 124 }
 125
 126 static void
 127 open_with_dialog (AnjutaFileLoaderPlugin *plugin, const gchar *uri,
 128                                   const gchar *mime_type)
 129 {
 130         GList *plugin_descs, *snode;
 131         GList *mime_apps, *node;
 132         GtkWidget *menu, *menuitem;
 133         GnomeVFSMimeApplication *mime_app;
 134
 135         GtkWidget *dialog, *parent, *hbox, *label;
 136         GtkWidget *options;
 137         gchar *message;
 138         AnjutaPluginManager *plugin_manager;
 139
 140         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (plugin)->shell,
 141                                                                                                           NULL);
 142         message = g_strdup_printf (_("<b>Cannot open \"%s\"</b>.\n\n"
 143                                                                  "There is no plugin, default action, or application "
 144                                                                  "configured to handle this file type.\n"
 145                                                                  "\n"
 146                                                                  "Mime type: %s.\n"
 147                                                                  "\n"
 148                                                                  "You may choose to try opening it with the following "
 149                                                                  "plugins or applications."),
 150                                                            g_basename(uri), mime_type);
 151         parent =
 152                 gtk_widget_get_toplevel (GTK_WIDGET(ANJUTA_PLUGIN (plugin)->shell));
 153         dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (parent),
 154                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 155                                                                          GTK_MESSAGE_INFO,
 156                                                                          GTK_BUTTONS_OK_CANCEL, message);
 157         g_free (message);
 158
 159         hbox = gtk_hbox_new (FALSE, 5);
 160         gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox), hbox,
 161                                                 FALSE, FALSE, 5);
 162         label = gtk_label_new (_("Open with:"));
 163         options = gtk_option_menu_new ();
 164         gtk_box_pack_end (GTK_BOX(hbox), options, FALSE, FALSE, 10);
 165         gtk_box_pack_end (GTK_BOX(hbox), label, FALSE, FALSE, 10);
 166
 167         menu = gtk_menu_new ();
 168
 169         /* Document manager plugin */
 170         menuitem = gtk_menu_item_new_with_label (_("Document Manager"));
 171         gtk_menu_append (menu, menuitem);
 172
 173         /* Open with plugins menu items */
 174         plugin_descs = get_available_plugins_for_mime (plugin, mime_type);
 175         snode = plugin_descs;
 176         while (snode)
 177         {
 178                 gchar *name;
 179                 AnjutaPluginDescription *desc;
 180
 181                 desc = (AnjutaPluginDescription *)(snode->data);
 182
 183                 name = NULL;
 184
 185                 anjuta_plugin_description_get_string (desc, "File Loader",
 186                                                                                           "Title", &name);
 187
 188                 if (!name)
 189                 {
 190                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 191                                                                                                   "Name", &name);
 192                 }
 193                 if (!name)
 194                 {
 195                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 196                                                                                                   "Location", &name);
 197                 }
 198                 menuitem = gtk_menu_item_new_with_label (name);
 199                 gtk_menu_append (menu, menuitem);
 200                 g_free (name);
 201                 snode = g_list_next (snode);
 202         }
 203
 204         /* Open with application menu items */
 205         mime_apps = gnome_vfs_mime_get_all_applications (mime_type);
 206         if (mime_apps)
 207         {
 208                 /* Separator */
 209                 menuitem = gtk_menu_item_new ();
 210                 gtk_menu_append (menu, menuitem);
 211         }
 212         node = mime_apps;
 213         while (node)
 214         {
 215                 mime_app = (GnomeVFSMimeApplication *)(node->data);
 216                 menuitem = gtk_menu_item_new_with_label (mime_app->name);
 217                 gtk_menu_append (menu, menuitem);
 218                 node = g_list_next (node);
 219         }
 220
 221         gtk_option_menu_set_menu (GTK_OPTION_MENU (options), menu);
 222         gtk_widget_show_all (hbox);
 223
 224         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
 225         {
 226                 gint option;
 227
 228                 option = gtk_option_menu_get_history(GTK_OPTION_MENU (options));
 229                 if (option == 0)
 230                 {
 231                         IAnjutaDocumentManager *docman;
 232                         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
 233                                                                                                  IAnjutaDocumentManager,
 234                                                                                                  NULL);
 235                         if (docman)
 236                         {
 237                                 ianjuta_file_open (IANJUTA_FILE (docman), uri, NULL);
 238                         }
 239                         else
 240                         {
 241                                 g_warning ("No document manager plugin!!");
 242                         }
 243                 }
 244                 else if (option < (g_list_length (plugin_descs) + 1))
 245                 {
 246                         AnjutaPluginDescription *desc;
 247                         gchar *location = NULL;
 248
 249                         option--;
 250                         desc = g_list_nth_data (plugin_descs, option);
 251                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 252                                                                                                   "Location", &location);
 253                         g_assert (location != NULL);
 254                         if (location != NULL)
 255                         {
 256                                 GObject *loaded_plugin;
 257
 258                                 loaded_plugin =
 259                                         anjuta_plugin_manager_get_plugin_by_id (plugin_manager,
 260                                                                                                                         location);
 261                                 if (loaded_plugin)
 262                                 {
 263                                         ianjuta_file_open (IANJUTA_FILE (loaded_plugin), uri, NULL);
 264                                         set_recent_file (plugin, uri, mime_type);
 265                                 }
 266                                 else
 267                                 {
 268                                         anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
 269                                                                                           "Failed to activate plugin: %s",
 270                                                                                           location);
 271                                 }
 272                                 g_free (location);
 273                         }
 274                 }
 275                 else
 276                 {
 277                         GList *uris = NULL;
 278                         GnomeVFSResult res;
 279
 280                         option -= (g_list_length (plugin_descs) + 2);
 281                         mime_app = g_list_nth_data (mime_apps, option);
 282                         uris = g_list_prepend (uris, (gpointer)uri);
 283                         res = gnome_vfs_mime_application_launch (mime_app, uris);
 284                         if (res != GNOME_VFS_OK)
 285                                 launch_application_failure (plugin, uri, res);
 286                         else
 287                                 set_recent_file (plugin, uri, mime_type);
 288                         g_list_free (uris);
 289                 }
 290         }
 291         gnome_vfs_mime_application_list_free (mime_apps);
 292         if (plugin_descs)
 293                 g_list_free (plugin_descs);
 294         gtk_widget_destroy (dialog);
 295 }
 296
 297 static gboolean
 298 launch_in_default_application (AnjutaFileLoaderPlugin *plugin,
 299                                                            const gchar *mime_type, const gchar *uri)
 300 {
 301         GnomeVFSMimeAction *action;
 302         GList *uris = NULL;
 303         gboolean ret;
 304
 305         uris = g_list_prepend (uris, (gpointer)uri);
 306
 307         ret = TRUE;
 308         action = gnome_vfs_mime_get_default_action (mime_type);
 309         if (!action || gnome_vfs_mime_action_launch (action, uris) != GNOME_VFS_OK)
 310         {
 311                 GnomeVFSMimeApplication *app;
 312                 GnomeVFSResult res;
 313                 app = gnome_vfs_mime_get_default_application (mime_type);
 314                 if (!app ||
 315                         (res =
 316                                 gnome_vfs_mime_application_launch (app, uris)) != GNOME_VFS_OK)
 317                 {
 318                         open_with_dialog (plugin, uri, mime_type);
 319                 }
 320                 if (app)
 321                         gnome_vfs_mime_application_free (app);
 322         }
 323         if (action)
 324                 gnome_vfs_mime_action_free (action);
 325         g_list_free (uris);
 326         return ret;
 327 }
 328
 329 static void
 330 open_file (AnjutaFileLoaderPlugin *plugin, const gchar *uri)
 331 {
 332         GnomeVFSURI *vfs_uri;
 333         gchar *dirname;
 334
 335         vfs_uri = gnome_vfs_uri_new (uri);
 336         dirname = gnome_vfs_uri_extract_dirname (vfs_uri);
 337         gnome_vfs_uri_unref (vfs_uri);
 338         chdir (dirname);
 339         g_free (dirname);
 340
 341         ianjuta_file_loader_load (IANJUTA_FILE_LOADER (plugin),
 342                                                           uri, FALSE, NULL);
 343 }
 344
 345 typedef struct
 346 {
 347         AnjutaFileLoaderPlugin *plugin;
 348         const gchar *uri;
 349 } RecentIdelOpenData;
 350
 351 static gboolean
 352 on_open_recent_file_idle (gpointer data)
 353 {
 354         RecentIdelOpenData *rdata;
 355
 356         rdata = (RecentIdelOpenData*)data;
 357         open_file (rdata->plugin, rdata->uri);
 358         g_free (rdata);
 359         return FALSE;
 360 }
 361
 362 static gboolean
 363 on_open_recent_file (EggRecentAction *action, AnjutaFileLoaderPlugin *plugin)
 364 {
 365         const gchar *uri;
 366         GnomeVFSURI *vfs_uri;
 367         gboolean ret = TRUE;
 368         RecentIdelOpenData *rdata;
 369
 370         uri = egg_recent_action_get_selected_uri (action);
 371         vfs_uri = gnome_vfs_uri_new (uri);
 372         rdata = g_new0 (RecentIdelOpenData, 1);
 373         rdata->plugin = plugin;
 374         rdata->uri = uri;
 375         g_idle_add (on_open_recent_file_idle, rdata);
 376         gnome_vfs_uri_unref (vfs_uri);
 377
 378         return ret;
 379 }
 380
 381 static void
 382 on_open_response_ok (GtkDialog* dialog, gint id,
 383                                          AnjutaFileLoaderPlugin *plugin)
 384 {
 385         GSList *list, *node;
 386
 387         if (id != GTK_RESPONSE_ACCEPT)
 388         {
 389                 gtk_widget_destroy (GTK_WIDGET (dialog));
 390                 return;
 391         }
 392
 393         list = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
 394         node = list;
 395         while (node)
 396         {
 397                 if (node->data)
 398                         open_file (plugin, (gchar *)node->data);
 399                 g_free (node->data);
 400                 node = g_slist_next (node);
 401         }
 402         g_slist_free (list);
 403 }
 404
 405 static void
 406 setup_file_filters (GtkFileChooser *fc)
 407 {
 408         GtkFileFilter *filter;
 409
 410         filter = gtk_file_filter_new ();
 411         gtk_file_filter_set_name (filter, _("All files"));
 412         gtk_file_filter_add_pattern (filter, "*");
 413         gtk_file_chooser_add_filter (fc, filter);
 414
 415         filter = gtk_file_filter_new ();
 416         gtk_file_filter_set_name (filter, _("Anjuta Projects"));
 417         gtk_file_filter_add_pattern (filter, "*.anjuta");
 418         gtk_file_filter_add_pattern (filter, "*.prj");
 419         gtk_file_chooser_add_filter (fc, filter);
 420
 421         filter = gtk_file_filter_new ();
 422         gtk_file_filter_set_name (filter, _("C/C++ source files"));
 423         gtk_file_filter_add_pattern (filter, "*.c");
 424         gtk_file_filter_add_pattern (filter, "*.cc");
 425         gtk_file_filter_add_pattern (filter, "*.cpp");
 426         gtk_file_filter_add_pattern (filter, "*.cxx");
 427         gtk_file_filter_add_pattern (filter, "*.c++");
 428         gtk_file_filter_add_pattern (filter, "*.h");
 429         gtk_file_filter_add_pattern (filter, "*.hh");
 430         gtk_file_filter_add_pattern (filter, "*.hpp");
 431         gtk_file_chooser_add_filter (fc, filter);
 432
 433         filter = gtk_file_filter_new ();
 434         gtk_file_filter_set_name (filter, _("C# source files"));
 435         gtk_file_filter_add_pattern (filter, "*.cs");
 436         gtk_file_filter_add_pattern (filter, "*.h");
 437         gtk_file_chooser_add_filter (fc, filter);
 438
 439         filter = gtk_file_filter_new ();
 440         gtk_file_filter_set_name (filter, _("Java source files"));
 441         gtk_file_filter_add_pattern (filter, "*.java");
 442         gtk_file_filter_add_pattern (filter, "*.js");
 443         gtk_file_chooser_add_filter (fc, filter);
 444
 445         filter = gtk_file_filter_new ();
 446         gtk_file_filter_set_name (filter, _("Pascal source files"));
 447         gtk_file_filter_add_pattern (filter, "*.pas");
 448         gtk_file_chooser_add_filter (fc, filter);
 449
 450         filter = gtk_file_filter_new ();
 451         gtk_file_filter_set_name (filter, _("PHP source files"));
 452         gtk_file_filter_add_pattern (filter, "*.php");
 453         gtk_file_filter_add_pattern (filter, "*.php?");
 454         gtk_file_filter_add_pattern (filter, "*.phtml");
 455         gtk_file_chooser_add_filter (fc, filter);
 456
 457         filter = gtk_file_filter_new ();
 458         gtk_file_filter_set_name (filter, _("Perl source files"));
 459         gtk_file_filter_add_pattern (filter, "*.pl");
 460         gtk_file_filter_add_pattern (filter, "*.pm");
 461         gtk_file_chooser_add_filter (fc, filter);
 462
 463         filter = gtk_file_filter_new ();
 464         gtk_file_filter_set_name (filter, _("Python source files"));
 465         gtk_file_filter_add_pattern (filter, "*.py");
 466         gtk_file_chooser_add_filter (fc, filter);
 467
 468         filter = gtk_file_filter_new ();
 469         gtk_file_filter_set_name (filter, _("Hyper text markup files"));
 470         gtk_file_filter_add_pattern (filter, "*.htm");
 471         gtk_file_filter_add_pattern (filter, "*.html");
 472         gtk_file_filter_add_pattern (filter, "*.xhtml");
 473         gtk_file_filter_add_pattern (filter, "*.dhtml");
 474         gtk_file_filter_add_pattern (filter, "*.cs");
 475         gtk_file_chooser_add_filter (fc, filter);
 476
 477         filter = gtk_file_filter_new ();
 478         gtk_file_filter_set_name (filter, _("Shell scripts files"));
 479         gtk_file_filter_add_pattern (filter, "*.sh");
 480         gtk_file_chooser_add_filter (fc, filter);
 481
 482         filter = gtk_file_filter_new ();
 483         gtk_file_filter_set_name (filter, _("Makefiles"));
 484         gtk_file_filter_add_pattern (filter, "Makefile*");
 485         gtk_file_filter_add_pattern (filter, "makefile*");
 486         gtk_file_chooser_add_filter (fc, filter);
 487
 488         filter = gtk_file_filter_new ();
 489         gtk_file_filter_set_name (filter, _("Lua files"));
 490         gtk_file_filter_add_pattern (filter, "*.lua");
 491         gtk_file_chooser_add_filter (fc, filter);
 492
 493         filter = gtk_file_filter_new ();
 494         gtk_file_filter_set_name (filter, _("Diff files"));
 495         gtk_file_filter_add_pattern (filter, "*.diff");
 496         gtk_file_filter_add_pattern (filter, "*.patch");
 497         gtk_file_filter_add_pattern (filter, "*.cvsdiff");
 498         gtk_file_chooser_add_filter (fc, filter);
 499 }
 500
 501 static GtkWidget*
 502 create_file_open_dialog_gui(GtkWindow* parent, AnjutaFileLoaderPlugin* plugin)
 503 {
 504         GtkWidget* dialog =
 505                 gtk_file_chooser_dialog_new (_("Open file"),
 506                                                                         parent,
 507                                                                         GTK_FILE_CHOOSER_ACTION_OPEN,
 508                                                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 509                                                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 510                                                                         NULL);
 511         gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(dialog), TRUE);
 512         gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
 513         setup_file_filters (GTK_FILE_CHOOSER (dialog));
 514
 515         g_signal_connect(G_OBJECT(dialog), "response",
 516                                         G_CALLBACK(on_open_response_ok), plugin);
 517         g_signal_connect_swapped (GTK_OBJECT (dialog),
 518                              "response",
 519                              G_CALLBACK (gtk_widget_destroy),
 520                              GTK_OBJECT (dialog));
 521         return dialog;
 522 }
 523
 524 static void
 525 on_open_activate (GtkAction *action, AnjutaFileLoaderPlugin *plugin)
 526 {
 527         GtkWidget *dlg;
 528
 529         dlg =
 530                 create_file_open_dialog_gui (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
 531                                                                          plugin);
 532         gtk_widget_show (dlg);
 533 }
 534
 535 static void
 536 on_new_activate (GtkAction *action, gpointer data)
 537 {
 538         IAnjutaDocumentManager *docman;
 539         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (data)->shell,
 540                                                                                  IAnjutaDocumentManager, NULL);
 541         if (docman)
 542         {
 543                 ianjuta_document_manager_add_buffer (docman, "", "", NULL);
 544         }
 545 }
 546
 547 static void
 548 on_activate_wizard (GtkMenuItem *menuitem,
 549                                         AnjutaFileLoaderPlugin *loader)
 550 {
 551         AnjutaPluginManager *plugin_manager;
 552         AnjutaPluginDescription *desc;
 553
 554         desc = g_object_get_data (G_OBJECT (menuitem), "__plugin_desc");
 555         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (loader)->shell,
 556                                                                                                           NULL);
 557         if (desc)
 558         {
 559                 gchar *id;
 560                 GObject *plugin;
 561
 562                 if (anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 563                                                                                                   "Location", &id))
 564                 {
 565                         plugin =
 566                                 anjuta_plugin_manager_get_plugin_by_id (plugin_manager, id);
 567                         ianjuta_wizard_activate (IANJUTA_WIZARD (plugin), NULL);
 568                 }
 569         }
 570 }
 571
 572 static GtkWidget*
 573 on_create_submenu (gpointer user_data)
 574 {
 575         AnjutaPluginManager *plugin_manager;
 576         AnjutaFileLoaderPlugin *loader;
 577         GList *node;
 578         gint count;
 579         GtkWidget *submenu = NULL;
 580         GList *plugin_descs = NULL;
 581
 582         loader = ANJUTA_PLUGIN_FILE_LOADER (user_data);
 583         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (loader)->shell,
 584                                                                                                           NULL);
 585         submenu = gtk_menu_new ();
 586         gtk_widget_show (submenu);
 587
 588         plugin_descs = anjuta_plugin_manager_query (plugin_manager,
 589                                                                                                 "Anjuta Plugin",
 590                                                                                                 "Interfaces", "IAnjutaWizard",
 591                                                                                                 NULL);
 592         plugin_descs = g_list_sort(plugin_descs, sort_wizards);
 593         node = plugin_descs;
 594         count = 0;
 595         while (node)
 596         {
 597                 AnjutaPluginDescription *desc;
 598                 GtkWidget *menuitem;
 599                 GtkWidget *icon;
 600                 gchar *str, *icon_path, *name;
 601
 602                 desc = node->data;
 603
 604                 icon = NULL;
 605                 name = NULL;
 606                 if (anjuta_plugin_description_get_string (desc, "Wizard",
 607                                                                                                   "Title", &str) ||
 608                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 609                                                                                                   "Name", &str))
 610                 {
 611                         count++;
 612                         if (count < 10)
 613                                 name = g_strdup_printf ("_%d. %s", count, str);
 614                         else
 615                                 name = g_strdup_printf ("%d. %s", count, str);
 616                         g_free (str);
 617                 }
 618                 if (anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 619                                                                                                   "Icon", &str))
 620                 {
 621                         GdkPixbuf *pixbuf, *scaled_pixbuf;
 622                         gint height, width;
 623
 624                         gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (submenu),
 625                                                                                            GTK_ICON_SIZE_MENU,
 626                                                                                            &width, &height);
 627                         icon_path = g_build_filename (PACKAGE_PIXMAPS_DIR, str, NULL);
 628                         pixbuf = gdk_pixbuf_new_from_file (icon_path, NULL);
 629                         if (pixbuf)
 630                         {
 631                                 scaled_pixbuf = gdk_pixbuf_scale_simple (pixbuf, width, height,
 632                                                                                                                  GDK_INTERP_BILINEAR);
 633                                 icon = gtk_image_new_from_pixbuf (scaled_pixbuf);
 634                 g_object_unref (pixbuf);
 635                                 g_object_unref (scaled_pixbuf);
 636                         }
 637                         else
 638                                 icon = gtk_image_new ();
 639
 640                         gtk_widget_show (icon);
 641                         g_free (icon_path);
 642                         g_free (str);
 643                 }
 644                 if (name)
 645                 {
 646                         menuitem = gtk_image_menu_item_new_with_mnemonic (name);
 647                         gtk_widget_show (menuitem);
 648                         g_object_set_data (G_OBJECT (menuitem), "__plugin_desc", desc);
 649                         g_signal_connect (G_OBJECT (menuitem), "activate",
 650                                                           G_CALLBACK (on_activate_wizard),
 651                                                           loader);
 652                         if (icon)
 653                                 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
 654                                                                                            icon);
 655                         gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem);
 656                 }
 657                 node = g_list_next (node);
 658         }
 659         g_list_free (plugin_descs);
 660         return submenu;
 661 }
 662
 663 /*
 664 static void
 665 on_recent_files_tooltip (GtkTooltips *tooltips, GtkWidget *menu_item,
 666                                                  EggRecentItem *item, gpointer user_data)
 667 {
 668         char *uri, *tip;
 669
 670         uri = egg_recent_item_get_uri_for_display (item);
 671         tip = g_strdup_printf ("Open '%s'", uri);
 672
 673         gtk_tooltips_set_tip (tooltips, menu_item, tip, NULL);
 674
 675         g_free (uri);
 676 }
 677 */
 678
 679 static void
 680 open_file_with (AnjutaFileLoaderPlugin *plugin, GtkMenuItem *menuitem,
 681                                 const gchar *uri)
 682 {
 683         GList *mime_apps;
 684         GnomeVFSMimeApplication *mime_app;
 685         gchar *mime_type;
 686         gint idx;
 687         AnjutaPluginDescription *desc;
 688         AnjutaPluginManager *plugin_manager;
 689
 690         idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem), "index"));
 691         desc = (AnjutaPluginDescription*) g_object_get_data (G_OBJECT (menuitem),
 692                                                                                                                  "desc");
 693         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (plugin)->shell,
 694                                                                                                           NULL);
 695         mime_type = anjuta_util_get_uri_mime_type (uri);
 696         mime_apps = gnome_vfs_mime_get_all_applications (mime_type);
 697
 698         /* Open with plugin */
 699         if (desc)
 700         {
 701                 gchar *location = NULL;
 702
 703                 anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 704                                                                                           "Location", &location);
 705                 g_assert (location != NULL);
 706                 if (location != NULL)
 707                 {
 708                         GObject *loaded_plugin;
 709
 710                         loaded_plugin =
 711                                 anjuta_plugin_manager_get_plugin_by_id (plugin_manager,
 712                                                                                                                 location);
 713                         if (loaded_plugin)
 714                         {
 715                                 ianjuta_file_open (IANJUTA_FILE (loaded_plugin), uri, NULL);
 716                                 set_recent_file (plugin, uri, mime_type);
 717                         }
 718                         else
 719                         {
 720                                 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN(plugin)->shell),
 721                                                                                   _("Failed to activate plugin: %s"),
 722                                                                                   location);
 723                         }
 724                         g_free (location);
 725                 }
 726         }
 727         else
 728         {
 729                 GList *uris = NULL;
 730                 GnomeVFSResult res;
 731
 732                 mime_app = g_list_nth_data (mime_apps, idx);
 733                 uris = g_list_prepend (uris, (gpointer)uri);
 734                 res = gnome_vfs_mime_application_launch (mime_app, uris);
 735                 if (res != GNOME_VFS_OK)
 736                         launch_application_failure (plugin, uri, res);
 737                 else
 738                         set_recent_file (plugin, uri, mime_type);
 739                 g_list_free (uris);
 740         }
 741         gnome_vfs_mime_application_list_free (mime_apps);
 742         g_free (mime_type);
 743 }
 744
 745 static void
 746 fm_open (GtkAction *action, AnjutaFileLoaderPlugin *plugin)
 747 {
 748         if (plugin->fm_current_uri)
 749                 open_file (plugin, plugin->fm_current_uri);
 750 }
 751
 752 static void
 753 fm_open_with (GtkMenuItem *menuitem, AnjutaFileLoaderPlugin *plugin)
 754 {
 755         if (plugin->fm_current_uri)
 756                 open_file_with (plugin, menuitem, plugin->fm_current_uri);
 757 }
 758
 759 static void
 760 pm_open (GtkAction *action, AnjutaFileLoaderPlugin *plugin)
 761 {
 762         if (plugin->pm_current_uri)
 763                 open_file (plugin, plugin->pm_current_uri);
 764 }
 765
 766 static void
 767 pm_open_with (GtkMenuItem *menuitem, AnjutaFileLoaderPlugin *plugin)
 768 {
 769         if (plugin->pm_current_uri)
 770                 open_file_with (plugin, menuitem, plugin->pm_current_uri);
 771 }
 772
 773 static GtkActionEntry actions_file[] = {
 774         {
 775                 "ActionFileNew",
 776                 GTK_STOCK_NEW,
 777                 N_("_New..."),
 778                 "<control>n",
 779                 N_("New empty editor."),
 780                 G_CALLBACK (on_new_activate)
 781         },
 782         {
 783                 "ActionFileOpen",
 784                 GTK_STOCK_OPEN,
 785                 N_("_Open..."),
 786                 "<control>o",
 787                 N_("Open file"),
 788                 G_CALLBACK (on_open_activate)
 789         }
 790 };
 791
 792 static GtkActionEntry popup_actions_file[] = {
 793         {
 794                 "ActionPopupOpen",
 795                 GTK_STOCK_OPEN,
 796                 N_("_Open"), NULL,
 797                 N_("Open file"),
 798                 G_CALLBACK (fm_open)
 799         },
 800         {
 801                 "ActionPopupOpenWith",
 802                 NULL,
 803                 N_("Open _With"), NULL,
 804                 N_("Open with"), NULL
 805         },
 806         {
 807                 "ActionPopupPMOpen",
 808                 GTK_STOCK_OPEN,
 809                 N_("_Open"), NULL,
 810                 N_("Open file"),
 811                 G_CALLBACK (pm_open)
 812         },
 813         {
 814                 "ActionPopupPMOpenWith",
 815                 NULL,
 816                 N_("Open _With"), NULL,
 817                 N_("Open with"), NULL
 818         }
 819 };
 820
 821 static gboolean
 822 create_open_with_submenu (AnjutaFileLoaderPlugin *plugin, GtkWidget *parentmenu,
 823                                                   const gchar *uri, GCallback callback,
 824                                                   gpointer callback_data)
 825 {
 826         GList *mime_apps, *node;
 827         GnomeVFSMimeApplication *mime_app;
 828         GList *plugin_descs, *snode;
 829         GtkWidget *menu, *menuitem;
 830         gchar *mime_type;
 831         gint idx;
 832         gboolean ret;
 833
 834         g_return_val_if_fail (GTK_IS_MENU_ITEM (parentmenu), FALSE);
 835
 836         menu = gtk_menu_new ();
 837         gtk_widget_show (menu);
 838         gtk_menu_item_set_submenu (GTK_MENU_ITEM (parentmenu), menu);
 839
 840         mime_type = anjuta_util_get_uri_mime_type (uri);
 841         if (mime_type == NULL)
 842                 return FALSE;
 843
 844         idx = 0;
 845
 846         /* Open with plugins menu items */
 847         plugin_descs = get_available_plugins_for_mime (plugin, mime_type);
 848         snode = plugin_descs;
 849         while (snode)
 850         {
 851                 gchar *name;
 852                 AnjutaPluginDescription *desc;
 853
 854                 desc = (AnjutaPluginDescription *)(snode->data);
 855                 name = NULL;
 856                 anjuta_plugin_description_get_string (desc, "File Loader",
 857                                                                                           "Title", &name);
 858                 if (!name)
 859                 {
 860                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 861                                                                                                   "Name", &name);
 862                 }
 863                 if (!name)
 864                 {
 865                         anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
 866                                                                                                   "Location", &name);
 867                 }
 868                 menuitem = gtk_menu_item_new_with_label (name);
 869                 g_object_set_data (G_OBJECT (menuitem), "index", GINT_TO_POINTER (idx));
 870                 g_object_set_data (G_OBJECT (menuitem), "desc", (gpointer)(desc));
 871                 g_signal_connect (G_OBJECT (menuitem), "activate",
 872                                                   G_CALLBACK (callback), callback_data);
 873                 gtk_menu_append (menu, menuitem);
 874                 g_free (name);
 875                 snode = g_list_next (snode);
 876                 idx++;
 877         }
 878
 879         /* Open with applications */
 880         mime_apps = gnome_vfs_mime_get_all_applications (mime_type);
 881         if (idx > 0 && mime_apps)
 882         {
 883                 menuitem = gtk_menu_item_new ();
 884                 gtk_menu_append (menu, menuitem);
 885                 idx++;
 886         }
 887         g_free (mime_type);
 888         idx = 0;
 889         node = mime_apps;
 890         while (node)
 891         {
 892                 mime_app = (GnomeVFSMimeApplication *)(node->data);
 893                 menuitem = gtk_menu_item_new_with_label (mime_app->name);
 894                 g_object_set_data (G_OBJECT (menuitem), "index", GINT_TO_POINTER (idx));
 895                 g_signal_connect (G_OBJECT (menuitem), "activate",
 896                                                   G_CALLBACK (callback), callback_data);
 897                 gtk_menu_append (menu, menuitem);
 898                 node = g_list_next (node);
 899                 idx++;
 900         }
 901         gtk_widget_show_all (menu);
 902
 903         if (mime_apps == NULL && plugin_descs == NULL)
 904                 ret = FALSE;
 905         else
 906                 ret = TRUE;
 907
 908         gnome_vfs_mime_application_list_free (mime_apps);
 909         if (plugin_descs)
 910                 g_list_free (plugin_descs);
 911
 912         return ret;
 913 }
 914
 915 static void
 916 value_added_fm_current_uri (AnjutaPlugin *plugin, const char *name,
 917                                                         const GValue *value, gpointer data)
 918 {
 919         AnjutaUI *ui;
 920         const gchar *uri;
 921         AnjutaFileLoaderPlugin *fl_plugin;
 922         GtkAction *action;
 923         GtkWidget *parentmenu;
 924
 925         uri = g_value_get_string (value);
 926         g_return_if_fail (name != NULL);
 927
 928         fl_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
 929         ui = anjuta_shell_get_ui (plugin->shell, NULL);
 930
 931         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader", "ActionPopupOpen");
 932         g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
 933
 934         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader",
 935                                                                    "ActionPopupOpenWith");
 936         g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
 937
 938         if (fl_plugin->fm_current_uri)
 939                 g_free (fl_plugin->fm_current_uri);
 940         fl_plugin->fm_current_uri = g_strdup (uri);
 941
 942         parentmenu =
 943                 gtk_ui_manager_get_widget (GTK_UI_MANAGER(ui),
 944                                         "/PopupFileManager/PlaceholderPopupFileOpen/OpenWith");
 945         if (!create_open_with_submenu (fl_plugin, parentmenu, uri,
 946                                                                    G_CALLBACK (fm_open_with), plugin))
 947                 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
 948 }
 949
 950 static void
 951 value_removed_fm_current_uri (AnjutaPlugin *plugin,
 952                                                           const char *name, gpointer data)
 953 {
 954         AnjutaUI *ui;
 955         GtkAction *action;
 956         AnjutaFileLoaderPlugin *fl_plugin;
 957
 958         fl_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
 959
 960         if (fl_plugin->fm_current_uri)
 961                 g_free (fl_plugin->fm_current_uri);
 962         fl_plugin->fm_current_uri = NULL;
 963
 964         ui = anjuta_shell_get_ui (plugin->shell, NULL);
 965         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader", "ActionPopupOpen");
 966         g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
 967
 968         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader",
 969                                                                    "ActionPopupOpenWith");
 970         g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
 971 }
 972
 973 static void
 974 value_added_pm_current_uri (AnjutaPlugin *plugin, const char *name,
 975                                                         const GValue *value, gpointer data)
 976 {
 977         AnjutaUI *ui;
 978         const gchar *uri;
 979         AnjutaFileLoaderPlugin *fl_plugin;
 980         GtkAction *action;
 981         GtkWidget *parentmenu;
 982
 983         uri = g_value_get_string (value);
 984         g_return_if_fail (name != NULL);
 985
 986         fl_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
 987         ui = anjuta_shell_get_ui (plugin->shell, NULL);
 988
 989         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader", "ActionPopupPMOpen");
 990         g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
 991
 992         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader",
 993                                                                    "ActionPopupPMOpenWith");
 994         g_object_set (G_OBJECT (action), "sensitive", TRUE, NULL);
 995
 996         if (fl_plugin->pm_current_uri)
 997                 g_free (fl_plugin->pm_current_uri);
 998         fl_plugin->pm_current_uri = g_strdup (uri);
 999
1000         parentmenu =
1001                 gtk_ui_manager_get_widget (GTK_UI_MANAGER(ui),
1002                                         "/PopupProjectManager/PlaceholderPopupProjectOpen/OpenWith");
1003         if (!create_open_with_submenu (fl_plugin, parentmenu, uri,
1004                                                                    G_CALLBACK (pm_open_with), plugin))
1005                 g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
1006 }
1007
1008 static void
1009 value_removed_pm_current_uri (AnjutaPlugin *plugin,
1010                                                           const char *name, gpointer data)
1011 {
1012         AnjutaUI *ui;
1013         GtkAction *action;
1014         AnjutaFileLoaderPlugin *fl_plugin;
1015
1016         fl_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
1017
1018         if (fl_plugin->pm_current_uri)
1019                 g_free (fl_plugin->pm_current_uri);
1020         fl_plugin->pm_current_uri = NULL;
1021
1022         ui = anjuta_shell_get_ui (plugin->shell, NULL);
1023         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader", "ActionPopupPMOpen");
1024         g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
1025
1026         action = anjuta_ui_get_action (ui, "ActionGroupPopupLoader",
1027                                                                    "ActionPopupPMOpenWith");
1028         g_object_set (G_OBJECT (action), "sensitive", FALSE, NULL);
1029 }
1030
1031 static void
1032 dnd_dropped (const gchar *uri, gpointer plugin)
1033 {
1034         ianjuta_file_loader_load (IANJUTA_FILE_LOADER (plugin), uri, FALSE, NULL);
1035 }
1036
1037 static void
1038 on_session_load (AnjutaShell *shell, AnjutaSessionPhase phase,
1039                                  AnjutaSession *session,
1040                                  AnjutaFileLoaderPlugin *plugin)
1041 {
1042         AnjutaStatus *status;
1043         const gchar *uri;
1044         gchar *mime_type;
1045         GList *files, *node;
1046         gint i;
1047
1048         /* We want to load the files first before other session loads */
1049         if (phase != ANJUTA_SESSION_PHASE_FIRST)
1050                 return;
1051
1052         files = anjuta_session_get_string_list (session, "File Loader", "Files");
1053         if (!files)
1054                 return;
1055
1056         status = anjuta_shell_get_status (shell, NULL);
1057         anjuta_status_progress_add_ticks (status, g_list_length(files));
1058
1059         /* Open project files first and then regular files */
1060         for (i = 0; i < 2; i++)
1061         {
1062                 node = files;
1063                 while (node)
1064                 {
1065                         uri = node->data;
1066                         if (uri)
1067                         {
1068                                 gchar *label, *filename;
1069
1070                                 mime_type = anjuta_util_get_uri_mime_type (uri);
1071
1072                                 filename = g_path_get_basename (uri);
1073                                 if (strchr (filename, '#'))
1074                                         *(strchr (filename, '#')) = '\0';
1075
1076                                 label = g_strconcat ("Loaded: ", filename, NULL);
1077
1078                                 if (i == 0 && mime_type &&
1079                                         strcmp (mime_type, "application/x-anjuta") == 0)
1080                                 {
1081                                         /* Project files first */
1082                                         /* FIXME: Ignore project files for now */
1083                                         /*
1084                                         ianjuta_file_loader_load (IANJUTA_FILE_LOADER (plugin),
1085                                                                                           uri, FALSE, NULL);
1086                                         */
1087                                         anjuta_status_progress_tick (status, NULL, label);
1088                                 }
1089                                 else if (i != 0 &&
1090                                                  (!mime_type ||
1091                                                   strcmp (mime_type, "application/x-anjuta") != 0))
1092                                 {
1093                                         /* Then rest of the files */
1094                                         ianjuta_file_loader_load (IANJUTA_FILE_LOADER (plugin),
1095                                                                                           uri, FALSE, NULL);
1096                                         anjuta_status_progress_tick (status, NULL, label);
1097                                 }
1098                                 g_free (filename);
1099                                 g_free (label);
1100                                 g_free (mime_type);
1101                         }
1102                         node = g_list_next (node);
1103                 }
1104         }
1105         if (files)
1106         {
1107                 g_list_foreach (files, (GFunc)g_free, NULL);
1108                 g_list_free (files);
1109         }
1110 }
1111
1112 static gboolean
1113 activate_plugin (AnjutaPlugin *plugin)
1114 {
1115         EggSubmenuAction *saction;
1116         GtkAction *action;
1117         AnjutaUI *ui;
1118         AnjutaFileLoaderPlugin *loader_plugin;
1119         // GtkWidget *recent_menu;
1120         // EggRecentViewGtk *recent_view;
1121         GtkActionGroup *group;
1122
1123         loader_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
1124
1125         DEBUG_PRINT ("AnjutaFileLoaderPlugin: Activating File Loader plugin...");
1126
1127         ui = anjuta_shell_get_ui (plugin->shell, NULL);
1128
1129         /* Add action group */
1130         loader_plugin->action_group =
1131                 anjuta_ui_add_action_group_entries (ui, "ActionGroupLoader",
1132                                                                                         _("File Loader"),
1133                                                                                         actions_file,
1134                                                                                         G_N_ELEMENTS (actions_file),
1135                                                                                         GETTEXT_PACKAGE, TRUE, plugin);
1136         loader_plugin->popup_action_group =
1137                 anjuta_ui_add_action_group_entries (ui, "ActionGroupPopupLoader",
1138                                                                                         _("File Loader"),
1139                                                                                         popup_actions_file,
1140                                                                                         G_N_ELEMENTS (popup_actions_file),
1141                                                                                         GETTEXT_PACKAGE, FALSE, plugin);
1142         saction = g_object_new (EGG_TYPE_SUBMENU_ACTION,
1143                                                         "name", "ActionFileWizard",
1144                                                         "label", _("New"),
1145                                                         "tooltip", _("New file, project and project components."),
1146                                                         NULL);
1147         egg_submenu_action_set_menu_factory (saction,
1148                                                                                  on_create_submenu, plugin);
1149         gtk_action_group_add_action (loader_plugin->action_group,
1150                                                                  GTK_ACTION (saction));
1151
1152         /* Set short labels */
1153         action = anjuta_ui_get_action (ui, "ActionGroupLoader", "ActionFileNew");
1154         g_object_set (G_OBJECT (action), "short-label", _("New"),
1155                                   "is-important", TRUE, NULL);
1156         action = anjuta_ui_get_action (ui, "ActionGroupLoader", "ActionFileOpen");
1157         g_object_set (G_OBJECT (action), "short-label", _("Open"),
1158                                   "is-important", TRUE, NULL);
1159
1160         group = gtk_action_group_new ("ActionGroupLoaderRecent");
1161         action = g_object_new (EGG_TYPE_RECENT_ACTION,
1162                                                    "name", "ActionFileOpenRecent",
1163                                                    "label", _("Open _Recent"),
1164                                                    "tooltip", _("Open recent file"),
1165                                                         NULL);
1166         egg_recent_action_add_model (EGG_RECENT_ACTION (action),
1167                                                                  loader_plugin->recent_files_model_top);
1168         egg_recent_action_add_model (EGG_RECENT_ACTION (action),
1169                                                                  loader_plugin->recent_files_model_bottom);
1170         g_signal_connect (action, "activate",
1171                                           G_CALLBACK (on_open_recent_file), plugin);
1172         gtk_action_group_add_action (group, action);
1173         anjuta_ui_add_action_group (ui, "ActionGroupLoaderRecent",
1174                                                                 N_("Open recent files"), group, FALSE);
1175         loader_plugin->recent_group = group;
1176
1177         /* Add UI */
1178         loader_plugin->uiid = anjuta_ui_merge (ui, UI_FILE);
1179
1180         /* Install drag n drop handler */
1181         dnd_drop_init (GTK_WIDGET (plugin->shell), dnd_dropped, plugin,
1182                                    "text/plain", "text/html", "text/source", "application-x/anjuta",
1183                                    NULL);
1184
1185         /* Add watches */
1186         loader_plugin->fm_watch_id =
1187                 anjuta_plugin_add_watch (plugin, "file_manager_current_uri",
1188                                                                  value_added_fm_current_uri,
1189                                                                  value_removed_fm_current_uri, NULL);
1190         loader_plugin->pm_watch_id =
1191                 anjuta_plugin_add_watch (plugin, "project_manager_current_uri",
1192                                                                  value_added_pm_current_uri,
1193                                                                  value_removed_pm_current_uri, NULL);
1194
1195         /* Connect to session */
1196         g_signal_connect (G_OBJECT (plugin->shell), "load_session",
1197                                           G_CALLBACK (on_session_load), plugin);
1198         return TRUE;
1199 }
1200
1201 static gboolean
1202 deactivate_plugin (AnjutaPlugin *plugin)
1203 {
1204         AnjutaUI *ui;
1205         AnjutaFileLoaderPlugin *loader_plugin;
1206
1207         loader_plugin = ANJUTA_PLUGIN_FILE_LOADER (plugin);
1208
1209         DEBUG_PRINT ("AnjutaFileLoaderPlugin: Deactivating File Loader plugin...");
1210
1211         /* Disconnect session */
1212         g_signal_handlers_disconnect_by_func (G_OBJECT (plugin->shell),
1213                                                                                   G_CALLBACK (on_session_load), plugin);
1214
1215         ui = anjuta_shell_get_ui (plugin->shell, NULL);
1216         /* Remove watches */
1217         anjuta_plugin_remove_watch (plugin, loader_plugin->fm_watch_id, TRUE);
1218         anjuta_plugin_remove_watch (plugin, loader_plugin->pm_watch_id, TRUE);
1219         /* Uninstall dnd */
1220         dnd_drop_finalize (GTK_WIDGET (plugin->shell), plugin);
1221         /* Remove UI */
1222         anjuta_ui_unmerge (ui, loader_plugin->uiid);
1223         /* Remove action group */
1224         anjuta_ui_remove_action_group (ui, loader_plugin->action_group);
1225         anjuta_ui_remove_action_group (ui, loader_plugin->popup_action_group);
1226         anjuta_ui_remove_action_group (ui, loader_plugin->recent_group);
1227         return TRUE;
1228 }
1229
1230 static void
1231 dispose (GObject *obj)
1232 {
1233         AnjutaFileLoaderPlugin *plugin = ANJUTA_PLUGIN_FILE_LOADER (obj);
1234         if (plugin->recent_files_model_top)
1235         {
1236                 g_object_unref (plugin->recent_files_model_top);
1237                 plugin->recent_files_model_top = NULL;
1238         }
1239         if (plugin->recent_files_model_bottom)
1240         {
1241                 g_object_unref (plugin->recent_files_model_bottom);
1242                 plugin->recent_files_model_bottom = NULL;
1243         }
1244         GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (obj));
1245 }
1246
1247 static void
1248 anjuta_file_loader_plugin_instance_init (GObject *obj)
1249 {
1250         AnjutaFileLoaderPlugin *plugin = ANJUTA_PLUGIN_FILE_LOADER (obj);
1251
1252         plugin->fm_current_uri = NULL;
1253         plugin->pm_current_uri = NULL;
1254
1255         plugin->recent_files_model_top =
1256                 egg_recent_model_new (EGG_RECENT_MODEL_SORT_MRU);
1257         egg_recent_model_set_limit (plugin->recent_files_model_top, 5);
1258         egg_recent_model_set_filter_groups (plugin->recent_files_model_top,
1259                                                                                 "anjuta-projects", NULL);
1260         plugin->recent_files_model_bottom =
1261                 egg_recent_model_new (EGG_RECENT_MODEL_SORT_MRU);
1262         egg_recent_model_set_limit (plugin->recent_files_model_bottom, 15);
1263         egg_recent_model_set_filter_groups (plugin->recent_files_model_bottom,
1264                                                                                 "anjuta-files", NULL);
1265 }
1266
1267 static void
1268 anjuta_file_loader_plugin_class_init (GObjectClass *klass)
1269 {
1270         AnjutaPluginClass *plugin_class = ANJUTA_PLUGIN_CLASS (klass);
1271
1272         parent_class = g_type_class_peek_parent (klass);
1273
1274         plugin_class->activate = activate_plugin;
1275         plugin_class->deactivate = deactivate_plugin;
1276         klass->dispose = dispose;
1277 }
1278
1279 static GObject*
1280 iloader_load (IAnjutaFileLoader *loader, const gchar *uri,
1281                           gboolean read_only, GError **err)
1282 {
1283         gchar *mime_type;
1284         gchar *new_uri;
1285         GnomeVFSURI* vfs_uri;
1286         AnjutaStatus *status;
1287         AnjutaPluginManager *plugin_manager;
1288         GList *plugin_descs = NULL;
1289         GObject *plugin = NULL;
1290
1291         g_return_val_if_fail (uri != NULL, NULL);
1292         vfs_uri = gnome_vfs_uri_new (uri);
1293
1294         if (!gnome_vfs_uri_exists (vfs_uri))
1295         {
1296                 launch_application_failure (ANJUTA_PLUGIN_FILE_LOADER (loader),
1297                                                                         uri, GNOME_VFS_ERROR_NOT_FOUND);
1298                 gnome_vfs_uri_unref (vfs_uri);
1299                 return NULL;
1300         }
1301
1302         new_uri = gnome_vfs_uri_to_string (vfs_uri,
1303                                                                            GNOME_VFS_URI_HIDE_FRAGMENT_IDENTIFIER);
1304         mime_type = anjuta_util_get_uri_mime_type (new_uri);
1305         gnome_vfs_uri_unref (vfs_uri);
1306
1307         if (mime_type == NULL)
1308         {
1309                 launch_application_failure (ANJUTA_PLUGIN_FILE_LOADER (loader),
1310                                                                         new_uri, GNOME_VFS_ERROR_NOT_FOUND);
1311                 g_free (new_uri);
1312                 return NULL;
1313         }
1314
1315         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN (loader)->shell,
1316                                                                                                           NULL);
1317         status = anjuta_shell_get_status (ANJUTA_PLUGIN (loader)->shell, NULL);
1318         anjuta_status_busy_push (status);
1319
1320         DEBUG_PRINT ("Opening URI: %s", uri);
1321
1322         plugin_descs = anjuta_plugin_manager_query (plugin_manager,
1323                                                                                                 "Anjuta Plugin",
1324                                                                                                 "Interfaces", "IAnjutaFile",
1325                                                                                                 "File Loader",
1326                                                                                                 "SupportedMimeTypes",
1327                                                                                                 mime_type,
1328                                                                                                 NULL);
1329
1330         if (g_list_length (plugin_descs) > 1)
1331         {
1332                 plugin =
1333                         anjuta_plugin_manager_select_and_activate (plugin_manager,
1334                                                                                                            "Open With",
1335                                                                 "Please select a plugin to open this file.",
1336                                                                                                            plugin_descs);
1337         }
1338         else if (g_list_length (plugin_descs) == 1)
1339         {
1340                 gchar *location = NULL;
1341
1342                 AnjutaPluginDescription *desc = plugin_descs->data;
1343                 anjuta_plugin_description_get_string (desc, "Anjuta Plugin",
1344                                                                                           "Location", &location);
1345                 g_return_val_if_fail (location != NULL, NULL);
1346                 plugin =
1347                         anjuta_plugin_manager_get_plugin_by_id (plugin_manager,
1348                                                                                                         location);
1349                 g_free (location);
1350         }
1351         else
1352         {
1353                 launch_in_default_application (ANJUTA_PLUGIN_FILE_LOADER (loader), mime_type, uri);
1354         }
1355         if (plugin)
1356                 ianjuta_file_open (IANJUTA_FILE(plugin), uri, NULL);
1357
1358         set_recent_file (ANJUTA_PLUGIN_FILE_LOADER (loader), new_uri, mime_type);
1359
1360         if (plugin_descs)
1361                 g_list_free (plugin_descs);
1362         g_free (mime_type);
1363         g_free (new_uri);
1364         anjuta_status_busy_pop (status);
1365
1366         return plugin;
1367 }
1368
1369 static void
1370 iloader_iface_init(IAnjutaLoaderIface *iface)
1371 {
1372         iface->find_plugins = NULL;
1373 }
1374
1375 static void
1376 iloader_file_iface_init(IAnjutaFileLoaderIface *iface)
1377 {
1378         iface->load = iloader_load;
1379 }
1380
1381 ANJUTA_PLUGIN_BEGIN (AnjutaFileLoaderPlugin, anjuta_file_loader_plugin);
1382 ANJUTA_PLUGIN_ADD_INTERFACE (iloader, IANJUTA_TYPE_LOADER);
1383 ANJUTA_PLUGIN_ADD_INTERFACE (iloader_file, IANJUTA_TYPE_FILE_LOADER);
1384 ANJUTA_PLUGIN_END;
1385
1386 ANJUTA_SIMPLE_PLUGIN (AnjutaFileLoaderPlugin, anjuta_file_loader_plugin);