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