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