plugins/saveactions.c

   1 /*
   2  *      saveactions.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2007-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2007-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22
  23 #ifdef HAVE_CONFIG_H
  24 #       include "config.h"
  25 #endif
  26
  27 #include "geanyplugin.h"
  28 #include "gtkcompat.h"
  29
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <glib/gstdio.h>
  33
  34
  35 GeanyData               *geany_data;
  36 GeanyFunctions  *geany_functions;
  37
  38
  39 PLUGIN_VERSION_CHECK(GEANY_API_VERSION)
  40
  41 PLUGIN_SET_INFO(_("Save Actions"), _("This plugin provides different actions related to saving of files."),
  42         VERSION, _("The Geany developer team"))
  43
  44
  45 enum
  46 {
  47         NOTEBOOK_PAGE_AUTOSAVE = 0,
  48         NOTEBOOK_PAGE_INSTANTSAVE,
  49         NOTEBOOK_PAGE_BACKUPCOPY
  50 };
  51
  52 static struct
  53 {
  54         GtkWidget *checkbox_enable_autosave;
  55         GtkWidget *checkbox_enable_instantsave;
  56         GtkWidget *checkbox_enable_backupcopy;
  57
  58         GtkWidget *autosave_interval_spin;
  59         GtkWidget *autosave_print_msg_checkbox;
  60         GtkWidget *autosave_save_all_radio1;
  61         GtkWidget *autosave_save_all_radio2;
  62
  63         GtkWidget *instantsave_ft_combo;
  64
  65         GtkWidget *backupcopy_entry_dir;
  66         GtkWidget *backupcopy_entry_time;
  67         GtkWidget *backupcopy_spin_dir_levels;
  68 }
  69 pref_widgets;
  70
  71
  72 static gboolean enable_autosave;
  73 static gboolean enable_instantsave;
  74 static gboolean enable_backupcopy;
  75
  76 static gint autosave_interval;
  77 static gboolean autosave_print_msg;
  78 static gboolean autosave_save_all;
  79 static guint autosave_src_id = 0;
  80
  81 static gchar *instantsave_default_ft;
  82
  83 static gchar *backupcopy_backup_dir; /* path to an existing directory in locale encoding */
  84 static gchar *backupcopy_time_fmt;
  85 static gint backupcopy_dir_levels;
  86
  87 static gchar *config_file;
  88
  89
  90 /* Ensures utf8_dir exists and is writable and
  91  * set backup_dir to the locale encoded form of utf8_dir */
  92 static gboolean backupcopy_set_backup_dir(const gchar *utf8_dir)
  93 {
  94         gchar *tmp;
  95
  96         if (G_UNLIKELY(! NZV(utf8_dir)))
  97                 return FALSE;
  98
  99         tmp = utils_get_locale_from_utf8(utf8_dir);
 100
 101         if (! g_path_is_absolute(tmp) ||
 102                 ! g_file_test(tmp, G_FILE_TEST_EXISTS) ||
 103                 ! g_file_test(tmp, G_FILE_TEST_IS_DIR))
 104         {
 105                 g_free(tmp);
 106                 return FALSE;
 107         }
 108         /** TODO add utils_is_file_writeable() to the plugin API and make use of it **/
 109
 110         SETPTR(backupcopy_backup_dir, tmp);
 111
 112         return TRUE;
 113 }
 114
 115
 116 static gchar *backupcopy_skip_root(gchar *filename)
 117 {
 118         /* first skip the root (e.g. c:\ on windows) */
 119         const gchar *dir = g_path_skip_root(filename);
 120
 121         /* if this has failed, use the filename again */
 122         if (dir == NULL)
 123                 dir = filename;
 124         /* check again for leading / or \ */
 125         while (*dir == G_DIR_SEPARATOR)
 126                 dir++;
 127
 128         return (gchar *) dir;
 129 }
 130
 131
 132 static gchar *backupcopy_create_dir_parts(const gchar *filename)
 133 {
 134         gint cnt_dir_parts = 0;
 135         gchar *cp;
 136         gchar *dirname;
 137         gchar last_char = 0;
 138         gint error;
 139         gchar *result;
 140         gchar *target_dir;
 141
 142         if (backupcopy_dir_levels == 0)
 143                 return g_strdup("");
 144
 145         dirname = g_path_get_dirname(filename);
 146
 147         cp = dirname;
 148         /* walk to the end of the string */
 149         while (*cp != '\0')
 150                 cp++;
 151
 152         /* walk backwards to find directory parts */
 153         while (cp > dirname)
 154         {
 155                 if (*cp == G_DIR_SEPARATOR && last_char != G_DIR_SEPARATOR)
 156                         cnt_dir_parts++;
 157
 158                 if (cnt_dir_parts == backupcopy_dir_levels)
 159                         break;
 160
 161                 last_char = *cp;
 162                 cp--;
 163         }
 164
 165         result = backupcopy_skip_root(cp); /* skip leading slash/backslash and c:\ */
 166         target_dir = g_build_filename(backupcopy_backup_dir, result, NULL);
 167
 168         error = utils_mkdir(target_dir, TRUE);
 169         if (error != 0)
 170         {
 171                 ui_set_statusbar(FALSE, _("Backup Copy: Directory could not be created (%s)."),
 172                         g_strerror(error));
 173
 174                 result = g_strdup(""); /* return an empty string in case of an error */
 175         }
 176         else
 177                 result = g_strdup(result);
 178
 179         g_free(dirname);
 180         g_free(target_dir);
 181
 182         return result;
 183 }
 184
 185
 186 static void backupcopy_document_save_cb(GObject *obj, GeanyDocument *doc, gpointer user_data)
 187 {
 188         FILE *src, *dst;
 189         gchar *locale_filename_src;
 190         gchar *locale_filename_dst;
 191         gchar *basename_src;
 192         gchar *dir_parts_src;
 193         gchar *stamp;
 194         gchar buf[512];
 195
 196         if (! enable_backupcopy)
 197                 return;
 198
 199         locale_filename_src = utils_get_locale_from_utf8(doc->file_name);
 200
 201         if ((src = g_fopen(locale_filename_src, "r")) == NULL)
 202         {
 203                 /* it's unlikely that this happens */
 204                 ui_set_statusbar(FALSE, _("Backup Copy: File could not be read (%s)."),
 205                         g_strerror(errno));
 206                 g_free(locale_filename_src);
 207                 return;
 208         }
 209
 210         stamp = utils_get_date_time(backupcopy_time_fmt, NULL);
 211         basename_src = g_path_get_basename(locale_filename_src);
 212         dir_parts_src = backupcopy_create_dir_parts(locale_filename_src);
 213         locale_filename_dst = g_strconcat(
 214                 backupcopy_backup_dir, G_DIR_SEPARATOR_S,
 215                 dir_parts_src, G_DIR_SEPARATOR_S,
 216                 basename_src, ".", stamp, NULL);
 217         g_free(basename_src);
 218         g_free(dir_parts_src);
 219
 220         if ((dst = g_fopen(locale_filename_dst, "wb")) == NULL)
 221         {
 222                 ui_set_statusbar(FALSE, _("Backup Copy: File could not be saved (%s)."),
 223                         g_strerror(errno));
 224                 g_free(locale_filename_src);
 225                 g_free(locale_filename_dst);
 226                 g_free(stamp);
 227                 fclose(src);
 228                 return;
 229         }
 230
 231         while (fgets(buf, sizeof(buf), src) != NULL)
 232         {
 233                 fputs(buf, dst);
 234         }
 235
 236         fclose(src);
 237         fclose(dst);
 238         g_free(locale_filename_src);
 239         g_free(locale_filename_dst);
 240         g_free(stamp);
 241 }
 242
 243
 244 static void instantsave_document_new_cb(GObject *obj, GeanyDocument *doc, gpointer user_data)
 245 {
 246     if (enable_instantsave && doc->file_name == NULL)
 247     {
 248                 gchar *new_filename;
 249                 gint fd;
 250                 GeanyFiletype *ft = doc->file_type;
 251
 252                 fd = g_file_open_tmp("gis_XXXXXX", &new_filename, NULL);
 253                 if (fd != -1)
 254                         close(fd); /* close the returned file descriptor as we only need the filename */
 255
 256                 if (ft == NULL || ft->id == GEANY_FILETYPES_NONE)
 257                         /* ft is NULL when a new file without template was opened, so use the
 258                          * configured default file type */
 259                         ft = filetypes_lookup_by_name(instantsave_default_ft);
 260
 261                 if (ft != NULL)
 262                         /* add the filetype's default extension to the new filename */
 263                         SETPTR(new_filename, g_strconcat(new_filename, ".", ft->extension, NULL));
 264
 265                 doc->file_name = new_filename;
 266
 267                 if (doc->file_type->id == GEANY_FILETYPES_NONE)
 268                         document_set_filetype(doc, filetypes_lookup_by_name(instantsave_default_ft));
 269
 270                 /* force saving the file to enable all the related actions(tab name, filetype, etc.) */
 271                 document_save_file(doc, TRUE);
 272     }
 273 }
 274
 275
 276 PluginCallback plugin_callbacks[] =
 277 {
 278         { "document-new", (GCallback) &instantsave_document_new_cb, FALSE, NULL },
 279         { "document-save", (GCallback) &backupcopy_document_save_cb, FALSE, NULL },
 280         { NULL, NULL, FALSE, NULL }
 281 };
 282
 283
 284 static gboolean auto_save(gpointer data)
 285 {
 286         GeanyDocument *doc;
 287         GeanyDocument *cur_doc = document_get_current();
 288         gint i, max = gtk_notebook_get_n_pages(GTK_NOTEBOOK(geany->main_widgets->notebook));
 289         gint saved_files = 0;
 290
 291         if (cur_doc == NULL)
 292                 return TRUE;
 293
 294         if (autosave_save_all)
 295         {
 296                 for (i = 0; i < max; i++)
 297                 {
 298                         doc = document_get_from_page(i);
 299
 300                         /* skip current file (save it last), skip files without name */
 301                         if (doc != cur_doc && doc->file_name != NULL)
 302                                 if (document_save_file(doc, FALSE))
 303                                         saved_files++;
 304                 }
 305         }
 306         /* finally save current file, do it after all other files to get correct window title and
 307          * symbol list */
 308         if (cur_doc->file_name != NULL)
 309                 if (document_save_file(cur_doc, FALSE))
 310                         saved_files++;
 311
 312         if (saved_files > 0 && autosave_print_msg)
 313                 ui_set_statusbar(FALSE, ngettext(
 314                         "Autosave: Saved %d file automatically.",
 315                         "Autosave: Saved %d files automatically.", saved_files),
 316                         saved_files);
 317
 318         return TRUE;
 319 }
 320
 321
 322 static void autosave_set_timeout(void)
 323 {
 324         if (! enable_autosave)
 325                 return;
 326
 327         if (autosave_src_id != 0)
 328                 g_source_remove(autosave_src_id);
 329         autosave_src_id = g_timeout_add(autosave_interval * 1000, (GSourceFunc) auto_save, NULL);
 330 }
 331
 332
 333 void plugin_init(GeanyData *data)
 334 {
 335         GKeyFile *config = g_key_file_new();
 336         gchar *tmp;
 337
 338         config_file = g_strconcat(geany->app->configdir, G_DIR_SEPARATOR_S, "plugins",
 339                 G_DIR_SEPARATOR_S, "saveactions", G_DIR_SEPARATOR_S, "saveactions.conf", NULL);
 340
 341         g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
 342
 343         enable_autosave = utils_get_setting_boolean(
 344                 config, "saveactions", "enable_autosave", FALSE);
 345         enable_instantsave = utils_get_setting_boolean(
 346                 config, "saveactions", "enable_instantsave", FALSE);
 347         enable_backupcopy = utils_get_setting_boolean(
 348                 config, "saveactions", "enable_backupcopy", FALSE);
 349
 350         instantsave_default_ft = utils_get_setting_string(config, "instantsave", "default_ft",
 351                 filetypes[GEANY_FILETYPES_NONE]->name);
 352
 353         autosave_src_id = 0; /* mark as invalid */
 354         autosave_interval = utils_get_setting_integer(config, "autosave", "interval", 300);
 355         autosave_print_msg = utils_get_setting_boolean(config, "autosave", "print_messages", FALSE);
 356         autosave_save_all = utils_get_setting_boolean(config, "autosave", "save_all", FALSE);
 357         if (enable_autosave)
 358                 autosave_set_timeout();
 359
 360         backupcopy_dir_levels = utils_get_setting_integer(config, "backupcopy", "dir_levels", 0);
 361         backupcopy_time_fmt = utils_get_setting_string(
 362                 config, "backupcopy", "time_fmt", "%Y-%m-%d-%H-%M-%S");
 363         tmp = utils_get_setting_string(config, "backupcopy", "backup_dir", g_get_tmp_dir());
 364         backupcopy_set_backup_dir(tmp);
 365
 366         g_key_file_free(config);
 367         g_free(tmp);
 368 }
 369
 370
 371 static void backupcopy_dir_button_clicked_cb(GtkButton *button, gpointer item)
 372 {
 373         /** TODO add win32_show_pref_file_dialog to the plugin API and use it **/
 374 /*
 375 #ifdef G_OS_WIN32
 376         win32_show_pref_file_dialog(item);
 377 #else
 378 */
 379         GtkWidget *dialog;
 380         gchar *text;
 381
 382         /* initialize the dialog */
 383         dialog = gtk_file_chooser_dialog_new(_("Select Directory"), NULL,
 384                                         GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 385                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 386                                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
 387
 388         text = utils_get_locale_from_utf8(gtk_entry_get_text(GTK_ENTRY(item)));
 389         if (NZV(text))
 390                 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), text);
 391
 392         /* run it */
 393         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
 394         {
 395                 gchar *utf8_filename, *tmp;
 396
 397                 tmp = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 398                 utf8_filename = utils_get_utf8_from_locale(tmp);
 399
 400                 gtk_entry_set_text(GTK_ENTRY(item), utf8_filename);
 401
 402                 g_free(utf8_filename);
 403                 g_free(tmp);
 404         }
 405
 406         gtk_widget_destroy(dialog);
 407 }
 408
 409
 410 static void configure_response_cb(GtkDialog *dialog, gint response, G_GNUC_UNUSED gpointer data)
 411 {
 412         if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY)
 413         {
 414                 GKeyFile *config = g_key_file_new();
 415                 gchar *str;
 416                 const gchar *text_dir, *text_time;
 417                 gchar *config_dir = g_path_get_dirname(config_file);
 418
 419                 enable_autosave = gtk_toggle_button_get_active(
 420                         GTK_TOGGLE_BUTTON(pref_widgets.checkbox_enable_autosave));
 421                 enable_instantsave = gtk_toggle_button_get_active(
 422                         GTK_TOGGLE_BUTTON(pref_widgets.checkbox_enable_instantsave));
 423                 enable_backupcopy = gtk_toggle_button_get_active(
 424                         GTK_TOGGLE_BUTTON(pref_widgets.checkbox_enable_backupcopy));
 425
 426                 autosave_interval = gtk_spin_button_get_value_as_int(
 427                         GTK_SPIN_BUTTON(pref_widgets.autosave_interval_spin));
 428                 autosave_print_msg = gtk_toggle_button_get_active(
 429                         GTK_TOGGLE_BUTTON(pref_widgets.autosave_print_msg_checkbox));
 430                 autosave_save_all = gtk_toggle_button_get_active(
 431                         GTK_TOGGLE_BUTTON(pref_widgets.autosave_save_all_radio2));
 432
 433                 g_free(instantsave_default_ft);
 434                 instantsave_default_ft = gtk_combo_box_text_get_active_text(
 435                         GTK_COMBO_BOX_TEXT(pref_widgets.instantsave_ft_combo));
 436
 437                 text_dir = gtk_entry_get_text(GTK_ENTRY(pref_widgets.backupcopy_entry_dir));
 438                 text_time = gtk_entry_get_text(GTK_ENTRY(pref_widgets.backupcopy_entry_time));
 439                 backupcopy_dir_levels = gtk_spin_button_get_value_as_int(
 440                         GTK_SPIN_BUTTON(pref_widgets.backupcopy_spin_dir_levels));
 441
 442
 443                 g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
 444
 445                 g_key_file_set_boolean(config, "saveactions", "enable_autosave", enable_autosave);
 446                 g_key_file_set_boolean(config, "saveactions", "enable_instantsave", enable_instantsave);
 447                 g_key_file_set_boolean(config, "saveactions", "enable_backupcopy", enable_backupcopy);
 448
 449                 g_key_file_set_boolean(config, "autosave", "print_messages", autosave_print_msg);
 450                 g_key_file_set_boolean(config, "autosave", "save_all", autosave_save_all);
 451                 g_key_file_set_integer(config, "autosave", "interval", autosave_interval);
 452
 453                 if (instantsave_default_ft != NULL)
 454                         g_key_file_set_string(config, "instantsave", "default_ft", instantsave_default_ft);
 455
 456                 g_key_file_set_integer(config, "backupcopy", "dir_levels", backupcopy_dir_levels);
 457                 g_key_file_set_string(config, "backupcopy", "time_fmt", text_time);
 458                 SETPTR(backupcopy_time_fmt, g_strdup(text_time));
 459                 if (enable_backupcopy)
 460                 {
 461                         if (NZV(text_dir) && backupcopy_set_backup_dir(text_dir))
 462                         {
 463                                 g_key_file_set_string(config, "backupcopy", "backup_dir", text_dir);
 464                         }
 465                         else
 466                         {
 467                                 dialogs_show_msgbox(GTK_MESSAGE_ERROR,
 468                                                 _("Backup directory does not exist or is not writable."));
 469                         }
 470                 }
 471
 472
 473                 if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0)
 474                 {
 475                         dialogs_show_msgbox(GTK_MESSAGE_ERROR,
 476                                 _("Plugin configuration directory could not be created."));
 477                 }
 478                 else
 479                 {
 480                         /* write config to file */
 481                         str = g_key_file_to_data(config, NULL, NULL);
 482                         utils_write_file(config_file, str);
 483                         g_free(str);
 484                 }
 485
 486                 if (enable_autosave)
 487                         autosave_set_timeout(); /* apply the changes */
 488
 489                 g_free(config_dir);
 490                 g_key_file_free(config);
 491         }
 492 }
 493
 494
 495 static void checkbox_toggled_cb(GtkToggleButton *tb, gpointer data)
 496 {
 497         gboolean enable = gtk_toggle_button_get_active(tb);
 498
 499         switch (GPOINTER_TO_INT(data))
 500         {
 501                 case NOTEBOOK_PAGE_AUTOSAVE:
 502                 {
 503                         gtk_widget_set_sensitive(pref_widgets.autosave_interval_spin, enable);
 504                         gtk_widget_set_sensitive(pref_widgets.autosave_print_msg_checkbox, enable);
 505                         gtk_widget_set_sensitive(pref_widgets.autosave_save_all_radio1, enable);
 506                         gtk_widget_set_sensitive(pref_widgets.autosave_save_all_radio2, enable);
 507                         break;
 508                 }
 509                 case NOTEBOOK_PAGE_INSTANTSAVE:
 510                 {
 511                         gtk_widget_set_sensitive(pref_widgets.instantsave_ft_combo, enable);
 512                         break;
 513                 }
 514                 case NOTEBOOK_PAGE_BACKUPCOPY:
 515                 {
 516                         gtk_widget_set_sensitive(pref_widgets.backupcopy_entry_dir, enable);
 517                         gtk_widget_set_sensitive(pref_widgets.backupcopy_entry_time, enable);
 518                         gtk_widget_set_sensitive(pref_widgets.backupcopy_spin_dir_levels, enable);
 519                         break;
 520                 }
 521         }
 522
 523 }
 524
 525
 526 GtkWidget *plugin_configure(GtkDialog *dialog)
 527 {
 528         GtkWidget *vbox, *label, *notebook_vbox, *checkbox_enable;
 529         GtkWidget *notebook, *inner_vbox;
 530
 531         vbox = gtk_vbox_new(FALSE, 6);
 532
 533         notebook = gtk_notebook_new();
 534         gtk_widget_set_can_focus(notebook, FALSE);
 535         gtk_container_set_border_width(GTK_CONTAINER(notebook), 5);
 536         gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0);
 537
 538         /*
 539          * Auto Save
 540          */
 541         {
 542                 GtkWidget *spin, *hbox, *checkbox, *radio1, *radio2;
 543
 544                 notebook_vbox = gtk_vbox_new(FALSE, 2);
 545                 inner_vbox = gtk_vbox_new(FALSE, 5);
 546                 gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
 547                 gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
 548                 gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
 549                         notebook_vbox, gtk_label_new(_("Auto Save")), NOTEBOOK_PAGE_AUTOSAVE);
 550
 551                 checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
 552                 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
 553                 pref_widgets.checkbox_enable_autosave = checkbox_enable;
 554                 gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
 555                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_autosave);
 556                 g_signal_connect(checkbox_enable, "toggled",
 557                         G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_AUTOSAVE));
 558
 559                 label = gtk_label_new_with_mnemonic(_("Auto save _interval:"));
 560                 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 561                 gtk_box_pack_start(GTK_BOX(inner_vbox), label, TRUE, TRUE, 0);
 562
 563                 pref_widgets.autosave_interval_spin = spin = gtk_spin_button_new_with_range(1, 1800, 1);
 564                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), autosave_interval);
 565                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
 566
 567                 label = gtk_label_new(_("seconds"));
 568
 569                 hbox = gtk_hbox_new(FALSE, 5);
 570                 gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0);
 571                 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 572
 573                 gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 5);
 574
 575                 checkbox = gtk_check_button_new_with_mnemonic(
 576                         _("_Print status message if files have been automatically saved"));
 577                 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE);
 578                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), autosave_print_msg);
 579                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), checkbox);
 580                 gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox, FALSE, FALSE, 5);
 581                 pref_widgets.autosave_print_msg_checkbox = checkbox;
 582
 583                 radio1 = gtk_radio_button_new_with_mnemonic(NULL,
 584                         _("Save only current open _file"));
 585                 pref_widgets.autosave_save_all_radio1 = radio1;
 586                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio1);
 587                 gtk_button_set_focus_on_click(GTK_BUTTON(radio1), FALSE);
 588                 gtk_container_add(GTK_CONTAINER(inner_vbox), radio1);
 589
 590                 radio2 = gtk_radio_button_new_with_mnemonic_from_widget(
 591                         GTK_RADIO_BUTTON(radio1), _("Sa_ve all open files"));
 592                 pref_widgets.autosave_save_all_radio2 = radio2;
 593                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio2);
 594                 gtk_button_set_focus_on_click(GTK_BUTTON(radio2), FALSE);
 595                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), autosave_save_all);
 596                 gtk_container_add(GTK_CONTAINER(inner_vbox), radio2);
 597         }
 598         /*
 599          * Instant Save
 600          */
 601         {
 602                 GtkWidget *combo;
 603                 guint i;
 604                 const GSList *node;
 605
 606                 notebook_vbox = gtk_vbox_new(FALSE, 2);
 607                 inner_vbox = gtk_vbox_new(FALSE, 5);
 608                 gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
 609                 gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
 610                 gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
 611                         notebook_vbox, gtk_label_new(_("Instant Save")), NOTEBOOK_PAGE_INSTANTSAVE);
 612
 613                 checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
 614                 pref_widgets.checkbox_enable_instantsave = checkbox_enable;
 615                 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
 616                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_instantsave);
 617                 gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
 618                 g_signal_connect(checkbox_enable, "toggled",
 619                         G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_INSTANTSAVE));
 620
 621                 label = gtk_label_new_with_mnemonic(_("_Filetype to use for newly opened files:"));
 622                 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 623                 gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0);
 624
 625                 pref_widgets.instantsave_ft_combo = combo = gtk_combo_box_text_new();
 626                 i = 0;
 627                 foreach_slist(node, filetypes_get_sorted_by_name())
 628                 {
 629                         GeanyFiletype *ft = node->data;
 630
 631                         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), ft->name);
 632
 633                         if (utils_str_equal(ft->name, instantsave_default_ft))
 634                                 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i);
 635                         i++;
 636                 }
 637                 gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3);
 638                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), combo);
 639                 gtk_box_pack_start(GTK_BOX(inner_vbox), combo, FALSE, FALSE, 0);
 640         }
 641         /*
 642          * Backup Copy
 643          */
 644         {
 645                 GtkWidget *hbox, *entry_dir, *entry_time, *button, *image, *spin_dir_levels;
 646
 647                 notebook_vbox = gtk_vbox_new(FALSE, 2);
 648                 inner_vbox = gtk_vbox_new(FALSE, 5);
 649                 gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5);
 650                 gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5);
 651                 gtk_notebook_insert_page(GTK_NOTEBOOK(notebook),
 652                         notebook_vbox, gtk_label_new(_("Backup Copy")), NOTEBOOK_PAGE_BACKUPCOPY);
 653
 654                 checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable"));
 655                 pref_widgets.checkbox_enable_backupcopy = checkbox_enable;
 656                 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE);
 657                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_backupcopy);
 658                 gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6);
 659                 g_signal_connect(checkbox_enable, "toggled",
 660                         G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_BACKUPCOPY));
 661
 662                 label = gtk_label_new_with_mnemonic(_("_Directory to save backup files in:"));
 663                 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 664                 gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0);
 665
 666                 pref_widgets.backupcopy_entry_dir = entry_dir = gtk_entry_new();
 667                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry_dir);
 668                 if (NZV(backupcopy_backup_dir))
 669                         gtk_entry_set_text(GTK_ENTRY(entry_dir), backupcopy_backup_dir);
 670
 671                 button = gtk_button_new();
 672                 g_signal_connect(button, "clicked",
 673                         G_CALLBACK(backupcopy_dir_button_clicked_cb), entry_dir);
 674
 675                 image = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
 676                 gtk_container_add(GTK_CONTAINER(button), image);
 677
 678                 hbox = gtk_hbox_new(FALSE, 6);
 679                 gtk_box_pack_start(GTK_BOX(hbox), entry_dir, TRUE, TRUE, 0);
 680                 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
 681
 682                 gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 0);
 683
 684                 label = gtk_label_new_with_mnemonic(
 685                         _("Date/_Time format for backup files (\"man strftime\" for details):"));
 686                 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 687                 gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 7);
 688
 689                 pref_widgets.backupcopy_entry_time = entry_time = gtk_entry_new();
 690                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry_time);
 691                 if (NZV(backupcopy_time_fmt))
 692                         gtk_entry_set_text(GTK_ENTRY(entry_time), backupcopy_time_fmt);
 693                 gtk_box_pack_start(GTK_BOX(inner_vbox), entry_time, FALSE, FALSE, 0);
 694
 695                 hbox = gtk_hbox_new(FALSE, 6);
 696
 697                 label = gtk_label_new_with_mnemonic(
 698                         _("Directory _levels to include in the backup destination:"));
 699                 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 700                 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 701
 702                 spin_dir_levels = gtk_spin_button_new_with_range(0, 20, 1);
 703                 pref_widgets.backupcopy_spin_dir_levels = spin_dir_levels;
 704                 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin_dir_levels), backupcopy_dir_levels);
 705                 gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin_dir_levels);
 706                 gtk_box_pack_start(GTK_BOX(hbox), spin_dir_levels, FALSE, FALSE, 0);
 707
 708                 gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 7);
 709         }
 710
 711         /* manually emit the toggled signal of the enable checkboxes to update the widget sensitivity */
 712         g_signal_emit_by_name(pref_widgets.checkbox_enable_autosave, "toggled");
 713         g_signal_emit_by_name(pref_widgets.checkbox_enable_instantsave, "toggled");
 714         g_signal_emit_by_name(pref_widgets.checkbox_enable_backupcopy, "toggled");
 715
 716         gtk_widget_show_all(vbox);
 717         g_signal_connect(dialog, "response", G_CALLBACK(configure_response_cb), NULL);
 718
 719         return vbox;
 720 }
 721
 722
 723 void plugin_cleanup(void)
 724 {
 725         if (autosave_src_id != 0)
 726                 g_source_remove(autosave_src_id);
 727
 728         g_free(instantsave_default_ft);
 729
 730         g_free(backupcopy_backup_dir);
 731         g_free(backupcopy_time_fmt);
 732
 733         g_free(config_file);
 734 }