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