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