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