?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove empty table rows in the Glade file
[geany-mirror.git] / src / ui_utils.c
blob6bf606acc316049d2e56be327b52755056430311
1 /*
2 * ui_utils.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2006-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 * Copyright 2011-2012 Matthew Brush <mbrush(at)codebrainz(dot)ca>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 /** @file ui_utils.h
24 * User Interface general utility functions.
25 */
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include "ui_utils.h"
32
33 #include "app.h"
34 #include "callbacks.h"
35 #include "dialogs.h"
36 #include "documentprivate.h"
37 #include "encodings.h"
38 #include "filetypes.h"
39 #include "geanymenubuttonaction.h"
40 #include "keyfile.h"
41 #include "main.h"
42 #include "msgwindow.h"
43 #include "prefs.h"
44 #include "project.h"
45 #include "sciwrappers.h"
46 #include "sidebar.h"
47 #include "stash.h"
48 #include "support.h"
49 #include "symbols.h"
50 #include "toolbar.h"
51 #include "utils.h"
52
53 #include "gtkcompat.h"
54
55 #include <string.h>
56 #include <ctype.h>
57 #include <gdk/gdkkeysyms.h>
58
59
60 #define DEFAULT_STATUSBAR_TEMPLATE N_(\
61 "line: %l / %L\t " \
62 "col: %c\t " \
63 "sel: %s\t " \
64 "%w %t %m" \
65 "mode: %M " \
66 "encoding: %e " \
67 "filetype: %f " \
68 "scope: %S")
69
70 GeanyInterfacePrefs interface_prefs;
71 GeanyMainWidgets main_widgets;
72
73 UIPrefs ui_prefs;
74 UIWidgets ui_widgets;
75
76 static GtkBuilder *builder = NULL;
77 static GtkWidget* window1 = NULL;
78 static GtkWidget* toolbar_popup_menu1 = NULL;
79 static GtkWidget* edit_menu1 = NULL;
80 static GtkWidget* prefs_dialog = NULL;
81 static GtkWidget* project_dialog = NULL;
82
83 static struct
84 {
85 /* pointers to widgets only sensitive when there is at least one document, the pointers can
86 * also be GtkAction objects, so check each pointer before using it */
87 GPtrArray *document_buttons;
88 GtkWidget *menu_insert_include_items[2];
89 GtkWidget *popup_goto_items[4];
90 GtkWidget *popup_copy_items[3];
91 GtkWidget *menu_copy_items[3];
92 GtkWidget *redo_items[3];
93 GtkWidget *undo_items[3];
94 GtkWidget *save_buttons[4];
95 GtkWidget *config_files_menu;
96 }
97 widgets;
98
99 enum
100 {
101 RECENT_FILE_FILE,
102 RECENT_FILE_PROJECT
103 };
104
105 typedef struct
106 {
107 gint type;
108 GQueue *recent_queue;
109 GtkWidget *menubar;
110 GtkWidget *toolbar;
111 void (*activate_cb)(GtkMenuItem *, gpointer);
112 } GeanyRecentFiles;
113
114
115 static void update_recent_menu(GeanyRecentFiles *grf);
116 static void recent_file_loaded(const gchar *utf8_filename, GeanyRecentFiles *grf);
117 static void recent_file_activate_cb(GtkMenuItem *menuitem, gpointer user_data);
118 static void recent_project_activate_cb(GtkMenuItem *menuitem, gpointer user_data);
119 static GtkWidget *progress_bar_create(void);
120
121
122 /* simple wrapper for gtk_widget_set_sensitive() to allow widget being NULL */
123 void ui_widget_set_sensitive(GtkWidget *widget, gboolean set)
124 {
125 if (widget != NULL)
126 gtk_widget_set_sensitive(widget, set);
127 }
128
129
130 /* allow_override is TRUE if text can be ignored when another message has been set
131 * that didn't use allow_override and has not timed out. */
132 static void set_statusbar(const gchar *text, gboolean allow_override)
133 {
134 static guint id = 0;
135 static glong last_time = 0;
136 GTimeVal timeval;
137 const gint GEANY_STATUS_TIMEOUT = 1;
138
139 if (! interface_prefs.statusbar_visible)
140 return; /* just do nothing if statusbar is not visible */
141
142 if (id == 0)
143 id = gtk_statusbar_get_context_id(GTK_STATUSBAR(ui_widgets.statusbar), "geany-main");
144
145 g_get_current_time(&timeval);
146
147 if (! allow_override)
148 {
149 gtk_statusbar_pop(GTK_STATUSBAR(ui_widgets.statusbar), id);
150 gtk_statusbar_push(GTK_STATUSBAR(ui_widgets.statusbar), id, text);
151 last_time = timeval.tv_sec;
152 }
153 else
154 if (timeval.tv_sec > last_time + GEANY_STATUS_TIMEOUT)
155 {
156 gtk_statusbar_pop(GTK_STATUSBAR(ui_widgets.statusbar), id);
157 gtk_statusbar_push(GTK_STATUSBAR(ui_widgets.statusbar), id, text);
158 }
159 }
160
161
162 /** Displays text on the statusbar.
163 * @param log Whether the message should be recorded in the Status window.
164 * @param format A @c printf -style string. */
165 void ui_set_statusbar(gboolean log, const gchar *format, ...)
166 {
167 gchar *string;
168 va_list args;
169
170 va_start(args, format);
171 string = g_strdup_vprintf(format, args);
172 va_end(args);
173
174 if (! prefs.suppress_status_messages)
175 set_statusbar(string, FALSE);
176
177 if (log || prefs.suppress_status_messages)
178 msgwin_status_add("%s", string);
179
180 g_free(string);
181 }
182
183
184 /* note: some comments below are for translators */
185 static gchar *create_statusbar_statistics(GeanyDocument *doc,
186 guint line, guint col, guint pos)
187 {
188 const gchar *cur_tag;
189 const gchar *fmt;
190 const gchar *expos; /* % expansion position */
191 const gchar sp[] = " ";
192 GString *stats_str;
193 ScintillaObject *sci = doc->editor->sci;
194
195 if (!EMPTY(ui_prefs.statusbar_template))
196 fmt = ui_prefs.statusbar_template;
197 else
198 fmt = _(DEFAULT_STATUSBAR_TEMPLATE);
199
200 stats_str = g_string_sized_new(120);
201
202 while ((expos = strchr(fmt, '%')) != NULL)
203 {
204 /* append leading text before % char */
205 g_string_append_len(stats_str, fmt, expos - fmt);
206
207 switch (*++expos)
208 {
209 case 'l':
210 g_string_append_printf(stats_str, "%d", line + 1);
211 break;
212 case 'L':
213 g_string_append_printf(stats_str, "%d",
214 sci_get_line_count(doc->editor->sci));
215 break;
216 case 'c':
217 g_string_append_printf(stats_str, "%d", col);
218 break;
219 case 'C':
220 g_string_append_printf(stats_str, "%d", col + 1);
221 break;
222 case 'p':
223 g_string_append_printf(stats_str, "%u", pos);
224 break;
225 case 's':
226 {
227 gint len = sci_get_selected_text_length(sci) - 1;
228 /* check if whole lines are selected */
229 if (!len || sci_get_col_from_position(sci,
230 sci_get_selection_start(sci)) != 0 ||
231 sci_get_col_from_position(sci,
232 sci_get_selection_end(sci)) != 0)
233 g_string_append_printf(stats_str, "%d", len);
234 else /* L = lines */
235 g_string_append_printf(stats_str, _("%dL"),
236 sci_get_lines_selected(doc->editor->sci) - 1);
237 break;
238 }
239 case 'w':
240 /* RO = read-only */
241 g_string_append(stats_str, (doc->readonly) ? _("RO ") :
242 /* OVR = overwrite/overtype, INS = insert */
243 (sci_get_overtype(doc->editor->sci) ? _("OVR") : _("INS")));
244 break;
245 case 'r':
246 if (doc->readonly)
247 {
248 g_string_append(stats_str, _("RO ")); /* RO = read-only */
249 g_string_append(stats_str, sp + 1);
250 }
251 break;
252 case 't':
253 {
254 switch (editor_get_indent_prefs(doc->editor)->type)
255 {
256 case GEANY_INDENT_TYPE_TABS:
257 g_string_append(stats_str, _("TAB"));
258 break;
259 case GEANY_INDENT_TYPE_SPACES: /* SP = space */
260 g_string_append(stats_str, _("SP"));
261 break;
262 case GEANY_INDENT_TYPE_BOTH: /* T/S = tabs and spaces */
263 g_string_append(stats_str, _("T/S"));
264 break;
265 }
266 break;
267 }
268 case 'm':
269 if (doc->changed)
270 {
271 g_string_append(stats_str, _("MOD")); /* MOD = modified */
272 g_string_append(stats_str, sp);
273 }
274 break;
275 case 'M':
276 g_string_append(stats_str, editor_get_eol_char_name(doc->editor));
277 break;
278 case 'e':
279 g_string_append(stats_str,
280 doc->encoding ? doc->encoding : _("unknown"));
281 if (encodings_is_unicode_charset(doc->encoding) && (doc->has_bom))
282 {
283 g_string_append_c(stats_str, ' ');
284 g_string_append(stats_str, _("(with BOM)")); /* BOM = byte order mark */
285 }
286 break;
287 case 'f':
288 g_string_append(stats_str, filetypes_get_display_name(doc->file_type));
289 break;
290 case 'S':
291 symbols_get_current_scope(doc, &cur_tag);
292 g_string_append(stats_str, cur_tag);
293 break;
294 case 'Y':
295 g_string_append_c(stats_str, ' ');
296 g_string_append_printf(stats_str, "%d",
297 sci_get_style_at(doc->editor->sci, pos));
298 break;
299 default:
300 g_string_append_len(stats_str, expos, 1);
301 }
302
303 /* skip past %c chars */
304 if (*expos)
305 fmt = expos + 1;
306 else
307 break;
308 }
309 /* add any remaining text */
310 g_string_append(stats_str, fmt);
311
312 return g_string_free(stats_str, FALSE);
313 }
314
315
316 /* updates the status bar document statistics */
317 void ui_update_statusbar(GeanyDocument *doc, gint pos)
318 {
319 g_return_if_fail(doc == NULL || doc->is_valid);
320
321 if (! interface_prefs.statusbar_visible)
322 return; /* just do nothing if statusbar is not visible */
323
324 if (doc == NULL)
325 doc = document_get_current();
326
327 if (doc != NULL)
328 {
329 guint line, col;
330 gchar *stats_str;
331
332 if (pos == -1)
333 pos = sci_get_current_position(doc->editor->sci);
334 line = sci_get_line_from_position(doc->editor->sci, pos);
335
336 /* Add temporary fix for sci infinite loop in Document::GetColumn(int)
337 * when current pos is beyond document end (can occur when removing
338 * blocks of selected lines especially esp. brace sections near end of file). */
339 if (pos <= sci_get_length(doc->editor->sci))
340 col = sci_get_col_from_position(doc->editor->sci, pos);
341 else
342 col = 0;
343
344 stats_str = create_statusbar_statistics(doc, line, col, pos);
345
346 /* can be overridden by status messages */
347 set_statusbar(stats_str, TRUE);
348 g_free(stats_str);
349 }
350 else /* no documents */
351 {
352 set_statusbar("", TRUE); /* can be overridden by status messages */
353 }
354 }
355
356
357 /* This sets the window title according to the current filename. */
358 void ui_set_window_title(GeanyDocument *doc)
359 {
360 GString *str;
361 GeanyProject *project = app->project;
362
363 g_return_if_fail(doc == NULL || doc->is_valid);
364
365 if (doc == NULL)
366 doc = document_get_current();
367
368 str = g_string_new(NULL);
369
370 if (doc != NULL)
371 {
372 g_string_append(str, doc->changed ? "*" : "");
373
374 if (doc->file_name == NULL)
375 g_string_append(str, DOC_FILENAME(doc));
376 else
377 {
378 gchar *short_name = document_get_basename_for_display(doc, 30);
379 gchar *dirname = g_path_get_dirname(DOC_FILENAME(doc));
380
381 g_string_append(str, short_name);
382 g_string_append(str, " - ");
383 g_string_append(str, dirname ? dirname : "");
384 g_free(short_name);
385 g_free(dirname);
386 }
387 g_string_append(str, " - ");
388 }
389 if (project)
390 {
391 g_string_append_c(str, '[');
392 g_string_append(str, project->name);
393 g_string_append(str, "] - ");
394 }
395 g_string_append(str, "Geany");
396 if (cl_options.new_instance)
397 {
398 g_string_append(str, _(" (new instance)"));
399 }
400 gtk_window_set_title(GTK_WINDOW(main_widgets.window), str->str);
401 g_string_free(str, TRUE);
402 }
403
404
405 void ui_set_editor_font(const gchar *font_name)
406 {
407 guint i;
408
409 g_return_if_fail(font_name != NULL);
410
411 /* do nothing if font has not changed */
412 if (interface_prefs.editor_font != NULL)
413 if (strcmp(font_name, interface_prefs.editor_font) == 0)
414 return;
415
416 g_free(interface_prefs.editor_font);
417 interface_prefs.editor_font = g_strdup(font_name);
418
419 /* We copy the current style, and update the font in all open tabs. */
420 for (i = 0; i < documents_array->len; i++)
421 {
422 if (documents[i]->editor)
423 {
424 editor_set_font(documents[i]->editor, interface_prefs.editor_font);
425 }
426 }
427
428 ui_set_statusbar(TRUE, _("Font updated (%s)."), interface_prefs.editor_font);
429 }
430
431
432 void ui_set_fullscreen(void)
433 {
434 if (ui_prefs.fullscreen)
435 {
436 gtk_window_fullscreen(GTK_WINDOW(main_widgets.window));
437 }
438 else
439 {
440 gtk_window_unfullscreen(GTK_WINDOW(main_widgets.window));
441 }
442 }
443
444
445 void ui_update_popup_reundo_items(GeanyDocument *doc)
446 {
447 gboolean enable_undo;
448 gboolean enable_redo;
449 guint i, len;
450
451 g_return_if_fail(doc == NULL || doc->is_valid);
452
453 if (doc == NULL)
454 {
455 enable_undo = FALSE;
456 enable_redo = FALSE;
457 }
458 else
459 {
460 enable_undo = document_can_undo(doc);
461 enable_redo = document_can_redo(doc);
462 }
463
464 /* index 0 is the popup menu, 1 is the menubar, 2 is the toolbar */
465 len = G_N_ELEMENTS(widgets.undo_items);
466 for (i = 0; i < len; i++)
467 {
468 ui_widget_set_sensitive(widgets.undo_items[i], enable_undo);
469 }
470 len = G_N_ELEMENTS(widgets.redo_items);
471 for (i = 0; i < len; i++)
472 {
473 ui_widget_set_sensitive(widgets.redo_items[i], enable_redo);
474 }
475 }
476
477
478 void ui_update_popup_copy_items(GeanyDocument *doc)
479 {
480 gboolean enable;
481 guint i, len;
482
483 g_return_if_fail(doc == NULL || doc->is_valid);
484
485 if (doc == NULL)
486 enable = FALSE;
487 else
488 enable = sci_has_selection(doc->editor->sci);
489
490 len = G_N_ELEMENTS(widgets.popup_copy_items);
491 for (i = 0; i < len; i++)
492 ui_widget_set_sensitive(widgets.popup_copy_items[i], enable);
493 }
494
495
496 void ui_update_popup_goto_items(gboolean enable)
497 {
498 guint i, len;
499 len = G_N_ELEMENTS(widgets.popup_goto_items);
500 for (i = 0; i < len; i++)
501 ui_widget_set_sensitive(widgets.popup_goto_items[i], enable);
502 }
503
504
505 void ui_update_menu_copy_items(GeanyDocument *doc)
506 {
507 gboolean enable = FALSE;
508 guint i, len;
509 GtkWidget *focusw = gtk_window_get_focus(GTK_WINDOW(main_widgets.window));
510
511 g_return_if_fail(doc == NULL || doc->is_valid);
512
513 if (IS_SCINTILLA(focusw))
514 enable = (doc == NULL) ? FALSE : sci_has_selection(doc->editor->sci);
515 else
516 if (GTK_IS_EDITABLE(focusw))
517 enable = gtk_editable_get_selection_bounds(GTK_EDITABLE(focusw), NULL, NULL);
518 else
519 if (GTK_IS_TEXT_VIEW(focusw))
520 {
521 GtkTextBuffer *buffer = gtk_text_view_get_buffer(
522 GTK_TEXT_VIEW(focusw));
523 enable = gtk_text_buffer_get_selection_bounds(buffer, NULL, NULL);
524 }
525
526 len = G_N_ELEMENTS(widgets.menu_copy_items);
527 for (i = 0; i < len; i++)
528 ui_widget_set_sensitive(widgets.menu_copy_items[i], enable);
529 }
530
531
532 void ui_update_insert_include_item(GeanyDocument *doc, gint item)
533 {
534 gboolean enable = FALSE;
535
536 g_return_if_fail(doc == NULL || doc->is_valid);
537
538 if (doc == NULL || doc->file_type == NULL)
539 enable = FALSE;
540 else if (doc->file_type->id == GEANY_FILETYPES_C || doc->file_type->id == GEANY_FILETYPES_CPP)
541 enable = TRUE;
542
543 ui_widget_set_sensitive(widgets.menu_insert_include_items[item], enable);
544 }
545
546
547 void ui_update_fold_items(void)
548 {
549 ui_widget_show_hide(ui_lookup_widget(main_widgets.window, "menu_fold_all1"), editor_prefs.folding);
550 ui_widget_show_hide(ui_lookup_widget(main_widgets.window, "menu_unfold_all1"), editor_prefs.folding);
551 ui_widget_show_hide(ui_lookup_widget(main_widgets.window, "separator22"), editor_prefs.folding);
552 }
553
554
555 static void insert_include_items(GtkMenu *me, GtkMenu *mp, gchar **includes, gchar *label)
556 {
557 guint i = 0;
558 GtkWidget *tmp_menu;
559 GtkWidget *tmp_popup;
560 GtkWidget *edit_menu, *edit_menu_item;
561 GtkWidget *popup_menu, *popup_menu_item;
562
563 edit_menu = gtk_menu_new();
564 popup_menu = gtk_menu_new();
565 edit_menu_item = gtk_menu_item_new_with_label(label);
566 popup_menu_item = gtk_menu_item_new_with_label(label);
567 gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit_menu_item), edit_menu);
568 gtk_menu_item_set_submenu(GTK_MENU_ITEM(popup_menu_item), popup_menu);
569
570 while (includes[i] != NULL)
571 {
572 tmp_menu = gtk_menu_item_new_with_label(includes[i]);
573 tmp_popup = gtk_menu_item_new_with_label(includes[i]);
574 gtk_container_add(GTK_CONTAINER(edit_menu), tmp_menu);
575 gtk_container_add(GTK_CONTAINER(popup_menu), tmp_popup);
576 g_signal_connect(tmp_menu, "activate",
577 G_CALLBACK(on_menu_insert_include_activate), (gpointer) includes[i]);
578 g_signal_connect(tmp_popup, "activate",
579 G_CALLBACK(on_insert_include_activate), (gpointer) includes[i]);
580 i++;
581 }
582 gtk_widget_show_all(edit_menu_item);
583 gtk_widget_show_all(popup_menu_item);
584 gtk_container_add(GTK_CONTAINER(me), edit_menu_item);
585 gtk_container_add(GTK_CONTAINER(mp), popup_menu_item);
586 }
587
588
589 void ui_create_insert_menu_items(void)
590 {
591 GtkMenu *menu_edit = GTK_MENU(ui_lookup_widget(main_widgets.window, "insert_include2_menu"));
592 GtkMenu *menu_popup = GTK_MENU(ui_lookup_widget(main_widgets.editor_menu, "insert_include1_menu"));
593 GtkWidget *blank;
594 const gchar *c_includes_stdlib[] = {
595 "assert.h", "ctype.h", "errno.h", "float.h", "limits.h", "locale.h", "math.h", "setjmp.h",
596 "signal.h", "stdarg.h", "stddef.h", "stdio.h", "stdlib.h", "string.h", "time.h", NULL
597 };
598 const gchar *c_includes_c99[] = {
599 "complex.h", "fenv.h", "inttypes.h", "iso646.h", "stdbool.h", "stdint.h",
600 "tgmath.h", "wchar.h", "wctype.h", NULL
601 };
602 const gchar *c_includes_cpp[] = {
603 "cstdio", "cstring", "cctype", "cmath", "ctime", "cstdlib", "cstdarg", NULL
604 };
605 const gchar *c_includes_cppstdlib[] = {
606 "iostream", "fstream", "iomanip", "sstream", "exception", "stdexcept",
607 "memory", "locale", NULL
608 };
609 const gchar *c_includes_stl[] = {
610 "bitset", "deque", "list", "map", "set", "queue", "stack", "vector", "algorithm",
611 "iterator", "functional", "string", "complex", "valarray", NULL
612 };
613
614 blank = gtk_menu_item_new_with_label("#include \"...\"");
615 gtk_container_add(GTK_CONTAINER(menu_edit), blank);
616 gtk_widget_show(blank);
617 g_signal_connect(blank, "activate", G_CALLBACK(on_menu_insert_include_activate),
618 (gpointer) "blank");
619 blank = gtk_separator_menu_item_new ();
620 gtk_container_add(GTK_CONTAINER(menu_edit), blank);
621 gtk_widget_show(blank);
622
623 blank = gtk_menu_item_new_with_label("#include \"...\"");
624 gtk_container_add(GTK_CONTAINER(menu_popup), blank);
625 gtk_widget_show(blank);
626 g_signal_connect(blank, "activate", G_CALLBACK(on_insert_include_activate),
627 (gpointer) "blank");
628 blank = gtk_separator_menu_item_new();
629 gtk_container_add(GTK_CONTAINER(menu_popup), blank);
630 gtk_widget_show(blank);
631
632 insert_include_items(menu_edit, menu_popup, (gchar**) c_includes_stdlib, _("C Standard Library"));
633 insert_include_items(menu_edit, menu_popup, (gchar**) c_includes_c99, _("ISO C99"));
634 insert_include_items(menu_edit, menu_popup, (gchar**) c_includes_cpp, _("C++ (C Standard Library)"));
635 insert_include_items(menu_edit, menu_popup, (gchar**) c_includes_cppstdlib, _("C++ Standard Library"));
636 insert_include_items(menu_edit, menu_popup, (gchar**) c_includes_stl, _("C++ STL"));
637 }
638
639
640 static void insert_date_items(GtkMenu *me, GtkMenu *mp, gchar *label)
641 {
642 GtkWidget *item;
643
644 item = gtk_menu_item_new_with_mnemonic(label);
645 gtk_container_add(GTK_CONTAINER(me), item);
646 gtk_widget_show(item);
647 g_signal_connect(item, "activate", G_CALLBACK(on_menu_insert_date_activate), label);
648
649 item = gtk_menu_item_new_with_mnemonic(label);
650 gtk_container_add(GTK_CONTAINER(mp), item);
651 gtk_widget_show(item);
652 g_signal_connect(item, "activate", G_CALLBACK(on_insert_date_activate), label);
653 }
654
655
656 void ui_create_insert_date_menu_items(void)
657 {
658 GtkMenu *menu_edit = GTK_MENU(ui_lookup_widget(main_widgets.window, "insert_date1_menu"));
659 GtkMenu *menu_popup = GTK_MENU(ui_lookup_widget(main_widgets.editor_menu, "insert_date2_menu"));
660 GtkWidget *item;
661 gchar *str;
662
663 insert_date_items(menu_edit, menu_popup, _("dd.mm.yyyy"));
664 insert_date_items(menu_edit, menu_popup, _("mm.dd.yyyy"));
665 insert_date_items(menu_edit, menu_popup, _("yyyy/mm/dd"));
666
667 item = gtk_separator_menu_item_new();
668 gtk_container_add(GTK_CONTAINER(menu_edit), item);
669 gtk_widget_show(item);
670 item = gtk_separator_menu_item_new();
671 gtk_container_add(GTK_CONTAINER(menu_popup), item);
672 gtk_widget_show(item);
673
674 insert_date_items(menu_edit, menu_popup, _("dd.mm.yyyy hh:mm:ss"));
675 insert_date_items(menu_edit, menu_popup, _("mm.dd.yyyy hh:mm:ss"));
676 insert_date_items(menu_edit, menu_popup, _("yyyy/mm/dd hh:mm:ss"));
677
678 item = gtk_separator_menu_item_new();
679 gtk_container_add(GTK_CONTAINER(menu_edit), item);
680 gtk_widget_show(item);
681 item = gtk_separator_menu_item_new();
682 gtk_container_add(GTK_CONTAINER(menu_popup), item);
683 gtk_widget_show(item);
684
685 str = _("_Use Custom Date Format");
686 item = gtk_menu_item_new_with_mnemonic(str);
687 gtk_container_add(GTK_CONTAINER(menu_edit), item);
688 gtk_widget_show(item);
689 g_signal_connect(item, "activate", G_CALLBACK(on_menu_insert_date_activate), str);
690 ui_hookup_widget(main_widgets.window, item, "insert_date_custom1");
691
692 item = gtk_menu_item_new_with_mnemonic(str);
693 gtk_container_add(GTK_CONTAINER(menu_popup), item);
694 gtk_widget_show(item);
695 g_signal_connect(item, "activate", G_CALLBACK(on_insert_date_activate), str);
696 ui_hookup_widget(main_widgets.editor_menu, item, "insert_date_custom2");
697
698 insert_date_items(menu_edit, menu_popup, _("_Set Custom Date Format"));
699 }
700
701
702 void ui_save_buttons_toggle(gboolean enable)
703 {
704 guint i;
705 gboolean dirty_tabs = FALSE;
706
707 if (ui_prefs.allow_always_save)
708 enable = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook)) > 0;
709
710 ui_widget_set_sensitive(widgets.save_buttons[0], enable);
711 ui_widget_set_sensitive(widgets.save_buttons[1], enable);
712
713 /* save all menu item and tool button */
714 for (i = 0; i < documents_array->len; i++)
715 {
716 /* check whether there are files where changes were made and if there are some,
717 * we need the save all button / item */
718 if (documents[i]->is_valid && documents[i]->changed)
719 {
720 dirty_tabs = TRUE;
721 break;
722 }
723 }
724
725 ui_widget_set_sensitive(widgets.save_buttons[2], dirty_tabs);
726 ui_widget_set_sensitive(widgets.save_buttons[3], dirty_tabs);
727 }
728
729
730 #define add_doc_widget(widget_name) \
731 g_ptr_array_add(widgets.document_buttons, ui_lookup_widget(main_widgets.window, widget_name))
732
733 #define add_doc_toolitem(widget_name) \
734 g_ptr_array_add(widgets.document_buttons, toolbar_get_action_by_name(widget_name))
735
736 static void init_document_widgets(void)
737 {
738 widgets.document_buttons = g_ptr_array_new();
739
740 /* Cache the document-sensitive widgets so we don't have to keep looking them up
741 * when using ui_document_buttons_update(). */
742 add_doc_widget("menu_close1");
743 add_doc_widget("close_other_documents1");
744 add_doc_widget("menu_change_font1");
745 add_doc_widget("menu_close_all1");
746 add_doc_widget("menu_save1");
747 add_doc_widget("menu_save_all1");
748 add_doc_widget("menu_save_as1");
749 add_doc_widget("menu_count_words1");
750 add_doc_widget("menu_build1");
751 add_doc_widget("add_comments1");
752 add_doc_widget("menu_paste1");
753 add_doc_widget("menu_undo2");
754 add_doc_widget("preferences2");
755 add_doc_widget("menu_reload1");
756 add_doc_widget("menu_document1");
757 add_doc_widget("menu_choose_color1");
758 add_doc_widget("menu_color_schemes");
759 add_doc_widget("menu_markers_margin1");
760 add_doc_widget("menu_linenumber_margin1");
761 add_doc_widget("menu_show_white_space1");
762 add_doc_widget("menu_show_line_endings1");
763 add_doc_widget("menu_show_indentation_guides1");
764 add_doc_widget("menu_zoom_in1");
765 add_doc_widget("menu_zoom_out1");
766 add_doc_widget("normal_size1");
767 add_doc_widget("treeview6");
768 add_doc_widget("print1");
769 add_doc_widget("menu_reload_as1");
770 add_doc_widget("menu_select_all1");
771 add_doc_widget("insert_date1");
772 add_doc_widget("insert_alternative_white_space1");
773 add_doc_widget("menu_format1");
774 add_doc_widget("commands2");
775 add_doc_widget("menu_open_selected_file1");
776 add_doc_widget("page_setup1");
777 add_doc_widget("find1");
778 add_doc_widget("find_next1");
779 add_doc_widget("find_previous1");
780 add_doc_widget("go_to_next_marker1");
781 add_doc_widget("go_to_previous_marker1");
782 add_doc_widget("replace1");
783 add_doc_widget("find_nextsel1");
784 add_doc_widget("find_prevsel1");
785 add_doc_widget("find_usage1");
786 add_doc_widget("find_document_usage1");
787 add_doc_widget("mark_all1");
788 add_doc_widget("go_to_line1");
789 add_doc_widget("goto_tag_definition1");
790 add_doc_widget("goto_tag_declaration1");
791 add_doc_widget("reset_indentation1");
792 add_doc_toolitem("Close");
793 add_doc_toolitem("CloseAll");
794 add_doc_toolitem("Search");
795 add_doc_toolitem("SearchEntry");
796 add_doc_toolitem("ZoomIn");
797 add_doc_toolitem("ZoomOut");
798 add_doc_toolitem("Indent");
799 add_doc_toolitem("UnIndent");
800 add_doc_toolitem("Cut");
801 add_doc_toolitem("Copy");
802 add_doc_toolitem("Paste");
803 add_doc_toolitem("Delete");
804 add_doc_toolitem("Save");
805 add_doc_toolitem("SaveAs");
806 add_doc_toolitem("SaveAll");
807 add_doc_toolitem("Compile");
808 add_doc_toolitem("Run");
809 add_doc_toolitem("Reload");
810 add_doc_toolitem("Color");
811 add_doc_toolitem("Goto");
812 add_doc_toolitem("GotoEntry");
813 add_doc_toolitem("Replace");
814 add_doc_toolitem("Print");
815 }
816
817
818 void ui_document_buttons_update(void)
819 {
820 guint i;
821 gboolean enable = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook)) > 0;
822
823 for (i = 0; i < widgets.document_buttons->len; i++)
824 {
825 GtkWidget *widget = g_ptr_array_index(widgets.document_buttons, i);
826 if (GTK_IS_ACTION(widget))
827 gtk_action_set_sensitive(GTK_ACTION(widget), enable);
828 else
829 ui_widget_set_sensitive(widget, enable);
830 }
831 }
832
833
834 static void on_doc_sensitive_widget_destroy(GtkWidget *widget, G_GNUC_UNUSED gpointer user_data)
835 {
836 g_ptr_array_remove_fast(widgets.document_buttons, widget);
837 }
838
839
840 /** Adds a widget to the list of widgets that should be set sensitive/insensitive
841 * when some documents are present/no documents are open.
842 * It will be removed when the widget is destroyed.
843 * @param widget The widget to add.
844 *
845 * @since 0.15
846 **/
847 void ui_add_document_sensitive(GtkWidget *widget)
848 {
849 gboolean enable = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook)) > 0;
850
851 ui_widget_set_sensitive(widget, enable);
852
853 g_ptr_array_add(widgets.document_buttons, widget);
854 g_signal_connect(widget, "destroy", G_CALLBACK(on_doc_sensitive_widget_destroy), NULL);
855 }
856
857
858 void ui_widget_show_hide(GtkWidget *widget, gboolean show)
859 {
860 if (show)
861 {
862 gtk_widget_show(widget);
863 }
864 else
865 {
866 gtk_widget_hide(widget);
867 }
868 }
869
870
871 void ui_sidebar_show_hide(void)
872 {
873 GtkWidget *widget;
874
875 /* check that there are no other notebook pages before hiding the sidebar completely
876 * other pages could be e.g. the file browser plugin */
877 if (! interface_prefs.sidebar_openfiles_visible && ! interface_prefs.sidebar_symbol_visible &&
878 gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.sidebar_notebook)) <= 2)
879 {
880 ui_prefs.sidebar_visible = FALSE;
881 }
882
883 widget = ui_lookup_widget(main_widgets.window, "menu_show_sidebar1");
884 if (ui_prefs.sidebar_visible != gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))
885 {
886 ignore_callback = TRUE;
887 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), ui_prefs.sidebar_visible);
888 ignore_callback = FALSE;
889 }
890
891 ui_widget_show_hide(main_widgets.sidebar_notebook, ui_prefs.sidebar_visible);
892
893 ui_widget_show_hide(gtk_notebook_get_nth_page(
894 GTK_NOTEBOOK(main_widgets.sidebar_notebook), 0), interface_prefs.sidebar_symbol_visible);
895 ui_widget_show_hide(gtk_notebook_get_nth_page(
896 GTK_NOTEBOOK(main_widgets.sidebar_notebook), 1), interface_prefs.sidebar_openfiles_visible);
897 }
898
899
900 void ui_document_show_hide(GeanyDocument *doc)
901 {
902 const gchar *widget_name;
903 GtkWidget *item;
904 const GeanyIndentPrefs *iprefs;
905
906 g_return_if_fail(doc == NULL || doc->is_valid);
907
908 if (doc == NULL)
909 doc = document_get_current();
910
911 if (doc == NULL)
912 return;
913
914 ignore_callback = TRUE;
915
916 gtk_check_menu_item_set_active(
917 GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_line_wrapping1")),
918 doc->editor->line_wrapping);
919
920 gtk_check_menu_item_set_active(
921 GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "line_breaking1")),
922 doc->editor->line_breaking);
923
924 iprefs = editor_get_indent_prefs(doc->editor);
925
926 item = ui_lookup_widget(main_widgets.window, "menu_use_auto_indentation1");
927 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), doc->editor->auto_indent);
928
929 switch (iprefs->type)
930 {
931 case GEANY_INDENT_TYPE_SPACES:
932 widget_name = "spaces1"; break;
933 case GEANY_INDENT_TYPE_TABS:
934 widget_name = "tabs1"; break;
935 case GEANY_INDENT_TYPE_BOTH:
936 default:
937 widget_name = "tabs_and_spaces1"; break;
938 }
939 item = ui_lookup_widget(main_widgets.window, widget_name);
940 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
941
942 if (iprefs->width >= 1 && iprefs->width <= 8)
943 {
944 gchar *name;
945
946 name = g_strdup_printf("indent_width_%d", iprefs->width);
947 item = ui_lookup_widget(main_widgets.window, name);
948 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
949 g_free(name);
950 }
951
952 gtk_check_menu_item_set_active(
953 GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "set_file_readonly1")),
954 doc->readonly);
955
956 item = ui_lookup_widget(main_widgets.window, "menu_write_unicode_bom1");
957 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), doc->has_bom);
958 ui_widget_set_sensitive(item, encodings_is_unicode_charset(doc->encoding));
959
960 switch (sci_get_eol_mode(doc->editor->sci))
961 {
962 case SC_EOL_CR: widget_name = "cr"; break;
963 case SC_EOL_LF: widget_name = "lf"; break;
964 default: widget_name = "crlf"; break;
965 }
966 gtk_check_menu_item_set_active(
967 GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, widget_name)), TRUE);
968
969 encodings_select_radio_item(doc->encoding);
970 filetypes_select_radio_item(doc->file_type);
971
972 ignore_callback = FALSE;
973 }
974
975
976 void ui_set_search_entry_background(GtkWidget *widget, gboolean success)
977 {
978 gtk_widget_set_name(widget, success ? NULL : "geany-search-entry-no-match");
979 }
980
981
982 static void recent_create_menu(GeanyRecentFiles *grf)
983 {
984 GtkWidget *tmp;
985 guint i, len;
986 gchar *filename;
987
988 len = MIN(file_prefs.mru_length, g_queue_get_length(grf->recent_queue));
989 for (i = 0; i < len; i++)
990 {
991 filename = g_queue_peek_nth(grf->recent_queue, i);
992 /* create menu item for the recent files menu in the menu bar */
993 tmp = gtk_menu_item_new_with_label(filename);
994 gtk_widget_show(tmp);
995 gtk_container_add(GTK_CONTAINER(grf->menubar), tmp);
996 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
997 /* create menu item for the recent files menu in the toolbar */
998 if (grf->toolbar != NULL)
999 {
1000 tmp = gtk_menu_item_new_with_label(filename);
1001 gtk_widget_show(tmp);
1002 gtk_container_add(GTK_CONTAINER(grf->toolbar), tmp);
1003 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
1004 }
1005 }
1006 }
1007
1008
1009 static GeanyRecentFiles *recent_get_recent_files(void)
1010 {
1011 static GeanyRecentFiles grf = { RECENT_FILE_FILE, NULL, NULL, NULL, NULL };
1012
1013 if (G_UNLIKELY(grf.recent_queue == NULL))
1014 {
1015 grf.recent_queue = ui_prefs.recent_queue;
1016 grf.menubar = ui_widgets.recent_files_menu_menubar;
1017 grf.toolbar = geany_menu_button_action_get_menu(GEANY_MENU_BUTTON_ACTION(
1018 toolbar_get_action_by_name("Open")));
1019 grf.activate_cb = recent_file_activate_cb;
1020 }
1021 return &grf;
1022 }
1023
1024
1025 static GeanyRecentFiles *recent_get_recent_projects(void)
1026 {
1027 static GeanyRecentFiles grf = { RECENT_FILE_PROJECT, NULL, NULL, NULL, NULL };
1028
1029 if (G_UNLIKELY(grf.recent_queue == NULL))
1030 {
1031 grf.recent_queue = ui_prefs.recent_projects_queue;
1032 grf.menubar = ui_widgets.recent_projects_menu_menubar;
1033 grf.toolbar = NULL;
1034 grf.activate_cb = recent_project_activate_cb;
1035 }
1036 return &grf;
1037 }
1038
1039
1040 void ui_create_recent_menus(void)
1041 {
1042 recent_create_menu(recent_get_recent_files());
1043 recent_create_menu(recent_get_recent_projects());
1044 }
1045
1046
1047 static void recent_file_activate_cb(GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer user_data)
1048 {
1049 gchar *utf8_filename = ui_menu_item_get_text(menuitem);
1050 gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename);
1051
1052 if (document_open_file(locale_filename, FALSE, NULL, NULL) != NULL)
1053 recent_file_loaded(utf8_filename, recent_get_recent_files());
1054
1055 g_free(locale_filename);
1056 g_free(utf8_filename);
1057 }
1058
1059
1060 static void recent_project_activate_cb(GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer user_data)
1061 {
1062 gchar *utf8_filename = ui_menu_item_get_text(menuitem);
1063 gchar *locale_filename = utils_get_locale_from_utf8(utf8_filename);
1064
1065 if (project_ask_close() && project_load_file_with_session(locale_filename))
1066 recent_file_loaded(utf8_filename, recent_get_recent_projects());
1067
1068 g_free(locale_filename);
1069 g_free(utf8_filename);
1070 }
1071
1072
1073 static void add_recent_file(const gchar *utf8_filename, GeanyRecentFiles *grf,
1074 const GtkRecentData *rdata)
1075 {
1076 if (g_queue_find_custom(grf->recent_queue, utf8_filename, (GCompareFunc) strcmp) == NULL)
1077 {
1078
1079 if (grf->type == RECENT_FILE_FILE && rdata)
1080 {
1081 GtkRecentManager *manager = gtk_recent_manager_get_default();
1082 gchar *uri = g_filename_to_uri(utf8_filename, NULL, NULL);
1083 if (uri != NULL)
1084 {
1085 gtk_recent_manager_add_full(manager, uri, rdata);
1086 g_free(uri);
1087 }
1088 }
1089
1090 g_queue_push_head(grf->recent_queue, g_strdup(utf8_filename));
1091 if (g_queue_get_length(grf->recent_queue) > file_prefs.mru_length)
1092 {
1093 g_free(g_queue_pop_tail(grf->recent_queue));
1094 }
1095 update_recent_menu(grf);
1096 }
1097 /* filename already in recent list */
1098 else
1099 recent_file_loaded(utf8_filename, grf);
1100 }
1101
1102
1103 void ui_add_recent_document(GeanyDocument *doc)
1104 {
1105 /* what are the groups for actually? */
1106 static const gchar *groups[2] = {
1107 "geany",
1108 NULL
1109 };
1110 GtkRecentData rdata;
1111
1112 /* Prepare the data for gtk_recent_manager_add_full() */
1113 rdata.display_name = NULL;
1114 rdata.description = NULL;
1115 rdata.mime_type = doc->file_type->mime_type;
1116 /* if we ain't got no mime-type, fallback to plain text */
1117 if (! rdata.mime_type)
1118 rdata.mime_type = (gchar *) "text/plain";
1119 rdata.app_name = (gchar *) "geany";
1120 rdata.app_exec = (gchar *) "geany %u";
1121 rdata.groups = (gchar **) groups;
1122 rdata.is_private = FALSE;
1123
1124 add_recent_file(doc->file_name, recent_get_recent_files(), &rdata);
1125 }
1126
1127
1128 void ui_add_recent_project_file(const gchar *utf8_filename)
1129 {
1130 add_recent_file(utf8_filename, recent_get_recent_projects(), NULL);
1131 }
1132
1133
1134 /* Returns: newly allocated string with the UTF-8 menu text. */
1135 gchar *ui_menu_item_get_text(GtkMenuItem *menu_item)
1136 {
1137 const gchar *text = NULL;
1138
1139 if (gtk_bin_get_child(GTK_BIN(menu_item)))
1140 {
1141 GtkWidget *child = gtk_bin_get_child(GTK_BIN(menu_item));
1142
1143 if (GTK_IS_LABEL(child))
1144 text = gtk_label_get_text(GTK_LABEL(child));
1145 }
1146 /* GTK owns text so it's much safer to return a copy of it in case the memory is reallocated */
1147 return g_strdup(text);
1148 }
1149
1150
1151 static gint find_recent_file_item(gconstpointer list_data, gconstpointer user_data)
1152 {
1153 gchar *menu_text = ui_menu_item_get_text(GTK_MENU_ITEM(list_data));
1154 gint result;
1155
1156 if (utils_str_equal(menu_text, user_data))
1157 result = 0;
1158 else
1159 result = 1;
1160
1161 g_free(menu_text);
1162 return result;
1163 }
1164
1165
1166 static void recent_file_loaded(const gchar *utf8_filename, GeanyRecentFiles *grf)
1167 {
1168 GList *item, *children;
1169 void *data;
1170 GtkWidget *tmp;
1171
1172 /* first reorder the queue */
1173 item = g_queue_find_custom(grf->recent_queue, utf8_filename, (GCompareFunc) strcmp);
1174 g_return_if_fail(item != NULL);
1175
1176 data = item->data;
1177 g_queue_remove(grf->recent_queue, data);
1178 g_queue_push_head(grf->recent_queue, data);
1179
1180 /* remove the old menuitem for the filename */
1181 children = gtk_container_get_children(GTK_CONTAINER(grf->menubar));
1182 item = g_list_find_custom(children, utf8_filename, (GCompareFunc) find_recent_file_item);
1183 if (item != NULL)
1184 gtk_widget_destroy(GTK_WIDGET(item->data));
1185 g_list_free(children);
1186
1187 if (grf->toolbar != NULL)
1188 {
1189 children = gtk_container_get_children(GTK_CONTAINER(grf->toolbar));
1190 item = g_list_find_custom(children, utf8_filename, (GCompareFunc) find_recent_file_item);
1191 if (item != NULL)
1192 gtk_widget_destroy(GTK_WIDGET(item->data));
1193 g_list_free(children);
1194 }
1195 /* now prepend a new menuitem for the filename,
1196 * first for the recent files menu in the menu bar */
1197 tmp = gtk_menu_item_new_with_label(utf8_filename);
1198 gtk_widget_show(tmp);
1199 gtk_menu_shell_prepend(GTK_MENU_SHELL(grf->menubar), tmp);
1200 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
1201 /* then for the recent files menu in the tool bar */
1202 if (grf->toolbar != NULL)
1203 {
1204 tmp = gtk_menu_item_new_with_label(utf8_filename);
1205 gtk_widget_show(tmp);
1206 gtk_container_add(GTK_CONTAINER(grf->toolbar), tmp);
1207 /* this is a bit ugly, but we need to use gtk_container_add(). Using
1208 * gtk_menu_shell_prepend() doesn't emit GtkContainer's "add" signal which we need in
1209 * GeanyMenubuttonAction */
1210 gtk_menu_reorder_child(GTK_MENU(grf->toolbar), tmp, 0);
1211 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
1212 }
1213 }
1214
1215
1216 static void update_recent_menu(GeanyRecentFiles *grf)
1217 {
1218 GtkWidget *tmp;
1219 gchar *filename;
1220 GList *children, *item;
1221
1222 filename = g_queue_peek_head(grf->recent_queue);
1223
1224 /* clean the MRU list before adding an item (menubar) */
1225 children = gtk_container_get_children(GTK_CONTAINER(grf->menubar));
1226 if (g_list_length(children) > file_prefs.mru_length - 1)
1227 {
1228 item = g_list_nth(children, file_prefs.mru_length - 1);
1229 while (item != NULL)
1230 {
1231 if (GTK_IS_MENU_ITEM(item->data))
1232 gtk_widget_destroy(GTK_WIDGET(item->data));
1233 item = g_list_next(item);
1234 }
1235 }
1236 g_list_free(children);
1237
1238 /* create item for the menu bar menu */
1239 tmp = gtk_menu_item_new_with_label(filename);
1240 gtk_widget_show(tmp);
1241 gtk_menu_shell_prepend(GTK_MENU_SHELL(grf->menubar), tmp);
1242 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
1243
1244 /* clean the MRU list before adding an item (toolbar) */
1245 if (grf->toolbar != NULL)
1246 {
1247 children = gtk_container_get_children(GTK_CONTAINER(grf->toolbar));
1248 if (g_list_length(children) > file_prefs.mru_length - 1)
1249 {
1250 item = g_list_nth(children, file_prefs.mru_length - 1);
1251 while (item != NULL)
1252 {
1253 if (GTK_IS_MENU_ITEM(item->data))
1254 gtk_widget_destroy(GTK_WIDGET(item->data));
1255 item = g_list_next(item);
1256 }
1257 }
1258 g_list_free(children);
1259
1260 /* create item for the tool bar menu */
1261 tmp = gtk_menu_item_new_with_label(filename);
1262 gtk_widget_show(tmp);
1263 gtk_container_add(GTK_CONTAINER(grf->toolbar), tmp);
1264 gtk_menu_reorder_child(GTK_MENU(grf->toolbar), tmp, 0);
1265 g_signal_connect(tmp, "activate", G_CALLBACK(grf->activate_cb), NULL);
1266 }
1267 }
1268
1269
1270 void ui_toggle_editor_features(GeanyUIEditorFeatures feature)
1271 {
1272 guint i;
1273
1274 foreach_document (i)
1275 {
1276 GeanyDocument *doc = documents[i];
1277
1278 switch (feature)
1279 {
1280 case GEANY_EDITOR_SHOW_MARKERS_MARGIN:
1281 sci_set_symbol_margin(doc->editor->sci, editor_prefs.show_markers_margin);
1282 break;
1283 case GEANY_EDITOR_SHOW_LINE_NUMBERS:
1284 sci_set_line_numbers(doc->editor->sci, editor_prefs.show_linenumber_margin, 0);
1285 break;
1286 case GEANY_EDITOR_SHOW_WHITE_SPACE:
1287 sci_set_visible_white_spaces(doc->editor->sci, editor_prefs.show_white_space);
1288 break;
1289 case GEANY_EDITOR_SHOW_LINE_ENDINGS:
1290 sci_set_visible_eols(doc->editor->sci, editor_prefs.show_line_endings);
1291 break;
1292 case GEANY_EDITOR_SHOW_INDENTATION_GUIDES:
1293 editor_set_indentation_guides(doc->editor);
1294 break;
1295 }
1296 }
1297 }
1298
1299
1300 void ui_update_view_editor_menu_items(void)
1301 {
1302 ignore_callback = TRUE;
1303 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_markers_margin1")), editor_prefs.show_markers_margin);
1304 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_linenumber_margin1")), editor_prefs.show_linenumber_margin);
1305 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_white_space1")), editor_prefs.show_white_space);
1306 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_line_endings1")), editor_prefs.show_line_endings);
1307 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_indentation_guides1")), editor_prefs.show_indent_guide);
1308 ignore_callback = FALSE;
1309 }
1310
1311
1312 /** Creates a GNOME HIG-style frame (with no border and indented child alignment).
1313 * @param label_text The label text.
1314 * @param alignment An address to store the alignment widget pointer.
1315 * @return The frame widget, setting the alignment container for packing child widgets. */
1316 GtkWidget *ui_frame_new_with_alignment(const gchar *label_text, GtkWidget **alignment)
1317 {
1318 GtkWidget *label, *align;
1319 GtkWidget *frame = gtk_frame_new(NULL);
1320
1321 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
1322
1323 align = gtk_alignment_new(0.5, 0.5, 1, 1);
1324 gtk_container_add(GTK_CONTAINER(frame), align);
1325 gtk_alignment_set_padding(GTK_ALIGNMENT(align), 0, 0, 12, 0);
1326
1327 label = ui_label_new_bold(label_text);
1328 gtk_frame_set_label_widget(GTK_FRAME(frame), label);
1329
1330 *alignment = align;
1331 return frame;
1332 }
1333
1334
1335 /** Makes a fixed border for dialogs without increasing the button box border.
1336 * @param dialog The parent container for the @c GtkVBox.
1337 * @return The packed @c GtkVBox. */
1338 GtkWidget *ui_dialog_vbox_new(GtkDialog *dialog)
1339 {
1340 GtkWidget *vbox = gtk_vbox_new(FALSE, 12); /* need child vbox to set a separate border. */
1341
1342 gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
1343 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), vbox, TRUE, TRUE, 0);
1344 return vbox;
1345 }
1346
1347
1348 static GtkWidget *dialog_get_widget_for_response(GtkDialog *dialog, gint response_id)
1349 {
1350 #if GTK_CHECK_VERSION(2, 20, 0)
1351 return gtk_dialog_get_widget_for_response(dialog, response_id);
1352 #else /* GTK < 2.20 */
1353 /* base logic stolen from GTK */
1354 GtkWidget *action_area = gtk_dialog_get_action_area(dialog);
1355 GtkWidget *widget = NULL;
1356 GList *children, *node;
1357
1358 children = gtk_container_get_children(GTK_CONTAINER(action_area));
1359 for (node = children; node && ! widget; node = node->next)
1360 {
1361 if (gtk_dialog_get_response_for_widget(dialog, node->data) == response_id)
1362 widget = node->data;
1363 }
1364 g_list_free(children);
1365
1366 return widget;
1367 #endif
1368 }
1369
1370
1371 /* Reorders a dialog's buttons
1372 * @param dialog A dialog
1373 * @param response First response ID to reorder
1374 * @param ... more response IDs, terminated by -1
1375 *
1376 * Like gtk_dialog_set_alternative_button_order(), but reorders the default
1377 * buttons layout, not the alternative one. This is useful if you e.g. added a
1378 * button to a dialog which already had some and need yours not to be on the
1379 * end.
1380 */
1381 /* Heavily based on gtk_dialog_set_alternative_button_order().
1382 * This relies on the action area to be a GtkBox, but although not documented
1383 * the API expose it to be a GtkHButtonBox though GtkBuilder, so it should be
1384 * fine */
1385 void ui_dialog_set_primary_button_order(GtkDialog *dialog, gint response, ...)
1386 {
1387 va_list ap;
1388 GtkWidget *action_area = gtk_dialog_get_action_area(dialog);
1389 gint position;
1390
1391 va_start(ap, response);
1392 for (position = 0; response != -1; position++)
1393 {
1394 GtkWidget *child = dialog_get_widget_for_response(dialog, response);
1395 if (child)
1396 gtk_box_reorder_child(GTK_BOX(action_area), child, position);
1397 else
1398 g_warning("%s: no child button with response id %d.", G_STRFUNC, response);
1399
1400 response = va_arg(ap, gint);
1401 }
1402 va_end(ap);
1403 }
1404
1405
1406 /** Creates a @c GtkButton with custom text and a stock image similar to
1407 * @c gtk_button_new_from_stock().
1408 * @param stock_id A @c GTK_STOCK_NAME string.
1409 * @param text Button label text, can include mnemonics.
1410 * @return The new @c GtkButton.
1411 */
1412 GtkWidget *ui_button_new_with_image(const gchar *stock_id, const gchar *text)
1413 {
1414 GtkWidget *image, *button;
1415
1416 button = gtk_button_new_with_mnemonic(text);
1417 gtk_widget_show(button);
1418 image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_BUTTON);
1419 gtk_button_set_image(GTK_BUTTON(button), image);
1420 /* note: image is shown by gtk */
1421 return button;
1422 }
1423
1424
1425 /** Creates a @c GtkImageMenuItem with a stock image and a custom label.
1426 * @param stock_id Stock image ID, e.g. @c GTK_STOCK_OPEN.
1427 * @param label Menu item label, can include mnemonics.
1428 * @return The new @c GtkImageMenuItem.
1429 *
1430 * @since 0.16
1431 */
1432 GtkWidget *
1433 ui_image_menu_item_new(const gchar *stock_id, const gchar *label)
1434 {
1435 GtkWidget *item = gtk_image_menu_item_new_with_mnemonic(label);
1436 GtkWidget *image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU);
1437
1438 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
1439 gtk_widget_show(image);
1440 return item;
1441 }
1442
1443
1444 static void entry_clear_icon_release_cb(GtkEntry *entry, gint icon_pos,
1445 GdkEvent *event, gpointer data)
1446 {
1447 if (event->button.button == 1 && icon_pos == 1)
1448 {
1449 gtk_entry_set_text(entry, "");
1450 gtk_widget_grab_focus(GTK_WIDGET(entry));
1451 }
1452 }
1453
1454
1455 /** Adds a small clear icon to the right end of the passed @a entry.
1456 * A callback to clear the contents of the GtkEntry is automatically added.
1457 *
1458 * @param entry The GtkEntry object to which the icon should be attached.
1459 *
1460 * @since 0.16
1461 */
1462 void ui_entry_add_clear_icon(GtkEntry *entry)
1463 {
1464 g_object_set(entry, "secondary-icon-stock", GTK_STOCK_CLEAR,
1465 "secondary-icon-activatable", TRUE, NULL);
1466 g_signal_connect(entry, "icon-release", G_CALLBACK(entry_clear_icon_release_cb), NULL);
1467 }
1468
1469
1470 /* Adds a :activate-backwards signal emitted by default when <Shift>Return is pressed */
1471 void ui_entry_add_activate_backward_signal(GtkEntry *entry)
1472 {
1473 static gboolean installed = FALSE;
1474
1475 g_return_if_fail(GTK_IS_ENTRY(entry));
1476
1477 if (G_UNLIKELY(! installed))
1478 {
1479 GtkBindingSet *binding_set;
1480
1481 installed = TRUE;
1482
1483 /* try to handle the unexpected case where GTK would already have installed the signal */
1484 if (g_signal_lookup("activate-backward", G_TYPE_FROM_INSTANCE(entry)))
1485 {
1486 g_warning("Signal GtkEntry:activate-backward is unexpectedly already installed");
1487 return;
1488 }
1489
1490 g_signal_new("activate-backward", G_TYPE_FROM_INSTANCE(entry),
1491 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, 0, NULL, NULL,
1492 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
1493 binding_set = gtk_binding_set_by_class(GTK_ENTRY_GET_CLASS(entry));
1494 gtk_binding_entry_add_signal(binding_set, GDK_Return, GDK_SHIFT_MASK, "activate-backward", 0);
1495 }
1496 }
1497
1498
1499 static void add_to_size_group(GtkWidget *widget, gpointer size_group)
1500 {
1501 g_return_if_fail(GTK_IS_SIZE_GROUP(size_group));
1502 gtk_size_group_add_widget(GTK_SIZE_GROUP(size_group), widget);
1503 }
1504
1505
1506 /* Copies the spacing and layout of the master GtkHButtonBox and synchronises
1507 * the width of each button box's children.
1508 * Should be called after all child widgets have been packed. */
1509 void ui_hbutton_box_copy_layout(GtkButtonBox *master, GtkButtonBox *copy)
1510 {
1511 GtkSizeGroup *size_group;
1512
1513 gtk_box_set_spacing(GTK_BOX(copy), 10);
1514 gtk_button_box_set_layout(copy, gtk_button_box_get_layout(master));
1515
1516 /* now we need to put the widest widget from each button box in a size group,
1517 * but we don't know the width before they are drawn, and for different label
1518 * translations the widest widget can vary, so we just add all widgets. */
1519 size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1520 gtk_container_foreach(GTK_CONTAINER(master), add_to_size_group, size_group);
1521 gtk_container_foreach(GTK_CONTAINER(copy), add_to_size_group, size_group);
1522 g_object_unref(size_group);
1523 }
1524
1525
1526 static gboolean tree_model_find_text(GtkTreeModel *model,
1527 GtkTreeIter *iter, gint column, const gchar *text)
1528 {
1529 gchar *combo_text;
1530 gboolean found = FALSE;
1531
1532 if (gtk_tree_model_get_iter_first(model, iter))
1533 {
1534 do
1535 {
1536 gtk_tree_model_get(model, iter, 0, &combo_text, -1);
1537 found = utils_str_equal(combo_text, text);
1538 g_free(combo_text);
1539
1540 if (found)
1541 return TRUE;
1542 }
1543 while (gtk_tree_model_iter_next(model, iter));
1544 }
1545 return FALSE;
1546 }
1547
1548
1549 /** Prepends @a text to the drop down list, removing a duplicate element in
1550 * the list if found. Also ensures there are <= @a history_len elements.
1551 * @param combo_entry .
1552 * @param text Text to add, or @c NULL for current entry text.
1553 * @param history_len Max number of items, or @c 0 for default. */
1554 void ui_combo_box_add_to_history(GtkComboBoxText *combo_entry,
1555 const gchar *text, gint history_len)
1556 {
1557 GtkComboBox *combo = GTK_COMBO_BOX(combo_entry);
1558 GtkTreeModel *model;
1559 GtkTreeIter iter;
1560 GtkTreePath *path;
1561
1562 if (history_len <= 0)
1563 history_len = 10;
1564 if (!text)
1565 text = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo))));
1566
1567 model = gtk_combo_box_get_model(combo);
1568
1569 if (tree_model_find_text(model, &iter, 0, text))
1570 {
1571 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
1572 }
1573 gtk_combo_box_text_prepend_text(combo_entry, text);
1574
1575 /* limit history */
1576 path = gtk_tree_path_new_from_indices(history_len, -1);
1577 if (gtk_tree_model_get_iter(model, &iter, path))
1578 {
1579 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
1580 }
1581 gtk_tree_path_free(path);
1582 }
1583
1584
1585 /* Same as gtk_combo_box_text_prepend_text(), except that text is only prepended if it not already
1586 * exists in the combo's model. */
1587 void ui_combo_box_prepend_text_once(GtkComboBoxText *combo, const gchar *text)
1588 {
1589 GtkTreeModel *model;
1590 GtkTreeIter iter;
1591
1592 model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
1593 if (tree_model_find_text(model, &iter, 0, text))
1594 return; /* don't prepend duplicate */
1595
1596 gtk_combo_box_text_prepend_text(combo, text);
1597 }
1598
1599
1600 /* Changes the color of the notebook tab text and open files items according to
1601 * document status. */
1602 void ui_update_tab_status(GeanyDocument *doc)
1603 {
1604 gtk_widget_set_name(doc->priv->tab_label, document_get_status_widget_class(doc));
1605
1606 sidebar_openfiles_update(doc);
1607 }
1608
1609
1610 static gboolean tree_model_iter_get_next(GtkTreeModel *model, GtkTreeIter *iter,
1611 gboolean down)
1612 {
1613 GtkTreePath *path;
1614 gboolean result;
1615
1616 if (down)
1617 return gtk_tree_model_iter_next(model, iter);
1618
1619 path = gtk_tree_model_get_path(model, iter);
1620 result = gtk_tree_path_prev(path) && gtk_tree_model_get_iter(model, iter, path);
1621 gtk_tree_path_free(path);
1622 return result;
1623 }
1624
1625
1626 /* note: the while loop might be more efficient when searching upwards if it
1627 * used tree paths instead of tree iters, but in practice it probably doesn't matter much. */
1628 static gboolean tree_view_find(GtkTreeView *treeview, TVMatchCallback cb, gboolean down)
1629 {
1630 GtkTreeSelection *treesel;
1631 GtkTreeIter iter;
1632 GtkTreeModel *model;
1633
1634 treesel = gtk_tree_view_get_selection(treeview);
1635 if (gtk_tree_selection_get_selected(treesel, &model, &iter))
1636 {
1637 /* get the next selected item */
1638 if (! tree_model_iter_get_next(model, &iter, down))
1639 return FALSE; /* no more items */
1640 }
1641 else /* no selection */
1642 {
1643 if (! gtk_tree_model_get_iter_first(model, &iter))
1644 return TRUE; /* no items */
1645 }
1646 while (TRUE)
1647 {
1648 gtk_tree_selection_select_iter(treesel, &iter);
1649 if (cb(FALSE))
1650 break; /* found next message */
1651
1652 if (! tree_model_iter_get_next(model, &iter, down))
1653 return FALSE; /* no more items */
1654 }
1655 /* scroll item in view */
1656 if (ui_prefs.msgwindow_visible)
1657 {
1658 GtkTreePath *path = gtk_tree_model_get_path(
1659 gtk_tree_view_get_model(treeview), &iter);
1660
1661 gtk_tree_view_scroll_to_cell(treeview, path, NULL, TRUE, 0.5, 0.5);
1662 gtk_tree_path_free(path);
1663 }
1664 return TRUE;
1665 }
1666
1667
1668 /* Returns FALSE if the treeview has items but no matching next item. */
1669 gboolean ui_tree_view_find_next(GtkTreeView *treeview, TVMatchCallback cb)
1670 {
1671 return tree_view_find(treeview, cb, TRUE);
1672 }
1673
1674
1675 /* Returns FALSE if the treeview has items but no matching next item. */
1676 gboolean ui_tree_view_find_previous(GtkTreeView *treeview, TVMatchCallback cb)
1677 {
1678 return tree_view_find(treeview, cb, FALSE);
1679 }
1680
1681
1682 /**
1683 * Modifies the font of a widget using gtk_widget_modify_font().
1684 *
1685 * @param widget The widget.
1686 * @param str The font name as expected by pango_font_description_from_string().
1687 */
1688 void ui_widget_modify_font_from_string(GtkWidget *widget, const gchar *str)
1689 {
1690 PangoFontDescription *pfd;
1691
1692 pfd = pango_font_description_from_string(str);
1693 gtk_widget_modify_font(widget, pfd);
1694 pango_font_description_free(pfd);
1695 }
1696
1697
1698 /** Creates a @c GtkHBox with @a entry packed into it and an open button which runs a
1699 * file chooser, replacing entry text (if successful) with the path returned from the
1700 * @c GtkFileChooser.
1701 * @note @a entry can be the child of an unparented widget, such as @c GtkComboBoxEntry.
1702 * @param title The file chooser dialog title, or @c NULL.
1703 * @param action The mode of the file chooser.
1704 * @param entry Can be an unpacked @c GtkEntry, or the child of an unpacked widget,
1705 * such as @c GtkComboBoxEntry.
1706 * @return The @c GtkHBox.
1707 */
1708 /* @see ui_setup_open_button_callback(). */
1709 GtkWidget *ui_path_box_new(const gchar *title, GtkFileChooserAction action, GtkEntry *entry)
1710 {
1711 GtkWidget *vbox, *dirbtn, *openimg, *hbox, *path_entry;
1712
1713 hbox = gtk_hbox_new(FALSE, 6);
1714 path_entry = GTK_WIDGET(entry);
1715
1716 /* prevent path_entry being vertically stretched to the height of dirbtn */
1717 vbox = gtk_vbox_new(FALSE, 0);
1718 if (gtk_widget_get_parent(path_entry)) /* entry->parent may be a GtkComboBoxEntry */
1719 {
1720 GtkWidget *parent = gtk_widget_get_parent(path_entry);
1721
1722 gtk_box_pack_start(GTK_BOX(vbox), parent, TRUE, FALSE, 0);
1723 }
1724 else
1725 gtk_box_pack_start(GTK_BOX(vbox), path_entry, TRUE, FALSE, 0);
1726
1727 dirbtn = gtk_button_new();
1728 openimg = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
1729 gtk_container_add(GTK_CONTAINER(dirbtn), openimg);
1730 ui_setup_open_button_callback(dirbtn, title, action, entry);
1731
1732 gtk_box_pack_end(GTK_BOX(hbox), dirbtn, FALSE, FALSE, 0);
1733 gtk_box_pack_end(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1734 return hbox;
1735 }
1736
1737
1738 static void ui_path_box_open_clicked(GtkButton *button, gpointer user_data);
1739
1740
1741 /* Setup a GtkButton to run a GtkFileChooser, setting entry text if successful.
1742 * title can be NULL.
1743 * action is the file chooser mode to use. */
1744 void ui_setup_open_button_callback(GtkWidget *open_btn, const gchar *title,
1745 GtkFileChooserAction action, GtkEntry *entry)
1746 {
1747 GtkWidget *path_entry = GTK_WIDGET(entry);
1748
1749 if (title)
1750 g_object_set_data_full(G_OBJECT(open_btn), "title", g_strdup(title),
1751 (GDestroyNotify) g_free);
1752 g_object_set_data(G_OBJECT(open_btn), "action", GINT_TO_POINTER(action));
1753 g_signal_connect(open_btn, "clicked", G_CALLBACK(ui_path_box_open_clicked), path_entry);
1754 }
1755
1756
1757 #ifndef G_OS_WIN32
1758 static gchar *run_file_chooser(const gchar *title, GtkFileChooserAction action,
1759 const gchar *utf8_path)
1760 {
1761 GtkWidget *dialog = gtk_file_chooser_dialog_new(title,
1762 GTK_WINDOW(main_widgets.window), action,
1763 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1764 GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL);
1765 gchar *locale_path;
1766 gchar *ret_path = NULL;
1767
1768 gtk_widget_set_name(dialog, "GeanyDialog");
1769 locale_path = utils_get_locale_from_utf8(utf8_path);
1770 if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
1771 {
1772 if (g_path_is_absolute(locale_path) && g_file_test(locale_path, G_FILE_TEST_IS_DIR))
1773 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
1774 }
1775 else if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
1776 {
1777 if (g_path_is_absolute(locale_path))
1778 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), locale_path);
1779 }
1780 g_free(locale_path);
1781
1782 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
1783 {
1784 gchar *dir_locale;
1785
1786 dir_locale = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1787 ret_path = utils_get_utf8_from_locale(dir_locale);
1788 g_free(dir_locale);
1789 }
1790 gtk_widget_destroy(dialog);
1791 return ret_path;
1792 }
1793 #endif
1794
1795
1796 static void ui_path_box_open_clicked(GtkButton *button, gpointer user_data)
1797 {
1798 GtkFileChooserAction action = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "action"));
1799 GtkEntry *entry = user_data;
1800 const gchar *title = g_object_get_data(G_OBJECT(button), "title");
1801 gchar *utf8_path = NULL;
1802
1803 /* TODO: extend for other actions */
1804 g_return_if_fail(action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
1805 action == GTK_FILE_CHOOSER_ACTION_OPEN);
1806
1807 if (title == NULL)
1808 title = (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER) ?
1809 _("Select Folder") : _("Select File");
1810
1811 if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
1812 {
1813 #ifdef G_OS_WIN32
1814 utf8_path = win32_show_file_dialog(GTK_WINDOW(ui_widgets.prefs_dialog), title,
1815 gtk_entry_get_text(GTK_ENTRY(entry)));
1816 #else
1817 utf8_path = run_file_chooser(title, action, gtk_entry_get_text(GTK_ENTRY(entry)));
1818 #endif
1819 }
1820 else if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
1821 {
1822 gchar *path = g_path_get_dirname(gtk_entry_get_text(GTK_ENTRY(entry)));
1823 #ifdef G_OS_WIN32
1824 utf8_path = win32_show_folder_dialog(ui_widgets.prefs_dialog, title,
1825 gtk_entry_get_text(GTK_ENTRY(entry)));
1826 #else
1827 utf8_path = run_file_chooser(title, action, path);
1828 #endif
1829 g_free(path);
1830 }
1831
1832 if (utf8_path != NULL)
1833 {
1834 gtk_entry_set_text(GTK_ENTRY(entry), utf8_path);
1835 g_free(utf8_path);
1836 }
1837 }
1838
1839
1840 void ui_statusbar_showhide(gboolean state)
1841 {
1842 /* handle statusbar visibility */
1843 if (state)
1844 {
1845 gtk_widget_show(ui_widgets.statusbar);
1846 ui_update_statusbar(NULL, -1);
1847 }
1848 else
1849 gtk_widget_hide(ui_widgets.statusbar);
1850 }
1851
1852
1853 /** Packs all @c GtkWidgets passed after the row argument into a table, using
1854 * one widget per cell. The first widget is not expanded as the table grows,
1855 * as this is usually a label.
1856 * @param table
1857 * @param row The row number of the table.
1858 */
1859 void ui_table_add_row(GtkTable *table, gint row, ...)
1860 {
1861 va_list args;
1862 guint i;
1863 GtkWidget *widget;
1864
1865 va_start(args, row);
1866 for (i = 0; (widget = va_arg(args, GtkWidget*), widget != NULL); i++)
1867 {
1868 gint options = (i == 0) ? GTK_FILL : GTK_EXPAND | GTK_FILL;
1869
1870 gtk_table_attach(GTK_TABLE(table), widget, i, i + 1, row, row + 1,
1871 options, 0, 0, 0);
1872 }
1873 va_end(args);
1874 }
1875
1876
1877 static void on_config_file_clicked(GtkWidget *widget, gpointer user_data)
1878 {
1879 const gchar *file_name = user_data;
1880 GeanyFiletype *ft = NULL;
1881
1882 if (strstr(file_name, G_DIR_SEPARATOR_S "filetypes."))
1883 ft = filetypes[GEANY_FILETYPES_CONF];
1884
1885 if (g_file_test(file_name, G_FILE_TEST_EXISTS))
1886 document_open_file(file_name, FALSE, ft, NULL);
1887 else
1888 {
1889 gchar *utf8_filename = utils_get_utf8_from_locale(file_name);
1890 gchar *base_name = g_path_get_basename(file_name);
1891 gchar *global_file = g_build_filename(app->datadir, base_name, NULL);
1892 gchar *global_content = NULL;
1893
1894 /* if the requested file doesn't exist in the user's config dir, try loading the file
1895 * from the global data directory and use its contents for the newly created file */
1896 if (g_file_test(global_file, G_FILE_TEST_EXISTS))
1897 g_file_get_contents(global_file, &global_content, NULL, NULL);
1898
1899 document_new_file(utf8_filename, ft, global_content);
1900
1901 utils_free_pointers(4, utf8_filename, base_name, global_file, global_content, NULL);
1902 }
1903 }
1904
1905
1906 static void free_on_closure_notify(gpointer data, GClosure *closure)
1907 {
1908 g_free(data);
1909 }
1910
1911
1912 /* @note You should connect to the "document-save" signal yourself to detect
1913 * if the user has just saved the config file, reloading it. */
1914 void ui_add_config_file_menu_item(const gchar *real_path, const gchar *label, GtkContainer *parent)
1915 {
1916 GtkWidget *item;
1917
1918 if (!parent)
1919 parent = GTK_CONTAINER(widgets.config_files_menu);
1920
1921 if (!label)
1922 {
1923 gchar *base_name;
1924
1925 base_name = g_path_get_basename(real_path);
1926 item = gtk_menu_item_new_with_label(base_name);
1927 g_free(base_name);
1928 }
1929 else
1930 item = gtk_menu_item_new_with_mnemonic(label);
1931
1932 gtk_widget_show(item);
1933 gtk_container_add(parent, item);
1934 g_signal_connect_data(item, "activate", G_CALLBACK(on_config_file_clicked),
1935 g_strdup(real_path), free_on_closure_notify, 0);
1936 }
1937
1938
1939 static gboolean sort_menu(gpointer data)
1940 {
1941 ui_menu_sort_by_label(GTK_MENU(data));
1942 return FALSE;
1943 }
1944
1945
1946 static void create_config_files_menu(void)
1947 {
1948 GtkWidget *menu, *item;
1949
1950 widgets.config_files_menu = menu = gtk_menu_new();
1951
1952 item = ui_lookup_widget(main_widgets.window, "configuration_files1");
1953 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
1954
1955 /* sort menu after all items added */
1956 g_idle_add(sort_menu, widgets.config_files_menu);
1957 }
1958
1959
1960 /* adds factory icons with a named icon source using the stock items id */
1961 static void add_stock_icons(const GtkStockItem *items, gsize count)
1962 {
1963 GtkIconFactory *factory = gtk_icon_factory_new();
1964 GtkIconSource *source = gtk_icon_source_new();
1965 gsize i;
1966
1967 for (i = 0; i < count; i++)
1968 {
1969 GtkIconSet *set = gtk_icon_set_new();
1970
1971 gtk_icon_source_set_icon_name(source, items[i].stock_id);
1972 gtk_icon_set_add_source(set, source);
1973 gtk_icon_factory_add(factory, items[i].stock_id, set);
1974 gtk_icon_set_unref(set);
1975 }
1976 gtk_icon_source_free(source);
1977 gtk_icon_factory_add_default(factory);
1978 g_object_unref(factory);
1979 }
1980
1981
1982 void ui_init_stock_items(void)
1983 {
1984 GtkStockItem items[] =
1985 {
1986 { GEANY_STOCK_SAVE_ALL, N_("Save All"), 0, 0, GETTEXT_PACKAGE },
1987 { GEANY_STOCK_CLOSE_ALL, N_("Close All"), 0, 0, GETTEXT_PACKAGE },
1988 { GEANY_STOCK_BUILD, N_("Build"), 0, 0, GETTEXT_PACKAGE }
1989 };
1990
1991 gtk_stock_add(items, G_N_ELEMENTS(items));
1992 add_stock_icons(items, G_N_ELEMENTS(items));
1993 }
1994
1995
1996 void ui_init_toolbar_widgets(void)
1997 {
1998 widgets.save_buttons[1] = toolbar_get_widget_by_name("Save");
1999 widgets.save_buttons[3] = toolbar_get_widget_by_name("SaveAll");
2000 widgets.redo_items[2] = toolbar_get_widget_by_name("Redo");
2001 widgets.undo_items[2] = toolbar_get_widget_by_name("Undo");
2002 }
2003
2004
2005 void ui_swap_sidebar_pos(void)
2006 {
2007 GtkWidget *pane = ui_lookup_widget(main_widgets.window, "hpaned1");
2008 GtkWidget *left = gtk_paned_get_child1(GTK_PANED(pane));
2009 GtkWidget *right = gtk_paned_get_child2(GTK_PANED(pane));
2010
2011 g_object_ref(left);
2012 g_object_ref(right);
2013 gtk_container_remove (GTK_CONTAINER (pane), left);
2014 gtk_container_remove (GTK_CONTAINER (pane), right);
2015 /* only scintilla notebook should expand */
2016 gtk_paned_pack1(GTK_PANED(pane), right, right == main_widgets.notebook, TRUE);
2017 gtk_paned_pack2(GTK_PANED(pane), left, left == main_widgets.notebook, TRUE);
2018 g_object_unref(left);
2019 g_object_unref(right);
2020
2021 gtk_paned_set_position(GTK_PANED(pane), gtk_widget_get_allocated_width(pane)
2022 - gtk_paned_get_position(GTK_PANED(pane)));
2023 }
2024
2025
2026 static void init_recent_files(void)
2027 {
2028 GtkWidget *toolbar_recent_files_menu;
2029
2030 /* add recent files to the File menu */
2031 ui_widgets.recent_files_menuitem = ui_lookup_widget(main_widgets.window, "recent_files1");
2032 ui_widgets.recent_files_menu_menubar = gtk_menu_new();
2033 gtk_menu_item_set_submenu(GTK_MENU_ITEM(ui_widgets.recent_files_menuitem),
2034 ui_widgets.recent_files_menu_menubar);
2035
2036 /* add recent files to the toolbar Open button */
2037 toolbar_recent_files_menu = gtk_menu_new();
2038 g_object_ref(toolbar_recent_files_menu);
2039 geany_menu_button_action_set_menu(GEANY_MENU_BUTTON_ACTION(
2040 toolbar_get_action_by_name("Open")), toolbar_recent_files_menu);
2041 }
2042
2043
2044 static void ui_menu_move(GtkWidget *menu, GtkWidget *old, GtkWidget *new)
2045 {
2046 g_object_ref(menu);
2047 gtk_menu_item_set_submenu(GTK_MENU_ITEM(old), NULL);
2048 gtk_menu_item_set_submenu(GTK_MENU_ITEM(new), menu);
2049 g_object_unref(menu);
2050 }
2051
2052
2053 typedef struct GeanySharedMenu
2054 {
2055 const gchar *menu;
2056 const gchar *menubar_item;
2057 const gchar *popup_item;
2058 }
2059 GeanySharedMenu;
2060
2061 #define foreach_menu(item, array) \
2062 for (item = array; item->menu; item++)
2063
2064 static void on_editor_menu_show(GtkWidget *widget, GeanySharedMenu *items)
2065 {
2066 GeanySharedMenu *item;
2067
2068 foreach_menu(item, items)
2069 {
2070 GtkWidget *popup = ui_lookup_widget(main_widgets.editor_menu, item->popup_item);
2071 GtkWidget *bar = ui_lookup_widget(main_widgets.window, item->menubar_item);
2072 GtkWidget *menu = ui_lookup_widget(main_widgets.window, item->menu);
2073
2074 ui_menu_move(menu, bar, popup);
2075 }
2076 }
2077
2078
2079 static void on_editor_menu_hide(GtkWidget *widget, GeanySharedMenu *items)
2080 {
2081 GeanySharedMenu *item;
2082
2083 foreach_menu(item, items)
2084 {
2085 GtkWidget *popup = ui_lookup_widget(main_widgets.editor_menu, item->popup_item);
2086 GtkWidget *bar = ui_lookup_widget(main_widgets.window, item->menubar_item);
2087 GtkWidget *menu = ui_lookup_widget(main_widgets.window, item->menu);
2088
2089 ui_menu_move(menu, popup, bar);
2090 }
2091 }
2092
2093
2094 /* Currently ui_init() is called before keyfile.c stash group code is initialized,
2095 * so this is called after that's done. */
2096 void ui_init_prefs(void)
2097 {
2098 StashGroup *group = stash_group_new(PACKAGE);
2099
2100 /* various prefs */
2101 configuration_add_various_pref_group(group);
2102
2103 stash_group_add_boolean(group, &interface_prefs.show_symbol_list_expanders,
2104 "show_symbol_list_expanders", TRUE);
2105 stash_group_add_boolean(group, &interface_prefs.compiler_tab_autoscroll,
2106 "compiler_tab_autoscroll", TRUE);
2107 stash_group_add_boolean(group, &ui_prefs.allow_always_save,
2108 "allow_always_save", FALSE);
2109 stash_group_add_string(group, &ui_prefs.statusbar_template,
2110 "statusbar_template", _(DEFAULT_STATUSBAR_TEMPLATE));
2111 stash_group_add_boolean(group, &ui_prefs.new_document_after_close,
2112 "new_document_after_close", FALSE);
2113 stash_group_add_boolean(group, &interface_prefs.msgwin_status_visible,
2114 "msgwin_status_visible", TRUE);
2115 stash_group_add_boolean(group, &interface_prefs.msgwin_compiler_visible,
2116 "msgwin_compiler_visible", TRUE);
2117 stash_group_add_boolean(group, &interface_prefs.msgwin_messages_visible,
2118 "msgwin_messages_visible", TRUE);
2119 stash_group_add_boolean(group, &interface_prefs.msgwin_scribble_visible,
2120 "msgwin_scribble_visible", TRUE);
2121 }
2122
2123
2124 /* Used to find out the name of the GtkBuilder retrieved object since
2125 * some objects will be GTK_IS_BUILDABLE() and use the GtkBuildable
2126 * 'name' property for that and those that don't implement GtkBuildable
2127 * will have a "gtk-builder-name" stored in the GObject's data list. */
2128 static const gchar *ui_guess_object_name(GObject *obj)
2129 {
2130 const gchar *name = NULL;
2131
2132 g_return_val_if_fail(G_IS_OBJECT(obj), NULL);
2133
2134 if (GTK_IS_BUILDABLE(obj))
2135 name = gtk_buildable_get_name(GTK_BUILDABLE(obj));
2136 if (! name)
2137 name = g_object_get_data(obj, "gtk-builder-name");
2138 if (! name)
2139 return NULL;
2140
2141 return name;
2142 }
2143
2144
2145 /* Compatibility functions */
2146 GtkWidget *create_edit_menu1(void)
2147 {
2148 return edit_menu1;
2149 }
2150
2151
2152 GtkWidget *create_prefs_dialog(void)
2153 {
2154 return prefs_dialog;
2155 }
2156
2157
2158 GtkWidget *create_project_dialog(void)
2159 {
2160 return project_dialog;
2161 }
2162
2163
2164 GtkWidget *create_toolbar_popup_menu1(void)
2165 {
2166 return toolbar_popup_menu1;
2167 }
2168
2169
2170 GtkWidget *create_window1(void)
2171 {
2172 return window1;
2173 }
2174
2175
2176 static GtkWidget *ui_get_top_parent(GtkWidget *widget)
2177 {
2178 GtkWidget *parent;
2179
2180 g_return_val_if_fail(GTK_IS_WIDGET(widget), NULL);
2181
2182 for (;;)
2183 {
2184 if (GTK_IS_MENU(widget))
2185 parent = gtk_menu_get_attach_widget(GTK_MENU(widget));
2186 else
2187 parent = gtk_widget_get_parent(widget);
2188 if (parent == NULL)
2189 parent = (GtkWidget*) g_object_get_data(G_OBJECT(widget), "GladeParentKey");
2190 if (parent == NULL)
2191 break;
2192 widget = parent;
2193 }
2194
2195 return widget;
2196 }
2197
2198
2199 void ui_init_builder(void)
2200 {
2201 gchar *interface_file;
2202 const gchar *name;
2203 GError *error;
2204 GSList *iter, *all_objects;
2205 GtkWidget *widget, *toplevel;
2206
2207 /* prevent function from being called twice */
2208 if (GTK_IS_BUILDER(builder))
2209 return;
2210
2211 builder = gtk_builder_new();
2212
2213 gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
2214
2215 error = NULL;
2216 interface_file = g_build_filename(app->datadir, "geany.glade", NULL);
2217 if (! gtk_builder_add_from_file(builder, interface_file, &error))
2218 {
2219 /* Show the user this message so they know WTF happened */
2220 dialogs_show_msgbox_with_secondary(GTK_MESSAGE_ERROR,
2221 _("Geany cannot start!"), error->message);
2222 /* Aborts */
2223 g_error("Cannot create user-interface: %s", error->message);
2224 g_error_free(error);
2225 g_free(interface_file);
2226 g_object_unref(builder);
2227 return;
2228 }
2229 g_free(interface_file);
2230
2231 gtk_builder_connect_signals(builder, NULL);
2232
2233 edit_menu1 = GTK_WIDGET(gtk_builder_get_object(builder, "edit_menu1"));
2234 prefs_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "prefs_dialog"));
2235 project_dialog = GTK_WIDGET(gtk_builder_get_object(builder, "project_dialog"));
2236 toolbar_popup_menu1 = GTK_WIDGET(gtk_builder_get_object(builder, "toolbar_popup_menu1"));
2237 window1 = GTK_WIDGET(gtk_builder_get_object(builder, "window1"));
2238
2239 g_object_set_data(G_OBJECT(edit_menu1), "edit_menu1", edit_menu1);
2240 g_object_set_data(G_OBJECT(prefs_dialog), "prefs_dialog", prefs_dialog);
2241 g_object_set_data(G_OBJECT(project_dialog), "project_dialog", project_dialog);
2242 g_object_set_data(G_OBJECT(toolbar_popup_menu1), "toolbar_popup_menu1", toolbar_popup_menu1);
2243 g_object_set_data(G_OBJECT(window1), "window1", window1);
2244
2245 all_objects = gtk_builder_get_objects(builder);
2246 for (iter = all_objects; iter != NULL; iter = g_slist_next(iter))
2247 {
2248 if (! GTK_IS_WIDGET(iter->data))
2249 continue;
2250
2251 widget = GTK_WIDGET(iter->data);
2252
2253 name = ui_guess_object_name(G_OBJECT(widget));
2254 if (! name)
2255 {
2256 g_warning("Unable to get name from GtkBuilder object");
2257 continue;
2258 }
2259
2260 toplevel = ui_get_top_parent(widget);
2261 if (toplevel)
2262 ui_hookup_widget(toplevel, widget, name);
2263 }
2264 g_slist_free(all_objects);
2265 }
2266
2267
2268 static void init_custom_style(void)
2269 {
2270 #if GTK_CHECK_VERSION(3, 0, 0)
2271 gchar *css_file = g_build_filename(app->datadir, "geany.css", NULL);
2272 GtkCssProvider *css = gtk_css_provider_new();
2273 GError *error = NULL;
2274
2275 if (! gtk_css_provider_load_from_path(css, css_file, &error))
2276 {
2277 g_warning("Failed to load custom CSS: %s", error->message);
2278 g_error_free(error);
2279 }
2280 else
2281 {
2282 gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
2283 GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2284 }
2285
2286 g_object_unref(css);
2287 g_free(css_file);
2288 #else
2289 /* see setup_gtk2_styles() in main.c */
2290 #endif
2291 }
2292
2293
2294 void ui_init(void)
2295 {
2296 init_custom_style();
2297
2298 init_recent_files();
2299
2300 ui_widgets.statusbar = ui_lookup_widget(main_widgets.window, "statusbar");
2301 ui_widgets.print_page_setup = ui_lookup_widget(main_widgets.window, "page_setup1");
2302
2303 main_widgets.progressbar = progress_bar_create();
2304
2305 /* current word sensitive items */
2306 widgets.popup_goto_items[0] = ui_lookup_widget(main_widgets.editor_menu, "goto_tag_definition2");
2307 widgets.popup_goto_items[1] = ui_lookup_widget(main_widgets.editor_menu, "context_action1");
2308 widgets.popup_goto_items[2] = ui_lookup_widget(main_widgets.editor_menu, "find_usage2");
2309 widgets.popup_goto_items[3] = ui_lookup_widget(main_widgets.editor_menu, "find_document_usage2");
2310
2311 widgets.popup_copy_items[0] = ui_lookup_widget(main_widgets.editor_menu, "cut1");
2312 widgets.popup_copy_items[1] = ui_lookup_widget(main_widgets.editor_menu, "copy1");
2313 widgets.popup_copy_items[2] = ui_lookup_widget(main_widgets.editor_menu, "delete1");
2314 widgets.menu_copy_items[0] = ui_lookup_widget(main_widgets.window, "menu_cut1");
2315 widgets.menu_copy_items[1] = ui_lookup_widget(main_widgets.window, "menu_copy1");
2316 widgets.menu_copy_items[2] = ui_lookup_widget(main_widgets.window, "menu_delete1");
2317 widgets.menu_insert_include_items[0] = ui_lookup_widget(main_widgets.editor_menu, "insert_include1");
2318 widgets.menu_insert_include_items[1] = ui_lookup_widget(main_widgets.window, "insert_include2");
2319 widgets.save_buttons[0] = ui_lookup_widget(main_widgets.window, "menu_save1");
2320 widgets.save_buttons[2] = ui_lookup_widget(main_widgets.window, "menu_save_all1");
2321 widgets.redo_items[0] = ui_lookup_widget(main_widgets.editor_menu, "redo1");
2322 widgets.redo_items[1] = ui_lookup_widget(main_widgets.window, "menu_redo2");
2323 widgets.undo_items[0] = ui_lookup_widget(main_widgets.editor_menu, "undo1");
2324 widgets.undo_items[1] = ui_lookup_widget(main_widgets.window, "menu_undo2");
2325
2326 /* reparent context submenus as needed */
2327 {
2328 GeanySharedMenu arr[] = {
2329 {"commands2_menu", "commands2", "commands1"},
2330 {"menu_format1_menu", "menu_format1", "menu_format2"},
2331 {"more1_menu", "more1", "search2"},
2332 {NULL, NULL, NULL}
2333 };
2334 static GeanySharedMenu items[G_N_ELEMENTS(arr)];
2335
2336 memcpy(items, arr, sizeof(arr));
2337 g_signal_connect(main_widgets.editor_menu, "show", G_CALLBACK(on_editor_menu_show), items);
2338 g_signal_connect(main_widgets.editor_menu, "hide", G_CALLBACK(on_editor_menu_hide), items);
2339 }
2340
2341 ui_init_toolbar_widgets();
2342 init_document_widgets();
2343 create_config_files_menu();
2344 }
2345
2346
2347 void ui_finalize_builder(void)
2348 {
2349 if (GTK_IS_BUILDER(builder))
2350 g_object_unref(builder);
2351
2352 /* cleanup refs lingering even after GtkBuilder is destroyed */
2353 if (GTK_IS_WIDGET(edit_menu1))
2354 gtk_widget_destroy(edit_menu1);
2355 if (GTK_IS_WIDGET(prefs_dialog))
2356 gtk_widget_destroy(prefs_dialog);
2357 if (GTK_IS_WIDGET(project_dialog))
2358 gtk_widget_destroy(project_dialog);
2359 if (GTK_IS_WIDGET(toolbar_popup_menu1))
2360 gtk_widget_destroy(toolbar_popup_menu1);
2361 if (GTK_IS_WIDGET(window1))
2362 gtk_widget_destroy(window1);
2363 }
2364
2365
2366 static void auto_separator_update(GeanyAutoSeparator *autosep)
2367 {
2368 g_return_if_fail(autosep->item_count >= 0);
2369
2370 if (autosep->widget)
2371 {
2372 if (autosep->item_count > 0)
2373 ui_widget_show_hide(autosep->widget, autosep->show_count > 0);
2374 else
2375 gtk_widget_destroy(autosep->widget);
2376 }
2377 }
2378
2379
2380 static void on_auto_separator_item_show_hide(GtkWidget *widget, gpointer user_data)
2381 {
2382 GeanyAutoSeparator *autosep = user_data;
2383
2384 if (gtk_widget_get_visible(widget))
2385 autosep->show_count++;
2386 else
2387 autosep->show_count--;
2388 auto_separator_update(autosep);
2389 }
2390
2391
2392 static void on_auto_separator_item_destroy(GtkWidget *widget, gpointer user_data)
2393 {
2394 GeanyAutoSeparator *autosep = user_data;
2395
2396 autosep->item_count--;
2397 autosep->item_count = MAX(autosep->item_count, 0);
2398 /* gtk_widget_get_visible() won't work now the widget is being destroyed,
2399 * so assume widget was visible */
2400 autosep->show_count--;
2401 autosep->show_count = MAX(autosep->item_count, 0);
2402 auto_separator_update(autosep);
2403 }
2404
2405
2406 /* Show the separator widget if @a item or another is visible. */
2407 /* Note: This would be neater taking a widget argument, setting a "visible-count"
2408 * property, and using reference counting to keep the widget alive whilst its visible group
2409 * is alive. */
2410 void ui_auto_separator_add_ref(GeanyAutoSeparator *autosep, GtkWidget *item)
2411 {
2412 /* set widget ptr NULL when widget destroyed */
2413 if (autosep->item_count == 0)
2414 g_signal_connect(autosep->widget, "destroy",
2415 G_CALLBACK(gtk_widget_destroyed), &autosep->widget);
2416
2417 if (gtk_widget_get_visible(item))
2418 autosep->show_count++;
2419
2420 autosep->item_count++;
2421 auto_separator_update(autosep);
2422
2423 g_signal_connect(item, "show", G_CALLBACK(on_auto_separator_item_show_hide), autosep);
2424 g_signal_connect(item, "hide", G_CALLBACK(on_auto_separator_item_show_hide), autosep);
2425 g_signal_connect(item, "destroy", G_CALLBACK(on_auto_separator_item_destroy), autosep);
2426 }
2427
2428
2429 /**
2430 * Sets @a text as the contents of the tooltip for @a widget.
2431 *
2432 * @param widget The widget the tooltip should be set for.
2433 * @param text The text for the tooltip.
2434 *
2435 * @since 0.16
2436 * @deprecated 0.21 use gtk_widget_set_tooltip_text() instead
2437 */
2438 void ui_widget_set_tooltip_text(GtkWidget *widget, const gchar *text)
2439 {
2440 gtk_widget_set_tooltip_text(widget, text);
2441 }
2442
2443
2444 /** Returns a widget from a name in a component, usually created by Glade.
2445 * Call it with the toplevel widget in the component (i.e. a window/dialog),
2446 * or alternatively any widget in the component, and the name of the widget
2447 * you want returned.
2448 * @param widget Widget with the @a widget_name property set.
2449 * @param widget_name Name to lookup.
2450 * @return The widget found.
2451 * @see ui_hookup_widget().
2452 *
2453 * @since 0.16
2454 */
2455 GtkWidget *ui_lookup_widget(GtkWidget *widget, const gchar *widget_name)
2456 {
2457 GtkWidget *parent, *found_widget;
2458
2459 g_return_val_if_fail(widget != NULL, NULL);
2460 g_return_val_if_fail(widget_name != NULL, NULL);
2461
2462 for (;;)
2463 {
2464 if (GTK_IS_MENU(widget))
2465 parent = gtk_menu_get_attach_widget(GTK_MENU(widget));
2466 else
2467 parent = gtk_widget_get_parent(widget);
2468 if (parent == NULL)
2469 parent = (GtkWidget*) g_object_get_data(G_OBJECT(widget), "GladeParentKey");
2470 if (parent == NULL)
2471 break;
2472 widget = parent;
2473 }
2474
2475 found_widget = (GtkWidget*) g_object_get_data(G_OBJECT(widget), widget_name);
2476 if (G_UNLIKELY(found_widget == NULL))
2477 g_warning("Widget not found: %s", widget_name);
2478 return found_widget;
2479 }
2480
2481
2482 /* wraps gtk_builder_get_object()
2483 * unlike ui_lookup_widget(), it does only support getting object created from the main
2484 * UI file, but it can fetch any object, not only widgets */
2485 gpointer ui_builder_get_object (const gchar *name)
2486 {
2487 return gtk_builder_get_object (builder, name);
2488 }
2489
2490
2491 /* Progress Bar */
2492 static guint progress_bar_timer_id = 0;
2493
2494
2495 static GtkWidget *progress_bar_create(void)
2496 {
2497 GtkWidget *bar = gtk_progress_bar_new();
2498
2499 /* Set the progressbar's height to 1 to fit it in the statusbar */
2500 gtk_widget_set_size_request(bar, -1, 1);
2501 gtk_box_pack_start (GTK_BOX(ui_widgets.statusbar), bar, FALSE, FALSE, 3);
2502
2503 return bar;
2504 }
2505
2506
2507 static gboolean progress_bar_pulse(gpointer data)
2508 {
2509 gtk_progress_bar_pulse(GTK_PROGRESS_BAR(main_widgets.progressbar));
2510
2511 return TRUE;
2512 }
2513
2514
2515 /**
2516 * Starts a constantly pulsing progressbar in the right corner of the statusbar
2517 * (if the statusbar is visible). This is a convenience function which adds a timer to
2518 * pulse the progressbar constantly until ui_progress_bar_stop() is called.
2519 * You can use this function when you have time consuming asynchronous operation and want to
2520 * display some activity in the GUI and when you don't know about detailed progress steps.
2521 * The progressbar widget is hidden by default when it is not active. This function and
2522 * ui_progress_bar_stop() will show and hide it automatically for you.
2523 *
2524 * You can also access the progressbar widget directly using @c geany->main_widgets->progressbar
2525 * and use the GtkProgressBar API to set discrete fractions to display better progress information.
2526 * In this case, you need to show and hide the widget yourself. You can find some example code
2527 * in @c src/printing.c.
2528 *
2529 * @param text The text to be shown as the progress bar label or NULL to leave it empty.
2530 *
2531 * @since 0.16
2532 **/
2533 void ui_progress_bar_start(const gchar *text)
2534 {
2535 g_return_if_fail(progress_bar_timer_id == 0);
2536
2537 if (! interface_prefs.statusbar_visible)
2538 return;
2539
2540 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(main_widgets.progressbar), text);
2541
2542 progress_bar_timer_id = g_timeout_add(200, progress_bar_pulse, NULL);
2543
2544 gtk_widget_show(GTK_WIDGET(main_widgets.progressbar));
2545 }
2546
2547
2548 /** Stops a running progress bar and hides the widget again.
2549 *
2550 * @since 0.16
2551 **/
2552 void ui_progress_bar_stop(void)
2553 {
2554 gtk_widget_hide(GTK_WIDGET(main_widgets.progressbar));
2555
2556 if (progress_bar_timer_id != 0)
2557 {
2558 g_source_remove(progress_bar_timer_id);
2559 progress_bar_timer_id = 0;
2560 }
2561 }
2562
2563
2564 static gint compare_menu_item_labels(gconstpointer a, gconstpointer b)
2565 {
2566 GtkMenuItem *item_a = GTK_MENU_ITEM(a);
2567 GtkMenuItem *item_b = GTK_MENU_ITEM(b);
2568 gchar *sa, *sb;
2569 gint result;
2570
2571 sa = ui_menu_item_get_text(item_a);
2572 sb = ui_menu_item_get_text(item_b);
2573 result = utils_str_casecmp(sa, sb);
2574 g_free(sa);
2575 g_free(sb);
2576 return result;
2577 }
2578
2579
2580 /* Currently @a menu should contain only GtkMenuItems with labels. */
2581 void ui_menu_sort_by_label(GtkMenu *menu)
2582 {
2583 GList *list = gtk_container_get_children(GTK_CONTAINER(menu));
2584 GList *node;
2585 gint pos;
2586
2587 list = g_list_sort(list, compare_menu_item_labels);
2588 pos = 0;
2589 foreach_list(node, list)
2590 {
2591 gtk_menu_reorder_child(menu, node->data, pos);
2592 pos++;
2593 }
2594 g_list_free(list);
2595 }
2596
2597
2598 void ui_label_set_markup(GtkLabel *label, const gchar *format, ...)
2599 {
2600 va_list a;
2601 gchar *text;
2602
2603 va_start(a, format);
2604 text = g_strdup_vprintf(format, a);
2605 va_end(a);
2606
2607 gtk_label_set_text(label, text);
2608 gtk_label_set_use_markup(label, TRUE);
2609 g_free(text);
2610 }
2611
2612
2613 GtkWidget *ui_label_new_bold(const gchar *text)
2614 {
2615 GtkWidget *label;
2616 gchar *label_text;
2617
2618 label_text = g_markup_escape_text(text, -1);
2619 label = gtk_label_new(NULL);
2620 ui_label_set_markup(GTK_LABEL(label), "<b>%s</b>", label_text);
2621 g_free(label_text);
2622 return label;
2623 }
2624
2625
2626 /** Adds a list of document items to @a menu.
2627 * @param menu Menu.
2628 * @param active Which document to highlight, or @c NULL.
2629 * @param callback is used for each menu item's @c "activate" signal and will be passed
2630 * the corresponding document pointer as @c user_data.
2631 * @warning You should check @c doc->is_valid in the callback.
2632 * @since 0.19 */
2633 void ui_menu_add_document_items(GtkMenu *menu, GeanyDocument *active, GCallback callback)
2634 {
2635 ui_menu_add_document_items_sorted(menu, active, callback, NULL);
2636 }
2637
2638
2639 /** Adds a list of document items to @a menu.
2640 *
2641 * @a compare_func might be NULL to not sort the documents in the menu. In this case,
2642 * the order of the document tabs is used.
2643 *
2644 * See document_compare_by_display_name() for an example sort function.
2645 *
2646 * @param menu Menu.
2647 * @param active Which document to highlight, or @c NULL.
2648 * @param callback is used for each menu item's @c "activate" signal and will be passed
2649 * the corresponding document pointer as @c user_data.
2650 * @param compare_func is used to sort the list. Might be @c NULL to not sort the list.
2651 * @warning You should check @c doc->is_valid in the callback.
2652 * @since 0.21 */
2653 void ui_menu_add_document_items_sorted(GtkMenu *menu, GeanyDocument *active,
2654 GCallback callback, GCompareFunc compare_func)
2655 {
2656 GtkWidget *menu_item, *menu_item_label, *image;
2657 GeanyDocument *doc;
2658 guint i, len;
2659 gchar *base_name, *label;
2660 GPtrArray *sorted_documents;
2661
2662 len = (guint) gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook));
2663
2664 sorted_documents = g_ptr_array_sized_new(len);
2665 /* copy the documents_array into the new one */
2666 foreach_document(i)
2667 {
2668 g_ptr_array_add(sorted_documents, documents[i]);
2669 }
2670 if (compare_func == NULL)
2671 compare_func = document_compare_by_tab_order;
2672
2673 /* and now sort it */
2674 g_ptr_array_sort(sorted_documents, compare_func);
2675
2676 for (i = 0; i < sorted_documents->len; i++)
2677 {
2678 doc = g_ptr_array_index(sorted_documents, i);
2679
2680 base_name = g_path_get_basename(DOC_FILENAME(doc));
2681 menu_item = gtk_image_menu_item_new_with_label(base_name);
2682 image = gtk_image_new_from_gicon(doc->file_type->icon, GTK_ICON_SIZE_MENU);
2683 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image);
2684
2685 gtk_widget_show(menu_item);
2686 gtk_container_add(GTK_CONTAINER(menu), menu_item);
2687 g_signal_connect(menu_item, "activate", callback, doc);
2688
2689 menu_item_label = gtk_bin_get_child(GTK_BIN(menu_item));
2690 gtk_widget_set_name(menu_item_label, document_get_status_widget_class(doc));
2691
2692 if (doc == active)
2693 {
2694 label = g_markup_escape_text(base_name, -1);
2695 ui_label_set_markup(GTK_LABEL(menu_item_label), "<b>%s</b>", label);
2696 g_free(label);
2697 }
2698
2699 g_free(base_name);
2700 }
2701 g_ptr_array_free(sorted_documents, TRUE);
2702 }
2703
2704
2705 /** Checks whether the passed @a keyval is the Enter or Return key.
2706 * There are three different Enter/Return key values
2707 * (@c GDK_Return, @c GDK_ISO_Enter, @c GDK_KP_Enter).
2708 * This is just a convenience function.
2709 * @param keyval A keyval.
2710 * @return @c TRUE if @a keyval is the one of the Enter/Return key values, otherwise @c FALSE.
2711 * @since 0.19 */
2712 gboolean ui_is_keyval_enter_or_return(guint keyval)
2713 {
2714 return (keyval == GDK_Return || keyval == GDK_ISO_Enter|| keyval == GDK_KP_Enter);
2715 }
2716
2717
2718 /** Reads an integer from the GTK default settings registry
2719 * (see http://library.gnome.org/devel/gtk/stable/GtkSettings.html).
2720 * @param property_name The property to read.
2721 * @param default_value The default value in case the value could not be read.
2722 * @return The value for the property if it exists, otherwise the @a default_value.
2723 * @since 0.19 */
2724 gint ui_get_gtk_settings_integer(const gchar *property_name, gint default_value)
2725 {
2726 if (g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(
2727 gtk_settings_get_default())), property_name))
2728 {
2729 gint value;
2730 g_object_get(G_OBJECT(gtk_settings_get_default()), property_name, &value, NULL);
2731 return value;
2732 }
2733 else
2734 return default_value;
2735 }
2736
2737
2738 void ui_editable_insert_text_callback(GtkEditable *editable, gchar *new_text,
2739 gint new_text_len, gint *position, gpointer data)
2740 {
2741 gboolean first = position != NULL && *position == 0;
2742 gint i;
2743
2744 if (new_text_len == -1)
2745 new_text_len = (gint) strlen(new_text);
2746
2747 for (i = 0; i < new_text_len; i++, new_text++)
2748 {
2749 if ((!first || !strchr("+-", *new_text)) && !isdigit(*new_text))
2750 {
2751 g_signal_stop_emission_by_name(editable, "insert-text");
2752 break;
2753 }
2754 first = FALSE;
2755 }
2756 }
2757
2758
2759 /* gets the icon that applies to a particular MIME type */
2760 GIcon *ui_get_mime_icon(const gchar *mime_type)
2761 {
2762 GIcon *icon = NULL;
2763 gchar *ctype;
2764
2765 ctype = g_content_type_from_mime_type(mime_type);
2766 if (ctype)
2767 {
2768 icon = g_content_type_get_icon(ctype);
2769 g_free(ctype);
2770 }
2771
2772 /* fallback if icon lookup failed, like it might happen on Windows (?) */
2773 if (! icon)
2774 {
2775 const gchar *stock_id = GTK_STOCK_FILE;
2776
2777 if (strstr(mime_type, "directory"))
2778 stock_id = GTK_STOCK_DIRECTORY;
2779
2780 icon = g_themed_icon_new(stock_id);
2781 }
2782 return icon;
2783 }
2784
2785
2786 void ui_focus_current_document(void)
2787 {
2788 GeanyDocument *doc = document_get_current();
2789
2790 if (doc != NULL)
2791 document_grab_focus(doc);
2792 }
2793
2794
2795 /** Finds the label text associated with stock_id
2796 * @param stock_id stock_id to lookup e.g. @c GTK_STOCK_OPEN.
2797 * @return The label text for stock
2798 * @since Geany 1.22 */
2799 const gchar *ui_lookup_stock_label(const gchar *stock_id)
2800 {
2801 GtkStockItem item;
2802
2803 if (gtk_stock_lookup(stock_id, &item))
2804 return item.label;
2805
2806 g_warning("No stock id '%s'!", stock_id);
2807 return NULL;
2808 }
2809
2810
2811 /* finds the next iter at any level
2812 * @param iter in/out, the current iter, will be changed to the next one
2813 * @param down whether to try the child iter
2814 * @return TRUE if there @p iter was set, or FALSE if there is no next iter */
2815 gboolean ui_tree_model_iter_any_next(GtkTreeModel *model, GtkTreeIter *iter, gboolean down)
2816 {
2817 GtkTreeIter guess;
2818 GtkTreeIter copy = *iter;
2819
2820 /* go down if the item has children */
2821 if (down && gtk_tree_model_iter_children(model, &guess, iter))
2822 *iter = guess;
2823 /* or to the next item at the same level */
2824 else if (gtk_tree_model_iter_next(model, &copy))
2825 *iter = copy;
2826 /* or to the next item at a parent level */
2827 else if (gtk_tree_model_iter_parent(model, &guess, iter))
2828 {
2829 copy = guess;
2830 while (TRUE)
2831 {
2832 if (gtk_tree_model_iter_next(model, &copy))
2833 {
2834 *iter = copy;
2835 return TRUE;
2836 }
2837 else if (gtk_tree_model_iter_parent(model, &copy, &guess))
2838 guess = copy;
2839 else
2840 return FALSE;
2841 }
2842 }
2843 else
2844 return FALSE;
2845
2846 return TRUE;
2847 }
2848
2849
2850 GtkWidget *ui_create_encodings_combo_box(gboolean has_detect, gint default_enc)
2851 {
2852 GtkCellRenderer *renderer;
2853 GtkTreeIter iter;
2854 GtkWidget *combo = gtk_combo_box_new();
2855 GtkTreeStore *store = encodings_encoding_store_new(has_detect);
2856
2857 if (default_enc < 0 || default_enc >= GEANY_ENCODINGS_MAX)
2858 default_enc = has_detect ? GEANY_ENCODINGS_MAX : GEANY_ENCODING_NONE;
2859
2860 gtk_combo_box_set_model(GTK_COMBO_BOX(combo), GTK_TREE_MODEL(store));
2861 if (encodings_encoding_store_get_iter(store, &iter, default_enc))
2862 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
2863 renderer = gtk_cell_renderer_text_new();
2864 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
2865 gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(combo), renderer,
2866 encodings_encoding_store_cell_data_func, NULL, NULL);
2867
2868 return combo;
2869 }
2870
2871
2872 gint ui_encodings_combo_box_get_active_encoding(GtkComboBox *combo)
2873 {
2874 GtkTreeIter iter;
2875 gint enc = GEANY_ENCODING_NONE;
2876
2877 /* there should always be an active iter anyway, but we check just in case */
2878 if (gtk_combo_box_get_active_iter(combo, &iter))
2879 {
2880 GtkTreeModel *model = gtk_combo_box_get_model(combo);
2881 enc = encodings_encoding_store_get_encoding(GTK_TREE_STORE(model), &iter);
2882 }
2883
2884 return enc;
2885 }
2886
2887
2888 gboolean ui_encodings_combo_box_set_active_encoding(GtkComboBox *combo, gint enc)
2889 {
2890 GtkTreeIter iter;
2891 GtkTreeModel *model = gtk_combo_box_get_model(combo);
2892
2893 if (encodings_encoding_store_get_iter(GTK_TREE_STORE(model), &iter, enc))
2894 {
2895 gtk_combo_box_set_active_iter(combo, &iter);
2896 return TRUE;
2897 }
2898 return FALSE;
2899 }
A fast and lightweight IDE