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