?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix unused warning when building without VTE support
[geany-mirror.git] / src / editor.c
blob0db81c475efa136de0ad621dcf854facde1d935c
1 /*
2 * editor.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6 * Copyright 2009-2012 Frank Lanitz <frank(at)frank(dot)uvena(dot)de>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 /**
24 * @file editor.h
25 * Editor-related functions for @ref GeanyEditor.
26 * Geany uses the Scintilla editing widget, and this file is mostly built around
27 * Scintilla's functionality.
28 * @see sciwrappers.h.
29 */
30 /* Callbacks for the Scintilla widget (ScintillaObject).
31 * Most important is the sci-notify callback, handled in on_editor_notification().
32 * This includes auto-indentation, comments, auto-completion, calltips, etc.
33 * Also some general Scintilla-related functions.
34 */
35
36
37 #include <ctype.h>
38 #include <string.h>
39
40 #include <gdk/gdkkeysyms.h>
41
42 #include "SciLexer.h"
43 #include "geany.h"
44
45 #include "support.h"
46 #include "editor.h"
47 #include "document.h"
48 #include "documentprivate.h"
49 #include "filetypes.h"
50 #include "filetypesprivate.h"
51 #include "sciwrappers.h"
52 #include "ui_utils.h"
53 #include "utils.h"
54 #include "dialogs.h"
55 #include "symbols.h"
56 #include "callbacks.h"
57 #include "templates.h"
58 #include "keybindings.h"
59 #include "project.h"
60 #include "projectprivate.h"
61 #include "main.h"
62 #include "highlighting.h"
63 #include "gtkcompat.h"
64
65
66 /* Note: use sciwrappers.h instead where possible.
67 * Do not use SSM in files unrelated to scintilla. */
68 #define SSM(s, m, w, l) scintilla_send_message(s, m, w, l)
69
70
71 static GHashTable *snippet_hash = NULL;
72 static GQueue *snippet_offsets = NULL;
73 static gint snippet_cursor_insert_pos;
74 static GtkAccelGroup *snippet_accel_group = NULL;
75
76 static const gchar geany_cursor_marker[] = "__GEANY_CURSOR_MARKER__";
77
78 /* holds word under the mouse or keyboard cursor */
79 static gchar current_word[GEANY_MAX_WORD_LENGTH];
80
81 /* Initialised in keyfile.c. */
82 GeanyEditorPrefs editor_prefs;
83
84 EditorInfo editor_info = {current_word, -1};
85
86 static struct
87 {
88 gchar *text;
89 gboolean set;
90 gchar *last_word;
91 guint tag_index;
92 gint pos;
93 ScintillaObject *sci;
94 } calltip = {NULL, FALSE, NULL, 0, 0, NULL};
95
96 static gchar indent[100];
97
98
99 static void on_new_line_added(GeanyEditor *editor);
100 static gboolean handle_xml(GeanyEditor *editor, gint pos, gchar ch);
101 static void insert_indent_after_line(GeanyEditor *editor, gint line);
102 static void auto_multiline(GeanyEditor *editor, gint pos);
103 static void auto_close_chars(ScintillaObject *sci, gint pos, gchar c);
104 static void close_block(GeanyEditor *editor, gint pos);
105 static void editor_highlight_braces(GeanyEditor *editor, gint cur_pos);
106 static void read_current_word(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen,
107 const gchar *wc, gboolean stem);
108 static gsize count_indent_size(GeanyEditor *editor, const gchar *base_indent);
109 static const gchar *snippets_find_completion_by_name(const gchar *type, const gchar *name);
110 static void snippets_make_replacements(GeanyEditor *editor, GString *pattern);
111 static gssize replace_cursor_markers(GeanyEditor *editor, GString *pattern);
112 static GeanyFiletype *editor_get_filetype_at_line(GeanyEditor *editor, gint line);
113 static gboolean sci_is_blank_line(ScintillaObject *sci, gint line);
114
115
116 void editor_snippets_free(void)
117 {
118 g_hash_table_destroy(snippet_hash);
119 g_queue_free(snippet_offsets);
120 gtk_window_remove_accel_group(GTK_WINDOW(main_widgets.window), snippet_accel_group);
121 }
122
123
124 static void snippets_load(GKeyFile *sysconfig, GKeyFile *userconfig)
125 {
126 gsize i, j, len = 0, len_keys = 0;
127 gchar **groups_user, **groups_sys;
128 gchar **keys_user, **keys_sys;
129 gchar *value;
130 GHashTable *tmp;
131
132 /* keys are strings, values are GHashTables, so use g_free and g_hash_table_destroy */
133 snippet_hash =
134 g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy);
135
136 /* first read all globally defined auto completions */
137 groups_sys = g_key_file_get_groups(sysconfig, &len);
138 for (i = 0; i < len; i++)
139 {
140 if (strcmp(groups_sys[i], "Keybindings") == 0)
141 continue;
142 keys_sys = g_key_file_get_keys(sysconfig, groups_sys[i], &len_keys, NULL);
143 /* create new hash table for the read section (=> filetype) */
144 tmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
145 g_hash_table_insert(snippet_hash, g_strdup(groups_sys[i]), tmp);
146
147 for (j = 0; j < len_keys; j++)
148 {
149 g_hash_table_insert(tmp, g_strdup(keys_sys[j]),
150 utils_get_setting_string(sysconfig, groups_sys[i], keys_sys[j], ""));
151 }
152 g_strfreev(keys_sys);
153 }
154 g_strfreev(groups_sys);
155
156 /* now read defined completions in user's configuration directory and add / replace them */
157 groups_user = g_key_file_get_groups(userconfig, &len);
158 for (i = 0; i < len; i++)
159 {
160 if (strcmp(groups_user[i], "Keybindings") == 0)
161 continue;
162 keys_user = g_key_file_get_keys(userconfig, groups_user[i], &len_keys, NULL);
163
164 tmp = g_hash_table_lookup(snippet_hash, groups_user[i]);
165 if (tmp == NULL)
166 { /* new key found, create hash table */
167 tmp = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
168 g_hash_table_insert(snippet_hash, g_strdup(groups_user[i]), tmp);
169 }
170 for (j = 0; j < len_keys; j++)
171 {
172 value = g_hash_table_lookup(tmp, keys_user[j]);
173 if (value == NULL)
174 { /* value = NULL means the key doesn't yet exist, so insert */
175 g_hash_table_insert(tmp, g_strdup(keys_user[j]),
176 utils_get_setting_string(userconfig, groups_user[i], keys_user[j], ""));
177 }
178 else
179 { /* old key and value will be freed by destroy function (g_free) */
180 g_hash_table_replace(tmp, g_strdup(keys_user[j]),
181 utils_get_setting_string(userconfig, groups_user[i], keys_user[j], ""));
182 }
183 }
184 g_strfreev(keys_user);
185 }
186 g_strfreev(groups_user);
187 }
188
189
190 static void on_snippet_keybinding_activate(gchar *key)
191 {
192 GeanyDocument *doc = document_get_current();
193 const gchar *s;
194 GHashTable *specials;
195
196 if (!doc || !gtk_widget_has_focus(GTK_WIDGET(doc->editor->sci)))
197 return;
198
199 s = snippets_find_completion_by_name(doc->file_type->name, key);
200 if (!s) /* allow user to specify keybindings for "special" snippets */
201 {
202 specials = g_hash_table_lookup(snippet_hash, "Special");
203 if (G_LIKELY(specials != NULL))
204 s = g_hash_table_lookup(specials, key);
205 }
206 if (!s)
207 {
208 utils_beep();
209 return;
210 }
211
212 editor_insert_snippet(doc->editor, sci_get_current_position(doc->editor->sci), s);
213 sci_scroll_caret(doc->editor->sci);
214 }
215
216
217 static void add_kb(GKeyFile *keyfile, const gchar *group, gchar **keys)
218 {
219 gsize i;
220
221 if (!keys)
222 return;
223 for (i = 0; i < g_strv_length(keys); i++)
224 {
225 guint key;
226 GdkModifierType mods;
227 gchar *accel_string = g_key_file_get_value(keyfile, group, keys[i], NULL);
228
229 gtk_accelerator_parse(accel_string, &key, &mods);
230 g_free(accel_string);
231
232 if (key == 0 && mods == 0)
233 {
234 g_warning("Can not parse accelerator \"%s\" from user snippets.conf", accel_string);
235 continue;
236 }
237 gtk_accel_group_connect(snippet_accel_group, key, mods, 0,
238 g_cclosure_new_swap((GCallback)on_snippet_keybinding_activate,
239 g_strdup(keys[i]), (GClosureNotify)g_free));
240 }
241 }
242
243
244 static void load_kb(GKeyFile *sysconfig, GKeyFile *userconfig)
245 {
246 const gchar kb_group[] = "Keybindings";
247 gchar **keys = g_key_file_get_keys(userconfig, kb_group, NULL, NULL);
248 gchar **ptr;
249
250 /* remove overridden keys from system keyfile */
251 foreach_strv(ptr, keys)
252 g_key_file_remove_key(sysconfig, kb_group, *ptr, NULL);
253
254 add_kb(userconfig, kb_group, keys);
255 g_strfreev(keys);
256
257 keys = g_key_file_get_keys(sysconfig, kb_group, NULL, NULL);
258 add_kb(sysconfig, kb_group, keys);
259 g_strfreev(keys);
260 }
261
262
263 void editor_snippets_init(void)
264 {
265 gchar *sysconfigfile, *userconfigfile;
266 GKeyFile *sysconfig = g_key_file_new();
267 GKeyFile *userconfig = g_key_file_new();
268
269 snippet_offsets = g_queue_new();
270
271 sysconfigfile = g_build_filename(app->datadir, "snippets.conf", NULL);
272 userconfigfile = g_build_filename(app->configdir, "snippets.conf", NULL);
273
274 /* check for old autocomplete.conf files (backwards compatibility) */
275 if (! g_file_test(userconfigfile, G_FILE_TEST_IS_REGULAR))
276 SETPTR(userconfigfile, g_build_filename(app->configdir, "autocomplete.conf", NULL));
277
278 /* load the actual config files */
279 g_key_file_load_from_file(sysconfig, sysconfigfile, G_KEY_FILE_NONE, NULL);
280 g_key_file_load_from_file(userconfig, userconfigfile, G_KEY_FILE_NONE, NULL);
281
282 snippets_load(sysconfig, userconfig);
283
284 /* setup snippet keybindings */
285 snippet_accel_group = gtk_accel_group_new();
286 gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), snippet_accel_group);
287 load_kb(sysconfig, userconfig);
288
289 g_free(sysconfigfile);
290 g_free(userconfigfile);
291 g_key_file_free(sysconfig);
292 g_key_file_free(userconfig);
293 }
294
295
296 static gboolean on_editor_button_press_event(GtkWidget *widget, GdkEventButton *event,
297 gpointer data)
298 {
299 GeanyEditor *editor = data;
300 GeanyDocument *doc = editor->document;
301
302 /* it's very unlikely we got a 'real' click even on 0, 0, so assume it is a
303 * fake event to show the editor menu triggered by a key event where we want to use the
304 * text cursor position. */
305 if (event->x > 0.0 && event->y > 0.0)
306 editor_info.click_pos = sci_get_position_from_xy(editor->sci,
307 (gint)event->x, (gint)event->y, FALSE);
308 else
309 editor_info.click_pos = sci_get_current_position(editor->sci);
310
311 if (event->button == 1)
312 {
313 guint state = event->state & gtk_accelerator_get_default_mod_mask();
314
315 if (event->type == GDK_BUTTON_PRESS && editor_prefs.disable_dnd)
316 {
317 gint ss = sci_get_selection_start(editor->sci);
318 sci_set_selection_end(editor->sci, ss);
319 }
320 if (event->type == GDK_BUTTON_PRESS && state == GDK_CONTROL_MASK)
321 {
322 sci_set_current_position(editor->sci, editor_info.click_pos, FALSE);
323
324 editor_find_current_word(editor, editor_info.click_pos,
325 current_word, sizeof current_word, NULL);
326 if (*current_word)
327 return symbols_goto_tag(current_word, TRUE);
328 else
329 keybindings_send_command(GEANY_KEY_GROUP_GOTO, GEANY_KEYS_GOTO_MATCHINGBRACE);
330 return TRUE;
331 }
332 return document_check_disk_status(doc, FALSE);
333 }
334
335 /* calls the edit popup menu in the editor */
336 if (event->button == 3)
337 {
338 gboolean can_goto;
339
340 /* ensure the editor widget has the focus after this operation */
341 gtk_widget_grab_focus(widget);
342
343 editor_find_current_word(editor, editor_info.click_pos,
344 current_word, sizeof current_word, NULL);
345
346 can_goto = sci_has_selection(editor->sci) || current_word[0] != '\0';
347 ui_update_popup_goto_items(can_goto);
348 ui_update_popup_copy_items(doc);
349 ui_update_insert_include_item(doc, 0);
350
351 g_signal_emit_by_name(geany_object, "update-editor-menu",
352 current_word, editor_info.click_pos, doc);
353
354 gtk_menu_popup(GTK_MENU(main_widgets.editor_menu),
355 NULL, NULL, NULL, NULL, event->button, event->time);
356
357 return TRUE;
358 }
359 return FALSE;
360 }
361
362
363 static gboolean is_style_php(gint style)
364 {
365 if ((style >= SCE_HPHP_DEFAULT && style <= SCE_HPHP_OPERATOR) ||
366 style == SCE_HPHP_COMPLEX_VARIABLE)
367 {
368 return TRUE;
369 }
370
371 return FALSE;
372 }
373
374
375 static gint editor_get_long_line_type(void)
376 {
377 if (app->project)
378 switch (app->project->long_line_behaviour)
379 {
380 case 0: /* marker disabled */
381 return 2;
382 case 1: /* use global settings */
383 break;
384 case 2: /* custom (enabled) */
385 return editor_prefs.long_line_type;
386 }
387
388 if (!editor_prefs.long_line_enabled)
389 return 2;
390 else
391 return editor_prefs.long_line_type;
392 }
393
394
395 static gint editor_get_long_line_column(void)
396 {
397 if (app->project && app->project->long_line_behaviour != 1 /* use global settings */)
398 return app->project->long_line_column;
399 else
400 return editor_prefs.long_line_column;
401 }
402
403
404 static const GeanyEditorPrefs *
405 get_default_prefs(void)
406 {
407 static GeanyEditorPrefs eprefs;
408
409 eprefs = editor_prefs;
410
411 /* project overrides */
412 eprefs.indentation = (GeanyIndentPrefs*)editor_get_indent_prefs(NULL);
413 eprefs.long_line_type = editor_get_long_line_type();
414 eprefs.long_line_column = editor_get_long_line_column();
415 return &eprefs;
416 }
417
418
419 /* Gets the prefs for the editor.
420 * Prefs can be different according to project or document.
421 * @warning Always get a fresh result instead of keeping a pointer to it if the editor/project
422 * settings may have changed, or if this function has been called for a different editor.
423 * @param editor The editor, or @c NULL to get the default prefs.
424 * @return The prefs. */
425 const GeanyEditorPrefs *editor_get_prefs(GeanyEditor *editor)
426 {
427 static GeanyEditorPrefs eprefs;
428 const GeanyEditorPrefs *dprefs = get_default_prefs();
429
430 /* Return the address of the default prefs to allow returning default and editor
431 * pref pointers without invalidating the contents of either. */
432 if (editor == NULL)
433 return dprefs;
434
435 eprefs = *dprefs;
436 eprefs.indentation = (GeanyIndentPrefs*)editor_get_indent_prefs(editor);
437 /* add other editor & document overrides as needed */
438 return &eprefs;
439 }
440
441
442 void editor_toggle_fold(GeanyEditor *editor, gint line, gint modifiers)
443 {
444 ScintillaObject *sci;
445 gint header;
446
447 g_return_if_fail(editor != NULL);
448
449 sci = editor->sci;
450 /* When collapsing a fold range whose starting line is offscreen,
451 * scroll the starting line to display at the top of the view.
452 * Otherwise it can be confusing when the document scrolls down to hide
453 * the folded lines. */
454 if ((sci_get_fold_level(sci, line) & SC_FOLDLEVELNUMBERMASK) > SC_FOLDLEVELBASE &&
455 !(sci_get_fold_level(sci, line) & SC_FOLDLEVELHEADERFLAG))
456 {
457 gint parent = sci_get_fold_parent(sci, line);
458 gint first = sci_get_first_visible_line(sci);
459
460 parent = SSM(sci, SCI_VISIBLEFROMDOCLINE, parent, 0);
461 if (first > parent)
462 SSM(sci, SCI_SETFIRSTVISIBLELINE, parent, 0);
463 }
464
465 /* find the fold header of the given line in case the one clicked isn't a fold point */
466 if (sci_get_fold_level(sci, line) & SC_FOLDLEVELHEADERFLAG)
467 header = line;
468 else
469 header = sci_get_fold_parent(sci, line);
470
471 if ((editor_prefs.unfold_all_children && ! (modifiers & SCMOD_SHIFT)) ||
472 (! editor_prefs.unfold_all_children && (modifiers & SCMOD_SHIFT)))
473 {
474 SSM(sci, SCI_FOLDCHILDREN, header, SC_FOLDACTION_TOGGLE);
475 }
476 else
477 {
478 SSM(sci, SCI_FOLDLINE, header, SC_FOLDACTION_TOGGLE);
479 }
480 }
481
482
483 static void on_margin_click(GeanyEditor *editor, SCNotification *nt)
484 {
485 /* left click to marker margin marks the line */
486 if (nt->margin == 1)
487 {
488 gint line = sci_get_line_from_position(editor->sci, nt->position);
489
490 /*sci_marker_delete_all(editor->sci, 1);*/
491 sci_toggle_marker_at_line(editor->sci, line, 1); /* toggle the marker */
492 }
493 /* left click on the folding margin to toggle folding state of current line */
494 else if (nt->margin == 2 && editor_prefs.folding)
495 {
496 gint line = sci_get_line_from_position(editor->sci, nt->position);
497 editor_toggle_fold(editor, line, nt->modifiers);
498 }
499 }
500
501
502 static void on_update_ui(GeanyEditor *editor, G_GNUC_UNUSED SCNotification *nt)
503 {
504 ScintillaObject *sci = editor->sci;
505 gint pos = sci_get_current_position(sci);
506
507 /* since Scintilla 2.24, SCN_UPDATEUI is also sent on scrolling though we don't need to handle
508 * this and so ignore every SCN_UPDATEUI events except for content and selection changes */
509 if (! (nt->updated & SC_UPDATE_CONTENT) && ! (nt->updated & SC_UPDATE_SELECTION))
510 return;
511
512 /* undo / redo menu update */
513 ui_update_popup_reundo_items(editor->document);
514
515 /* brace highlighting */
516 editor_highlight_braces(editor, pos);
517
518 ui_update_statusbar(editor->document, pos);
519
520 #if 0
521 /** experimental code for inverting selections */
522 {
523 gint i;
524 for (i = SSM(sci, SCI_GETSELECTIONSTART, 0, 0); i < SSM(sci, SCI_GETSELECTIONEND, 0, 0); i++)
525 {
526 /* need to get colour from getstyleat(), but how? */
527 SSM(sci, SCI_STYLESETFORE, STYLE_DEFAULT, 0);
528 SSM(sci, SCI_STYLESETBACK, STYLE_DEFAULT, 0);
529 }
530
531 sci_get_style_at(sci, pos);
532 }
533 #endif
534 }
535
536
537 static void check_line_breaking(GeanyEditor *editor, gint pos)
538 {
539 ScintillaObject *sci = editor->sci;
540 gint line, lstart, col;
541 gchar c;
542
543 if (!editor->line_breaking)
544 return;
545
546 col = sci_get_col_from_position(sci, pos);
547
548 line = sci_get_current_line(sci);
549
550 lstart = sci_get_position_from_line(sci, line);
551
552 /* use column instead of position which might be different with multibyte characters */
553 if (col < editor_prefs.line_break_column)
554 return;
555
556 /* look for the last space before line_break_column */
557 pos = MIN(pos, lstart + editor_prefs.line_break_column);
558
559 while (pos > lstart)
560 {
561 c = sci_get_char_at(sci, --pos);
562 if (c == GDK_space)
563 {
564 gint diff, last_pos, last_col;
565
566 /* remember the distance between the current column and the last column on the line
567 * (we use column position in case the previous line gets altered, such as removing
568 * trailing spaces or in case it contains multibyte characters) */
569 last_pos = sci_get_line_end_position(sci, line);
570 last_col = sci_get_col_from_position(sci, last_pos);
571 diff = last_col - col;
572
573 /* break the line after the space */
574 sci_set_current_position(sci, pos + 1, FALSE);
575 sci_cancel(sci); /* don't select from completion list */
576 sci_send_command(sci, SCI_NEWLINE);
577 line++;
578
579 /* correct cursor position (might not be at line end) */
580 last_pos = sci_get_line_end_position(sci, line);
581 last_col = sci_get_col_from_position(sci, last_pos); /* get last column on line */
582 /* last column - distance is the desired column, then retrieve its document position */
583 pos = sci_get_position_from_col(sci, line, last_col - diff);
584 sci_set_current_position(sci, pos, FALSE);
585 sci_scroll_caret(sci);
586 return;
587 }
588 }
589 }
590
591
592 static void show_autocomplete(ScintillaObject *sci, gsize rootlen, GString *words)
593 {
594 /* hide autocompletion if only option is already typed */
595 if (rootlen >= words->len ||
596 (words->str[rootlen] == '?' && rootlen >= words->len - 2))
597 {
598 sci_send_command(sci, SCI_AUTOCCANCEL);
599 return;
600 }
601 /* store whether a calltip is showing, so we can reshow it after autocompletion */
602 calltip.set = (gboolean) SSM(sci, SCI_CALLTIPACTIVE, 0, 0);
603 SSM(sci, SCI_AUTOCSHOW, rootlen, (sptr_t) words->str);
604 }
605
606
607 static void show_tags_list(GeanyEditor *editor, const GPtrArray *tags, gsize rootlen)
608 {
609 ScintillaObject *sci = editor->sci;
610
611 g_return_if_fail(tags);
612
613 if (tags->len > 0)
614 {
615 GString *words = g_string_sized_new(150);
616 guint j;
617
618 for (j = 0; j < tags->len; ++j)
619 {
620 TMTag *tag = tags->pdata[j];
621
622 if (j > 0)
623 g_string_append_c(words, '\n');
624
625 if (j == editor_prefs.autocompletion_max_entries)
626 {
627 g_string_append(words, "...");
628 break;
629 }
630 g_string_append(words, tag->name);
631
632 /* for now, tag types don't all follow C, so just look at arglist */
633 if (!EMPTY(tag->atts.entry.arglist))
634 g_string_append(words, "?2");
635 else
636 g_string_append(words, "?1");
637 }
638 show_autocomplete(sci, rootlen, words);
639 g_string_free(words, TRUE);
640 }
641 }
642
643
644 /* do not use with long strings */
645 static gboolean match_last_chars(ScintillaObject *sci, gint pos, const gchar *str)
646 {
647 gsize len = strlen(str);
648 gchar *buf;
649
650 g_return_val_if_fail(len < 100, FALSE);
651 g_return_val_if_fail((gint)len <= pos, FALSE);
652
653 buf = g_alloca(len + 1);
654 sci_get_text_range(sci, pos - len, pos, buf);
655 return strcmp(str, buf) == 0;
656 }
657
658
659 static gboolean reshow_calltip(gpointer data)
660 {
661 GeanyDocument *doc;
662
663 g_return_val_if_fail(calltip.sci != NULL, FALSE);
664
665 SSM(calltip.sci, SCI_CALLTIPCANCEL, 0, 0);
666 doc = document_get_current();
667
668 if (doc && doc->editor->sci == calltip.sci)
669 {
670 /* we use the position where the calltip was previously started as SCI_GETCURRENTPOS
671 * may be completely wrong in case the user cancelled the auto completion with the mouse */
672 SSM(calltip.sci, SCI_CALLTIPSHOW, calltip.pos, (sptr_t) calltip.text);
673 }
674 return FALSE;
675 }
676
677
678 static void request_reshowing_calltip(SCNotification *nt)
679 {
680 if (calltip.set)
681 {
682 /* delay the reshow of the calltip window to make sure it is actually displayed,
683 * without it might be not visible on SCN_AUTOCCANCEL. the priority is set to
684 * low to hopefully make Scintilla's events happen before reshowing since they
685 * seem to re-cancel the calltip on autoc menu hiding too */
686 g_idle_add_full(G_PRIORITY_LOW, reshow_calltip, NULL, NULL);
687 }
688 }
689
690
691 static void autocomplete_scope(GeanyEditor *editor)
692 {
693 ScintillaObject *sci = editor->sci;
694 gint pos = sci_get_current_position(editor->sci);
695 gchar typed = sci_get_char_at(sci, pos - 1);
696 gchar *name;
697 const GPtrArray *tags = NULL;
698 const TMTag *tag;
699 GeanyFiletype *ft = editor->document->file_type;
700
701 if (ft->id == GEANY_FILETYPES_C || ft->id == GEANY_FILETYPES_CPP)
702 {
703 if (match_last_chars(sci, pos, "->") || match_last_chars(sci, pos, "::"))
704 pos--;
705 else if (ft->id == GEANY_FILETYPES_CPP && match_last_chars(sci, pos, "->*"))
706 pos-=2;
707 else if (typed != '.')
708 return;
709 }
710 else if (typed != '.')
711 return;
712
713 /* allow for a space between word and operator */
714 if (isspace(sci_get_char_at(sci, pos - 2)))
715 pos--;
716 name = editor_get_word_at_pos(editor, pos - 1, NULL);
717 if (!name)
718 return;
719
720 tags = tm_workspace_find(name, tm_tag_max_t, NULL, FALSE, ft->lang);
721 g_free(name);
722 if (!tags || tags->len == 0)
723 return;
724
725 tag = g_ptr_array_index(tags, 0);
726 name = tag->atts.entry.var_type;
727 if (name)
728 {
729 TMWorkObject *obj = editor->document->tm_file;
730
731 tags = tm_workspace_find_scope_members(obj ? obj->tags_array : NULL,
732 name, TRUE, FALSE);
733 if (tags)
734 show_tags_list(editor, tags, 0);
735 }
736 }
737
738
739 static void on_char_added(GeanyEditor *editor, SCNotification *nt)
740 {
741 ScintillaObject *sci = editor->sci;
742 gint pos = sci_get_current_position(sci);
743
744 switch (nt->ch)
745 {
746 case '\r':
747 { /* simple indentation (only for CR format) */
748 if (sci_get_eol_mode(sci) == SC_EOL_CR)
749 on_new_line_added(editor);
750 break;
751 }
752 case '\n':
753 { /* simple indentation (for CR/LF and LF format) */
754 on_new_line_added(editor);
755 break;
756 }
757 case '>':
758 editor_start_auto_complete(editor, pos, FALSE); /* C/C++ ptr-> scope completion */
759 /* fall through */
760 case '/':
761 { /* close xml-tags */
762 handle_xml(editor, pos, nt->ch);
763 break;
764 }
765 case '(':
766 {
767 auto_close_chars(sci, pos, nt->ch);
768 /* show calltips */
769 editor_show_calltip(editor, --pos);
770 break;
771 }
772 case ')':
773 { /* hide calltips */
774 if (SSM(sci, SCI_CALLTIPACTIVE, 0, 0))
775 {
776 SSM(sci, SCI_CALLTIPCANCEL, 0, 0);
777 }
778 g_free(calltip.text);
779 calltip.text = NULL;
780 calltip.pos = 0;
781 calltip.sci = NULL;
782 calltip.set = FALSE;
783 break;
784 }
785 case '{':
786 case '[':
787 case '"':
788 case '\'':
789 {
790 auto_close_chars(sci, pos, nt->ch);
791 break;
792 }
793 case '}':
794 { /* closing bracket handling */
795 if (editor->auto_indent)
796 close_block(editor, pos - 1);
797 break;
798 }
799 /* scope autocompletion */
800 case '.':
801 case ':': /* C/C++ class:: syntax */
802 /* tag autocompletion */
803 default:
804 #if 0
805 if (! editor_start_auto_complete(editor, pos, FALSE))
806 request_reshowing_calltip(nt);
807 #else
808 editor_start_auto_complete(editor, pos, FALSE);
809 #endif
810 }
811 check_line_breaking(editor, pos);
812 }
813
814
815 /* expand() and fold_changed() are copied from SciTE (thanks) to fix #1923350. */
816 static void expand(ScintillaObject *sci, gint *line, gboolean doExpand,
817 gboolean force, gint visLevels, gint level)
818 {
819 gint lineMaxSubord = SSM(sci, SCI_GETLASTCHILD, *line, level & SC_FOLDLEVELNUMBERMASK);
820 gint levelLine = level;
821 (*line)++;
822 while (*line <= lineMaxSubord)
823 {
824 if (force)
825 {
826 if (visLevels > 0)
827 SSM(sci, SCI_SHOWLINES, *line, *line);
828 else
829 SSM(sci, SCI_HIDELINES, *line, *line);
830 }
831 else
832 {
833 if (doExpand)
834 SSM(sci, SCI_SHOWLINES, *line, *line);
835 }
836 if (levelLine == -1)
837 levelLine = SSM(sci, SCI_GETFOLDLEVEL, *line, 0);
838 if (levelLine & SC_FOLDLEVELHEADERFLAG)
839 {
840 if (force)
841 {
842 if (visLevels > 1)
843 SSM(sci, SCI_SETFOLDEXPANDED, *line, 1);
844 else
845 SSM(sci, SCI_SETFOLDEXPANDED, *line, 0);
846 expand(sci, line, doExpand, force, visLevels - 1, -1);
847 }
848 else
849 {
850 if (doExpand)
851 {
852 if (!sci_get_fold_expanded(sci, *line))
853 SSM(sci, SCI_SETFOLDEXPANDED, *line, 1);
854 expand(sci, line, TRUE, force, visLevels - 1, -1);
855 }
856 else
857 {
858 expand(sci, line, FALSE, force, visLevels - 1, -1);
859 }
860 }
861 }
862 else
863 {
864 (*line)++;
865 }
866 }
867 }
868
869
870 static void fold_changed(ScintillaObject *sci, gint line, gint levelNow, gint levelPrev)
871 {
872 if (levelNow & SC_FOLDLEVELHEADERFLAG)
873 {
874 if (! (levelPrev & SC_FOLDLEVELHEADERFLAG))
875 {
876 /* Adding a fold point */
877 SSM(sci, SCI_SETFOLDEXPANDED, line, 1);
878 expand(sci, &line, TRUE, FALSE, 0, levelPrev);
879 }
880 }
881 else if (levelPrev & SC_FOLDLEVELHEADERFLAG)
882 {
883 if (! sci_get_fold_expanded(sci, line))
884 { /* Removing the fold from one that has been contracted so should expand
885 * otherwise lines are left invisible with no way to make them visible */
886 SSM(sci, SCI_SETFOLDEXPANDED, line, 1);
887 expand(sci, &line, TRUE, FALSE, 0, levelPrev);
888 }
889 }
890 if (! (levelNow & SC_FOLDLEVELWHITEFLAG) &&
891 ((levelPrev & SC_FOLDLEVELNUMBERMASK) > (levelNow & SC_FOLDLEVELNUMBERMASK)))
892 {
893 /* See if should still be hidden */
894 gint parentLine = sci_get_fold_parent(sci, line);
895 if (parentLine < 0)
896 {
897 SSM(sci, SCI_SHOWLINES, line, line);
898 }
899 else if (sci_get_fold_expanded(sci, parentLine) &&
900 sci_get_line_is_visible(sci, parentLine))
901 {
902 SSM(sci, SCI_SHOWLINES, line, line);
903 }
904 }
905 }
906
907
908 static void ensure_range_visible(ScintillaObject *sci, gint posStart, gint posEnd,
909 gboolean enforcePolicy)
910 {
911 gint lineStart = sci_get_line_from_position(sci, MIN(posStart, posEnd));
912 gint lineEnd = sci_get_line_from_position(sci, MAX(posStart, posEnd));
913 gint line;
914
915 for (line = lineStart; line <= lineEnd; line++)
916 {
917 SSM(sci, enforcePolicy ? SCI_ENSUREVISIBLEENFORCEPOLICY : SCI_ENSUREVISIBLE, line, 0);
918 }
919 }
920
921
922 static void auto_update_margin_width(GeanyEditor *editor)
923 {
924 gint next_linecount = 1;
925 gint linecount = sci_get_line_count(editor->sci);
926 GeanyDocument *doc = editor->document;
927
928 while (next_linecount <= linecount)
929 next_linecount *= 10;
930
931 if (editor->document->priv->line_count != next_linecount)
932 {
933 doc->priv->line_count = next_linecount;
934 sci_set_line_numbers(editor->sci, TRUE, 0);
935 }
936 }
937
938
939 static void partial_complete(ScintillaObject *sci, const gchar *text)
940 {
941 gint pos = sci_get_current_position(sci);
942
943 sci_insert_text(sci, pos, text);
944 sci_set_current_position(sci, pos + strlen(text), TRUE);
945 }
946
947
948 /* Complete the next word part from @a entry */
949 static gboolean check_partial_completion(GeanyEditor *editor, const gchar *entry)
950 {
951 gchar *stem, *ptr, *text = utils_strdupa(entry);
952
953 read_current_word(editor, -1, current_word, sizeof current_word, NULL, TRUE);
954 stem = current_word;
955 if (strstr(text, stem) != text)
956 return FALSE; /* shouldn't happen */
957 if (strlen(text) <= strlen(stem))
958 return FALSE;
959
960 text += strlen(stem); /* skip stem */
961 ptr = strstr(text + 1, "_");
962 if (ptr)
963 {
964 ptr[1] = '\0';
965 partial_complete(editor->sci, text);
966 return TRUE;
967 }
968 else
969 {
970 /* CamelCase */
971 foreach_str(ptr, text + 1)
972 {
973 if (!ptr[0])
974 break;
975 if (g_ascii_isupper(*ptr) && g_ascii_islower(ptr[1]))
976 {
977 ptr[0] = '\0';
978 partial_complete(editor->sci, text);
979 return TRUE;
980 }
981 }
982 }
983 return FALSE;
984 }
985
986
987 /* Callback for the "sci-notify" signal to emit a "editor-notify" signal.
988 * Plugins can connect to the "editor-notify" signal. */
989 void editor_sci_notify_cb(G_GNUC_UNUSED GtkWidget *widget, G_GNUC_UNUSED gint scn,
990 gpointer scnt, gpointer data)
991 {
992 GeanyEditor *editor = data;
993 gboolean retval;
994
995 g_return_if_fail(editor != NULL);
996
997 g_signal_emit_by_name(geany_object, "editor-notify", editor, scnt, &retval);
998 }
999
1000
1001 static gboolean on_editor_notify(G_GNUC_UNUSED GObject *object, GeanyEditor *editor,
1002 SCNotification *nt, G_GNUC_UNUSED gpointer data)
1003 {
1004 ScintillaObject *sci = editor->sci;
1005 GeanyDocument *doc = editor->document;
1006
1007 switch (nt->nmhdr.code)
1008 {
1009 case SCN_SAVEPOINTLEFT:
1010 document_set_text_changed(doc, TRUE);
1011 break;
1012
1013 case SCN_SAVEPOINTREACHED:
1014 document_set_text_changed(doc, FALSE);
1015 break;
1016
1017 case SCN_MODIFYATTEMPTRO:
1018 utils_beep();
1019 break;
1020
1021 case SCN_MARGINCLICK:
1022 on_margin_click(editor, nt);
1023 break;
1024
1025 case SCN_UPDATEUI:
1026 on_update_ui(editor, nt);
1027 break;
1028
1029 case SCN_PAINTED:
1030 /* Visible lines are only laid out accurately just before painting,
1031 * so we need to only call editor_scroll_to_line here, because the document
1032 * may have line wrapping and folding enabled.
1033 * http://scintilla.sourceforge.net/ScintillaDoc.html#LineWrapping
1034 * This is important e.g. when loading a session and switching pages
1035 * and having the cursor scroll in view. */
1036 /* FIXME: Really we want to do this just before painting, not after it
1037 * as it will cause repainting. */
1038 if (editor->scroll_percent > 0.0F)
1039 {
1040 editor_scroll_to_line(editor, -1, editor->scroll_percent);
1041 /* disable further scrolling */
1042 editor->scroll_percent = -1.0F;
1043 }
1044 break;
1045
1046 case SCN_MODIFIED:
1047 if (editor_prefs.show_linenumber_margin && (nt->modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) && nt->linesAdded)
1048 {
1049 /* automatically adjust Scintilla's line numbers margin width */
1050 auto_update_margin_width(editor);
1051 }
1052 if (nt->modificationType & SC_STARTACTION && ! ignore_callback)
1053 {
1054 /* get notified about undo changes */
1055 document_undo_add(doc, UNDO_SCINTILLA, NULL);
1056 }
1057 if (editor_prefs.folding && (nt->modificationType & SC_MOD_CHANGEFOLD) != 0)
1058 {
1059 /* handle special fold cases, e.g. #1923350 */
1060 fold_changed(sci, nt->line, nt->foldLevelNow, nt->foldLevelPrev);
1061 }
1062 if (nt->modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT))
1063 {
1064 document_update_tag_list_in_idle(doc);
1065 }
1066 break;
1067
1068 case SCN_CHARADDED:
1069 on_char_added(editor, nt);
1070 break;
1071
1072 case SCN_USERLISTSELECTION:
1073 if (nt->listType == 1)
1074 {
1075 sci_add_text(sci, nt->text);
1076 }
1077 break;
1078
1079 case SCN_AUTOCSELECTION:
1080 if (g_str_equal(nt->text, "..."))
1081 {
1082 sci_cancel(sci);
1083 utils_beep();
1084 break;
1085 }
1086 /* fall through */
1087 case SCN_AUTOCCANCELLED:
1088 /* now that autocomplete is finishing or was cancelled, reshow calltips
1089 * if they were showing */
1090 request_reshowing_calltip(nt);
1091 break;
1092
1093 #ifdef GEANY_DEBUG
1094 case SCN_STYLENEEDED:
1095 geany_debug("style");
1096 break;
1097 #endif
1098 case SCN_NEEDSHOWN:
1099 ensure_range_visible(sci, nt->position, nt->position + nt->length, FALSE);
1100 break;
1101
1102 case SCN_URIDROPPED:
1103 if (nt->text != NULL)
1104 {
1105 document_open_file_list(nt->text, strlen(nt->text));
1106 }
1107 break;
1108
1109 case SCN_CALLTIPCLICK:
1110 if (nt->position > 0)
1111 {
1112 switch (nt->position)
1113 {
1114 case 1: /* up arrow */
1115 if (calltip.tag_index > 0)
1116 calltip.tag_index--;
1117 break;
1118
1119 case 2: calltip.tag_index++; break; /* down arrow */
1120 }
1121 editor_show_calltip(editor, -1);
1122 }
1123 break;
1124
1125 case SCN_ZOOM:
1126 /* recalculate line margin width */
1127 sci_set_line_numbers(sci, editor_prefs.show_linenumber_margin, 0);
1128 break;
1129 }
1130 /* we always return FALSE here to let plugins handle the event too */
1131 return FALSE;
1132 }
1133
1134
1135 /* Note: this is the same as sci_get_tab_width(), but is still useful when you don't have
1136 * a scintilla pointer. */
1137 static gint get_tab_width(const GeanyIndentPrefs *indent_prefs)
1138 {
1139 if (indent_prefs->type == GEANY_INDENT_TYPE_BOTH)
1140 return indent_prefs->hard_tab_width;
1141
1142 return indent_prefs->width; /* tab width = indent width */
1143 }
1144
1145
1146 /* Returns a string containing width chars of whitespace, filled with simple space
1147 * characters or with the right number of tab characters, according to the indent prefs.
1148 * (Result is filled with tabs *and* spaces if width isn't a multiple of
1149 * the tab width). */
1150 static gchar *
1151 get_whitespace(const GeanyIndentPrefs *iprefs, gint width)
1152 {
1153 g_return_val_if_fail(width >= 0, NULL);
1154
1155 if (width == 0)
1156 return g_strdup("");
1157
1158 if (iprefs->type == GEANY_INDENT_TYPE_SPACES)
1159 {
1160 return g_strnfill(width, ' ');
1161 }
1162 else
1163 { /* first fill text with tabs and fill the rest with spaces */
1164 const gint tab_width = get_tab_width(iprefs);
1165 gint tabs = width / tab_width;
1166 gint spaces = width % tab_width;
1167 gint len = tabs + spaces;
1168 gchar *str;
1169
1170 str = g_malloc(len + 1);
1171
1172 memset(str, '\t', tabs);
1173 memset(str + tabs, ' ', spaces);
1174 str[len] = '\0';
1175 return str;
1176 }
1177 }
1178
1179
1180 static const GeanyIndentPrefs *
1181 get_default_indent_prefs(void)
1182 {
1183 static GeanyIndentPrefs iprefs;
1184
1185 iprefs = app->project ? *app->project->priv->indentation : *editor_prefs.indentation;
1186 return &iprefs;
1187 }
1188
1189
1190 /** Gets the indentation prefs for the editor.
1191 * Prefs can be different according to project or document.
1192 * @warning Always get a fresh result instead of keeping a pointer to it if the editor/project
1193 * settings may have changed, or if this function has been called for a different editor.
1194 * @param editor The editor, or @c NULL to get the default indent prefs.
1195 * @return The indent prefs. */
1196 const GeanyIndentPrefs *
1197 editor_get_indent_prefs(GeanyEditor *editor)
1198 {
1199 static GeanyIndentPrefs iprefs;
1200 const GeanyIndentPrefs *dprefs = get_default_indent_prefs();
1201
1202 /* Return the address of the default prefs to allow returning default and editor
1203 * pref pointers without invalidating the contents of either. */
1204 if (editor == NULL)
1205 return dprefs;
1206
1207 iprefs = *dprefs;
1208 iprefs.type = editor->indent_type;
1209 iprefs.width = editor->indent_width;
1210
1211 /* if per-document auto-indent is enabled, but we don't have a global mode set,
1212 * just use basic auto-indenting */
1213 if (editor->auto_indent && iprefs.auto_indent_mode == GEANY_AUTOINDENT_NONE)
1214 iprefs.auto_indent_mode = GEANY_AUTOINDENT_BASIC;
1215
1216 if (!editor->auto_indent)
1217 iprefs.auto_indent_mode = GEANY_AUTOINDENT_NONE;
1218
1219 return &iprefs;
1220 }
1221
1222
1223 static void on_new_line_added(GeanyEditor *editor)
1224 {
1225 ScintillaObject *sci = editor->sci;
1226 gint line = sci_get_current_line(sci);
1227
1228 /* simple indentation */
1229 if (editor->auto_indent)
1230 {
1231 insert_indent_after_line(editor, line - 1);
1232 }
1233
1234 if (editor_prefs.auto_continue_multiline)
1235 { /* " * " auto completion in multiline C/C++/D/Java comments */
1236 auto_multiline(editor, line);
1237 }
1238
1239 if (editor_prefs.newline_strip)
1240 { /* strip the trailing spaces on the previous line */
1241 editor_strip_line_trailing_spaces(editor, line - 1);
1242 }
1243 }
1244
1245
1246 static gboolean lexer_has_braces(ScintillaObject *sci)
1247 {
1248 gint lexer = sci_get_lexer(sci);
1249
1250 switch (lexer)
1251 {
1252 case SCLEX_CPP:
1253 case SCLEX_D:
1254 case SCLEX_HTML: /* for PHP & JS */
1255 case SCLEX_PASCAL: /* for multiline comments? */
1256 case SCLEX_BASH:
1257 case SCLEX_PERL:
1258 case SCLEX_TCL:
1259 case SCLEX_R:
1260 case SCLEX_RUST:
1261 return TRUE;
1262 default:
1263 return FALSE;
1264 }
1265 }
1266
1267
1268 /* Read indent chars for the line that pos is on into indent global variable.
1269 * Note: Use sci_get_line_indentation() and get_whitespace()/editor_insert_text_block()
1270 * instead in any new code. */
1271 static void read_indent(GeanyEditor *editor, gint pos)
1272 {
1273 ScintillaObject *sci = editor->sci;
1274 guint i, len, j = 0;
1275 gint line;
1276 gchar *linebuf;
1277
1278 line = sci_get_line_from_position(sci, pos);
1279
1280 len = sci_get_line_length(sci, line);
1281 linebuf = sci_get_line(sci, line);
1282
1283 for (i = 0; i < len && j <= (sizeof(indent) - 1); i++)
1284 {
1285 if (linebuf[i] == ' ' || linebuf[i] == '\t') /* simple indentation */
1286 indent[j++] = linebuf[i];
1287 else
1288 break;
1289 }
1290 indent[j] = '\0';
1291 g_free(linebuf);
1292 }
1293
1294
1295 static gint get_brace_indent(ScintillaObject *sci, gint line)
1296 {
1297 gint start = sci_get_position_from_line(sci, line);
1298 gint end = sci_get_line_end_position(sci, line) - 1;
1299 gint lexer = sci_get_lexer(sci);
1300 gint count = 0;
1301 gint pos;
1302
1303 for (pos = end; pos >= start && count < 1; pos--)
1304 {
1305 if (highlighting_is_code_style(lexer, sci_get_style_at(sci, pos)))
1306 {
1307 gchar c = sci_get_char_at(sci, pos);
1308
1309 if (c == '{')
1310 count ++;
1311 else if (c == '}')
1312 count --;
1313 }
1314 }
1315
1316 return count > 0 ? 1 : 0;
1317 }
1318
1319
1320 /* gets the last code position on a line
1321 * warning: if there is no code position on the line, returns the start position */
1322 static gint get_sci_line_code_end_position(ScintillaObject *sci, gint line)
1323 {
1324 gint start = sci_get_position_from_line(sci, line);
1325 gint lexer = sci_get_lexer(sci);
1326 gint pos;
1327
1328 for (pos = sci_get_line_end_position(sci, line) - 1; pos > start; pos--)
1329 {
1330 gint style = sci_get_style_at(sci, pos);
1331
1332 if (highlighting_is_code_style(lexer, style) && ! isspace(sci_get_char_at(sci, pos)))
1333 break;
1334 }
1335
1336 return pos;
1337 }
1338
1339
1340 static gint get_python_indent(ScintillaObject *sci, gint line)
1341 {
1342 gint last_char = get_sci_line_code_end_position(sci, line);
1343
1344 /* add extra indentation for Python after colon */
1345 if (sci_get_char_at(sci, last_char) == ':' &&
1346 sci_get_style_at(sci, last_char) == SCE_P_OPERATOR)
1347 {
1348 return 1;
1349 }
1350 return 0;
1351 }
1352
1353
1354 static gint get_xml_indent(ScintillaObject *sci, gint line)
1355 {
1356 gboolean need_close = FALSE;
1357 gint end = get_sci_line_code_end_position(sci, line);
1358 gint pos;
1359
1360 /* don't indent if there's a closing tag to the right of the cursor */
1361 pos = sci_get_current_position(sci);
1362 if (sci_get_char_at(sci, pos) == '<' &&
1363 sci_get_char_at(sci, pos + 1) == '/')
1364 return 0;
1365
1366 if (sci_get_char_at(sci, end) == '>' &&
1367 sci_get_char_at(sci, end - 1) != '/')
1368 {
1369 gint style = sci_get_style_at(sci, end);
1370
1371 if (style == SCE_H_TAG || style == SCE_H_TAGUNKNOWN)
1372 {
1373 gint start = sci_get_position_from_line(sci, line);
1374 gchar *line_contents = sci_get_contents_range(sci, start, end + 1);
1375 gchar *opened_tag_name = utils_find_open_xml_tag(line_contents, end + 1 - start);
1376
1377 if (!EMPTY(opened_tag_name))
1378 {
1379 need_close = TRUE;
1380 if (sci_get_lexer(sci) == SCLEX_HTML && utils_is_short_html_tag(opened_tag_name))
1381 need_close = FALSE;
1382 }
1383 g_free(line_contents);
1384 g_free(opened_tag_name);
1385 }
1386 }
1387
1388 return need_close ? 1 : 0;
1389 }
1390
1391
1392 static gint get_indent_size_after_line(GeanyEditor *editor, gint line)
1393 {
1394 ScintillaObject *sci = editor->sci;
1395 gint size;
1396 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1397
1398 g_return_val_if_fail(line >= 0, 0);
1399
1400 size = sci_get_line_indentation(sci, line);
1401
1402 if (iprefs->auto_indent_mode > GEANY_AUTOINDENT_BASIC)
1403 {
1404 gint additional_indent = 0;
1405
1406 if (lexer_has_braces(sci))
1407 additional_indent = iprefs->width * get_brace_indent(sci, line);
1408 else if (sci_get_lexer(sci) == SCLEX_PYTHON) /* Python/Cython */
1409 additional_indent = iprefs->width * get_python_indent(sci, line);
1410
1411 /* HTML lexer "has braces" because of PHP and JavaScript. If get_brace_indent() did not
1412 * recommend us to insert additional indent, we are probably not in PHP/JavaScript chunk and
1413 * should make the XML-related check */
1414 if (additional_indent == 0 &&
1415 (sci_get_lexer(sci) == SCLEX_HTML ||
1416 sci_get_lexer(sci) == SCLEX_XML) &&
1417 editor->document->file_type->priv->xml_indent_tags)
1418 {
1419 size += iprefs->width * get_xml_indent(sci, line);
1420 }
1421
1422 size += additional_indent;
1423 }
1424 return size;
1425 }
1426
1427
1428 static void insert_indent_after_line(GeanyEditor *editor, gint line)
1429 {
1430 ScintillaObject *sci = editor->sci;
1431 gint line_indent = sci_get_line_indentation(sci, line);
1432 gint size = get_indent_size_after_line(editor, line);
1433 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1434 gchar *text;
1435
1436 if (size == 0)
1437 return;
1438
1439 if (iprefs->type == GEANY_INDENT_TYPE_TABS && size == line_indent)
1440 {
1441 /* support tab indents, space aligns style - copy last line 'indent' exactly */
1442 gint start = sci_get_position_from_line(sci, line);
1443 gint end = sci_get_line_indent_position(sci, line);
1444
1445 text = sci_get_contents_range(sci, start, end);
1446 }
1447 else
1448 {
1449 text = get_whitespace(iprefs, size);
1450 }
1451 sci_add_text(sci, text);
1452 g_free(text);
1453 }
1454
1455
1456 static void auto_close_chars(ScintillaObject *sci, gint pos, gchar c)
1457 {
1458 const gchar *closing_char = NULL;
1459 gint end_pos = -1;
1460
1461 if (utils_isbrace(c, 0))
1462 end_pos = sci_find_matching_brace(sci, pos - 1);
1463
1464 switch (c)
1465 {
1466 case '(':
1467 if ((editor_prefs.autoclose_chars & GEANY_AC_PARENTHESIS) && end_pos == -1)
1468 closing_char = ")";
1469 break;
1470 case '{':
1471 if ((editor_prefs.autoclose_chars & GEANY_AC_CBRACKET) && end_pos == -1)
1472 closing_char = "}";
1473 break;
1474 case '[':
1475 if ((editor_prefs.autoclose_chars & GEANY_AC_SBRACKET) && end_pos == -1)
1476 closing_char = "]";
1477 break;
1478 case '\'':
1479 if (editor_prefs.autoclose_chars & GEANY_AC_SQUOTE)
1480 closing_char = "'";
1481 break;
1482 case '"':
1483 if (editor_prefs.autoclose_chars & GEANY_AC_DQUOTE)
1484 closing_char = "\"";
1485 break;
1486 }
1487
1488 if (closing_char != NULL)
1489 {
1490 sci_add_text(sci, closing_char);
1491 sci_set_current_position(sci, pos, TRUE);
1492 }
1493 }
1494
1495
1496 /* Finds a corresponding matching brace to the given pos
1497 * (this is taken from Scintilla Editor.cxx,
1498 * fit to work with close_block) */
1499 static gint brace_match(ScintillaObject *sci, gint pos)
1500 {
1501 gchar chBrace = sci_get_char_at(sci, pos);
1502 gchar chSeek = utils_brace_opposite(chBrace);
1503 gchar chAtPos;
1504 gint direction = -1;
1505 gint styBrace;
1506 gint depth = 1;
1507 gint styAtPos;
1508
1509 /* Hack: we need the style at @p pos but it isn't computed yet, so force styling
1510 * of this very position */
1511 sci_colourise(sci, pos, pos + 1);
1512
1513 styBrace = sci_get_style_at(sci, pos);
1514
1515 if (utils_is_opening_brace(chBrace, editor_prefs.brace_match_ltgt))
1516 direction = 1;
1517
1518 pos += direction;
1519 while ((pos >= 0) && (pos < sci_get_length(sci)))
1520 {
1521 chAtPos = sci_get_char_at(sci, pos);
1522 styAtPos = sci_get_style_at(sci, pos);
1523
1524 if ((pos > sci_get_end_styled(sci)) || (styAtPos == styBrace))
1525 {
1526 if (chAtPos == chBrace)
1527 depth++;
1528 if (chAtPos == chSeek)
1529 depth--;
1530 if (depth == 0)
1531 return pos;
1532 }
1533 pos += direction;
1534 }
1535 return -1;
1536 }
1537
1538
1539 /* Called after typing '}'. */
1540 static void close_block(GeanyEditor *editor, gint pos)
1541 {
1542 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1543 gint x = 0, cnt = 0;
1544 gint line, line_len;
1545 gchar *text, *line_buf;
1546 ScintillaObject *sci;
1547 gint line_indent, last_indent;
1548
1549 if (iprefs->auto_indent_mode < GEANY_AUTOINDENT_CURRENTCHARS)
1550 return;
1551 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
1552
1553 sci = editor->sci;
1554
1555 if (! lexer_has_braces(sci))
1556 return;
1557
1558 line = sci_get_line_from_position(sci, pos);
1559 line_len = sci_get_line_end_position(sci, line) - sci_get_position_from_line(sci, line);
1560
1561 /* check that the line is empty, to not kill text in the line */
1562 line_buf = sci_get_line(sci, line);
1563 line_buf[line_len] = '\0';
1564 while (x < line_len)
1565 {
1566 if (isspace(line_buf[x]))
1567 cnt++;
1568 x++;
1569 }
1570 g_free(line_buf);
1571
1572 if ((line_len - 1) != cnt)
1573 return;
1574
1575 if (iprefs->auto_indent_mode == GEANY_AUTOINDENT_MATCHBRACES)
1576 {
1577 gint start_brace = brace_match(sci, pos);
1578
1579 if (start_brace >= 0)
1580 {
1581 gint line_start;
1582 gint brace_line = sci_get_line_from_position(sci, start_brace);
1583 gint size = sci_get_line_indentation(sci, brace_line);
1584 gchar *ind = get_whitespace(iprefs, size);
1585
1586 text = g_strconcat(ind, "}", NULL);
1587 line_start = sci_get_position_from_line(sci, line);
1588 sci_set_anchor(sci, line_start);
1589 sci_replace_sel(sci, text);
1590 g_free(text);
1591 g_free(ind);
1592 return;
1593 }
1594 /* fall through - unmatched brace (possibly because of TCL, PHP lexer bugs) */
1595 }
1596
1597 /* GEANY_AUTOINDENT_CURRENTCHARS */
1598 line_indent = sci_get_line_indentation(sci, line);
1599 last_indent = sci_get_line_indentation(sci, line - 1);
1600
1601 if (line_indent < last_indent)
1602 return;
1603 line_indent -= iprefs->width;
1604 line_indent = MAX(0, line_indent);
1605 sci_set_line_indentation(sci, line, line_indent);
1606 }
1607
1608
1609 /* checks whether @p c is an ASCII character (e.g. < 0x80) */
1610 #define IS_ASCII(c) (((unsigned char)(c)) < 0x80)
1611
1612
1613 /* Reads the word at given cursor position and writes it into the given buffer. The buffer will be
1614 * NULL terminated in any case, even when the word is truncated because wordlen is too small.
1615 * position can be -1, then the current position is used.
1616 * wc are the wordchars to use, if NULL, GEANY_WORDCHARS will be used */
1617 static void read_current_word(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen,
1618 const gchar *wc, gboolean stem)
1619 {
1620 gint line, line_start, startword, endword;
1621 gchar *chunk;
1622 ScintillaObject *sci;
1623
1624 g_return_if_fail(editor != NULL);
1625 sci = editor->sci;
1626
1627 if (pos == -1)
1628 pos = sci_get_current_position(sci);
1629
1630 line = sci_get_line_from_position(sci, pos);
1631 line_start = sci_get_position_from_line(sci, line);
1632 startword = pos - line_start;
1633 endword = pos - line_start;
1634
1635 word[0] = '\0';
1636 chunk = sci_get_line(sci, line);
1637
1638 if (wc == NULL)
1639 wc = GEANY_WORDCHARS;
1640
1641 /* the checks for "c < 0" are to allow any Unicode character which should make the code
1642 * a little bit more Unicode safe, anyway, this allows also any Unicode punctuation,
1643 * TODO: improve this code */
1644 while (startword > 0 && (strchr(wc, chunk[startword - 1]) || ! IS_ASCII(chunk[startword - 1])))
1645 startword--;
1646 if (!stem)
1647 {
1648 while (chunk[endword] != 0 && (strchr(wc, chunk[endword]) || ! IS_ASCII(chunk[endword])))
1649 endword++;
1650 }
1651
1652 if (startword != endword)
1653 {
1654 chunk[endword] = '\0';
1655
1656 g_strlcpy(word, chunk + startword, wordlen); /* ensure null terminated */
1657 }
1658 else
1659 g_strlcpy(word, "", wordlen);
1660
1661 g_free(chunk);
1662 }
1663
1664
1665 /* Reads the word at given cursor position and writes it into the given buffer. The buffer will be
1666 * NULL terminated in any case, even when the word is truncated because wordlen is too small.
1667 * position can be -1, then the current position is used.
1668 * wc are the wordchars to use, if NULL, GEANY_WORDCHARS will be used */
1669 void editor_find_current_word(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen,
1670 const gchar *wc)
1671 {
1672 read_current_word(editor, pos, word, wordlen, wc, FALSE);
1673 }
1674
1675
1676 /* Same as editor_find_current_word() but uses editor's word boundaries to decide what the word
1677 * is. This should be used e.g. to get the word to search for */
1678 void editor_find_current_word_sciwc(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen)
1679 {
1680 gint start;
1681 gint end;
1682
1683 g_return_if_fail(editor != NULL);
1684
1685 if (pos == -1)
1686 pos = sci_get_current_position(editor->sci);
1687
1688 start = sci_word_start_position(editor->sci, pos, TRUE);
1689 end = sci_word_end_position(editor->sci, pos, TRUE);
1690
1691 if (start == end) /* caret in whitespaces sequence */
1692 *word = 0;
1693 else
1694 {
1695 if ((guint)(end - start) >= wordlen)
1696 end = start + (wordlen - 1);
1697 sci_get_text_range(editor->sci, start, end, word);
1698 }
1699 }
1700
1701
1702 /**
1703 * Finds the word at the position specified by @a pos. If any word is found, it is returned.
1704 * Otherwise NULL is returned.
1705 * Additional wordchars can be specified to define what to consider as a word.
1706 *
1707 * @param editor The editor to operate on.
1708 * @param pos The position where the word should be read from.
1709 * May be @c -1 to use the current position.
1710 * @param wordchars The wordchars to separate words. wordchars mean all characters to count
1711 * as part of a word. May be @c NULL to use the default wordchars,
1712 * see @ref GEANY_WORDCHARS.
1713 *
1714 * @return A newly-allocated string containing the word at the given @a pos or @c NULL.
1715 * Should be freed when no longer needed.
1716 *
1717 * @since 0.16
1718 */
1719 gchar *editor_get_word_at_pos(GeanyEditor *editor, gint pos, const gchar *wordchars)
1720 {
1721 static gchar cword[GEANY_MAX_WORD_LENGTH];
1722
1723 g_return_val_if_fail(editor != NULL, FALSE);
1724
1725 read_current_word(editor, pos, cword, sizeof(cword), wordchars, FALSE);
1726
1727 return (*cword == '\0') ? NULL : g_strdup(cword);
1728 }
1729
1730
1731 /* Read the word up to position @a pos. */
1732 static const gchar *
1733 editor_read_word_stem(GeanyEditor *editor, gint pos, const gchar *wordchars)
1734 {
1735 static gchar word[GEANY_MAX_WORD_LENGTH];
1736
1737 read_current_word(editor, pos, word, sizeof word, wordchars, TRUE);
1738
1739 return (*word) ? word : NULL;
1740 }
1741
1742
1743 static gint find_previous_brace(ScintillaObject *sci, gint pos)
1744 {
1745 gint orig_pos = pos;
1746
1747 while (pos >= 0 && pos > orig_pos - 300)
1748 {
1749 gchar c = sci_get_char_at(sci, pos);
1750 if (utils_is_opening_brace(c, editor_prefs.brace_match_ltgt))
1751 return pos;
1752 pos--;
1753 }
1754 return -1;
1755 }
1756
1757
1758 static gint find_start_bracket(ScintillaObject *sci, gint pos)
1759 {
1760 gint brackets = 0;
1761 gint orig_pos = pos;
1762
1763 while (pos > 0 && pos > orig_pos - 300)
1764 {
1765 gchar c = sci_get_char_at(sci, pos);
1766
1767 if (c == ')') brackets++;
1768 else if (c == '(') brackets--;
1769 if (brackets < 0) return pos; /* found start bracket */
1770 pos--;
1771 }
1772 return -1;
1773 }
1774
1775
1776 static gboolean append_calltip(GString *str, const TMTag *tag, filetype_id ft_id)
1777 {
1778 if (! tag->atts.entry.arglist)
1779 return FALSE;
1780
1781 if (ft_id != GEANY_FILETYPES_PASCAL)
1782 { /* usual calltips: "retval tagname (arglist)" */
1783 if (tag->atts.entry.var_type)
1784 {
1785 guint i;
1786
1787 g_string_append(str, tag->atts.entry.var_type);
1788 for (i = 0; i < tag->atts.entry.pointerOrder; i++)
1789 {
1790 g_string_append_c(str, '*');
1791 }
1792 g_string_append_c(str, ' ');
1793 }
1794 if (tag->atts.entry.scope)
1795 {
1796 const gchar *cosep = symbols_get_context_separator(ft_id);
1797
1798 g_string_append(str, tag->atts.entry.scope);
1799 g_string_append(str, cosep);
1800 }
1801 g_string_append(str, tag->name);
1802 g_string_append_c(str, ' ');
1803 g_string_append(str, tag->atts.entry.arglist);
1804 }
1805 else
1806 { /* special case Pascal calltips: "tagname (arglist) : retval" */
1807 g_string_append(str, tag->name);
1808 g_string_append_c(str, ' ');
1809 g_string_append(str, tag->atts.entry.arglist);
1810
1811 if (!EMPTY(tag->atts.entry.var_type))
1812 {
1813 g_string_append(str, " : ");
1814 g_string_append(str, tag->atts.entry.var_type);
1815 }
1816 }
1817
1818 return TRUE;
1819 }
1820
1821
1822 static gchar *find_calltip(const gchar *word, GeanyFiletype *ft)
1823 {
1824 const GPtrArray *tags;
1825 const gint arg_types = tm_tag_function_t | tm_tag_prototype_t |
1826 tm_tag_method_t | tm_tag_macro_with_arg_t;
1827 TMTagAttrType *attrs = NULL;
1828 TMTag *tag;
1829 GString *str = NULL;
1830 guint i;
1831
1832 g_return_val_if_fail(ft && word && *word, NULL);
1833
1834 /* use all types in case language uses wrong tag type e.g. python "members" instead of "methods" */
1835 tags = tm_workspace_find(word, tm_tag_max_t, attrs, FALSE, ft->lang);
1836 if (tags->len == 0)
1837 return NULL;
1838
1839 tag = TM_TAG(tags->pdata[0]);
1840
1841 if (ft->id == GEANY_FILETYPES_D &&
1842 (tag->type == tm_tag_class_t || tag->type == tm_tag_struct_t))
1843 {
1844 /* user typed e.g. 'new Classname(' so lookup D constructor Classname::this() */
1845 tags = tm_workspace_find_scoped("this", tag->name,
1846 arg_types, attrs, FALSE, ft->lang, TRUE);
1847 if (tags->len == 0)
1848 return NULL;
1849 }
1850
1851 /* remove tags with no argument list */
1852 for (i = 0; i < tags->len; i++)
1853 {
1854 tag = TM_TAG(tags->pdata[i]);
1855
1856 if (! tag->atts.entry.arglist)
1857 tags->pdata[i] = NULL;
1858 }
1859 tm_tags_prune((GPtrArray *) tags);
1860 if (tags->len == 0)
1861 return NULL;
1862 else
1863 { /* remove duplicate calltips */
1864 TMTagAttrType sort_attr[] = {tm_tag_attr_name_t, tm_tag_attr_scope_t,
1865 tm_tag_attr_arglist_t, 0};
1866
1867 tm_tags_sort((GPtrArray *) tags, sort_attr, TRUE);
1868 }
1869
1870 /* if the current word has changed since last time, start with the first tag match */
1871 if (! utils_str_equal(word, calltip.last_word))
1872 calltip.tag_index = 0;
1873 /* cache the current word for next time */
1874 g_free(calltip.last_word);
1875 calltip.last_word = g_strdup(word);
1876 calltip.tag_index = MIN(calltip.tag_index, tags->len - 1); /* ensure tag_index is in range */
1877
1878 for (i = calltip.tag_index; i < tags->len; i++)
1879 {
1880 tag = TM_TAG(tags->pdata[i]);
1881
1882 if (str == NULL)
1883 {
1884 str = g_string_new(NULL);
1885 if (calltip.tag_index > 0)
1886 g_string_prepend(str, "\001 "); /* up arrow */
1887 append_calltip(str, tag, FILETYPE_ID(ft));
1888 }
1889 else /* add a down arrow */
1890 {
1891 if (calltip.tag_index > 0) /* already have an up arrow */
1892 g_string_insert_c(str, 1, '\002');
1893 else
1894 g_string_prepend(str, "\002 ");
1895 break;
1896 }
1897 }
1898 if (str)
1899 {
1900 gchar *result = str->str;
1901
1902 g_string_free(str, FALSE);
1903 return result;
1904 }
1905 return NULL;
1906 }
1907
1908
1909 /* use pos = -1 to search for the previous unmatched open bracket. */
1910 gboolean editor_show_calltip(GeanyEditor *editor, gint pos)
1911 {
1912 gint orig_pos = pos; /* the position for the calltip */
1913 gint lexer;
1914 gint style;
1915 gchar word[GEANY_MAX_WORD_LENGTH];
1916 gchar *str;
1917 ScintillaObject *sci;
1918
1919 g_return_val_if_fail(editor != NULL, FALSE);
1920 g_return_val_if_fail(editor->document->file_type != NULL, FALSE);
1921
1922 sci = editor->sci;
1923
1924 lexer = sci_get_lexer(sci);
1925
1926 if (pos == -1)
1927 {
1928 /* position of '(' is unknown, so go backwards from current position to find it */
1929 pos = sci_get_current_position(sci);
1930 pos--;
1931 orig_pos = pos;
1932 pos = (lexer == SCLEX_LATEX) ? find_previous_brace(sci, pos) :
1933 find_start_bracket(sci, pos);
1934 if (pos == -1)
1935 return FALSE;
1936 }
1937
1938 /* the style 1 before the brace (which may be highlighted) */
1939 style = sci_get_style_at(sci, pos - 1);
1940 if (! highlighting_is_code_style(lexer, style))
1941 return FALSE;
1942
1943 word[0] = '\0';
1944 editor_find_current_word(editor, pos - 1, word, sizeof word, NULL);
1945 if (word[0] == '\0')
1946 return FALSE;
1947
1948 str = find_calltip(word, editor->document->file_type);
1949 if (str)
1950 {
1951 g_free(calltip.text); /* free the old calltip */
1952 calltip.text = str;
1953 calltip.pos = orig_pos;
1954 calltip.sci = sci;
1955 calltip.set = TRUE;
1956 utils_wrap_string(calltip.text, -1);
1957 SSM(sci, SCI_CALLTIPSHOW, orig_pos, (sptr_t) calltip.text);
1958 return TRUE;
1959 }
1960 return FALSE;
1961 }
1962
1963
1964 gchar *editor_get_calltip_text(GeanyEditor *editor, const TMTag *tag)
1965 {
1966 GString *str;
1967
1968 g_return_val_if_fail(editor != NULL, NULL);
1969
1970 str = g_string_new(NULL);
1971 if (append_calltip(str, tag, editor->document->file_type->id))
1972 return g_string_free(str, FALSE);
1973 else
1974 return g_string_free(str, TRUE);
1975 }
1976
1977
1978 /* HTML entities auto completion from html_entities.tags text file */
1979 static gboolean
1980 autocomplete_html(ScintillaObject *sci, const gchar *root, gsize rootlen)
1981 {
1982 guint i;
1983 gboolean found = FALSE;
1984 GString *words;
1985 const gchar **entities = symbols_get_html_entities();
1986
1987 if (*root != '&' || entities == NULL)
1988 return FALSE;
1989
1990 words = g_string_sized_new(500);
1991 for (i = 0; ; i++)
1992 {
1993 if (entities[i] == NULL)
1994 break;
1995 else if (entities[i][0] == '#')
1996 continue;
1997
1998 if (! strncmp(entities[i], root, rootlen))
1999 {
2000 if (words->len)
2001 g_string_append_c(words, '\n');
2002
2003 g_string_append(words, entities[i]);
2004 found = TRUE;
2005 }
2006 }
2007 if (found)
2008 show_autocomplete(sci, rootlen, words);
2009
2010 g_string_free(words, TRUE);
2011 return found;
2012 }
2013
2014
2015 /* Current document & global tags autocompletion */
2016 static gboolean
2017 autocomplete_tags(GeanyEditor *editor, const gchar *root, gsize rootlen)
2018 {
2019 TMTagAttrType attrs[] = { tm_tag_attr_name_t, 0 };
2020 const GPtrArray *tags;
2021 GeanyDocument *doc;
2022
2023 g_return_val_if_fail(editor, FALSE);
2024
2025 doc = editor->document;
2026
2027 tags = tm_workspace_find(root, tm_tag_max_t, attrs, TRUE, doc->file_type->lang);
2028 if (tags)
2029 {
2030 show_tags_list(editor, tags, rootlen);
2031 return tags->len > 0;
2032 }
2033 return FALSE;
2034 }
2035
2036
2037 static gboolean autocomplete_check_html(GeanyEditor *editor, gint style, gint pos)
2038 {
2039 GeanyFiletype *ft = editor->document->file_type;
2040 gboolean try = FALSE;
2041
2042 /* use entity completion when style is not JavaScript, ASP, Python, PHP, ...
2043 * (everything after SCE_HJ_START is for embedded scripting languages) */
2044 if (ft->id == GEANY_FILETYPES_HTML && style < SCE_HJ_START)
2045 try = TRUE;
2046 else if (sci_get_lexer(editor->sci) == SCLEX_XML && style < SCE_HJ_START)
2047 try = TRUE;
2048 else if (ft->id == GEANY_FILETYPES_PHP)
2049 {
2050 /* use entity completion when style is outside of PHP styles */
2051 if (! is_style_php(style))
2052 try = TRUE;
2053 }
2054 if (try)
2055 {
2056 gchar root[GEANY_MAX_WORD_LENGTH];
2057 gchar *tmp;
2058
2059 read_current_word(editor, pos, root, sizeof(root), GEANY_WORDCHARS"&", TRUE);
2060
2061 /* Allow something like "&quot;some text&quot;".
2062 * for entity completion we want to have completion for '&' within words. */
2063 tmp = strchr(root, '&');
2064 if (tmp != NULL)
2065 {
2066 return autocomplete_html(editor->sci, tmp, strlen(tmp));
2067 }
2068 }
2069 return FALSE;
2070 }
2071
2072
2073 /* Algorithm based on based on Scite's StartAutoCompleteWord()
2074 * @returns a sorted list of words matching @p root */
2075 static GSList *get_doc_words(ScintillaObject *sci, gchar *root, gsize rootlen)
2076 {
2077 gchar *word;
2078 gint len, current, word_end;
2079 gint pos_find, flags;
2080 guint word_length;
2081 gsize nmatches = 0;
2082 GSList *words = NULL;
2083 struct Sci_TextToFind ttf;
2084
2085 len = sci_get_length(sci);
2086 current = sci_get_current_position(sci) - rootlen;
2087
2088 ttf.lpstrText = root;
2089 ttf.chrg.cpMin = 0;
2090 ttf.chrg.cpMax = len;
2091 ttf.chrgText.cpMin = 0;
2092 ttf.chrgText.cpMax = 0;
2093 flags = SCFIND_WORDSTART | SCFIND_MATCHCASE;
2094
2095 /* search the whole document for the word root and collect results */
2096 pos_find = scintilla_send_message(sci, SCI_FINDTEXT, flags, (uptr_t) &ttf);
2097 while (pos_find >= 0 && pos_find < len)
2098 {
2099 word_end = pos_find + rootlen;
2100 if (pos_find != current)
2101 {
2102 word_end = sci_word_end_position(sci, word_end, TRUE);
2103
2104 word_length = word_end - pos_find;
2105 if (word_length > rootlen)
2106 {
2107 word = sci_get_contents_range(sci, pos_find, word_end);
2108 /* search whether we already have the word in, otherwise add it */
2109 if (g_slist_find_custom(words, word, (GCompareFunc)strcmp) != NULL)
2110 g_free(word);
2111 else
2112 {
2113 words = g_slist_prepend(words, word);
2114 nmatches++;
2115 }
2116
2117 if (nmatches == editor_prefs.autocompletion_max_entries)
2118 break;
2119 }
2120 }
2121 ttf.chrg.cpMin = word_end;
2122 pos_find = scintilla_send_message(sci, SCI_FINDTEXT, flags, (uptr_t) &ttf);
2123 }
2124
2125 return g_slist_sort(words, (GCompareFunc)utils_str_casecmp);
2126 }
2127
2128
2129 static gboolean autocomplete_doc_word(GeanyEditor *editor, gchar *root, gsize rootlen)
2130 {
2131 ScintillaObject *sci = editor->sci;
2132 GSList *words, *node;
2133 GString *str;
2134 guint n_words = 0;
2135
2136 words = get_doc_words(sci, root, rootlen);
2137 if (!words)
2138 {
2139 scintilla_send_message(sci, SCI_AUTOCCANCEL, 0, 0);
2140 return FALSE;
2141 }
2142
2143 str = g_string_sized_new(rootlen * 2 * 10);
2144 foreach_slist(node, words)
2145 {
2146 g_string_append(str, node->data);
2147 g_free(node->data);
2148 if (node->next)
2149 g_string_append_c(str, '\n');
2150 n_words++;
2151 }
2152 if (n_words >= editor_prefs.autocompletion_max_entries)
2153 g_string_append(str, "\n...");
2154
2155 g_slist_free(words);
2156
2157 show_autocomplete(sci, rootlen, str);
2158 g_string_free(str, TRUE);
2159 return TRUE;
2160 }
2161
2162
2163 gboolean editor_start_auto_complete(GeanyEditor *editor, gint pos, gboolean force)
2164 {
2165 gint rootlen, lexer, style;
2166 gchar *root;
2167 gchar cword[GEANY_MAX_WORD_LENGTH];
2168 ScintillaObject *sci;
2169 gboolean ret = FALSE;
2170 const gchar *wordchars;
2171 GeanyFiletype *ft;
2172
2173 g_return_val_if_fail(editor != NULL, FALSE);
2174
2175 if (! editor_prefs.auto_complete_symbols && ! force)
2176 return FALSE;
2177
2178 /* If we are at the beginning of the document, we skip autocompletion as we can't determine the
2179 * necessary styling information */
2180 if (G_UNLIKELY(pos < 2))
2181 return FALSE;
2182
2183 sci = editor->sci;
2184 ft = editor->document->file_type;
2185
2186 lexer = sci_get_lexer(sci);
2187 style = sci_get_style_at(sci, pos - 2);
2188
2189 /* don't autocomplete in comments and strings */
2190 if (!force && !highlighting_is_code_style(lexer, style))
2191 return FALSE;
2192
2193 autocomplete_scope(editor);
2194 ret = autocomplete_check_html(editor, style, pos);
2195
2196 if (ft->id == GEANY_FILETYPES_LATEX)
2197 wordchars = GEANY_WORDCHARS"\\"; /* add \ to word chars if we are in a LaTeX file */
2198 else if (ft->id == GEANY_FILETYPES_CSS)
2199 wordchars = GEANY_WORDCHARS"-"; /* add - because they are part of property names */
2200 else
2201 wordchars = GEANY_WORDCHARS;
2202
2203 read_current_word(editor, pos, cword, sizeof(cword), wordchars, TRUE);
2204 root = cword;
2205 rootlen = strlen(root);
2206
2207 if (!ret && rootlen > 0)
2208 {
2209 if (ft->id == GEANY_FILETYPES_PHP && style == SCE_HPHP_DEFAULT &&
2210 rootlen == 3 && strcmp(root, "php") == 0 && pos >= 5 &&
2211 sci_get_char_at(sci, pos - 5) == '<' &&
2212 sci_get_char_at(sci, pos - 4) == '?')
2213 {
2214 /* nothing, don't complete PHP open tags */
2215 }
2216 else
2217 {
2218 /* force is set when called by keyboard shortcut, otherwise start at the
2219 * editor_prefs.symbolcompletion_min_chars'th char */
2220 if (force || rootlen >= editor_prefs.symbolcompletion_min_chars)
2221 {
2222 /* complete tags, except if forcing when completion is already visible */
2223 if (!(force && SSM(sci, SCI_AUTOCACTIVE, 0, 0)))
2224 ret = autocomplete_tags(editor, root, rootlen);
2225
2226 /* If forcing and there's nothing else to show, complete from words in document */
2227 if (!ret && (force || editor_prefs.autocomplete_doc_words))
2228 ret = autocomplete_doc_word(editor, root, rootlen);
2229 }
2230 }
2231 }
2232 if (!ret && force)
2233 utils_beep();
2234
2235 return ret;
2236 }
2237
2238
2239 static const gchar *snippets_find_completion_by_name(const gchar *type, const gchar *name)
2240 {
2241 gchar *result = NULL;
2242 GHashTable *tmp;
2243
2244 g_return_val_if_fail(type != NULL && name != NULL, NULL);
2245
2246 tmp = g_hash_table_lookup(snippet_hash, type);
2247 if (tmp != NULL)
2248 {
2249 result = g_hash_table_lookup(tmp, name);
2250 }
2251 /* whether nothing is set for the current filetype(tmp is NULL) or
2252 * the particular completion for this filetype is not set (result is NULL) */
2253 if (tmp == NULL || result == NULL)
2254 {
2255 tmp = g_hash_table_lookup(snippet_hash, "Default");
2256 if (tmp != NULL)
2257 {
2258 result = g_hash_table_lookup(tmp, name);
2259 }
2260 }
2261 /* if result is still NULL here, no completion could be found */
2262
2263 /* result is owned by the hash table and will be freed when the table will destroyed */
2264 return result;
2265 }
2266
2267
2268 static void snippets_replace_specials(gpointer key, gpointer value, gpointer user_data)
2269 {
2270 gchar *needle;
2271 GString *pattern = user_data;
2272
2273 g_return_if_fail(key != NULL);
2274 g_return_if_fail(value != NULL);
2275
2276 needle = g_strconcat("%", (gchar*) key, "%", NULL);
2277
2278 utils_string_replace_all(pattern, needle, (gchar*) value);
2279 g_free(needle);
2280 }
2281
2282
2283 static void fix_indentation(GeanyEditor *editor, GString *buf)
2284 {
2285 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
2286 gchar *whitespace;
2287 GRegex *regex;
2288 gint cflags = G_REGEX_MULTILINE;
2289
2290 /* transform leading tabs into indent widths (in spaces) */
2291 whitespace = g_strnfill(iprefs->width, ' ');
2292 regex = g_regex_new("^ *(\t)", cflags, 0, NULL);
2293 while (utils_string_regex_replace_all(buf, regex, 1, whitespace, TRUE));
2294 g_regex_unref(regex);
2295
2296 /* remaining tabs are for alignment */
2297 if (iprefs->type != GEANY_INDENT_TYPE_TABS)
2298 utils_string_replace_all(buf, "\t", whitespace);
2299
2300 /* use leading tabs */
2301 if (iprefs->type != GEANY_INDENT_TYPE_SPACES)
2302 {
2303 gchar *str;
2304
2305 /* for tabs+spaces mode we want the real tab width, not indent width */
2306 SETPTR(whitespace, g_strnfill(sci_get_tab_width(editor->sci), ' '));
2307 str = g_strdup_printf("^\t*(%s)", whitespace);
2308
2309 regex = g_regex_new(str, cflags, 0, NULL);
2310 while (utils_string_regex_replace_all(buf, regex, 1, "\t", TRUE));
2311 g_regex_unref(regex);
2312 g_free(str);
2313 }
2314 g_free(whitespace);
2315 }
2316
2317
2318 /** Inserts text, replacing \\t tab chars (@c 0x9) and \\n newline chars (@c 0xA)
2319 * accordingly for the document.
2320 * - Leading tabs are replaced with the correct indentation.
2321 * - Non-leading tabs are replaced with spaces (except when using 'Tabs' indent type).
2322 * - Newline chars are replaced with the correct line ending string.
2323 * This is very useful for inserting code without having to handle the indent
2324 * type yourself (Tabs & Spaces mode can be tricky).
2325 * @param editor Editor.
2326 * @param text Intended as e.g. @c "if (foo)\n\tbar();".
2327 * @param insert_pos Document position to insert text at.
2328 * @param cursor_index If >= 0, the index into @a text to place the cursor.
2329 * @param newline_indent_size Indentation size (in spaces) to insert for each newline; use
2330 * -1 to read the indent size from the line with @a insert_pos on it.
2331 * @param replace_newlines Whether to replace newlines. If
2332 * newlines have been replaced already, this should be false, to avoid errors e.g. on Windows.
2333 * @warning Make sure all \\t tab chars in @a text are intended as indent widths or alignment,
2334 * not hard tabs, as those won't be preserved.
2335 * @note This doesn't scroll the cursor in view afterwards. **/
2336 void editor_insert_text_block(GeanyEditor *editor, const gchar *text, gint insert_pos,
2337 gint cursor_index, gint newline_indent_size, gboolean replace_newlines)
2338 {
2339 ScintillaObject *sci = editor->sci;
2340 gint line_start = sci_get_line_from_position(sci, insert_pos);
2341 GString *buf;
2342 const gchar *eol = editor_get_eol_char(editor);
2343 gint idx;
2344
2345 g_return_if_fail(text);
2346 g_return_if_fail(editor != NULL);
2347 g_return_if_fail(insert_pos >= 0);
2348
2349 buf = g_string_new(text);
2350
2351 if (cursor_index >= 0)
2352 g_string_insert(buf, cursor_index, geany_cursor_marker); /* remember cursor pos */
2353
2354 if (newline_indent_size == -1)
2355 {
2356 /* count indent size up to insert_pos instead of asking sci
2357 * because there may be spaces after it */
2358 gchar *tmp = sci_get_line(sci, line_start);
2359
2360 idx = insert_pos - sci_get_position_from_line(sci, line_start);
2361 tmp[idx] = '\0';
2362 newline_indent_size = count_indent_size(editor, tmp);
2363 g_free(tmp);
2364 }
2365
2366 /* Add line indents (in spaces) */
2367 if (newline_indent_size > 0)
2368 {
2369 const gchar *nl = replace_newlines ? "\n" : eol;
2370 gchar *whitespace;
2371
2372 whitespace = g_strnfill(newline_indent_size, ' ');
2373 SETPTR(whitespace, g_strconcat(nl, whitespace, NULL));
2374 utils_string_replace_all(buf, nl, whitespace);
2375 g_free(whitespace);
2376 }
2377
2378 /* transform line endings */
2379 if (replace_newlines)
2380 utils_string_replace_all(buf, "\n", eol);
2381
2382 fix_indentation(editor, buf);
2383
2384 idx = replace_cursor_markers(editor, buf);
2385 if (idx >= 0)
2386 {
2387 sci_insert_text(sci, insert_pos, buf->str);
2388 sci_set_current_position(sci, insert_pos + idx, FALSE);
2389 }
2390 else
2391 sci_insert_text(sci, insert_pos, buf->str);
2392
2393 snippet_cursor_insert_pos = sci_get_current_position(sci);
2394
2395 g_string_free(buf, TRUE);
2396 }
2397
2398
2399 /* Move the cursor to the next specified cursor position in an inserted snippet.
2400 * Can, and should, be optimized to give better results */
2401 void editor_goto_next_snippet_cursor(GeanyEditor *editor)
2402 {
2403 ScintillaObject *sci = editor->sci;
2404 gint current_pos = sci_get_current_position(sci);
2405
2406 if (snippet_offsets && !g_queue_is_empty(snippet_offsets))
2407 {
2408 gint offset;
2409
2410 offset = GPOINTER_TO_INT(g_queue_pop_head(snippet_offsets));
2411 if (current_pos > snippet_cursor_insert_pos)
2412 snippet_cursor_insert_pos = offset + current_pos;
2413 else
2414 snippet_cursor_insert_pos += offset;
2415
2416 sci_set_current_position(sci, snippet_cursor_insert_pos, TRUE);
2417 }
2418 else
2419 {
2420 utils_beep();
2421 }
2422 }
2423
2424
2425 static void snippets_make_replacements(GeanyEditor *editor, GString *pattern)
2426 {
2427 GHashTable *specials;
2428
2429 /* replace 'special' completions */
2430 specials = g_hash_table_lookup(snippet_hash, "Special");
2431 if (G_LIKELY(specials != NULL))
2432 {
2433 g_hash_table_foreach(specials, snippets_replace_specials, pattern);
2434 }
2435
2436 /* now transform other wildcards */
2437 utils_string_replace_all(pattern, "%newline%", "\n");
2438 utils_string_replace_all(pattern, "%ws%", "\t");
2439
2440 /* replace %cursor% by a very unlikely string marker */
2441 utils_string_replace_all(pattern, "%cursor%", geany_cursor_marker);
2442
2443 /* unescape '%' after all %wildcards% */
2444 templates_replace_valist(pattern, "{pc}", "%", NULL);
2445
2446 /* replace any template {foo} wildcards */
2447 templates_replace_common(pattern, editor->document->file_name, editor->document->file_type, NULL);
2448 }
2449
2450
2451 static gssize replace_cursor_markers(GeanyEditor *editor, GString *pattern)
2452 {
2453 gssize cur_index = -1;
2454 gint i;
2455 GList *temp_list = NULL;
2456 gint cursor_steps = 0, old_cursor = 0;
2457
2458 i = 0;
2459 while (1)
2460 {
2461 cursor_steps = utils_string_find(pattern, cursor_steps, -1, geany_cursor_marker);
2462 if (cursor_steps == -1)
2463 break;
2464
2465 g_string_erase(pattern, cursor_steps, strlen(geany_cursor_marker));
2466
2467 if (i++ > 0)
2468 {
2469 /* save the relative offset to each cursor position */
2470 temp_list = g_list_prepend(temp_list, GINT_TO_POINTER(cursor_steps - old_cursor));
2471 }
2472 else
2473 {
2474 /* first cursor already includes newline positions */
2475 cur_index = cursor_steps;
2476 }
2477 old_cursor = cursor_steps;
2478 }
2479
2480 /* put the cursor positions for the most recent
2481 * parsed snippet first, followed by any remaining positions */
2482 i = 0;
2483 if (temp_list)
2484 {
2485 GList *node;
2486
2487 temp_list = g_list_reverse(temp_list);
2488 foreach_list(node, temp_list)
2489 g_queue_push_nth(snippet_offsets, node->data, i++);
2490
2491 /* limit length of queue */
2492 while (g_queue_get_length(snippet_offsets) > 20)
2493 g_queue_pop_tail(snippet_offsets);
2494
2495 g_list_free(temp_list);
2496 }
2497 /* if there's no first cursor, skip whole snippet */
2498 if (cur_index < 0)
2499 cur_index = pattern->len;
2500
2501 return cur_index;
2502 }
2503
2504
2505 static gboolean snippets_complete_constructs(GeanyEditor *editor, gint pos, const gchar *word)
2506 {
2507 ScintillaObject *sci = editor->sci;
2508 gchar *str;
2509 const gchar *completion;
2510 gint str_len;
2511 gint ft_id = editor->document->file_type->id;
2512
2513 str = g_strdup(word);
2514 g_strstrip(str);
2515
2516 completion = snippets_find_completion_by_name(filetypes[ft_id]->name, str);
2517 if (completion == NULL)
2518 {
2519 g_free(str);
2520 return FALSE;
2521 }
2522
2523 /* remove the typed word, it will be added again by the used auto completion
2524 * (not really necessary but this makes the auto completion more flexible,
2525 * e.g. with a completion like hi=hello, so typing "hi<TAB>" will result in "hello") */
2526 str_len = strlen(str);
2527 sci_set_selection_start(sci, pos - str_len);
2528 sci_set_selection_end(sci, pos);
2529 sci_replace_sel(sci, "");
2530 pos -= str_len; /* pos has changed while deleting */
2531
2532 editor_insert_snippet(editor, pos, completion);
2533 sci_scroll_caret(sci);
2534
2535 g_free(str);
2536 return TRUE;
2537 }
2538
2539
2540 static gboolean at_eol(ScintillaObject *sci, gint pos)
2541 {
2542 gint line = sci_get_line_from_position(sci, pos);
2543 gchar c;
2544
2545 /* skip any trailing spaces */
2546 while (TRUE)
2547 {
2548 c = sci_get_char_at(sci, pos);
2549 if (c == ' ' || c == '\t')
2550 pos++;
2551 else
2552 break;
2553 }
2554
2555 return (pos == sci_get_line_end_position(sci, line));
2556 }
2557
2558
2559 gboolean editor_complete_snippet(GeanyEditor *editor, gint pos)
2560 {
2561 gboolean result = FALSE;
2562 const gchar *wc;
2563 const gchar *word;
2564 ScintillaObject *sci;
2565
2566 g_return_val_if_fail(editor != NULL, FALSE);
2567
2568 sci = editor->sci;
2569 if (sci_has_selection(sci))
2570 return FALSE;
2571 /* return if we are editing an existing line (chars on right of cursor) */
2572 if (keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
2573 GEANY_KEYS_EDITOR_COMPLETESNIPPET)->key == GDK_space &&
2574 ! editor_prefs.complete_snippets_whilst_editing && ! at_eol(sci, pos))
2575 return FALSE;
2576
2577 wc = snippets_find_completion_by_name("Special", "wordchars");
2578 word = editor_read_word_stem(editor, pos, wc);
2579
2580 /* prevent completion of "for " */
2581 if (!EMPTY(word) &&
2582 ! isspace(sci_get_char_at(sci, pos - 1))) /* pos points to the line end char so use pos -1 */
2583 {
2584 sci_start_undo_action(sci); /* needed because we insert a space separately from construct */
2585 result = snippets_complete_constructs(editor, pos, word);
2586 sci_end_undo_action(sci);
2587 if (result)
2588 sci_cancel(sci); /* cancel any autocompletion list, etc */
2589 }
2590 return result;
2591 }
2592
2593
2594 void editor_show_macro_list(GeanyEditor *editor)
2595 {
2596 GString *words;
2597
2598 if (editor == NULL || editor->document->file_type == NULL)
2599 return;
2600
2601 words = symbols_get_macro_list(editor->document->file_type->lang);
2602 if (words == NULL)
2603 return;
2604
2605 SSM(editor->sci, SCI_USERLISTSHOW, 1, (sptr_t) words->str);
2606 g_string_free(words, TRUE);
2607 }
2608
2609
2610 static void insert_closing_tag(GeanyEditor *editor, gint pos, gchar ch, const gchar *tag_name)
2611 {
2612 ScintillaObject *sci = editor->sci;
2613 gchar *to_insert = NULL;
2614
2615 if (ch == '/')
2616 {
2617 const gchar *gt = ">";
2618 /* if there is already a '>' behind the cursor, don't add it */
2619 if (sci_get_char_at(sci, pos) == '>')
2620 gt = "";
2621
2622 to_insert = g_strconcat(tag_name, gt, NULL);
2623 }
2624 else
2625 to_insert = g_strconcat("</", tag_name, ">", NULL);
2626
2627 sci_start_undo_action(sci);
2628 sci_replace_sel(sci, to_insert);
2629 if (ch == '>')
2630 sci_set_selection(sci, pos, pos);
2631 sci_end_undo_action(sci);
2632 g_free(to_insert);
2633 }
2634
2635
2636 /*
2637 * (stolen from anjuta and heavily modified)
2638 * This routine will auto complete XML or HTML tags that are still open by closing them
2639 * @param ch The character we are dealing with, currently only works with the '>' character
2640 * @return True if handled, false otherwise
2641 */
2642 static gboolean handle_xml(GeanyEditor *editor, gint pos, gchar ch)
2643 {
2644 ScintillaObject *sci = editor->sci;
2645 gint lexer = sci_get_lexer(sci);
2646 gint min, size, style;
2647 gchar *str_found, sel[512];
2648 gboolean result = FALSE;
2649
2650 /* If the user has turned us off, quit now.
2651 * This may make sense only in certain languages */
2652 if (! editor_prefs.auto_close_xml_tags || (lexer != SCLEX_HTML && lexer != SCLEX_XML))
2653 return FALSE;
2654
2655 /* return if we are inside any embedded script */
2656 style = sci_get_style_at(sci, pos);
2657 if (style > SCE_H_XCCOMMENT && ! highlighting_is_string_style(lexer, style))
2658 return FALSE;
2659
2660 /* if ch is /, check for </, else quit */
2661 if (ch == '/' && sci_get_char_at(sci, pos - 2) != '<')
2662 return FALSE;
2663
2664 /* Grab the last 512 characters or so */
2665 min = pos - (sizeof(sel) - 1);
2666 if (min < 0) min = 0;
2667
2668 if (pos - min < 3)
2669 return FALSE; /* Smallest tag is 3 characters e.g. <p> */
2670
2671 sci_get_text_range(sci, min, pos, sel);
2672 sel[sizeof(sel) - 1] = '\0';
2673
2674 if (ch == '>' && sel[pos - min - 2] == '/')
2675 /* User typed something like "<br/>" */
2676 return FALSE;
2677
2678 size = pos - min;
2679 if (ch == '/')
2680 size -= 2; /* skip </ */
2681 str_found = utils_find_open_xml_tag(sel, size);
2682
2683 if (lexer == SCLEX_HTML && utils_is_short_html_tag(str_found))
2684 {
2685 /* ignore tag */
2686 }
2687 else if (!EMPTY(str_found))
2688 {
2689 insert_closing_tag(editor, pos, ch, str_found);
2690 result = TRUE;
2691 }
2692 g_free(str_found);
2693 return result;
2694 }
2695
2696
2697 /* like sci_get_line_indentation(), but for a string. */
2698 static gsize count_indent_size(GeanyEditor *editor, const gchar *base_indent)
2699 {
2700 const gchar *ptr;
2701 gsize tab_size = sci_get_tab_width(editor->sci);
2702 gsize count = 0;
2703
2704 g_return_val_if_fail(base_indent, 0);
2705
2706 for (ptr = base_indent; *ptr != 0; ptr++)
2707 {
2708 switch (*ptr)
2709 {
2710 case ' ':
2711 count++;
2712 break;
2713 case '\t':
2714 count += tab_size;
2715 break;
2716 default:
2717 return count;
2718 }
2719 }
2720 return count;
2721 }
2722
2723
2724 /* Handles special cases where HTML is embedded in another language or
2725 * another language is embedded in HTML */
2726 static GeanyFiletype *editor_get_filetype_at_line(GeanyEditor *editor, gint line)
2727 {
2728 gint style, line_start;
2729 GeanyFiletype *current_ft;
2730
2731 g_return_val_if_fail(editor != NULL, NULL);
2732 g_return_val_if_fail(editor->document->file_type != NULL, NULL);
2733
2734 current_ft = editor->document->file_type;
2735 line_start = sci_get_position_from_line(editor->sci, line);
2736 style = sci_get_style_at(editor->sci, line_start);
2737
2738 /* Handle PHP filetype with embedded HTML */
2739 if (current_ft->id == GEANY_FILETYPES_PHP && ! is_style_php(style))
2740 current_ft = filetypes[GEANY_FILETYPES_HTML];
2741
2742 /* Handle languages embedded in HTML */
2743 if (current_ft->id == GEANY_FILETYPES_HTML)
2744 {
2745 /* Embedded JS */
2746 if (style >= SCE_HJ_DEFAULT && style <= SCE_HJ_REGEX)
2747 current_ft = filetypes[GEANY_FILETYPES_JS];
2748 /* ASP JS */
2749 else if (style >= SCE_HJA_DEFAULT && style <= SCE_HJA_REGEX)
2750 current_ft = filetypes[GEANY_FILETYPES_JS];
2751 /* Embedded VB */
2752 else if (style >= SCE_HB_DEFAULT && style <= SCE_HB_STRINGEOL)
2753 current_ft = filetypes[GEANY_FILETYPES_BASIC];
2754 /* ASP VB */
2755 else if (style >= SCE_HBA_DEFAULT && style <= SCE_HBA_STRINGEOL)
2756 current_ft = filetypes[GEANY_FILETYPES_BASIC];
2757 /* Embedded Python */
2758 else if (style >= SCE_HP_DEFAULT && style <= SCE_HP_IDENTIFIER)
2759 current_ft = filetypes[GEANY_FILETYPES_PYTHON];
2760 /* ASP Python */
2761 else if (style >= SCE_HPA_DEFAULT && style <= SCE_HPA_IDENTIFIER)
2762 current_ft = filetypes[GEANY_FILETYPES_PYTHON];
2763 /* Embedded PHP */
2764 else if ((style >= SCE_HPHP_DEFAULT && style <= SCE_HPHP_OPERATOR) ||
2765 style == SCE_HPHP_COMPLEX_VARIABLE)
2766 {
2767 current_ft = filetypes[GEANY_FILETYPES_PHP];
2768 }
2769 }
2770
2771 /* Ensure the filetype's config is loaded */
2772 filetypes_load_config(current_ft->id, FALSE);
2773
2774 return current_ft;
2775 }
2776
2777
2778 static void real_comment_multiline(GeanyEditor *editor, gint line_start, gint last_line)
2779 {
2780 const gchar *eol;
2781 gchar *str_begin, *str_end;
2782 const gchar *co, *cc;
2783 gint line_len;
2784 GeanyFiletype *ft;
2785
2786 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
2787
2788 ft = editor_get_filetype_at_line(editor, line_start);
2789
2790 eol = editor_get_eol_char(editor);
2791 if (! filetype_get_comment_open_close(ft, FALSE, &co, &cc))
2792 g_return_if_reached();
2793 str_begin = g_strdup_printf("%s%s", (co != NULL) ? co : "", eol);
2794 str_end = g_strdup_printf("%s%s", (cc != NULL) ? cc : "", eol);
2795
2796 /* insert the comment strings */
2797 sci_insert_text(editor->sci, line_start, str_begin);
2798 line_len = sci_get_position_from_line(editor->sci, last_line + 2);
2799 sci_insert_text(editor->sci, line_len, str_end);
2800
2801 g_free(str_begin);
2802 g_free(str_end);
2803 }
2804
2805
2806 /* find @p text inside the range of the current style */
2807 static gint find_in_current_style(ScintillaObject *sci, const gchar *text, gboolean backwards)
2808 {
2809 gint start = sci_get_current_position(sci);
2810 gint end = start;
2811 gint len = sci_get_length(sci);
2812 gint current_style = sci_get_style_at(sci, start);
2813 struct Sci_TextToFind ttf;
2814
2815 while (start > 0 && sci_get_style_at(sci, start - 1) == current_style)
2816 start -= 1;
2817 while (end < len && sci_get_style_at(sci, end + 1) == current_style)
2818 end += 1;
2819
2820 ttf.lpstrText = (gchar*) text;
2821 ttf.chrg.cpMin = backwards ? end + 1 : start;
2822 ttf.chrg.cpMax = backwards ? start : end + 1;
2823 return sci_find_text(sci, 0, &ttf);
2824 }
2825
2826
2827 static void sci_delete_line(ScintillaObject *sci, gint line)
2828 {
2829 gint start = sci_get_position_from_line(sci, line);
2830 gint len = sci_get_line_length(sci, line);
2831 SSM(sci, SCI_DELETERANGE, start, len);
2832 }
2833
2834
2835 static gboolean real_uncomment_multiline(GeanyEditor *editor)
2836 {
2837 /* find the beginning of the multi line comment */
2838 gint start, end, start_line, end_line;
2839 GeanyFiletype *ft;
2840 const gchar *co, *cc;
2841
2842 g_return_val_if_fail(editor != NULL && editor->document->file_type != NULL, FALSE);
2843
2844 ft = editor_get_filetype_at_line(editor, sci_get_current_line(editor->sci));
2845 if (! filetype_get_comment_open_close(ft, FALSE, &co, &cc))
2846 g_return_val_if_reached(FALSE);
2847
2848 start = find_in_current_style(editor->sci, co, TRUE);
2849 end = find_in_current_style(editor->sci, cc, FALSE);
2850
2851 if (start < 0 || end < 0 || start > end /* who knows */)
2852 return FALSE;
2853
2854 start_line = sci_get_line_from_position(editor->sci, start);
2855 end_line = sci_get_line_from_position(editor->sci, end);
2856
2857 /* remove comment close chars */
2858 SSM(editor->sci, SCI_DELETERANGE, end, strlen(cc));
2859 if (sci_is_blank_line(editor->sci, end_line))
2860 sci_delete_line(editor->sci, end_line);
2861
2862 /* remove comment open chars (do it last since it would move the end position) */
2863 SSM(editor->sci, SCI_DELETERANGE, start, strlen(co));
2864 if (sci_is_blank_line(editor->sci, start_line))
2865 sci_delete_line(editor->sci, start_line);
2866
2867 return TRUE;
2868 }
2869
2870
2871 static gint get_multiline_comment_style(GeanyEditor *editor, gint line_start)
2872 {
2873 gint lexer = sci_get_lexer(editor->sci);
2874 gint style_comment;
2875
2876 /* List only those lexers which support multi line comments */
2877 switch (lexer)
2878 {
2879 case SCLEX_XML:
2880 case SCLEX_HTML:
2881 {
2882 if (is_style_php(sci_get_style_at(editor->sci, line_start)))
2883 style_comment = SCE_HPHP_COMMENT;
2884 else
2885 style_comment = SCE_H_COMMENT;
2886 break;
2887 }
2888 case SCLEX_HASKELL:
2889 case SCLEX_LITERATEHASKELL:
2890 style_comment = SCE_HA_COMMENTBLOCK; break;
2891 case SCLEX_LUA: style_comment = SCE_LUA_COMMENT; break;
2892 case SCLEX_CSS: style_comment = SCE_CSS_COMMENT; break;
2893 case SCLEX_SQL: style_comment = SCE_SQL_COMMENT; break;
2894 case SCLEX_CAML: style_comment = SCE_CAML_COMMENT; break;
2895 case SCLEX_D: style_comment = SCE_D_COMMENT; break;
2896 case SCLEX_PASCAL: style_comment = SCE_PAS_COMMENT; break;
2897 case SCLEX_RUST: style_comment = SCE_RUST_COMMENTBLOCK; break;
2898 default: style_comment = SCE_C_COMMENT;
2899 }
2900
2901 return style_comment;
2902 }
2903
2904
2905 /* set toggle to TRUE if the caller is the toggle function, FALSE otherwise
2906 * returns the amount of uncommented single comment lines, in case of multi line uncomment
2907 * it returns just 1 */
2908 gint editor_do_uncomment(GeanyEditor *editor, gint line, gboolean toggle)
2909 {
2910 gint first_line, last_line;
2911 gint x, i, line_start, line_len;
2912 gint sel_start, sel_end;
2913 gint count = 0;
2914 gsize co_len;
2915 gchar sel[256];
2916 const gchar *co, *cc;
2917 gboolean single_line = FALSE;
2918 GeanyFiletype *ft;
2919
2920 g_return_val_if_fail(editor != NULL && editor->document->file_type != NULL, 0);
2921
2922 if (line < 0)
2923 { /* use selection or current line */
2924 sel_start = sci_get_selection_start(editor->sci);
2925 sel_end = sci_get_selection_end(editor->sci);
2926
2927 first_line = sci_get_line_from_position(editor->sci, sel_start);
2928 /* Find the last line with chars selected (not EOL char) */
2929 last_line = sci_get_line_from_position(editor->sci,
2930 sel_end - editor_get_eol_char_len(editor));
2931 last_line = MAX(first_line, last_line);
2932 }
2933 else
2934 {
2935 first_line = last_line = line;
2936 sel_start = sel_end = sci_get_position_from_line(editor->sci, line);
2937 }
2938
2939 ft = editor_get_filetype_at_line(editor, first_line);
2940
2941 if (! filetype_get_comment_open_close(ft, TRUE, &co, &cc))
2942 return 0;
2943
2944 co_len = strlen(co);
2945 if (co_len == 0)
2946 return 0;
2947
2948 sci_start_undo_action(editor->sci);
2949
2950 for (i = first_line; i <= last_line; i++)
2951 {
2952 gint buf_len;
2953
2954 line_start = sci_get_position_from_line(editor->sci, i);
2955 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
2956 x = 0;
2957
2958 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
2959 if (buf_len <= 0)
2960 continue;
2961 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
2962 sel[buf_len] = '\0';
2963
2964 while (isspace(sel[x])) x++;
2965
2966 /* to skip blank lines */
2967 if (x < line_len && sel[x] != '\0')
2968 {
2969 /* use single line comment */
2970 if (EMPTY(cc))
2971 {
2972 single_line = TRUE;
2973
2974 if (toggle)
2975 {
2976 gsize tm_len = strlen(editor_prefs.comment_toggle_mark);
2977 if (strncmp(sel + x, co, co_len) != 0 ||
2978 strncmp(sel + x + co_len, editor_prefs.comment_toggle_mark, tm_len) != 0)
2979 continue;
2980
2981 co_len += tm_len;
2982 }
2983 else
2984 {
2985 if (strncmp(sel + x, co, co_len) != 0)
2986 continue;
2987 }
2988
2989 sci_set_selection(editor->sci, line_start + x, line_start + x + co_len);
2990 sci_replace_sel(editor->sci, "");
2991 count++;
2992 }
2993 /* use multi line comment */
2994 else
2995 {
2996 gint style_comment;
2997
2998 /* skip lines which are already comments */
2999 style_comment = get_multiline_comment_style(editor, line_start);
3000 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3001 {
3002 if (real_uncomment_multiline(editor))
3003 count = 1;
3004 }
3005
3006 /* break because we are already on the last line */
3007 break;
3008 }
3009 }
3010 }
3011 sci_end_undo_action(editor->sci);
3012
3013 /* restore selection if there is one
3014 * but don't touch the selection if caller is editor_do_comment_toggle */
3015 if (! toggle && sel_start < sel_end)
3016 {
3017 if (single_line)
3018 {
3019 sci_set_selection_start(editor->sci, sel_start - co_len);
3020 sci_set_selection_end(editor->sci, sel_end - (count * co_len));
3021 }
3022 else
3023 {
3024 gint eol_len = editor_get_eol_char_len(editor);
3025 sci_set_selection_start(editor->sci, sel_start - co_len - eol_len);
3026 sci_set_selection_end(editor->sci, sel_end - co_len - eol_len);
3027 }
3028 }
3029
3030 return count;
3031 }
3032
3033
3034 void editor_do_comment_toggle(GeanyEditor *editor)
3035 {
3036 gint first_line, last_line;
3037 gint x, i, line_start, line_len, first_line_start, last_line_start;
3038 gint sel_start, sel_end;
3039 gint count_commented = 0, count_uncommented = 0;
3040 gchar sel[256];
3041 const gchar *co, *cc;
3042 gboolean break_loop = FALSE, single_line = FALSE;
3043 gboolean first_line_was_comment = FALSE;
3044 gboolean last_line_was_comment = FALSE;
3045 gsize co_len;
3046 gsize tm_len = strlen(editor_prefs.comment_toggle_mark);
3047 GeanyFiletype *ft;
3048
3049 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
3050
3051 sel_start = sci_get_selection_start(editor->sci);
3052 sel_end = sci_get_selection_end(editor->sci);
3053
3054 first_line = sci_get_line_from_position(editor->sci, sel_start);
3055 /* Find the last line with chars selected (not EOL char) */
3056 last_line = sci_get_line_from_position(editor->sci,
3057 sel_end - editor_get_eol_char_len(editor));
3058 last_line = MAX(first_line, last_line);
3059
3060 first_line_start = sci_get_position_from_line(editor->sci, first_line);
3061 last_line_start = sci_get_position_from_line(editor->sci, last_line);
3062
3063 ft = editor_get_filetype_at_line(editor, first_line);
3064
3065 if (! filetype_get_comment_open_close(ft, TRUE, &co, &cc))
3066 return;
3067
3068 co_len = strlen(co);
3069 if (co_len == 0)
3070 return;
3071
3072 sci_start_undo_action(editor->sci);
3073
3074 for (i = first_line; (i <= last_line) && (! break_loop); i++)
3075 {
3076 gint buf_len;
3077
3078 line_start = sci_get_position_from_line(editor->sci, i);
3079 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
3080 x = 0;
3081
3082 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
3083 if (buf_len < 0)
3084 continue;
3085 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
3086 sel[buf_len] = '\0';
3087
3088 while (isspace(sel[x])) x++;
3089
3090 /* use single line comment */
3091 if (EMPTY(cc))
3092 {
3093 gboolean do_continue = FALSE;
3094 single_line = TRUE;
3095
3096 if (strncmp(sel + x, co, co_len) == 0 &&
3097 strncmp(sel + x + co_len, editor_prefs.comment_toggle_mark, tm_len) == 0)
3098 {
3099 do_continue = TRUE;
3100 }
3101
3102 if (do_continue && i == first_line)
3103 first_line_was_comment = TRUE;
3104 last_line_was_comment = do_continue;
3105
3106 if (do_continue)
3107 {
3108 count_uncommented += editor_do_uncomment(editor, i, TRUE);
3109 continue;
3110 }
3111
3112 /* we are still here, so the above lines were not already comments, so comment it */
3113 editor_do_comment(editor, i, TRUE, TRUE, TRUE);
3114 count_commented++;
3115 }
3116 /* use multi line comment */
3117 else
3118 {
3119 gint style_comment;
3120
3121 /* skip lines which are already comments */
3122 style_comment = get_multiline_comment_style(editor, line_start);
3123 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3124 {
3125 if (real_uncomment_multiline(editor))
3126 count_uncommented++;
3127 }
3128 else
3129 {
3130 real_comment_multiline(editor, line_start, last_line);
3131 count_commented++;
3132 }
3133
3134 /* break because we are already on the last line */
3135 break_loop = TRUE;
3136 break;
3137 }
3138 }
3139
3140 sci_end_undo_action(editor->sci);
3141
3142 co_len += tm_len;
3143
3144 /* restore selection or caret position */
3145 if (single_line)
3146 {
3147 gint a = (first_line_was_comment) ? - (gint) co_len : (gint) co_len;
3148 gint indent_len;
3149
3150 /* don't modify sel_start when the selection starts within indentation */
3151 read_indent(editor, sel_start);
3152 indent_len = (gint) strlen(indent);
3153 if ((sel_start - first_line_start) <= indent_len)
3154 a = 0;
3155 /* if the selection start was inside the comment mark, adjust the position */
3156 else if (first_line_was_comment &&
3157 sel_start >= (first_line_start + indent_len) &&
3158 sel_start <= (first_line_start + indent_len + (gint) co_len))
3159 {
3160 a = (first_line_start + indent_len) - sel_start;
3161 }
3162
3163 if (sel_start < sel_end)
3164 {
3165 gint b = (count_commented * (gint) co_len) - (count_uncommented * (gint) co_len);
3166
3167 /* same for selection end, but here we add an offset on the offset above */
3168 read_indent(editor, sel_end + b);
3169 indent_len = (gint) strlen(indent);
3170 if ((sel_end - last_line_start) < indent_len)
3171 b += last_line_was_comment ? (gint) co_len : -(gint) co_len;
3172 else if (last_line_was_comment &&
3173 sel_end >= (last_line_start + indent_len) &&
3174 sel_end <= (last_line_start + indent_len + (gint) co_len))
3175 {
3176 b += (gint) co_len - (sel_end - (last_line_start + indent_len));
3177 }
3178
3179 sci_set_selection_start(editor->sci, sel_start + a);
3180 sci_set_selection_end(editor->sci, sel_end + b);
3181 }
3182 else
3183 sci_set_current_position(editor->sci, sel_start + a, TRUE);
3184 }
3185 else
3186 {
3187 gint eol_len = editor_get_eol_char_len(editor);
3188 if (count_uncommented > 0)
3189 {
3190 sci_set_selection_start(editor->sci, sel_start - (gint) co_len + eol_len);
3191 sci_set_selection_end(editor->sci, sel_end - (gint) co_len + eol_len);
3192 }
3193 else if (count_commented > 0)
3194 {
3195 sci_set_selection_start(editor->sci, sel_start + (gint) co_len - eol_len);
3196 sci_set_selection_end(editor->sci, sel_end + (gint) co_len - eol_len);
3197 }
3198 if (sel_start >= sel_end)
3199 sci_scroll_caret(editor->sci);
3200 }
3201 }
3202
3203
3204 /* set toggle to TRUE if the caller is the toggle function, FALSE otherwise */
3205 void editor_do_comment(GeanyEditor *editor, gint line, gboolean allow_empty_lines, gboolean toggle,
3206 gboolean single_comment)
3207 {
3208 gint first_line, last_line;
3209 gint x, i, line_start, line_len;
3210 gint sel_start, sel_end, co_len;
3211 gchar sel[256];
3212 const gchar *co, *cc;
3213 gboolean break_loop = FALSE, single_line = FALSE;
3214 GeanyFiletype *ft;
3215
3216 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
3217
3218 if (line < 0)
3219 { /* use selection or current line */
3220 sel_start = sci_get_selection_start(editor->sci);
3221 sel_end = sci_get_selection_end(editor->sci);
3222
3223 first_line = sci_get_line_from_position(editor->sci, sel_start);
3224 /* Find the last line with chars selected (not EOL char) */
3225 last_line = sci_get_line_from_position(editor->sci,
3226 sel_end - editor_get_eol_char_len(editor));
3227 last_line = MAX(first_line, last_line);
3228 }
3229 else
3230 {
3231 first_line = last_line = line;
3232 sel_start = sel_end = sci_get_position_from_line(editor->sci, line);
3233 }
3234
3235 ft = editor_get_filetype_at_line(editor, first_line);
3236
3237 if (! filetype_get_comment_open_close(ft, single_comment, &co, &cc))
3238 return;
3239
3240 co_len = strlen(co);
3241 if (co_len == 0)
3242 return;
3243
3244 sci_start_undo_action(editor->sci);
3245
3246 for (i = first_line; (i <= last_line) && (! break_loop); i++)
3247 {
3248 gint buf_len;
3249
3250 line_start = sci_get_position_from_line(editor->sci, i);
3251 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
3252 x = 0;
3253
3254 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
3255 if (buf_len < 0)
3256 continue;
3257 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
3258 sel[buf_len] = '\0';
3259
3260 while (isspace(sel[x])) x++;
3261
3262 /* to skip blank lines */
3263 if (allow_empty_lines || (x < line_len && sel[x] != '\0'))
3264 {
3265 /* use single line comment */
3266 if (EMPTY(cc))
3267 {
3268 gint start = line_start;
3269 single_line = TRUE;
3270
3271 if (ft->comment_use_indent)
3272 start = line_start + x;
3273
3274 if (toggle)
3275 {
3276 gchar *text = g_strconcat(co, editor_prefs.comment_toggle_mark, NULL);
3277 sci_insert_text(editor->sci, start, text);
3278 g_free(text);
3279 }
3280 else
3281 sci_insert_text(editor->sci, start, co);
3282 }
3283 /* use multi line comment */
3284 else
3285 {
3286 gint style_comment;
3287
3288 /* skip lines which are already comments */
3289 style_comment = get_multiline_comment_style(editor, line_start);
3290 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3291 continue;
3292
3293 real_comment_multiline(editor, line_start, last_line);
3294
3295 /* break because we are already on the last line */
3296 break_loop = TRUE;
3297 break;
3298 }
3299 }
3300 }
3301 sci_end_undo_action(editor->sci);
3302
3303 /* restore selection if there is one
3304 * but don't touch the selection if caller is editor_do_comment_toggle */
3305 if (! toggle && sel_start < sel_end)
3306 {
3307 if (single_line)
3308 {
3309 sci_set_selection_start(editor->sci, sel_start + co_len);
3310 sci_set_selection_end(editor->sci, sel_end + ((i - first_line) * co_len));
3311 }
3312 else
3313 {
3314 gint eol_len = editor_get_eol_char_len(editor);
3315 sci_set_selection_start(editor->sci, sel_start + co_len + eol_len);
3316 sci_set_selection_end(editor->sci, sel_end + co_len + eol_len);
3317 }
3318 }
3319 }
3320
3321
3322 static gboolean brace_timeout_active = FALSE;
3323
3324 static gboolean delay_match_brace(G_GNUC_UNUSED gpointer user_data)
3325 {
3326 GeanyDocument *doc = document_get_current();
3327 GeanyEditor *editor;
3328 gint brace_pos = GPOINTER_TO_INT(user_data);
3329 gint end_pos, cur_pos;
3330
3331 brace_timeout_active = FALSE;
3332 if (!doc)
3333 return FALSE;
3334
3335 editor = doc->editor;
3336 cur_pos = sci_get_current_position(editor->sci) - 1;
3337
3338 if (cur_pos != brace_pos)
3339 {
3340 cur_pos++;
3341 if (cur_pos != brace_pos)
3342 {
3343 /* we have moved past the original brace_pos, but after the timeout
3344 * we may now be on a new brace, so check again */
3345 editor_highlight_braces(editor, cur_pos);
3346 return FALSE;
3347 }
3348 }
3349 if (!utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3350 {
3351 editor_highlight_braces(editor, cur_pos);
3352 return FALSE;
3353 }
3354 end_pos = sci_find_matching_brace(editor->sci, brace_pos);
3355
3356 if (end_pos >= 0)
3357 {
3358 gint col = MIN(sci_get_col_from_position(editor->sci, brace_pos),
3359 sci_get_col_from_position(editor->sci, end_pos));
3360 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, col, 0);
3361 SSM(editor->sci, SCI_BRACEHIGHLIGHT, brace_pos, end_pos);
3362 }
3363 else
3364 {
3365 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, 0, 0);
3366 SSM(editor->sci, SCI_BRACEBADLIGHT, brace_pos, 0);
3367 }
3368 return FALSE;
3369 }
3370
3371
3372 static void editor_highlight_braces(GeanyEditor *editor, gint cur_pos)
3373 {
3374 gint brace_pos = cur_pos - 1;
3375
3376 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, 0, 0);
3377 SSM(editor->sci, SCI_BRACEBADLIGHT, (uptr_t)-1, 0);
3378
3379 if (! utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3380 {
3381 brace_pos++;
3382 if (! utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3383 {
3384 return;
3385 }
3386 }
3387 if (!brace_timeout_active)
3388 {
3389 brace_timeout_active = TRUE;
3390 /* delaying matching makes scrolling faster e.g. holding down arrow keys */
3391 g_timeout_add(100, delay_match_brace, GINT_TO_POINTER(brace_pos));
3392 }
3393 }
3394
3395
3396 static gboolean in_block_comment(gint lexer, gint style)
3397 {
3398 switch (lexer)
3399 {
3400 case SCLEX_COBOL:
3401 case SCLEX_CPP:
3402 return (style == SCE_C_COMMENT ||
3403 style == SCE_C_COMMENTDOC);
3404
3405 case SCLEX_PASCAL:
3406 return (style == SCE_PAS_COMMENT ||
3407 style == SCE_PAS_COMMENT2);
3408
3409 case SCLEX_D:
3410 return (style == SCE_D_COMMENT ||
3411 style == SCE_D_COMMENTDOC ||
3412 style == SCE_D_COMMENTNESTED);
3413
3414 case SCLEX_HTML:
3415 return (style == SCE_HPHP_COMMENT);
3416
3417 case SCLEX_CSS:
3418 return (style == SCE_CSS_COMMENT);
3419
3420 case SCLEX_RUST:
3421 return (style == SCE_RUST_COMMENTBLOCK ||
3422 style == SCE_RUST_COMMENTBLOCKDOC);
3423
3424 default:
3425 return FALSE;
3426 }
3427 }
3428
3429
3430 static gboolean is_comment_char(gchar c, gint lexer)
3431 {
3432 if ((c == '*' || c == '+') && lexer == SCLEX_D)
3433 return TRUE;
3434 else
3435 if (c == '*')
3436 return TRUE;
3437
3438 return FALSE;
3439 }
3440
3441
3442 static void auto_multiline(GeanyEditor *editor, gint cur_line)
3443 {
3444 ScintillaObject *sci = editor->sci;
3445 gint indent_pos, style;
3446 gint lexer = sci_get_lexer(sci);
3447
3448 /* Use the start of the line enter was pressed on, to avoid any doc keyword styles */
3449 indent_pos = sci_get_line_indent_position(sci, cur_line - 1);
3450 style = sci_get_style_at(sci, indent_pos);
3451 if (!in_block_comment(lexer, style))
3452 return;
3453
3454 /* Check whether the comment block continues on this line */
3455 indent_pos = sci_get_line_indent_position(sci, cur_line);
3456 if (sci_get_style_at(sci, indent_pos) == style || indent_pos >= sci_get_length(sci))
3457 {
3458 gchar *previous_line = sci_get_line(sci, cur_line - 1);
3459 /* the type of comment, '*' (C/C++/Java), '+' and the others (D) */
3460 const gchar *continuation = "*";
3461 const gchar *whitespace = ""; /* to hold whitespace if needed */
3462 gchar *result;
3463 gint len = strlen(previous_line);
3464 gint i;
3465
3466 /* find and stop at end of multi line comment */
3467 i = len - 1;
3468 while (i >= 0 && isspace(previous_line[i])) i--;
3469 if (i >= 1 && is_comment_char(previous_line[i - 1], lexer) && previous_line[i] == '/')
3470 {
3471 gint indent_len, indent_width;
3472
3473 indent_pos = sci_get_line_indent_position(sci, cur_line);
3474 indent_len = sci_get_col_from_position(sci, indent_pos);
3475 indent_width = editor_get_indent_prefs(editor)->width;
3476
3477 /* if there is one too many spaces, delete the last space,
3478 * to return to the indent used before the multiline comment was started. */
3479 if (indent_len % indent_width == 1)
3480 SSM(sci, SCI_DELETEBACKNOTLINE, 0, 0); /* remove whitespace indent */
3481 g_free(previous_line);
3482 return;
3483 }
3484 /* check whether we are on the second line of multi line comment */
3485 i = 0;
3486 while (i < len && isspace(previous_line[i])) i++; /* get to start of the line */
3487
3488 if (i + 1 < len &&
3489 previous_line[i] == '/' && is_comment_char(previous_line[i + 1], lexer))
3490 { /* we are on the second line of a multi line comment, so we have to insert white space */
3491 whitespace = " ";
3492 }
3493
3494 if (style == SCE_D_COMMENTNESTED)
3495 continuation = "+"; /* for nested comments in D */
3496
3497 result = g_strconcat(whitespace, continuation, " ", NULL);
3498 sci_add_text(sci, result);
3499 g_free(result);
3500
3501 g_free(previous_line);
3502 }
3503 }
3504
3505
3506 #if 0
3507 static gboolean editor_lexer_is_c_like(gint lexer)
3508 {
3509 switch (lexer)
3510 {
3511 case SCLEX_CPP:
3512 case SCLEX_D:
3513 return TRUE;
3514
3515 default:
3516 return FALSE;
3517 }
3518 }
3519 #endif
3520
3521
3522 /* inserts a three-line comment at one line above current cursor position */
3523 void editor_insert_multiline_comment(GeanyEditor *editor)
3524 {
3525 gchar *text;
3526 gint text_len;
3527 gint line;
3528 gint pos;
3529 gboolean have_multiline_comment = FALSE;
3530 GeanyDocument *doc;
3531 const gchar *co, *cc;
3532
3533 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
3534
3535 if (! filetype_get_comment_open_close(editor->document->file_type, FALSE, &co, &cc))
3536 g_return_if_reached();
3537 if (!EMPTY(cc))
3538 have_multiline_comment = TRUE;
3539
3540 sci_start_undo_action(editor->sci);
3541
3542 doc = editor->document;
3543
3544 /* insert three lines one line above of the current position */
3545 line = sci_get_line_from_position(editor->sci, editor_info.click_pos);
3546 pos = sci_get_position_from_line(editor->sci, line);
3547
3548 /* use the indent on the current line but only when comment indentation is used
3549 * and we don't have multi line comment characters */
3550 if (editor->auto_indent &&
3551 ! have_multiline_comment && doc->file_type->comment_use_indent)
3552 {
3553 read_indent(editor, editor_info.click_pos);
3554 text = g_strdup_printf("%s\n%s\n%s\n", indent, indent, indent);
3555 text_len = strlen(text);
3556 }
3557 else
3558 {
3559 text = g_strdup("\n\n\n");
3560 text_len = 3;
3561 }
3562 sci_insert_text(editor->sci, pos, text);
3563 g_free(text);
3564
3565 /* select the inserted lines for commenting */
3566 sci_set_selection_start(editor->sci, pos);
3567 sci_set_selection_end(editor->sci, pos + text_len);
3568
3569 editor_do_comment(editor, -1, TRUE, FALSE, FALSE);
3570
3571 /* set the current position to the start of the first inserted line */
3572 pos += strlen(co);
3573
3574 /* on multi line comment jump to the next line, otherwise add the length of added indentation */
3575 if (have_multiline_comment)
3576 pos += 1;
3577 else
3578 pos += strlen(indent);
3579
3580 sci_set_current_position(editor->sci, pos, TRUE);
3581 /* reset the selection */
3582 sci_set_anchor(editor->sci, pos);
3583
3584 sci_end_undo_action(editor->sci);
3585 }
3586
3587
3588 /* Note: If the editor is pending a redraw, set document::scroll_percent instead.
3589 * Scroll the view to make line appear at percent_of_view.
3590 * line can be -1 to use the current position. */
3591 void editor_scroll_to_line(GeanyEditor *editor, gint line, gfloat percent_of_view)
3592 {
3593 gint los;
3594 GtkWidget *wid;
3595
3596 g_return_if_fail(editor != NULL);
3597
3598 wid = GTK_WIDGET(editor->sci);
3599
3600 if (! gtk_widget_get_window(wid) || ! gdk_window_is_viewable(gtk_widget_get_window(wid)))
3601 return; /* prevent gdk_window_scroll warning */
3602
3603 if (line == -1)
3604 line = sci_get_current_line(editor->sci);
3605
3606 /* sci 'visible line' != doc line number because of folding and line wrapping */
3607 /* calling SCI_VISIBLEFROMDOCLINE for line is more accurate than calling
3608 * SCI_DOCLINEFROMVISIBLE for vis1. */
3609 line = SSM(editor->sci, SCI_VISIBLEFROMDOCLINE, line, 0);
3610 los = SSM(editor->sci, SCI_LINESONSCREEN, 0, 0);
3611 line = line - los * percent_of_view;
3612 SSM(editor->sci, SCI_SETFIRSTVISIBLELINE, line, 0);
3613 sci_scroll_caret(editor->sci); /* needed for horizontal scrolling */
3614 }
3615
3616
3617 /* creates and inserts one tab or whitespace of the amount of the tab width */
3618 void editor_insert_alternative_whitespace(GeanyEditor *editor)
3619 {
3620 gchar *text;
3621 GeanyIndentPrefs iprefs = *editor_get_indent_prefs(editor);
3622
3623 g_return_if_fail(editor != NULL);
3624
3625 switch (iprefs.type)
3626 {
3627 case GEANY_INDENT_TYPE_TABS:
3628 iprefs.type = GEANY_INDENT_TYPE_SPACES;
3629 break;
3630 case GEANY_INDENT_TYPE_SPACES:
3631 case GEANY_INDENT_TYPE_BOTH: /* most likely we want a tab */
3632 iprefs.type = GEANY_INDENT_TYPE_TABS;
3633 break;
3634 }
3635 text = get_whitespace(&iprefs, iprefs.width);
3636 sci_add_text(editor->sci, text);
3637 g_free(text);
3638 }
3639
3640
3641 void editor_select_word(GeanyEditor *editor)
3642 {
3643 gint pos;
3644 gint start;
3645 gint end;
3646
3647 g_return_if_fail(editor != NULL);
3648
3649 pos = SSM(editor->sci, SCI_GETCURRENTPOS, 0, 0);
3650 start = sci_word_start_position(editor->sci, pos, TRUE);
3651 end = sci_word_end_position(editor->sci, pos, TRUE);
3652
3653 if (start == end) /* caret in whitespaces sequence */
3654 {
3655 /* look forward but reverse the selection direction,
3656 * so the caret end up stay as near as the original position. */
3657 end = sci_word_end_position(editor->sci, pos, FALSE);
3658 start = sci_word_end_position(editor->sci, end, TRUE);
3659 if (start == end)
3660 return;
3661 }
3662
3663 sci_set_selection(editor->sci, start, end);
3664 }
3665
3666
3667 /* extra_line is for selecting the cursor line (or anchor line) at the bottom of a selection,
3668 * when those lines have no selection (cursor at start of line). */
3669 void editor_select_lines(GeanyEditor *editor, gboolean extra_line)
3670 {
3671 gint start, end, line;
3672
3673 g_return_if_fail(editor != NULL);
3674
3675 start = sci_get_selection_start(editor->sci);
3676 end = sci_get_selection_end(editor->sci);
3677
3678 /* check if whole lines are already selected */
3679 if (! extra_line && start != end &&
3680 sci_get_col_from_position(editor->sci, start) == 0 &&
3681 sci_get_col_from_position(editor->sci, end) == 0)
3682 return;
3683
3684 line = sci_get_line_from_position(editor->sci, start);
3685 start = sci_get_position_from_line(editor->sci, line);
3686
3687 line = sci_get_line_from_position(editor->sci, end);
3688 end = sci_get_position_from_line(editor->sci, line + 1);
3689
3690 sci_set_selection(editor->sci, start, end);
3691 }
3692
3693
3694 static gboolean sci_is_blank_line(ScintillaObject *sci, gint line)
3695 {
3696 return sci_get_line_indent_position(sci, line) ==
3697 sci_get_line_end_position(sci, line);
3698 }
3699
3700
3701 /* Returns first line of paragraph for GTK_DIR_UP, line after paragraph
3702 * ends for GTK_DIR_DOWN or -1 if called on an empty line. */
3703 static gint find_paragraph_stop(GeanyEditor *editor, gint line, gint direction)
3704 {
3705 gint step;
3706 ScintillaObject *sci = editor->sci;
3707
3708 /* first check current line and return -1 if it is empty to skip creating of a selection */
3709 if (sci_is_blank_line(sci, line))
3710 return -1;
3711
3712 if (direction == GTK_DIR_UP)
3713 step = -1;
3714 else
3715 step = 1;
3716
3717 while (TRUE)
3718 {
3719 line += step;
3720 if (line == -1)
3721 {
3722 /* start of document */
3723 line = 0;
3724 break;
3725 }
3726 if (line == sci_get_line_count(sci))
3727 break;
3728
3729 if (sci_is_blank_line(sci, line))
3730 {
3731 /* return line paragraph starts on */
3732 if (direction == GTK_DIR_UP)
3733 line++;
3734 break;
3735 }
3736 }
3737 return line;
3738 }
3739
3740
3741 void editor_select_paragraph(GeanyEditor *editor)
3742 {
3743 gint pos_start, pos_end, line_start, line_found;
3744
3745 g_return_if_fail(editor != NULL);
3746
3747 line_start = sci_get_current_line(editor->sci);
3748
3749 line_found = find_paragraph_stop(editor, line_start, GTK_DIR_UP);
3750 if (line_found == -1)
3751 return;
3752
3753 pos_start = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3754
3755 line_found = find_paragraph_stop(editor, line_start, GTK_DIR_DOWN);
3756 pos_end = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3757
3758 sci_set_selection(editor->sci, pos_start, pos_end);
3759 }
3760
3761
3762 /* Returns first line of block for GTK_DIR_UP, line after block
3763 * ends for GTK_DIR_DOWN or -1 if called on an empty line. */
3764 static gint find_block_stop(GeanyEditor *editor, gint line, gint direction)
3765 {
3766 gint step, ind;
3767 ScintillaObject *sci = editor->sci;
3768
3769 /* first check current line and return -1 if it is empty to skip creating of a selection */
3770 if (sci_is_blank_line(sci, line))
3771 return -1;
3772
3773 if (direction == GTK_DIR_UP)
3774 step = -1;
3775 else
3776 step = 1;
3777
3778 ind = sci_get_line_indentation(sci, line);
3779 while (TRUE)
3780 {
3781 line += step;
3782 if (line == -1)
3783 {
3784 /* start of document */
3785 line = 0;
3786 break;
3787 }
3788 if (line == sci_get_line_count(sci))
3789 break;
3790
3791 if (sci_get_line_indentation(sci, line) != ind ||
3792 sci_is_blank_line(sci, line))
3793 {
3794 /* return line block starts on */
3795 if (direction == GTK_DIR_UP)
3796 line++;
3797 break;
3798 }
3799 }
3800 return line;
3801 }
3802
3803
3804 void editor_select_indent_block(GeanyEditor *editor)
3805 {
3806 gint pos_start, pos_end, line_start, line_found;
3807
3808 g_return_if_fail(editor != NULL);
3809
3810 line_start = sci_get_current_line(editor->sci);
3811
3812 line_found = find_block_stop(editor, line_start, GTK_DIR_UP);
3813 if (line_found == -1)
3814 return;
3815
3816 pos_start = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3817
3818 line_found = find_block_stop(editor, line_start, GTK_DIR_DOWN);
3819 pos_end = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3820
3821 sci_set_selection(editor->sci, pos_start, pos_end);
3822 }
3823
3824
3825 /* simple indentation to indent the current line with the same indent as the previous one */
3826 static void smart_line_indentation(GeanyEditor *editor, gint first_line, gint last_line)
3827 {
3828 gint i, sel_start = 0, sel_end = 0;
3829
3830 /* get previous line and use it for read_indent to use that line
3831 * (otherwise it would fail on a line only containing "{" in advanced indentation mode) */
3832 read_indent(editor, sci_get_position_from_line(editor->sci, first_line - 1));
3833
3834 for (i = first_line; i <= last_line; i++)
3835 {
3836 /* skip the first line or if the indentation of the previous and current line are equal */
3837 if (i == 0 ||
3838 SSM(editor->sci, SCI_GETLINEINDENTATION, i - 1, 0) ==
3839 SSM(editor->sci, SCI_GETLINEINDENTATION, i, 0))
3840 continue;
3841
3842 sel_start = SSM(editor->sci, SCI_POSITIONFROMLINE, i, 0);
3843 sel_end = SSM(editor->sci, SCI_GETLINEINDENTPOSITION, i, 0);
3844 if (sel_start < sel_end)
3845 {
3846 sci_set_selection(editor->sci, sel_start, sel_end);
3847 sci_replace_sel(editor->sci, "");
3848 }
3849 sci_insert_text(editor->sci, sel_start, indent);
3850 }
3851 }
3852
3853
3854 /* simple indentation to indent the current line with the same indent as the previous one */
3855 void editor_smart_line_indentation(GeanyEditor *editor, gint pos)
3856 {
3857 gint first_line, last_line;
3858 gint first_sel_start, first_sel_end;
3859 ScintillaObject *sci;
3860
3861 g_return_if_fail(editor != NULL);
3862
3863 sci = editor->sci;
3864
3865 first_sel_start = sci_get_selection_start(sci);
3866 first_sel_end = sci_get_selection_end(sci);
3867
3868 first_line = sci_get_line_from_position(sci, first_sel_start);
3869 /* Find the last line with chars selected (not EOL char) */
3870 last_line = sci_get_line_from_position(sci, first_sel_end - editor_get_eol_char_len(editor));
3871 last_line = MAX(first_line, last_line);
3872
3873 if (pos == -1)
3874 pos = first_sel_start;
3875
3876 sci_start_undo_action(sci);
3877
3878 smart_line_indentation(editor, first_line, last_line);
3879
3880 /* set cursor position if there was no selection */
3881 if (first_sel_start == first_sel_end)
3882 {
3883 gint indent_pos = SSM(sci, SCI_GETLINEINDENTPOSITION, first_line, 0);
3884
3885 /* use indent position as user may wish to change indentation afterwards */
3886 sci_set_current_position(sci, indent_pos, FALSE);
3887 }
3888 else
3889 {
3890 /* fully select all the lines affected */
3891 sci_set_selection_start(sci, sci_get_position_from_line(sci, first_line));
3892 sci_set_selection_end(sci, sci_get_position_from_line(sci, last_line + 1));
3893 }
3894
3895 sci_end_undo_action(sci);
3896 }
3897
3898
3899 /* increase / decrease current line or selection by one space */
3900 void editor_indentation_by_one_space(GeanyEditor *editor, gint pos, gboolean decrease)
3901 {
3902 gint i, first_line, last_line, line_start, indentation_end, count = 0;
3903 gint sel_start, sel_end, first_line_offset = 0;
3904
3905 g_return_if_fail(editor != NULL);
3906
3907 sel_start = sci_get_selection_start(editor->sci);
3908 sel_end = sci_get_selection_end(editor->sci);
3909
3910 first_line = sci_get_line_from_position(editor->sci, sel_start);
3911 /* Find the last line with chars selected (not EOL char) */
3912 last_line = sci_get_line_from_position(editor->sci, sel_end - editor_get_eol_char_len(editor));
3913 last_line = MAX(first_line, last_line);
3914
3915 if (pos == -1)
3916 pos = sel_start;
3917
3918 sci_start_undo_action(editor->sci);
3919
3920 for (i = first_line; i <= last_line; i++)
3921 {
3922 indentation_end = SSM(editor->sci, SCI_GETLINEINDENTPOSITION, i, 0);
3923 if (decrease)
3924 {
3925 line_start = SSM(editor->sci, SCI_POSITIONFROMLINE, i, 0);
3926 /* searching backwards for a space to remove */
3927 while (sci_get_char_at(editor->sci, indentation_end) != ' ' && indentation_end > line_start)
3928 indentation_end--;
3929
3930 if (sci_get_char_at(editor->sci, indentation_end) == ' ')
3931 {
3932 sci_set_selection(editor->sci, indentation_end, indentation_end + 1);
3933 sci_replace_sel(editor->sci, "");
3934 count--;
3935 if (i == first_line)
3936 first_line_offset = -1;
3937 }
3938 }
3939 else
3940 {
3941 sci_insert_text(editor->sci, indentation_end, " ");
3942 count++;
3943 if (i == first_line)
3944 first_line_offset = 1;
3945 }
3946 }
3947
3948 /* set cursor position */
3949 if (sel_start < sel_end)
3950 {
3951 gint start = sel_start + first_line_offset;
3952 if (first_line_offset < 0)
3953 start = MAX(sel_start + first_line_offset,
3954 SSM(editor->sci, SCI_POSITIONFROMLINE, first_line, 0));
3955
3956 sci_set_selection_start(editor->sci, start);
3957 sci_set_selection_end(editor->sci, sel_end + count);
3958 }
3959 else
3960 sci_set_current_position(editor->sci, pos + count, FALSE);
3961
3962 sci_end_undo_action(editor->sci);
3963 }
3964
3965
3966 void editor_finalize(void)
3967 {
3968 scintilla_release_resources();
3969 }
3970
3971
3972 /* wordchars: NULL or a string containing characters to match a word.
3973 * Returns: the current selection or the current word.
3974 *
3975 * Passing NULL as wordchars is NOT the same as passing GEANY_WORDCHARS: NULL means
3976 * using Scintillas's word boundaries. */
3977 gchar *editor_get_default_selection(GeanyEditor *editor, gboolean use_current_word,
3978 const gchar *wordchars)
3979 {
3980 gchar *s = NULL;
3981
3982 g_return_val_if_fail(editor != NULL, NULL);
3983
3984 if (sci_get_lines_selected(editor->sci) == 1)
3985 s = sci_get_selection_contents(editor->sci);
3986 else if (sci_get_lines_selected(editor->sci) == 0 && use_current_word)
3987 { /* use the word at current cursor position */
3988 gchar word[GEANY_MAX_WORD_LENGTH];
3989
3990 if (wordchars != NULL)
3991 editor_find_current_word(editor, -1, word, sizeof(word), wordchars);
3992 else
3993 editor_find_current_word_sciwc(editor, -1, word, sizeof(word));
3994
3995 if (word[0] != '\0')
3996 s = g_strdup(word);
3997 }
3998 return s;
3999 }
4000
4001
4002 /* Note: Usually the line should be made visible (not folded) before calling this.
4003 * Returns: TRUE if line is/will be displayed to the user, or FALSE if it is
4004 * outside the *vertical* view.
4005 * Warning: You may need horizontal scrolling to make the cursor visible - so always call
4006 * sci_scroll_caret() when this returns TRUE. */
4007 gboolean editor_line_in_view(GeanyEditor *editor, gint line)
4008 {
4009 gint vis1, los;
4010
4011 g_return_val_if_fail(editor != NULL, FALSE);
4012
4013 /* If line is wrapped the result may occur on another virtual line than the first and may be
4014 * still hidden, so increase the line number to check for the next document line */
4015 if (SSM(editor->sci, SCI_WRAPCOUNT, line, 0) > 1)
4016 line++;
4017
4018 line = SSM(editor->sci, SCI_VISIBLEFROMDOCLINE, line, 0); /* convert to visible line number */
4019 vis1 = SSM(editor->sci, SCI_GETFIRSTVISIBLELINE, 0, 0);
4020 los = SSM(editor->sci, SCI_LINESONSCREEN, 0, 0);
4021
4022 return (line >= vis1 && line < vis1 + los);
4023 }
4024
4025
4026 /* If the current line is outside the current view window, scroll the line
4027 * so it appears at percent_of_view. */
4028 void editor_display_current_line(GeanyEditor *editor, gfloat percent_of_view)
4029 {
4030 gint line;
4031
4032 g_return_if_fail(editor != NULL);
4033
4034 line = sci_get_current_line(editor->sci);
4035
4036 /* unfold maybe folded results */
4037 sci_ensure_line_is_visible(editor->sci, line);
4038
4039 /* scroll the line if it's off screen */
4040 if (! editor_line_in_view(editor, line))
4041 editor->scroll_percent = percent_of_view;
4042 else
4043 sci_scroll_caret(editor->sci); /* may need horizontal scrolling */
4044 }
4045
4046
4047 /*
4048 * Deletes all currently set indicators in the @a editor window.
4049 * Error indicators (red squiggly underlines) and usual line markers are removed.
4050 *
4051 * @param editor The editor to operate on.
4052 */
4053 void editor_indicator_clear_errors(GeanyEditor *editor)
4054 {
4055 editor_indicator_clear(editor, GEANY_INDICATOR_ERROR);
4056 sci_marker_delete_all(editor->sci, 0); /* remove the yellow error line marker */
4057 }
4058
4059
4060 /**
4061 * Deletes all currently set indicators matching @a indic in the @a editor window.
4062 *
4063 * @param editor The editor to operate on.
4064 * @param indic The indicator number to clear, this is a value of @ref GeanyIndicator.
4065 *
4066 * @since 0.16
4067 */
4068 void editor_indicator_clear(GeanyEditor *editor, gint indic)
4069 {
4070 glong last_pos;
4071
4072 g_return_if_fail(editor != NULL);
4073
4074 last_pos = sci_get_length(editor->sci);
4075 if (last_pos > 0)
4076 {
4077 sci_indicator_set(editor->sci, indic);
4078 sci_indicator_clear(editor->sci, 0, last_pos);
4079 }
4080 }
4081
4082
4083 /**
4084 * Sets an indicator @a indic on @a line.
4085 * Whitespace at the start and the end of the line is not marked.
4086 *
4087 * @param editor The editor to operate on.
4088 * @param indic The indicator number to use, this is a value of @ref GeanyIndicator.
4089 * @param line The line number which should be marked.
4090 *
4091 * @since 0.16
4092 */
4093 void editor_indicator_set_on_line(GeanyEditor *editor, gint indic, gint line)
4094 {
4095 gint start, end;
4096 guint i = 0, len;
4097 gchar *linebuf;
4098
4099 g_return_if_fail(editor != NULL);
4100 g_return_if_fail(line >= 0);
4101
4102 start = sci_get_position_from_line(editor->sci, line);
4103 end = sci_get_position_from_line(editor->sci, line + 1);
4104
4105 /* skip blank lines */
4106 if ((start + 1) == end ||
4107 start > end ||
4108 (sci_get_line_end_position(editor->sci, line) - start) == 0)
4109 {
4110 return;
4111 }
4112
4113 len = end - start;
4114 linebuf = sci_get_line(editor->sci, line);
4115
4116 /* don't set the indicator on whitespace */
4117 while (isspace(linebuf[i]))
4118 i++;
4119 while (len > 1 && len > i && isspace(linebuf[len - 1]))
4120 {
4121 len--;
4122 end--;
4123 }
4124 g_free(linebuf);
4125
4126 editor_indicator_set_on_range(editor, indic, start + i, end);
4127 }
4128
4129
4130 /**
4131 * Sets an indicator on the range specified by @a start and @a end.
4132 * No error checking or whitespace removal is performed, this should be done by the calling
4133 * function if necessary.
4134 *
4135 * @param editor The editor to operate on.
4136 * @param indic The indicator number to use, this is a value of @ref GeanyIndicator.
4137 * @param start The starting position for the marker.
4138 * @param end The ending position for the marker.
4139 *
4140 * @since 0.16
4141 */
4142 void editor_indicator_set_on_range(GeanyEditor *editor, gint indic, gint start, gint end)
4143 {
4144 g_return_if_fail(editor != NULL);
4145 if (start >= end)
4146 return;
4147
4148 sci_indicator_set(editor->sci, indic);
4149 sci_indicator_fill(editor->sci, start, end - start);
4150 }
4151
4152
4153 /* Inserts the given colour (format should be #...), if there is a selection starting with 0x...
4154 * the replacement will also start with 0x... */
4155 void editor_insert_color(GeanyEditor *editor, const gchar *colour)
4156 {
4157 g_return_if_fail(editor != NULL);
4158
4159 if (sci_has_selection(editor->sci))
4160 {
4161 gint start = sci_get_selection_start(editor->sci);
4162 const gchar *replacement = colour;
4163
4164 if (sci_get_char_at(editor->sci, start) == '0' &&
4165 sci_get_char_at(editor->sci, start + 1) == 'x')
4166 {
4167 sci_set_selection_start(editor->sci, start + 2);
4168 sci_set_selection_end(editor->sci, start + 8);
4169 replacement++; /* skip the leading "0x" */
4170 }
4171 else if (sci_get_char_at(editor->sci, start - 1) == '#')
4172 { /* double clicking something like #00ffff may only select 00ffff because of wordchars */
4173 replacement++; /* so skip the '#' to only replace the colour value */
4174 }
4175 sci_replace_sel(editor->sci, replacement);
4176 }
4177 else
4178 sci_add_text(editor->sci, colour);
4179 }
4180
4181
4182 /**
4183 * Retrieves the end of line characters mode (LF, CR/LF, CR) in the given editor.
4184 * If @a editor is @c NULL, the default end of line characters are used.
4185 *
4186 * @param editor The editor to operate on, or @c NULL to query the default value.
4187 * @return The used end of line characters mode.
4188 *
4189 * @since 0.20
4190 */
4191 gint editor_get_eol_char_mode(GeanyEditor *editor)
4192 {
4193 gint mode = file_prefs.default_eol_character;
4194
4195 if (editor != NULL)
4196 mode = sci_get_eol_mode(editor->sci);
4197
4198 return mode;
4199 }
4200
4201
4202 /**
4203 * Retrieves the localized name (for displaying) of the used end of line characters
4204 * (LF, CR/LF, CR) in the given editor.
4205 * If @a editor is @c NULL, the default end of line characters are used.
4206 *
4207 * @param editor The editor to operate on, or @c NULL to query the default value.
4208 * @return The name of the end of line characters.
4209 *
4210 * @since 0.19
4211 */
4212 const gchar *editor_get_eol_char_name(GeanyEditor *editor)
4213 {
4214 gint mode = file_prefs.default_eol_character;
4215
4216 if (editor != NULL)
4217 mode = sci_get_eol_mode(editor->sci);
4218
4219 return utils_get_eol_name(mode);
4220 }
4221
4222
4223 /**
4224 * Retrieves the length of the used end of line characters (LF, CR/LF, CR) in the given editor.
4225 * If @a editor is @c NULL, the default end of line characters are used.
4226 * The returned value is 1 for CR and LF and 2 for CR/LF.
4227 *
4228 * @param editor The editor to operate on, or @c NULL to query the default value.
4229 * @return The length of the end of line characters.
4230 *
4231 * @since 0.19
4232 */
4233 gint editor_get_eol_char_len(GeanyEditor *editor)
4234 {
4235 gint mode = file_prefs.default_eol_character;
4236
4237 if (editor != NULL)
4238 mode = sci_get_eol_mode(editor->sci);
4239
4240 switch (mode)
4241 {
4242 case SC_EOL_CRLF: return 2; break;
4243 default: return 1; break;
4244 }
4245 }
4246
4247
4248 /**
4249 * Retrieves the used end of line characters (LF, CR/LF, CR) in the given editor.
4250 * If @a editor is @c NULL, the default end of line characters are used.
4251 * The returned value is either "\n", "\r\n" or "\r".
4252 *
4253 * @param editor The editor to operate on, or @c NULL to query the default value.
4254 * @return The end of line characters.
4255 *
4256 * @since 0.19
4257 */
4258 const gchar *editor_get_eol_char(GeanyEditor *editor)
4259 {
4260 gint mode = file_prefs.default_eol_character;
4261
4262 if (editor != NULL)
4263 mode = sci_get_eol_mode(editor->sci);
4264
4265 return utils_get_eol_char(mode);
4266 }
4267
4268
4269 static void fold_all(GeanyEditor *editor, gboolean want_fold)
4270 {
4271 gint lines, first, i;
4272
4273 if (editor == NULL || ! editor_prefs.folding)
4274 return;
4275
4276 lines = sci_get_line_count(editor->sci);
4277 first = sci_get_first_visible_line(editor->sci);
4278
4279 for (i = 0; i < lines; i++)
4280 {
4281 gint level = sci_get_fold_level(editor->sci, i);
4282
4283 if (level & SC_FOLDLEVELHEADERFLAG)
4284 {
4285 if (sci_get_fold_expanded(editor->sci, i) == want_fold)
4286 sci_toggle_fold(editor->sci, i);
4287 }
4288 }
4289 editor_scroll_to_line(editor, first, 0.0F);
4290 }
4291
4292
4293 void editor_unfold_all(GeanyEditor *editor)
4294 {
4295 fold_all(editor, FALSE);
4296 }
4297
4298
4299 void editor_fold_all(GeanyEditor *editor)
4300 {
4301 fold_all(editor, TRUE);
4302 }
4303
4304
4305 void editor_replace_tabs(GeanyEditor *editor)
4306 {
4307 gint search_pos, pos_in_line, current_tab_true_length;
4308 gint tab_len;
4309 gchar *tab_str;
4310 struct Sci_TextToFind ttf;
4311
4312 g_return_if_fail(editor != NULL);
4313
4314 sci_start_undo_action(editor->sci);
4315 tab_len = sci_get_tab_width(editor->sci);
4316 ttf.chrg.cpMin = 0;
4317 ttf.chrg.cpMax = sci_get_length(editor->sci);
4318 ttf.lpstrText = (gchar*) "\t";
4319
4320 while (TRUE)
4321 {
4322 search_pos = sci_find_text(editor->sci, SCFIND_MATCHCASE, &ttf);
4323 if (search_pos == -1)
4324 break;
4325
4326 pos_in_line = sci_get_col_from_position(editor->sci, search_pos);
4327 current_tab_true_length = tab_len - (pos_in_line % tab_len);
4328 tab_str = g_strnfill(current_tab_true_length, ' ');
4329 sci_set_target_start(editor->sci, search_pos);
4330 sci_set_target_end(editor->sci, search_pos + 1);
4331 sci_replace_target(editor->sci, tab_str, FALSE);
4332 /* next search starts after replacement */
4333 ttf.chrg.cpMin = search_pos + current_tab_true_length - 1;
4334 /* update end of range now text has changed */
4335 ttf.chrg.cpMax += current_tab_true_length - 1;
4336 g_free(tab_str);
4337 }
4338 sci_end_undo_action(editor->sci);
4339 }
4340
4341
4342 /* Replaces all occurrences all spaces of the length of a given tab_width. */
4343 void editor_replace_spaces(GeanyEditor *editor)
4344 {
4345 gint search_pos;
4346 static gdouble tab_len_f = -1.0; /* keep the last used value */
4347 gint tab_len;
4348 struct Sci_TextToFind ttf;
4349
4350 g_return_if_fail(editor != NULL);
4351
4352 if (tab_len_f < 0.0)
4353 tab_len_f = sci_get_tab_width(editor->sci);
4354
4355 if (! dialogs_show_input_numeric(
4356 _("Enter Tab Width"),
4357 _("Enter the amount of spaces which should be replaced by a tab character."),
4358 &tab_len_f, 1, 100, 1))
4359 {
4360 return;
4361 }
4362 tab_len = (gint) tab_len_f;
4363
4364 sci_start_undo_action(editor->sci);
4365 ttf.chrg.cpMin = 0;
4366 ttf.chrg.cpMax = sci_get_length(editor->sci);
4367 ttf.lpstrText = g_strnfill(tab_len, ' ');
4368
4369 while (TRUE)
4370 {
4371 search_pos = sci_find_text(editor->sci, SCFIND_MATCHCASE, &ttf);
4372 if (search_pos == -1)
4373 break;
4374 /* only replace indentation because otherwise we can mess up alignment */
4375 if (search_pos > sci_get_line_indent_position(editor->sci,
4376 sci_get_line_from_position(editor->sci, search_pos)))
4377 {
4378 ttf.chrg.cpMin = search_pos + tab_len;
4379 continue;
4380 }
4381 sci_set_target_start(editor->sci, search_pos);
4382 sci_set_target_end(editor->sci, search_pos + tab_len);
4383 sci_replace_target(editor->sci, "\t", FALSE);
4384 ttf.chrg.cpMin = search_pos;
4385 /* update end of range now text has changed */
4386 ttf.chrg.cpMax -= tab_len - 1;
4387 }
4388 sci_end_undo_action(editor->sci);
4389 g_free(ttf.lpstrText);
4390 }
4391
4392
4393 void editor_strip_line_trailing_spaces(GeanyEditor *editor, gint line)
4394 {
4395 gint line_start = sci_get_position_from_line(editor->sci, line);
4396 gint line_end = sci_get_line_end_position(editor->sci, line);
4397 gint i = line_end - 1;
4398 gchar ch = sci_get_char_at(editor->sci, i);
4399
4400 /* Diff hunks should keep trailing spaces */
4401 if (sci_get_lexer(editor->sci) == SCLEX_DIFF)
4402 return;
4403
4404 while ((i >= line_start) && ((ch == ' ') || (ch == '\t')))
4405 {
4406 i--;
4407 ch = sci_get_char_at(editor->sci, i);
4408 }
4409 if (i < (line_end - 1))
4410 {
4411 sci_set_target_start(editor->sci, i + 1);
4412 sci_set_target_end(editor->sci, line_end);
4413 sci_replace_target(editor->sci, "", FALSE);
4414 }
4415 }
4416
4417
4418 void editor_strip_trailing_spaces(GeanyEditor *editor)
4419 {
4420 gint max_lines = sci_get_line_count(editor->sci);
4421 gint line;
4422
4423 sci_start_undo_action(editor->sci);
4424
4425 for (line = 0; line < max_lines; line++)
4426 {
4427 editor_strip_line_trailing_spaces(editor, line);
4428 }
4429 sci_end_undo_action(editor->sci);
4430 }
4431
4432
4433 void editor_ensure_final_newline(GeanyEditor *editor)
4434 {
4435 gint max_lines = sci_get_line_count(editor->sci);
4436 gboolean append_newline = (max_lines == 1);
4437 gint end_document = sci_get_position_from_line(editor->sci, max_lines);
4438
4439 if (max_lines > 1)
4440 {
4441 append_newline = end_document > sci_get_position_from_line(editor->sci, max_lines - 1);
4442 }
4443 if (append_newline)
4444 {
4445 const gchar *eol = editor_get_eol_char(editor);
4446
4447 sci_insert_text(editor->sci, end_document, eol);
4448 }
4449 }
4450
4451
4452 void editor_set_font(GeanyEditor *editor, const gchar *font)
4453 {
4454 gint style, size;
4455 gchar *font_name;
4456 PangoFontDescription *pfd;
4457
4458 g_return_if_fail(editor);
4459
4460 pfd = pango_font_description_from_string(font);
4461 size = pango_font_description_get_size(pfd) / PANGO_SCALE;
4462 font_name = g_strdup_printf("!%s", pango_font_description_get_family(pfd));
4463 pango_font_description_free(pfd);
4464
4465 for (style = 0; style <= STYLE_MAX; style++)
4466 sci_set_font(editor->sci, style, font_name, size);
4467
4468 g_free(font_name);
4469
4470 /* zoom to 100% to prevent confusion */
4471 sci_zoom_off(editor->sci);
4472 }
4473
4474
4475 void editor_set_line_wrapping(GeanyEditor *editor, gboolean wrap)
4476 {
4477 g_return_if_fail(editor != NULL);
4478
4479 editor->line_wrapping = wrap;
4480 sci_set_lines_wrapped(editor->sci, wrap);
4481 }
4482
4483
4484 /** Sets the indent type for @a editor.
4485 * @param editor Editor.
4486 * @param type Indent type.
4487 *
4488 * @since 0.16
4489 */
4490 void editor_set_indent_type(GeanyEditor *editor, GeanyIndentType type)
4491 {
4492 editor_set_indent(editor, type, editor->indent_width);
4493 }
4494
4495
4496 void editor_set_indent_width(GeanyEditor *editor, gint width)
4497 {
4498 editor_set_indent(editor, editor->indent_type, width);
4499 }
4500
4501
4502 void editor_set_indent(GeanyEditor *editor, GeanyIndentType type, gint width)
4503 {
4504 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
4505 ScintillaObject *sci = editor->sci;
4506 gboolean use_tabs = type != GEANY_INDENT_TYPE_SPACES;
4507
4508 editor->indent_type = type;
4509 editor->indent_width = width;
4510 sci_set_use_tabs(sci, use_tabs);
4511
4512 if (type == GEANY_INDENT_TYPE_BOTH)
4513 {
4514 sci_set_tab_width(sci, iprefs->hard_tab_width);
4515 if (iprefs->hard_tab_width != 8)
4516 {
4517 static gboolean warn = TRUE;
4518 if (warn)
4519 ui_set_statusbar(TRUE, _("Warning: non-standard hard tab width: %d != 8!"),
4520 iprefs->hard_tab_width);
4521 warn = FALSE;
4522 }
4523 }
4524 else
4525 sci_set_tab_width(sci, width);
4526
4527 SSM(sci, SCI_SETINDENT, width, 0);
4528
4529 /* remove indent spaces on backspace, if using any spaces to indent */
4530 SSM(sci, SCI_SETBACKSPACEUNINDENTS, type != GEANY_INDENT_TYPE_TABS, 0);
4531 }
4532
4533
4534 /* Convenience function for editor_goto_pos() to pass in a line number. */
4535 gboolean editor_goto_line(GeanyEditor *editor, gint line_no, gint offset)
4536 {
4537 gint pos;
4538
4539 g_return_val_if_fail(editor, FALSE);
4540 if (line_no < 0 || line_no >= sci_get_line_count(editor->sci))
4541 return FALSE;
4542
4543 if (offset != 0)
4544 {
4545 gint current_line = sci_get_current_line(editor->sci);
4546 line_no *= offset;
4547 line_no = current_line + line_no;
4548 }
4549
4550 pos = sci_get_position_from_line(editor->sci, line_no);
4551 return editor_goto_pos(editor, pos, TRUE);
4552 }
4553
4554
4555 /** Moves to position @a pos, switching to the document if necessary,
4556 * setting a marker if @a mark is set.
4557 *
4558 * @param editor Editor.
4559 * @param pos The position.
4560 * @param mark Whether to set a mark on the position.
4561 * @return @c TRUE if action has been performed, otherwise @c FALSE.
4562 *
4563 * @since 0.20
4564 **/
4565 gboolean editor_goto_pos(GeanyEditor *editor, gint pos, gboolean mark)
4566 {
4567 g_return_val_if_fail(editor, FALSE);
4568 if (G_UNLIKELY(pos < 0))
4569 return FALSE;
4570
4571 if (mark)
4572 {
4573 gint line = sci_get_line_from_position(editor->sci, pos);
4574
4575 /* mark the tag with the yellow arrow */
4576 sci_marker_delete_all(editor->sci, 0);
4577 sci_set_marker_at_line(editor->sci, line, 0);
4578 }
4579
4580 sci_goto_pos(editor->sci, pos, TRUE);
4581 editor->scroll_percent = 0.25F;
4582
4583 /* finally switch to the page */
4584 document_show_tab(editor->document);
4585 return TRUE;
4586 }
4587
4588
4589 static gboolean
4590 on_editor_scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer user_data)
4591 {
4592 GeanyEditor *editor = user_data;
4593
4594 /* Handle scroll events if Alt is pressed and scroll whole pages instead of a
4595 * few lines only, maybe this could/should be done in Scintilla directly */
4596 if (event->state & GDK_MOD1_MASK)
4597 {
4598 sci_send_command(editor->sci, (event->direction == GDK_SCROLL_DOWN) ? SCI_PAGEDOWN : SCI_PAGEUP);
4599 return TRUE;
4600 }
4601 else if (event->state & GDK_SHIFT_MASK)
4602 {
4603 gint amount = (event->direction == GDK_SCROLL_DOWN) ? 8 : -8;
4604
4605 sci_scroll_columns(editor->sci, amount);
4606 return TRUE;
4607 }
4608
4609 return FALSE; /* let Scintilla handle all other cases */
4610 }
4611
4612
4613 static gboolean editor_check_colourise(GeanyEditor *editor)
4614 {
4615 GeanyDocument *doc = editor->document;
4616
4617 if (!doc->priv->colourise_needed)
4618 return FALSE;
4619
4620 doc->priv->colourise_needed = FALSE;
4621 sci_colourise(editor->sci, 0, -1);
4622
4623 /* now that the current document is colourised, fold points are now accurate,
4624 * so force an update of the current function/tag. */
4625 symbols_get_current_function(NULL, NULL);
4626 ui_update_statusbar(NULL, -1);
4627
4628 return TRUE;
4629 }
4630
4631
4632 /* We only want to colourise just before drawing, to save startup time and
4633 * prevent unnecessary recolouring other documents after one is saved.
4634 * Really we want a "draw" signal but there doesn't seem to be one (expose is too late,
4635 * and "show" doesn't work). */
4636 static gboolean on_editor_focus_in(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
4637 {
4638 GeanyEditor *editor = user_data;
4639
4640 editor_check_colourise(editor);
4641 return FALSE;
4642 }
4643
4644
4645 static gboolean on_editor_expose_event(GtkWidget *widget, GdkEventExpose *event,
4646 gpointer user_data)
4647 {
4648 GeanyEditor *editor = user_data;
4649
4650 /* This is just to catch any uncolourised documents being drawn that didn't receive focus
4651 * for some reason, maybe it's not necessary but just in case. */
4652 editor_check_colourise(editor);
4653 return FALSE;
4654 }
4655
4656
4657 #if GTK_CHECK_VERSION(3, 0, 0)
4658 static gboolean on_editor_draw(GtkWidget *widget, cairo_t *cr, gpointer user_data)
4659 {
4660 return on_editor_expose_event(widget, NULL, user_data);
4661 }
4662 #endif
4663
4664
4665 static void setup_sci_keys(ScintillaObject *sci)
4666 {
4667 /* disable some Scintilla keybindings to be able to redefine them cleanly */
4668 sci_clear_cmdkey(sci, 'A' | (SCMOD_CTRL << 16)); /* select all */
4669 sci_clear_cmdkey(sci, 'D' | (SCMOD_CTRL << 16)); /* duplicate */
4670 sci_clear_cmdkey(sci, 'T' | (SCMOD_CTRL << 16)); /* line transpose */
4671 sci_clear_cmdkey(sci, 'T' | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line copy */
4672 sci_clear_cmdkey(sci, 'L' | (SCMOD_CTRL << 16)); /* line cut */
4673 sci_clear_cmdkey(sci, 'L' | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line delete */
4674 sci_clear_cmdkey(sci, SCK_DELETE | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line to end delete */
4675 sci_clear_cmdkey(sci, '/' | (SCMOD_CTRL << 16)); /* Previous word part */
4676 sci_clear_cmdkey(sci, '\\' | (SCMOD_CTRL << 16)); /* Next word part */
4677 sci_clear_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16)); /* scroll line up */
4678 sci_clear_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16)); /* scroll line down */
4679 sci_clear_cmdkey(sci, SCK_HOME); /* line start */
4680 sci_clear_cmdkey(sci, SCK_END); /* line end */
4681 sci_clear_cmdkey(sci, SCK_END | (SCMOD_ALT << 16)); /* visual line end */
4682
4683 if (editor_prefs.use_gtk_word_boundaries)
4684 {
4685 /* use GtkEntry-like word boundaries */
4686 sci_assign_cmdkey(sci, SCK_RIGHT | (SCMOD_CTRL << 16), SCI_WORDRIGHTEND);
4687 sci_assign_cmdkey(sci, SCK_RIGHT | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_WORDRIGHTENDEXTEND);
4688 sci_assign_cmdkey(sci, SCK_DELETE | (SCMOD_CTRL << 16), SCI_DELWORDRIGHTEND);
4689 }
4690 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_ALT << 16), SCI_LINESCROLLUP);
4691 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_ALT << 16), SCI_LINESCROLLDOWN);
4692 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16), SCI_PARAUP);
4693 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_PARAUPEXTEND);
4694 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16), SCI_PARADOWN);
4695 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_PARADOWNEXTEND);
4696
4697 sci_clear_cmdkey(sci, SCK_BACK | (SCMOD_ALT << 16)); /* clear Alt-Backspace (Undo) */
4698 }
4699
4700
4701 /* registers a Scintilla image from a named icon from the theme */
4702 static gboolean register_named_icon(ScintillaObject *sci, guint id, const gchar *name)
4703 {
4704 GError *error = NULL;
4705 GdkPixbuf *pixbuf;
4706 gint n_channels, rowstride, width, height;
4707 gint size;
4708
4709 gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &size, NULL);
4710 pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), name, size, 0, &error);
4711 if (! pixbuf)
4712 {
4713 g_warning("failed to load icon '%s': %s", name, error->message);
4714 g_error_free(error);
4715 return FALSE;
4716 }
4717
4718 n_channels = gdk_pixbuf_get_n_channels(pixbuf);
4719 rowstride = gdk_pixbuf_get_rowstride(pixbuf);
4720 width = gdk_pixbuf_get_width(pixbuf);
4721 height = gdk_pixbuf_get_height(pixbuf);
4722
4723 if (gdk_pixbuf_get_bits_per_sample(pixbuf) != 8 ||
4724 ! gdk_pixbuf_get_has_alpha(pixbuf) ||
4725 n_channels != 4 ||
4726 rowstride != width * n_channels)
4727 {
4728 g_warning("incompatible image data for icon '%s'", name);
4729 g_object_unref(pixbuf);
4730 return FALSE;
4731 }
4732
4733 SSM(sci, SCI_RGBAIMAGESETWIDTH, width, 0);
4734 SSM(sci, SCI_RGBAIMAGESETHEIGHT, height, 0);
4735 SSM(sci, SCI_REGISTERRGBAIMAGE, id, (sptr_t)gdk_pixbuf_get_pixels(pixbuf));
4736
4737 g_object_unref(pixbuf);
4738 return TRUE;
4739 }
4740
4741
4742 /* Create new editor widget (scintilla).
4743 * @note The @c "sci-notify" signal is connected separately. */
4744 static ScintillaObject *create_new_sci(GeanyEditor *editor)
4745 {
4746 ScintillaObject *sci;
4747
4748 sci = SCINTILLA(scintilla_new());
4749
4750 /* Scintilla doesn't support RTL languages properly and is primarily
4751 * intended to be used with LTR source code, so override the
4752 * GTK+ default text direction for the Scintilla widget. */
4753 gtk_widget_set_direction(GTK_WIDGET(sci), GTK_TEXT_DIR_LTR);
4754
4755 gtk_widget_show(GTK_WIDGET(sci));
4756
4757 sci_set_codepage(sci, SC_CP_UTF8);
4758 /*SSM(sci, SCI_SETWRAPSTARTINDENT, 4, 0);*/
4759 /* disable scintilla provided popup menu */
4760 sci_use_popup(sci, FALSE);
4761
4762 setup_sci_keys(sci);
4763
4764 sci_set_symbol_margin(sci, editor_prefs.show_markers_margin);
4765 sci_set_lines_wrapped(sci, editor_prefs.line_wrapping);
4766 sci_set_caret_policy_x(sci, CARET_JUMPS | CARET_EVEN, 0);
4767 /*sci_set_caret_policy_y(sci, CARET_JUMPS | CARET_EVEN, 0);*/
4768 SSM(sci, SCI_AUTOCSETSEPARATOR, '\n', 0);
4769 SSM(sci, SCI_SETSCROLLWIDTHTRACKING, 1, 0);
4770
4771 /* tag autocompletion images */
4772 register_named_icon(sci, 1, "classviewer-var");
4773 register_named_icon(sci, 2, "classviewer-method");
4774
4775 /* necessary for column mode editing, implemented in Scintilla since 2.0 */
4776 SSM(sci, SCI_SETADDITIONALSELECTIONTYPING, 1, 0);
4777
4778 /* virtual space */
4779 SSM(sci, SCI_SETVIRTUALSPACEOPTIONS, editor_prefs.show_virtual_space, 0);
4780
4781 /* only connect signals if this is for the document notebook, not split window */
4782 if (editor->sci == NULL)
4783 {
4784 g_signal_connect(sci, "button-press-event", G_CALLBACK(on_editor_button_press_event), editor);
4785 g_signal_connect(sci, "scroll-event", G_CALLBACK(on_editor_scroll_event), editor);
4786 g_signal_connect(sci, "motion-notify-event", G_CALLBACK(on_motion_event), NULL);
4787 g_signal_connect(sci, "focus-in-event", G_CALLBACK(on_editor_focus_in), editor);
4788 #if GTK_CHECK_VERSION(3, 0, 0)
4789 g_signal_connect(sci, "draw", G_CALLBACK(on_editor_draw), editor);
4790 #else
4791 g_signal_connect(sci, "expose-event", G_CALLBACK(on_editor_expose_event), editor);
4792 #endif
4793 }
4794 return sci;
4795 }
4796
4797
4798 /** Creates a new Scintilla @c GtkWidget based on the settings for @a editor.
4799 * @param editor Editor settings.
4800 * @return The new widget.
4801 *
4802 * @since 0.15
4803 **/
4804 ScintillaObject *editor_create_widget(GeanyEditor *editor)
4805 {
4806 const GeanyIndentPrefs *iprefs = get_default_indent_prefs();
4807 ScintillaObject *old, *sci;
4808
4809 /* temporarily change editor to use the new sci widget */
4810 old = editor->sci;
4811 sci = create_new_sci(editor);
4812 editor->sci = sci;
4813
4814 editor_set_indent(editor, iprefs->type, iprefs->width);
4815 editor_set_font(editor, interface_prefs.editor_font);
4816 editor_apply_update_prefs(editor);
4817
4818 /* if editor already had a widget, restore it */
4819 if (old)
4820 editor->sci = old;
4821 return sci;
4822 }
4823
4824
4825 GeanyEditor *editor_create(GeanyDocument *doc)
4826 {
4827 const GeanyIndentPrefs *iprefs = get_default_indent_prefs();
4828 GeanyEditor *editor = g_new0(GeanyEditor, 1);
4829
4830 editor->document = doc;
4831 doc->editor = editor; /* needed in case some editor functions/callbacks expect it */
4832
4833 editor->auto_indent = (iprefs->auto_indent_mode != GEANY_AUTOINDENT_NONE);
4834 editor->line_wrapping = editor_prefs.line_wrapping;
4835 editor->scroll_percent = -1.0F;
4836 editor->line_breaking = FALSE;
4837
4838 editor->sci = editor_create_widget(editor);
4839 return editor;
4840 }
4841
4842
4843 /* in case we need to free some fields in future */
4844 void editor_destroy(GeanyEditor *editor)
4845 {
4846 g_free(editor);
4847 }
4848
4849
4850 static void on_document_save(GObject *obj, GeanyDocument *doc)
4851 {
4852 gchar *f = g_build_filename(app->configdir, "snippets.conf", NULL);
4853
4854 if (utils_str_equal(doc->real_path, f))
4855 {
4856 /* reload snippets */
4857 editor_snippets_free();
4858 editor_snippets_init();
4859 }
4860 g_free(f);
4861 }
4862
4863
4864 gboolean editor_complete_word_part(GeanyEditor *editor)
4865 {
4866 gchar *entry;
4867
4868 g_return_val_if_fail(editor, FALSE);
4869
4870 if (!SSM(editor->sci, SCI_AUTOCACTIVE, 0, 0))
4871 return FALSE;
4872
4873 entry = sci_get_string(editor->sci, SCI_AUTOCGETCURRENTTEXT, 0);
4874
4875 /* if no word part, complete normally */
4876 if (!check_partial_completion(editor, entry))
4877 SSM(editor->sci, SCI_AUTOCCOMPLETE, 0, 0);
4878
4879 g_free(entry);
4880 return TRUE;
4881 }
4882
4883
4884 void editor_init(void)
4885 {
4886 static GeanyIndentPrefs indent_prefs;
4887 gchar *f;
4888
4889 memset(&editor_prefs, 0, sizeof(GeanyEditorPrefs));
4890 memset(&indent_prefs, 0, sizeof(GeanyIndentPrefs));
4891 editor_prefs.indentation = &indent_prefs;
4892
4893 /* use g_signal_connect_after() to allow plugins connecting to the signal before the default
4894 * handler (on_editor_notify) is called */
4895 g_signal_connect_after(geany_object, "editor-notify", G_CALLBACK(on_editor_notify), NULL);
4896
4897 f = g_build_filename(app->configdir, "snippets.conf", NULL);
4898 ui_add_config_file_menu_item(f, NULL, NULL);
4899 g_free(f);
4900 g_signal_connect(geany_object, "document-save", G_CALLBACK(on_document_save), NULL);
4901 }
4902
4903
4904 /* TODO: Should these be user-defined instead of hard-coded? */
4905 void editor_set_indentation_guides(GeanyEditor *editor)
4906 {
4907 gint mode;
4908 gint lexer;
4909
4910 g_return_if_fail(editor != NULL);
4911
4912 if (! editor_prefs.show_indent_guide)
4913 {
4914 sci_set_indentation_guides(editor->sci, SC_IV_NONE);
4915 return;
4916 }
4917
4918 lexer = sci_get_lexer(editor->sci);
4919 switch (lexer)
4920 {
4921 /* Lines added/removed are prefixed with +/- characters, so
4922 * those lines will not be shown with any indentation guides.
4923 * It can be distracting that only a few of lines in a diff/patch
4924 * file will show the guides. */
4925 case SCLEX_DIFF:
4926 mode = SC_IV_NONE;
4927 break;
4928
4929 /* These languages use indentation for control blocks; the "look forward" method works
4930 * best here */
4931 case SCLEX_PYTHON:
4932 case SCLEX_HASKELL:
4933 case SCLEX_MAKEFILE:
4934 case SCLEX_ASM:
4935 case SCLEX_SQL:
4936 case SCLEX_COBOL:
4937 case SCLEX_PROPERTIES:
4938 case SCLEX_FORTRAN: /* Is this the best option for Fortran? */
4939 case SCLEX_CAML:
4940 mode = SC_IV_LOOKFORWARD;
4941 break;
4942
4943 /* C-like (structured) languages benefit from the "look both" method */
4944 case SCLEX_CPP:
4945 case SCLEX_HTML:
4946 case SCLEX_XML:
4947 case SCLEX_PERL:
4948 case SCLEX_LATEX:
4949 case SCLEX_LUA:
4950 case SCLEX_PASCAL:
4951 case SCLEX_RUBY:
4952 case SCLEX_TCL:
4953 case SCLEX_F77:
4954 case SCLEX_CSS:
4955 case SCLEX_BASH:
4956 case SCLEX_VHDL:
4957 case SCLEX_FREEBASIC:
4958 case SCLEX_D:
4959 case SCLEX_OCTAVE:
4960 case SCLEX_RUST:
4961 mode = SC_IV_LOOKBOTH;
4962 break;
4963
4964 default:
4965 mode = SC_IV_REAL;
4966 break;
4967 }
4968
4969 sci_set_indentation_guides(editor->sci, mode);
4970 }
4971
4972
4973 /* Apply just the prefs that can change in the Preferences dialog */
4974 void editor_apply_update_prefs(GeanyEditor *editor)
4975 {
4976 ScintillaObject *sci;
4977
4978 g_return_if_fail(editor != NULL);
4979
4980 if (main_status.quitting)
4981 return;
4982
4983 sci = editor->sci;
4984
4985 sci_set_mark_long_lines(sci, editor_get_long_line_type(),
4986 editor_get_long_line_column(), editor_prefs.long_line_color);
4987
4988 /* update indent width, tab width */
4989 editor_set_indent(editor, editor->indent_type, editor->indent_width);
4990 sci_set_tab_indents(sci, editor_prefs.use_tab_to_indent);
4991
4992 sci_assign_cmdkey(sci, SCK_HOME | (SCMOD_SHIFT << 16),
4993 editor_prefs.smart_home_key ? SCI_VCHOMEEXTEND : SCI_HOMEEXTEND);
4994 sci_assign_cmdkey(sci, SCK_HOME | ((SCMOD_SHIFT | SCMOD_ALT) << 16),
4995 editor_prefs.smart_home_key ? SCI_VCHOMERECTEXTEND : SCI_HOMERECTEXTEND);
4996
4997 sci_set_autoc_max_height(sci, editor_prefs.symbolcompletion_max_height);
4998 SSM(sci, SCI_AUTOCSETDROPRESTOFWORD, editor_prefs.completion_drops_rest_of_word, 0);
4999
5000 editor_set_indentation_guides(editor);
5001
5002 sci_set_visible_white_spaces(sci, editor_prefs.show_white_space);
5003 sci_set_visible_eols(sci, editor_prefs.show_line_endings);
5004 sci_set_symbol_margin(sci, editor_prefs.show_markers_margin);
5005 sci_set_line_numbers(sci, editor_prefs.show_linenumber_margin, 0);
5006
5007 sci_set_folding_margin_visible(sci, editor_prefs.folding);
5008
5009 /* virtual space */
5010 SSM(sci, SCI_SETVIRTUALSPACEOPTIONS, editor_prefs.show_virtual_space, 0);
5011
5012 /* (dis)allow scrolling past end of document */
5013 sci_set_scroll_stop_at_last_line(sci, editor_prefs.scroll_stop_at_last_line);
5014
5015 sci_set_scrollbar_mode(sci, editor_prefs.show_scrollbars);
5016 }
5017
5018
5019 /* This is for tab-indents, space aligns formatted code. Spaces should be preserved. */
5020 static void change_tab_indentation(GeanyEditor *editor, gint line, gboolean increase)
5021 {
5022 ScintillaObject *sci = editor->sci;
5023 gint pos = sci_get_position_from_line(sci, line);
5024
5025 if (increase)
5026 {
5027 sci_insert_text(sci, pos, "\t");
5028 }
5029 else
5030 {
5031 if (sci_get_char_at(sci, pos) == '\t')
5032 {
5033 sci_set_selection(sci, pos, pos + 1);
5034 sci_replace_sel(sci, "");
5035 }
5036 else /* remove spaces only if no tabs */
5037 {
5038 gint width = sci_get_line_indentation(sci, line);
5039
5040 width -= editor_get_indent_prefs(editor)->width;
5041 sci_set_line_indentation(sci, line, width);
5042 }
5043 }
5044 }
5045
5046
5047 static void editor_change_line_indent(GeanyEditor *editor, gint line, gboolean increase)
5048 {
5049 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
5050 ScintillaObject *sci = editor->sci;
5051
5052 if (iprefs->type == GEANY_INDENT_TYPE_TABS)
5053 change_tab_indentation(editor, line, increase);
5054 else
5055 {
5056 gint width = sci_get_line_indentation(sci, line);
5057
5058 width += increase ? iprefs->width : -iprefs->width;
5059 sci_set_line_indentation(sci, line, width);
5060 }
5061 }
5062
5063
5064 void editor_indent(GeanyEditor *editor, gboolean increase)
5065 {
5066 ScintillaObject *sci = editor->sci;
5067 gint caret_pos, caret_line, caret_offset, caret_indent_pos, caret_line_len;
5068 gint anchor_pos, anchor_line, anchor_offset, anchor_indent_pos, anchor_line_len;
5069
5070 /* backup information needed to restore caret and anchor */
5071 caret_pos = sci_get_current_position(sci);
5072 anchor_pos = SSM(sci, SCI_GETANCHOR, 0, 0);
5073 caret_line = sci_get_line_from_position(sci, caret_pos);
5074 anchor_line = sci_get_line_from_position(sci, anchor_pos);
5075 caret_offset = caret_pos - sci_get_position_from_line(sci, caret_line);
5076 anchor_offset = anchor_pos - sci_get_position_from_line(sci, anchor_line);
5077 caret_indent_pos = sci_get_line_indent_position(sci, caret_line);
5078 anchor_indent_pos = sci_get_line_indent_position(sci, anchor_line);
5079 caret_line_len = sci_get_line_length(sci, caret_line);
5080 anchor_line_len = sci_get_line_length(sci, anchor_line);
5081
5082 if (sci_get_lines_selected(sci) <= 1)
5083 {
5084 editor_change_line_indent(editor, sci_get_current_line(sci), increase);
5085 }
5086 else
5087 {
5088 gint start, end;
5089 gint line, lstart, lend;
5090
5091 editor_select_lines(editor, FALSE);
5092 start = sci_get_selection_start(sci);
5093 end = sci_get_selection_end(sci);
5094 lstart = sci_get_line_from_position(sci, start);
5095 lend = sci_get_line_from_position(sci, end);
5096 if (end == sci_get_length(sci))
5097 lend++; /* for last line with text on it */
5098
5099 sci_start_undo_action(sci);
5100 for (line = lstart; line < lend; line++)
5101 {
5102 editor_change_line_indent(editor, line, increase);
5103 }
5104 sci_end_undo_action(sci);
5105 }
5106
5107 /* restore caret and anchor position */
5108 if (caret_pos >= caret_indent_pos)
5109 caret_offset += sci_get_line_length(sci, caret_line) - caret_line_len;
5110 if (anchor_pos >= anchor_indent_pos)
5111 anchor_offset += sci_get_line_length(sci, anchor_line) - anchor_line_len;
5112
5113 SSM(sci, SCI_SETCURRENTPOS, sci_get_position_from_line(sci, caret_line) + caret_offset, 0);
5114 SSM(sci, SCI_SETANCHOR, sci_get_position_from_line(sci, anchor_line) + anchor_offset, 0);
5115 }
5116
5117
5118 /** Gets snippet by name.
5119 *
5120 * If @a editor is passed, returns a snippet specific to the document filetype.
5121 * If @a editor is @c NULL, returns a snippet from the default set.
5122 *
5123 * @param editor Editor or @c NULL.
5124 * @param snippet_name Snippet name.
5125 * @return snippet or @c NULL if it was not found. Must not be freed.
5126 */
5127 const gchar *editor_find_snippet(GeanyEditor *editor, const gchar *snippet_name)
5128 {
5129 const gchar *subhash_name = editor ? editor->document->file_type->name : "Default";
5130 GHashTable *subhash = g_hash_table_lookup(snippet_hash, subhash_name);
5131
5132 return subhash ? g_hash_table_lookup(subhash, snippet_name) : NULL;
5133 }
5134
5135
5136 /** Replaces all special sequences in @a snippet and inserts it at @a pos.
5137 * If you insert at the current position, consider calling @c sci_scroll_caret()
5138 * after this function.
5139 * @param editor .
5140 * @param pos .
5141 * @param snippet .
5142 */
5143 void editor_insert_snippet(GeanyEditor *editor, gint pos, const gchar *snippet)
5144 {
5145 GString *pattern;
5146
5147 pattern = g_string_new(snippet);
5148 snippets_make_replacements(editor, pattern);
5149 editor_insert_text_block(editor, pattern->str, pos, -1, -1, TRUE);
5150 g_string_free(pattern, TRUE);
5151 }
A fast and lightweight IDE