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