src/project.c

   1 /*
   2  *      project.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 /** @file project.h
  23  * Project Management.
  24  */
  25
  26 #include "geany.h"
  27
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32 #include "project.h"
  33 #include "projectprivate.h"
  34
  35 #include "dialogs.h"
  36 #include "support.h"
  37 #include "utils.h"
  38 #include "ui_utils.h"
  39 #include "document.h"
  40 #include "msgwindow.h"
  41 #include "main.h"
  42 #include "keyfile.h"
  43 #include "win32.h"
  44 #include "build.h"
  45 #include "editor.h"
  46 #include "stash.h"
  47 #include "sidebar.h"
  48 #include "filetypes.h"
  49
  50
  51 ProjectPrefs project_prefs = { NULL, FALSE, FALSE };
  52
  53
  54 static GeanyProjectPrivate priv;
  55 static GeanyIndentPrefs indentation;
  56
  57 static GSList *stash_groups = NULL;
  58
  59 static struct
  60 {
  61         gchar *project_file_path; /* in UTF-8 */
  62 } local_prefs = { NULL };
  63
  64 static gboolean entries_modified;
  65
  66 /* simple struct to keep references to the elements of the properties dialog */
  67 typedef struct _PropertyDialogElements
  68 {
  69         GtkWidget *dialog;
  70         GtkWidget *notebook;
  71         GtkWidget *name;
  72         GtkWidget *description;
  73         GtkWidget *file_name;
  74         GtkWidget *base_path;
  75         GtkWidget *patterns;
  76         BuildTableData build_properties;
  77         gint build_page_num;
  78 } PropertyDialogElements;
  79
  80
  81 static gboolean update_config(const PropertyDialogElements *e, gboolean new_project);
  82 static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElements *e);
  83 static gboolean load_config(const gchar *filename);
  84 static gboolean write_config(gboolean emit_signal);
  85 static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e);
  86 static void on_entries_changed(GtkEditable *editable, PropertyDialogElements *e);
  87 static void on_radio_long_line_custom_toggled(GtkToggleButton *radio, GtkWidget *spin_long_line);
  88 static void apply_editor_prefs(void);
  89 static void init_stash_prefs(void);
  90
  91
  92 #define SHOW_ERR(args) dialogs_show_msgbox(GTK_MESSAGE_ERROR, args)
  93 #define SHOW_ERR1(args, more) dialogs_show_msgbox(GTK_MESSAGE_ERROR, args, more)
  94 #define MAX_NAME_LEN 50
  95 /* "projects" is part of the default project base path so be careful when translating
  96  * please avoid special characters and spaces, look at the source for details or ask Frank */
  97 #define PROJECT_DIR _("projects")
  98
  99
 100 /* TODO: this should be ported to Glade like the project preferences dialog,
 101  * then we can get rid of the PropertyDialogElements struct altogether as
 102  * widgets pointers can be accessed through ui_lookup_widget(). */
 103 void project_new(void)
 104 {
 105         GtkWidget *vbox;
 106         GtkWidget *table;
 107         GtkWidget *image;
 108         GtkWidget *button;
 109         GtkWidget *bbox;
 110         GtkWidget *label;
 111         PropertyDialogElements *e;
 112
 113         if (! project_ask_close())
 114                 return;
 115
 116         g_return_if_fail(app->project == NULL);
 117
 118         e = g_new0(PropertyDialogElements, 1);
 119         e->dialog = gtk_dialog_new_with_buttons(_("New Project"), GTK_WINDOW(main_widgets.window),
 120                                                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
 121                                                                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
 122
 123         gtk_widget_set_name(e->dialog, "GeanyDialogProject");
 124         bbox = gtk_hbox_new(FALSE, 0);
 125         button = gtk_button_new();
 126         gtk_widget_set_can_default(button, TRUE);
 127         gtk_window_set_default(GTK_WINDOW(e->dialog), button);
 128         image = gtk_image_new_from_stock(GTK_STOCK_NEW, GTK_ICON_SIZE_BUTTON);
 129         label = gtk_label_new_with_mnemonic(_("C_reate"));
 130         gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 3);
 131         gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 3);
 132         gtk_container_add(GTK_CONTAINER(button), bbox);
 133         gtk_dialog_add_action_widget(GTK_DIALOG(e->dialog), button, GTK_RESPONSE_OK);
 134
 135         vbox = ui_dialog_vbox_new(GTK_DIALOG(e->dialog));
 136
 137         entries_modified = FALSE;
 138
 139         table = gtk_table_new(3, 2, FALSE);
 140         gtk_table_set_row_spacings(GTK_TABLE(table), 5);
 141         gtk_table_set_col_spacings(GTK_TABLE(table), 10);
 142
 143         label = gtk_label_new(_("Name:"));
 144         gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
 145
 146         e->name = gtk_entry_new();
 147         gtk_entry_set_activates_default(GTK_ENTRY(e->name), TRUE);
 148         ui_entry_add_clear_icon(GTK_ENTRY(e->name));
 149         gtk_entry_set_max_length(GTK_ENTRY(e->name), MAX_NAME_LEN);
 150
 151         ui_table_add_row(GTK_TABLE(table), 0, label, e->name, NULL);
 152
 153         label = gtk_label_new(_("Filename:"));
 154         gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
 155
 156         e->file_name = gtk_entry_new();
 157         gtk_entry_set_activates_default(GTK_ENTRY(e->file_name), TRUE);
 158         ui_entry_add_clear_icon(GTK_ENTRY(e->file_name));
 159         gtk_entry_set_width_chars(GTK_ENTRY(e->file_name), 30);
 160         button = gtk_button_new();
 161         g_signal_connect(button, "clicked", G_CALLBACK(on_file_save_button_clicked), e);
 162         image = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
 163         gtk_container_add(GTK_CONTAINER(button), image);
 164         bbox = gtk_hbox_new(FALSE, 6);
 165         gtk_box_pack_start(GTK_BOX(bbox), e->file_name, TRUE, TRUE, 0);
 166         gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
 167
 168         ui_table_add_row(GTK_TABLE(table), 1, label, bbox, NULL);
 169
 170         label = gtk_label_new(_("Base path:"));
 171         gtk_misc_set_alignment(GTK_MISC(label), 1, 0);
 172
 173         e->base_path = gtk_entry_new();
 174         gtk_entry_set_activates_default(GTK_ENTRY(e->base_path), TRUE);
 175         ui_entry_add_clear_icon(GTK_ENTRY(e->base_path));
 176         gtk_widget_set_tooltip_text(e->base_path,
 177                 _("Base directory of all files that make up the project. "
 178                 "This can be a new path, or an existing directory tree. "
 179                 "You can use paths relative to the project filename."));
 180         bbox = ui_path_box_new(_("Choose Project Base Path"),
 181                 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_ENTRY(e->base_path));
 182
 183         ui_table_add_row(GTK_TABLE(table), 2, label, bbox, NULL);
 184
 185         gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
 186
 187         /* signals */
 188         g_signal_connect(e->name, "changed", G_CALLBACK(on_name_entry_changed), e);
 189         /* run the callback manually to initialise the base_path and file_name fields */
 190         on_name_entry_changed(GTK_EDITABLE(e->name), e);
 191
 192         g_signal_connect(e->file_name, "changed", G_CALLBACK(on_entries_changed), e);
 193         g_signal_connect(e->base_path, "changed", G_CALLBACK(on_entries_changed), e);
 194
 195         gtk_widget_show_all(e->dialog);
 196
 197         while (gtk_dialog_run(GTK_DIALOG(e->dialog)) == GTK_RESPONSE_OK)
 198         {
 199                 if (update_config(e, TRUE))
 200                 {
 201                         if (!write_config(TRUE))
 202                                 SHOW_ERR(_("Project file could not be written"));
 203                         else
 204                         {
 205                                 ui_set_statusbar(TRUE, _("Project \"%s\" created."), app->project->name);
 206
 207                                 ui_add_recent_project_file(app->project->file_name);
 208                                 break;
 209                         }
 210                 }
 211         }
 212         gtk_widget_destroy(e->dialog);
 213         g_free(e);
 214 }
 215
 216
 217 gboolean project_load_file_with_session(const gchar *locale_file_name)
 218 {
 219         if (project_load_file(locale_file_name))
 220         {
 221                 if (project_prefs.project_session)
 222                 {
 223                         configuration_open_files();
 224                         /* open a new file if no other file was opened */
 225                         document_new_file_if_non_open();
 226                         ui_focus_current_document();
 227                 }
 228                 return TRUE;
 229         }
 230         return FALSE;
 231 }
 232
 233
 234 #ifndef G_OS_WIN32
 235 static void run_open_dialog(GtkDialog *dialog)
 236 {
 237         while (gtk_dialog_run(dialog) == GTK_RESPONSE_ACCEPT)
 238         {
 239                 gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 240
 241                 /* try to load the config */
 242                 if (! project_load_file_with_session(filename))
 243                 {
 244                         gchar *utf8_filename = utils_get_utf8_from_locale(filename);
 245
 246                         SHOW_ERR1(_("Project file \"%s\" could not be loaded."), utf8_filename);
 247                         gtk_widget_grab_focus(GTK_WIDGET(dialog));
 248                         g_free(utf8_filename);
 249                         g_free(filename);
 250                         continue;
 251                 }
 252                 g_free(filename);
 253                 break;
 254         }
 255 }
 256 #endif
 257
 258
 259 void project_open(void)
 260 {
 261         const gchar *dir = local_prefs.project_file_path;
 262 #ifdef G_OS_WIN32
 263         gchar *file;
 264 #else
 265         GtkWidget *dialog;
 266         GtkFileFilter *filter;
 267         gchar *locale_path;
 268 #endif
 269         if (! project_ask_close()) return;
 270
 271 #ifdef G_OS_WIN32
 272         file = win32_show_project_open_dialog(main_widgets.window, _("Open Project"), dir, FALSE, TRUE);
 273         if (file != NULL)
 274         {
 275                 /* try to load the config */
 276                 if (! project_load_file_with_session(file))
 277                 {
 278                         SHOW_ERR1(_("Project file \"%s\" could not be loaded."), file);
 279                 }
 280                 g_free(file);
 281         }
 282 #else
 283
 284         dialog = gtk_file_chooser_dialog_new(_("Open Project"), GTK_WINDOW(main_widgets.window),
 285                         GTK_FILE_CHOOSER_ACTION_OPEN,
 286                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 287                         GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
 288         gtk_widget_set_name(dialog, "GeanyDialogProject");
 289
 290         /* set default Open, so pressing enter can open multiple files */
 291         gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
 292         gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
 293         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
 294         gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
 295         gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
 296         gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
 297
 298         /* add FileFilters */
 299         filter = gtk_file_filter_new();
 300         gtk_file_filter_set_name(filter, _("All files"));
 301         gtk_file_filter_add_pattern(filter, "*");
 302         gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 303         filter = gtk_file_filter_new();
 304         gtk_file_filter_set_name(filter, _("Project files"));
 305         gtk_file_filter_add_pattern(filter, "*." GEANY_PROJECT_EXT);
 306         gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
 307         gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
 308
 309         locale_path = utils_get_locale_from_utf8(dir);
 310         if (g_file_test(locale_path, G_FILE_TEST_EXISTS) &&
 311                 g_file_test(locale_path, G_FILE_TEST_IS_DIR))
 312         {
 313                 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
 314         }
 315         g_free(locale_path);
 316
 317         gtk_widget_show_all(dialog);
 318         run_open_dialog(GTK_DIALOG(dialog));
 319         gtk_widget_destroy(GTK_WIDGET(dialog));
 320 #endif
 321 }
 322
 323
 324 /* Called when creating, opening, closing and updating projects. */
 325 static void update_ui(void)
 326 {
 327         if (main_status.quitting)
 328                 return;
 329
 330         ui_set_window_title(NULL);
 331         build_menu_update(NULL);
 332         sidebar_openfiles_update_all();
 333 }
 334
 335
 336 static void remove_foreach_project_filetype(gpointer data, gpointer user_data)
 337 {
 338         GeanyFiletype *ft = data;
 339         if (ft != NULL)
 340         {
 341                 SETPTR(ft->projfilecmds, NULL);
 342                 SETPTR(ft->projexeccmds, NULL);
 343                 SETPTR(ft->projerror_regex_string, NULL);
 344                 ft->project_list_entry = -1;
 345         }
 346 }
 347
 348
 349 /* open_default will make function reload default session files on close */
 350 void project_close(gboolean open_default)
 351 {
 352         GSList *node;
 353
 354         g_return_if_fail(app->project != NULL);
 355
 356         /* save project session files, etc */
 357         if (!write_config(FALSE))
 358                 g_warning("Project file \"%s\" could not be written", app->project->file_name);
 359
 360         if (project_prefs.project_session)
 361         {
 362                 /* close all existing tabs first */
 363                 if (!document_close_all())
 364                         return;
 365         }
 366         ui_set_statusbar(TRUE, _("Project \"%s\" closed."), app->project->name);
 367
 368         /* remove project filetypes build entries */
 369         if (app->project->build_filetypes_list != NULL)
 370         {
 371                 g_ptr_array_foreach(app->project->build_filetypes_list, remove_foreach_project_filetype, NULL);
 372                 g_ptr_array_free(app->project->build_filetypes_list, FALSE);
 373         }
 374
 375         /* remove project non filetype build menu items */
 376         build_remove_menu_item(GEANY_BCS_PROJ, GEANY_GBG_NON_FT, -1);
 377         build_remove_menu_item(GEANY_BCS_PROJ, GEANY_GBG_EXEC, -1);
 378
 379         g_free(app->project->name);
 380         g_free(app->project->description);
 381         g_free(app->project->file_name);
 382         g_free(app->project->base_path);
 383
 384         g_free(app->project);
 385         app->project = NULL;
 386
 387         foreach_slist(node, stash_groups)
 388                 stash_group_free(node->data);
 389
 390         g_slist_free(stash_groups);
 391         stash_groups = NULL;
 392
 393         apply_editor_prefs(); /* ensure that global settings are restored */
 394
 395         if (project_prefs.project_session)
 396         {
 397                 /* after closing all tabs let's open the tabs found in the default config */
 398                 if (open_default && cl_options.load_session)
 399                 {
 400                         configuration_reload_default_session();
 401                         configuration_open_files();
 402                         /* open a new file if no other file was opened */
 403                         document_new_file_if_non_open();
 404                         ui_focus_current_document();
 405                 }
 406         }
 407         g_signal_emit_by_name(geany_object, "project-close");
 408
 409         update_ui();
 410 }
 411
 412
 413 /* Shows the file chooser dialog when base path button is clicked
 414  * FIXME: this should be connected in Glade but 3.8.1 has a bug
 415  * where it won't pass any objects as user data (#588824). */
 416 G_MODULE_EXPORT void
 417 on_project_properties_base_path_button_clicked(GtkWidget *button,
 418         GtkWidget *base_path_entry)
 419 {
 420         GtkWidget *dialog;
 421
 422         g_return_if_fail(base_path_entry != NULL);
 423         g_return_if_fail(GTK_IS_WIDGET(base_path_entry));
 424
 425         dialog = gtk_file_chooser_dialog_new(_("Choose Project Base Path"),
 426                 NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
 427                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 428                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 429                 NULL);
 430
 431         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
 432         {
 433                 gtk_entry_set_text(GTK_ENTRY(base_path_entry),
 434                         gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
 435         }
 436
 437         gtk_widget_destroy(dialog);
 438 }
 439
 440
 441 static void insert_build_page(PropertyDialogElements *e)
 442 {
 443         GtkWidget *build_table, *label;
 444         GeanyDocument *doc = document_get_current();
 445         GeanyFiletype *ft = NULL;
 446
 447         if (doc != NULL)
 448                 ft = doc->file_type;
 449
 450         build_table = build_commands_table(doc, GEANY_BCS_PROJ, &(e->build_properties), ft);
 451         gtk_container_set_border_width(GTK_CONTAINER(build_table), 6);
 452         label = gtk_label_new(_("Build"));
 453         e->build_page_num = gtk_notebook_append_page(GTK_NOTEBOOK(e->notebook),
 454                 build_table, label);
 455 }
 456
 457
 458 static void create_properties_dialog(PropertyDialogElements *e)
 459 {
 460         GtkWidget *base_path_button;
 461         static guint base_path_button_handler_id = 0;
 462         static guint radio_long_line_handler_id = 0;
 463
 464         e->dialog = create_project_dialog();
 465         e->notebook = ui_lookup_widget(e->dialog, "project_notebook");
 466         e->file_name = ui_lookup_widget(e->dialog, "label_project_dialog_filename");
 467         e->name = ui_lookup_widget(e->dialog, "entry_project_dialog_name");
 468         e->description = ui_lookup_widget(e->dialog, "textview_project_dialog_description");
 469         e->base_path = ui_lookup_widget(e->dialog, "entry_project_dialog_base_path");
 470         e->patterns = ui_lookup_widget(e->dialog, "entry_project_dialog_file_patterns");
 471
 472         gtk_entry_set_max_length(GTK_ENTRY(e->name), MAX_NAME_LEN);
 473
 474         ui_entry_add_clear_icon(GTK_ENTRY(e->name));
 475         ui_entry_add_clear_icon(GTK_ENTRY(e->base_path));
 476         ui_entry_add_clear_icon(GTK_ENTRY(e->patterns));
 477
 478         /* Workaround for bug in Glade 3.8.1, see comment above signal handler */
 479         if (base_path_button_handler_id == 0)
 480         {
 481                 base_path_button = ui_lookup_widget(e->dialog, "button_project_dialog_base_path");
 482                 base_path_button_handler_id =
 483                         g_signal_connect(base_path_button, "clicked",
 484                         G_CALLBACK(on_project_properties_base_path_button_clicked),
 485                         e->base_path);
 486         }
 487
 488         /* Same as above, should be in Glade but can't due to bug in 3.8.1 */
 489         if (radio_long_line_handler_id == 0)
 490         {
 491                 radio_long_line_handler_id =
 492                         g_signal_connect(ui_lookup_widget(e->dialog,
 493                         "radio_long_line_custom_project"), "toggled",
 494                         G_CALLBACK(on_radio_long_line_custom_toggled),
 495                         ui_lookup_widget(e->dialog, "spin_long_line_project"));
 496         }
 497 }
 498
 499
 500 static void show_project_properties(gboolean show_build)
 501 {
 502         GeanyProject *p = app->project;
 503         GtkWidget *widget = NULL;
 504         GtkWidget *radio_long_line_custom;
 505         static PropertyDialogElements e;
 506         GSList *node;
 507
 508         g_return_if_fail(app->project != NULL);
 509
 510         entries_modified = FALSE;
 511
 512         if (e.dialog == NULL)
 513                 create_properties_dialog(&e);
 514
 515         insert_build_page(&e);
 516
 517         foreach_slist(node, stash_groups)
 518                 stash_group_display(node->data, e.dialog);
 519
 520         /* fill the elements with the appropriate data */
 521         gtk_entry_set_text(GTK_ENTRY(e.name), p->name);
 522         gtk_label_set_text(GTK_LABEL(e.file_name), p->file_name);
 523         gtk_entry_set_text(GTK_ENTRY(e.base_path), p->base_path);
 524
 525         radio_long_line_custom = ui_lookup_widget(e.dialog, "radio_long_line_custom_project");
 526         switch (p->long_line_behaviour)
 527         {
 528                 case 0: widget = ui_lookup_widget(e.dialog, "radio_long_line_disabled_project"); break;
 529                 case 1: widget = ui_lookup_widget(e.dialog, "radio_long_line_default_project"); break;
 530                 case 2: widget = radio_long_line_custom; break;
 531         }
 532         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
 533
 534         widget = ui_lookup_widget(e.dialog, "spin_long_line_project");
 535         gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), (gdouble)p->long_line_column);
 536         on_radio_long_line_custom_toggled(GTK_TOGGLE_BUTTON(radio_long_line_custom), widget);
 537
 538         if (p->description != NULL)
 539         {       /* set text */
 540                 GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e.description));
 541                 gtk_text_buffer_set_text(buffer, p->description, -1);
 542         }
 543
 544         if (p->file_patterns != NULL)
 545         {       /* set the file patterns */
 546                 gchar *str;
 547
 548                 str = g_strjoinv(" ", p->file_patterns);
 549                 gtk_entry_set_text(GTK_ENTRY(e.patterns), str);
 550                 g_free(str);
 551         }
 552
 553         g_signal_emit_by_name(geany_object, "project-dialog-open", e.notebook);
 554         gtk_widget_show_all(e.dialog);
 555
 556         /* note: notebook page must be shown before setting current page */
 557         if (show_build)
 558                 gtk_notebook_set_current_page(GTK_NOTEBOOK(e.notebook), e.build_page_num);
 559         else
 560                 gtk_notebook_set_current_page(GTK_NOTEBOOK(e.notebook), 0);
 561
 562         while (gtk_dialog_run(GTK_DIALOG(e.dialog)) == GTK_RESPONSE_OK)
 563         {
 564                 if (update_config(&e, FALSE))
 565                 {
 566                         g_signal_emit_by_name(geany_object, "project-dialog-confirmed", e.notebook);
 567                         if (!write_config(TRUE))
 568                                 SHOW_ERR(_("Project file could not be written"));
 569                         else
 570                         {
 571                                 ui_set_statusbar(TRUE, _("Project \"%s\" saved."), app->project->name);
 572                                 break;
 573                         }
 574                 }
 575         }
 576
 577         build_free_fields(e.build_properties);
 578         g_signal_emit_by_name(geany_object, "project-dialog-close", e.notebook);
 579         gtk_notebook_remove_page(GTK_NOTEBOOK(e.notebook), e.build_page_num);
 580         gtk_widget_hide(e.dialog);
 581 }
 582
 583
 584 void project_properties(void)
 585 {
 586         show_project_properties(FALSE);
 587 }
 588
 589
 590 void project_build_properties(void)
 591 {
 592         show_project_properties(TRUE);
 593 }
 594
 595
 596 /* checks whether there is an already open project and asks the user if he wants to close it or
 597  * abort the current action. Returns FALSE when the current action(the caller) should be cancelled
 598  * and TRUE if we can go ahead */
 599 gboolean project_ask_close(void)
 600 {
 601         if (app->project != NULL)
 602         {
 603                 if (dialogs_show_question_full(NULL, GTK_STOCK_CLOSE, GTK_STOCK_CANCEL,
 604                         _("Do you want to close it before proceeding?"),
 605                         _("The '%s' project is open."), app->project->name))
 606                 {
 607                         project_close(FALSE);
 608                         return TRUE;
 609                 }
 610                 else
 611                         return FALSE;
 612         }
 613         else
 614                 return TRUE;
 615 }
 616
 617
 618 static GeanyProject *create_project(void)
 619 {
 620         GeanyProject *project = g_new0(GeanyProject, 1);
 621
 622         memset(&priv, 0, sizeof priv);
 623         priv.indentation = &indentation;
 624         project->priv = &priv;
 625
 626         init_stash_prefs();
 627
 628         project->file_patterns = NULL;
 629
 630         project->long_line_behaviour = 1 /* use global settings */;
 631         project->long_line_column = editor_prefs.long_line_column;
 632
 633         app->project = project;
 634         return project;
 635 }
 636
 637
 638 /* Verifies data for New & Properties dialogs.
 639  * Returns: FALSE if the user needs to change any data. */
 640 static gboolean update_config(const PropertyDialogElements *e, gboolean new_project)
 641 {
 642         const gchar *name, *file_name, *base_path;
 643         gchar *locale_filename;
 644         gsize name_len;
 645         gint err_code = 0;
 646         GeanyProject *p;
 647
 648         g_return_val_if_fail(e != NULL, TRUE);
 649
 650         name = gtk_entry_get_text(GTK_ENTRY(e->name));
 651         name_len = strlen(name);
 652         if (name_len == 0)
 653         {
 654                 SHOW_ERR(_("The specified project name is too short."));
 655                 gtk_widget_grab_focus(e->name);
 656                 return FALSE;
 657         }
 658         else if (name_len > MAX_NAME_LEN)
 659         {
 660                 SHOW_ERR1(_("The specified project name is too long (max. %d characters)."), MAX_NAME_LEN);
 661                 gtk_widget_grab_focus(e->name);
 662                 return FALSE;
 663         }
 664
 665         if (new_project)
 666                 file_name = gtk_entry_get_text(GTK_ENTRY(e->file_name));
 667         else
 668                 file_name = gtk_label_get_text(GTK_LABEL(e->file_name));
 669
 670         if (G_UNLIKELY(! NZV(file_name)))
 671         {
 672                 SHOW_ERR(_("You have specified an invalid project filename."));
 673                 gtk_widget_grab_focus(e->file_name);
 674                 return FALSE;
 675         }
 676
 677         locale_filename = utils_get_locale_from_utf8(file_name);
 678         base_path = gtk_entry_get_text(GTK_ENTRY(e->base_path));
 679         if (NZV(base_path))
 680         {       /* check whether the given directory actually exists */
 681                 gchar *locale_path = utils_get_locale_from_utf8(base_path);
 682
 683                 if (! g_path_is_absolute(locale_path))
 684                 {       /* relative base path, so add base dir of project file name */
 685                         gchar *dir = g_path_get_dirname(locale_filename);
 686                         SETPTR(locale_path, g_strconcat(dir, locale_path, NULL));
 687                         g_free(dir);
 688                 }
 689
 690                 if (! g_file_test(locale_path, G_FILE_TEST_IS_DIR))
 691                 {
 692                         gboolean create_dir;
 693
 694                         create_dir = dialogs_show_question_full(NULL, GTK_STOCK_OK, GTK_STOCK_CANCEL,
 695                                 _("Create the project's base path directory?"),
 696                                 _("The path \"%s\" does not exist."),
 697                                 base_path);
 698
 699                         if (create_dir)
 700                                 err_code = utils_mkdir(locale_path, TRUE);
 701
 702                         if (! create_dir || err_code != 0)
 703                         {
 704                                 if (err_code != 0)
 705                                         SHOW_ERR1(_("Project base directory could not be created (%s)."),
 706                                                 g_strerror(err_code));
 707                                 gtk_widget_grab_focus(e->base_path);
 708                                 utils_free_pointers(2, locale_path, locale_filename, NULL);
 709                                 return FALSE;
 710                         }
 711                 }
 712                 g_free(locale_path);
 713         }
 714         /* finally test whether the given project file can be written */
 715         if ((err_code = utils_is_file_writable(locale_filename)) != 0 ||
 716                 (err_code = g_file_test(locale_filename, G_FILE_TEST_IS_DIR) ? EISDIR : 0) != 0)
 717         {
 718                 SHOW_ERR1(_("Project file could not be written (%s)."), g_strerror(err_code));
 719                 gtk_widget_grab_focus(e->file_name);
 720                 g_free(locale_filename);
 721                 return FALSE;
 722         }
 723         g_free(locale_filename);
 724
 725         if (app->project == NULL)
 726         {
 727                 create_project();
 728                 new_project = TRUE;
 729         }
 730         p = app->project;
 731
 732         SETPTR(p->name, g_strdup(name));
 733         SETPTR(p->file_name, g_strdup(file_name));
 734         /* use "." if base_path is empty */
 735         SETPTR(p->base_path, g_strdup(NZV(base_path) ? base_path : "./"));
 736
 737         if (! new_project)      /* save properties specific fields */
 738         {
 739                 GtkTextIter start, end;
 740                 GtkTextBuffer *buffer;
 741                 GeanyDocument *doc = document_get_current();
 742                 GeanyBuildCommand *oldvalue;
 743                 GeanyFiletype *ft = doc ? doc->file_type : NULL;
 744                 GtkWidget *widget;
 745                 gchar *tmp;
 746                 GString *str;
 747                 GSList *node;
 748
 749                 /* get and set the project description */
 750                 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->description));
 751                 gtk_text_buffer_get_start_iter(buffer, &start);
 752                 gtk_text_buffer_get_end_iter(buffer, &end);
 753                 SETPTR(p->description, g_strdup(gtk_text_buffer_get_text(buffer, &start, &end, FALSE)));
 754
 755                 foreach_slist(node, stash_groups)
 756                         stash_group_update(node->data, e->dialog);
 757
 758                 /* read the project build menu */
 759                 oldvalue = ft ? ft->projfilecmds : NULL;
 760                 build_read_project(ft, e->build_properties);
 761
 762                 if (ft != NULL && ft->projfilecmds != oldvalue && ft->project_list_entry < 0)
 763                 {
 764                         if (p->build_filetypes_list == NULL)
 765                                 p->build_filetypes_list = g_ptr_array_new();
 766                         ft->project_list_entry = p->build_filetypes_list->len;
 767                         g_ptr_array_add(p->build_filetypes_list, ft);
 768                 }
 769                 build_menu_update(doc);
 770
 771                 widget = ui_lookup_widget(e->dialog, "radio_long_line_disabled_project");
 772                 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
 773                         p->long_line_behaviour = 0;
 774                 else
 775                 {
 776                         widget = ui_lookup_widget(e->dialog, "radio_long_line_default_project");
 777                         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
 778                                 p->long_line_behaviour = 1;
 779                         else
 780                                 /* "Custom" radio button must be checked */
 781                                 p->long_line_behaviour = 2;
 782                 }
 783
 784                 widget = ui_lookup_widget(e->dialog, "spin_long_line_project");
 785                 p->long_line_column = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
 786                 apply_editor_prefs();
 787
 788                 /* get and set the project file patterns */
 789                 tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(e->patterns)));
 790                 g_strfreev(p->file_patterns);
 791                 g_strstrip(tmp);
 792                 str = g_string_new(tmp);
 793                 do {} while (utils_string_replace_all(str, "  ", " "));
 794                 p->file_patterns = g_strsplit(str->str, " ", -1);
 795                 g_string_free(str, TRUE);
 796                 g_free(tmp);
 797         }
 798
 799         update_ui();
 800
 801         return TRUE;
 802 }
 803
 804
 805 #ifndef G_OS_WIN32
 806 static void run_dialog(GtkWidget *dialog, GtkWidget *entry)
 807 {
 808         /* set filename in the file chooser dialog */
 809         const gchar *utf8_filename = gtk_entry_get_text(GTK_ENTRY(entry));
 810         gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename);
 811
 812         if (g_path_is_absolute(locale_filename))
 813         {
 814                 if (g_file_test(locale_filename, G_FILE_TEST_EXISTS))
 815                 {
 816                         /* if the current filename is a directory, we must use
 817                          * gtk_file_chooser_set_current_folder(which expects a locale filename) otherwise
 818                          * we end up in the parent directory */
 819                         if (g_file_test(locale_filename, G_FILE_TEST_IS_DIR))
 820                                 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_filename);
 821                         else
 822                                 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), utf8_filename);
 823                 }
 824                 else /* if the file doesn't yet exist, use at least the current directory */
 825                 {
 826                         gchar *locale_dir = g_path_get_dirname(locale_filename);
 827                         gchar *name = g_path_get_basename(utf8_filename);
 828
 829                         if (g_file_test(locale_dir, G_FILE_TEST_EXISTS))
 830                                 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dir);
 831                         gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), name);
 832
 833                         g_free(name);
 834                         g_free(locale_dir);
 835                 }
 836         }
 837         else if (gtk_file_chooser_get_action(GTK_FILE_CHOOSER(dialog)) != GTK_FILE_CHOOSER_ACTION_OPEN)
 838         {
 839                 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), utf8_filename);
 840         }
 841         g_free(locale_filename);
 842
 843         /* run it */
 844         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
 845         {
 846                 gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
 847                 gchar *tmp_utf8_filename = utils_get_utf8_from_locale(filename);
 848
 849                 gtk_entry_set_text(GTK_ENTRY(entry), tmp_utf8_filename);
 850
 851                 g_free(tmp_utf8_filename);
 852                 g_free(filename);
 853         }
 854         gtk_widget_destroy(dialog);
 855 }
 856 #endif
 857
 858
 859 static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElements *e)
 860 {
 861 #ifdef G_OS_WIN32
 862         gchar *path = win32_show_project_open_dialog(e->dialog, _("Choose Project Filename"),
 863                                                 gtk_entry_get_text(GTK_ENTRY(e->file_name)), TRUE, TRUE);
 864         if (path != NULL)
 865         {
 866                 gtk_entry_set_text(GTK_ENTRY(e->file_name), path);
 867                 g_free(path);
 868         }
 869 #else
 870         GtkWidget *dialog;
 871
 872         /* initialise the dialog */
 873         dialog = gtk_file_chooser_dialog_new(_("Choose Project Filename"), NULL,
 874                                         GTK_FILE_CHOOSER_ACTION_SAVE,
 875                                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 876                                         GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
 877         gtk_widget_set_name(dialog, "GeanyDialogProject");
 878         gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
 879         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
 880         gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
 881         gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
 882
 883         run_dialog(dialog, e->file_name);
 884 #endif
 885 }
 886
 887
 888 /* sets the project base path and the project file name according to the project name */
 889 static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e)
 890 {
 891         gchar *base_path;
 892         gchar *file_name;
 893         gchar *name;
 894         const gchar *project_dir = local_prefs.project_file_path;
 895
 896         if (entries_modified)
 897                 return;
 898
 899         name = gtk_editable_get_chars(editable, 0, -1);
 900         if (NZV(name))
 901         {
 902                 base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S,
 903                         name, G_DIR_SEPARATOR_S, NULL);
 904                 if (project_prefs.project_file_in_basedir)
 905                         file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S,
 906                                 name, "." GEANY_PROJECT_EXT, NULL);
 907                 else
 908                         file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S,
 909                                 name, "." GEANY_PROJECT_EXT, NULL);
 910         }
 911         else
 912         {
 913                 base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL);
 914                 file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL);
 915         }
 916         g_free(name);
 917
 918         gtk_entry_set_text(GTK_ENTRY(e->base_path), base_path);
 919         gtk_entry_set_text(GTK_ENTRY(e->file_name), file_name);
 920
 921         entries_modified = FALSE;
 922
 923         g_free(base_path);
 924         g_free(file_name);
 925 }
 926
 927
 928 static void on_entries_changed(GtkEditable *editable, PropertyDialogElements *e)
 929 {
 930         entries_modified = TRUE;
 931 }
 932
 933
 934 static void on_radio_long_line_custom_toggled(GtkToggleButton *radio, GtkWidget *spin_long_line)
 935 {
 936         gtk_widget_set_sensitive(spin_long_line, gtk_toggle_button_get_active(radio));
 937 }
 938
 939
 940 gboolean project_load_file(const gchar *locale_file_name)
 941 {
 942         g_return_val_if_fail(locale_file_name != NULL, FALSE);
 943
 944         if (load_config(locale_file_name))
 945         {
 946                 gchar *utf8_filename = utils_get_utf8_from_locale(locale_file_name);
 947
 948                 ui_set_statusbar(TRUE, _("Project \"%s\" opened."), app->project->name);
 949
 950                 ui_add_recent_project_file(utf8_filename);
 951                 g_free(utf8_filename);
 952                 return TRUE;
 953         }
 954         else
 955         {
 956                 gchar *utf8_filename = utils_get_utf8_from_locale(locale_file_name);
 957
 958                 ui_set_statusbar(TRUE, _("Project file \"%s\" could not be loaded."), utf8_filename);
 959                 g_free(utf8_filename);
 960         }
 961         return FALSE;
 962 }
 963
 964
 965 /* Reads the given filename and creates a new project with the data found in the file.
 966  * At this point there should not be an already opened project in Geany otherwise it will just
 967  * return.
 968  * The filename is expected in the locale encoding. */
 969 static gboolean load_config(const gchar *filename)
 970 {
 971         GKeyFile *config;
 972         GeanyProject *p;
 973         GSList *node;
 974
 975         /* there should not be an open project */
 976         g_return_val_if_fail(app->project == NULL && filename != NULL, FALSE);
 977
 978         config = g_key_file_new();
 979         if (! g_key_file_load_from_file(config, filename, G_KEY_FILE_NONE, NULL))
 980         {
 981                 g_key_file_free(config);
 982                 return FALSE;
 983         }
 984
 985         p = create_project();
 986
 987         foreach_slist(node, stash_groups)
 988                 stash_group_load_from_key_file(node->data, config);
 989
 990         p->name = utils_get_setting_string(config, "project", "name", GEANY_STRING_UNTITLED);
 991         p->description = utils_get_setting_string(config, "project", "description", "");
 992         p->file_name = utils_get_utf8_from_locale(filename);
 993         p->base_path = utils_get_setting_string(config, "project", "base_path", "");
 994         p->file_patterns = g_key_file_get_string_list(config, "project", "file_patterns", NULL, NULL);
 995
 996         p->long_line_behaviour = utils_get_setting_integer(config, "long line marker",
 997                 "long_line_behaviour", 1 /* follow global */);
 998         p->long_line_column = utils_get_setting_integer(config, "long line marker",
 999                 "long_line_column", editor_prefs.long_line_column);
1000         apply_editor_prefs();
1001
1002         build_load_menu(config, GEANY_BCS_PROJ, (gpointer)p);
1003         if (project_prefs.project_session)
1004         {
1005                 /* save current (non-project) session (it could has been changed since program startup) */
1006                 configuration_save_default_session();
1007                 /* now close all open files */
1008                 document_close_all();
1009                 /* read session files so they can be opened with configuration_open_files() */
1010                 configuration_load_session_files(config, FALSE);
1011                 ui_focus_current_document();
1012         }
1013         g_signal_emit_by_name(geany_object, "project-open", config);
1014         g_key_file_free(config);
1015
1016         update_ui();
1017         return TRUE;
1018 }
1019
1020
1021 static void apply_editor_prefs(void)
1022 {
1023         guint i;
1024
1025         foreach_document(i)
1026                 editor_apply_update_prefs(documents[i]->editor);
1027 }
1028
1029
1030 /* Write the project settings as well as the project session files into its configuration files.
1031  * emit_signal defines whether the project-save signal should be emitted. When write_config()
1032  * is called while closing a project, this is used to skip emitting the signal because
1033  * project-close will be emitted afterwards.
1034  * Returns: TRUE if project file was written successfully. */
1035 static gboolean write_config(gboolean emit_signal)
1036 {
1037         GeanyProject *p;
1038         GKeyFile *config;
1039         gchar *filename;
1040         gchar *data;
1041         gboolean ret = FALSE;
1042         GSList *node;
1043
1044         g_return_val_if_fail(app->project != NULL, FALSE);
1045
1046         p = app->project;
1047
1048         config = g_key_file_new();
1049         /* try to load an existing config to keep manually added comments */
1050         filename = utils_get_locale_from_utf8(p->file_name);
1051         g_key_file_load_from_file(config, filename, G_KEY_FILE_NONE, NULL);
1052
1053         foreach_slist(node, stash_groups)
1054                 stash_group_save_to_key_file(node->data, config);
1055
1056         g_key_file_set_string(config, "project", "name", p->name);
1057         g_key_file_set_string(config, "project", "base_path", p->base_path);
1058
1059         if (p->description)
1060                 g_key_file_set_string(config, "project", "description", p->description);
1061         if (p->file_patterns)
1062                 g_key_file_set_string_list(config, "project", "file_patterns",
1063                         (const gchar**) p->file_patterns, g_strv_length(p->file_patterns));
1064
1065         g_key_file_set_integer(config, "long line marker", "long_line_behaviour", p->long_line_behaviour);
1066         g_key_file_set_integer(config, "long line marker", "long_line_column", p->long_line_column);
1067
1068         /* store the session files into the project too */
1069         if (project_prefs.project_session)
1070                 configuration_save_session_files(config);
1071         build_save_menu(config, (gpointer)p, GEANY_BCS_PROJ);
1072         if (emit_signal)
1073         {
1074                 g_signal_emit_by_name(geany_object, "project-save", config);
1075         }
1076         /* write the file */
1077         data = g_key_file_to_data(config, NULL, NULL);
1078         ret = (utils_write_file(filename, data) == 0);
1079
1080         g_free(data);
1081         g_free(filename);
1082         g_key_file_free(config);
1083
1084         return ret;
1085 }
1086
1087
1088 /* Constructs the project's base path which is used for "Make all" and "Execute".
1089  * The result is an absolute string in UTF-8 encoding which is either the same as
1090  * base path if it is absolute or it is built out of project file name's dir and base_path.
1091  * If there is no project or project's base_path is invalid, NULL will be returned.
1092  * The returned string should be freed when no longer needed. */
1093 gchar *project_get_base_path(void)
1094 {
1095         GeanyProject *project = app->project;
1096
1097         if (project && NZV(project->base_path))
1098         {
1099                 if (g_path_is_absolute(project->base_path))
1100                         return g_strdup(project->base_path);
1101                 else
1102                 {       /* build base_path out of project file name's dir and base_path */
1103                         gchar *path;
1104                         gchar *dir = g_path_get_dirname(project->file_name);
1105
1106                         if (utils_str_equal(project->base_path, "./"))
1107                                 return dir;
1108
1109                         path = g_build_filename(dir, project->base_path, NULL);
1110                         g_free(dir);
1111                         return path;
1112                 }
1113         }
1114         return NULL;
1115 }
1116
1117
1118 /* This is to save project-related global settings, NOT project file settings. */
1119 void project_save_prefs(GKeyFile *config)
1120 {
1121         GeanyProject *project = app->project;
1122
1123         if (cl_options.load_session)
1124         {
1125                 const gchar *utf8_filename = (project == NULL) ? "" : project->file_name;
1126
1127                 g_key_file_set_string(config, "project", "session_file", utf8_filename);
1128         }
1129         g_key_file_set_string(config, "project", "project_file_path",
1130                 NVL(local_prefs.project_file_path, ""));
1131 }
1132
1133
1134 void project_load_prefs(GKeyFile *config)
1135 {
1136         if (cl_options.load_session)
1137         {
1138                 g_return_if_fail(project_prefs.session_file == NULL);
1139                 project_prefs.session_file = utils_get_setting_string(config, "project",
1140                         "session_file", "");
1141         }
1142         local_prefs.project_file_path = utils_get_setting_string(config, "project",
1143                 "project_file_path", NULL);
1144         if (local_prefs.project_file_path == NULL)
1145         {
1146                 local_prefs.project_file_path = g_build_filename(g_get_home_dir(), PROJECT_DIR, NULL);
1147         }
1148 }
1149
1150
1151 /* Initialize project-related preferences in the Preferences dialog. */
1152 void project_setup_prefs(void)
1153 {
1154         GtkWidget *path_entry = ui_lookup_widget(ui_widgets.prefs_dialog, "project_file_path_entry");
1155         GtkWidget *path_btn = ui_lookup_widget(ui_widgets.prefs_dialog, "project_file_path_button");
1156         static gboolean callback_setup = FALSE;
1157
1158         g_return_if_fail(local_prefs.project_file_path != NULL);
1159
1160         gtk_entry_set_text(GTK_ENTRY(path_entry), local_prefs.project_file_path);
1161         if (! callback_setup)
1162         {       /* connect the callback only once */
1163                 callback_setup = TRUE;
1164                 ui_setup_open_button_callback(path_btn, NULL,
1165                         GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_ENTRY(path_entry));
1166         }
1167 }
1168
1169
1170 /* Update project-related preferences after using the Preferences dialog. */
1171 void project_apply_prefs(void)
1172 {
1173         GtkWidget *path_entry = ui_lookup_widget(ui_widgets.prefs_dialog, "project_file_path_entry");
1174         const gchar *str;
1175
1176         str = gtk_entry_get_text(GTK_ENTRY(path_entry));
1177         SETPTR(local_prefs.project_file_path, g_strdup(str));
1178 }
1179
1180
1181 static void add_stash_group(StashGroup *group)
1182 {
1183         stash_groups = g_slist_prepend(stash_groups, group);
1184 }
1185
1186
1187 static void init_stash_prefs(void)
1188 {
1189         StashGroup *group;
1190         GKeyFile *kf;
1191
1192         group = stash_group_new("indentation");
1193         /* copy global defaults */
1194         indentation = *editor_get_indent_prefs(NULL);
1195         stash_group_set_use_defaults(group, FALSE);
1196         add_stash_group(group);
1197
1198         stash_group_add_spin_button_integer(group, &indentation.width,
1199                 "indent_width", 4, "spin_indent_width_project");
1200         stash_group_add_radio_buttons(group, (gint*)(gpointer)&indentation.type,
1201                 "indent_type", GEANY_INDENT_TYPE_TABS,
1202                 "radio_indent_spaces_project", GEANY_INDENT_TYPE_SPACES,
1203                 "radio_indent_tabs_project", GEANY_INDENT_TYPE_TABS,
1204                 "radio_indent_both_project", GEANY_INDENT_TYPE_BOTH,
1205                 NULL);
1206         /* This is a 'hidden' pref for backwards-compatibility */
1207         stash_group_add_integer(group, &indentation.hard_tab_width,
1208                 "indent_hard_tab_width", 8);
1209         stash_group_add_toggle_button(group, &indentation.detect_type,
1210                 "detect_indent", FALSE, "check_detect_indent_type_project");
1211         stash_group_add_toggle_button(group, &indentation.detect_width,
1212                 "detect_indent_width", FALSE, "check_detect_indent_width_project");
1213         stash_group_add_combo_box(group, (gint*)(gpointer)&indentation.auto_indent_mode,
1214                 "indent_mode", GEANY_AUTOINDENT_CURRENTCHARS, "combo_auto_indent_mode_project");
1215
1216         group = stash_group_new("file_prefs");
1217         stash_group_add_toggle_button(group, &priv.final_new_line,
1218                 "final_new_line", file_prefs.final_new_line, "check_new_line1");
1219         stash_group_add_toggle_button(group, &priv.ensure_convert_new_lines,
1220                 "ensure_convert_new_lines", file_prefs.ensure_convert_new_lines, "check_ensure_convert_new_lines1");
1221         stash_group_add_toggle_button(group, &priv.strip_trailing_spaces,
1222                 "strip_trailing_spaces", file_prefs.strip_trailing_spaces, "check_trailing_spaces1");
1223         stash_group_add_toggle_button(group, &priv.replace_tabs,
1224                 "replace_tabs", file_prefs.replace_tabs, "check_replace_tabs1");
1225         add_stash_group(group);
1226         /* apply defaults */
1227         kf = g_key_file_new();
1228         stash_group_load_from_key_file(group, kf);
1229         g_key_file_free(kf);
1230 }
1231
1232
1233 #define COPY_PREF(dest, prefname)\
1234         (dest.prefname = priv.prefname)
1235
1236 const GeanyFilePrefs *project_get_file_prefs(void)
1237 {
1238         static GeanyFilePrefs fp;
1239
1240         if (!app->project)
1241                 return &file_prefs;
1242
1243         fp = file_prefs;
1244         COPY_PREF(fp, final_new_line);
1245         COPY_PREF(fp, ensure_convert_new_lines);
1246         COPY_PREF(fp, strip_trailing_spaces);
1247         COPY_PREF(fp, replace_tabs);
1248         return &fp;
1249 }
1250
1251
1252 void project_init(void)
1253 {
1254 }
1255
1256
1257 void project_finalize(void)
1258 {
1259 }