?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add utils_get_real_path() and use it
[geany-mirror.git] / src / search.c
blob7f78bc692609518994317e0c9a8b76a14e301653
1 /*
2 * search.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2006-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 /*
23 * Find, Replace, Find in Files dialog related functions.
24 * Note that the basic text find functions are in document.c.
25 */
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include "search.h"
32
33 #include "app.h"
34 #include "document.h"
35 #include "encodings.h"
36 #include "encodingsprivate.h"
37 #include "keyfile.h"
38 #include "msgwindow.h"
39 #include "prefs.h"
40 #include "sciwrappers.h"
41 #include "spawn.h"
42 #include "stash.h"
43 #include "support.h"
44 #include "toolbar.h"
45 #include "ui_utils.h"
46 #include "utils.h"
47
48 #include "gtkcompat.h"
49
50 #include <unistd.h>
51 #include <string.h>
52 #include <ctype.h>
53
54 #include <gdk/gdkkeysyms.h>
55
56 enum
57 {
58 GEANY_RESPONSE_FIND = 1,
59 GEANY_RESPONSE_FIND_PREVIOUS,
60 GEANY_RESPONSE_FIND_IN_FILE,
61 GEANY_RESPONSE_FIND_IN_SESSION,
62 GEANY_RESPONSE_MARK,
63 GEANY_RESPONSE_REPLACE,
64 GEANY_RESPONSE_REPLACE_AND_FIND,
65 GEANY_RESPONSE_REPLACE_IN_SESSION,
66 GEANY_RESPONSE_REPLACE_IN_FILE,
67 GEANY_RESPONSE_REPLACE_IN_SEL
68 };
69
70
71 enum
72 {
73 FILES_MODE_ALL,
74 FILES_MODE_PROJECT,
75 FILES_MODE_CUSTOM
76 };
77
78
79 GeanySearchData search_data;
80 GeanySearchPrefs search_prefs;
81
82
83 static struct
84 {
85 gboolean fif_regexp;
86 gboolean fif_case_sensitive;
87 gboolean fif_match_whole_word;
88 gboolean fif_invert_results;
89 gboolean fif_recursive;
90 gboolean fif_use_extra_options;
91 gchar *fif_extra_options;
92 gint fif_files_mode;
93 gchar *fif_files;
94 gboolean find_regexp;
95 gboolean find_regexp_multiline;
96 gboolean find_escape_sequences;
97 gboolean find_case_sensitive;
98 gboolean find_match_whole_word;
99 gboolean find_match_word_start;
100 gboolean find_close_dialog;
101 gboolean replace_regexp;
102 gboolean replace_regexp_multiline;
103 gboolean replace_escape_sequences;
104 gboolean replace_case_sensitive;
105 gboolean replace_match_whole_word;
106 gboolean replace_match_word_start;
107 gboolean replace_search_backwards;
108 gboolean replace_close_dialog;
109 }
110 settings;
111
112 static StashGroup *fif_prefs = NULL;
113 static StashGroup *find_prefs = NULL;
114 static StashGroup *replace_prefs = NULL;
115
116
117 static struct
118 {
119 GtkWidget *dialog;
120 GtkWidget *entry;
121 gboolean all_expanded;
122 gint position[2]; /* x, y */
123 }
124 find_dlg = {NULL, NULL, FALSE, {0, 0}};
125
126 static struct
127 {
128 GtkWidget *dialog;
129 GtkWidget *find_combobox;
130 GtkWidget *find_entry;
131 GtkWidget *replace_combobox;
132 GtkWidget *replace_entry;
133 gboolean all_expanded;
134 gint position[2]; /* x, y */
135 }
136 replace_dlg = {NULL, NULL, NULL, NULL, NULL, FALSE, {0, 0}};
137
138 static struct
139 {
140 GtkWidget *dialog;
141 GtkWidget *dir_combo;
142 GtkWidget *files_combo;
143 GtkWidget *search_combo;
144 GtkWidget *encoding_combo;
145 GtkWidget *files_mode_combo;
146 gint position[2]; /* x, y */
147 }
148 fif_dlg = {NULL, NULL, NULL, NULL, NULL, NULL, {0, 0}};
149
150
151 static void search_read_io(GString *string, GIOCondition condition, gpointer data);
152 static void search_read_io_stderr(GString *string, GIOCondition condition, gpointer data);
153
154 static void search_finished(GPid child_pid, gint status, gpointer user_data);
155
156 static gchar **search_get_argv(const gchar **argv_prefix, const gchar *dir);
157
158 static GRegex *compile_regex(const gchar *str, GeanyFindFlags sflags);
159
160
161 static void
162 on_find_replace_checkbutton_toggled(GtkToggleButton *togglebutton, gpointer user_data);
163
164 static void
165 on_find_dialog_response(GtkDialog *dialog, gint response, gpointer user_data);
166
167 static void
168 on_find_entry_activate(GtkEntry *entry, gpointer user_data);
169
170 static void
171 on_find_entry_activate_backward(GtkEntry *entry, gpointer user_data);
172
173 static void
174 on_replace_dialog_response(GtkDialog *dialog, gint response, gpointer user_data);
175
176 static void
177 on_replace_find_entry_activate(GtkEntry *entry, gpointer user_data);
178
179 static void
180 on_replace_entry_activate(GtkEntry *entry, gpointer user_data);
181
182 static void
183 on_find_in_files_dialog_response(GtkDialog *dialog, gint response, gpointer user_data);
184
185 static gboolean
186 search_find_in_files(const gchar *utf8_search_text, const gchar *dir, const gchar *opts,
187 const gchar *enc);
188
189
190 static void init_prefs(void)
191 {
192 StashGroup *group;
193
194 group = stash_group_new("search");
195 configuration_add_pref_group(group, TRUE);
196 stash_group_add_toggle_button(group, &search_prefs.always_wrap,
197 "pref_search_hide_find_dialog", FALSE, "check_always_wrap_search");
198 stash_group_add_toggle_button(group, &search_prefs.hide_find_dialog,
199 "pref_search_always_wrap", FALSE, "check_hide_find_dialog");
200 stash_group_add_toggle_button(group, &search_prefs.use_current_file_dir,
201 "pref_search_current_file_dir", TRUE, "check_fif_current_dir");
202 stash_group_add_boolean(group, &find_dlg.all_expanded, "find_all_expanded", FALSE);
203 stash_group_add_boolean(group, &replace_dlg.all_expanded, "replace_all_expanded", FALSE);
204 /* dialog positions */
205 stash_group_add_integer(group, &find_dlg.position[0], "position_find_x", -1);
206 stash_group_add_integer(group, &find_dlg.position[1], "position_find_y", -1);
207 stash_group_add_integer(group, &replace_dlg.position[0], "position_replace_x", -1);
208 stash_group_add_integer(group, &replace_dlg.position[1], "position_replace_y", -1);
209 stash_group_add_integer(group, &fif_dlg.position[0], "position_fif_x", -1);
210 stash_group_add_integer(group, &fif_dlg.position[1], "position_fif_y", -1);
211
212 memset(&settings, '\0', sizeof(settings));
213
214 group = stash_group_new("search");
215 fif_prefs = group;
216 configuration_add_pref_group(group, FALSE);
217 stash_group_add_toggle_button(group, &settings.fif_regexp,
218 "fif_regexp", FALSE, "check_regexp");
219 stash_group_add_toggle_button(group, &settings.fif_case_sensitive,
220 "fif_case_sensitive", TRUE, "check_case");
221 stash_group_add_toggle_button(group, &settings.fif_match_whole_word,
222 "fif_match_whole_word", FALSE, "check_wholeword");
223 stash_group_add_toggle_button(group, &settings.fif_invert_results,
224 "fif_invert_results", FALSE, "check_invert");
225 stash_group_add_toggle_button(group, &settings.fif_recursive,
226 "fif_recursive", FALSE, "check_recursive");
227 stash_group_add_entry(group, &settings.fif_extra_options,
228 "fif_extra_options", "", "entry_extra");
229 stash_group_add_toggle_button(group, &settings.fif_use_extra_options,
230 "fif_use_extra_options", FALSE, "check_extra");
231 stash_group_add_entry(group, &settings.fif_files,
232 "fif_files", "", "entry_files");
233 stash_group_add_combo_box(group, &settings.fif_files_mode,
234 "fif_files_mode", FILES_MODE_ALL, "combo_files_mode");
235
236 group = stash_group_new("search");
237 find_prefs = group;
238 configuration_add_pref_group(group, FALSE);
239 stash_group_add_toggle_button(group, &settings.find_regexp,
240 "find_regexp", FALSE, "check_regexp");
241 stash_group_add_toggle_button(group, &settings.find_regexp_multiline,
242 "find_regexp_multiline", FALSE, "check_multiline");
243 stash_group_add_toggle_button(group, &settings.find_case_sensitive,
244 "find_case_sensitive", FALSE, "check_case");
245 stash_group_add_toggle_button(group, &settings.find_escape_sequences,
246 "find_escape_sequences", FALSE, "check_escape");
247 stash_group_add_toggle_button(group, &settings.find_match_whole_word,
248 "find_match_whole_word", FALSE, "check_word");
249 stash_group_add_toggle_button(group, &settings.find_match_word_start,
250 "find_match_word_start", FALSE, "check_wordstart");
251 stash_group_add_toggle_button(group, &settings.find_close_dialog,
252 "find_close_dialog", TRUE, "check_close");
253
254 group = stash_group_new("search");
255 replace_prefs = group;
256 configuration_add_pref_group(group, FALSE);
257 stash_group_add_toggle_button(group, &settings.replace_regexp,
258 "replace_regexp", FALSE, "check_regexp");
259 stash_group_add_toggle_button(group, &settings.replace_regexp_multiline,
260 "replace_regexp_multiline", FALSE, "check_multiline");
261 stash_group_add_toggle_button(group, &settings.replace_case_sensitive,
262 "replace_case_sensitive", FALSE, "check_case");
263 stash_group_add_toggle_button(group, &settings.replace_escape_sequences,
264 "replace_escape_sequences", FALSE, "check_escape");
265 stash_group_add_toggle_button(group, &settings.replace_match_whole_word,
266 "replace_match_whole_word", FALSE, "check_word");
267 stash_group_add_toggle_button(group, &settings.replace_match_word_start,
268 "replace_match_word_start", FALSE, "check_wordstart");
269 stash_group_add_toggle_button(group, &settings.replace_search_backwards,
270 "replace_search_backwards", FALSE, "check_back");
271 stash_group_add_toggle_button(group, &settings.replace_close_dialog,
272 "replace_close_dialog", TRUE, "check_close");
273 }
274
275
276 void search_init(void)
277 {
278 search_data.text = NULL;
279 search_data.original_text = NULL;
280 init_prefs();
281 }
282
283
284 #define FREE_WIDGET(wid) \
285 if (wid && GTK_IS_WIDGET(wid)) gtk_widget_destroy(wid);
286
287 void search_finalize(void)
288 {
289 FREE_WIDGET(find_dlg.dialog);
290 FREE_WIDGET(replace_dlg.dialog);
291 FREE_WIDGET(fif_dlg.dialog);
292 g_free(search_data.text);
293 g_free(search_data.original_text);
294 }
295
296
297 static void on_widget_toggled_set_insensitive(
298 GtkToggleButton *togglebutton, gpointer user_data)
299 {
300 gtk_widget_set_sensitive(GTK_WIDGET(user_data),
301 !gtk_toggle_button_get_active(togglebutton));
302 }
303
304
305 static GtkWidget *add_find_checkboxes(GtkDialog *dialog)
306 {
307 GtkWidget *checkbox1, *checkbox2, *check_regexp, *checkbox5,
308 *checkbox7, *check_multiline, *hbox, *fbox, *mbox;
309
310 check_regexp = gtk_check_button_new_with_mnemonic(_("_Use regular expressions"));
311 ui_hookup_widget(dialog, check_regexp, "check_regexp");
312 gtk_button_set_focus_on_click(GTK_BUTTON(check_regexp), FALSE);
313 gtk_widget_set_tooltip_text(check_regexp, _("Use Perl-like regular expressions. "
314 "For detailed information about using regular expressions, please refer to the manual."));
315 g_signal_connect(check_regexp, "toggled",
316 G_CALLBACK(on_find_replace_checkbutton_toggled), dialog);
317
318 checkbox7 = gtk_check_button_new_with_mnemonic(_("Use _escape sequences"));
319 ui_hookup_widget(dialog, checkbox7, "check_escape");
320 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox7), FALSE);
321 gtk_widget_set_tooltip_text(checkbox7,
322 _("Replace \\\\, \\t, \\n, \\r and \\uXXXX (Unicode characters) with the "
323 "corresponding control characters"));
324
325 check_multiline = gtk_check_button_new_with_mnemonic(_("Use multi-line matchin_g"));
326 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_multiline), FALSE);
327 gtk_widget_set_sensitive(check_multiline, FALSE);
328 ui_hookup_widget(dialog, check_multiline, "check_multiline");
329 gtk_button_set_focus_on_click(GTK_BUTTON(check_multiline), FALSE);
330 gtk_widget_set_tooltip_text(check_multiline, _("Perform regular expression "
331 "matching on the whole buffer at once rather than line by line, allowing "
332 "matches to span multiple lines. In this mode, newline characters are part "
333 "of the input and can be captured as normal characters by the pattern."));
334
335 /* Search features */
336 fbox = gtk_vbox_new(FALSE, 0);
337 gtk_box_pack_start(GTK_BOX(fbox), check_regexp, FALSE, FALSE, 0);
338 gtk_box_pack_start(GTK_BOX(fbox), check_multiline, FALSE, FALSE, 0);
339 gtk_box_pack_start(GTK_BOX(fbox), checkbox7, FALSE, FALSE, 0);
340
341 if (dialog != GTK_DIALOG(find_dlg.dialog))
342 {
343 GtkWidget *check_back = gtk_check_button_new_with_mnemonic(_("Search _backwards"));
344 ui_hookup_widget(dialog, check_back, "check_back");
345 gtk_button_set_focus_on_click(GTK_BUTTON(check_back), FALSE);
346 gtk_container_add(GTK_CONTAINER(fbox), check_back);
347 }
348
349 checkbox1 = gtk_check_button_new_with_mnemonic(_("C_ase sensitive"));
350 ui_hookup_widget(dialog, checkbox1, "check_case");
351 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox1), FALSE);
352
353 checkbox2 = gtk_check_button_new_with_mnemonic(_("Match only a _whole word"));
354 ui_hookup_widget(dialog, checkbox2, "check_word");
355 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox2), FALSE);
356
357 checkbox5 = gtk_check_button_new_with_mnemonic(_("Match from s_tart of word"));
358 ui_hookup_widget(dialog, checkbox5, "check_wordstart");
359 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox5), FALSE);
360
361 /* disable wordstart when wholeword is checked */
362 g_signal_connect(checkbox2, "toggled",
363 G_CALLBACK(on_widget_toggled_set_insensitive), checkbox5);
364
365 /* Matching options */
366 mbox = gtk_vbox_new(FALSE, 0);
367 gtk_box_pack_start(GTK_BOX(mbox), checkbox1, FALSE, FALSE, 0);
368 gtk_box_pack_start(GTK_BOX(mbox), checkbox2, FALSE, FALSE, 0);
369 gtk_box_pack_start(GTK_BOX(mbox), checkbox5, FALSE, FALSE, 0);
370
371 hbox = gtk_hbox_new(TRUE, 6);
372 gtk_container_add(GTK_CONTAINER(hbox), fbox);
373 gtk_container_add(GTK_CONTAINER(hbox), mbox);
374 return hbox;
375 }
376
377
378 static void send_find_dialog_response(GtkButton *button, gpointer user_data)
379 {
380 gtk_dialog_response(GTK_DIALOG(find_dlg.dialog), GPOINTER_TO_INT(user_data));
381 }
382
383
384 /* store text, clear search flags so we can use Search->Find Next/Previous */
385 static void setup_find_next(const gchar *text)
386 {
387 g_free(search_data.text);
388 g_free(search_data.original_text);
389 search_data.text = g_strdup(text);
390 search_data.original_text = g_strdup(text);
391 search_data.flags = 0;
392 search_data.backwards = FALSE;
393 search_data.search_bar = FALSE;
394 }
395
396
397 /* Search for next match of the current "selection".
398 * Optionally for X11 based systems, this will try to use the system-wide
399 * x-selection first.
400 * If it doesn't find a suitable search string it will try to use
401 * the current word instead, or just repeat the last search.
402 * Search flags are always zero.
403 */
404 void search_find_selection(GeanyDocument *doc, gboolean search_backwards)
405 {
406 gchar *s = NULL;
407
408 g_return_if_fail(DOC_VALID(doc));
409
410 #ifdef G_OS_UNIX
411 if (search_prefs.find_selection_type == GEANY_FIND_SEL_X)
412 {
413 GtkClipboard *clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
414
415 s = gtk_clipboard_wait_for_text(clipboard);
416 if (s && (strchr(s,'\n') || strchr(s, '\r')))
417 {
418 g_free(s);
419 s = NULL;
420 };
421 }
422 #endif
423
424 if (!s && sci_has_selection(doc->editor->sci))
425 s = sci_get_selection_contents(doc->editor->sci);
426
427 if (!s && search_prefs.find_selection_type != GEANY_FIND_SEL_AGAIN)
428 {
429 /* get the current word */
430 s = editor_get_default_selection(doc->editor, TRUE, NULL);
431 }
432
433 if (s)
434 {
435 setup_find_next(s); /* allow find next/prev */
436
437 if (document_find_text(doc, s, NULL, 0, search_backwards, NULL, FALSE, NULL) > -1)
438 editor_display_current_line(doc->editor, 0.3F);
439 g_free(s);
440 }
441 else if (search_prefs.find_selection_type == GEANY_FIND_SEL_AGAIN)
442 {
443 /* Repeat last search (in case selection was lost) */
444 search_find_again(search_backwards);
445 }
446 else
447 {
448 utils_beep();
449 }
450 }
451
452
453 static void on_expander_activated(GtkExpander *exp, gpointer data)
454 {
455 gboolean *setting = data;
456
457 *setting = gtk_expander_get_expanded(exp);
458 }
459
460
461 static void create_find_dialog(void)
462 {
463 GtkWidget *label, *entry, *sbox, *vbox;
464 GtkWidget *exp, *bbox, *button, *check_close;
465
466 find_dlg.dialog = gtk_dialog_new_with_buttons(_("Find"),
467 GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT,
468 GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
469 vbox = ui_dialog_vbox_new(GTK_DIALOG(find_dlg.dialog));
470 gtk_widget_set_name(find_dlg.dialog, "GeanyDialogSearch");
471 gtk_box_set_spacing(GTK_BOX(vbox), 9);
472
473 button = ui_button_new_with_image(GTK_STOCK_GO_BACK, _("_Previous"));
474 gtk_dialog_add_action_widget(GTK_DIALOG(find_dlg.dialog), button,
475 GEANY_RESPONSE_FIND_PREVIOUS);
476 ui_hookup_widget(find_dlg.dialog, button, "btn_previous");
477
478 button = ui_button_new_with_image(GTK_STOCK_GO_FORWARD, _("_Next"));
479 gtk_dialog_add_action_widget(GTK_DIALOG(find_dlg.dialog), button,
480 GEANY_RESPONSE_FIND);
481
482 label = gtk_label_new_with_mnemonic(_("_Search for:"));
483 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
484
485 entry = gtk_combo_box_text_new_with_entry();
486 ui_entry_add_clear_icon(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(entry))));
487 gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
488 gtk_entry_set_width_chars(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(entry))), 50);
489 find_dlg.entry = gtk_bin_get_child(GTK_BIN(entry));
490
491 g_signal_connect(gtk_bin_get_child(GTK_BIN(entry)), "activate",
492 G_CALLBACK(on_find_entry_activate), entry);
493 ui_entry_add_activate_backward_signal(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(entry))));
494 g_signal_connect(gtk_bin_get_child(GTK_BIN(entry)), "activate-backward",
495 G_CALLBACK(on_find_entry_activate_backward), entry);
496 g_signal_connect(find_dlg.dialog, "response",
497 G_CALLBACK(on_find_dialog_response), entry);
498 g_signal_connect(find_dlg.dialog, "delete-event",
499 G_CALLBACK(gtk_widget_hide_on_delete), NULL);
500
501 sbox = gtk_hbox_new(FALSE, 6);
502 gtk_box_pack_start(GTK_BOX(sbox), label, FALSE, FALSE, 0);
503 gtk_box_pack_start(GTK_BOX(sbox), entry, TRUE, TRUE, 0);
504 gtk_box_pack_start(GTK_BOX(vbox), sbox, TRUE, FALSE, 0);
505
506 gtk_container_add(GTK_CONTAINER(vbox),
507 add_find_checkboxes(GTK_DIALOG(find_dlg.dialog)));
508
509 /* Now add the multiple match options */
510 exp = gtk_expander_new_with_mnemonic(_("_Find All"));
511 gtk_expander_set_expanded(GTK_EXPANDER(exp), find_dlg.all_expanded);
512 g_signal_connect_after(exp, "activate",
513 G_CALLBACK(on_expander_activated), &find_dlg.all_expanded);
514
515 bbox = gtk_hbutton_box_new();
516
517 button = gtk_button_new_with_mnemonic(_("_Mark"));
518 gtk_widget_set_tooltip_text(button,
519 _("Mark all matches in the current document"));
520 gtk_container_add(GTK_CONTAINER(bbox), button);
521 g_signal_connect(button, "clicked", G_CALLBACK(send_find_dialog_response),
522 GINT_TO_POINTER(GEANY_RESPONSE_MARK));
523
524 button = gtk_button_new_with_mnemonic(_("In Sessi_on"));
525 gtk_container_add(GTK_CONTAINER(bbox), button);
526 g_signal_connect(button, "clicked", G_CALLBACK(send_find_dialog_response),
527 GINT_TO_POINTER(GEANY_RESPONSE_FIND_IN_SESSION));
528
529 button = gtk_button_new_with_mnemonic(_("_In Document"));
530 gtk_container_add(GTK_CONTAINER(bbox), button);
531 g_signal_connect(button, "clicked", G_CALLBACK(send_find_dialog_response),
532 GINT_TO_POINTER(GEANY_RESPONSE_FIND_IN_FILE));
533
534 /* close window checkbox */
535 check_close = gtk_check_button_new_with_mnemonic(_("Close _dialog"));
536 ui_hookup_widget(find_dlg.dialog, check_close, "check_close");
537 gtk_button_set_focus_on_click(GTK_BUTTON(check_close), FALSE);
538 gtk_widget_set_tooltip_text(check_close,
539 _("Disable this option to keep the dialog open"));
540 gtk_container_add(GTK_CONTAINER(bbox), check_close);
541 gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(bbox), check_close, TRUE);
542
543 ui_hbutton_box_copy_layout(
544 GTK_BUTTON_BOX(gtk_dialog_get_action_area(GTK_DIALOG(find_dlg.dialog))),
545 GTK_BUTTON_BOX(bbox));
546 gtk_container_add(GTK_CONTAINER(exp), bbox);
547 gtk_container_add(GTK_CONTAINER(vbox), exp);
548 }
549
550
551 static void set_dialog_position(GtkWidget *dialog, gint *position)
552 {
553 if (position[0] >= 0)
554 gtk_window_move(GTK_WINDOW(dialog), position[0], position[1]);
555 }
556
557
558 void search_show_find_dialog(void)
559 {
560 GeanyDocument *doc = document_get_current();
561 gchar *sel = NULL;
562
563 g_return_if_fail(doc != NULL);
564
565 sel = editor_get_default_selection(doc->editor, search_prefs.use_current_word, NULL);
566
567 if (find_dlg.dialog == NULL)
568 {
569 create_find_dialog();
570 stash_group_display(find_prefs, find_dlg.dialog);
571 if (sel)
572 gtk_entry_set_text(GTK_ENTRY(find_dlg.entry), sel);
573
574 set_dialog_position(find_dlg.dialog, find_dlg.position);
575 gtk_widget_show_all(find_dlg.dialog);
576 }
577 else
578 {
579 /* only set selection if the dialog is not already visible */
580 if (! gtk_widget_get_visible(find_dlg.dialog) && sel)
581 gtk_entry_set_text(GTK_ENTRY(find_dlg.entry), sel);
582 gtk_widget_grab_focus(find_dlg.entry);
583 set_dialog_position(find_dlg.dialog, find_dlg.position);
584 gtk_widget_show(find_dlg.dialog);
585 if (sel != NULL) /* when we have a selection, reset the entry widget's background colour */
586 ui_set_search_entry_background(find_dlg.entry, TRUE);
587 /* bring the dialog back in the foreground in case it is already open but the focus is away */
588 gtk_window_present(GTK_WINDOW(find_dlg.dialog));
589 }
590
591 g_free(sel);
592 }
593
594
595 static void send_replace_dialog_response(GtkButton *button, gpointer user_data)
596 {
597 gtk_dialog_response(GTK_DIALOG(replace_dlg.dialog), GPOINTER_TO_INT(user_data));
598 }
599
600
601 static gboolean
602 on_widget_key_pressed_set_focus(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
603 {
604 if (event->keyval == GDK_Tab)
605 {
606 gtk_widget_grab_focus(GTK_WIDGET(user_data));
607 return TRUE;
608 }
609 return FALSE;
610 }
611
612
613 static void create_replace_dialog(void)
614 {
615 GtkWidget *label_find, *label_replace,
616 *check_close, *button, *rbox, *fbox, *vbox, *exp, *bbox;
617 GtkSizeGroup *label_size;
618
619 replace_dlg.dialog = gtk_dialog_new_with_buttons(_("Replace"),
620 GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT,
621 GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL, NULL);
622 vbox = ui_dialog_vbox_new(GTK_DIALOG(replace_dlg.dialog));
623 gtk_box_set_spacing(GTK_BOX(vbox), 9);
624 gtk_widget_set_name(replace_dlg.dialog, "GeanyDialogSearch");
625
626 button = gtk_button_new_from_stock(GTK_STOCK_FIND);
627 gtk_dialog_add_action_widget(GTK_DIALOG(replace_dlg.dialog), button,
628 GEANY_RESPONSE_FIND);
629 button = gtk_button_new_with_mnemonic(_("_Replace"));
630 gtk_button_set_image(GTK_BUTTON(button),
631 gtk_image_new_from_stock(GTK_STOCK_FIND_AND_REPLACE, GTK_ICON_SIZE_BUTTON));
632 gtk_dialog_add_action_widget(GTK_DIALOG(replace_dlg.dialog), button,
633 GEANY_RESPONSE_REPLACE);
634 button = gtk_button_new_with_mnemonic(_("Replace & Fi_nd"));
635 gtk_button_set_image(GTK_BUTTON(button),
636 gtk_image_new_from_stock(GTK_STOCK_FIND_AND_REPLACE, GTK_ICON_SIZE_BUTTON));
637 gtk_dialog_add_action_widget(GTK_DIALOG(replace_dlg.dialog), button,
638 GEANY_RESPONSE_REPLACE_AND_FIND);
639
640 label_find = gtk_label_new_with_mnemonic(_("_Search for:"));
641 gtk_misc_set_alignment(GTK_MISC(label_find), 0, 0.5);
642
643 label_replace = gtk_label_new_with_mnemonic(_("Replace wit_h:"));
644 gtk_misc_set_alignment(GTK_MISC(label_replace), 0, 0.5);
645
646 replace_dlg.find_combobox = gtk_combo_box_text_new_with_entry();
647 replace_dlg.find_entry = gtk_bin_get_child(GTK_BIN(replace_dlg.find_combobox));
648 ui_entry_add_clear_icon(GTK_ENTRY(replace_dlg.find_entry));
649 gtk_label_set_mnemonic_widget(GTK_LABEL(label_find), replace_dlg.find_combobox);
650 gtk_entry_set_width_chars(GTK_ENTRY(replace_dlg.find_entry), 50);
651 ui_hookup_widget(replace_dlg.dialog, replace_dlg.find_combobox, "entry_find");
652
653 replace_dlg.replace_combobox = gtk_combo_box_text_new_with_entry();
654 replace_dlg.replace_entry = gtk_bin_get_child(GTK_BIN(replace_dlg.replace_combobox));
655 ui_entry_add_clear_icon(GTK_ENTRY(replace_dlg.replace_entry));
656 gtk_label_set_mnemonic_widget(GTK_LABEL(label_replace), replace_dlg.replace_combobox);
657 gtk_entry_set_width_chars(GTK_ENTRY(replace_dlg.replace_entry), 50);
658 ui_hookup_widget(replace_dlg.dialog, replace_dlg.replace_combobox, "entry_replace");
659
660 /* tab from find to the replace entry */
661 g_signal_connect(replace_dlg.find_entry,
662 "key-press-event", G_CALLBACK(on_widget_key_pressed_set_focus),
663 replace_dlg.replace_entry);
664 g_signal_connect(replace_dlg.find_entry, "activate",
665 G_CALLBACK(on_replace_find_entry_activate), NULL);
666 g_signal_connect(replace_dlg.replace_entry, "activate",
667 G_CALLBACK(on_replace_entry_activate), NULL);
668 g_signal_connect(replace_dlg.dialog, "response",
669 G_CALLBACK(on_replace_dialog_response), NULL);
670 g_signal_connect(replace_dlg.dialog, "delete-event",
671 G_CALLBACK(gtk_widget_hide_on_delete), NULL);
672
673 fbox = gtk_hbox_new(FALSE, 6);
674 gtk_box_pack_start(GTK_BOX(fbox), label_find, FALSE, FALSE, 0);
675 gtk_box_pack_start(GTK_BOX(fbox), replace_dlg.find_combobox, TRUE, TRUE, 0);
676
677 rbox = gtk_hbox_new(FALSE, 6);
678 gtk_box_pack_start(GTK_BOX(rbox), label_replace, FALSE, FALSE, 0);
679 gtk_box_pack_start(GTK_BOX(rbox), replace_dlg.replace_combobox, TRUE, TRUE, 0);
680
681 label_size = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
682 gtk_size_group_add_widget(label_size, label_find);
683 gtk_size_group_add_widget(label_size, label_replace);
684 g_object_unref(G_OBJECT(label_size)); /* auto destroy the size group */
685
686 gtk_box_pack_start(GTK_BOX(vbox), fbox, TRUE, FALSE, 0);
687 gtk_box_pack_start(GTK_BOX(vbox), rbox, TRUE, FALSE, 0);
688 gtk_container_add(GTK_CONTAINER(vbox),
689 add_find_checkboxes(GTK_DIALOG(replace_dlg.dialog)));
690
691 /* Now add the multiple replace options */
692 exp = gtk_expander_new_with_mnemonic(_("Re_place All"));
693 gtk_expander_set_expanded(GTK_EXPANDER(exp), replace_dlg.all_expanded);
694 g_signal_connect_after(exp, "activate",
695 G_CALLBACK(on_expander_activated), &replace_dlg.all_expanded);
696
697 bbox = gtk_hbutton_box_new();
698
699 button = gtk_button_new_with_mnemonic(_("In Sessi_on"));
700 gtk_container_add(GTK_CONTAINER(bbox), button);
701 g_signal_connect(button, "clicked", G_CALLBACK(send_replace_dialog_response),
702 GINT_TO_POINTER(GEANY_RESPONSE_REPLACE_IN_SESSION));
703
704 button = gtk_button_new_with_mnemonic(_("_In Document"));
705 gtk_container_add(GTK_CONTAINER(bbox), button);
706 g_signal_connect(button, "clicked", G_CALLBACK(send_replace_dialog_response),
707 GINT_TO_POINTER(GEANY_RESPONSE_REPLACE_IN_FILE));
708
709 button = gtk_button_new_with_mnemonic(_("In Se_lection"));
710 gtk_widget_set_tooltip_text(button,
711 _("Replace all matches found in the currently selected text"));
712 gtk_container_add(GTK_CONTAINER(bbox), button);
713 g_signal_connect(button, "clicked", G_CALLBACK(send_replace_dialog_response),
714 GINT_TO_POINTER(GEANY_RESPONSE_REPLACE_IN_SEL));
715
716 /* close window checkbox */
717 check_close = gtk_check_button_new_with_mnemonic(_("Close _dialog"));
718 ui_hookup_widget(replace_dlg.dialog, check_close, "check_close");
719 gtk_button_set_focus_on_click(GTK_BUTTON(check_close), FALSE);
720 gtk_widget_set_tooltip_text(check_close,
721 _("Disable this option to keep the dialog open"));
722 gtk_container_add(GTK_CONTAINER(bbox), check_close);
723 gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(bbox), check_close, TRUE);
724
725 ui_hbutton_box_copy_layout(
726 GTK_BUTTON_BOX(gtk_dialog_get_action_area(GTK_DIALOG(replace_dlg.dialog))),
727 GTK_BUTTON_BOX(bbox));
728 gtk_container_add(GTK_CONTAINER(exp), bbox);
729 gtk_container_add(GTK_CONTAINER(vbox), exp);
730 }
731
732
733 void search_show_replace_dialog(void)
734 {
735 GeanyDocument *doc = document_get_current();
736 gchar *sel = NULL;
737
738 if (doc == NULL)
739 return;
740
741 sel = editor_get_default_selection(doc->editor, search_prefs.use_current_word, NULL);
742
743 if (replace_dlg.dialog == NULL)
744 {
745 create_replace_dialog();
746 stash_group_display(replace_prefs, replace_dlg.dialog);
747 if (sel)
748 gtk_entry_set_text(GTK_ENTRY(replace_dlg.find_entry), sel);
749
750 set_dialog_position(replace_dlg.dialog, replace_dlg.position);
751 gtk_widget_show_all(replace_dlg.dialog);
752 }
753 else
754 {
755 /* only set selection if the dialog is not already visible */
756 if (! gtk_widget_get_visible(replace_dlg.dialog) && sel)
757 gtk_entry_set_text(GTK_ENTRY(replace_dlg.find_entry), sel);
758 if (sel != NULL) /* when we have a selection, reset the entry widget's background colour */
759 ui_set_search_entry_background(replace_dlg.find_entry, TRUE);
760 gtk_widget_grab_focus(replace_dlg.find_entry);
761 set_dialog_position(replace_dlg.dialog, replace_dlg.position);
762 gtk_widget_show(replace_dlg.dialog);
763 /* bring the dialog back in the foreground in case it is already open but the focus is away */
764 gtk_window_present(GTK_WINDOW(replace_dlg.dialog));
765 }
766
767 g_free(sel);
768 }
769
770
771 static void on_widget_toggled_set_sensitive(GtkToggleButton *togglebutton, gpointer user_data)
772 {
773 /* disable extra option entry when checkbutton not checked */
774 gtk_widget_set_sensitive(GTK_WIDGET(user_data),
775 gtk_toggle_button_get_active(togglebutton));
776 }
777
778
779 static void update_file_patterns(GtkWidget *mode_combo, GtkWidget *fcombo)
780 {
781 gint selection;
782 GtkWidget *entry;
783
784 entry = gtk_bin_get_child(GTK_BIN(fcombo));
785
786 selection = gtk_combo_box_get_active(GTK_COMBO_BOX(mode_combo));
787
788 if (selection == FILES_MODE_ALL)
789 {
790 gtk_entry_set_text(GTK_ENTRY(entry), "");
791 gtk_widget_set_sensitive(fcombo, FALSE);
792 }
793 else if (selection == FILES_MODE_CUSTOM)
794 {
795 gtk_widget_set_sensitive(fcombo, TRUE);
796 }
797 else if (selection == FILES_MODE_PROJECT)
798 {
799 if (app->project && !EMPTY(app->project->file_patterns))
800 {
801 gchar *patterns;
802
803 patterns = g_strjoinv(" ", app->project->file_patterns);
804 gtk_entry_set_text(GTK_ENTRY(entry), patterns);
805 g_free(patterns);
806 }
807 else
808 {
809 gtk_entry_set_text(GTK_ENTRY(entry), "");
810 }
811
812 gtk_widget_set_sensitive(fcombo, FALSE);
813 }
814 }
815
816
817 /* creates the combo to choose which files include in the search */
818 static GtkWidget *create_fif_file_mode_combo(void)
819 {
820 GtkWidget *combo;
821 GtkCellRenderer *renderer;
822 GtkListStore *store;
823 GtkTreeIter iter;
824
825 /* text/sensitive */
826 store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_BOOLEAN);
827 gtk_list_store_append(store, &iter);
828 gtk_list_store_set(store, &iter, 0, _("all"), 1, TRUE, -1);
829 gtk_list_store_append(store, &iter);
830 gtk_list_store_set(store, &iter, 0, _("project"), 1, app->project != NULL, -1);
831 gtk_list_store_append(store, &iter);
832 gtk_list_store_set(store, &iter, 0, _("custom"), 1, TRUE, -1);
833
834 combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
835 g_object_unref(store);
836 gtk_widget_set_tooltip_text(combo, _("All: search all files in the directory\n"
837 "Project: use file patterns defined in the project settings\n"
838 "Custom: specify file patterns manually"));
839
840 renderer = gtk_cell_renderer_text_new();
841 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
842 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 0, "sensitive", 1, NULL);
843
844 return combo;
845 }
846
847
848 /* updates the sensitivity of the project combo item */
849 static void update_fif_file_mode_combo(void)
850 {
851 GtkTreeModel *model = gtk_combo_box_get_model(GTK_COMBO_BOX(fif_dlg.files_mode_combo));
852 GtkTreeIter iter;
853
854 /* "1" refers to the second list entry, project */
855 if (gtk_tree_model_get_iter_from_string(model, &iter, "1"))
856 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1, app->project != NULL, -1);
857 }
858
859
860 static void create_fif_dialog(void)
861 {
862 GtkWidget *dir_combo, *combo, *fcombo, *e_combo, *entry;
863 GtkWidget *label, *label1, *label2, *label3, *checkbox1, *checkbox2, *check_wholeword,
864 *check_recursive, *check_extra, *entry_extra, *check_regexp, *combo_files_mode;
865 GtkWidget *dbox, *sbox, *lbox, *rbox, *hbox, *vbox, *ebox;
866 GtkSizeGroup *size_group;
867
868 fif_dlg.dialog = gtk_dialog_new_with_buttons(
869 _("Find in Files"), GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT,
870 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
871 vbox = ui_dialog_vbox_new(GTK_DIALOG(fif_dlg.dialog));
872 gtk_box_set_spacing(GTK_BOX(vbox), 9);
873 gtk_widget_set_name(fif_dlg.dialog, "GeanyDialogSearch");
874
875 gtk_dialog_add_button(GTK_DIALOG(fif_dlg.dialog), GTK_STOCK_FIND, GTK_RESPONSE_ACCEPT);
876 gtk_dialog_set_default_response(GTK_DIALOG(fif_dlg.dialog),
877 GTK_RESPONSE_ACCEPT);
878
879 label = gtk_label_new_with_mnemonic(_("_Search for:"));
880 gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
881
882 combo = gtk_combo_box_text_new_with_entry();
883 entry = gtk_bin_get_child(GTK_BIN(combo));
884 ui_entry_add_clear_icon(GTK_ENTRY(entry));
885 gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry);
886 gtk_entry_set_width_chars(GTK_ENTRY(entry), 50);
887 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
888 fif_dlg.search_combo = combo;
889
890 sbox = gtk_hbox_new(FALSE, 6);
891 gtk_box_pack_start(GTK_BOX(sbox), label, FALSE, FALSE, 0);
892 gtk_box_pack_start(GTK_BOX(sbox), combo, TRUE, TRUE, 0);
893
894 /* make labels same width */
895 size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
896 gtk_size_group_add_widget(size_group, label);
897
898 label3 = gtk_label_new_with_mnemonic(_("Fi_les:"));
899 gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);
900
901 combo_files_mode = create_fif_file_mode_combo();
902 gtk_label_set_mnemonic_widget(GTK_LABEL(label3), combo_files_mode);
903 ui_hookup_widget(fif_dlg.dialog, combo_files_mode, "combo_files_mode");
904 fif_dlg.files_mode_combo = combo_files_mode;
905
906 fcombo = gtk_combo_box_text_new_with_entry();
907 entry = gtk_bin_get_child(GTK_BIN(fcombo));
908 ui_entry_add_clear_icon(GTK_ENTRY(entry));
909 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
910 gtk_widget_set_tooltip_text(entry, _("File patterns, e.g. *.c *.h"));
911 ui_hookup_widget(fif_dlg.dialog, entry, "entry_files");
912 fif_dlg.files_combo = fcombo;
913
914 /* update the entry when selection is changed */
915 g_signal_connect(combo_files_mode, "changed", G_CALLBACK(update_file_patterns), fcombo);
916
917 hbox = gtk_hbox_new(FALSE, 6);
918 gtk_box_pack_start(GTK_BOX(hbox), label3, FALSE, FALSE, 0);
919 gtk_box_pack_start(GTK_BOX(hbox), combo_files_mode, FALSE, FALSE, 0);
920 gtk_box_pack_start(GTK_BOX(hbox), fcombo, TRUE, TRUE, 0);
921
922 label1 = gtk_label_new_with_mnemonic(_("_Directory:"));
923 gtk_misc_set_alignment(GTK_MISC(label1), 0, 0.5);
924
925 dir_combo = gtk_combo_box_text_new_with_entry();
926 entry = gtk_bin_get_child(GTK_BIN(dir_combo));
927 ui_entry_add_clear_icon(GTK_ENTRY(entry));
928 gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
929 gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry);
930 gtk_entry_set_width_chars(GTK_ENTRY(entry), 50);
931 fif_dlg.dir_combo = dir_combo;
932
933 /* tab from files to the dir entry */
934 g_signal_connect(gtk_bin_get_child(GTK_BIN(fcombo)), "key-press-event",
935 G_CALLBACK(on_widget_key_pressed_set_focus), entry);
936
937 dbox = ui_path_box_new(NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
938 GTK_ENTRY(entry));
939 gtk_box_pack_start(GTK_BOX(dbox), label1, FALSE, FALSE, 0);
940
941 label2 = gtk_label_new_with_mnemonic(_("E_ncoding:"));
942 gtk_misc_set_alignment(GTK_MISC(label2), 0, 0.5);
943
944 e_combo = ui_create_encodings_combo_box(FALSE, GEANY_ENCODING_UTF_8);
945 gtk_label_set_mnemonic_widget(GTK_LABEL(label2), e_combo);
946 fif_dlg.encoding_combo = e_combo;
947
948 ebox = gtk_hbox_new(FALSE, 6);
949 gtk_box_pack_start(GTK_BOX(ebox), label2, FALSE, FALSE, 0);
950 gtk_box_pack_start(GTK_BOX(ebox), e_combo, TRUE, TRUE, 0);
951
952 gtk_size_group_add_widget(size_group, label1);
953 gtk_size_group_add_widget(size_group, label2);
954 gtk_size_group_add_widget(size_group, label3);
955 g_object_unref(G_OBJECT(size_group)); /* auto destroy the size group */
956
957 gtk_box_pack_start(GTK_BOX(vbox), sbox, TRUE, FALSE, 0);
958 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);
959 gtk_box_pack_start(GTK_BOX(vbox), dbox, TRUE, FALSE, 0);
960 gtk_box_pack_start(GTK_BOX(vbox), ebox, TRUE, FALSE, 0);
961
962 check_regexp = gtk_check_button_new_with_mnemonic(_("_Use regular expressions"));
963 ui_hookup_widget(fif_dlg.dialog, check_regexp, "check_regexp");
964 gtk_button_set_focus_on_click(GTK_BUTTON(check_regexp), FALSE);
965 gtk_widget_set_tooltip_text(check_regexp, _("See grep's manual page for more information"));
966
967 check_recursive = gtk_check_button_new_with_mnemonic(_("_Recurse in subfolders"));
968 ui_hookup_widget(fif_dlg.dialog, check_recursive, "check_recursive");
969 gtk_button_set_focus_on_click(GTK_BUTTON(check_recursive), FALSE);
970
971 checkbox1 = gtk_check_button_new_with_mnemonic(_("C_ase sensitive"));
972 ui_hookup_widget(fif_dlg.dialog, checkbox1, "check_case");
973 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox1), FALSE);
974 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox1), TRUE);
975
976 check_wholeword = gtk_check_button_new_with_mnemonic(_("Match only a _whole word"));
977 ui_hookup_widget(fif_dlg.dialog, check_wholeword, "check_wholeword");
978 gtk_button_set_focus_on_click(GTK_BUTTON(check_wholeword), FALSE);
979
980 checkbox2 = gtk_check_button_new_with_mnemonic(_("_Invert search results"));
981 ui_hookup_widget(fif_dlg.dialog, checkbox2, "check_invert");
982 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox2), FALSE);
983 gtk_widget_set_tooltip_text(checkbox2,
984 _("Invert the sense of matching, to select non-matching lines"));
985
986 lbox = gtk_vbox_new(FALSE, 0);
987 gtk_container_add(GTK_CONTAINER(lbox), check_regexp);
988 gtk_container_add(GTK_CONTAINER(lbox), checkbox2);
989 gtk_container_add(GTK_CONTAINER(lbox), check_recursive);
990
991 rbox = gtk_vbox_new(FALSE, 0);
992 gtk_container_add(GTK_CONTAINER(rbox), checkbox1);
993 gtk_container_add(GTK_CONTAINER(rbox), check_wholeword);
994 gtk_container_add(GTK_CONTAINER(rbox), gtk_label_new(NULL));
995
996 hbox = gtk_hbox_new(FALSE, 6);
997 gtk_container_add(GTK_CONTAINER(hbox), lbox);
998 gtk_container_add(GTK_CONTAINER(hbox), rbox);
999 gtk_container_add(GTK_CONTAINER(vbox), hbox);
1000
1001 check_extra = gtk_check_button_new_with_mnemonic(_("E_xtra options:"));
1002 ui_hookup_widget(fif_dlg.dialog, check_extra, "check_extra");
1003 gtk_button_set_focus_on_click(GTK_BUTTON(check_extra), FALSE);
1004
1005 entry_extra = gtk_entry_new();
1006 ui_entry_add_clear_icon(GTK_ENTRY(entry_extra));
1007 gtk_entry_set_activates_default(GTK_ENTRY(entry_extra), TRUE);
1008 gtk_widget_set_sensitive(entry_extra, FALSE);
1009 gtk_widget_set_tooltip_text(entry_extra, _("Other options to pass to Grep"));
1010 ui_hookup_widget(fif_dlg.dialog, entry_extra, "entry_extra");
1011
1012 /* enable entry_extra when check_extra is checked */
1013 g_signal_connect(check_extra, "toggled",
1014 G_CALLBACK(on_widget_toggled_set_sensitive), entry_extra);
1015
1016 hbox = gtk_hbox_new(FALSE, 6);
1017 gtk_box_pack_start(GTK_BOX(hbox), check_extra, FALSE, FALSE, 0);
1018 gtk_box_pack_start(GTK_BOX(hbox), entry_extra, TRUE, TRUE, 0);
1019 gtk_container_add(GTK_CONTAINER(vbox), hbox);
1020
1021 g_signal_connect(fif_dlg.dialog, "response",
1022 G_CALLBACK(on_find_in_files_dialog_response), NULL);
1023 g_signal_connect(fif_dlg.dialog, "delete-event",
1024 G_CALLBACK(gtk_widget_hide_on_delete), NULL);
1025 }
1026
1027
1028 /**
1029 * Shows the Find in Files dialog.
1030 *
1031 * @param dir The directory to search in (UTF-8 encoding). May be @c NULL
1032 * to determine it the usual way by using the current document's path.
1033 *
1034 * @since 0.14, plugin API 53
1035 */
1036 GEANY_API_SYMBOL
1037 void search_show_find_in_files_dialog(const gchar *dir)
1038 {
1039 search_show_find_in_files_dialog_full(NULL, dir);
1040 }
1041
1042
1043 void search_show_find_in_files_dialog_full(const gchar *text, const gchar *dir)
1044 {
1045 GtkWidget *entry; /* for child GtkEntry of a GtkComboBoxEntry */
1046 GeanyDocument *doc = document_get_current();
1047 gchar *sel = NULL;
1048 gchar *cur_dir = NULL;
1049 GeanyEncodingIndex enc_idx = GEANY_ENCODING_UTF_8;
1050
1051 if (fif_dlg.dialog == NULL)
1052 {
1053 create_fif_dialog();
1054 gtk_widget_show_all(fif_dlg.dialog);
1055 if (doc && !text)
1056 sel = editor_get_default_selection(doc->editor, search_prefs.use_current_word, NULL);
1057 }
1058 stash_group_display(fif_prefs, fif_dlg.dialog);
1059
1060 if (!text)
1061 {
1062 /* only set selection if the dialog is not already visible, or has just been created */
1063 if (doc && ! sel && ! gtk_widget_get_visible(fif_dlg.dialog))
1064 sel = editor_get_default_selection(doc->editor, search_prefs.use_current_word, NULL);
1065
1066 text = sel;
1067 }
1068 entry = gtk_bin_get_child(GTK_BIN(fif_dlg.search_combo));
1069 if (text)
1070 gtk_entry_set_text(GTK_ENTRY(entry), text);
1071 g_free(sel);
1072
1073 /* add project's base path directory to the dir list, we do this here once
1074 * (in create_fif_dialog() it would fail if a project is opened after dialog creation) */
1075 if (app->project != NULL && !EMPTY(app->project->base_path))
1076 {
1077 ui_combo_box_prepend_text_once(GTK_COMBO_BOX_TEXT(fif_dlg.dir_combo),
1078 app->project->base_path);
1079 }
1080
1081 entry = gtk_bin_get_child(GTK_BIN(fif_dlg.dir_combo));
1082 if (!EMPTY(dir))
1083 cur_dir = g_strdup(dir); /* custom directory argument passed */
1084 else
1085 {
1086 if (search_prefs.use_current_file_dir)
1087 {
1088 static gchar *last_cur_dir = NULL;
1089 static GeanyDocument *last_doc = NULL;
1090
1091 /* Only set the directory entry once for the current document */
1092 cur_dir = utils_get_current_file_dir_utf8();
1093 if (doc == last_doc && cur_dir && utils_str_equal(cur_dir, last_cur_dir))
1094 {
1095 /* in case the user now wants the current directory, add it to history */
1096 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(fif_dlg.dir_combo), cur_dir, 0);
1097 SETPTR(cur_dir, NULL);
1098 }
1099 else
1100 SETPTR(last_cur_dir, g_strdup(cur_dir));
1101
1102 last_doc = doc;
1103 }
1104 if (!cur_dir && EMPTY(gtk_entry_get_text(GTK_ENTRY(entry))))
1105 {
1106 /* use default_open_path if no directory could be determined
1107 * (e.g. when no files are open) */
1108 if (!cur_dir)
1109 cur_dir = g_strdup(utils_get_default_dir_utf8());
1110 if (!cur_dir)
1111 cur_dir = g_get_current_dir();
1112 }
1113 }
1114 if (cur_dir)
1115 {
1116 gtk_entry_set_text(GTK_ENTRY(entry), cur_dir);
1117 g_free(cur_dir);
1118 }
1119
1120 update_fif_file_mode_combo();
1121 update_file_patterns(fif_dlg.files_mode_combo, fif_dlg.files_combo);
1122
1123 /* set the encoding of the current file */
1124 if (doc != NULL)
1125 enc_idx = encodings_get_idx_from_charset(doc->encoding);
1126 ui_encodings_combo_box_set_active_encoding(GTK_COMBO_BOX(fif_dlg.encoding_combo), enc_idx);
1127
1128 /* put the focus to the directory entry if it is empty */
1129 if (utils_str_equal(gtk_entry_get_text(GTK_ENTRY(entry)), ""))
1130 gtk_widget_grab_focus(fif_dlg.dir_combo);
1131 else
1132 gtk_widget_grab_focus(fif_dlg.search_combo);
1133
1134 /* set dialog window position */
1135 set_dialog_position(fif_dlg.dialog, fif_dlg.position);
1136
1137 gtk_widget_show(fif_dlg.dialog);
1138 /* bring the dialog back in the foreground in case it is already open but the focus is away */
1139 gtk_window_present(GTK_WINDOW(fif_dlg.dialog));
1140 }
1141
1142
1143 static void
1144 on_find_replace_checkbutton_toggled(GtkToggleButton *togglebutton, gpointer user_data)
1145 {
1146 GtkWidget *dialog = GTK_WIDGET(user_data);
1147 GtkToggleButton *chk_regexp = GTK_TOGGLE_BUTTON(
1148 ui_lookup_widget(dialog, "check_regexp"));
1149
1150 if (togglebutton == chk_regexp)
1151 {
1152 gboolean regex_set = gtk_toggle_button_get_active(chk_regexp);
1153 GtkWidget *check_word = ui_lookup_widget(dialog, "check_word");
1154 GtkWidget *check_wordstart = ui_lookup_widget(dialog, "check_wordstart");
1155 GtkWidget *check_escape = ui_lookup_widget(dialog, "check_escape");
1156 GtkWidget *check_multiline = ui_lookup_widget(dialog, "check_multiline");
1157 gboolean replace = (dialog != find_dlg.dialog);
1158 const char *back_button[2] = { "btn_previous" , "check_back" };
1159
1160 /* hide options that don't apply to regex searches */
1161 gtk_widget_set_sensitive(check_escape, ! regex_set);
1162 gtk_widget_set_sensitive(ui_lookup_widget(dialog, back_button[replace]), ! regex_set);
1163 gtk_widget_set_sensitive(check_word, ! regex_set);
1164 gtk_widget_set_sensitive(check_wordstart, ! regex_set);
1165 gtk_widget_set_sensitive(check_multiline, regex_set);
1166 }
1167 }
1168
1169
1170 static GeanyMatchInfo *match_info_new(GeanyFindFlags flags, gint start, gint end)
1171 {
1172 GeanyMatchInfo *info = g_slice_alloc(sizeof *info);
1173
1174 info->flags = flags;
1175 info->start = start;
1176 info->end = end;
1177 info->match_text = NULL;
1178
1179 return info;
1180 }
1181
1182 void geany_match_info_free(GeanyMatchInfo *info)
1183 {
1184 g_free(info->match_text);
1185 g_slice_free1(sizeof *info, info);
1186 }
1187
1188
1189 /* find all in the given range.
1190 * Returns a list of allocated GeanyMatchInfo, should be freed using:
1191 *
1192 * foreach_slist(node, matches)
1193 * geany_match_info_free(node->data);
1194 * g_slist_free(matches); */
1195 static GSList *find_range(ScintillaObject *sci, GeanyFindFlags flags, struct Sci_TextToFind *ttf)
1196 {
1197 GSList *matches = NULL;
1198 GeanyMatchInfo *info;
1199
1200 g_return_val_if_fail(sci != NULL && ttf->lpstrText != NULL, NULL);
1201 if (! *ttf->lpstrText)
1202 return NULL;
1203
1204 while (search_find_text(sci, flags, ttf, &info) != -1)
1205 {
1206 if (ttf->chrgText.cpMax > ttf->chrg.cpMax)
1207 {
1208 /* found text is partially out of range */
1209 geany_match_info_free(info);
1210 break;
1211 }
1212
1213 matches = g_slist_prepend(matches, info);
1214 ttf->chrg.cpMin = ttf->chrgText.cpMax;
1215
1216 /* avoid rematching with empty matches like "(?=[a-z])" or "^$".
1217 * note we cannot assume a match will always be empty or not and then break out, since
1218 * matches like "a?(?=b)" will sometimes be empty and sometimes not */
1219 if (ttf->chrgText.cpMax == ttf->chrgText.cpMin)
1220 ttf->chrg.cpMin ++;
1221 }
1222
1223 return g_slist_reverse(matches);
1224 }
1225
1226
1227 /* Clears markers if text is null/empty.
1228 * @return Number of matches marked. */
1229 gint search_mark_all(GeanyDocument *doc, const gchar *search_text, GeanyFindFlags flags)
1230 {
1231 gint count = 0;
1232 struct Sci_TextToFind ttf;
1233 GSList *match, *matches;
1234
1235 g_return_val_if_fail(DOC_VALID(doc), 0);
1236
1237 /* clear previous search indicators */
1238 editor_indicator_clear(doc->editor, GEANY_INDICATOR_SEARCH);
1239
1240 if (G_UNLIKELY(EMPTY(search_text)))
1241 return 0;
1242
1243 ttf.chrg.cpMin = 0;
1244 ttf.chrg.cpMax = sci_get_length(doc->editor->sci);
1245 ttf.lpstrText = (gchar *)search_text;
1246
1247 matches = find_range(doc->editor->sci, flags, &ttf);
1248 foreach_slist (match, matches)
1249 {
1250 GeanyMatchInfo *info = match->data;
1251
1252 if (info->end != info->start)
1253 editor_indicator_set_on_range(doc->editor, GEANY_INDICATOR_SEARCH, info->start, info->end);
1254 count++;
1255
1256 geany_match_info_free(info);
1257 }
1258 g_slist_free(matches);
1259
1260 return count;
1261 }
1262
1263
1264 static void
1265 on_find_entry_activate(GtkEntry *entry, gpointer user_data)
1266 {
1267 on_find_dialog_response(NULL, GEANY_RESPONSE_FIND, user_data);
1268 }
1269
1270
1271 static void
1272 on_find_entry_activate_backward(GtkEntry *entry, gpointer user_data)
1273 {
1274 /* can't search backwards with a regexp */
1275 if (search_data.flags & GEANY_FIND_REGEXP)
1276 utils_beep();
1277 else
1278 on_find_dialog_response(NULL, GEANY_RESPONSE_FIND_PREVIOUS, user_data);
1279 }
1280
1281
1282 static GeanyFindFlags int_search_flags(gint match_case, gint whole_word, gint regexp, gint multiline, gint word_start)
1283 {
1284 return (match_case ? GEANY_FIND_MATCHCASE : 0) |
1285 (regexp ? GEANY_FIND_REGEXP : 0) |
1286 (whole_word ? GEANY_FIND_WHOLEWORD : 0) |
1287 (multiline ? GEANY_FIND_MULTILINE : 0) |
1288 /* SCFIND_WORDSTART overrides SCFIND_WHOLEWORD, but we want the opposite */
1289 (word_start && !whole_word ? GEANY_FIND_WORDSTART : 0);
1290 }
1291
1292
1293 static void
1294 on_find_dialog_response(GtkDialog *dialog, gint response, gpointer user_data)
1295 {
1296 gtk_window_get_position(GTK_WINDOW(find_dlg.dialog),
1297 &find_dlg.position[0], &find_dlg.position[1]);
1298
1299 stash_group_update(find_prefs, find_dlg.dialog);
1300
1301 if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1302 gtk_widget_hide(find_dlg.dialog);
1303 else
1304 {
1305 GeanyDocument *doc = document_get_current();
1306 gboolean check_close = settings.find_close_dialog;
1307
1308 if (doc == NULL)
1309 return;
1310
1311 search_data.backwards = FALSE;
1312 search_data.search_bar = FALSE;
1313
1314 g_free(search_data.text);
1315 g_free(search_data.original_text);
1316 search_data.text = g_strdup(gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(user_data)))));
1317 search_data.original_text = g_strdup(search_data.text);
1318 search_data.flags = int_search_flags(settings.find_case_sensitive,
1319 settings.find_match_whole_word, settings.find_regexp, settings.find_regexp_multiline,
1320 settings.find_match_word_start);
1321
1322 if (EMPTY(search_data.text))
1323 {
1324 fail:
1325 utils_beep();
1326 gtk_widget_grab_focus(find_dlg.entry);
1327 return;
1328 }
1329 if (search_data.flags & GEANY_FIND_REGEXP)
1330 {
1331 GRegex *regex = compile_regex(search_data.text, search_data.flags);
1332 if (!regex)
1333 goto fail;
1334 else
1335 g_regex_unref(regex);
1336 }
1337 else if (settings.find_escape_sequences)
1338 {
1339 if (! utils_str_replace_escape(search_data.text, FALSE))
1340 goto fail;
1341 }
1342 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(user_data), search_data.original_text, 0);
1343
1344 switch (response)
1345 {
1346 case GEANY_RESPONSE_FIND:
1347 case GEANY_RESPONSE_FIND_PREVIOUS:
1348 {
1349 gint result = document_find_text(doc, search_data.text, search_data.original_text, search_data.flags,
1350 (response == GEANY_RESPONSE_FIND_PREVIOUS), NULL, TRUE, GTK_WIDGET(find_dlg.dialog));
1351 ui_set_search_entry_background(find_dlg.entry, (result > -1));
1352 check_close = search_prefs.hide_find_dialog;
1353 break;
1354 }
1355 case GEANY_RESPONSE_FIND_IN_FILE:
1356 search_find_usage(search_data.text, search_data.original_text, search_data.flags, FALSE);
1357 break;
1358
1359 case GEANY_RESPONSE_FIND_IN_SESSION:
1360 search_find_usage(search_data.text, search_data.original_text, search_data.flags, TRUE);
1361 break;
1362
1363 case GEANY_RESPONSE_MARK:
1364 {
1365 gint count = search_mark_all(doc, search_data.text, search_data.flags);
1366
1367 if (count == 0)
1368 ui_set_statusbar(FALSE, _("No matches found for \"%s\"."), search_data.original_text);
1369 else
1370 ui_set_statusbar(FALSE,
1371 ngettext("Found %d match for \"%s\".",
1372 "Found %d matches for \"%s\".", count),
1373 count, search_data.original_text);
1374 }
1375 break;
1376 }
1377 if (check_close)
1378 gtk_widget_hide(find_dlg.dialog);
1379 }
1380 }
1381
1382
1383 static void
1384 on_replace_find_entry_activate(GtkEntry *entry, gpointer user_data)
1385 {
1386 on_replace_dialog_response(NULL, GEANY_RESPONSE_FIND, NULL);
1387 }
1388
1389
1390 static void
1391 on_replace_entry_activate(GtkEntry *entry, gpointer user_data)
1392 {
1393 on_replace_dialog_response(NULL,
1394 search_prefs.replace_and_find_by_default ? GEANY_RESPONSE_REPLACE_AND_FIND : GEANY_RESPONSE_REPLACE,
1395 NULL);
1396 }
1397
1398
1399 static void replace_in_session(GeanyDocument *doc,
1400 GeanyFindFlags search_flags_re, gboolean search_replace_escape_re,
1401 const gchar *find, const gchar *replace,
1402 const gchar *original_find, const gchar *original_replace)
1403 {
1404 guint n, page_count, rep_count = 0, file_count = 0;
1405
1406 /* replace in all documents following notebook tab order */
1407 page_count = gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets.notebook));
1408 for (n = 0; n < page_count; n++)
1409 {
1410 GeanyDocument *tmp_doc = document_get_from_page(n);
1411 gint reps = 0;
1412
1413 reps = document_replace_all(tmp_doc, find, replace, original_find, original_replace, search_flags_re);
1414 rep_count += reps;
1415 if (reps)
1416 file_count++;
1417 }
1418 if (file_count == 0)
1419 {
1420 utils_beep();
1421 ui_set_statusbar(FALSE, _("No matches found for \"%s\"."), original_find);
1422 return;
1423 }
1424 /* if only one file was changed, don't override that document's status message
1425 * so we don't have to translate 4 messages for ngettext */
1426 if (file_count > 1)
1427 ui_set_statusbar(FALSE, _("Replaced %u matches in %u documents."),
1428 rep_count, file_count);
1429
1430 /* show which docs had replacements: */
1431 gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_STATUS);
1432
1433 ui_save_buttons_toggle(doc->changed); /* update save all */
1434 }
1435
1436
1437 static void
1438 on_replace_dialog_response(GtkDialog *dialog, gint response, gpointer user_data)
1439 {
1440 GeanyDocument *doc = document_get_current();
1441 GeanyFindFlags search_flags_re;
1442 gboolean search_backwards_re, search_replace_escape_re;
1443 gchar *find, *replace, *original_find = NULL, *original_replace = NULL;
1444
1445 gtk_window_get_position(GTK_WINDOW(replace_dlg.dialog),
1446 &replace_dlg.position[0], &replace_dlg.position[1]);
1447
1448 stash_group_update(replace_prefs, replace_dlg.dialog);
1449
1450 if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT)
1451 {
1452 gtk_widget_hide(replace_dlg.dialog);
1453 return;
1454 }
1455
1456 search_backwards_re = settings.replace_search_backwards;
1457 search_replace_escape_re = settings.replace_escape_sequences;
1458 find = g_strdup(gtk_entry_get_text(GTK_ENTRY(replace_dlg.find_entry)));
1459 replace = g_strdup(gtk_entry_get_text(GTK_ENTRY(replace_dlg.replace_entry)));
1460
1461 search_flags_re = int_search_flags(settings.replace_case_sensitive,
1462 settings.replace_match_whole_word, settings.replace_regexp,
1463 settings.replace_regexp_multiline, settings.replace_match_word_start);
1464
1465 if ((response != GEANY_RESPONSE_FIND) && (search_flags_re & GEANY_FIND_MATCHCASE)
1466 && (strcmp(find, replace) == 0))
1467 goto fail;
1468
1469 original_find = g_strdup(find);
1470 original_replace = g_strdup(replace);
1471
1472 if (search_flags_re & GEANY_FIND_REGEXP)
1473 {
1474 GRegex *regex = compile_regex(find, search_flags_re);
1475 if (regex)
1476 g_regex_unref(regex);
1477 /* find escapes will be handled by GRegex */
1478 if (!regex || !utils_str_replace_escape(replace, TRUE))
1479 goto fail;
1480 }
1481 else if (search_replace_escape_re)
1482 {
1483 if (! utils_str_replace_escape(find, FALSE) ||
1484 ! utils_str_replace_escape(replace, FALSE))
1485 goto fail;
1486 }
1487
1488 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(replace_dlg.find_combobox), original_find, 0);
1489 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(replace_dlg.replace_combobox), original_replace, 0);
1490
1491 switch (response)
1492 {
1493 case GEANY_RESPONSE_REPLACE_AND_FIND:
1494 {
1495 gint rep = document_replace_text(doc, find, original_find, replace, search_flags_re,
1496 search_backwards_re);
1497 if (rep != -1)
1498 document_find_text(doc, find, original_find, search_flags_re, search_backwards_re,
1499 NULL, TRUE, NULL);
1500 break;
1501 }
1502 case GEANY_RESPONSE_REPLACE:
1503 document_replace_text(doc, find, original_find, replace, search_flags_re,
1504 search_backwards_re);
1505 break;
1506
1507 case GEANY_RESPONSE_FIND:
1508 {
1509 gint result = document_find_text(doc, find, original_find, search_flags_re,
1510 search_backwards_re, NULL, TRUE, GTK_WIDGET(dialog));
1511 ui_set_search_entry_background(replace_dlg.find_entry, (result > -1));
1512 break;
1513 }
1514 case GEANY_RESPONSE_REPLACE_IN_FILE:
1515 if (! document_replace_all(doc, find, replace, original_find, original_replace, search_flags_re))
1516 utils_beep();
1517 break;
1518
1519 case GEANY_RESPONSE_REPLACE_IN_SESSION:
1520 replace_in_session(doc, search_flags_re, search_replace_escape_re, find, replace, original_find, original_replace);
1521 break;
1522
1523 case GEANY_RESPONSE_REPLACE_IN_SEL:
1524 document_replace_sel(doc, find, replace, original_find, original_replace, search_flags_re);
1525 break;
1526 }
1527 switch (response)
1528 {
1529 case GEANY_RESPONSE_REPLACE_IN_SEL:
1530 case GEANY_RESPONSE_REPLACE_IN_FILE:
1531 case GEANY_RESPONSE_REPLACE_IN_SESSION:
1532 if (settings.replace_close_dialog)
1533 gtk_widget_hide(replace_dlg.dialog);
1534 }
1535 g_free(find);
1536 g_free(replace);
1537 g_free(original_find);
1538 g_free(original_replace);
1539 return;
1540
1541 fail:
1542 utils_beep();
1543 gtk_widget_grab_focus(replace_dlg.find_entry);
1544 g_free(find);
1545 g_free(replace);
1546 g_free(original_find);
1547 g_free(original_replace);
1548 }
1549
1550
1551 static GString *get_grep_options(void)
1552 {
1553 GString *gstr = g_string_new("-nHI"); /* line numbers, filenames, ignore binaries */
1554
1555 if (settings.fif_invert_results)
1556 g_string_append_c(gstr, 'v');
1557 if (! settings.fif_case_sensitive)
1558 g_string_append_c(gstr, 'i');
1559 if (settings.fif_match_whole_word)
1560 g_string_append_c(gstr, 'w');
1561 if (settings.fif_recursive)
1562 g_string_append_c(gstr, 'r');
1563
1564 if (!settings.fif_regexp)
1565 g_string_append_c(gstr, 'F');
1566 else
1567 g_string_append_c(gstr, 'E');
1568
1569 if (settings.fif_use_extra_options)
1570 {
1571 g_strstrip(settings.fif_extra_options);
1572
1573 if (*settings.fif_extra_options != 0)
1574 {
1575 g_string_append_c(gstr, ' ');
1576 g_string_append(gstr, settings.fif_extra_options);
1577 }
1578 }
1579 g_strstrip(settings.fif_files);
1580 if (settings.fif_files_mode != FILES_MODE_ALL && *settings.fif_files)
1581 {
1582 GString *tmp;
1583
1584 /* put --include= before each pattern */
1585 tmp = g_string_new(settings.fif_files);
1586 do {} while (utils_string_replace_all(tmp, " ", " "));
1587 g_string_prepend_c(tmp, ' ');
1588 utils_string_replace_all(tmp, " ", " --include=");
1589 g_string_append(gstr, tmp->str);
1590 g_string_free(tmp, TRUE);
1591 }
1592 return gstr;
1593 }
1594
1595
1596 static void
1597 on_find_in_files_dialog_response(GtkDialog *dialog, gint response,
1598 G_GNUC_UNUSED gpointer user_data)
1599 {
1600 gtk_window_get_position(GTK_WINDOW(fif_dlg.dialog), &fif_dlg.position[0], &fif_dlg.position[1]);
1601
1602 stash_group_update(fif_prefs, fif_dlg.dialog);
1603
1604 if (response == GTK_RESPONSE_ACCEPT)
1605 {
1606 GtkWidget *search_combo = fif_dlg.search_combo;
1607 const gchar *search_text =
1608 gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(search_combo))));
1609 GtkWidget *dir_combo = fif_dlg.dir_combo;
1610 const gchar *utf8_dir =
1611 gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(dir_combo))));
1612 GeanyEncodingIndex enc_idx =
1613 ui_encodings_combo_box_get_active_encoding(GTK_COMBO_BOX(fif_dlg.encoding_combo));
1614
1615 if (G_UNLIKELY(EMPTY(utf8_dir)))
1616 ui_set_statusbar(FALSE, _("Invalid directory for find in files."));
1617 else if (!EMPTY(search_text))
1618 {
1619 GString *opts = get_grep_options();
1620 const gchar *enc = (enc_idx == GEANY_ENCODING_UTF_8) ? NULL :
1621 encodings_get_charset_from_index(enc_idx);
1622
1623 if (search_find_in_files(search_text, utf8_dir, opts->str, enc))
1624 {
1625 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(search_combo), search_text, 0);
1626 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(fif_dlg.files_combo), NULL, 0);
1627 ui_combo_box_add_to_history(GTK_COMBO_BOX_TEXT(dir_combo), utf8_dir, 0);
1628 gtk_widget_hide(fif_dlg.dialog);
1629 }
1630 g_string_free(opts, TRUE);
1631 }
1632 else
1633 ui_set_statusbar(FALSE, _("No text to find."));
1634 }
1635 else
1636 gtk_widget_hide(fif_dlg.dialog);
1637 }
1638
1639
1640 static gboolean
1641 search_find_in_files(const gchar *utf8_search_text, const gchar *utf8_dir, const gchar *opts,
1642 const gchar *enc)
1643 {
1644 gchar **argv_prefix, **argv;
1645 gchar *command_grep;
1646 gchar *command_line, *dir;
1647 gchar *search_text = NULL;
1648 GError *error = NULL;
1649 gboolean ret = FALSE;
1650 gssize utf8_text_len;
1651
1652 if (EMPTY(utf8_search_text) || ! utf8_dir) return TRUE;
1653
1654 command_grep = g_find_program_in_path(tool_prefs.grep_cmd);
1655 if (command_grep == NULL)
1656 command_line = g_strdup_printf("%s %s --", tool_prefs.grep_cmd, opts);
1657 else
1658 {
1659 command_line = g_strdup_printf("\"%s\" %s --", command_grep, opts);
1660 g_free(command_grep);
1661 }
1662
1663 /* convert the search text in the preferred encoding (if the text is not valid UTF-8. assume
1664 * it is already in the preferred encoding) */
1665 utf8_text_len = strlen(utf8_search_text);
1666 if (enc != NULL && g_utf8_validate(utf8_search_text, utf8_text_len, NULL))
1667 {
1668 search_text = g_convert(utf8_search_text, utf8_text_len, enc, "UTF-8", NULL, NULL, NULL);
1669 }
1670 if (search_text == NULL)
1671 search_text = g_strdup(utf8_search_text);
1672
1673 argv_prefix = g_new(gchar*, 3);
1674 argv_prefix[0] = search_text;
1675 dir = utils_get_locale_from_utf8(utf8_dir);
1676
1677 /* finally add the arguments(files to be searched) */
1678 if (settings.fif_recursive) /* recursive option set */
1679 {
1680 /* Use '.' so we get relative paths in the output */
1681 argv_prefix[1] = g_strdup(".");
1682 argv_prefix[2] = NULL;
1683 argv = argv_prefix;
1684 }
1685 else
1686 {
1687 argv_prefix[1] = NULL;
1688 argv = search_get_argv((const gchar**)argv_prefix, dir);
1689 g_strfreev(argv_prefix);
1690
1691 if (argv == NULL) /* no files */
1692 {
1693 g_free(command_line);
1694 return FALSE;
1695 }
1696 }
1697
1698 gtk_list_store_clear(msgwindow.store_msg);
1699 gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_MESSAGE);
1700
1701 /* we can pass 'enc' without strdup'ing it here because it's a global const string and
1702 * always exits longer than the lifetime of this function */
1703 if (spawn_with_callbacks(dir, command_line, argv, NULL, 0, NULL, NULL, search_read_io,
1704 (gpointer) enc, 0, search_read_io_stderr, (gpointer) enc, 0, search_finished, NULL,
1705 NULL, &error))
1706 {
1707 gchar *utf8_str;
1708
1709 ui_progress_bar_start(_("Searching..."));
1710 msgwin_set_messages_dir(dir);
1711 utf8_str = g_strdup_printf(_("%s %s -- %s (in directory: %s)"),
1712 tool_prefs.grep_cmd, opts, utf8_search_text, utf8_dir);
1713 msgwin_msg_add_string(COLOR_BLUE, -1, NULL, utf8_str);
1714 g_free(utf8_str);
1715 ret = TRUE;
1716 }
1717 else
1718 {
1719 ui_set_statusbar(TRUE, _("Cannot execute grep tool \"%s\": %s. "
1720 "Check the path setting in Preferences."), tool_prefs.grep_cmd, error->message);
1721 g_error_free(error);
1722 }
1723
1724 utils_free_pointers(2, dir, command_line, NULL);
1725 g_strfreev(argv);
1726 return ret;
1727 }
1728
1729
1730 static gboolean pattern_list_match(GSList *patterns, const gchar *str)
1731 {
1732 GSList *item;
1733
1734 foreach_slist(item, patterns)
1735 {
1736 if (g_pattern_match_string(item->data, str))
1737 return TRUE;
1738 }
1739 return FALSE;
1740 }
1741
1742
1743 /* Creates an argument vector of strings, copying argv_prefix[] values for
1744 * the first arguments, then followed by filenames found in dir.
1745 * Returns NULL if no files were found, otherwise returned vector should be fully freed. */
1746 static gchar **search_get_argv(const gchar **argv_prefix, const gchar *dir)
1747 {
1748 guint prefix_len, list_len, i, j;
1749 gchar **argv;
1750 GSList *list, *item, *patterns = NULL;
1751 GError *error = NULL;
1752
1753 g_return_val_if_fail(dir != NULL, NULL);
1754
1755 prefix_len = g_strv_length((gchar**)argv_prefix);
1756 list = utils_get_file_list(dir, &list_len, &error);
1757 if (error)
1758 {
1759 ui_set_statusbar(TRUE, _("Could not open directory (%s)"), error->message);
1760 g_error_free(error);
1761 return NULL;
1762 }
1763 if (list == NULL)
1764 return NULL;
1765
1766 argv = g_new(gchar*, prefix_len + list_len + 1);
1767
1768 for (i = 0, j = 0; i < prefix_len; i++)
1769 {
1770 if (g_str_has_prefix(argv_prefix[i], "--include="))
1771 {
1772 const gchar *pat = &(argv_prefix[i][10]); /* the pattern part of the argument */
1773
1774 patterns = g_slist_prepend(patterns, g_pattern_spec_new(pat));
1775 }
1776 else
1777 argv[j++] = g_strdup(argv_prefix[i]);
1778 }
1779
1780 if (patterns)
1781 {
1782 GSList *pat;
1783
1784 foreach_slist(item, list)
1785 {
1786 if (pattern_list_match(patterns, item->data))
1787 argv[j++] = item->data;
1788 else
1789 g_free(item->data);
1790 }
1791 foreach_slist(pat, patterns)
1792 g_pattern_spec_free(pat->data);
1793 g_slist_free(patterns);
1794 }
1795 else
1796 {
1797 foreach_slist(item, list)
1798 argv[j++] = item->data;
1799 }
1800
1801 argv[j] = NULL;
1802 g_slist_free(list);
1803 return argv;
1804 }
1805
1806
1807 static void read_fif_io(gchar *msg, GIOCondition condition, gchar *enc, gint msg_color)
1808 {
1809 if (condition & (G_IO_IN | G_IO_PRI))
1810 {
1811 gchar *utf8_msg = NULL;
1812
1813 g_strstrip(msg);
1814 /* enc is NULL when encoding is set to UTF-8, so we can skip any conversion */
1815 if (enc != NULL)
1816 {
1817 if (! g_utf8_validate(msg, -1, NULL))
1818 {
1819 utf8_msg = g_convert(msg, -1, "UTF-8", enc, NULL, NULL, NULL);
1820 }
1821 if (utf8_msg == NULL)
1822 utf8_msg = msg;
1823 }
1824 else
1825 utf8_msg = msg;
1826
1827 msgwin_msg_add_string(msg_color, -1, NULL, utf8_msg);
1828
1829 if (utf8_msg != msg)
1830 g_free(utf8_msg);
1831 }
1832 }
1833
1834
1835 static void search_read_io(GString *string, GIOCondition condition, gpointer data)
1836 {
1837 read_fif_io(string->str, condition, data, COLOR_BLACK);
1838 }
1839
1840
1841 static void search_read_io_stderr(GString *string, GIOCondition condition, gpointer data)
1842 {
1843 read_fif_io(string->str, condition, data, COLOR_DARK_RED);
1844 }
1845
1846
1847 static void search_finished(GPid child_pid, gint status, gpointer user_data)
1848 {
1849 const gchar *msg = _("Search failed.");
1850 gint exit_status;
1851
1852 if (SPAWN_WIFEXITED(status))
1853 {
1854 exit_status = SPAWN_WEXITSTATUS(status);
1855 }
1856 else if (SPAWN_WIFSIGNALED(status))
1857 {
1858 exit_status = -1;
1859 g_warning("Find in Files: The command failed unexpectedly (signal received).");
1860 }
1861 else
1862 {
1863 exit_status = 1;
1864 }
1865
1866 switch (exit_status)
1867 {
1868 case 0:
1869 {
1870 gint count = gtk_tree_model_iter_n_children(
1871 GTK_TREE_MODEL(msgwindow.store_msg), NULL) - 1;
1872 gchar *text = ngettext(
1873 "Search completed with %d match.",
1874 "Search completed with %d matches.", count);
1875
1876 msgwin_msg_add(COLOR_BLUE, -1, NULL, text, count);
1877 ui_set_statusbar(FALSE, text, count);
1878 break;
1879 }
1880 case 1:
1881 msg = _("No matches found.");
1882 default:
1883 msgwin_msg_add_string(COLOR_BLUE, -1, NULL, msg);
1884 ui_set_statusbar(FALSE, "%s", msg);
1885 break;
1886 }
1887 utils_beep();
1888 ui_progress_bar_stop();
1889 }
1890
1891
1892 static GRegex *compile_regex(const gchar *str, GeanyFindFlags sflags)
1893 {
1894 GRegex *regex;
1895 GError *error = NULL;
1896 gint rflags = 0;
1897
1898 if (sflags & GEANY_FIND_MULTILINE)
1899 rflags |= G_REGEX_MULTILINE;
1900 if (~sflags & GEANY_FIND_MATCHCASE)
1901 rflags |= G_REGEX_CASELESS;
1902 if (sflags & (GEANY_FIND_WHOLEWORD | GEANY_FIND_WORDSTART))
1903 {
1904 geany_debug("%s: Unsupported regex flags found!", G_STRFUNC);
1905 }
1906
1907 regex = g_regex_new(str, rflags, 0, &error);
1908 if (!regex)
1909 {
1910 ui_set_statusbar(FALSE, _("Bad regex: %s"), error->message);
1911 g_error_free(error);
1912 }
1913 return regex;
1914 }
1915
1916
1917 /* groups that don't exist are handled OK as len = end - start = (-1) - (-1) = 0 */
1918 static gchar *get_regex_match_string(const gchar *text, const GeanyMatchInfo *match, guint nth)
1919 {
1920 const gint start = match->matches[nth].start;
1921 const gint end = match->matches[nth].end;
1922 return g_strndup(&text[start], end - start);
1923 }
1924
1925
1926 static gint find_regex(ScintillaObject *sci, guint pos, GRegex *regex, gboolean multiline, GeanyMatchInfo *match)
1927 {
1928 const gchar *text;
1929 GMatchInfo *minfo;
1930 guint document_length;
1931 gint ret = -1;
1932 gint offset = 0;
1933
1934 document_length = (guint)sci_get_length(sci);
1935 if (document_length <= 0)
1936 return -1; /* skip empty documents */
1937
1938 g_return_val_if_fail(pos <= document_length, -1);
1939
1940 if (multiline)
1941 {
1942 /* Warning: any SCI calls will invalidate 'text' after calling SCI_GETCHARACTERPOINTER */
1943 text = (void*)SSM(sci, SCI_GETCHARACTERPOINTER, 0, 0);
1944 g_regex_match_full(regex, text, -1, pos, 0, &minfo, NULL);
1945 }
1946 else /* single-line mode, manually match against each line */
1947 {
1948 gint line = sci_get_line_from_position(sci, pos);
1949
1950 for (;;)
1951 {
1952 gint start = sci_get_position_from_line(sci, line);
1953 gint end = sci_get_line_end_position(sci, line);
1954
1955 text = (void*)SSM(sci, SCI_GETRANGEPOINTER, start, end - start);
1956 if (g_regex_match_full(regex, text, end - start, pos - start, 0, &minfo, NULL))
1957 {
1958 offset = start;
1959 break;
1960 }
1961 else /* not found, try next line */
1962 {
1963 line ++;
1964 if (line >= sci_get_line_count(sci))
1965 break;
1966 pos = sci_get_position_from_line(sci, line);
1967 /* don't free last info, it's freed below */
1968 g_match_info_free(minfo);
1969 }
1970 }
1971 }
1972
1973 /* Warning: minfo will become invalid when 'text' does! */
1974 if (g_match_info_matches(minfo))
1975 {
1976 guint i;
1977
1978 /* copy whole match text and offsets before they become invalid */
1979 SETPTR(match->match_text, g_match_info_fetch(minfo, 0));
1980
1981 foreach_range(i, G_N_ELEMENTS(match->matches))
1982 {
1983 gint start = -1, end = -1;
1984
1985 g_match_info_fetch_pos(minfo, (gint)i, &start, &end);
1986 match->matches[i].start = offset + start;
1987 match->matches[i].end = offset + end;
1988 }
1989 match->start = match->matches[0].start;
1990 match->end = match->matches[0].end;
1991 ret = match->start;
1992 }
1993 g_match_info_free(minfo);
1994 return ret;
1995 }
1996
1997
1998 static gint geany_find_flags_to_sci_flags(GeanyFindFlags flags)
1999 {
2000 g_warn_if_fail(! (flags & GEANY_FIND_REGEXP) || ! (flags & GEANY_FIND_MULTILINE));
2001
2002 return ((flags & GEANY_FIND_MATCHCASE) ? SCFIND_MATCHCASE : 0) |
2003 ((flags & GEANY_FIND_WHOLEWORD) ? SCFIND_WHOLEWORD : 0) |
2004 ((flags & GEANY_FIND_REGEXP) ? SCFIND_REGEXP | SCFIND_POSIX : 0) |
2005 ((flags & GEANY_FIND_WORDSTART) ? SCFIND_WORDSTART : 0);
2006 }
2007
2008
2009 gint search_find_prev(ScintillaObject *sci, const gchar *str, GeanyFindFlags flags, GeanyMatchInfo **match_)
2010 {
2011 gint ret;
2012
2013 g_return_val_if_fail(! (flags & GEANY_FIND_REGEXP), -1);
2014
2015 ret = sci_search_prev(sci, geany_find_flags_to_sci_flags(flags), str);
2016 if (ret != -1 && match_)
2017 *match_ = match_info_new(flags, ret, ret + strlen(str));
2018 return ret;
2019 }
2020
2021
2022 gint search_find_next(ScintillaObject *sci, const gchar *str, GeanyFindFlags flags, GeanyMatchInfo **match_)
2023 {
2024 GeanyMatchInfo *match;
2025 GRegex *regex;
2026 gint ret = -1;
2027 gint pos;
2028
2029 if (~flags & GEANY_FIND_REGEXP)
2030 {
2031 ret = sci_search_next(sci, geany_find_flags_to_sci_flags(flags), str);
2032 if (ret != -1 && match_)
2033 *match_ = match_info_new(flags, ret, ret + strlen(str));
2034 return ret;
2035 }
2036
2037 regex = compile_regex(str, flags);
2038 if (!regex)
2039 return -1;
2040
2041 match = match_info_new(flags, 0, 0);
2042
2043 pos = sci_get_current_position(sci);
2044 ret = find_regex(sci, pos, regex, flags & GEANY_FIND_MULTILINE, match);
2045 /* avoid re-matching the same position in case of empty matches */
2046 if (ret == pos && match->matches[0].start == match->matches[0].end)
2047 ret = find_regex(sci, pos + 1, regex, flags & GEANY_FIND_MULTILINE, match);
2048 if (ret >= 0)
2049 sci_set_selection(sci, match->start, match->end);
2050
2051 if (ret != -1 && match_)
2052 *match_ = match;
2053 else
2054 geany_match_info_free(match);
2055
2056 g_regex_unref(regex);
2057 return ret;
2058 }
2059
2060
2061 gint search_replace_match(ScintillaObject *sci, const GeanyMatchInfo *match, const gchar *replace_text)
2062 {
2063 GString *str;
2064 gint ret = 0;
2065 gint i = 0;
2066
2067 sci_set_target_start(sci, match->start);
2068 sci_set_target_end(sci, match->end);
2069
2070 if (! (match->flags & GEANY_FIND_REGEXP))
2071 return sci_replace_target(sci, replace_text, FALSE);
2072
2073 str = g_string_new(replace_text);
2074 while (str->str[i])
2075 {
2076 gchar *ptr = &str->str[i];
2077 gchar *grp;
2078 gchar c;
2079
2080 if (ptr[0] != '\\')
2081 {
2082 i++;
2083 continue;
2084 }
2085 c = ptr[1];
2086 /* backslash or unnecessary escape */
2087 if (c == '\\' || !isdigit(c))
2088 {
2089 g_string_erase(str, i, 1);
2090 i++;
2091 continue;
2092 }
2093 /* digit escape */
2094 g_string_erase(str, i, 2);
2095 /* fix match offsets by subtracting index of whole match start from the string */
2096 grp = get_regex_match_string(match->match_text - match->matches[0].start, match, c - '0');
2097 g_string_insert(str, i, grp);
2098 i += strlen(grp);
2099 g_free(grp);
2100 }
2101 ret = sci_replace_target(sci, str->str, FALSE);
2102 g_string_free(str, TRUE);
2103 return ret;
2104 }
2105
2106
2107 gint search_find_text(ScintillaObject *sci, GeanyFindFlags flags, struct Sci_TextToFind *ttf, GeanyMatchInfo **match_)
2108 {
2109 GeanyMatchInfo *match = NULL;
2110 GRegex *regex;
2111 gint ret;
2112
2113 if (~flags & GEANY_FIND_REGEXP)
2114 {
2115 ret = sci_find_text(sci, geany_find_flags_to_sci_flags(flags), ttf);
2116 if (ret != -1 && match_)
2117 *match_ = match_info_new(flags, ttf->chrgText.cpMin, ttf->chrgText.cpMax);
2118 return ret;
2119 }
2120
2121 regex = compile_regex(ttf->lpstrText, flags);
2122 if (!regex)
2123 return -1;
2124
2125 match = match_info_new(flags, 0, 0);
2126
2127 ret = find_regex(sci, ttf->chrg.cpMin, regex, flags & GEANY_FIND_MULTILINE, match);
2128 if (ret >= ttf->chrg.cpMax)
2129 ret = -1;
2130 else if (ret >= 0)
2131 {
2132 ttf->chrgText.cpMin = match->start;
2133 ttf->chrgText.cpMax = match->end;
2134 }
2135
2136 if (ret != -1 && match_)
2137 *match_ = match;
2138 else
2139 geany_match_info_free(match);
2140
2141 g_regex_unref(regex);
2142 return ret;
2143 }
2144
2145
2146 static gint find_document_usage(GeanyDocument *doc, const gchar *search_text, GeanyFindFlags flags)
2147 {
2148 gchar *buffer, *short_file_name;
2149 struct Sci_TextToFind ttf;
2150 gint count = 0;
2151 gint prev_line = -1;
2152 GSList *match, *matches;
2153
2154 g_return_val_if_fail(DOC_VALID(doc), 0);
2155
2156 short_file_name = g_path_get_basename(DOC_FILENAME(doc));
2157
2158 ttf.chrg.cpMin = 0;
2159 ttf.chrg.cpMax = sci_get_length(doc->editor->sci);
2160 ttf.lpstrText = (gchar *)search_text;
2161
2162 matches = find_range(doc->editor->sci, flags, &ttf);
2163 foreach_slist (match, matches)
2164 {
2165 GeanyMatchInfo *info = match->data;
2166 gint line = sci_get_line_from_position(doc->editor->sci, info->start);
2167
2168 if (line != prev_line)
2169 {
2170 buffer = sci_get_line(doc->editor->sci, line);
2171 msgwin_msg_add(COLOR_BLACK, line + 1, doc,
2172 "%s:%d: %s", short_file_name, line + 1, g_strstrip(buffer));
2173 g_free(buffer);
2174 prev_line = line;
2175 }
2176 count++;
2177
2178 geany_match_info_free(info);
2179 }
2180 g_slist_free(matches);
2181 g_free(short_file_name);
2182 return count;
2183 }
2184
2185
2186 void search_find_usage(const gchar *search_text, const gchar *original_search_text,
2187 GeanyFindFlags flags, gboolean in_session)
2188 {
2189 GeanyDocument *doc;
2190 gint count = 0;
2191
2192 doc = document_get_current();
2193 g_return_if_fail(doc != NULL);
2194
2195 if (G_UNLIKELY(EMPTY(search_text)))
2196 {
2197 utils_beep();
2198 return;
2199 }
2200
2201 gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_MESSAGE);
2202 gtk_list_store_clear(msgwindow.store_msg);
2203
2204 if (! in_session)
2205 { /* use current document */
2206 count = find_document_usage(doc, search_text, flags);
2207 }
2208 else
2209 {
2210 guint i;
2211 for (i = 0; i < documents_array->len; i++)
2212 {
2213 if (documents[i]->is_valid)
2214 {
2215 count += find_document_usage(documents[i], search_text, flags);
2216 }
2217 }
2218 }
2219
2220 if (count == 0) /* no matches were found */
2221 {
2222 ui_set_statusbar(FALSE, _("No matches found for \"%s\"."), original_search_text);
2223 msgwin_msg_add(COLOR_BLUE, -1, NULL, _("No matches found for \"%s\"."), original_search_text);
2224 }
2225 else
2226 {
2227 ui_set_statusbar(FALSE, ngettext(
2228 "Found %d match for \"%s\".", "Found %d matches for \"%s\".", count),
2229 count, original_search_text);
2230 msgwin_msg_add(COLOR_BLUE, -1, NULL, ngettext(
2231 "Found %d match for \"%s\".", "Found %d matches for \"%s\".", count),
2232 count, original_search_text);
2233 }
2234 }
2235
2236
2237 /* ttf is updated to include the last match position (ttf->chrg.cpMin) and
2238 * the new search range end (ttf->chrg.cpMax).
2239 * Note: Normally you would call sci_start/end_undo_action() around this call. */
2240 guint search_replace_range(ScintillaObject *sci, struct Sci_TextToFind *ttf,
2241 GeanyFindFlags flags, const gchar *replace_text)
2242 {
2243 gint count = 0;
2244 gint offset = 0; /* difference between search pos and replace pos */
2245 GSList *match, *matches;
2246
2247 g_return_val_if_fail(sci != NULL && ttf->lpstrText != NULL && replace_text != NULL, 0);
2248 if (! *ttf->lpstrText)
2249 return 0;
2250
2251 matches = find_range(sci, flags, ttf);
2252 foreach_slist (match, matches)
2253 {
2254 GeanyMatchInfo *info = match->data;
2255 gint replace_len;
2256
2257 info->start += offset;
2258 info->end += offset;
2259
2260 replace_len = search_replace_match(sci, info, replace_text);
2261 offset += replace_len - (info->end - info->start);
2262 count ++;
2263
2264 /* on last match, update the last match/new range end */
2265 if (! match->next)
2266 {
2267 ttf->chrg.cpMin = info->start;
2268 ttf->chrg.cpMax += offset;
2269 }
2270
2271 geany_match_info_free(info);
2272 }
2273 g_slist_free(matches);
2274
2275 return count;
2276 }
2277
2278
2279 void search_find_again(gboolean change_direction)
2280 {
2281 GeanyDocument *doc = document_get_current();
2282
2283 g_return_if_fail(doc != NULL);
2284
2285 if (search_data.text)
2286 {
2287 gboolean forward = ! search_data.backwards;
2288 gint result = document_find_text(doc, search_data.text, search_data.original_text, search_data.flags,
2289 change_direction ? forward : !forward, NULL, FALSE, NULL);
2290
2291 if (result > -1)
2292 editor_display_current_line(doc->editor, 0.3F);
2293
2294 if (search_data.search_bar)
2295 ui_set_search_entry_background(
2296 toolbar_get_widget_child_by_name("SearchEntry"), (result > -1));
2297 }
2298 }
A fast and lightweight IDE