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