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