plugins/project-import/project-import.c

   1 /*
   2  *  project-import.c (c) 2005 Johannes Schmid
   3  *  This program is free software; you can redistribute it and/or modify
   4  *  it under the terms of the GNU General Public License as published by
   5  *  the Free Software Foundation; either version 2 of the License, or
   6  *  (at your option) any later version.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU Library General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public License
  14  *  along with this program; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  */
  17
  18 #include "project-import.h"
  19 #include <gnome.h>
  20 #include <libgnomevfs/gnome-vfs.h>
  21 #include <libanjuta/interfaces/ianjuta-file-loader.h>
  22
  23 #include <config.h>
  24
  25 #include <gbf/gbf-backend.h>
  26
  27 #define GLADE_FILE PACKAGE_DATA_DIR"/glade/anjuta-project-import.glade"
  28 #define AM_PROJECT_FILE PACKAGE_DATA_DIR"/project/terminal/project.anjuta"
  29 #define MKFILE_PROJECT_FILE PACKAGE_DATA_DIR"/project/mkfile/project.anjuta"
  30
  31 static GObjectClass *parent_class = NULL;
  32
  33 static void
  34 on_import_cancel (GnomeDruid* druid, ProjectImport* pi)
  35 {
  36         g_object_unref (G_OBJECT(pi));
  37 }
  38
  39 static gboolean
  40 on_import_key_press_event(GtkWidget *widget, GdkEventKey *event,
  41                           ProjectImport* pi)
  42 {
  43         if (event->keyval == GDK_Escape)
  44         {
  45                 g_object_unref(G_OBJECT(pi));
  46                 return TRUE;
  47         }
  48         return FALSE;
  49 }
  50
  51 static gboolean
  52 on_import_next(GnomeDruidPage* page, GtkWidget* druid, ProjectImport* pi)
  53 {
  54         GSList* l;
  55         GbfBackend* backend = NULL;
  56         GbfProject* proj;
  57
  58         const gchar* name = gtk_entry_get_text(GTK_ENTRY(pi->import_name));
  59         gchar* path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(pi->import_path));
  60
  61         if (!name || !path || !strlen(name) || !strlen(path))
  62         {
  63                 g_free (path);
  64                 return TRUE;
  65         }
  66
  67         gbf_backend_init();
  68
  69         for (l = gbf_backend_get_backends (); l; l = l->next) {
  70                 backend = l->data;
  71                 if (!backend)
  72                 {
  73                         g_warning("Backend appears empty!");
  74                         continue;
  75                 }
  76
  77                 /* Probe the backend to find out if the project directory is OK */
  78                 /* If probe() returns TRUE then we have a valid backend */
  79
  80                 proj = gbf_backend_new_project(backend->id);
  81                 if (proj)
  82                 {
  83                         if (gbf_project_probe(proj, path, NULL))
  84                         {
  85                                 /* This is a valid backend for this root directory */
  86                                 /* FIXME: Possibility of more than one valid backend? */
  87                                 g_object_unref(proj);
  88                                 break;
  89                         }
  90                         g_object_unref(proj);
  91                 }
  92                 backend = NULL;
  93         }
  94
  95         if (!backend)
  96         {
  97                 gchar* message_text =
  98                 g_strdup_printf(_("Could not find a valid project backend for the "
  99                                                   "directory given (%s). Please select a different "
 100                                                   "directory, or try upgrading to a newer version of "
 101                                                   "the Gnome Build Framework."), path);
 102
 103                 GtkDialog* message =
 104                 GTK_DIALOG(gtk_message_dialog_new(GTK_WINDOW(pi->window),
 105                                                                                   GTK_DIALOG_DESTROY_WITH_PARENT,
 106                                                                                   GTK_MESSAGE_ERROR,
 107                                                                                   GTK_BUTTONS_CLOSE,
 108                                                                                   message_text));
 109
 110                 g_free(message_text);
 111
 112                 gtk_dialog_run(message);
 113                 gtk_widget_destroy(GTK_WIDGET(message));
 114                 g_free (path);
 115                 return TRUE;
 116         }
 117
 118         gchar* summary;
 119
 120         summary = g_strdup_printf(_("Project name: %s\n"
 121                                                                 "Project type: %s\n"
 122                                                                 "Project path: %s\n"),
 123                                                                 name, backend->name, path);
 124         gnome_druid_page_edge_set_text(GNOME_DRUID_PAGE_EDGE(pi->import_finish),
 125                                                                    summary);
 126
 127         g_free(summary);
 128
 129         if (pi->backend_id)
 130                 g_free(pi->backend_id);
 131         pi->backend_id = g_strdup(backend->id);
 132         g_free (path);
 133
 134         return FALSE;
 135 }
 136
 137 static gboolean
 138 on_import_finish (GnomeDruidPage* page, GtkWidget* druid, ProjectImport* pi)
 139 {
 140         const gchar* name = gtk_entry_get_text (GTK_ENTRY(pi->import_name));
 141         gchar* path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(pi->import_path));
 142
 143         gchar* project_file = g_strconcat (path, "/", name, ".", "anjuta", NULL);
 144
 145         IAnjutaFileLoader* loader;
 146
 147         if (!project_import_generate_file (pi, project_file))
 148         {
 149                 g_free (project_file);
 150                 g_free (path);
 151                 return TRUE;
 152         }
 153
 154         loader = anjuta_shell_get_interface (ANJUTA_PLUGIN (pi->plugin)->shell,
 155                                              IAnjutaFileLoader, NULL);
 156         if (!loader)
 157         {
 158                 g_warning("No IAnjutaFileLoader interface! Cannot open project file!");
 159                 g_object_unref (G_OBJECT (pi));
 160                 g_free (project_file);
 161                 return FALSE;
 162         }
 163         ianjuta_file_loader_load (loader, project_file, FALSE, NULL);
 164         g_object_unref (G_OBJECT (pi));
 165         g_free (project_file);
 166         g_free (path);
 167         return FALSE;
 168 }
 169
 170 static void
 171 project_import_init(ProjectImport *pi)
 172 {
 173         GladeXML* gxml = glade_xml_new(GLADE_FILE, "import_window", NULL);
 174         GtkWidget* import_page;
 175
 176         pi->window = glade_xml_get_widget(gxml, "import_window");
 177         pi->druid = glade_xml_get_widget(gxml, "import_druid");
 178         pi->import_name = glade_xml_get_widget(gxml, "import_name");
 179         pi->import_path = glade_xml_get_widget(gxml, "import_path");
 180         pi->import_finish = glade_xml_get_widget(gxml, "import_finish");
 181
 182         pi->backend_id = NULL;
 183
 184         import_page = glade_xml_get_widget(gxml, "import_page");
 185         g_signal_connect(G_OBJECT(import_page), "next",
 186                                          G_CALLBACK(on_import_next), pi);
 187         g_signal_connect(G_OBJECT(pi->import_finish), "finish",
 188                                          G_CALLBACK(on_import_finish), pi);
 189         g_signal_connect(G_OBJECT(pi->druid), "cancel",
 190                                          G_CALLBACK(on_import_cancel), pi);
 191         g_signal_connect(G_OBJECT(pi->druid), "key-press-event",
 192                         G_CALLBACK(on_import_key_press_event), pi);
 193
 194         g_object_unref(G_OBJECT(gxml));
 195         gtk_widget_show_all(pi->window);
 196 }
 197
 198 static void
 199 project_import_finalize(GObject *object)
 200 {
 201         ProjectImport *cobj;
 202         cobj = PROJECT_IMPORT(object);
 203
 204         if (cobj->backend_id)
 205                 g_free(cobj->backend_id);
 206
 207         gtk_widget_destroy(cobj->window);
 208
 209         /* Deactivate plugin once wizard is finished */
 210         if (anjuta_plugin_is_active(cobj->plugin))
 211                 anjuta_plugin_deactivate (cobj->plugin);
 212         G_OBJECT_CLASS(parent_class)->finalize(object);
 213 }
 214
 215 static void
 216 project_import_class_init(ProjectImportClass *klass)
 217 {
 218         GObjectClass *object_class = G_OBJECT_CLASS(klass);
 219
 220         parent_class = g_type_class_peek_parent(klass);
 221         object_class->finalize = project_import_finalize;
 222 }
 223
 224 GType
 225 project_import_get_type()
 226 {
 227         static GType type = 0;
 228
 229         if(type == 0) {
 230                 static const GTypeInfo our_info = {
 231                         sizeof (ProjectImportClass),
 232                         NULL,
 233                         NULL,
 234                         (GClassInitFunc)project_import_class_init,
 235                         NULL,
 236                         NULL,
 237                         sizeof (ProjectImport),
 238                         0,
 239                         (GInstanceInitFunc)project_import_init,
 240                 };
 241
 242                 type = g_type_register_static(G_TYPE_OBJECT,
 243                         "ProjectImport", &our_info, 0);
 244         }
 245
 246         return type;
 247 }
 248
 249 ProjectImport *
 250 project_import_new(AnjutaPlugin* plugin)
 251 {
 252         ProjectImport *obj;
 253
 254         obj = PROJECT_IMPORT(g_object_new(PROJECT_IMPORT_TYPE, NULL));
 255
 256         obj->plugin = plugin;
 257         gtk_window_set_transient_for (GTK_WINDOW (obj->window),
 258                                                                   GTK_WINDOW (ANJUTA_PLUGIN (plugin)->shell));
 259
 260         return obj;
 261 }
 262
 263 void
 264 project_import_set_name (ProjectImport *pi, const gchar *name)
 265 {
 266         g_return_if_fail (IS_PROJECT_IMPORT (pi));
 267         g_return_if_fail (name != NULL);
 268
 269         gtk_entry_set_text (GTK_ENTRY (pi->import_name), name);
 270 }
 271
 272 void
 273 project_import_set_directory (ProjectImport *pi, const gchar *directory)
 274 {
 275         g_return_if_fail (IS_PROJECT_IMPORT (pi));
 276         g_return_if_fail (directory != NULL);
 277
 278         gchar* uri = gnome_vfs_make_uri_from_input (directory);
 279         gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (pi->import_path), uri);
 280         g_free (uri);
 281 }
 282
 283 gboolean
 284 project_import_generate_file(ProjectImport* pi, const gchar* prjfile)
 285 {
 286         /* Of course we could do some more intelligent stuff here
 287         and check which plugins are really needed but for now we just
 288         take a default project file. */
 289
 290         GnomeVFSURI* source_uri;
 291         if (!strcmp (pi->backend_id, "gbf-am:GbfAmProject"))
 292                 source_uri = gnome_vfs_uri_new(AM_PROJECT_FILE);
 293         else if (!strcmp (pi->backend_id, "gbf-mkfile:GbfMkfileProject"))
 294                 source_uri = gnome_vfs_uri_new(MKFILE_PROJECT_FILE);
 295         else
 296         {
 297                 /* We shouldn't get here, unless someone has upgraded their GBF */
 298                 /* but not Anjuta.                                              */
 299
 300                 GtkWidget *dlg;
 301
 302                 dlg = gtk_message_dialog_new(GTK_WINDOW(pi->window),
 303                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
 304                                                                          GTK_MESSAGE_ERROR,
 305                                                                          GTK_BUTTONS_CLOSE,
 306                                                                          _("Generation of project file failed. Cannot "
 307                                                                            "find an appropriate project template to "
 308                                                                            "use. Please make sure your version of "
 309                                                                            "Anjuta is up to date."));
 310
 311                 gtk_dialog_run(GTK_DIALOG(dlg));
 312                 gtk_widget_destroy (dlg);
 313                 return FALSE;
 314         }
 315
 316         GnomeVFSURI* dest_uri = gnome_vfs_uri_new(prjfile);
 317
 318         GnomeVFSResult error = gnome_vfs_xfer_uri (source_uri,
 319                                                 dest_uri,
 320                                                 GNOME_VFS_XFER_DEFAULT,
 321                                                 GNOME_VFS_XFER_ERROR_MODE_ABORT,
 322                                                 GNOME_VFS_XFER_OVERWRITE_MODE_ABORT,
 323                                                 NULL,
 324                                                 NULL);
 325         /* Handle already existing file */
 326         if (error == GNOME_VFS_ERROR_FILE_EXISTS)
 327         {
 328                 if (anjuta_util_dialog_boolean_question (GTK_WINDOW (pi->window),
 329                                 _("A file named \"%s\" already exists. "
 330                                   "Do you want to replace it?"), prjfile))
 331                 {
 332                         error = gnome_vfs_xfer_uri (source_uri,
 333                                         dest_uri,
 334                                         GNOME_VFS_XFER_DEFAULT,
 335                                         GNOME_VFS_XFER_ERROR_MODE_ABORT,
 336                                         GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE,
 337                                         NULL,
 338                                         NULL);
 339                 }
 340         }
 341
 342         /* Update file time if possible */
 343         if (error == GNOME_VFS_OK)
 344         {
 345                 GnomeVFSFileInfo *file_info;
 346
 347                 file_info = gnome_vfs_file_info_new ();
 348                 file_info->ctime = time (NULL);
 349                 file_info->mtime = file_info->ctime;
 350                 file_info->atime = file_info->ctime;
 351
 352                 gnome_vfs_set_file_info_uri (dest_uri,
 353                                              file_info,
 354                                              GNOME_VFS_SET_FILE_INFO_TIME);
 355
 356                 gnome_vfs_file_info_unref (file_info);
 357         }
 358
 359         gnome_vfs_uri_unref (source_uri);
 360         gnome_vfs_uri_unref (dest_uri);
 361
 362         switch (error)
 363         {
 364         case GNOME_VFS_OK:
 365                 break;
 366         case GNOME_VFS_ERROR_FILE_EXISTS:
 367                 return FALSE;
 368         default:
 369                 anjuta_util_dialog_error (GTK_WINDOW (pi->window),
 370                                 _("A file named \"%s\" cannot be written: %s.  "
 371                                   "Check if you have write access to the project directory."),
 372                                   prjfile, gnome_vfs_result_to_string (error));
 373
 374                 return FALSE;
 375         }
 376
 377         return TRUE;
 378 }