?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
javascript: Stop using longjmp() and friends
[geany-mirror.git] / src / editor.c
blob9e0c95fee75b3f965fd5f748dcd781665268fafa
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 = event->state & gtk_accelerator_get_default_mod_mask();
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 == GDK_CONTROL_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 (match_last_chars(sci, pos, "->") || match_last_chars(sci, pos, "::"))
713 pos--;
714 else if (ft->id == GEANY_FILETYPES_CPP && 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 const GeanyIndentPrefs *
1206 editor_get_indent_prefs(GeanyEditor *editor)
1207 {
1208 static GeanyIndentPrefs iprefs;
1209 const GeanyIndentPrefs *dprefs = get_default_indent_prefs();
1210
1211 /* Return the address of the default prefs to allow returning default and editor
1212 * pref pointers without invalidating the contents of either. */
1213 if (editor == NULL)
1214 return dprefs;
1215
1216 iprefs = *dprefs;
1217 iprefs.type = editor->indent_type;
1218 iprefs.width = editor->indent_width;
1219
1220 /* if per-document auto-indent is enabled, but we don't have a global mode set,
1221 * just use basic auto-indenting */
1222 if (editor->auto_indent && iprefs.auto_indent_mode == GEANY_AUTOINDENT_NONE)
1223 iprefs.auto_indent_mode = GEANY_AUTOINDENT_BASIC;
1224
1225 if (!editor->auto_indent)
1226 iprefs.auto_indent_mode = GEANY_AUTOINDENT_NONE;
1227
1228 return &iprefs;
1229 }
1230
1231
1232 static void on_new_line_added(GeanyEditor *editor)
1233 {
1234 ScintillaObject *sci = editor->sci;
1235 gint line = sci_get_current_line(sci);
1236
1237 /* simple indentation */
1238 if (editor->auto_indent)
1239 {
1240 insert_indent_after_line(editor, line - 1);
1241 }
1242
1243 if (get_project_pref(auto_continue_multiline))
1244 { /* " * " auto completion in multiline C/C++/D/Java comments */
1245 auto_multiline(editor, line);
1246 }
1247
1248 if (editor_prefs.newline_strip)
1249 { /* strip the trailing spaces on the previous line */
1250 editor_strip_line_trailing_spaces(editor, line - 1);
1251 }
1252 }
1253
1254
1255 static gboolean lexer_has_braces(ScintillaObject *sci)
1256 {
1257 gint lexer = sci_get_lexer(sci);
1258
1259 switch (lexer)
1260 {
1261 case SCLEX_CPP:
1262 case SCLEX_D:
1263 case SCLEX_HTML: /* for PHP & JS */
1264 case SCLEX_PASCAL: /* for multiline comments? */
1265 case SCLEX_BASH:
1266 case SCLEX_PERL:
1267 case SCLEX_TCL:
1268 case SCLEX_R:
1269 case SCLEX_RUST:
1270 return TRUE;
1271 default:
1272 return FALSE;
1273 }
1274 }
1275
1276
1277 /* Read indent chars for the line that pos is on into indent global variable.
1278 * Note: Use sci_get_line_indentation() and get_whitespace()/editor_insert_text_block()
1279 * instead in any new code. */
1280 static void read_indent(GeanyEditor *editor, gint pos)
1281 {
1282 ScintillaObject *sci = editor->sci;
1283 guint i, len, j = 0;
1284 gint line;
1285 gchar *linebuf;
1286
1287 line = sci_get_line_from_position(sci, pos);
1288
1289 len = sci_get_line_length(sci, line);
1290 linebuf = sci_get_line(sci, line);
1291
1292 for (i = 0; i < len && j <= (sizeof(indent) - 1); i++)
1293 {
1294 if (linebuf[i] == ' ' || linebuf[i] == '\t') /* simple indentation */
1295 indent[j++] = linebuf[i];
1296 else
1297 break;
1298 }
1299 indent[j] = '\0';
1300 g_free(linebuf);
1301 }
1302
1303
1304 static gint get_brace_indent(ScintillaObject *sci, gint line)
1305 {
1306 gint start = sci_get_position_from_line(sci, line);
1307 gint end = sci_get_line_end_position(sci, line) - 1;
1308 gint lexer = sci_get_lexer(sci);
1309 gint count = 0;
1310 gint pos;
1311
1312 for (pos = end; pos >= start && count < 1; pos--)
1313 {
1314 if (highlighting_is_code_style(lexer, sci_get_style_at(sci, pos)))
1315 {
1316 gchar c = sci_get_char_at(sci, pos);
1317
1318 if (c == '{')
1319 count ++;
1320 else if (c == '}')
1321 count --;
1322 }
1323 }
1324
1325 return count > 0 ? 1 : 0;
1326 }
1327
1328
1329 /* gets the last code position on a line
1330 * warning: if there is no code position on the line, returns the start position */
1331 static gint get_sci_line_code_end_position(ScintillaObject *sci, gint line)
1332 {
1333 gint start = sci_get_position_from_line(sci, line);
1334 gint lexer = sci_get_lexer(sci);
1335 gint pos;
1336
1337 for (pos = sci_get_line_end_position(sci, line) - 1; pos > start; pos--)
1338 {
1339 gint style = sci_get_style_at(sci, pos);
1340
1341 if (highlighting_is_code_style(lexer, style) && ! isspace(sci_get_char_at(sci, pos)))
1342 break;
1343 }
1344
1345 return pos;
1346 }
1347
1348
1349 static gint get_python_indent(ScintillaObject *sci, gint line)
1350 {
1351 gint last_char = get_sci_line_code_end_position(sci, line);
1352
1353 /* add extra indentation for Python after colon */
1354 if (sci_get_char_at(sci, last_char) == ':' &&
1355 sci_get_style_at(sci, last_char) == SCE_P_OPERATOR)
1356 {
1357 return 1;
1358 }
1359 return 0;
1360 }
1361
1362
1363 static gint get_xml_indent(ScintillaObject *sci, gint line)
1364 {
1365 gboolean need_close = FALSE;
1366 gint end = get_sci_line_code_end_position(sci, line);
1367 gint pos;
1368
1369 /* don't indent if there's a closing tag to the right of the cursor */
1370 pos = sci_get_current_position(sci);
1371 if (sci_get_char_at(sci, pos) == '<' &&
1372 sci_get_char_at(sci, pos + 1) == '/')
1373 return 0;
1374
1375 if (sci_get_char_at(sci, end) == '>' &&
1376 sci_get_char_at(sci, end - 1) != '/')
1377 {
1378 gint style = sci_get_style_at(sci, end);
1379
1380 if (style == SCE_H_TAG || style == SCE_H_TAGUNKNOWN)
1381 {
1382 gint start = sci_get_position_from_line(sci, line);
1383 gchar *line_contents = sci_get_contents_range(sci, start, end + 1);
1384 gchar *opened_tag_name = utils_find_open_xml_tag(line_contents, end + 1 - start);
1385
1386 if (!EMPTY(opened_tag_name))
1387 {
1388 need_close = TRUE;
1389 if (sci_get_lexer(sci) == SCLEX_HTML && utils_is_short_html_tag(opened_tag_name))
1390 need_close = FALSE;
1391 }
1392 g_free(line_contents);
1393 g_free(opened_tag_name);
1394 }
1395 }
1396
1397 return need_close ? 1 : 0;
1398 }
1399
1400
1401 static gint get_indent_size_after_line(GeanyEditor *editor, gint line)
1402 {
1403 ScintillaObject *sci = editor->sci;
1404 gint size;
1405 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1406
1407 g_return_val_if_fail(line >= 0, 0);
1408
1409 size = sci_get_line_indentation(sci, line);
1410
1411 if (iprefs->auto_indent_mode > GEANY_AUTOINDENT_BASIC)
1412 {
1413 gint additional_indent = 0;
1414
1415 if (lexer_has_braces(sci))
1416 additional_indent = iprefs->width * get_brace_indent(sci, line);
1417 else if (sci_get_lexer(sci) == SCLEX_PYTHON) /* Python/Cython */
1418 additional_indent = iprefs->width * get_python_indent(sci, line);
1419
1420 /* HTML lexer "has braces" because of PHP and JavaScript. If get_brace_indent() did not
1421 * recommend us to insert additional indent, we are probably not in PHP/JavaScript chunk and
1422 * should make the XML-related check */
1423 if (additional_indent == 0 &&
1424 (sci_get_lexer(sci) == SCLEX_HTML ||
1425 sci_get_lexer(sci) == SCLEX_XML) &&
1426 editor->document->file_type->priv->xml_indent_tags)
1427 {
1428 size += iprefs->width * get_xml_indent(sci, line);
1429 }
1430
1431 size += additional_indent;
1432 }
1433 return size;
1434 }
1435
1436
1437 static void insert_indent_after_line(GeanyEditor *editor, gint line)
1438 {
1439 ScintillaObject *sci = editor->sci;
1440 gint line_indent = sci_get_line_indentation(sci, line);
1441 gint size = get_indent_size_after_line(editor, line);
1442 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1443 gchar *text;
1444
1445 if (size == 0)
1446 return;
1447
1448 if (iprefs->type == GEANY_INDENT_TYPE_TABS && size == line_indent)
1449 {
1450 /* support tab indents, space aligns style - copy last line 'indent' exactly */
1451 gint start = sci_get_position_from_line(sci, line);
1452 gint end = sci_get_line_indent_position(sci, line);
1453
1454 text = sci_get_contents_range(sci, start, end);
1455 }
1456 else
1457 {
1458 text = get_whitespace(iprefs, size);
1459 }
1460 sci_add_text(sci, text);
1461 g_free(text);
1462 }
1463
1464
1465 static void auto_close_chars(ScintillaObject *sci, gint pos, gchar c)
1466 {
1467 const gchar *closing_char = NULL;
1468 gint end_pos = -1;
1469
1470 if (utils_isbrace(c, 0))
1471 end_pos = sci_find_matching_brace(sci, pos - 1);
1472
1473 switch (c)
1474 {
1475 case '(':
1476 if ((editor_prefs.autoclose_chars & GEANY_AC_PARENTHESIS) && end_pos == -1)
1477 closing_char = ")";
1478 break;
1479 case '{':
1480 if ((editor_prefs.autoclose_chars & GEANY_AC_CBRACKET) && end_pos == -1)
1481 closing_char = "}";
1482 break;
1483 case '[':
1484 if ((editor_prefs.autoclose_chars & GEANY_AC_SBRACKET) && end_pos == -1)
1485 closing_char = "]";
1486 break;
1487 case '\'':
1488 if (editor_prefs.autoclose_chars & GEANY_AC_SQUOTE)
1489 closing_char = "'";
1490 break;
1491 case '"':
1492 if (editor_prefs.autoclose_chars & GEANY_AC_DQUOTE)
1493 closing_char = "\"";
1494 break;
1495 }
1496
1497 if (closing_char != NULL)
1498 {
1499 sci_add_text(sci, closing_char);
1500 sci_set_current_position(sci, pos, TRUE);
1501 }
1502 }
1503
1504
1505 /* Finds a corresponding matching brace to the given pos
1506 * (this is taken from Scintilla Editor.cxx,
1507 * fit to work with close_block) */
1508 static gint brace_match(ScintillaObject *sci, gint pos)
1509 {
1510 gchar chBrace = sci_get_char_at(sci, pos);
1511 gchar chSeek = utils_brace_opposite(chBrace);
1512 gchar chAtPos;
1513 gint direction = -1;
1514 gint styBrace;
1515 gint depth = 1;
1516 gint styAtPos;
1517
1518 /* Hack: we need the style at @p pos but it isn't computed yet, so force styling
1519 * of this very position */
1520 sci_colourise(sci, pos, pos + 1);
1521
1522 styBrace = sci_get_style_at(sci, pos);
1523
1524 if (utils_is_opening_brace(chBrace, editor_prefs.brace_match_ltgt))
1525 direction = 1;
1526
1527 pos += direction;
1528 while ((pos >= 0) && (pos < sci_get_length(sci)))
1529 {
1530 chAtPos = sci_get_char_at(sci, pos);
1531 styAtPos = sci_get_style_at(sci, pos);
1532
1533 if ((pos > sci_get_end_styled(sci)) || (styAtPos == styBrace))
1534 {
1535 if (chAtPos == chBrace)
1536 depth++;
1537 if (chAtPos == chSeek)
1538 depth--;
1539 if (depth == 0)
1540 return pos;
1541 }
1542 pos += direction;
1543 }
1544 return -1;
1545 }
1546
1547
1548 /* Called after typing '}'. */
1549 static void close_block(GeanyEditor *editor, gint pos)
1550 {
1551 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
1552 gint x = 0, cnt = 0;
1553 gint line, line_len;
1554 gchar *text, *line_buf;
1555 ScintillaObject *sci;
1556 gint line_indent, last_indent;
1557
1558 if (iprefs->auto_indent_mode < GEANY_AUTOINDENT_CURRENTCHARS)
1559 return;
1560 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
1561
1562 sci = editor->sci;
1563
1564 if (! lexer_has_braces(sci))
1565 return;
1566
1567 line = sci_get_line_from_position(sci, pos);
1568 line_len = sci_get_line_end_position(sci, line) - sci_get_position_from_line(sci, line);
1569
1570 /* check that the line is empty, to not kill text in the line */
1571 line_buf = sci_get_line(sci, line);
1572 line_buf[line_len] = '\0';
1573 while (x < line_len)
1574 {
1575 if (isspace(line_buf[x]))
1576 cnt++;
1577 x++;
1578 }
1579 g_free(line_buf);
1580
1581 if ((line_len - 1) != cnt)
1582 return;
1583
1584 if (iprefs->auto_indent_mode == GEANY_AUTOINDENT_MATCHBRACES)
1585 {
1586 gint start_brace = brace_match(sci, pos);
1587
1588 if (start_brace >= 0)
1589 {
1590 gint line_start;
1591 gint brace_line = sci_get_line_from_position(sci, start_brace);
1592 gint size = sci_get_line_indentation(sci, brace_line);
1593 gchar *ind = get_whitespace(iprefs, size);
1594
1595 text = g_strconcat(ind, "}", NULL);
1596 line_start = sci_get_position_from_line(sci, line);
1597 sci_set_anchor(sci, line_start);
1598 sci_replace_sel(sci, text);
1599 g_free(text);
1600 g_free(ind);
1601 return;
1602 }
1603 /* fall through - unmatched brace (possibly because of TCL, PHP lexer bugs) */
1604 }
1605
1606 /* GEANY_AUTOINDENT_CURRENTCHARS */
1607 line_indent = sci_get_line_indentation(sci, line);
1608 last_indent = sci_get_line_indentation(sci, line - 1);
1609
1610 if (line_indent < last_indent)
1611 return;
1612 line_indent -= iprefs->width;
1613 line_indent = MAX(0, line_indent);
1614 sci_set_line_indentation(sci, line, line_indent);
1615 }
1616
1617
1618 /* checks whether @p c is an ASCII character (e.g. < 0x80) */
1619 #define IS_ASCII(c) (((unsigned char)(c)) < 0x80)
1620
1621
1622 /* Reads the word at given cursor position and writes it into the given buffer. The buffer will be
1623 * NULL terminated in any case, even when the word is truncated because wordlen is too small.
1624 * position can be -1, then the current position is used.
1625 * wc are the wordchars to use, if NULL, GEANY_WORDCHARS will be used */
1626 static void read_current_word(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen,
1627 const gchar *wc, gboolean stem)
1628 {
1629 gint line, line_start, startword, endword;
1630 gchar *chunk;
1631 ScintillaObject *sci;
1632
1633 g_return_if_fail(editor != NULL);
1634 sci = editor->sci;
1635
1636 if (pos == -1)
1637 pos = sci_get_current_position(sci);
1638
1639 line = sci_get_line_from_position(sci, pos);
1640 line_start = sci_get_position_from_line(sci, line);
1641 startword = pos - line_start;
1642 endword = pos - line_start;
1643
1644 word[0] = '\0';
1645 chunk = sci_get_line(sci, line);
1646
1647 if (wc == NULL)
1648 wc = GEANY_WORDCHARS;
1649
1650 /* the checks for "c < 0" are to allow any Unicode character which should make the code
1651 * a little bit more Unicode safe, anyway, this allows also any Unicode punctuation,
1652 * TODO: improve this code */
1653 while (startword > 0 && (strchr(wc, chunk[startword - 1]) || ! IS_ASCII(chunk[startword - 1])))
1654 startword--;
1655 if (!stem)
1656 {
1657 while (chunk[endword] != 0 && (strchr(wc, chunk[endword]) || ! IS_ASCII(chunk[endword])))
1658 endword++;
1659 }
1660
1661 if (startword != endword)
1662 {
1663 chunk[endword] = '\0';
1664
1665 g_strlcpy(word, chunk + startword, wordlen); /* ensure null terminated */
1666 }
1667 else
1668 g_strlcpy(word, "", wordlen);
1669
1670 g_free(chunk);
1671 }
1672
1673
1674 /* Reads the word at given cursor position and writes it into the given buffer. The buffer will be
1675 * NULL terminated in any case, even when the word is truncated because wordlen is too small.
1676 * position can be -1, then the current position is used.
1677 * wc are the wordchars to use, if NULL, GEANY_WORDCHARS will be used */
1678 void editor_find_current_word(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen,
1679 const gchar *wc)
1680 {
1681 read_current_word(editor, pos, word, wordlen, wc, FALSE);
1682 }
1683
1684
1685 /* Same as editor_find_current_word() but uses editor's word boundaries to decide what the word
1686 * is. This should be used e.g. to get the word to search for */
1687 void editor_find_current_word_sciwc(GeanyEditor *editor, gint pos, gchar *word, gsize wordlen)
1688 {
1689 gint start;
1690 gint end;
1691
1692 g_return_if_fail(editor != NULL);
1693
1694 if (pos == -1)
1695 pos = sci_get_current_position(editor->sci);
1696
1697 start = sci_word_start_position(editor->sci, pos, TRUE);
1698 end = sci_word_end_position(editor->sci, pos, TRUE);
1699
1700 if (start == end) /* caret in whitespaces sequence */
1701 *word = 0;
1702 else
1703 {
1704 if ((guint)(end - start) >= wordlen)
1705 end = start + (wordlen - 1);
1706 sci_get_text_range(editor->sci, start, end, word);
1707 }
1708 }
1709
1710
1711 /**
1712 * Finds the word at the position specified by @a pos. If any word is found, it is returned.
1713 * Otherwise NULL is returned.
1714 * Additional wordchars can be specified to define what to consider as a word.
1715 *
1716 * @param editor The editor to operate on.
1717 * @param pos The position where the word should be read from.
1718 * May be @c -1 to use the current position.
1719 * @param wordchars The wordchars to separate words. wordchars mean all characters to count
1720 * as part of a word. May be @c NULL to use the default wordchars,
1721 * see @ref GEANY_WORDCHARS.
1722 *
1723 * @return A newly-allocated string containing the word at the given @a pos or @c NULL.
1724 * Should be freed when no longer needed.
1725 *
1726 * @since 0.16
1727 */
1728 gchar *editor_get_word_at_pos(GeanyEditor *editor, gint pos, const gchar *wordchars)
1729 {
1730 static gchar cword[GEANY_MAX_WORD_LENGTH];
1731
1732 g_return_val_if_fail(editor != NULL, FALSE);
1733
1734 read_current_word(editor, pos, cword, sizeof(cword), wordchars, FALSE);
1735
1736 return (*cword == '\0') ? NULL : g_strdup(cword);
1737 }
1738
1739
1740 /* Read the word up to position @a pos. */
1741 static const gchar *
1742 editor_read_word_stem(GeanyEditor *editor, gint pos, const gchar *wordchars)
1743 {
1744 static gchar word[GEANY_MAX_WORD_LENGTH];
1745
1746 read_current_word(editor, pos, word, sizeof word, wordchars, TRUE);
1747
1748 return (*word) ? word : NULL;
1749 }
1750
1751
1752 static gint find_previous_brace(ScintillaObject *sci, gint pos)
1753 {
1754 gint orig_pos = pos;
1755
1756 while (pos >= 0 && pos > orig_pos - 300)
1757 {
1758 gchar c = sci_get_char_at(sci, pos);
1759 if (utils_is_opening_brace(c, editor_prefs.brace_match_ltgt))
1760 return pos;
1761 pos--;
1762 }
1763 return -1;
1764 }
1765
1766
1767 static gint find_start_bracket(ScintillaObject *sci, gint pos)
1768 {
1769 gint brackets = 0;
1770 gint orig_pos = pos;
1771
1772 while (pos > 0 && pos > orig_pos - 300)
1773 {
1774 gchar c = sci_get_char_at(sci, pos);
1775
1776 if (c == ')') brackets++;
1777 else if (c == '(') brackets--;
1778 if (brackets < 0) return pos; /* found start bracket */
1779 pos--;
1780 }
1781 return -1;
1782 }
1783
1784
1785 static gboolean append_calltip(GString *str, const TMTag *tag, filetype_id ft_id)
1786 {
1787 if (! tag->arglist)
1788 return FALSE;
1789
1790 if (ft_id != GEANY_FILETYPES_PASCAL)
1791 { /* usual calltips: "retval tagname (arglist)" */
1792 if (tag->var_type)
1793 {
1794 guint i;
1795
1796 g_string_append(str, tag->var_type);
1797 for (i = 0; i < tag->pointerOrder; i++)
1798 {
1799 g_string_append_c(str, '*');
1800 }
1801 g_string_append_c(str, ' ');
1802 }
1803 if (tag->scope)
1804 {
1805 const gchar *cosep = symbols_get_context_separator(ft_id);
1806
1807 g_string_append(str, tag->scope);
1808 g_string_append(str, cosep);
1809 }
1810 g_string_append(str, tag->name);
1811 g_string_append_c(str, ' ');
1812 g_string_append(str, tag->arglist);
1813 }
1814 else
1815 { /* special case Pascal calltips: "tagname (arglist) : retval" */
1816 g_string_append(str, tag->name);
1817 g_string_append_c(str, ' ');
1818 g_string_append(str, tag->arglist);
1819
1820 if (!EMPTY(tag->var_type))
1821 {
1822 g_string_append(str, " : ");
1823 g_string_append(str, tag->var_type);
1824 }
1825 }
1826
1827 return TRUE;
1828 }
1829
1830
1831 static gchar *find_calltip(const gchar *word, GeanyFiletype *ft)
1832 {
1833 const GPtrArray *tags;
1834 const TMTagType arg_types = tm_tag_function_t | tm_tag_prototype_t |
1835 tm_tag_method_t | tm_tag_macro_with_arg_t;
1836 TMTagAttrType *attrs = NULL;
1837 TMTag *tag;
1838 GString *str = NULL;
1839 guint i;
1840
1841 g_return_val_if_fail(ft && word && *word, NULL);
1842
1843 /* use all types in case language uses wrong tag type e.g. python "members" instead of "methods" */
1844 tags = tm_workspace_find(word, tm_tag_max_t, attrs, FALSE, ft->lang);
1845 if (tags->len == 0)
1846 return NULL;
1847
1848 tag = TM_TAG(tags->pdata[0]);
1849
1850 if (ft->id == GEANY_FILETYPES_D &&
1851 (tag->type == tm_tag_class_t || tag->type == tm_tag_struct_t))
1852 {
1853 /* user typed e.g. 'new Classname(' so lookup D constructor Classname::this() */
1854 tags = tm_workspace_find_scoped("this", tag->name,
1855 arg_types, attrs, FALSE, ft->lang, TRUE);
1856 if (tags->len == 0)
1857 return NULL;
1858 }
1859
1860 /* remove tags with no argument list */
1861 for (i = 0; i < tags->len; i++)
1862 {
1863 tag = TM_TAG(tags->pdata[i]);
1864
1865 if (! tag->arglist)
1866 tags->pdata[i] = NULL;
1867 }
1868 tm_tags_prune((GPtrArray *) tags);
1869 if (tags->len == 0)
1870 return NULL;
1871 else
1872 { /* remove duplicate calltips */
1873 TMTagAttrType sort_attr[] = {tm_tag_attr_name_t, tm_tag_attr_scope_t,
1874 tm_tag_attr_arglist_t, 0};
1875
1876 tm_tags_sort((GPtrArray *) tags, sort_attr, TRUE, FALSE);
1877 }
1878
1879 /* if the current word has changed since last time, start with the first tag match */
1880 if (! utils_str_equal(word, calltip.last_word))
1881 calltip.tag_index = 0;
1882 /* cache the current word for next time */
1883 g_free(calltip.last_word);
1884 calltip.last_word = g_strdup(word);
1885 calltip.tag_index = MIN(calltip.tag_index, tags->len - 1); /* ensure tag_index is in range */
1886
1887 for (i = calltip.tag_index; i < tags->len; i++)
1888 {
1889 tag = TM_TAG(tags->pdata[i]);
1890
1891 if (str == NULL)
1892 {
1893 str = g_string_new(NULL);
1894 if (calltip.tag_index > 0)
1895 g_string_prepend(str, "\001 "); /* up arrow */
1896 append_calltip(str, tag, FILETYPE_ID(ft));
1897 }
1898 else /* add a down arrow */
1899 {
1900 if (calltip.tag_index > 0) /* already have an up arrow */
1901 g_string_insert_c(str, 1, '\002');
1902 else
1903 g_string_prepend(str, "\002 ");
1904 break;
1905 }
1906 }
1907 if (str)
1908 {
1909 gchar *result = str->str;
1910
1911 g_string_free(str, FALSE);
1912 return result;
1913 }
1914 return NULL;
1915 }
1916
1917
1918 /* use pos = -1 to search for the previous unmatched open bracket. */
1919 gboolean editor_show_calltip(GeanyEditor *editor, gint pos)
1920 {
1921 gint orig_pos = pos; /* the position for the calltip */
1922 gint lexer;
1923 gint style;
1924 gchar word[GEANY_MAX_WORD_LENGTH];
1925 gchar *str;
1926 ScintillaObject *sci;
1927
1928 g_return_val_if_fail(editor != NULL, FALSE);
1929 g_return_val_if_fail(editor->document->file_type != NULL, FALSE);
1930
1931 sci = editor->sci;
1932
1933 lexer = sci_get_lexer(sci);
1934
1935 if (pos == -1)
1936 {
1937 /* position of '(' is unknown, so go backwards from current position to find it */
1938 pos = sci_get_current_position(sci);
1939 pos--;
1940 orig_pos = pos;
1941 pos = (lexer == SCLEX_LATEX) ? find_previous_brace(sci, pos) :
1942 find_start_bracket(sci, pos);
1943 if (pos == -1)
1944 return FALSE;
1945 }
1946
1947 /* the style 1 before the brace (which may be highlighted) */
1948 style = sci_get_style_at(sci, pos - 1);
1949 if (! highlighting_is_code_style(lexer, style))
1950 return FALSE;
1951
1952 word[0] = '\0';
1953 editor_find_current_word(editor, pos - 1, word, sizeof word, NULL);
1954 if (word[0] == '\0')
1955 return FALSE;
1956
1957 str = find_calltip(word, editor->document->file_type);
1958 if (str)
1959 {
1960 g_free(calltip.text); /* free the old calltip */
1961 calltip.text = str;
1962 calltip.pos = orig_pos;
1963 calltip.sci = sci;
1964 calltip.set = TRUE;
1965 utils_wrap_string(calltip.text, -1);
1966 SSM(sci, SCI_CALLTIPSHOW, orig_pos, (sptr_t) calltip.text);
1967 return TRUE;
1968 }
1969 return FALSE;
1970 }
1971
1972
1973 gchar *editor_get_calltip_text(GeanyEditor *editor, const TMTag *tag)
1974 {
1975 GString *str;
1976
1977 g_return_val_if_fail(editor != NULL, NULL);
1978
1979 str = g_string_new(NULL);
1980 if (append_calltip(str, tag, editor->document->file_type->id))
1981 return g_string_free(str, FALSE);
1982 else
1983 return g_string_free(str, TRUE);
1984 }
1985
1986
1987 /* HTML entities auto completion from html_entities.tags text file */
1988 static gboolean
1989 autocomplete_html(ScintillaObject *sci, const gchar *root, gsize rootlen)
1990 {
1991 guint i;
1992 gboolean found = FALSE;
1993 GString *words;
1994 const gchar **entities = symbols_get_html_entities();
1995
1996 if (*root != '&' || entities == NULL)
1997 return FALSE;
1998
1999 words = g_string_sized_new(500);
2000 for (i = 0; ; i++)
2001 {
2002 if (entities[i] == NULL)
2003 break;
2004 else if (entities[i][0] == '#')
2005 continue;
2006
2007 if (! strncmp(entities[i], root, rootlen))
2008 {
2009 if (words->len)
2010 g_string_append_c(words, '\n');
2011
2012 g_string_append(words, entities[i]);
2013 found = TRUE;
2014 }
2015 }
2016 if (found)
2017 show_autocomplete(sci, rootlen, words);
2018
2019 g_string_free(words, TRUE);
2020 return found;
2021 }
2022
2023
2024 /* Current document & global tags autocompletion */
2025 static gboolean
2026 autocomplete_tags(GeanyEditor *editor, const gchar *root, gsize rootlen)
2027 {
2028 TMTagAttrType attrs[] = { tm_tag_attr_name_t, 0 };
2029 const GPtrArray *tags;
2030 GeanyDocument *doc;
2031
2032 g_return_val_if_fail(editor, FALSE);
2033
2034 doc = editor->document;
2035
2036 tags = tm_workspace_find(root, tm_tag_max_t, attrs, TRUE, doc->file_type->lang);
2037 if (tags)
2038 {
2039 show_tags_list(editor, tags, rootlen);
2040 return tags->len > 0;
2041 }
2042 return FALSE;
2043 }
2044
2045
2046 static gboolean autocomplete_check_html(GeanyEditor *editor, gint style, gint pos)
2047 {
2048 GeanyFiletype *ft = editor->document->file_type;
2049 gboolean try = FALSE;
2050
2051 /* use entity completion when style is not JavaScript, ASP, Python, PHP, ...
2052 * (everything after SCE_HJ_START is for embedded scripting languages) */
2053 if (ft->id == GEANY_FILETYPES_HTML && style < SCE_HJ_START)
2054 try = TRUE;
2055 else if (sci_get_lexer(editor->sci) == SCLEX_XML && style < SCE_HJ_START)
2056 try = TRUE;
2057 else if (ft->id == GEANY_FILETYPES_PHP)
2058 {
2059 /* use entity completion when style is outside of PHP styles */
2060 if (! is_style_php(style))
2061 try = TRUE;
2062 }
2063 if (try)
2064 {
2065 gchar root[GEANY_MAX_WORD_LENGTH];
2066 gchar *tmp;
2067
2068 read_current_word(editor, pos, root, sizeof(root), GEANY_WORDCHARS"&", TRUE);
2069
2070 /* Allow something like "&quot;some text&quot;".
2071 * for entity completion we want to have completion for '&' within words. */
2072 tmp = strchr(root, '&');
2073 if (tmp != NULL)
2074 {
2075 return autocomplete_html(editor->sci, tmp, strlen(tmp));
2076 }
2077 }
2078 return FALSE;
2079 }
2080
2081
2082 /* Algorithm based on based on Scite's StartAutoCompleteWord()
2083 * @returns a sorted list of words matching @p root */
2084 static GSList *get_doc_words(ScintillaObject *sci, gchar *root, gsize rootlen)
2085 {
2086 gchar *word;
2087 gint len, current, word_end;
2088 gint pos_find, flags;
2089 guint word_length;
2090 gsize nmatches = 0;
2091 GSList *words = NULL;
2092 struct Sci_TextToFind ttf;
2093
2094 len = sci_get_length(sci);
2095 current = sci_get_current_position(sci) - rootlen;
2096
2097 ttf.lpstrText = root;
2098 ttf.chrg.cpMin = 0;
2099 ttf.chrg.cpMax = len;
2100 ttf.chrgText.cpMin = 0;
2101 ttf.chrgText.cpMax = 0;
2102 flags = SCFIND_WORDSTART | SCFIND_MATCHCASE;
2103
2104 /* search the whole document for the word root and collect results */
2105 pos_find = scintilla_send_message(sci, SCI_FINDTEXT, flags, (uptr_t) &ttf);
2106 while (pos_find >= 0 && pos_find < len)
2107 {
2108 word_end = pos_find + rootlen;
2109 if (pos_find != current)
2110 {
2111 word_end = sci_word_end_position(sci, word_end, TRUE);
2112
2113 word_length = word_end - pos_find;
2114 if (word_length > rootlen)
2115 {
2116 word = sci_get_contents_range(sci, pos_find, word_end);
2117 /* search whether we already have the word in, otherwise add it */
2118 if (g_slist_find_custom(words, word, (GCompareFunc)strcmp) != NULL)
2119 g_free(word);
2120 else
2121 {
2122 words = g_slist_prepend(words, word);
2123 nmatches++;
2124 }
2125
2126 if (nmatches == editor_prefs.autocompletion_max_entries)
2127 break;
2128 }
2129 }
2130 ttf.chrg.cpMin = word_end;
2131 pos_find = scintilla_send_message(sci, SCI_FINDTEXT, flags, (uptr_t) &ttf);
2132 }
2133
2134 return g_slist_sort(words, (GCompareFunc)utils_str_casecmp);
2135 }
2136
2137
2138 static gboolean autocomplete_doc_word(GeanyEditor *editor, gchar *root, gsize rootlen)
2139 {
2140 ScintillaObject *sci = editor->sci;
2141 GSList *words, *node;
2142 GString *str;
2143 guint n_words = 0;
2144
2145 words = get_doc_words(sci, root, rootlen);
2146 if (!words)
2147 {
2148 scintilla_send_message(sci, SCI_AUTOCCANCEL, 0, 0);
2149 return FALSE;
2150 }
2151
2152 str = g_string_sized_new(rootlen * 2 * 10);
2153 foreach_slist(node, words)
2154 {
2155 g_string_append(str, node->data);
2156 g_free(node->data);
2157 if (node->next)
2158 g_string_append_c(str, '\n');
2159 n_words++;
2160 }
2161 if (n_words >= editor_prefs.autocompletion_max_entries)
2162 g_string_append(str, "\n...");
2163
2164 g_slist_free(words);
2165
2166 show_autocomplete(sci, rootlen, str);
2167 g_string_free(str, TRUE);
2168 return TRUE;
2169 }
2170
2171
2172 gboolean editor_start_auto_complete(GeanyEditor *editor, gint pos, gboolean force)
2173 {
2174 gint rootlen, lexer, style;
2175 gchar *root;
2176 gchar cword[GEANY_MAX_WORD_LENGTH];
2177 ScintillaObject *sci;
2178 gboolean ret = FALSE;
2179 const gchar *wordchars;
2180 GeanyFiletype *ft;
2181
2182 g_return_val_if_fail(editor != NULL, FALSE);
2183
2184 if (! editor_prefs.auto_complete_symbols && ! force)
2185 return FALSE;
2186
2187 /* If we are at the beginning of the document, we skip autocompletion as we can't determine the
2188 * necessary styling information */
2189 if (G_UNLIKELY(pos < 2))
2190 return FALSE;
2191
2192 sci = editor->sci;
2193 ft = editor->document->file_type;
2194
2195 lexer = sci_get_lexer(sci);
2196 style = sci_get_style_at(sci, pos - 2);
2197
2198 /* don't autocomplete in comments and strings */
2199 if (!force && !highlighting_is_code_style(lexer, style))
2200 return FALSE;
2201
2202 autocomplete_scope(editor);
2203 ret = autocomplete_check_html(editor, style, pos);
2204
2205 if (ft->id == GEANY_FILETYPES_LATEX)
2206 wordchars = GEANY_WORDCHARS"\\"; /* add \ to word chars if we are in a LaTeX file */
2207 else if (ft->id == GEANY_FILETYPES_CSS)
2208 wordchars = GEANY_WORDCHARS"-"; /* add - because they are part of property names */
2209 else
2210 wordchars = GEANY_WORDCHARS;
2211
2212 read_current_word(editor, pos, cword, sizeof(cword), wordchars, TRUE);
2213 root = cword;
2214 rootlen = strlen(root);
2215
2216 if (!ret && rootlen > 0)
2217 {
2218 if (ft->id == GEANY_FILETYPES_PHP && style == SCE_HPHP_DEFAULT &&
2219 rootlen == 3 && strcmp(root, "php") == 0 && pos >= 5 &&
2220 sci_get_char_at(sci, pos - 5) == '<' &&
2221 sci_get_char_at(sci, pos - 4) == '?')
2222 {
2223 /* nothing, don't complete PHP open tags */
2224 }
2225 else
2226 {
2227 /* force is set when called by keyboard shortcut, otherwise start at the
2228 * editor_prefs.symbolcompletion_min_chars'th char */
2229 if (force || rootlen >= editor_prefs.symbolcompletion_min_chars)
2230 {
2231 /* complete tags, except if forcing when completion is already visible */
2232 if (!(force && SSM(sci, SCI_AUTOCACTIVE, 0, 0)))
2233 ret = autocomplete_tags(editor, root, rootlen);
2234
2235 /* If forcing and there's nothing else to show, complete from words in document */
2236 if (!ret && (force || editor_prefs.autocomplete_doc_words))
2237 ret = autocomplete_doc_word(editor, root, rootlen);
2238 }
2239 }
2240 }
2241 if (!ret && force)
2242 utils_beep();
2243
2244 return ret;
2245 }
2246
2247
2248 static const gchar *snippets_find_completion_by_name(const gchar *type, const gchar *name)
2249 {
2250 gchar *result = NULL;
2251 GHashTable *tmp;
2252
2253 g_return_val_if_fail(type != NULL && name != NULL, NULL);
2254
2255 tmp = g_hash_table_lookup(snippet_hash, type);
2256 if (tmp != NULL)
2257 {
2258 result = g_hash_table_lookup(tmp, name);
2259 }
2260 /* whether nothing is set for the current filetype(tmp is NULL) or
2261 * the particular completion for this filetype is not set (result is NULL) */
2262 if (tmp == NULL || result == NULL)
2263 {
2264 tmp = g_hash_table_lookup(snippet_hash, "Default");
2265 if (tmp != NULL)
2266 {
2267 result = g_hash_table_lookup(tmp, name);
2268 }
2269 }
2270 /* if result is still NULL here, no completion could be found */
2271
2272 /* result is owned by the hash table and will be freed when the table will destroyed */
2273 return result;
2274 }
2275
2276
2277 static void snippets_replace_specials(gpointer key, gpointer value, gpointer user_data)
2278 {
2279 gchar *needle;
2280 GString *pattern = user_data;
2281
2282 g_return_if_fail(key != NULL);
2283 g_return_if_fail(value != NULL);
2284
2285 needle = g_strconcat("%", (gchar*) key, "%", NULL);
2286
2287 utils_string_replace_all(pattern, needle, (gchar*) value);
2288 g_free(needle);
2289 }
2290
2291
2292 static void fix_indentation(GeanyEditor *editor, GString *buf)
2293 {
2294 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
2295 gchar *whitespace;
2296 GRegex *regex;
2297 gint cflags = G_REGEX_MULTILINE;
2298
2299 /* transform leading tabs into indent widths (in spaces) */
2300 whitespace = g_strnfill(iprefs->width, ' ');
2301 regex = g_regex_new("^ *(\t)", cflags, 0, NULL);
2302 while (utils_string_regex_replace_all(buf, regex, 1, whitespace, TRUE));
2303 g_regex_unref(regex);
2304
2305 /* remaining tabs are for alignment */
2306 if (iprefs->type != GEANY_INDENT_TYPE_TABS)
2307 utils_string_replace_all(buf, "\t", whitespace);
2308
2309 /* use leading tabs */
2310 if (iprefs->type != GEANY_INDENT_TYPE_SPACES)
2311 {
2312 gchar *str;
2313
2314 /* for tabs+spaces mode we want the real tab width, not indent width */
2315 SETPTR(whitespace, g_strnfill(sci_get_tab_width(editor->sci), ' '));
2316 str = g_strdup_printf("^\t*(%s)", whitespace);
2317
2318 regex = g_regex_new(str, cflags, 0, NULL);
2319 while (utils_string_regex_replace_all(buf, regex, 1, "\t", TRUE));
2320 g_regex_unref(regex);
2321 g_free(str);
2322 }
2323 g_free(whitespace);
2324 }
2325
2326
2327 /** Inserts text, replacing \\t tab chars (@c 0x9) and \\n newline chars (@c 0xA)
2328 * accordingly for the document.
2329 * - Leading tabs are replaced with the correct indentation.
2330 * - Non-leading tabs are replaced with spaces (except when using 'Tabs' indent type).
2331 * - Newline chars are replaced with the correct line ending string.
2332 * This is very useful for inserting code without having to handle the indent
2333 * type yourself (Tabs & Spaces mode can be tricky).
2334 * @param editor Editor.
2335 * @param text Intended as e.g. @c "if (foo)\n\tbar();".
2336 * @param insert_pos Document position to insert text at.
2337 * @param cursor_index If >= 0, the index into @a text to place the cursor.
2338 * @param newline_indent_size Indentation size (in spaces) to insert for each newline; use
2339 * -1 to read the indent size from the line with @a insert_pos on it.
2340 * @param replace_newlines Whether to replace newlines. If
2341 * newlines have been replaced already, this should be false, to avoid errors e.g. on Windows.
2342 * @warning Make sure all \\t tab chars in @a text are intended as indent widths or alignment,
2343 * not hard tabs, as those won't be preserved.
2344 * @note This doesn't scroll the cursor in view afterwards. **/
2345 void editor_insert_text_block(GeanyEditor *editor, const gchar *text, gint insert_pos,
2346 gint cursor_index, gint newline_indent_size, gboolean replace_newlines)
2347 {
2348 ScintillaObject *sci = editor->sci;
2349 gint line_start = sci_get_line_from_position(sci, insert_pos);
2350 GString *buf;
2351 const gchar *eol = editor_get_eol_char(editor);
2352 gint idx;
2353
2354 g_return_if_fail(text);
2355 g_return_if_fail(editor != NULL);
2356 g_return_if_fail(insert_pos >= 0);
2357
2358 buf = g_string_new(text);
2359
2360 if (cursor_index >= 0)
2361 g_string_insert(buf, cursor_index, geany_cursor_marker); /* remember cursor pos */
2362
2363 if (newline_indent_size == -1)
2364 {
2365 /* count indent size up to insert_pos instead of asking sci
2366 * because there may be spaces after it */
2367 gchar *tmp = sci_get_line(sci, line_start);
2368
2369 idx = insert_pos - sci_get_position_from_line(sci, line_start);
2370 tmp[idx] = '\0';
2371 newline_indent_size = count_indent_size(editor, tmp);
2372 g_free(tmp);
2373 }
2374
2375 /* Add line indents (in spaces) */
2376 if (newline_indent_size > 0)
2377 {
2378 const gchar *nl = replace_newlines ? "\n" : eol;
2379 gchar *whitespace;
2380
2381 whitespace = g_strnfill(newline_indent_size, ' ');
2382 SETPTR(whitespace, g_strconcat(nl, whitespace, NULL));
2383 utils_string_replace_all(buf, nl, whitespace);
2384 g_free(whitespace);
2385 }
2386
2387 /* transform line endings */
2388 if (replace_newlines)
2389 utils_string_replace_all(buf, "\n", eol);
2390
2391 fix_indentation(editor, buf);
2392
2393 idx = replace_cursor_markers(editor, buf);
2394 if (idx >= 0)
2395 {
2396 sci_insert_text(sci, insert_pos, buf->str);
2397 sci_set_current_position(sci, insert_pos + idx, FALSE);
2398 }
2399 else
2400 sci_insert_text(sci, insert_pos, buf->str);
2401
2402 snippet_cursor_insert_pos = sci_get_current_position(sci);
2403
2404 g_string_free(buf, TRUE);
2405 }
2406
2407
2408 /* Move the cursor to the next specified cursor position in an inserted snippet.
2409 * Can, and should, be optimized to give better results */
2410 void editor_goto_next_snippet_cursor(GeanyEditor *editor)
2411 {
2412 ScintillaObject *sci = editor->sci;
2413 gint current_pos = sci_get_current_position(sci);
2414
2415 if (snippet_offsets && !g_queue_is_empty(snippet_offsets))
2416 {
2417 gint offset;
2418
2419 offset = GPOINTER_TO_INT(g_queue_pop_head(snippet_offsets));
2420 if (current_pos > snippet_cursor_insert_pos)
2421 snippet_cursor_insert_pos = offset + current_pos;
2422 else
2423 snippet_cursor_insert_pos += offset;
2424
2425 sci_set_current_position(sci, snippet_cursor_insert_pos, TRUE);
2426 }
2427 else
2428 {
2429 utils_beep();
2430 }
2431 }
2432
2433
2434 static void snippets_make_replacements(GeanyEditor *editor, GString *pattern)
2435 {
2436 GHashTable *specials;
2437
2438 /* replace 'special' completions */
2439 specials = g_hash_table_lookup(snippet_hash, "Special");
2440 if (G_LIKELY(specials != NULL))
2441 {
2442 g_hash_table_foreach(specials, snippets_replace_specials, pattern);
2443 }
2444
2445 /* now transform other wildcards */
2446 utils_string_replace_all(pattern, "%newline%", "\n");
2447 utils_string_replace_all(pattern, "%ws%", "\t");
2448
2449 /* replace %cursor% by a very unlikely string marker */
2450 utils_string_replace_all(pattern, "%cursor%", geany_cursor_marker);
2451
2452 /* unescape '%' after all %wildcards% */
2453 templates_replace_valist(pattern, "{pc}", "%", NULL);
2454
2455 /* replace any template {foo} wildcards */
2456 templates_replace_common(pattern, editor->document->file_name, editor->document->file_type, NULL);
2457 }
2458
2459
2460 static gssize replace_cursor_markers(GeanyEditor *editor, GString *pattern)
2461 {
2462 gssize cur_index = -1;
2463 gint i;
2464 GList *temp_list = NULL;
2465 gint cursor_steps = 0, old_cursor = 0;
2466
2467 i = 0;
2468 while (1)
2469 {
2470 cursor_steps = utils_string_find(pattern, cursor_steps, -1, geany_cursor_marker);
2471 if (cursor_steps == -1)
2472 break;
2473
2474 g_string_erase(pattern, cursor_steps, strlen(geany_cursor_marker));
2475
2476 if (i++ > 0)
2477 {
2478 /* save the relative offset to each cursor position */
2479 temp_list = g_list_prepend(temp_list, GINT_TO_POINTER(cursor_steps - old_cursor));
2480 }
2481 else
2482 {
2483 /* first cursor already includes newline positions */
2484 cur_index = cursor_steps;
2485 }
2486 old_cursor = cursor_steps;
2487 }
2488
2489 /* put the cursor positions for the most recent
2490 * parsed snippet first, followed by any remaining positions */
2491 i = 0;
2492 if (temp_list)
2493 {
2494 GList *node;
2495
2496 temp_list = g_list_reverse(temp_list);
2497 foreach_list(node, temp_list)
2498 g_queue_push_nth(snippet_offsets, node->data, i++);
2499
2500 /* limit length of queue */
2501 while (g_queue_get_length(snippet_offsets) > 20)
2502 g_queue_pop_tail(snippet_offsets);
2503
2504 g_list_free(temp_list);
2505 }
2506 /* if there's no first cursor, skip whole snippet */
2507 if (cur_index < 0)
2508 cur_index = pattern->len;
2509
2510 return cur_index;
2511 }
2512
2513
2514 static gboolean snippets_complete_constructs(GeanyEditor *editor, gint pos, const gchar *word)
2515 {
2516 ScintillaObject *sci = editor->sci;
2517 gchar *str;
2518 const gchar *completion;
2519 gint str_len;
2520 gint ft_id = editor->document->file_type->id;
2521
2522 str = g_strdup(word);
2523 g_strstrip(str);
2524
2525 completion = snippets_find_completion_by_name(filetypes[ft_id]->name, str);
2526 if (completion == NULL)
2527 {
2528 g_free(str);
2529 return FALSE;
2530 }
2531
2532 /* remove the typed word, it will be added again by the used auto completion
2533 * (not really necessary but this makes the auto completion more flexible,
2534 * e.g. with a completion like hi=hello, so typing "hi<TAB>" will result in "hello") */
2535 str_len = strlen(str);
2536 sci_set_selection_start(sci, pos - str_len);
2537 sci_set_selection_end(sci, pos);
2538 sci_replace_sel(sci, "");
2539 pos -= str_len; /* pos has changed while deleting */
2540
2541 editor_insert_snippet(editor, pos, completion);
2542 sci_scroll_caret(sci);
2543
2544 g_free(str);
2545 return TRUE;
2546 }
2547
2548
2549 static gboolean at_eol(ScintillaObject *sci, gint pos)
2550 {
2551 gint line = sci_get_line_from_position(sci, pos);
2552 gchar c;
2553
2554 /* skip any trailing spaces */
2555 while (TRUE)
2556 {
2557 c = sci_get_char_at(sci, pos);
2558 if (c == ' ' || c == '\t')
2559 pos++;
2560 else
2561 break;
2562 }
2563
2564 return (pos == sci_get_line_end_position(sci, line));
2565 }
2566
2567
2568 gboolean editor_complete_snippet(GeanyEditor *editor, gint pos)
2569 {
2570 gboolean result = FALSE;
2571 const gchar *wc;
2572 const gchar *word;
2573 ScintillaObject *sci;
2574
2575 g_return_val_if_fail(editor != NULL, FALSE);
2576
2577 sci = editor->sci;
2578 if (sci_has_selection(sci))
2579 return FALSE;
2580 /* return if we are editing an existing line (chars on right of cursor) */
2581 if (keybindings_lookup_item(GEANY_KEY_GROUP_EDITOR,
2582 GEANY_KEYS_EDITOR_COMPLETESNIPPET)->key == GDK_space &&
2583 ! editor_prefs.complete_snippets_whilst_editing && ! at_eol(sci, pos))
2584 return FALSE;
2585
2586 wc = snippets_find_completion_by_name("Special", "wordchars");
2587 word = editor_read_word_stem(editor, pos, wc);
2588
2589 /* prevent completion of "for " */
2590 if (!EMPTY(word) &&
2591 ! isspace(sci_get_char_at(sci, pos - 1))) /* pos points to the line end char so use pos -1 */
2592 {
2593 sci_start_undo_action(sci); /* needed because we insert a space separately from construct */
2594 result = snippets_complete_constructs(editor, pos, word);
2595 sci_end_undo_action(sci);
2596 if (result)
2597 sci_cancel(sci); /* cancel any autocompletion list, etc */
2598 }
2599 return result;
2600 }
2601
2602
2603 void editor_show_macro_list(GeanyEditor *editor)
2604 {
2605 GString *words;
2606
2607 if (editor == NULL || editor->document->file_type == NULL)
2608 return;
2609
2610 words = symbols_get_macro_list(editor->document->file_type->lang);
2611 if (words == NULL)
2612 return;
2613
2614 SSM(editor->sci, SCI_USERLISTSHOW, 1, (sptr_t) words->str);
2615 g_string_free(words, TRUE);
2616 }
2617
2618
2619 static void insert_closing_tag(GeanyEditor *editor, gint pos, gchar ch, const gchar *tag_name)
2620 {
2621 ScintillaObject *sci = editor->sci;
2622 gchar *to_insert = NULL;
2623
2624 if (ch == '/')
2625 {
2626 const gchar *gt = ">";
2627 /* if there is already a '>' behind the cursor, don't add it */
2628 if (sci_get_char_at(sci, pos) == '>')
2629 gt = "";
2630
2631 to_insert = g_strconcat(tag_name, gt, NULL);
2632 }
2633 else
2634 to_insert = g_strconcat("</", tag_name, ">", NULL);
2635
2636 sci_start_undo_action(sci);
2637 sci_replace_sel(sci, to_insert);
2638 if (ch == '>')
2639 sci_set_selection(sci, pos, pos);
2640 sci_end_undo_action(sci);
2641 g_free(to_insert);
2642 }
2643
2644
2645 /*
2646 * (stolen from anjuta and heavily modified)
2647 * This routine will auto complete XML or HTML tags that are still open by closing them
2648 * @param ch The character we are dealing with, currently only works with the '>' character
2649 * @return True if handled, false otherwise
2650 */
2651 static gboolean handle_xml(GeanyEditor *editor, gint pos, gchar ch)
2652 {
2653 ScintillaObject *sci = editor->sci;
2654 gint lexer = sci_get_lexer(sci);
2655 gint min, size, style;
2656 gchar *str_found, sel[512];
2657 gboolean result = FALSE;
2658
2659 /* If the user has turned us off, quit now.
2660 * This may make sense only in certain languages */
2661 if (! editor_prefs.auto_close_xml_tags || (lexer != SCLEX_HTML && lexer != SCLEX_XML))
2662 return FALSE;
2663
2664 /* return if we are inside any embedded script */
2665 style = sci_get_style_at(sci, pos);
2666 if (style > SCE_H_XCCOMMENT && ! highlighting_is_string_style(lexer, style))
2667 return FALSE;
2668
2669 /* if ch is /, check for </, else quit */
2670 if (ch == '/' && sci_get_char_at(sci, pos - 2) != '<')
2671 return FALSE;
2672
2673 /* Grab the last 512 characters or so */
2674 min = pos - (sizeof(sel) - 1);
2675 if (min < 0) min = 0;
2676
2677 if (pos - min < 3)
2678 return FALSE; /* Smallest tag is 3 characters e.g. <p> */
2679
2680 sci_get_text_range(sci, min, pos, sel);
2681 sel[sizeof(sel) - 1] = '\0';
2682
2683 if (ch == '>' && sel[pos - min - 2] == '/')
2684 /* User typed something like "<br/>" */
2685 return FALSE;
2686
2687 size = pos - min;
2688 if (ch == '/')
2689 size -= 2; /* skip </ */
2690 str_found = utils_find_open_xml_tag(sel, size);
2691
2692 if (lexer == SCLEX_HTML && utils_is_short_html_tag(str_found))
2693 {
2694 /* ignore tag */
2695 }
2696 else if (!EMPTY(str_found))
2697 {
2698 insert_closing_tag(editor, pos, ch, str_found);
2699 result = TRUE;
2700 }
2701 g_free(str_found);
2702 return result;
2703 }
2704
2705
2706 /* like sci_get_line_indentation(), but for a string. */
2707 static gsize count_indent_size(GeanyEditor *editor, const gchar *base_indent)
2708 {
2709 const gchar *ptr;
2710 gsize tab_size = sci_get_tab_width(editor->sci);
2711 gsize count = 0;
2712
2713 g_return_val_if_fail(base_indent, 0);
2714
2715 for (ptr = base_indent; *ptr != 0; ptr++)
2716 {
2717 switch (*ptr)
2718 {
2719 case ' ':
2720 count++;
2721 break;
2722 case '\t':
2723 count += tab_size;
2724 break;
2725 default:
2726 return count;
2727 }
2728 }
2729 return count;
2730 }
2731
2732
2733 /* Handles special cases where HTML is embedded in another language or
2734 * another language is embedded in HTML */
2735 static GeanyFiletype *editor_get_filetype_at_line(GeanyEditor *editor, gint line)
2736 {
2737 gint style, line_start;
2738 GeanyFiletype *current_ft;
2739
2740 g_return_val_if_fail(editor != NULL, NULL);
2741 g_return_val_if_fail(editor->document->file_type != NULL, NULL);
2742
2743 current_ft = editor->document->file_type;
2744 line_start = sci_get_position_from_line(editor->sci, line);
2745 style = sci_get_style_at(editor->sci, line_start);
2746
2747 /* Handle PHP filetype with embedded HTML */
2748 if (current_ft->id == GEANY_FILETYPES_PHP && ! is_style_php(style))
2749 current_ft = filetypes[GEANY_FILETYPES_HTML];
2750
2751 /* Handle languages embedded in HTML */
2752 if (current_ft->id == GEANY_FILETYPES_HTML)
2753 {
2754 /* Embedded JS */
2755 if (style >= SCE_HJ_DEFAULT && style <= SCE_HJ_REGEX)
2756 current_ft = filetypes[GEANY_FILETYPES_JS];
2757 /* ASP JS */
2758 else if (style >= SCE_HJA_DEFAULT && style <= SCE_HJA_REGEX)
2759 current_ft = filetypes[GEANY_FILETYPES_JS];
2760 /* Embedded VB */
2761 else if (style >= SCE_HB_DEFAULT && style <= SCE_HB_STRINGEOL)
2762 current_ft = filetypes[GEANY_FILETYPES_BASIC];
2763 /* ASP VB */
2764 else if (style >= SCE_HBA_DEFAULT && style <= SCE_HBA_STRINGEOL)
2765 current_ft = filetypes[GEANY_FILETYPES_BASIC];
2766 /* Embedded Python */
2767 else if (style >= SCE_HP_DEFAULT && style <= SCE_HP_IDENTIFIER)
2768 current_ft = filetypes[GEANY_FILETYPES_PYTHON];
2769 /* ASP Python */
2770 else if (style >= SCE_HPA_DEFAULT && style <= SCE_HPA_IDENTIFIER)
2771 current_ft = filetypes[GEANY_FILETYPES_PYTHON];
2772 /* Embedded PHP */
2773 else if ((style >= SCE_HPHP_DEFAULT && style <= SCE_HPHP_OPERATOR) ||
2774 style == SCE_HPHP_COMPLEX_VARIABLE)
2775 {
2776 current_ft = filetypes[GEANY_FILETYPES_PHP];
2777 }
2778 }
2779
2780 /* Ensure the filetype's config is loaded */
2781 filetypes_load_config(current_ft->id, FALSE);
2782
2783 return current_ft;
2784 }
2785
2786
2787 static void real_comment_multiline(GeanyEditor *editor, gint line_start, gint last_line)
2788 {
2789 const gchar *eol;
2790 gchar *str_begin, *str_end;
2791 const gchar *co, *cc;
2792 gint line_len;
2793 GeanyFiletype *ft;
2794
2795 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
2796
2797 ft = editor_get_filetype_at_line(editor, line_start);
2798
2799 eol = editor_get_eol_char(editor);
2800 if (! filetype_get_comment_open_close(ft, FALSE, &co, &cc))
2801 g_return_if_reached();
2802 str_begin = g_strdup_printf("%s%s", (co != NULL) ? co : "", eol);
2803 str_end = g_strdup_printf("%s%s", (cc != NULL) ? cc : "", eol);
2804
2805 /* insert the comment strings */
2806 sci_insert_text(editor->sci, line_start, str_begin);
2807 line_len = sci_get_position_from_line(editor->sci, last_line + 2);
2808 sci_insert_text(editor->sci, line_len, str_end);
2809
2810 g_free(str_begin);
2811 g_free(str_end);
2812 }
2813
2814
2815 /* find @p text inside the range of the current style */
2816 static gint find_in_current_style(ScintillaObject *sci, const gchar *text, gboolean backwards)
2817 {
2818 gint start = sci_get_current_position(sci);
2819 gint end = start;
2820 gint len = sci_get_length(sci);
2821 gint current_style = sci_get_style_at(sci, start);
2822 struct Sci_TextToFind ttf;
2823
2824 while (start > 0 && sci_get_style_at(sci, start - 1) == current_style)
2825 start -= 1;
2826 while (end < len && sci_get_style_at(sci, end + 1) == current_style)
2827 end += 1;
2828
2829 ttf.lpstrText = (gchar*) text;
2830 ttf.chrg.cpMin = backwards ? end + 1 : start;
2831 ttf.chrg.cpMax = backwards ? start : end + 1;
2832 return sci_find_text(sci, 0, &ttf);
2833 }
2834
2835
2836 static void sci_delete_line(ScintillaObject *sci, gint line)
2837 {
2838 gint start = sci_get_position_from_line(sci, line);
2839 gint len = sci_get_line_length(sci, line);
2840 SSM(sci, SCI_DELETERANGE, start, len);
2841 }
2842
2843
2844 static gboolean real_uncomment_multiline(GeanyEditor *editor)
2845 {
2846 /* find the beginning of the multi line comment */
2847 gint start, end, start_line, end_line;
2848 GeanyFiletype *ft;
2849 const gchar *co, *cc;
2850
2851 g_return_val_if_fail(editor != NULL && editor->document->file_type != NULL, FALSE);
2852
2853 ft = editor_get_filetype_at_line(editor, sci_get_current_line(editor->sci));
2854 if (! filetype_get_comment_open_close(ft, FALSE, &co, &cc))
2855 g_return_val_if_reached(FALSE);
2856
2857 start = find_in_current_style(editor->sci, co, TRUE);
2858 end = find_in_current_style(editor->sci, cc, FALSE);
2859
2860 if (start < 0 || end < 0 || start > end /* who knows */)
2861 return FALSE;
2862
2863 start_line = sci_get_line_from_position(editor->sci, start);
2864 end_line = sci_get_line_from_position(editor->sci, end);
2865
2866 /* remove comment close chars */
2867 SSM(editor->sci, SCI_DELETERANGE, end, strlen(cc));
2868 if (sci_is_blank_line(editor->sci, end_line))
2869 sci_delete_line(editor->sci, end_line);
2870
2871 /* remove comment open chars (do it last since it would move the end position) */
2872 SSM(editor->sci, SCI_DELETERANGE, start, strlen(co));
2873 if (sci_is_blank_line(editor->sci, start_line))
2874 sci_delete_line(editor->sci, start_line);
2875
2876 return TRUE;
2877 }
2878
2879
2880 static gint get_multiline_comment_style(GeanyEditor *editor, gint line_start)
2881 {
2882 gint lexer = sci_get_lexer(editor->sci);
2883 gint style_comment;
2884
2885 /* List only those lexers which support multi line comments */
2886 switch (lexer)
2887 {
2888 case SCLEX_XML:
2889 case SCLEX_HTML:
2890 {
2891 if (is_style_php(sci_get_style_at(editor->sci, line_start)))
2892 style_comment = SCE_HPHP_COMMENT;
2893 else
2894 style_comment = SCE_H_COMMENT;
2895 break;
2896 }
2897 case SCLEX_HASKELL:
2898 case SCLEX_LITERATEHASKELL:
2899 style_comment = SCE_HA_COMMENTBLOCK; break;
2900 case SCLEX_LUA: style_comment = SCE_LUA_COMMENT; break;
2901 case SCLEX_CSS: style_comment = SCE_CSS_COMMENT; break;
2902 case SCLEX_SQL: style_comment = SCE_SQL_COMMENT; break;
2903 case SCLEX_CAML: style_comment = SCE_CAML_COMMENT; break;
2904 case SCLEX_D: style_comment = SCE_D_COMMENT; break;
2905 case SCLEX_PASCAL: style_comment = SCE_PAS_COMMENT; break;
2906 case SCLEX_RUST: style_comment = SCE_RUST_COMMENTBLOCK; break;
2907 default: style_comment = SCE_C_COMMENT;
2908 }
2909
2910 return style_comment;
2911 }
2912
2913
2914 /* set toggle to TRUE if the caller is the toggle function, FALSE otherwise
2915 * returns the amount of uncommented single comment lines, in case of multi line uncomment
2916 * it returns just 1 */
2917 gint editor_do_uncomment(GeanyEditor *editor, gint line, gboolean toggle)
2918 {
2919 gint first_line, last_line;
2920 gint x, i, line_start, line_len;
2921 gint sel_start, sel_end;
2922 gint count = 0;
2923 gsize co_len;
2924 gchar sel[256];
2925 const gchar *co, *cc;
2926 gboolean single_line = FALSE;
2927 GeanyFiletype *ft;
2928
2929 g_return_val_if_fail(editor != NULL && editor->document->file_type != NULL, 0);
2930
2931 if (line < 0)
2932 { /* use selection or current line */
2933 sel_start = sci_get_selection_start(editor->sci);
2934 sel_end = sci_get_selection_end(editor->sci);
2935
2936 first_line = sci_get_line_from_position(editor->sci, sel_start);
2937 /* Find the last line with chars selected (not EOL char) */
2938 last_line = sci_get_line_from_position(editor->sci,
2939 sel_end - editor_get_eol_char_len(editor));
2940 last_line = MAX(first_line, last_line);
2941 }
2942 else
2943 {
2944 first_line = last_line = line;
2945 sel_start = sel_end = sci_get_position_from_line(editor->sci, line);
2946 }
2947
2948 ft = editor_get_filetype_at_line(editor, first_line);
2949
2950 if (! filetype_get_comment_open_close(ft, TRUE, &co, &cc))
2951 return 0;
2952
2953 co_len = strlen(co);
2954 if (co_len == 0)
2955 return 0;
2956
2957 sci_start_undo_action(editor->sci);
2958
2959 for (i = first_line; i <= last_line; i++)
2960 {
2961 gint buf_len;
2962
2963 line_start = sci_get_position_from_line(editor->sci, i);
2964 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
2965 x = 0;
2966
2967 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
2968 if (buf_len <= 0)
2969 continue;
2970 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
2971 sel[buf_len] = '\0';
2972
2973 while (isspace(sel[x])) x++;
2974
2975 /* to skip blank lines */
2976 if (x < line_len && sel[x] != '\0')
2977 {
2978 /* use single line comment */
2979 if (EMPTY(cc))
2980 {
2981 single_line = TRUE;
2982
2983 if (toggle)
2984 {
2985 gsize tm_len = strlen(editor_prefs.comment_toggle_mark);
2986 if (strncmp(sel + x, co, co_len) != 0 ||
2987 strncmp(sel + x + co_len, editor_prefs.comment_toggle_mark, tm_len) != 0)
2988 continue;
2989
2990 co_len += tm_len;
2991 }
2992 else
2993 {
2994 if (strncmp(sel + x, co, co_len) != 0)
2995 continue;
2996 }
2997
2998 sci_set_selection(editor->sci, line_start + x, line_start + x + co_len);
2999 sci_replace_sel(editor->sci, "");
3000 count++;
3001 }
3002 /* use multi line comment */
3003 else
3004 {
3005 gint style_comment;
3006
3007 /* skip lines which are already comments */
3008 style_comment = get_multiline_comment_style(editor, line_start);
3009 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3010 {
3011 if (real_uncomment_multiline(editor))
3012 count = 1;
3013 }
3014
3015 /* break because we are already on the last line */
3016 break;
3017 }
3018 }
3019 }
3020 sci_end_undo_action(editor->sci);
3021
3022 /* restore selection if there is one
3023 * but don't touch the selection if caller is editor_do_comment_toggle */
3024 if (! toggle && sel_start < sel_end)
3025 {
3026 if (single_line)
3027 {
3028 sci_set_selection_start(editor->sci, sel_start - co_len);
3029 sci_set_selection_end(editor->sci, sel_end - (count * co_len));
3030 }
3031 else
3032 {
3033 gint eol_len = editor_get_eol_char_len(editor);
3034 sci_set_selection_start(editor->sci, sel_start - co_len - eol_len);
3035 sci_set_selection_end(editor->sci, sel_end - co_len - eol_len);
3036 }
3037 }
3038
3039 return count;
3040 }
3041
3042
3043 void editor_do_comment_toggle(GeanyEditor *editor)
3044 {
3045 gint first_line, last_line;
3046 gint x, i, line_start, line_len, first_line_start, last_line_start;
3047 gint sel_start, sel_end;
3048 gint count_commented = 0, count_uncommented = 0;
3049 gchar sel[256];
3050 const gchar *co, *cc;
3051 gboolean break_loop = FALSE, single_line = FALSE;
3052 gboolean first_line_was_comment = FALSE;
3053 gboolean last_line_was_comment = FALSE;
3054 gsize co_len;
3055 gsize tm_len = strlen(editor_prefs.comment_toggle_mark);
3056 GeanyFiletype *ft;
3057
3058 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
3059
3060 sel_start = sci_get_selection_start(editor->sci);
3061 sel_end = sci_get_selection_end(editor->sci);
3062
3063 first_line = sci_get_line_from_position(editor->sci, sel_start);
3064 /* Find the last line with chars selected (not EOL char) */
3065 last_line = sci_get_line_from_position(editor->sci,
3066 sel_end - editor_get_eol_char_len(editor));
3067 last_line = MAX(first_line, last_line);
3068
3069 first_line_start = sci_get_position_from_line(editor->sci, first_line);
3070 last_line_start = sci_get_position_from_line(editor->sci, last_line);
3071
3072 ft = editor_get_filetype_at_line(editor, first_line);
3073
3074 if (! filetype_get_comment_open_close(ft, TRUE, &co, &cc))
3075 return;
3076
3077 co_len = strlen(co);
3078 if (co_len == 0)
3079 return;
3080
3081 sci_start_undo_action(editor->sci);
3082
3083 for (i = first_line; (i <= last_line) && (! break_loop); i++)
3084 {
3085 gint buf_len;
3086
3087 line_start = sci_get_position_from_line(editor->sci, i);
3088 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
3089 x = 0;
3090
3091 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
3092 if (buf_len < 0)
3093 continue;
3094 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
3095 sel[buf_len] = '\0';
3096
3097 while (isspace(sel[x])) x++;
3098
3099 /* use single line comment */
3100 if (EMPTY(cc))
3101 {
3102 gboolean do_continue = FALSE;
3103 single_line = TRUE;
3104
3105 if (strncmp(sel + x, co, co_len) == 0 &&
3106 strncmp(sel + x + co_len, editor_prefs.comment_toggle_mark, tm_len) == 0)
3107 {
3108 do_continue = TRUE;
3109 }
3110
3111 if (do_continue && i == first_line)
3112 first_line_was_comment = TRUE;
3113 last_line_was_comment = do_continue;
3114
3115 if (do_continue)
3116 {
3117 count_uncommented += editor_do_uncomment(editor, i, TRUE);
3118 continue;
3119 }
3120
3121 /* we are still here, so the above lines were not already comments, so comment it */
3122 count_commented += editor_do_comment(editor, i, FALSE, TRUE, TRUE);
3123 }
3124 /* use multi line comment */
3125 else
3126 {
3127 gint style_comment;
3128
3129 /* skip lines which are already comments */
3130 style_comment = get_multiline_comment_style(editor, line_start);
3131 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3132 {
3133 if (real_uncomment_multiline(editor))
3134 count_uncommented++;
3135 }
3136 else
3137 {
3138 real_comment_multiline(editor, line_start, last_line);
3139 count_commented++;
3140 }
3141
3142 /* break because we are already on the last line */
3143 break_loop = TRUE;
3144 break;
3145 }
3146 }
3147
3148 sci_end_undo_action(editor->sci);
3149
3150 co_len += tm_len;
3151
3152 /* restore selection or caret position */
3153 if (single_line)
3154 {
3155 gint a = (first_line_was_comment) ? - (gint) co_len : (gint) co_len;
3156 gint indent_len;
3157
3158 /* don't modify sel_start when the selection starts within indentation */
3159 read_indent(editor, sel_start);
3160 indent_len = (gint) strlen(indent);
3161 if ((sel_start - first_line_start) <= indent_len)
3162 a = 0;
3163 /* if the selection start was inside the comment mark, adjust the position */
3164 else if (first_line_was_comment &&
3165 sel_start >= (first_line_start + indent_len) &&
3166 sel_start <= (first_line_start + indent_len + (gint) co_len))
3167 {
3168 a = (first_line_start + indent_len) - sel_start;
3169 }
3170
3171 if (sel_start < sel_end)
3172 {
3173 gint b = (count_commented * (gint) co_len) - (count_uncommented * (gint) co_len);
3174
3175 /* same for selection end, but here we add an offset on the offset above */
3176 read_indent(editor, sel_end + b);
3177 indent_len = (gint) strlen(indent);
3178 if ((sel_end - last_line_start) < indent_len)
3179 b += last_line_was_comment ? (gint) co_len : -(gint) co_len;
3180 else if (last_line_was_comment &&
3181 sel_end >= (last_line_start + indent_len) &&
3182 sel_end <= (last_line_start + indent_len + (gint) co_len))
3183 {
3184 b += (gint) co_len - (sel_end - (last_line_start + indent_len));
3185 }
3186
3187 sci_set_selection_start(editor->sci, sel_start + a);
3188 sci_set_selection_end(editor->sci, sel_end + b);
3189 }
3190 else
3191 sci_set_current_position(editor->sci, sel_start + a, TRUE);
3192 }
3193 else
3194 {
3195 gint eol_len = editor_get_eol_char_len(editor);
3196 if (count_uncommented > 0)
3197 {
3198 sci_set_selection_start(editor->sci, sel_start - (gint) co_len + eol_len);
3199 sci_set_selection_end(editor->sci, sel_end - (gint) co_len + eol_len);
3200 }
3201 else if (count_commented > 0)
3202 {
3203 sci_set_selection_start(editor->sci, sel_start + (gint) co_len - eol_len);
3204 sci_set_selection_end(editor->sci, sel_end + (gint) co_len - eol_len);
3205 }
3206 if (sel_start >= sel_end)
3207 sci_scroll_caret(editor->sci);
3208 }
3209 }
3210
3211
3212 /* set toggle to TRUE if the caller is the toggle function, FALSE otherwise */
3213 gint editor_do_comment(GeanyEditor *editor, gint line, gboolean allow_empty_lines, gboolean toggle,
3214 gboolean single_comment)
3215 {
3216 gint first_line, last_line;
3217 gint x, i, line_start, line_len;
3218 gint sel_start, sel_end, co_len;
3219 gint count = 0;
3220 gchar sel[256];
3221 const gchar *co, *cc;
3222 gboolean break_loop = FALSE, single_line = FALSE;
3223 GeanyFiletype *ft;
3224
3225 g_return_val_if_fail(editor != NULL && editor->document->file_type != NULL, 0);
3226
3227 if (line < 0)
3228 { /* use selection or current line */
3229 sel_start = sci_get_selection_start(editor->sci);
3230 sel_end = sci_get_selection_end(editor->sci);
3231
3232 first_line = sci_get_line_from_position(editor->sci, sel_start);
3233 /* Find the last line with chars selected (not EOL char) */
3234 last_line = sci_get_line_from_position(editor->sci,
3235 sel_end - editor_get_eol_char_len(editor));
3236 last_line = MAX(first_line, last_line);
3237 }
3238 else
3239 {
3240 first_line = last_line = line;
3241 sel_start = sel_end = sci_get_position_from_line(editor->sci, line);
3242 }
3243
3244 ft = editor_get_filetype_at_line(editor, first_line);
3245
3246 if (! filetype_get_comment_open_close(ft, single_comment, &co, &cc))
3247 return 0;
3248
3249 co_len = strlen(co);
3250 if (co_len == 0)
3251 return 0;
3252
3253 sci_start_undo_action(editor->sci);
3254
3255 for (i = first_line; (i <= last_line) && (! break_loop); i++)
3256 {
3257 gint buf_len;
3258
3259 line_start = sci_get_position_from_line(editor->sci, i);
3260 line_len = sci_get_line_end_position(editor->sci, i) - line_start;
3261 x = 0;
3262
3263 buf_len = MIN((gint)sizeof(sel) - 1, line_len);
3264 if (buf_len < 0)
3265 continue;
3266 sci_get_text_range(editor->sci, line_start, line_start + buf_len, sel);
3267 sel[buf_len] = '\0';
3268
3269 while (isspace(sel[x])) x++;
3270
3271 /* to skip blank lines */
3272 if (allow_empty_lines || (x < line_len && sel[x] != '\0'))
3273 {
3274 /* use single line comment */
3275 if (EMPTY(cc))
3276 {
3277 gint start = line_start;
3278 single_line = TRUE;
3279
3280 if (ft->comment_use_indent)
3281 start = line_start + x;
3282
3283 if (toggle)
3284 {
3285 gchar *text = g_strconcat(co, editor_prefs.comment_toggle_mark, NULL);
3286 sci_insert_text(editor->sci, start, text);
3287 g_free(text);
3288 }
3289 else
3290 sci_insert_text(editor->sci, start, co);
3291 count++;
3292 }
3293 /* use multi line comment */
3294 else
3295 {
3296 gint style_comment;
3297
3298 /* skip lines which are already comments */
3299 style_comment = get_multiline_comment_style(editor, line_start);
3300 if (sci_get_style_at(editor->sci, line_start + x) == style_comment)
3301 continue;
3302
3303 real_comment_multiline(editor, line_start, last_line);
3304 count = 1;
3305
3306 /* break because we are already on the last line */
3307 break_loop = TRUE;
3308 break;
3309 }
3310 }
3311 }
3312 sci_end_undo_action(editor->sci);
3313
3314 /* restore selection if there is one
3315 * but don't touch the selection if caller is editor_do_comment_toggle */
3316 if (! toggle && sel_start < sel_end)
3317 {
3318 if (single_line)
3319 {
3320 sci_set_selection_start(editor->sci, sel_start + co_len);
3321 sci_set_selection_end(editor->sci, sel_end + (count * co_len));
3322 }
3323 else
3324 {
3325 gint eol_len = editor_get_eol_char_len(editor);
3326 sci_set_selection_start(editor->sci, sel_start + co_len + eol_len);
3327 sci_set_selection_end(editor->sci, sel_end + co_len + eol_len);
3328 }
3329 }
3330 return count;
3331 }
3332
3333
3334 static gboolean brace_timeout_active = FALSE;
3335
3336 static gboolean delay_match_brace(G_GNUC_UNUSED gpointer user_data)
3337 {
3338 GeanyDocument *doc = document_get_current();
3339 GeanyEditor *editor;
3340 gint brace_pos = GPOINTER_TO_INT(user_data);
3341 gint end_pos, cur_pos;
3342
3343 brace_timeout_active = FALSE;
3344 if (!doc)
3345 return FALSE;
3346
3347 editor = doc->editor;
3348 cur_pos = sci_get_current_position(editor->sci) - 1;
3349
3350 if (cur_pos != brace_pos)
3351 {
3352 cur_pos++;
3353 if (cur_pos != brace_pos)
3354 {
3355 /* we have moved past the original brace_pos, but after the timeout
3356 * we may now be on a new brace, so check again */
3357 editor_highlight_braces(editor, cur_pos);
3358 return FALSE;
3359 }
3360 }
3361 if (!utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3362 {
3363 editor_highlight_braces(editor, cur_pos);
3364 return FALSE;
3365 }
3366 end_pos = sci_find_matching_brace(editor->sci, brace_pos);
3367
3368 if (end_pos >= 0)
3369 {
3370 gint col = MIN(sci_get_col_from_position(editor->sci, brace_pos),
3371 sci_get_col_from_position(editor->sci, end_pos));
3372 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, col, 0);
3373 SSM(editor->sci, SCI_BRACEHIGHLIGHT, brace_pos, end_pos);
3374 }
3375 else
3376 {
3377 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, 0, 0);
3378 SSM(editor->sci, SCI_BRACEBADLIGHT, brace_pos, 0);
3379 }
3380 return FALSE;
3381 }
3382
3383
3384 static void editor_highlight_braces(GeanyEditor *editor, gint cur_pos)
3385 {
3386 gint brace_pos = cur_pos - 1;
3387
3388 SSM(editor->sci, SCI_SETHIGHLIGHTGUIDE, 0, 0);
3389 SSM(editor->sci, SCI_BRACEBADLIGHT, (uptr_t)-1, 0);
3390
3391 if (! utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3392 {
3393 brace_pos++;
3394 if (! utils_isbrace(sci_get_char_at(editor->sci, brace_pos), editor_prefs.brace_match_ltgt))
3395 {
3396 return;
3397 }
3398 }
3399 if (!brace_timeout_active)
3400 {
3401 brace_timeout_active = TRUE;
3402 /* delaying matching makes scrolling faster e.g. holding down arrow keys */
3403 g_timeout_add(100, delay_match_brace, GINT_TO_POINTER(brace_pos));
3404 }
3405 }
3406
3407
3408 static gboolean in_block_comment(gint lexer, gint style)
3409 {
3410 switch (lexer)
3411 {
3412 case SCLEX_COBOL:
3413 case SCLEX_CPP:
3414 return (style == SCE_C_COMMENT ||
3415 style == SCE_C_COMMENTDOC);
3416
3417 case SCLEX_PASCAL:
3418 return (style == SCE_PAS_COMMENT ||
3419 style == SCE_PAS_COMMENT2);
3420
3421 case SCLEX_D:
3422 return (style == SCE_D_COMMENT ||
3423 style == SCE_D_COMMENTDOC ||
3424 style == SCE_D_COMMENTNESTED);
3425
3426 case SCLEX_HTML:
3427 return (style == SCE_HPHP_COMMENT);
3428
3429 case SCLEX_CSS:
3430 return (style == SCE_CSS_COMMENT);
3431
3432 case SCLEX_RUST:
3433 return (style == SCE_RUST_COMMENTBLOCK ||
3434 style == SCE_RUST_COMMENTBLOCKDOC);
3435
3436 default:
3437 return FALSE;
3438 }
3439 }
3440
3441
3442 static gboolean is_comment_char(gchar c, gint lexer)
3443 {
3444 if ((c == '*' || c == '+') && lexer == SCLEX_D)
3445 return TRUE;
3446 else
3447 if (c == '*')
3448 return TRUE;
3449
3450 return FALSE;
3451 }
3452
3453
3454 static void auto_multiline(GeanyEditor *editor, gint cur_line)
3455 {
3456 ScintillaObject *sci = editor->sci;
3457 gint indent_pos, style;
3458 gint lexer = sci_get_lexer(sci);
3459
3460 /* Use the start of the line enter was pressed on, to avoid any doc keyword styles */
3461 indent_pos = sci_get_line_indent_position(sci, cur_line - 1);
3462 style = sci_get_style_at(sci, indent_pos);
3463 if (!in_block_comment(lexer, style))
3464 return;
3465
3466 /* Check whether the comment block continues on this line */
3467 indent_pos = sci_get_line_indent_position(sci, cur_line);
3468 if (sci_get_style_at(sci, indent_pos) == style || indent_pos >= sci_get_length(sci))
3469 {
3470 gchar *previous_line = sci_get_line(sci, cur_line - 1);
3471 /* the type of comment, '*' (C/C++/Java), '+' and the others (D) */
3472 const gchar *continuation = "*";
3473 const gchar *whitespace = ""; /* to hold whitespace if needed */
3474 gchar *result;
3475 gint len = strlen(previous_line);
3476 gint i;
3477
3478 /* find and stop at end of multi line comment */
3479 i = len - 1;
3480 while (i >= 0 && isspace(previous_line[i])) i--;
3481 if (i >= 1 && is_comment_char(previous_line[i - 1], lexer) && previous_line[i] == '/')
3482 {
3483 gint indent_len, indent_width;
3484
3485 indent_pos = sci_get_line_indent_position(sci, cur_line);
3486 indent_len = sci_get_col_from_position(sci, indent_pos);
3487 indent_width = editor_get_indent_prefs(editor)->width;
3488
3489 /* if there is one too many spaces, delete the last space,
3490 * to return to the indent used before the multiline comment was started. */
3491 if (indent_len % indent_width == 1)
3492 SSM(sci, SCI_DELETEBACKNOTLINE, 0, 0); /* remove whitespace indent */
3493 g_free(previous_line);
3494 return;
3495 }
3496 /* check whether we are on the second line of multi line comment */
3497 i = 0;
3498 while (i < len && isspace(previous_line[i])) i++; /* get to start of the line */
3499
3500 if (i + 1 < len &&
3501 previous_line[i] == '/' && is_comment_char(previous_line[i + 1], lexer))
3502 { /* we are on the second line of a multi line comment, so we have to insert white space */
3503 whitespace = " ";
3504 }
3505
3506 if (style == SCE_D_COMMENTNESTED)
3507 continuation = "+"; /* for nested comments in D */
3508
3509 result = g_strconcat(whitespace, continuation, " ", NULL);
3510 sci_add_text(sci, result);
3511 g_free(result);
3512
3513 g_free(previous_line);
3514 }
3515 }
3516
3517
3518 #if 0
3519 static gboolean editor_lexer_is_c_like(gint lexer)
3520 {
3521 switch (lexer)
3522 {
3523 case SCLEX_CPP:
3524 case SCLEX_D:
3525 return TRUE;
3526
3527 default:
3528 return FALSE;
3529 }
3530 }
3531 #endif
3532
3533
3534 /* inserts a three-line comment at one line above current cursor position */
3535 void editor_insert_multiline_comment(GeanyEditor *editor)
3536 {
3537 gchar *text;
3538 gint text_len;
3539 gint line;
3540 gint pos;
3541 gboolean have_multiline_comment = FALSE;
3542 GeanyDocument *doc;
3543 const gchar *co, *cc;
3544
3545 g_return_if_fail(editor != NULL && editor->document->file_type != NULL);
3546
3547 if (! filetype_get_comment_open_close(editor->document->file_type, FALSE, &co, &cc))
3548 g_return_if_reached();
3549 if (!EMPTY(cc))
3550 have_multiline_comment = TRUE;
3551
3552 sci_start_undo_action(editor->sci);
3553
3554 doc = editor->document;
3555
3556 /* insert three lines one line above of the current position */
3557 line = sci_get_line_from_position(editor->sci, editor_info.click_pos);
3558 pos = sci_get_position_from_line(editor->sci, line);
3559
3560 /* use the indent on the current line but only when comment indentation is used
3561 * and we don't have multi line comment characters */
3562 if (editor->auto_indent &&
3563 ! have_multiline_comment && doc->file_type->comment_use_indent)
3564 {
3565 read_indent(editor, editor_info.click_pos);
3566 text = g_strdup_printf("%s\n%s\n%s\n", indent, indent, indent);
3567 text_len = strlen(text);
3568 }
3569 else
3570 {
3571 text = g_strdup("\n\n\n");
3572 text_len = 3;
3573 }
3574 sci_insert_text(editor->sci, pos, text);
3575 g_free(text);
3576
3577 /* select the inserted lines for commenting */
3578 sci_set_selection_start(editor->sci, pos);
3579 sci_set_selection_end(editor->sci, pos + text_len);
3580
3581 editor_do_comment(editor, -1, TRUE, FALSE, FALSE);
3582
3583 /* set the current position to the start of the first inserted line */
3584 pos += strlen(co);
3585
3586 /* on multi line comment jump to the next line, otherwise add the length of added indentation */
3587 if (have_multiline_comment)
3588 pos += 1;
3589 else
3590 pos += strlen(indent);
3591
3592 sci_set_current_position(editor->sci, pos, TRUE);
3593 /* reset the selection */
3594 sci_set_anchor(editor->sci, pos);
3595
3596 sci_end_undo_action(editor->sci);
3597 }
3598
3599
3600 /* Note: If the editor is pending a redraw, set document::scroll_percent instead.
3601 * Scroll the view to make line appear at percent_of_view.
3602 * line can be -1 to use the current position. */
3603 void editor_scroll_to_line(GeanyEditor *editor, gint line, gfloat percent_of_view)
3604 {
3605 gint los;
3606 GtkWidget *wid;
3607
3608 g_return_if_fail(editor != NULL);
3609
3610 wid = GTK_WIDGET(editor->sci);
3611
3612 if (! gtk_widget_get_window(wid) || ! gdk_window_is_viewable(gtk_widget_get_window(wid)))
3613 return; /* prevent gdk_window_scroll warning */
3614
3615 if (line == -1)
3616 line = sci_get_current_line(editor->sci);
3617
3618 /* sci 'visible line' != doc line number because of folding and line wrapping */
3619 /* calling SCI_VISIBLEFROMDOCLINE for line is more accurate than calling
3620 * SCI_DOCLINEFROMVISIBLE for vis1. */
3621 line = SSM(editor->sci, SCI_VISIBLEFROMDOCLINE, line, 0);
3622 los = SSM(editor->sci, SCI_LINESONSCREEN, 0, 0);
3623 line = line - los * percent_of_view;
3624 SSM(editor->sci, SCI_SETFIRSTVISIBLELINE, line, 0);
3625 sci_scroll_caret(editor->sci); /* needed for horizontal scrolling */
3626 }
3627
3628
3629 /* creates and inserts one tab or whitespace of the amount of the tab width */
3630 void editor_insert_alternative_whitespace(GeanyEditor *editor)
3631 {
3632 gchar *text;
3633 GeanyIndentPrefs iprefs = *editor_get_indent_prefs(editor);
3634
3635 g_return_if_fail(editor != NULL);
3636
3637 switch (iprefs.type)
3638 {
3639 case GEANY_INDENT_TYPE_TABS:
3640 iprefs.type = GEANY_INDENT_TYPE_SPACES;
3641 break;
3642 case GEANY_INDENT_TYPE_SPACES:
3643 case GEANY_INDENT_TYPE_BOTH: /* most likely we want a tab */
3644 iprefs.type = GEANY_INDENT_TYPE_TABS;
3645 break;
3646 }
3647 text = get_whitespace(&iprefs, iprefs.width);
3648 sci_add_text(editor->sci, text);
3649 g_free(text);
3650 }
3651
3652
3653 void editor_select_word(GeanyEditor *editor)
3654 {
3655 gint pos;
3656 gint start;
3657 gint end;
3658
3659 g_return_if_fail(editor != NULL);
3660
3661 pos = SSM(editor->sci, SCI_GETCURRENTPOS, 0, 0);
3662 start = sci_word_start_position(editor->sci, pos, TRUE);
3663 end = sci_word_end_position(editor->sci, pos, TRUE);
3664
3665 if (start == end) /* caret in whitespaces sequence */
3666 {
3667 /* look forward but reverse the selection direction,
3668 * so the caret end up stay as near as the original position. */
3669 end = sci_word_end_position(editor->sci, pos, FALSE);
3670 start = sci_word_end_position(editor->sci, end, TRUE);
3671 if (start == end)
3672 return;
3673 }
3674
3675 sci_set_selection(editor->sci, start, end);
3676 }
3677
3678
3679 /* extra_line is for selecting the cursor line (or anchor line) at the bottom of a selection,
3680 * when those lines have no selection (cursor at start of line). */
3681 void editor_select_lines(GeanyEditor *editor, gboolean extra_line)
3682 {
3683 gint start, end, line;
3684
3685 g_return_if_fail(editor != NULL);
3686
3687 start = sci_get_selection_start(editor->sci);
3688 end = sci_get_selection_end(editor->sci);
3689
3690 /* check if whole lines are already selected */
3691 if (! extra_line && start != end &&
3692 sci_get_col_from_position(editor->sci, start) == 0 &&
3693 sci_get_col_from_position(editor->sci, end) == 0)
3694 return;
3695
3696 line = sci_get_line_from_position(editor->sci, start);
3697 start = sci_get_position_from_line(editor->sci, line);
3698
3699 line = sci_get_line_from_position(editor->sci, end);
3700 end = sci_get_position_from_line(editor->sci, line + 1);
3701
3702 sci_set_selection(editor->sci, start, end);
3703 }
3704
3705
3706 static gboolean sci_is_blank_line(ScintillaObject *sci, gint line)
3707 {
3708 return sci_get_line_indent_position(sci, line) ==
3709 sci_get_line_end_position(sci, line);
3710 }
3711
3712
3713 /* Returns first line of paragraph for GTK_DIR_UP, line after paragraph
3714 * ends for GTK_DIR_DOWN or -1 if called on an empty line. */
3715 static gint find_paragraph_stop(GeanyEditor *editor, gint line, gint direction)
3716 {
3717 gint step;
3718 ScintillaObject *sci = editor->sci;
3719
3720 /* first check current line and return -1 if it is empty to skip creating of a selection */
3721 if (sci_is_blank_line(sci, line))
3722 return -1;
3723
3724 if (direction == GTK_DIR_UP)
3725 step = -1;
3726 else
3727 step = 1;
3728
3729 while (TRUE)
3730 {
3731 line += step;
3732 if (line == -1)
3733 {
3734 /* start of document */
3735 line = 0;
3736 break;
3737 }
3738 if (line == sci_get_line_count(sci))
3739 break;
3740
3741 if (sci_is_blank_line(sci, line))
3742 {
3743 /* return line paragraph starts on */
3744 if (direction == GTK_DIR_UP)
3745 line++;
3746 break;
3747 }
3748 }
3749 return line;
3750 }
3751
3752
3753 void editor_select_paragraph(GeanyEditor *editor)
3754 {
3755 gint pos_start, pos_end, line_start, line_found;
3756
3757 g_return_if_fail(editor != NULL);
3758
3759 line_start = sci_get_current_line(editor->sci);
3760
3761 line_found = find_paragraph_stop(editor, line_start, GTK_DIR_UP);
3762 if (line_found == -1)
3763 return;
3764
3765 pos_start = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3766
3767 line_found = find_paragraph_stop(editor, line_start, GTK_DIR_DOWN);
3768 pos_end = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3769
3770 sci_set_selection(editor->sci, pos_start, pos_end);
3771 }
3772
3773
3774 /* Returns first line of block for GTK_DIR_UP, line after block
3775 * ends for GTK_DIR_DOWN or -1 if called on an empty line. */
3776 static gint find_block_stop(GeanyEditor *editor, gint line, gint direction)
3777 {
3778 gint step, ind;
3779 ScintillaObject *sci = editor->sci;
3780
3781 /* first check current line and return -1 if it is empty to skip creating of a selection */
3782 if (sci_is_blank_line(sci, line))
3783 return -1;
3784
3785 if (direction == GTK_DIR_UP)
3786 step = -1;
3787 else
3788 step = 1;
3789
3790 ind = sci_get_line_indentation(sci, line);
3791 while (TRUE)
3792 {
3793 line += step;
3794 if (line == -1)
3795 {
3796 /* start of document */
3797 line = 0;
3798 break;
3799 }
3800 if (line == sci_get_line_count(sci))
3801 break;
3802
3803 if (sci_get_line_indentation(sci, line) != ind ||
3804 sci_is_blank_line(sci, line))
3805 {
3806 /* return line block starts on */
3807 if (direction == GTK_DIR_UP)
3808 line++;
3809 break;
3810 }
3811 }
3812 return line;
3813 }
3814
3815
3816 void editor_select_indent_block(GeanyEditor *editor)
3817 {
3818 gint pos_start, pos_end, line_start, line_found;
3819
3820 g_return_if_fail(editor != NULL);
3821
3822 line_start = sci_get_current_line(editor->sci);
3823
3824 line_found = find_block_stop(editor, line_start, GTK_DIR_UP);
3825 if (line_found == -1)
3826 return;
3827
3828 pos_start = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3829
3830 line_found = find_block_stop(editor, line_start, GTK_DIR_DOWN);
3831 pos_end = SSM(editor->sci, SCI_POSITIONFROMLINE, line_found, 0);
3832
3833 sci_set_selection(editor->sci, pos_start, pos_end);
3834 }
3835
3836
3837 /* simple indentation to indent the current line with the same indent as the previous one */
3838 static void smart_line_indentation(GeanyEditor *editor, gint first_line, gint last_line)
3839 {
3840 gint i, sel_start = 0, sel_end = 0;
3841
3842 /* get previous line and use it for read_indent to use that line
3843 * (otherwise it would fail on a line only containing "{" in advanced indentation mode) */
3844 read_indent(editor, sci_get_position_from_line(editor->sci, first_line - 1));
3845
3846 for (i = first_line; i <= last_line; i++)
3847 {
3848 /* skip the first line or if the indentation of the previous and current line are equal */
3849 if (i == 0 ||
3850 SSM(editor->sci, SCI_GETLINEINDENTATION, i - 1, 0) ==
3851 SSM(editor->sci, SCI_GETLINEINDENTATION, i, 0))
3852 continue;
3853
3854 sel_start = SSM(editor->sci, SCI_POSITIONFROMLINE, i, 0);
3855 sel_end = SSM(editor->sci, SCI_GETLINEINDENTPOSITION, i, 0);
3856 if (sel_start < sel_end)
3857 {
3858 sci_set_selection(editor->sci, sel_start, sel_end);
3859 sci_replace_sel(editor->sci, "");
3860 }
3861 sci_insert_text(editor->sci, sel_start, indent);
3862 }
3863 }
3864
3865
3866 /* simple indentation to indent the current line with the same indent as the previous one */
3867 void editor_smart_line_indentation(GeanyEditor *editor, gint pos)
3868 {
3869 gint first_line, last_line;
3870 gint first_sel_start, first_sel_end;
3871 ScintillaObject *sci;
3872
3873 g_return_if_fail(editor != NULL);
3874
3875 sci = editor->sci;
3876
3877 first_sel_start = sci_get_selection_start(sci);
3878 first_sel_end = sci_get_selection_end(sci);
3879
3880 first_line = sci_get_line_from_position(sci, first_sel_start);
3881 /* Find the last line with chars selected (not EOL char) */
3882 last_line = sci_get_line_from_position(sci, first_sel_end - editor_get_eol_char_len(editor));
3883 last_line = MAX(first_line, last_line);
3884
3885 if (pos == -1)
3886 pos = first_sel_start;
3887
3888 sci_start_undo_action(sci);
3889
3890 smart_line_indentation(editor, first_line, last_line);
3891
3892 /* set cursor position if there was no selection */
3893 if (first_sel_start == first_sel_end)
3894 {
3895 gint indent_pos = SSM(sci, SCI_GETLINEINDENTPOSITION, first_line, 0);
3896
3897 /* use indent position as user may wish to change indentation afterwards */
3898 sci_set_current_position(sci, indent_pos, FALSE);
3899 }
3900 else
3901 {
3902 /* fully select all the lines affected */
3903 sci_set_selection_start(sci, sci_get_position_from_line(sci, first_line));
3904 sci_set_selection_end(sci, sci_get_position_from_line(sci, last_line + 1));
3905 }
3906
3907 sci_end_undo_action(sci);
3908 }
3909
3910
3911 /* increase / decrease current line or selection by one space */
3912 void editor_indentation_by_one_space(GeanyEditor *editor, gint pos, gboolean decrease)
3913 {
3914 gint i, first_line, last_line, line_start, indentation_end, count = 0;
3915 gint sel_start, sel_end, first_line_offset = 0;
3916
3917 g_return_if_fail(editor != NULL);
3918
3919 sel_start = sci_get_selection_start(editor->sci);
3920 sel_end = sci_get_selection_end(editor->sci);
3921
3922 first_line = sci_get_line_from_position(editor->sci, sel_start);
3923 /* Find the last line with chars selected (not EOL char) */
3924 last_line = sci_get_line_from_position(editor->sci, sel_end - editor_get_eol_char_len(editor));
3925 last_line = MAX(first_line, last_line);
3926
3927 if (pos == -1)
3928 pos = sel_start;
3929
3930 sci_start_undo_action(editor->sci);
3931
3932 for (i = first_line; i <= last_line; i++)
3933 {
3934 indentation_end = SSM(editor->sci, SCI_GETLINEINDENTPOSITION, i, 0);
3935 if (decrease)
3936 {
3937 line_start = SSM(editor->sci, SCI_POSITIONFROMLINE, i, 0);
3938 /* searching backwards for a space to remove */
3939 while (sci_get_char_at(editor->sci, indentation_end) != ' ' && indentation_end > line_start)
3940 indentation_end--;
3941
3942 if (sci_get_char_at(editor->sci, indentation_end) == ' ')
3943 {
3944 sci_set_selection(editor->sci, indentation_end, indentation_end + 1);
3945 sci_replace_sel(editor->sci, "");
3946 count--;
3947 if (i == first_line)
3948 first_line_offset = -1;
3949 }
3950 }
3951 else
3952 {
3953 sci_insert_text(editor->sci, indentation_end, " ");
3954 count++;
3955 if (i == first_line)
3956 first_line_offset = 1;
3957 }
3958 }
3959
3960 /* set cursor position */
3961 if (sel_start < sel_end)
3962 {
3963 gint start = sel_start + first_line_offset;
3964 if (first_line_offset < 0)
3965 start = MAX(sel_start + first_line_offset,
3966 SSM(editor->sci, SCI_POSITIONFROMLINE, first_line, 0));
3967
3968 sci_set_selection_start(editor->sci, start);
3969 sci_set_selection_end(editor->sci, sel_end + count);
3970 }
3971 else
3972 sci_set_current_position(editor->sci, pos + count, FALSE);
3973
3974 sci_end_undo_action(editor->sci);
3975 }
3976
3977
3978 void editor_finalize(void)
3979 {
3980 scintilla_release_resources();
3981 }
3982
3983
3984 /* wordchars: NULL or a string containing characters to match a word.
3985 * Returns: the current selection or the current word.
3986 *
3987 * Passing NULL as wordchars is NOT the same as passing GEANY_WORDCHARS: NULL means
3988 * using Scintillas's word boundaries. */
3989 gchar *editor_get_default_selection(GeanyEditor *editor, gboolean use_current_word,
3990 const gchar *wordchars)
3991 {
3992 gchar *s = NULL;
3993
3994 g_return_val_if_fail(editor != NULL, NULL);
3995
3996 if (sci_get_lines_selected(editor->sci) == 1)
3997 s = sci_get_selection_contents(editor->sci);
3998 else if (sci_get_lines_selected(editor->sci) == 0 && use_current_word)
3999 { /* use the word at current cursor position */
4000 gchar word[GEANY_MAX_WORD_LENGTH];
4001
4002 if (wordchars != NULL)
4003 editor_find_current_word(editor, -1, word, sizeof(word), wordchars);
4004 else
4005 editor_find_current_word_sciwc(editor, -1, word, sizeof(word));
4006
4007 if (word[0] != '\0')
4008 s = g_strdup(word);
4009 }
4010 return s;
4011 }
4012
4013
4014 /* Note: Usually the line should be made visible (not folded) before calling this.
4015 * Returns: TRUE if line is/will be displayed to the user, or FALSE if it is
4016 * outside the *vertical* view.
4017 * Warning: You may need horizontal scrolling to make the cursor visible - so always call
4018 * sci_scroll_caret() when this returns TRUE. */
4019 gboolean editor_line_in_view(GeanyEditor *editor, gint line)
4020 {
4021 gint vis1, los;
4022
4023 g_return_val_if_fail(editor != NULL, FALSE);
4024
4025 /* If line is wrapped the result may occur on another virtual line than the first and may be
4026 * still hidden, so increase the line number to check for the next document line */
4027 if (SSM(editor->sci, SCI_WRAPCOUNT, line, 0) > 1)
4028 line++;
4029
4030 line = SSM(editor->sci, SCI_VISIBLEFROMDOCLINE, line, 0); /* convert to visible line number */
4031 vis1 = SSM(editor->sci, SCI_GETFIRSTVISIBLELINE, 0, 0);
4032 los = SSM(editor->sci, SCI_LINESONSCREEN, 0, 0);
4033
4034 return (line >= vis1 && line < vis1 + los);
4035 }
4036
4037
4038 /* If the current line is outside the current view window, scroll the line
4039 * so it appears at percent_of_view. */
4040 void editor_display_current_line(GeanyEditor *editor, gfloat percent_of_view)
4041 {
4042 gint line;
4043
4044 g_return_if_fail(editor != NULL);
4045
4046 line = sci_get_current_line(editor->sci);
4047
4048 /* unfold maybe folded results */
4049 sci_ensure_line_is_visible(editor->sci, line);
4050
4051 /* scroll the line if it's off screen */
4052 if (! editor_line_in_view(editor, line))
4053 editor->scroll_percent = percent_of_view;
4054 else
4055 sci_scroll_caret(editor->sci); /* may need horizontal scrolling */
4056 }
4057
4058
4059 /*
4060 * Deletes all currently set indicators in the @a editor window.
4061 * Error indicators (red squiggly underlines) and usual line markers are removed.
4062 *
4063 * @param editor The editor to operate on.
4064 */
4065 void editor_indicator_clear_errors(GeanyEditor *editor)
4066 {
4067 editor_indicator_clear(editor, GEANY_INDICATOR_ERROR);
4068 sci_marker_delete_all(editor->sci, 0); /* remove the yellow error line marker */
4069 }
4070
4071
4072 /**
4073 * Deletes all currently set indicators matching @a indic in the @a editor window.
4074 *
4075 * @param editor The editor to operate on.
4076 * @param indic The indicator number to clear, this is a value of @ref GeanyIndicator.
4077 *
4078 * @since 0.16
4079 */
4080 void editor_indicator_clear(GeanyEditor *editor, gint indic)
4081 {
4082 glong last_pos;
4083
4084 g_return_if_fail(editor != NULL);
4085
4086 last_pos = sci_get_length(editor->sci);
4087 if (last_pos > 0)
4088 {
4089 sci_indicator_set(editor->sci, indic);
4090 sci_indicator_clear(editor->sci, 0, last_pos);
4091 }
4092 }
4093
4094
4095 /**
4096 * Sets an indicator @a indic on @a line.
4097 * Whitespace at the start and the end of the line is not marked.
4098 *
4099 * @param editor The editor to operate on.
4100 * @param indic The indicator number to use, this is a value of @ref GeanyIndicator.
4101 * @param line The line number which should be marked.
4102 *
4103 * @since 0.16
4104 */
4105 void editor_indicator_set_on_line(GeanyEditor *editor, gint indic, gint line)
4106 {
4107 gint start, end;
4108 guint i = 0, len;
4109 gchar *linebuf;
4110
4111 g_return_if_fail(editor != NULL);
4112 g_return_if_fail(line >= 0);
4113
4114 start = sci_get_position_from_line(editor->sci, line);
4115 end = sci_get_position_from_line(editor->sci, line + 1);
4116
4117 /* skip blank lines */
4118 if ((start + 1) == end ||
4119 start > end ||
4120 (sci_get_line_end_position(editor->sci, line) - start) == 0)
4121 {
4122 return;
4123 }
4124
4125 len = end - start;
4126 linebuf = sci_get_line(editor->sci, line);
4127
4128 /* don't set the indicator on whitespace */
4129 while (isspace(linebuf[i]))
4130 i++;
4131 while (len > 1 && len > i && isspace(linebuf[len - 1]))
4132 {
4133 len--;
4134 end--;
4135 }
4136 g_free(linebuf);
4137
4138 editor_indicator_set_on_range(editor, indic, start + i, end);
4139 }
4140
4141
4142 /**
4143 * Sets an indicator on the range specified by @a start and @a end.
4144 * No error checking or whitespace removal is performed, this should be done by the calling
4145 * function if necessary.
4146 *
4147 * @param editor The editor to operate on.
4148 * @param indic The indicator number to use, this is a value of @ref GeanyIndicator.
4149 * @param start The starting position for the marker.
4150 * @param end The ending position for the marker.
4151 *
4152 * @since 0.16
4153 */
4154 void editor_indicator_set_on_range(GeanyEditor *editor, gint indic, gint start, gint end)
4155 {
4156 g_return_if_fail(editor != NULL);
4157 if (start >= end)
4158 return;
4159
4160 sci_indicator_set(editor->sci, indic);
4161 sci_indicator_fill(editor->sci, start, end - start);
4162 }
4163
4164
4165 /* Inserts the given colour (format should be #...), if there is a selection starting with 0x...
4166 * the replacement will also start with 0x... */
4167 void editor_insert_color(GeanyEditor *editor, const gchar *colour)
4168 {
4169 g_return_if_fail(editor != NULL);
4170
4171 if (sci_has_selection(editor->sci))
4172 {
4173 gint start = sci_get_selection_start(editor->sci);
4174 const gchar *replacement = colour;
4175
4176 if (sci_get_char_at(editor->sci, start) == '0' &&
4177 sci_get_char_at(editor->sci, start + 1) == 'x')
4178 {
4179 gint end = sci_get_selection_end(editor->sci);
4180
4181 sci_set_selection_start(editor->sci, start + 2);
4182 /* we need to also re-set the selection end in case the anchor was located before
4183 * the cursor, since set_selection_start() always moves the cursor, not the anchor */
4184 sci_set_selection_end(editor->sci, end);
4185 replacement++; /* skip the leading "0x" */
4186 }
4187 else if (sci_get_char_at(editor->sci, start - 1) == '#')
4188 { /* double clicking something like #00ffff may only select 00ffff because of wordchars */
4189 replacement++; /* so skip the '#' to only replace the colour value */
4190 }
4191 sci_replace_sel(editor->sci, replacement);
4192 }
4193 else
4194 sci_add_text(editor->sci, colour);
4195 }
4196
4197
4198 /**
4199 * Retrieves the end of line characters mode (LF, CR/LF, CR) in the given editor.
4200 * If @a editor is @c NULL, the default end of line characters are used.
4201 *
4202 * @param editor The editor to operate on, or @c NULL to query the default value.
4203 * @return The used end of line characters mode.
4204 *
4205 * @since 0.20
4206 */
4207 gint editor_get_eol_char_mode(GeanyEditor *editor)
4208 {
4209 gint mode = file_prefs.default_eol_character;
4210
4211 if (editor != NULL)
4212 mode = sci_get_eol_mode(editor->sci);
4213
4214 return mode;
4215 }
4216
4217
4218 /**
4219 * Retrieves the localized name (for displaying) of the used end of line characters
4220 * (LF, CR/LF, CR) in the given editor.
4221 * If @a editor is @c NULL, the default end of line characters are used.
4222 *
4223 * @param editor The editor to operate on, or @c NULL to query the default value.
4224 * @return The name of the end of line characters.
4225 *
4226 * @since 0.19
4227 */
4228 const gchar *editor_get_eol_char_name(GeanyEditor *editor)
4229 {
4230 gint mode = file_prefs.default_eol_character;
4231
4232 if (editor != NULL)
4233 mode = sci_get_eol_mode(editor->sci);
4234
4235 return utils_get_eol_name(mode);
4236 }
4237
4238
4239 /**
4240 * Retrieves the length of the used end of line characters (LF, CR/LF, CR) in the given editor.
4241 * If @a editor is @c NULL, the default end of line characters are used.
4242 * The returned value is 1 for CR and LF and 2 for CR/LF.
4243 *
4244 * @param editor The editor to operate on, or @c NULL to query the default value.
4245 * @return The length of the end of line characters.
4246 *
4247 * @since 0.19
4248 */
4249 gint editor_get_eol_char_len(GeanyEditor *editor)
4250 {
4251 gint mode = file_prefs.default_eol_character;
4252
4253 if (editor != NULL)
4254 mode = sci_get_eol_mode(editor->sci);
4255
4256 switch (mode)
4257 {
4258 case SC_EOL_CRLF: return 2; break;
4259 default: return 1; break;
4260 }
4261 }
4262
4263
4264 /**
4265 * Retrieves the used end of line characters (LF, CR/LF, CR) in the given editor.
4266 * If @a editor is @c NULL, the default end of line characters are used.
4267 * The returned value is either "\n", "\r\n" or "\r".
4268 *
4269 * @param editor The editor to operate on, or @c NULL to query the default value.
4270 * @return The end of line characters.
4271 *
4272 * @since 0.19
4273 */
4274 const gchar *editor_get_eol_char(GeanyEditor *editor)
4275 {
4276 gint mode = file_prefs.default_eol_character;
4277
4278 if (editor != NULL)
4279 mode = sci_get_eol_mode(editor->sci);
4280
4281 return utils_get_eol_char(mode);
4282 }
4283
4284
4285 static void fold_all(GeanyEditor *editor, gboolean want_fold)
4286 {
4287 gint lines, first, i;
4288
4289 if (editor == NULL || ! editor_prefs.folding)
4290 return;
4291
4292 lines = sci_get_line_count(editor->sci);
4293 first = sci_get_first_visible_line(editor->sci);
4294
4295 for (i = 0; i < lines; i++)
4296 {
4297 gint level = sci_get_fold_level(editor->sci, i);
4298
4299 if (level & SC_FOLDLEVELHEADERFLAG)
4300 {
4301 if (sci_get_fold_expanded(editor->sci, i) == want_fold)
4302 sci_toggle_fold(editor->sci, i);
4303 }
4304 }
4305 editor_scroll_to_line(editor, first, 0.0F);
4306 }
4307
4308
4309 void editor_unfold_all(GeanyEditor *editor)
4310 {
4311 fold_all(editor, FALSE);
4312 }
4313
4314
4315 void editor_fold_all(GeanyEditor *editor)
4316 {
4317 fold_all(editor, TRUE);
4318 }
4319
4320
4321 void editor_replace_tabs(GeanyEditor *editor)
4322 {
4323 gint search_pos, pos_in_line, current_tab_true_length;
4324 gint tab_len;
4325 gchar *tab_str;
4326 struct Sci_TextToFind ttf;
4327
4328 g_return_if_fail(editor != NULL);
4329
4330 sci_start_undo_action(editor->sci);
4331 tab_len = sci_get_tab_width(editor->sci);
4332 ttf.chrg.cpMin = 0;
4333 ttf.chrg.cpMax = sci_get_length(editor->sci);
4334 ttf.lpstrText = (gchar*) "\t";
4335
4336 while (TRUE)
4337 {
4338 search_pos = sci_find_text(editor->sci, SCFIND_MATCHCASE, &ttf);
4339 if (search_pos == -1)
4340 break;
4341
4342 pos_in_line = sci_get_col_from_position(editor->sci, search_pos);
4343 current_tab_true_length = tab_len - (pos_in_line % tab_len);
4344 tab_str = g_strnfill(current_tab_true_length, ' ');
4345 sci_set_target_start(editor->sci, search_pos);
4346 sci_set_target_end(editor->sci, search_pos + 1);
4347 sci_replace_target(editor->sci, tab_str, FALSE);
4348 /* next search starts after replacement */
4349 ttf.chrg.cpMin = search_pos + current_tab_true_length - 1;
4350 /* update end of range now text has changed */
4351 ttf.chrg.cpMax += current_tab_true_length - 1;
4352 g_free(tab_str);
4353 }
4354 sci_end_undo_action(editor->sci);
4355 }
4356
4357
4358 /* Replaces all occurrences all spaces of the length of a given tab_width. */
4359 void editor_replace_spaces(GeanyEditor *editor)
4360 {
4361 gint search_pos;
4362 static gdouble tab_len_f = -1.0; /* keep the last used value */
4363 gint tab_len;
4364 gchar *text;
4365 struct Sci_TextToFind ttf;
4366
4367 g_return_if_fail(editor != NULL);
4368
4369 if (tab_len_f < 0.0)
4370 tab_len_f = sci_get_tab_width(editor->sci);
4371
4372 if (! dialogs_show_input_numeric(
4373 _("Enter Tab Width"),
4374 _("Enter the amount of spaces which should be replaced by a tab character."),
4375 &tab_len_f, 1, 100, 1))
4376 {
4377 return;
4378 }
4379 tab_len = (gint) tab_len_f;
4380 text = g_strnfill(tab_len, ' ');
4381
4382 sci_start_undo_action(editor->sci);
4383 ttf.chrg.cpMin = 0;
4384 ttf.chrg.cpMax = sci_get_length(editor->sci);
4385 ttf.lpstrText = text;
4386
4387 while (TRUE)
4388 {
4389 search_pos = sci_find_text(editor->sci, SCFIND_MATCHCASE, &ttf);
4390 if (search_pos == -1)
4391 break;
4392 /* only replace indentation because otherwise we can mess up alignment */
4393 if (search_pos > sci_get_line_indent_position(editor->sci,
4394 sci_get_line_from_position(editor->sci, search_pos)))
4395 {
4396 ttf.chrg.cpMin = search_pos + tab_len;
4397 continue;
4398 }
4399 sci_set_target_start(editor->sci, search_pos);
4400 sci_set_target_end(editor->sci, search_pos + tab_len);
4401 sci_replace_target(editor->sci, "\t", FALSE);
4402 ttf.chrg.cpMin = search_pos;
4403 /* update end of range now text has changed */
4404 ttf.chrg.cpMax -= tab_len - 1;
4405 }
4406 sci_end_undo_action(editor->sci);
4407 g_free(text);
4408 }
4409
4410
4411 void editor_strip_line_trailing_spaces(GeanyEditor *editor, gint line)
4412 {
4413 gint line_start = sci_get_position_from_line(editor->sci, line);
4414 gint line_end = sci_get_line_end_position(editor->sci, line);
4415 gint i = line_end - 1;
4416 gchar ch = sci_get_char_at(editor->sci, i);
4417
4418 /* Diff hunks should keep trailing spaces */
4419 if (sci_get_lexer(editor->sci) == SCLEX_DIFF)
4420 return;
4421
4422 while ((i >= line_start) && ((ch == ' ') || (ch == '\t')))
4423 {
4424 i--;
4425 ch = sci_get_char_at(editor->sci, i);
4426 }
4427 if (i < (line_end - 1))
4428 {
4429 sci_set_target_start(editor->sci, i + 1);
4430 sci_set_target_end(editor->sci, line_end);
4431 sci_replace_target(editor->sci, "", FALSE);
4432 }
4433 }
4434
4435
4436 void editor_strip_trailing_spaces(GeanyEditor *editor)
4437 {
4438 gint max_lines = sci_get_line_count(editor->sci);
4439 gint line;
4440
4441 sci_start_undo_action(editor->sci);
4442
4443 for (line = 0; line < max_lines; line++)
4444 {
4445 editor_strip_line_trailing_spaces(editor, line);
4446 }
4447 sci_end_undo_action(editor->sci);
4448 }
4449
4450
4451 void editor_ensure_final_newline(GeanyEditor *editor)
4452 {
4453 gint max_lines = sci_get_line_count(editor->sci);
4454 gboolean append_newline = (max_lines == 1);
4455 gint end_document = sci_get_position_from_line(editor->sci, max_lines);
4456
4457 if (max_lines > 1)
4458 {
4459 append_newline = end_document > sci_get_position_from_line(editor->sci, max_lines - 1);
4460 }
4461 if (append_newline)
4462 {
4463 const gchar *eol = editor_get_eol_char(editor);
4464
4465 sci_insert_text(editor->sci, end_document, eol);
4466 }
4467 }
4468
4469
4470 void editor_set_font(GeanyEditor *editor, const gchar *font)
4471 {
4472 gint style, size;
4473 gchar *font_name;
4474 PangoFontDescription *pfd;
4475
4476 g_return_if_fail(editor);
4477
4478 pfd = pango_font_description_from_string(font);
4479 size = pango_font_description_get_size(pfd) / PANGO_SCALE;
4480 font_name = g_strdup_printf("!%s", pango_font_description_get_family(pfd));
4481 pango_font_description_free(pfd);
4482
4483 for (style = 0; style <= STYLE_MAX; style++)
4484 sci_set_font(editor->sci, style, font_name, size);
4485
4486 g_free(font_name);
4487
4488 /* zoom to 100% to prevent confusion */
4489 sci_zoom_off(editor->sci);
4490 }
4491
4492
4493 void editor_set_line_wrapping(GeanyEditor *editor, gboolean wrap)
4494 {
4495 g_return_if_fail(editor != NULL);
4496
4497 editor->line_wrapping = wrap;
4498 sci_set_lines_wrapped(editor->sci, wrap);
4499 }
4500
4501
4502 /** Sets the indent type for @a editor.
4503 * @param editor Editor.
4504 * @param type Indent type.
4505 *
4506 * @since 0.16
4507 */
4508 void editor_set_indent_type(GeanyEditor *editor, GeanyIndentType type)
4509 {
4510 editor_set_indent(editor, type, editor->indent_width);
4511 }
4512
4513
4514 void editor_set_indent_width(GeanyEditor *editor, gint width)
4515 {
4516 editor_set_indent(editor, editor->indent_type, width);
4517 }
4518
4519
4520 void editor_set_indent(GeanyEditor *editor, GeanyIndentType type, gint width)
4521 {
4522 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
4523 ScintillaObject *sci = editor->sci;
4524 gboolean use_tabs = type != GEANY_INDENT_TYPE_SPACES;
4525
4526 editor->indent_type = type;
4527 editor->indent_width = width;
4528 sci_set_use_tabs(sci, use_tabs);
4529
4530 if (type == GEANY_INDENT_TYPE_BOTH)
4531 {
4532 sci_set_tab_width(sci, iprefs->hard_tab_width);
4533 if (iprefs->hard_tab_width != 8)
4534 {
4535 static gboolean warn = TRUE;
4536 if (warn)
4537 ui_set_statusbar(TRUE, _("Warning: non-standard hard tab width: %d != 8!"),
4538 iprefs->hard_tab_width);
4539 warn = FALSE;
4540 }
4541 }
4542 else
4543 sci_set_tab_width(sci, width);
4544
4545 SSM(sci, SCI_SETINDENT, width, 0);
4546
4547 /* remove indent spaces on backspace, if using any spaces to indent */
4548 SSM(sci, SCI_SETBACKSPACEUNINDENTS, type != GEANY_INDENT_TYPE_TABS, 0);
4549 }
4550
4551
4552 /* Convenience function for editor_goto_pos() to pass in a line number. */
4553 gboolean editor_goto_line(GeanyEditor *editor, gint line_no, gint offset)
4554 {
4555 gint pos;
4556
4557 g_return_val_if_fail(editor, FALSE);
4558 if (line_no < 0 || line_no >= sci_get_line_count(editor->sci))
4559 return FALSE;
4560
4561 if (offset != 0)
4562 {
4563 gint current_line = sci_get_current_line(editor->sci);
4564 line_no *= offset;
4565 line_no = current_line + line_no;
4566 }
4567
4568 pos = sci_get_position_from_line(editor->sci, line_no);
4569 return editor_goto_pos(editor, pos, TRUE);
4570 }
4571
4572
4573 /** Moves to position @a pos, switching to the document if necessary,
4574 * setting a marker if @a mark is set.
4575 *
4576 * @param editor Editor.
4577 * @param pos The position.
4578 * @param mark Whether to set a mark on the position.
4579 * @return @c TRUE if action has been performed, otherwise @c FALSE.
4580 *
4581 * @since 0.20
4582 **/
4583 gboolean editor_goto_pos(GeanyEditor *editor, gint pos, gboolean mark)
4584 {
4585 g_return_val_if_fail(editor, FALSE);
4586 if (G_UNLIKELY(pos < 0))
4587 return FALSE;
4588
4589 if (mark)
4590 {
4591 gint line = sci_get_line_from_position(editor->sci, pos);
4592
4593 /* mark the tag with the yellow arrow */
4594 sci_marker_delete_all(editor->sci, 0);
4595 sci_set_marker_at_line(editor->sci, line, 0);
4596 }
4597
4598 sci_goto_pos(editor->sci, pos, TRUE);
4599 editor->scroll_percent = 0.25F;
4600
4601 /* finally switch to the page */
4602 document_show_tab(editor->document);
4603 return TRUE;
4604 }
4605
4606
4607 static gboolean
4608 on_editor_scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer user_data)
4609 {
4610 GeanyEditor *editor = user_data;
4611
4612 /* Handle scroll events if Alt is pressed and scroll whole pages instead of a
4613 * few lines only, maybe this could/should be done in Scintilla directly */
4614 if (event->state & GDK_MOD1_MASK)
4615 {
4616 sci_send_command(editor->sci, (event->direction == GDK_SCROLL_DOWN) ? SCI_PAGEDOWN : SCI_PAGEUP);
4617 return TRUE;
4618 }
4619 else if (event->state & GDK_SHIFT_MASK)
4620 {
4621 gint amount = (event->direction == GDK_SCROLL_DOWN) ? 8 : -8;
4622
4623 sci_scroll_columns(editor->sci, amount);
4624 return TRUE;
4625 }
4626
4627 return FALSE; /* let Scintilla handle all other cases */
4628 }
4629
4630
4631 static gboolean editor_check_colourise(GeanyEditor *editor)
4632 {
4633 GeanyDocument *doc = editor->document;
4634
4635 if (!doc->priv->colourise_needed)
4636 return FALSE;
4637
4638 doc->priv->colourise_needed = FALSE;
4639 sci_colourise(editor->sci, 0, -1);
4640
4641 /* now that the current document is colourised, fold points are now accurate,
4642 * so force an update of the current function/tag. */
4643 symbols_get_current_function(NULL, NULL);
4644 ui_update_statusbar(NULL, -1);
4645
4646 return TRUE;
4647 }
4648
4649
4650 /* We only want to colourise just before drawing, to save startup time and
4651 * prevent unnecessary recolouring other documents after one is saved.
4652 * Really we want a "draw" signal but there doesn't seem to be one (expose is too late,
4653 * and "show" doesn't work). */
4654 static gboolean on_editor_focus_in(GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
4655 {
4656 GeanyEditor *editor = user_data;
4657
4658 editor_check_colourise(editor);
4659 return FALSE;
4660 }
4661
4662
4663 static gboolean on_editor_expose_event(GtkWidget *widget, GdkEventExpose *event,
4664 gpointer user_data)
4665 {
4666 GeanyEditor *editor = user_data;
4667
4668 /* This is just to catch any uncolourised documents being drawn that didn't receive focus
4669 * for some reason, maybe it's not necessary but just in case. */
4670 editor_check_colourise(editor);
4671 return FALSE;
4672 }
4673
4674
4675 #if GTK_CHECK_VERSION(3, 0, 0)
4676 static gboolean on_editor_draw(GtkWidget *widget, cairo_t *cr, gpointer user_data)
4677 {
4678 return on_editor_expose_event(widget, NULL, user_data);
4679 }
4680 #endif
4681
4682
4683 static void setup_sci_keys(ScintillaObject *sci)
4684 {
4685 /* disable some Scintilla keybindings to be able to redefine them cleanly */
4686 sci_clear_cmdkey(sci, 'A' | (SCMOD_CTRL << 16)); /* select all */
4687 sci_clear_cmdkey(sci, 'D' | (SCMOD_CTRL << 16)); /* duplicate */
4688 sci_clear_cmdkey(sci, 'T' | (SCMOD_CTRL << 16)); /* line transpose */
4689 sci_clear_cmdkey(sci, 'T' | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line copy */
4690 sci_clear_cmdkey(sci, 'L' | (SCMOD_CTRL << 16)); /* line cut */
4691 sci_clear_cmdkey(sci, 'L' | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line delete */
4692 sci_clear_cmdkey(sci, SCK_DELETE | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16)); /* line to end delete */
4693 sci_clear_cmdkey(sci, '/' | (SCMOD_CTRL << 16)); /* Previous word part */
4694 sci_clear_cmdkey(sci, '\\' | (SCMOD_CTRL << 16)); /* Next word part */
4695 sci_clear_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16)); /* scroll line up */
4696 sci_clear_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16)); /* scroll line down */
4697 sci_clear_cmdkey(sci, SCK_HOME); /* line start */
4698 sci_clear_cmdkey(sci, SCK_END); /* line end */
4699 sci_clear_cmdkey(sci, SCK_END | (SCMOD_ALT << 16)); /* visual line end */
4700
4701 if (editor_prefs.use_gtk_word_boundaries)
4702 {
4703 /* use GtkEntry-like word boundaries */
4704 sci_assign_cmdkey(sci, SCK_RIGHT | (SCMOD_CTRL << 16), SCI_WORDRIGHTEND);
4705 sci_assign_cmdkey(sci, SCK_RIGHT | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_WORDRIGHTENDEXTEND);
4706 sci_assign_cmdkey(sci, SCK_DELETE | (SCMOD_CTRL << 16), SCI_DELWORDRIGHTEND);
4707 }
4708 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_ALT << 16), SCI_LINESCROLLUP);
4709 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_ALT << 16), SCI_LINESCROLLDOWN);
4710 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16), SCI_PARAUP);
4711 sci_assign_cmdkey(sci, SCK_UP | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_PARAUPEXTEND);
4712 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16), SCI_PARADOWN);
4713 sci_assign_cmdkey(sci, SCK_DOWN | (SCMOD_CTRL << 16) | (SCMOD_SHIFT << 16), SCI_PARADOWNEXTEND);
4714
4715 sci_clear_cmdkey(sci, SCK_BACK | (SCMOD_ALT << 16)); /* clear Alt-Backspace (Undo) */
4716 }
4717
4718
4719 /* registers a Scintilla image from a named icon from the theme */
4720 static gboolean register_named_icon(ScintillaObject *sci, guint id, const gchar *name)
4721 {
4722 GError *error = NULL;
4723 GdkPixbuf *pixbuf;
4724 gint n_channels, rowstride, width, height;
4725 gint size;
4726
4727 gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &size, NULL);
4728 pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), name, size, 0, &error);
4729 if (! pixbuf)
4730 {
4731 g_warning("failed to load icon '%s': %s", name, error->message);
4732 g_error_free(error);
4733 return FALSE;
4734 }
4735
4736 n_channels = gdk_pixbuf_get_n_channels(pixbuf);
4737 rowstride = gdk_pixbuf_get_rowstride(pixbuf);
4738 width = gdk_pixbuf_get_width(pixbuf);
4739 height = gdk_pixbuf_get_height(pixbuf);
4740
4741 if (gdk_pixbuf_get_bits_per_sample(pixbuf) != 8 ||
4742 ! gdk_pixbuf_get_has_alpha(pixbuf) ||
4743 n_channels != 4 ||
4744 rowstride != width * n_channels)
4745 {
4746 g_warning("incompatible image data for icon '%s'", name);
4747 g_object_unref(pixbuf);
4748 return FALSE;
4749 }
4750
4751 SSM(sci, SCI_RGBAIMAGESETWIDTH, width, 0);
4752 SSM(sci, SCI_RGBAIMAGESETHEIGHT, height, 0);
4753 SSM(sci, SCI_REGISTERRGBAIMAGE, id, (sptr_t)gdk_pixbuf_get_pixels(pixbuf));
4754
4755 g_object_unref(pixbuf);
4756 return TRUE;
4757 }
4758
4759
4760 /* Create new editor widget (scintilla).
4761 * @note The @c "sci-notify" signal is connected separately. */
4762 static ScintillaObject *create_new_sci(GeanyEditor *editor)
4763 {
4764 ScintillaObject *sci;
4765
4766 sci = SCINTILLA(scintilla_new());
4767
4768 /* Scintilla doesn't support RTL languages properly and is primarily
4769 * intended to be used with LTR source code, so override the
4770 * GTK+ default text direction for the Scintilla widget. */
4771 gtk_widget_set_direction(GTK_WIDGET(sci), GTK_TEXT_DIR_LTR);
4772
4773 gtk_widget_show(GTK_WIDGET(sci));
4774
4775 sci_set_codepage(sci, SC_CP_UTF8);
4776 /*SSM(sci, SCI_SETWRAPSTARTINDENT, 4, 0);*/
4777 /* disable scintilla provided popup menu */
4778 sci_use_popup(sci, FALSE);
4779
4780 setup_sci_keys(sci);
4781
4782 sci_set_symbol_margin(sci, editor_prefs.show_markers_margin);
4783 sci_set_lines_wrapped(sci, editor->line_wrapping);
4784 sci_set_caret_policy_x(sci, CARET_JUMPS | CARET_EVEN, 0);
4785 /*sci_set_caret_policy_y(sci, CARET_JUMPS | CARET_EVEN, 0);*/
4786 SSM(sci, SCI_AUTOCSETSEPARATOR, '\n', 0);
4787 SSM(sci, SCI_SETSCROLLWIDTHTRACKING, 1, 0);
4788
4789 /* tag autocompletion images */
4790 register_named_icon(sci, 1, "classviewer-var");
4791 register_named_icon(sci, 2, "classviewer-method");
4792
4793 /* necessary for column mode editing, implemented in Scintilla since 2.0 */
4794 SSM(sci, SCI_SETADDITIONALSELECTIONTYPING, 1, 0);
4795
4796 /* virtual space */
4797 SSM(sci, SCI_SETVIRTUALSPACEOPTIONS, editor_prefs.show_virtual_space, 0);
4798
4799 /* only connect signals if this is for the document notebook, not split window */
4800 if (editor->sci == NULL)
4801 {
4802 g_signal_connect(sci, "button-press-event", G_CALLBACK(on_editor_button_press_event), editor);
4803 g_signal_connect(sci, "scroll-event", G_CALLBACK(on_editor_scroll_event), editor);
4804 g_signal_connect(sci, "motion-notify-event", G_CALLBACK(on_motion_event), NULL);
4805 g_signal_connect(sci, "focus-in-event", G_CALLBACK(on_editor_focus_in), editor);
4806 #if GTK_CHECK_VERSION(3, 0, 0)
4807 g_signal_connect(sci, "draw", G_CALLBACK(on_editor_draw), editor);
4808 #else
4809 g_signal_connect(sci, "expose-event", G_CALLBACK(on_editor_expose_event), editor);
4810 #endif
4811 }
4812 return sci;
4813 }
4814
4815
4816 /** Creates a new Scintilla @c GtkWidget based on the settings for @a editor.
4817 * @param editor Editor settings.
4818 * @return The new widget.
4819 *
4820 * @since 0.15
4821 **/
4822 ScintillaObject *editor_create_widget(GeanyEditor *editor)
4823 {
4824 const GeanyIndentPrefs *iprefs = get_default_indent_prefs();
4825 ScintillaObject *old, *sci;
4826 GeanyIndentType old_indent_type = editor->indent_type;
4827 gint old_indent_width = editor->indent_width;
4828
4829 /* temporarily change editor to use the new sci widget */
4830 old = editor->sci;
4831 sci = create_new_sci(editor);
4832 editor->sci = sci;
4833
4834 editor_set_indent(editor, iprefs->type, iprefs->width);
4835 editor_set_font(editor, interface_prefs.editor_font);
4836 editor_apply_update_prefs(editor);
4837
4838 /* if editor already had a widget, restore it */
4839 if (old)
4840 {
4841 editor->indent_type = old_indent_type;
4842 editor->indent_width = old_indent_width;
4843 editor->sci = old;
4844 }
4845 return sci;
4846 }
4847
4848
4849 GeanyEditor *editor_create(GeanyDocument *doc)
4850 {
4851 const GeanyIndentPrefs *iprefs = get_default_indent_prefs();
4852 GeanyEditor *editor = g_new0(GeanyEditor, 1);
4853
4854 editor->document = doc;
4855 doc->editor = editor; /* needed in case some editor functions/callbacks expect it */
4856
4857 editor->auto_indent = (iprefs->auto_indent_mode != GEANY_AUTOINDENT_NONE);
4858 editor->line_wrapping = get_project_pref(line_wrapping);
4859 editor->scroll_percent = -1.0F;
4860 editor->line_breaking = FALSE;
4861
4862 editor->sci = editor_create_widget(editor);
4863 return editor;
4864 }
4865
4866
4867 /* in case we need to free some fields in future */
4868 void editor_destroy(GeanyEditor *editor)
4869 {
4870 g_free(editor);
4871 }
4872
4873
4874 static void on_document_save(GObject *obj, GeanyDocument *doc)
4875 {
4876 gchar *f = g_build_filename(app->configdir, "snippets.conf", NULL);
4877
4878 if (utils_str_equal(doc->real_path, f))
4879 {
4880 /* reload snippets */
4881 editor_snippets_free();
4882 editor_snippets_init();
4883 }
4884 g_free(f);
4885 }
4886
4887
4888 gboolean editor_complete_word_part(GeanyEditor *editor)
4889 {
4890 gchar *entry;
4891
4892 g_return_val_if_fail(editor, FALSE);
4893
4894 if (!SSM(editor->sci, SCI_AUTOCACTIVE, 0, 0))
4895 return FALSE;
4896
4897 entry = sci_get_string(editor->sci, SCI_AUTOCGETCURRENTTEXT, 0);
4898
4899 /* if no word part, complete normally */
4900 if (!check_partial_completion(editor, entry))
4901 SSM(editor->sci, SCI_AUTOCCOMPLETE, 0, 0);
4902
4903 g_free(entry);
4904 return TRUE;
4905 }
4906
4907
4908 void editor_init(void)
4909 {
4910 static GeanyIndentPrefs indent_prefs;
4911 gchar *f;
4912
4913 memset(&editor_prefs, 0, sizeof(GeanyEditorPrefs));
4914 memset(&indent_prefs, 0, sizeof(GeanyIndentPrefs));
4915 editor_prefs.indentation = &indent_prefs;
4916
4917 /* use g_signal_connect_after() to allow plugins connecting to the signal before the default
4918 * handler (on_editor_notify) is called */
4919 g_signal_connect_after(geany_object, "editor-notify", G_CALLBACK(on_editor_notify), NULL);
4920
4921 f = g_build_filename(app->configdir, "snippets.conf", NULL);
4922 ui_add_config_file_menu_item(f, NULL, NULL);
4923 g_free(f);
4924 g_signal_connect(geany_object, "document-save", G_CALLBACK(on_document_save), NULL);
4925 }
4926
4927
4928 /* TODO: Should these be user-defined instead of hard-coded? */
4929 void editor_set_indentation_guides(GeanyEditor *editor)
4930 {
4931 gint mode;
4932 gint lexer;
4933
4934 g_return_if_fail(editor != NULL);
4935
4936 if (! editor_prefs.show_indent_guide)
4937 {
4938 sci_set_indentation_guides(editor->sci, SC_IV_NONE);
4939 return;
4940 }
4941
4942 lexer = sci_get_lexer(editor->sci);
4943 switch (lexer)
4944 {
4945 /* Lines added/removed are prefixed with +/- characters, so
4946 * those lines will not be shown with any indentation guides.
4947 * It can be distracting that only a few of lines in a diff/patch
4948 * file will show the guides. */
4949 case SCLEX_DIFF:
4950 mode = SC_IV_NONE;
4951 break;
4952
4953 /* These languages use indentation for control blocks; the "look forward" method works
4954 * best here */
4955 case SCLEX_PYTHON:
4956 case SCLEX_HASKELL:
4957 case SCLEX_MAKEFILE:
4958 case SCLEX_ASM:
4959 case SCLEX_SQL:
4960 case SCLEX_COBOL:
4961 case SCLEX_PROPERTIES:
4962 case SCLEX_FORTRAN: /* Is this the best option for Fortran? */
4963 case SCLEX_CAML:
4964 mode = SC_IV_LOOKFORWARD;
4965 break;
4966
4967 /* C-like (structured) languages benefit from the "look both" method */
4968 case SCLEX_CPP:
4969 case SCLEX_HTML:
4970 case SCLEX_XML:
4971 case SCLEX_PERL:
4972 case SCLEX_LATEX:
4973 case SCLEX_LUA:
4974 case SCLEX_PASCAL:
4975 case SCLEX_RUBY:
4976 case SCLEX_TCL:
4977 case SCLEX_F77:
4978 case SCLEX_CSS:
4979 case SCLEX_BASH:
4980 case SCLEX_VHDL:
4981 case SCLEX_FREEBASIC:
4982 case SCLEX_D:
4983 case SCLEX_OCTAVE:
4984 case SCLEX_RUST:
4985 mode = SC_IV_LOOKBOTH;
4986 break;
4987
4988 default:
4989 mode = SC_IV_REAL;
4990 break;
4991 }
4992
4993 sci_set_indentation_guides(editor->sci, mode);
4994 }
4995
4996
4997 /* Apply non-document prefs that can change in the Preferences dialog */
4998 void editor_apply_update_prefs(GeanyEditor *editor)
4999 {
5000 ScintillaObject *sci;
5001
5002 g_return_if_fail(editor != NULL);
5003
5004 if (main_status.quitting)
5005 return;
5006
5007 sci = editor->sci;
5008
5009 sci_set_mark_long_lines(sci, editor_get_long_line_type(),
5010 editor_get_long_line_column(), editor_prefs.long_line_color);
5011
5012 /* update indent width, tab width */
5013 editor_set_indent(editor, editor->indent_type, editor->indent_width);
5014 sci_set_tab_indents(sci, editor_prefs.use_tab_to_indent);
5015
5016 sci_assign_cmdkey(sci, SCK_HOME | (SCMOD_SHIFT << 16),
5017 editor_prefs.smart_home_key ? SCI_VCHOMEEXTEND : SCI_HOMEEXTEND);
5018 sci_assign_cmdkey(sci, SCK_HOME | ((SCMOD_SHIFT | SCMOD_ALT) << 16),
5019 editor_prefs.smart_home_key ? SCI_VCHOMERECTEXTEND : SCI_HOMERECTEXTEND);
5020
5021 sci_set_autoc_max_height(sci, editor_prefs.symbolcompletion_max_height);
5022 SSM(sci, SCI_AUTOCSETDROPRESTOFWORD, editor_prefs.completion_drops_rest_of_word, 0);
5023
5024 editor_set_indentation_guides(editor);
5025
5026 sci_set_visible_white_spaces(sci, editor_prefs.show_white_space);
5027 sci_set_visible_eols(sci, editor_prefs.show_line_endings);
5028 sci_set_symbol_margin(sci, editor_prefs.show_markers_margin);
5029 sci_set_line_numbers(sci, editor_prefs.show_linenumber_margin);
5030
5031 sci_set_folding_margin_visible(sci, editor_prefs.folding);
5032
5033 /* virtual space */
5034 SSM(sci, SCI_SETVIRTUALSPACEOPTIONS, editor_prefs.show_virtual_space, 0);
5035
5036 /* (dis)allow scrolling past end of document */
5037 sci_set_scroll_stop_at_last_line(sci, editor_prefs.scroll_stop_at_last_line);
5038
5039 sci_set_scrollbar_mode(sci, editor_prefs.show_scrollbars);
5040 }
5041
5042
5043 /* This is for tab-indents, space aligns formatted code. Spaces should be preserved. */
5044 static void change_tab_indentation(GeanyEditor *editor, gint line, gboolean increase)
5045 {
5046 ScintillaObject *sci = editor->sci;
5047 gint pos = sci_get_position_from_line(sci, line);
5048
5049 if (increase)
5050 {
5051 sci_insert_text(sci, pos, "\t");
5052 }
5053 else
5054 {
5055 if (sci_get_char_at(sci, pos) == '\t')
5056 {
5057 sci_set_selection(sci, pos, pos + 1);
5058 sci_replace_sel(sci, "");
5059 }
5060 else /* remove spaces only if no tabs */
5061 {
5062 gint width = sci_get_line_indentation(sci, line);
5063
5064 width -= editor_get_indent_prefs(editor)->width;
5065 sci_set_line_indentation(sci, line, width);
5066 }
5067 }
5068 }
5069
5070
5071 static void editor_change_line_indent(GeanyEditor *editor, gint line, gboolean increase)
5072 {
5073 const GeanyIndentPrefs *iprefs = editor_get_indent_prefs(editor);
5074 ScintillaObject *sci = editor->sci;
5075
5076 if (iprefs->type == GEANY_INDENT_TYPE_TABS)
5077 change_tab_indentation(editor, line, increase);
5078 else
5079 {
5080 gint width = sci_get_line_indentation(sci, line);
5081
5082 width += increase ? iprefs->width : -iprefs->width;
5083 sci_set_line_indentation(sci, line, width);
5084 }
5085 }
5086
5087
5088 void editor_indent(GeanyEditor *editor, gboolean increase)
5089 {
5090 ScintillaObject *sci = editor->sci;
5091 gint caret_pos, caret_line, caret_offset, caret_indent_pos, caret_line_len;
5092 gint anchor_pos, anchor_line, anchor_offset, anchor_indent_pos, anchor_line_len;
5093
5094 /* backup information needed to restore caret and anchor */
5095 caret_pos = sci_get_current_position(sci);
5096 anchor_pos = SSM(sci, SCI_GETANCHOR, 0, 0);
5097 caret_line = sci_get_line_from_position(sci, caret_pos);
5098 anchor_line = sci_get_line_from_position(sci, anchor_pos);
5099 caret_offset = caret_pos - sci_get_position_from_line(sci, caret_line);
5100 anchor_offset = anchor_pos - sci_get_position_from_line(sci, anchor_line);
5101 caret_indent_pos = sci_get_line_indent_position(sci, caret_line);
5102 anchor_indent_pos = sci_get_line_indent_position(sci, anchor_line);
5103 caret_line_len = sci_get_line_length(sci, caret_line);
5104 anchor_line_len = sci_get_line_length(sci, anchor_line);
5105
5106 if (sci_get_lines_selected(sci) <= 1)
5107 {
5108 editor_change_line_indent(editor, sci_get_current_line(sci), increase);
5109 }
5110 else
5111 {
5112 gint start, end;
5113 gint line, lstart, lend;
5114
5115 editor_select_lines(editor, FALSE);
5116 start = sci_get_selection_start(sci);
5117 end = sci_get_selection_end(sci);
5118 lstart = sci_get_line_from_position(sci, start);
5119 lend = sci_get_line_from_position(sci, end);
5120 if (end == sci_get_length(sci))
5121 lend++; /* for last line with text on it */
5122
5123 sci_start_undo_action(sci);
5124 for (line = lstart; line < lend; line++)
5125 {
5126 editor_change_line_indent(editor, line, increase);
5127 }
5128 sci_end_undo_action(sci);
5129 }
5130
5131 /* restore caret and anchor position */
5132 if (caret_pos >= caret_indent_pos)
5133 caret_offset += sci_get_line_length(sci, caret_line) - caret_line_len;
5134 if (anchor_pos >= anchor_indent_pos)
5135 anchor_offset += sci_get_line_length(sci, anchor_line) - anchor_line_len;
5136
5137 SSM(sci, SCI_SETCURRENTPOS, sci_get_position_from_line(sci, caret_line) + caret_offset, 0);
5138 SSM(sci, SCI_SETANCHOR, sci_get_position_from_line(sci, anchor_line) + anchor_offset, 0);
5139 }
5140
5141
5142 /** Gets snippet by name.
5143 *
5144 * If @a editor is passed, returns a snippet specific to the document filetype.
5145 * If @a editor is @c NULL, returns a snippet from the default set.
5146 *
5147 * @param editor Editor or @c NULL.
5148 * @param snippet_name Snippet name.
5149 * @return snippet or @c NULL if it was not found. Must not be freed.
5150 */
5151 const gchar *editor_find_snippet(GeanyEditor *editor, const gchar *snippet_name)
5152 {
5153 const gchar *subhash_name = editor ? editor->document->file_type->name : "Default";
5154 GHashTable *subhash = g_hash_table_lookup(snippet_hash, subhash_name);
5155
5156 return subhash ? g_hash_table_lookup(subhash, snippet_name) : NULL;
5157 }
5158
5159
5160 /** Replaces all special sequences in @a snippet and inserts it at @a pos.
5161 * If you insert at the current position, consider calling @c sci_scroll_caret()
5162 * after this function.
5163 * @param editor .
5164 * @param pos .
5165 * @param snippet .
5166 */
5167 void editor_insert_snippet(GeanyEditor *editor, gint pos, const gchar *snippet)
5168 {
5169 GString *pattern;
5170
5171 pattern = g_string_new(snippet);
5172 snippets_make_replacements(editor, pattern);
5173 editor_insert_text_block(editor, pattern->str, pos, -1, -1, TRUE);
5174 g_string_free(pattern, TRUE);
5175 }
A fast and lightweight IDE