?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add the go ctags parser
[geany-mirror.git] / src / dialogs.c
blobc0d1dd84e86f5d405dd60ec1a3bed2ce25c95350
1 /*
2 * dialogs.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 /*
23 * File related dialogs, miscellaneous dialogs, font dialog.
24 */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include "dialogs.h"
31
32 #include "app.h"
33 #include "build.h"
34 #include "document.h"
35 #include "encodings.h"
36 #include "filetypes.h"
37 #include "main.h"
38 #include "support.h"
39 #include "utils.h"
40 #include "ui_utils.h"
41 #include "win32.h"
42
43 #include "gtkcompat.h"
44
45 #include <gdk/gdkkeysyms.h>
46 #include <string.h>
47
48 #ifdef HAVE_SYS_TIME_H
49 # include <sys/time.h>
50 #endif
51 #include <time.h>
52
53 #ifdef HAVE_SYS_TYPES_H
54 # include <sys/types.h>
55 #endif
56
57 /* gstdio.h also includes sys/stat.h */
58 #include <glib/gstdio.h>
59
60
61 enum
62 {
63 GEANY_RESPONSE_RENAME,
64 GEANY_RESPONSE_VIEW
65 };
66
67
68 static struct FileSelState
69 {
70 struct
71 {
72 guint filter_idx;
73 gint encoding_idx;
74 gint filetype_idx;
75 gboolean show_hidden;
76 gboolean more_options_visible;
77 } open;
78 }
79 filesel_state = {
80 {
81 0,
82 GEANY_ENCODINGS_MAX, /* default encoding is detect from file */
83 GEANY_FILETYPES_NONE, /* default filetype is detect from extension */
84 FALSE,
85 FALSE
86 }
87 };
88
89
90 static gint filetype_combo_box_get_active_filetype(GtkComboBox *combo);
91
92
93 /* gets the ID of the current file filter */
94 static guint file_chooser_get_filter_idx(GtkFileChooser *chooser)
95 {
96 guint idx = 0;
97 GtkFileFilter *current;
98 GSList *filters, *item;
99
100 current = gtk_file_chooser_get_filter(chooser);
101 filters = gtk_file_chooser_list_filters(chooser);
102 foreach_slist(item, filters)
103 {
104 if (item->data == current)
105 break;
106 idx ++;
107 }
108 g_slist_free(filters);
109 return idx;
110 }
111
112
113 /* sets the current file filter from its ID */
114 static void file_chooser_set_filter_idx(GtkFileChooser *chooser, guint idx)
115 {
116 GtkFileFilter *current;
117 GSList *filters;
118
119 filters = gtk_file_chooser_list_filters(chooser);
120 current = g_slist_nth_data(filters, idx);
121 g_slist_free(filters);
122 gtk_file_chooser_set_filter(chooser, current);
123 }
124
125
126 static gboolean open_file_dialog_handle_response(GtkWidget *dialog, gint response)
127 {
128 gboolean ret = TRUE;
129
130 if (response == GTK_RESPONSE_ACCEPT || response == GEANY_RESPONSE_VIEW)
131 {
132 GSList *filelist;
133 GeanyFiletype *ft = NULL;
134 const gchar *charset = NULL;
135 GtkWidget *expander = ui_lookup_widget(dialog, "more_options_expander");
136 GtkWidget *filetype_combo = ui_lookup_widget(dialog, "filetype_combo");
137 GtkWidget *encoding_combo = ui_lookup_widget(dialog, "encoding_combo");
138 gboolean ro = (response == GEANY_RESPONSE_VIEW); /* View clicked */
139
140 filesel_state.open.more_options_visible = gtk_expander_get_expanded(GTK_EXPANDER(expander));
141 filesel_state.open.filter_idx = file_chooser_get_filter_idx(GTK_FILE_CHOOSER(dialog));
142 filesel_state.open.filetype_idx = filetype_combo_box_get_active_filetype(GTK_COMBO_BOX(filetype_combo));
143
144 /* ignore detect from file item */
145 if (filesel_state.open.filetype_idx > 0)
146 ft = filetypes_index(filesel_state.open.filetype_idx);
147
148 filesel_state.open.encoding_idx = ui_encodings_combo_box_get_active_encoding(GTK_COMBO_BOX(encoding_combo));
149 if (filesel_state.open.encoding_idx >= 0 && filesel_state.open.encoding_idx < GEANY_ENCODINGS_MAX)
150 charset = encodings[filesel_state.open.encoding_idx].charset;
151
152 filelist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
153 if (filelist != NULL)
154 {
155 const gchar *first = filelist->data;
156
157 // When there's only one filename it may have been typed manually
158 if (!filelist->next && !g_file_test(first, G_FILE_TEST_EXISTS))
159 {
160 dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("\"%s\" was not found."), first);
161 ret = FALSE;
162 }
163 else
164 {
165 document_open_files(filelist, ro, ft, charset);
166 }
167 g_slist_foreach(filelist, (GFunc) g_free, NULL); /* free filenames */
168 }
169 g_slist_free(filelist);
170 }
171 if (app->project && !EMPTY(app->project->base_path))
172 gtk_file_chooser_remove_shortcut_folder(GTK_FILE_CHOOSER(dialog),
173 app->project->base_path, NULL);
174 return ret;
175 }
176
177
178 static void on_file_open_show_hidden_notify(GObject *filechooser,
179 GParamSpec *pspec, gpointer data)
180 {
181 GtkWidget *toggle_button;
182
183 toggle_button = ui_lookup_widget(GTK_WIDGET(filechooser), "check_hidden");
184
185 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_button),
186 gtk_file_chooser_get_show_hidden(GTK_FILE_CHOOSER(filechooser)));
187 }
188
189
190 static void
191 on_file_open_check_hidden_toggled(GtkToggleButton *togglebutton, GtkWidget *dialog)
192 {
193 filesel_state.open.show_hidden = gtk_toggle_button_get_active(togglebutton);
194 gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), filesel_state.open.show_hidden);
195 }
196
197
198 static void filetype_combo_cell_data_func(GtkCellLayout *cell_layout, GtkCellRenderer *cell,
199 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
200 {
201 gboolean sensitive = !gtk_tree_model_iter_has_child(tree_model, iter);
202 gchar *text;
203
204 gtk_tree_model_get(tree_model, iter, 1, &text, -1);
205 g_object_set(cell, "sensitive", sensitive, "text", text, NULL);
206 g_free(text);
207 }
208
209
210 static GtkWidget *create_filetype_combo_box(void)
211 {
212 GtkTreeStore *store;
213 GtkTreeIter iter_compiled, iter_script, iter_markup, iter_misc, iter_detect;
214 GtkTreeIter *iter_parent;
215 GtkWidget *combo;
216 GtkCellRenderer *renderer;
217 GSList *node;
218
219 store = gtk_tree_store_new(2, G_TYPE_INT, G_TYPE_STRING);
220
221 gtk_tree_store_insert_with_values(store, &iter_detect, NULL, -1,
222 0, GEANY_FILETYPES_NONE, 1, _("Detect from file"), -1);
223
224 gtk_tree_store_insert_with_values(store, &iter_compiled, NULL, -1,
225 0, -1, 1, _("Programming Languages"), -1);
226 gtk_tree_store_insert_with_values(store, &iter_script, NULL, -1,
227 0, -1, 1, _("Scripting Languages"), -1);
228 gtk_tree_store_insert_with_values(store, &iter_markup, NULL, -1,
229 0, -1, 1, _("Markup Languages"), -1);
230 gtk_tree_store_insert_with_values(store, &iter_misc, NULL, -1,
231 0, -1, 1, _("Miscellaneous"), -1);
232
233 foreach_slist (node, filetypes_by_title)
234 {
235 GeanyFiletype *ft = node->data;
236
237 if (ft->id == GEANY_FILETYPES_NONE)
238 continue;
239
240 switch (ft->group)
241 {
242 case GEANY_FILETYPE_GROUP_COMPILED: iter_parent = &iter_compiled; break;
243 case GEANY_FILETYPE_GROUP_SCRIPT: iter_parent = &iter_script; break;
244 case GEANY_FILETYPE_GROUP_MARKUP: iter_parent = &iter_markup; break;
245 case GEANY_FILETYPE_GROUP_MISC: iter_parent = &iter_misc; break;
246 case GEANY_FILETYPE_GROUP_NONE:
247 default: iter_parent = NULL;
248 }
249 gtk_tree_store_insert_with_values(store, NULL, iter_parent, -1,
250 0, (gint) ft->id, 1, ft->title, -1);
251 }
252
253 combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
254 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter_detect);
255 renderer = gtk_cell_renderer_text_new();
256 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
257 gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo), renderer,
258 filetype_combo_cell_data_func, NULL, NULL);
259
260 g_object_unref(store);
261
262 return combo;
263 }
264
265
266 static gint filetype_combo_box_get_active_filetype(GtkComboBox *combo)
267 {
268 gint id = 0;
269 GtkTreeIter iter;
270
271 if (gtk_combo_box_get_active_iter(combo, &iter))
272 {
273 GtkTreeModel *model = gtk_combo_box_get_model(combo);
274 gtk_tree_model_get(model, &iter, 0, &id, -1);
275 }
276 return id;
277 }
278
279
280 static gboolean filetype_combo_box_set_active_filetype(GtkComboBox *combo, const gint id)
281 {
282 GtkTreeModel *model = gtk_combo_box_get_model(combo);
283 GtkTreeIter iter;
284
285 if (gtk_tree_model_get_iter_first(model, &iter))
286 {
287 do
288 {
289 gint row_id;
290 gtk_tree_model_get(model, &iter, 0, &row_id, -1);
291 if (id == row_id)
292 {
293 gtk_combo_box_set_active_iter(combo, &iter);
294 return TRUE;
295 }
296 }
297 while (ui_tree_model_iter_any_next(model, &iter, TRUE));
298 }
299 return FALSE;
300 }
301
302
303 static GtkWidget *add_file_open_extra_widget(GtkWidget *dialog)
304 {
305 GtkWidget *expander, *vbox, *table, *check_hidden;
306 GtkWidget *filetype_ebox, *filetype_label, *filetype_combo;
307 GtkWidget *encoding_ebox, *encoding_label, *encoding_combo;
308
309 expander = gtk_expander_new_with_mnemonic(_("_More Options"));
310 vbox = gtk_vbox_new(FALSE, 6);
311 gtk_container_add(GTK_CONTAINER(expander), vbox);
312
313 table = gtk_table_new(2, 4, FALSE);
314
315 /* line 1 with checkbox and encoding combo */
316 check_hidden = gtk_check_button_new_with_mnemonic(_("Show _hidden files"));
317 gtk_widget_show(check_hidden);
318 gtk_table_attach(GTK_TABLE(table), check_hidden, 0, 1, 0, 1,
319 (GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
320 (GtkAttachOptions) (0), 0, 5);
321
322 /* spacing */
323 gtk_table_attach(GTK_TABLE(table), gtk_label_new(""), 1, 2, 0, 1,
324 (GtkAttachOptions) (GTK_FILL),
325 (GtkAttachOptions) (0), 5, 5);
326
327 encoding_label = gtk_label_new(_("Set encoding:"));
328 gtk_misc_set_alignment(GTK_MISC(encoding_label), 1, 0);
329 gtk_table_attach(GTK_TABLE(table), encoding_label, 2, 3, 0, 1,
330 (GtkAttachOptions) (GTK_FILL),
331 (GtkAttachOptions) (0), 4, 5);
332 /* the ebox is for the tooltip, because gtk_combo_box can't show tooltips */
333 encoding_ebox = gtk_event_box_new();
334 encoding_combo = ui_create_encodings_combo_box(TRUE, GEANY_ENCODINGS_MAX);
335 gtk_widget_set_tooltip_text(encoding_ebox,
336 _("Explicitly defines an encoding for the file, if it would not be detected. This is useful when you know that the encoding of a file cannot be detected correctly by Geany.\nNote if you choose multiple files, they will all be opened with the chosen encoding."));
337 gtk_container_add(GTK_CONTAINER(encoding_ebox), encoding_combo);
338 gtk_table_attach(GTK_TABLE(table), encoding_ebox, 3, 4, 0, 1,
339 (GtkAttachOptions) (GTK_FILL),
340 (GtkAttachOptions) (0), 0, 5);
341
342 /* line 2 with filetype combo */
343 filetype_label = gtk_label_new(_("Set filetype:"));
344 gtk_misc_set_alignment(GTK_MISC(filetype_label), 1, 0);
345 gtk_table_attach(GTK_TABLE(table), filetype_label, 2, 3, 1, 2,
346 (GtkAttachOptions) (GTK_FILL),
347 (GtkAttachOptions) (0), 4, 5);
348 /* the ebox is for the tooltip, because gtk_combo_box can't show tooltips */
349 filetype_ebox = gtk_event_box_new();
350 filetype_combo = create_filetype_combo_box();
351 gtk_widget_set_tooltip_text(filetype_ebox,
352 _("Explicitly defines a filetype for the file, if it would not be detected by filename extension.\nNote if you choose multiple files, they will all be opened with the chosen filetype."));
353 gtk_container_add(GTK_CONTAINER(filetype_ebox), filetype_combo);
354 gtk_table_attach(GTK_TABLE(table), filetype_ebox, 3, 4, 1, 2,
355 (GtkAttachOptions) (GTK_FILL),
356 (GtkAttachOptions) (0), 0, 5);
357
358 gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
359 gtk_widget_show_all(vbox);
360
361 g_signal_connect(check_hidden, "toggled", G_CALLBACK(on_file_open_check_hidden_toggled), dialog);
362
363 ui_hookup_widget(dialog, expander, "more_options_expander");
364 ui_hookup_widget(dialog, check_hidden, "check_hidden");
365 ui_hookup_widget(dialog, filetype_combo, "filetype_combo");
366 ui_hookup_widget(dialog, encoding_combo, "encoding_combo");
367
368 return expander;
369 }
370
371
372 static GtkWidget *create_open_file_dialog(void)
373 {
374 GtkWidget *dialog;
375 GtkWidget *viewbtn;
376 GSList *node;
377
378 dialog = gtk_file_chooser_dialog_new(_("Open File"), GTK_WINDOW(main_widgets.window),
379 GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
380 gtk_widget_set_name(dialog, "GeanyDialog");
381
382 viewbtn = gtk_dialog_add_button(GTK_DIALOG(dialog), C_("Open dialog action", "_View"), GEANY_RESPONSE_VIEW);
383 gtk_widget_set_tooltip_text(viewbtn,
384 _("Opens the file in read-only mode. If you choose more than one file to open, all files will be opened read-only."));
385
386 gtk_dialog_add_buttons(GTK_DIALOG(dialog),
387 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
388 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
389 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
390
391 gtk_widget_set_size_request(dialog, -1, 460);
392 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
393 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
394 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), FALSE);
395 gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
396 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
397 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
398 gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), FALSE);
399
400 /* add checkboxes and filename entry */
401 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), add_file_open_extra_widget(dialog));
402
403 /* add FileFilters(start with "All Files") */
404 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),
405 filetypes_create_file_filter(filetypes[GEANY_FILETYPES_NONE]));
406 /* now create meta filter "All Source" */
407 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),
408 filetypes_create_file_filter_all_source());
409 foreach_slist(node, filetypes_by_title)
410 {
411 GeanyFiletype *ft = node->data;
412
413 if (G_UNLIKELY(ft->id == GEANY_FILETYPES_NONE))
414 continue;
415 gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filetypes_create_file_filter(ft));
416 }
417
418 g_signal_connect(dialog, "notify::show-hidden",
419 G_CALLBACK(on_file_open_show_hidden_notify), NULL);
420
421 return dialog;
422 }
423
424
425 static void open_file_dialog_apply_settings(GtkWidget *dialog)
426 {
427 static gboolean initialized = FALSE;
428 GtkWidget *check_hidden = ui_lookup_widget(dialog, "check_hidden");
429 GtkWidget *filetype_combo = ui_lookup_widget(dialog, "filetype_combo");
430 GtkWidget *encoding_combo = ui_lookup_widget(dialog, "encoding_combo");
431 GtkWidget *expander = ui_lookup_widget(dialog, "more_options_expander");
432
433 /* we can't know the initial position of combo boxes, so retreive it the first time */
434 if (! initialized)
435 {
436 filesel_state.open.filter_idx = file_chooser_get_filter_idx(GTK_FILE_CHOOSER(dialog));
437
438 initialized = TRUE;
439 }
440 else
441 {
442 file_chooser_set_filter_idx(GTK_FILE_CHOOSER(dialog), filesel_state.open.filter_idx);
443 }
444 gtk_expander_set_expanded(GTK_EXPANDER(expander), filesel_state.open.more_options_visible);
445 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_hidden), filesel_state.open.show_hidden);
446 ui_encodings_combo_box_set_active_encoding(GTK_COMBO_BOX(encoding_combo), filesel_state.open.encoding_idx);
447 filetype_combo_box_set_active_filetype(GTK_COMBO_BOX(filetype_combo), filesel_state.open.filetype_idx);
448 }
449
450
451 /* This shows the file selection dialog to open a file. */
452 void dialogs_show_open_file(void)
453 {
454 gchar *initdir;
455
456 /* set dialog directory to the current file's directory, if present */
457 initdir = utils_get_current_file_dir_utf8();
458
459 /* use project or default startup directory (if set) if no files are open */
460 /** TODO should it only be used when initally open the dialog and not on every show? */
461 if (! initdir)
462 initdir = g_strdup(utils_get_default_dir_utf8());
463
464 SETPTR(initdir, utils_get_locale_from_utf8(initdir));
465
466 #ifdef G_OS_WIN32
467 if (interface_prefs.use_native_windows_dialogs)
468 win32_show_document_open_dialog(GTK_WINDOW(main_widgets.window), _("Open File"), initdir);
469 else
470 #endif
471 {
472 GtkWidget *dialog = create_open_file_dialog();
473
474 open_file_dialog_apply_settings(dialog);
475
476 if (initdir != NULL && g_path_is_absolute(initdir))
477 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), initdir);
478
479 if (app->project && !EMPTY(app->project->base_path))
480 gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),
481 app->project->base_path, NULL);
482
483 while (!open_file_dialog_handle_response(dialog,
484 gtk_dialog_run(GTK_DIALOG(dialog))));
485 gtk_widget_destroy(dialog);
486 }
487 g_free(initdir);
488 }
489
490
491 static gboolean handle_save_as(const gchar *utf8_filename, gboolean rename_file)
492 {
493 GeanyDocument *doc = document_get_current();
494 gboolean success = FALSE;
495
496 g_return_val_if_fail(!EMPTY(utf8_filename), FALSE);
497
498 if (doc->file_name != NULL)
499 {
500 if (rename_file)
501 {
502 document_rename_file(doc, utf8_filename);
503 }
504 /* create a new tm_source_file object otherwise tagmanager won't work correctly */
505 tm_workspace_remove_object(doc->tm_file, TRUE, TRUE);
506 doc->tm_file = NULL;
507 }
508 success = document_save_file_as(doc, utf8_filename);
509
510 build_menu_update(doc);
511 return success;
512 }
513
514
515 static gboolean save_as_dialog_handle_response(GtkWidget *dialog, gint response)
516 {
517 gboolean rename_file = FALSE;
518 gboolean success = FALSE;
519 gchar *new_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
520
521 switch (response)
522 {
523 case GEANY_RESPONSE_RENAME:
524 /* rename doesn't check for empty filename or overwriting */
525 if (G_UNLIKELY(EMPTY(new_filename)))
526 {
527 utils_beep();
528 break;
529 }
530 if (g_file_test(new_filename, G_FILE_TEST_EXISTS) &&
531 !dialogs_show_question_full(NULL, NULL, NULL,
532 _("Overwrite?"),
533 _("Filename already exists!")))
534 break;
535 rename_file = TRUE;
536 /* fall through */
537 case GTK_RESPONSE_ACCEPT:
538 {
539 gchar *utf8_filename;
540
541 utf8_filename = utils_get_utf8_from_locale(new_filename);
542 success = handle_save_as(utf8_filename, rename_file);
543 g_free(utf8_filename);
544 break;
545 }
546 case GTK_RESPONSE_DELETE_EVENT:
547 case GTK_RESPONSE_CANCEL:
548 success = TRUE;
549 break;
550 }
551 g_free(new_filename);
552
553 return success;
554 }
555
556
557 static GtkWidget *create_save_file_dialog(GeanyDocument *doc)
558 {
559 GtkWidget *dialog, *rename_btn;
560 const gchar *initdir;
561
562 dialog = gtk_file_chooser_dialog_new(_("Save File"), GTK_WINDOW(main_widgets.window),
563 GTK_FILE_CHOOSER_ACTION_SAVE, NULL, NULL);
564 gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
565 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
566 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), FALSE);
567 gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
568 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
569 gtk_widget_set_name(dialog, "GeanyDialog");
570
571 rename_btn = gtk_dialog_add_button(GTK_DIALOG(dialog), _("R_ename"), GEANY_RESPONSE_RENAME);
572 gtk_widget_set_tooltip_text(rename_btn, _("Save the file and rename it"));
573 /* disable rename unless file exists on disk */
574 gtk_widget_set_sensitive(rename_btn, doc->real_path != NULL);
575
576 gtk_dialog_add_buttons(GTK_DIALOG(dialog),
577 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
578 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
579 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
580
581 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
582 gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), FALSE);
583
584 /* set the folder by default to the project base dir or the global pref for opening files */
585 initdir = utils_get_default_dir_utf8();
586 if (initdir)
587 {
588 gchar *linitdir = utils_get_locale_from_utf8(initdir);
589 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), linitdir);
590 g_free(linitdir);
591 }
592 return dialog;
593 }
594
595
596 static gboolean show_save_as_gtk(GeanyDocument *doc)
597 {
598 GtkWidget *dialog;
599 gint resp;
600
601 g_return_val_if_fail(DOC_VALID(doc), FALSE);
602
603 dialog = create_save_file_dialog(doc);
604
605 if (doc->file_name != NULL)
606 {
607 if (g_path_is_absolute(doc->file_name))
608 {
609 gchar *locale_filename = utils_get_locale_from_utf8(doc->file_name);
610 gchar *locale_basename = g_path_get_basename(locale_filename);
611 gchar *locale_dirname = g_path_get_dirname(locale_filename);
612
613 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_dirname);
614 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), locale_basename);
615
616 g_free(locale_filename);
617 g_free(locale_basename);
618 g_free(locale_dirname);
619 }
620 else
621 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), doc->file_name);
622 }
623 else
624 {
625 gchar *fname = NULL;
626
627 if (doc->file_type != NULL && doc->file_type->extension != NULL)
628 fname = g_strconcat(GEANY_STRING_UNTITLED, ".",
629 doc->file_type->extension, NULL);
630 else
631 fname = g_strdup(GEANY_STRING_UNTITLED);
632
633 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fname);
634
635 g_free(fname);
636 }
637
638 if (app->project && !EMPTY(app->project->base_path))
639 gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),
640 app->project->base_path, NULL);
641
642 /* Run the dialog synchronously, pausing this function call */
643 do
644 {
645 resp = gtk_dialog_run(GTK_DIALOG(dialog));
646 }
647 while (! save_as_dialog_handle_response(dialog, resp));
648
649 if (app->project && !EMPTY(app->project->base_path))
650 gtk_file_chooser_remove_shortcut_folder(GTK_FILE_CHOOSER(dialog),
651 app->project->base_path, NULL);
652
653 gtk_widget_destroy(dialog);
654
655 return (resp == GTK_RESPONSE_ACCEPT);
656 }
657
658
659 /**
660 * Shows the Save As dialog for the current notebook page.
661 *
662 * @return @c TRUE if the file was saved, otherwise @c FALSE.
663 **/
664 gboolean dialogs_show_save_as(void)
665 {
666 GeanyDocument *doc = document_get_current();
667 gboolean result = FALSE;
668
669 g_return_val_if_fail(doc, FALSE);
670
671 #ifdef G_OS_WIN32
672 if (interface_prefs.use_native_windows_dialogs)
673 {
674 gchar *utf8_name = win32_show_document_save_as_dialog(GTK_WINDOW(main_widgets.window),
675 _("Save File"), doc);
676 if (utf8_name != NULL)
677 result = handle_save_as(utf8_name, FALSE);
678 }
679 else
680 #endif
681 result = show_save_as_gtk(doc);
682 return result;
683 }
684
685
686 #ifndef G_OS_WIN32
687 static void show_msgbox_dialog(GtkWidget *dialog, GtkMessageType type, GtkWindow *parent)
688 {
689 const gchar *title;
690 switch (type)
691 {
692 case GTK_MESSAGE_ERROR:
693 title = _("Error");
694 break;
695 case GTK_MESSAGE_QUESTION:
696 title = _("Question");
697 break;
698 case GTK_MESSAGE_WARNING:
699 title = _("Warning");
700 break;
701 default:
702 title = _("Information");
703 break;
704 }
705 gtk_window_set_title(GTK_WINDOW(dialog), title);
706 gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany");
707 gtk_widget_set_name(dialog, "GeanyDialog");
708
709 gtk_dialog_run(GTK_DIALOG(dialog));
710 gtk_widget_destroy(dialog);
711 }
712 #endif
713
714
715 /**
716 * Shows a message box of the type @a type with @a text.
717 * On Unix-like systems a GTK message dialog box is shown, on Win32 systems a native Windows
718 * message dialog box is shown.
719 *
720 * @param type A @c GtkMessageType, e.g. @c GTK_MESSAGE_INFO, @c GTK_MESSAGE_WARNING,
721 * @c GTK_MESSAGE_QUESTION, @c GTK_MESSAGE_ERROR.
722 * @param text Printf()-style format string.
723 * @param ... Arguments for the @a text format string.
724 **/
725 void dialogs_show_msgbox(GtkMessageType type, const gchar *text, ...)
726 {
727 #ifndef G_OS_WIN32
728 GtkWidget *dialog;
729 #endif
730 gchar *string;
731 va_list args;
732 GtkWindow *parent = (main_status.main_window_realized) ? GTK_WINDOW(main_widgets.window) : NULL;
733
734 va_start(args, text);
735 string = g_strdup_vprintf(text, args);
736 va_end(args);
737
738 #ifdef G_OS_WIN32
739 win32_message_dialog(GTK_WIDGET(parent), type, string);
740 #else
741 dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT,
742 type, GTK_BUTTONS_OK, "%s", string);
743 show_msgbox_dialog(dialog, type, parent);
744 #endif
745 g_free(string);
746 }
747
748
749 void dialogs_show_msgbox_with_secondary(GtkMessageType type, const gchar *text, const gchar *secondary)
750 {
751 GtkWindow *parent = (main_status.main_window_realized) ? GTK_WINDOW(main_widgets.window) : NULL;
752 #ifdef G_OS_WIN32
753 /* put the two strings together because Windows message boxes don't support secondary texts */
754 gchar *string = g_strconcat(text, "\n", secondary, NULL);
755 win32_message_dialog(GTK_WIDGET(parent), type, string);
756 g_free(string);
757 #else
758 GtkWidget *dialog;
759 dialog = gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT,
760 type, GTK_BUTTONS_OK, "%s", text);
761 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", secondary);
762 show_msgbox_dialog(dialog, type, parent);
763 #endif
764 }
765
766
767 static gint run_unsaved_dialog(const gchar *msg, const gchar *msg2)
768 {
769 GtkWidget *dialog, *button;
770 gint ret;
771
772 dialog = gtk_message_dialog_new(GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT,
773 GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", msg);
774 gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
775 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", msg2);
776 gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
777
778 button = ui_button_new_with_image(GTK_STOCK_CLEAR, _("_Don't save"));
779 gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_NO);
780 gtk_widget_show(button);
781
782 gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_YES);
783
784 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_YES);
785 ret = gtk_dialog_run(GTK_DIALOG(dialog));
786
787 gtk_widget_destroy(dialog);
788
789 return ret;
790 }
791
792
793 gboolean dialogs_show_unsaved_file(GeanyDocument *doc)
794 {
795 gchar *msg, *short_fn = NULL;
796 const gchar *msg2;
797 gint response;
798 gboolean old_quitting_state = main_status.quitting;
799
800 /* display the file tab to remind the user of the document */
801 main_status.quitting = FALSE;
802 document_show_tab(doc);
803 main_status.quitting = old_quitting_state;
804
805 short_fn = document_get_basename_for_display(doc, -1);
806
807 msg = g_strdup_printf(_("The file '%s' is not saved."), short_fn);
808 msg2 = _("Do you want to save it before closing?");
809 g_free(short_fn);
810
811 response = run_unsaved_dialog(msg, msg2);
812 g_free(msg);
813
814 switch (response)
815 {
816 case GTK_RESPONSE_YES:
817 /* document_save_file() returns the status if the file could be saved */
818 return document_save_file(doc, FALSE);
819
820 case GTK_RESPONSE_NO:
821 return TRUE;
822
823 case GTK_RESPONSE_CANCEL: /* fall through to default and leave the function */
824 default:
825 return FALSE;
826 }
827 }
828
829
830 /* Use GtkFontChooserDialog on GTK3.2 for consistency, and because
831 * GtkFontSelectionDialog is somewhat broken on 3.4 */
832 #if GTK_CHECK_VERSION(3, 2, 0)
833 # undef GTK_FONT_SELECTION_DIALOG
834 # define GTK_FONT_SELECTION_DIALOG GTK_FONT_CHOOSER_DIALOG
835
836 # define gtk_font_selection_dialog_new(title) \
837 gtk_font_chooser_dialog_new((title), NULL)
838 # define gtk_font_selection_dialog_get_font_name(dlg) \
839 gtk_font_chooser_get_font(GTK_FONT_CHOOSER(dlg))
840 # define gtk_font_selection_dialog_set_font_name(dlg, font) \
841 gtk_font_chooser_set_font(GTK_FONT_CHOOSER(dlg), (font))
842 #endif
843
844 static void
845 on_font_dialog_response(GtkDialog *dialog, gint response, gpointer user_data)
846 {
847 gboolean close = TRUE;
848
849 switch (response)
850 {
851 case GTK_RESPONSE_APPLY:
852 case GTK_RESPONSE_OK:
853 {
854 gchar *fontname;
855
856 fontname = gtk_font_selection_dialog_get_font_name(
857 GTK_FONT_SELECTION_DIALOG(ui_widgets.open_fontsel));
858 ui_set_editor_font(fontname);
859 g_free(fontname);
860
861 close = (response == GTK_RESPONSE_OK);
862 break;
863 }
864 }
865
866 if (close)
867 gtk_widget_hide(ui_widgets.open_fontsel);
868 }
869
870
871 /* This shows the font selection dialog to choose a font. */
872 void dialogs_show_open_font(void)
873 {
874 #ifdef G_OS_WIN32
875 if (interface_prefs.use_native_windows_dialogs)
876 {
877 win32_show_font_dialog();
878 return;
879 }
880 #endif
881
882 if (ui_widgets.open_fontsel == NULL)
883 {
884 GtkWidget *apply_button;
885
886 ui_widgets.open_fontsel = gtk_font_selection_dialog_new(_("Choose font"));;
887 gtk_container_set_border_width(GTK_CONTAINER(ui_widgets.open_fontsel), 4);
888 gtk_window_set_modal(GTK_WINDOW(ui_widgets.open_fontsel), TRUE);
889 gtk_window_set_destroy_with_parent(GTK_WINDOW(ui_widgets.open_fontsel), TRUE);
890 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(ui_widgets.open_fontsel), TRUE);
891 gtk_window_set_type_hint(GTK_WINDOW(ui_widgets.open_fontsel), GDK_WINDOW_TYPE_HINT_DIALOG);
892 gtk_widget_set_name(ui_widgets.open_fontsel, "GeanyDialog");
893
894 #if GTK_CHECK_VERSION(2, 20, 0)
895 /* apply button doesn't have a getter and is hidden by default, but we'd like to show it */
896 apply_button = gtk_dialog_get_widget_for_response(GTK_DIALOG(ui_widgets.open_fontsel), GTK_RESPONSE_APPLY);
897 #else
898 apply_button = GTK_FONT_SELECTION_DIALOG(ui_widgets.open_fontsel)->apply_button;
899 #endif
900 if (apply_button)
901 gtk_widget_show(apply_button);
902
903 g_signal_connect(ui_widgets.open_fontsel,
904 "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
905 g_signal_connect(ui_widgets.open_fontsel,
906 "response", G_CALLBACK(on_font_dialog_response), NULL);
907
908 gtk_window_set_transient_for(GTK_WINDOW(ui_widgets.open_fontsel), GTK_WINDOW(main_widgets.window));
909 }
910 gtk_font_selection_dialog_set_font_name(
911 GTK_FONT_SELECTION_DIALOG(ui_widgets.open_fontsel), interface_prefs.editor_font);
912 /* We make sure the dialog is visible. */
913 gtk_window_present(GTK_WINDOW(ui_widgets.open_fontsel));
914 }
915
916
917 static void
918 on_input_dialog_show(GtkDialog *dialog, GtkWidget *entry)
919 {
920 gtk_widget_grab_focus(entry);
921 }
922
923
924 static void
925 on_input_entry_activate(GtkEntry *entry, GtkDialog *dialog)
926 {
927 gtk_dialog_response(dialog, GTK_RESPONSE_ACCEPT);
928 }
929
930
931 static void
932 on_input_numeric_activate(GtkEntry *entry, GtkDialog *dialog)
933 {
934 gtk_dialog_response(dialog, GTK_RESPONSE_ACCEPT);
935 }
936
937
938 typedef struct
939 {
940 GtkWidget *entry;
941 GtkWidget *combo;
942
943 GeanyInputCallback callback;
944 gpointer data;
945 }
946 InputDialogData;
947
948
949 static void
950 on_input_dialog_response(GtkDialog *dialog, gint response, InputDialogData *data)
951 {
952 if (response == GTK_RESPONSE_ACCEPT)
953 {
954 const gchar *str = gtk_entry_get_text(GTK_ENTRY(data->entry));
955
956 if (data->combo != NULL)
957 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(data->combo), str, 0);
958
959 data->callback(str, data->data);
960 }
961 gtk_widget_hide(GTK_WIDGET(dialog));
962 }
963
964
965 /* Create and display an input dialog.
966 * persistent: whether to remember previous entry text in a combo box;
967 * in this case the dialog returned is not destroyed on a response,
968 * and can be reshown.
969 * Returns: the dialog widget. */
970 static GtkWidget *
971 dialogs_show_input_full(const gchar *title, GtkWindow *parent,
972 const gchar *label_text, const gchar *default_text,
973 gboolean persistent, GeanyInputCallback input_cb, gpointer input_cb_data,
974 GCallback insert_text_cb, gpointer insert_text_cb_data)
975 {
976 GtkWidget *dialog, *vbox;
977 InputDialogData *data = g_malloc(sizeof *data);
978
979 dialog = gtk_dialog_new_with_buttons(title, parent,
980 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
981 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
982 vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog));
983 gtk_widget_set_name(dialog, "GeanyDialog");
984 gtk_box_set_spacing(GTK_BOX(vbox), 6);
985
986 data->combo = NULL;
987 data->entry = NULL;
988 data->callback = input_cb;
989 data->data = input_cb_data;
990
991 if (label_text)
992 {
993 GtkWidget *label = gtk_label_new(label_text);
994 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
995 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
996 gtk_container_add(GTK_CONTAINER(vbox), label);
997 }
998
999 if (persistent) /* remember previous entry text in a combo box */
1000 {
1001 data->combo = gtk_combo_box_text_new_with_entry();
1002 data->entry = gtk_bin_get_child(GTK_BIN(data->combo));
1003 ui_entry_add_clear_icon(GTK_ENTRY(data->entry));
1004 gtk_container_add(GTK_CONTAINER(vbox), data->combo);
1005 }
1006 else
1007 {
1008 data->entry = gtk_entry_new();
1009 ui_entry_add_clear_icon(GTK_ENTRY(data->entry));
1010 gtk_container_add(GTK_CONTAINER(vbox), data->entry);
1011 }
1012
1013 if (default_text != NULL)
1014 {
1015 gtk_entry_set_text(GTK_ENTRY(data->entry), default_text);
1016 }
1017 gtk_entry_set_max_length(GTK_ENTRY(data->entry), 255);
1018 gtk_entry_set_width_chars(GTK_ENTRY(data->entry), 30);
1019
1020 if (insert_text_cb != NULL)
1021 g_signal_connect(data->entry, "insert-text", insert_text_cb, insert_text_cb_data);
1022 g_signal_connect(data->entry, "activate", G_CALLBACK(on_input_entry_activate), dialog);
1023 g_signal_connect(dialog, "show", G_CALLBACK(on_input_dialog_show), data->entry);
1024 g_signal_connect_data(dialog, "response", G_CALLBACK(on_input_dialog_response), data, (GClosureNotify)g_free, 0);
1025
1026 if (persistent)
1027 {
1028 /* override default handler */
1029 g_signal_connect(dialog, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
1030 gtk_widget_show_all(dialog);
1031 return dialog;
1032 }
1033 gtk_widget_show_all(dialog);
1034 gtk_dialog_run(GTK_DIALOG(dialog));
1035 gtk_widget_destroy(dialog);
1036 return NULL;
1037 }
1038
1039
1040 /* Remember previous entry text in a combo box.
1041 * Returns: the dialog widget. */
1042 GtkWidget *
1043 dialogs_show_input_persistent(const gchar *title, GtkWindow *parent,
1044 const gchar *label_text, const gchar *default_text,
1045 GeanyInputCallback input_cb, gpointer input_cb_data)
1046 {
1047 return dialogs_show_input_full(title, parent, label_text, default_text, TRUE, input_cb, input_cb_data, NULL, NULL);
1048 }
1049
1050
1051 static void on_dialog_input(const gchar *str, gpointer data)
1052 {
1053 gchar **dialog_input = data;
1054 *dialog_input = g_strdup(str);
1055 }
1056
1057
1058 /** Asks the user for text input.
1059 * @param title Dialog title.
1060 * @param parent The currently focused window, usually @c geany->main_widgets->window.
1061 * @c NULL can be used but is discouraged due to window manager effects.
1062 * @param label_text Label text, or @c NULL.
1063 * @param default_text Text to display in the input field, or @c NULL.
1064 * @return New copy of user input or @c NULL if cancelled.
1065 * @since 0.20. */
1066 gchar *dialogs_show_input(const gchar *title, GtkWindow *parent, const gchar *label_text,
1067 const gchar *default_text)
1068 {
1069 gchar *dialog_input = NULL;
1070 dialogs_show_input_full(title, parent, label_text, default_text, FALSE, on_dialog_input, &dialog_input, NULL, NULL);
1071 return dialog_input;
1072 }
1073
1074
1075 /* Note: could be changed to dialogs_show_validated_input with argument for callback. */
1076 /* Returns: newly allocated copy of the entry text or NULL on cancel.
1077 * Specialised variant for Goto Line dialog. */
1078 gchar *dialogs_show_input_goto_line(const gchar *title, GtkWindow *parent, const gchar *label_text,
1079 const gchar *default_text)
1080 {
1081 gchar *dialog_input = NULL;
1082 dialogs_show_input_full(
1083 title, parent, label_text, default_text, FALSE, on_dialog_input, &dialog_input,
1084 G_CALLBACK(ui_editable_insert_text_callback), NULL);
1085 return dialog_input;
1086 }
1087
1088
1089 /**
1090 * Shows an input box to enter a numerical value using a GtkSpinButton.
1091 * If the dialog is aborted, @a value remains untouched.
1092 *
1093 * @param title The dialog title.
1094 * @param label_text The shown dialog label.
1095 * @param value The default value for the spin button and the return location of the entered value.
1096 * Must be non-NULL.
1097 * @param min Minimum allowable value (see documentation for @c gtk_spin_button_new_with_range()).
1098 * @param max Maximum allowable value (see documentation for @c gtk_spin_button_new_with_range()).
1099 * @param step Increment added or subtracted by spinning the widget
1100 * (see documentation for @c gtk_spin_button_new_with_range()).
1101 *
1102 * @return @c TRUE if a value was entered and the dialog closed with 'OK'. @c FALSE otherwise.
1103 *
1104 * @since 0.16
1105 **/
1106 gboolean dialogs_show_input_numeric(const gchar *title, const gchar *label_text,
1107 gdouble *value, gdouble min, gdouble max, gdouble step)
1108 {
1109 GtkWidget *dialog, *label, *spin, *vbox;
1110 gboolean res = FALSE;
1111
1112 g_return_val_if_fail(title != NULL, FALSE);
1113 g_return_val_if_fail(label_text != NULL, FALSE);
1114 g_return_val_if_fail(value != NULL, FALSE);
1115
1116 dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(main_widgets.window),
1117 GTK_DIALOG_DESTROY_WITH_PARENT,
1118 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1119 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
1120 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
1121 vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog));
1122 gtk_widget_set_name(dialog, "GeanyDialog");
1123
1124 label = gtk_label_new(label_text);
1125 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
1126
1127 spin = gtk_spin_button_new_with_range(min, max, step);
1128 ui_entry_add_clear_icon(GTK_ENTRY(spin));
1129 gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), *value);
1130 g_signal_connect(spin, "activate", G_CALLBACK(on_input_numeric_activate), dialog);
1131
1132 gtk_container_add(GTK_CONTAINER(vbox), label);
1133 gtk_container_add(GTK_CONTAINER(vbox), spin);
1134 gtk_widget_show_all(vbox);
1135
1136 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1137 {
1138 *value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(spin));
1139 res = TRUE;
1140 }
1141 gtk_widget_destroy(dialog);
1142
1143 return res;
1144 }
1145
1146
1147 void dialogs_show_file_properties(GeanyDocument *doc)
1148 {
1149 GtkWidget *dialog, *label, *image, *check;
1150 gchar *file_size, *title, *base_name, *time_changed, *time_modified, *time_accessed, *enctext;
1151 gchar *short_name;
1152 #ifdef HAVE_SYS_TYPES_H
1153 struct stat st;
1154 off_t filesize;
1155 mode_t mode;
1156 gchar *locale_filename;
1157 #else
1158 gint filesize = 0;
1159 gint mode = 0;
1160 #endif
1161
1162 /* define this ones, to avoid later trouble */
1163 #ifndef S_IRUSR
1164 # define S_IRUSR 0
1165 # define S_IWUSR 0
1166 # define S_IXUSR 0
1167 #endif
1168 #ifndef S_IRGRP
1169 # define S_IRGRP 0
1170 # define S_IWGRP 0
1171 # define S_IXGRP 0
1172 # define S_IROTH 0
1173 # define S_IWOTH 0
1174 # define S_IXOTH 0
1175 #endif
1176
1177 g_return_if_fail(doc == NULL || doc->is_valid);
1178
1179 if (doc == NULL || doc->file_name == NULL)
1180 {
1181 dialogs_show_msgbox(GTK_MESSAGE_ERROR,
1182 _("An error occurred or file information could not be retrieved (e.g. from a new file)."));
1183 return;
1184 }
1185
1186
1187 #ifdef HAVE_SYS_TYPES_H
1188 locale_filename = utils_get_locale_from_utf8(doc->file_name);
1189 if (g_stat(locale_filename, &st) == 0)
1190 {
1191 /* first copy the returned string and the trim it, to not modify the static glibc string
1192 * g_strchomp() is used to remove trailing EOL chars, which are there for whatever reason */
1193 time_changed = g_strchomp(g_strdup(ctime(&st.st_ctime)));
1194 time_modified = g_strchomp(g_strdup(ctime(&st.st_mtime)));
1195 time_accessed = g_strchomp(g_strdup(ctime(&st.st_atime)));
1196 filesize = st.st_size;
1197 mode = st.st_mode;
1198 }
1199 else
1200 {
1201 time_changed = g_strdup(_("unknown"));
1202 time_modified = g_strdup(_("unknown"));
1203 time_accessed = g_strdup(_("unknown"));
1204 filesize = (off_t) 0;
1205 mode = (mode_t) 0;
1206 }
1207 g_free(locale_filename);
1208 #else
1209 time_changed = g_strdup(_("unknown"));
1210 time_modified = g_strdup(_("unknown"));
1211 time_accessed = g_strdup(_("unknown"));
1212 #endif
1213
1214 base_name = g_path_get_basename(doc->file_name);
1215 short_name = utils_str_middle_truncate(base_name, 30);
1216 title = g_strdup_printf(_("%s Properties"), short_name);
1217 dialog = ui_builder_get_object("properties_dialog");
1218 gtk_window_set_title(GTK_WINDOW(dialog), title);
1219 g_free(short_name);
1220 g_free(title);
1221 gtk_widget_set_name(dialog, "GeanyDialog");
1222
1223 label = ui_lookup_widget(dialog, "file_name_label");
1224 gtk_label_set_text(GTK_LABEL(label), base_name);
1225
1226 image = ui_lookup_widget(dialog, "file_type_image");
1227 gtk_image_set_from_gicon(GTK_IMAGE(image), doc->file_type->icon,
1228 GTK_ICON_SIZE_BUTTON);
1229
1230 label = ui_lookup_widget(dialog, "file_type_label");
1231 gtk_label_set_text(GTK_LABEL(label), doc->file_type->title);
1232
1233 label = ui_lookup_widget(dialog, "file_size_label");
1234 file_size = utils_make_human_readable_str(filesize, 1, 0);
1235 gtk_label_set_text(GTK_LABEL(label), file_size);
1236 g_free(file_size);
1237
1238 label = ui_lookup_widget(dialog, "file_location_label");
1239 gtk_label_set_text(GTK_LABEL(label), doc->file_name);
1240
1241 check = ui_lookup_widget(dialog, "file_read_only_check");
1242 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), doc->readonly);
1243
1244 label = ui_lookup_widget(dialog, "file_encoding_label");
1245 enctext = g_strdup_printf("%s %s",
1246 doc->encoding,
1247 (encodings_is_unicode_charset(doc->encoding)) ?
1248 ((doc->has_bom) ? _("(with BOM)") : _("(without BOM)")) : "");
1249 gtk_label_set_text(GTK_LABEL(label), enctext);
1250 g_free(enctext);
1251
1252 label = ui_lookup_widget(dialog, "file_modified_label");
1253 gtk_label_set_text(GTK_LABEL(label), time_modified);
1254 label = ui_lookup_widget(dialog, "file_changed_label");
1255 gtk_label_set_text(GTK_LABEL(label), time_changed);
1256 label = ui_lookup_widget(dialog, "file_accessed_label");
1257 gtk_label_set_text(GTK_LABEL(label), time_accessed);
1258
1259 /* permissions */
1260 check = ui_lookup_widget(dialog, "file_perm_owner_r_check");
1261 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IRUSR);
1262 check = ui_lookup_widget(dialog, "file_perm_owner_w_check");
1263 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IWUSR);
1264 check = ui_lookup_widget(dialog, "file_perm_owner_x_check");
1265 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IXUSR);
1266 check = ui_lookup_widget(dialog, "file_perm_group_r_check");
1267 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IRGRP);
1268 check = ui_lookup_widget(dialog, "file_perm_group_w_check");
1269 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IWGRP);
1270 check = ui_lookup_widget(dialog, "file_perm_group_x_check");
1271 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IXGRP);
1272 check = ui_lookup_widget(dialog, "file_perm_other_r_check");
1273 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IROTH);
1274 check = ui_lookup_widget(dialog, "file_perm_other_w_check");
1275 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IWOTH);
1276 check = ui_lookup_widget(dialog, "file_perm_other_x_check");
1277 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), mode & S_IXOTH);
1278
1279 g_free(base_name);
1280 g_free(time_changed);
1281 g_free(time_modified);
1282 g_free(time_accessed);
1283
1284 gtk_widget_show(dialog);
1285 }
1286
1287
1288 /* extra_text can be NULL; otherwise it is displayed below main_text.
1289 * if parent is NULL, main_widgets.window will be used
1290 * btn_1, btn_2, btn_3 can be NULL.
1291 * returns response_1, response_2 or response_3 */
1292 static gint show_prompt(GtkWidget *parent,
1293 const gchar *btn_1, GtkResponseType response_1,
1294 const gchar *btn_2, GtkResponseType response_2,
1295 const gchar *btn_3, GtkResponseType response_3,
1296 const gchar *question_text, const gchar *extra_text)
1297 {
1298 gboolean ret = FALSE;
1299 GtkWidget *dialog;
1300 GtkWidget *btn;
1301
1302 if (btn_2 == NULL)
1303 {
1304 btn_2 = GTK_STOCK_NO;
1305 response_2 = GTK_RESPONSE_NO;
1306 }
1307 if (btn_3 == NULL)
1308 {
1309 btn_3 = GTK_STOCK_YES;
1310 response_3 = GTK_RESPONSE_YES;
1311 }
1312
1313 #ifdef G_OS_WIN32
1314 /* our native dialog code doesn't support custom buttons */
1315 if (utils_str_equal(btn_3, GTK_STOCK_YES) &&
1316 utils_str_equal(btn_2, GTK_STOCK_NO) && btn_1 == NULL)
1317 {
1318 gchar *string = (extra_text == NULL) ? g_strdup(question_text) :
1319 g_strconcat(question_text, "\n\n", extra_text, NULL);
1320
1321 ret = win32_message_dialog(parent, GTK_MESSAGE_QUESTION, string);
1322 ret = ret ? response_3 : response_2;
1323 g_free(string);
1324 return ret;
1325 }
1326 #endif
1327 if (parent == NULL && main_status.main_window_realized)
1328 parent = main_widgets.window;
1329
1330 dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
1331 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
1332 GTK_BUTTONS_NONE, "%s", question_text);
1333 gtk_widget_set_name(dialog, "GeanyDialog");
1334 gtk_window_set_title(GTK_WINDOW(dialog), _("Question"));
1335 gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany");
1336
1337 /* question_text will be in bold if optional extra_text used */
1338 if (extra_text != NULL)
1339 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
1340 "%s", extra_text);
1341
1342 if (btn_1 != NULL)
1343 gtk_dialog_add_button(GTK_DIALOG(dialog), btn_1, response_1);
1344
1345 /* For a cancel button, use cancel response so user can press escape to cancel */
1346 btn = gtk_dialog_add_button(GTK_DIALOG(dialog), btn_2,
1347 utils_str_equal(btn_2, GTK_STOCK_CANCEL) ? GTK_RESPONSE_CANCEL : response_2);
1348 /* we don't want a default, but we need to override the apply button as default */
1349 gtk_widget_grab_default(btn);
1350 gtk_dialog_add_button(GTK_DIALOG(dialog), btn_3, response_3);
1351
1352 ret = gtk_dialog_run(GTK_DIALOG(dialog));
1353 gtk_widget_destroy(dialog);
1354
1355 if (ret == GTK_RESPONSE_CANCEL)
1356 ret = response_2;
1357 return ret;
1358 }
1359
1360
1361 /**
1362 * Shows a question message box with @a text and Yes/No buttons.
1363 * On Unix-like systems a GTK message dialog box is shown, on Win32 systems a native Windows
1364 * message dialog box is shown.
1365 *
1366 * @param text Printf()-style format string.
1367 * @param ... Arguments for the @a text format string.
1368 *
1369 * @return @c TRUE if the user answered with Yes, otherwise @c FALSE.
1370 **/
1371 gboolean dialogs_show_question(const gchar *text, ...)
1372 {
1373 gchar *string;
1374 va_list args;
1375 GtkWidget *parent = (main_status.main_window_realized) ? main_widgets.window : NULL;
1376 gint result;
1377
1378 va_start(args, text);
1379 string = g_strdup_vprintf(text, args);
1380 va_end(args);
1381 result = show_prompt(parent,
1382 NULL, GTK_RESPONSE_NONE,
1383 GTK_STOCK_NO, GTK_RESPONSE_NO,
1384 GTK_STOCK_YES, GTK_RESPONSE_YES,
1385 string, NULL);
1386 g_free(string);
1387 return (result == GTK_RESPONSE_YES);
1388 }
1389
1390
1391 /* extra_text can be NULL; otherwise it is displayed below main_text.
1392 * if parent is NULL, main_widgets.window will be used
1393 * yes_btn, no_btn can be NULL. */
1394 gboolean dialogs_show_question_full(GtkWidget *parent, const gchar *yes_btn, const gchar *no_btn,
1395 const gchar *extra_text, const gchar *main_text, ...)
1396 {
1397 gint result;
1398 gchar *string;
1399 va_list args;
1400
1401 va_start(args, main_text);
1402 string = g_strdup_vprintf(main_text, args);
1403 va_end(args);
1404 result = show_prompt(parent,
1405 NULL, GTK_RESPONSE_NONE,
1406 no_btn, GTK_RESPONSE_NO,
1407 yes_btn, GTK_RESPONSE_YES,
1408 string, extra_text);
1409 g_free(string);
1410 return (result == GTK_RESPONSE_YES);
1411 }
1412
1413
1414 /* extra_text can be NULL; otherwise it is displayed below main_text.
1415 * if parent is NULL, main_widgets.window will be used
1416 * btn_1, btn_2, btn_3 can be NULL.
1417 * returns response_1, response_2 or response_3 */
1418 gint dialogs_show_prompt(GtkWidget *parent,
1419 const gchar *btn_1, GtkResponseType response_1,
1420 const gchar *btn_2, GtkResponseType response_2,
1421 const gchar *btn_3, GtkResponseType response_3,
1422 const gchar *extra_text, const gchar *main_text, ...)
1423 {
1424 gchar *string;
1425 va_list args;
1426 gint result;
1427
1428 va_start(args, main_text);
1429 string = g_strdup_vprintf(main_text, args);
1430 va_end(args);
1431 result = show_prompt(parent, btn_1, response_1, btn_2, response_2, btn_3, response_3,
1432 string, extra_text);
1433 g_free(string);
1434 return result;
1435 }
A fast and lightweight IDE