?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update for new Scintilla styles
[geany-mirror.git] / src / highlighting.c
blobc09a2b2a0916fdc7b1f2c549d041c5cbbfd08188
1 /*
2 * highlighting.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
6 * Copyright 2011-2012 Colomban Wendling <ban(at)herbesfolles(dot)org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22
23 /**
24 * @file highlighting.h
25 * Syntax highlighting for the different filetypes, using the Scintilla lexers.
26 */
27
28 #include "geany.h"
29
30 #include <stdlib.h>
31 #include <ctype.h>
32 #include <string.h>
33 #include <glib.h>
34 #include <glib/gprintf.h>
35
36 #include "SciLexer.h"
37 #include "highlighting.h"
38 #include "editor.h"
39 #include "utils.h"
40 #include "filetypes.h"
41 #include "symbols.h"
42 #include "ui_utils.h"
43 #include "utils.h"
44 #include "main.h"
45 #include "support.h"
46 #include "sciwrappers.h"
47 #include "document.h"
48 #include "dialogs.h"
49 #include "filetypesprivate.h"
50
51 #include "highlightingmappings.h"
52
53
54 #define GEANY_COLORSCHEMES_SUBDIR "colorschemes"
55
56 /* Whitespace has to be set after setting wordchars. */
57 #define GEANY_WHITESPACE_CHARS " \t" "!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~"
58
59
60 static gchar *whitespace_chars;
61
62
63 typedef struct
64 {
65 gsize count; /* number of styles */
66 GeanyLexerStyle *styling; /* array of styles, NULL if not used or uninitialised */
67 gchar **keywords;
68 gchar *wordchars; /* NULL used for style sets with no styles */
69 gchar **property_keys;
70 gchar **property_values;
71 } StyleSet;
72
73 /* each filetype has a styleset but GEANY_FILETYPES_NONE uses common_style_set for styling */
74 static StyleSet *style_sets = NULL;
75
76
77 enum /* Geany common styling */
78 {
79 GCS_DEFAULT,
80 GCS_SELECTION,
81 GCS_BRACE_GOOD,
82 GCS_BRACE_BAD,
83 GCS_MARGIN_LINENUMBER,
84 GCS_MARGIN_FOLDING,
85 GCS_FOLD_SYMBOL_HIGHLIGHT,
86 GCS_CURRENT_LINE,
87 GCS_CARET,
88 GCS_INDENT_GUIDE,
89 GCS_WHITE_SPACE,
90 GCS_LINE_WRAP_VISUALS,
91 GCS_LINE_WRAP_INDENT,
92 GCS_TRANSLUCENCY,
93 GCS_MARKER_LINE,
94 GCS_MARKER_SEARCH,
95 GCS_MARKER_MARK,
96 GCS_MARKER_TRANSLUCENCY,
97 GCS_LINE_HEIGHT,
98 GCS_CALLTIPS,
99 GCS_MAX
100 };
101
102 static struct
103 {
104 GeanyLexerStyle styling[GCS_MAX];
105
106 /* icon style, 1-4 */
107 gint fold_marker;
108 /* vertical line style, 0-2 */
109 gint fold_lines;
110 /* horizontal line when folded, 0-2 */
111 gint fold_draw_line;
112
113 gchar *wordchars;
114 } common_style_set;
115
116
117 /* For filetypes.common [named_styles] section.
118 * 0xBBGGRR format.
119 * e.g. "comment" => &GeanyLexerStyle{0x0000d0, 0xffffff, FALSE, FALSE} */
120 static GHashTable *named_style_hash = NULL;
121
122 /* 0xBBGGRR format, set by "default" named style. */
123 static GeanyLexerStyle gsd_default = {0x000000, 0xffffff, FALSE, FALSE};
124
125
126 /* Note: use sciwrappers.h instead where possible.
127 * Do not use SSM in files unrelated to scintilla. */
128 #define SSM(s, m, w, l) scintilla_send_message(s, m, w, l)
129
130 /* filetypes should use the filetypes.foo [lexer_properties] group instead of hardcoding */
131 static void sci_set_property(ScintillaObject *sci, const gchar *name, const gchar *value)
132 {
133 SSM(sci, SCI_SETPROPERTY, (uptr_t) name, (sptr_t) value);
134 }
135
136
137 static void new_styleset(guint file_type_id, gsize styling_count)
138 {
139 StyleSet *set = &style_sets[file_type_id];
140
141 set->count = styling_count;
142 set->styling = g_new0(GeanyLexerStyle, styling_count);
143 }
144
145
146 static void free_styleset(guint file_type_id)
147 {
148 StyleSet *style_ptr;
149 style_ptr = &style_sets[file_type_id];
150
151 style_ptr->count = 0;
152 g_free(style_ptr->styling);
153 style_ptr->styling = NULL;
154 g_strfreev(style_ptr->keywords);
155 style_ptr->keywords = NULL;
156 g_free(style_ptr->wordchars);
157 style_ptr->wordchars = NULL;
158 g_strfreev(style_ptr->property_keys);
159 style_ptr->property_keys = NULL;
160 g_strfreev(style_ptr->property_values);
161 style_ptr->property_values = NULL;
162 }
163
164
165 static void get_keyfile_keywords(GKeyFile *config, GKeyFile *configh,
166 const gchar *key, guint ft_id, guint pos)
167 {
168 style_sets[ft_id].keywords[pos] =
169 utils_get_setting(string, configh, config, "keywords", key, "");
170 }
171
172
173 static void get_keyfile_wordchars(GKeyFile *config, GKeyFile *configh, gchar **wordchars)
174 {
175 *wordchars = utils_get_setting(string, configh, config,
176 "settings", "wordchars", GEANY_WORDCHARS);
177 }
178
179
180 static gboolean read_named_style(const gchar *named_style, GeanyLexerStyle *style)
181 {
182 GeanyLexerStyle *cs;
183 gchar *comma, *name = NULL;
184 const gchar *bold = NULL;
185 const gchar *italic = NULL;
186
187 g_return_val_if_fail(named_style, FALSE);
188 name = utils_strdupa(named_style); /* named_style must not be written to, may be a static string */
189
190 comma = strstr(name, ",");
191 if (comma)
192 {
193 bold = strstr(comma, ",bold");
194 italic = strstr(comma, ",italic");
195 *comma = '\0'; /* terminate name to make lookup work */
196 }
197 cs = g_hash_table_lookup(named_style_hash, name);
198
199 if (cs)
200 {
201 *style = *cs;
202 if (bold)
203 style->bold = !style->bold;
204 if (italic)
205 style->italic = !style->italic;
206 }
207 else
208 {
209 *style = gsd_default;
210 }
211 return (cs != NULL);
212 }
213
214
215 /* Parses a color in `str` which can be an HTML color (ex. #0099cc),
216 * an abbreviated HTML color (ex. #09c) or a hex string color
217 * (ex. 0x0099cc). The result of the conversion is stored into the
218 * location pointed to by `clr`. */
219 static void parse_color(GKeyFile *kf, const gchar *str, gint *clr)
220 {
221 gint c;
222 gchar *named_color = NULL;
223
224 g_return_if_fail(clr != NULL);
225
226 if (G_UNLIKELY(EMPTY(str)))
227 return;
228
229 named_color = g_key_file_get_string(kf, "named_colors", str, NULL);
230 if (named_color)
231 str = named_color;
232
233 c = utils_parse_color_to_bgr(str);
234 if (c == -1)
235 geany_debug("Bad color '%s'", str);
236 else
237 *clr = c;
238
239 g_free(named_color);
240 }
241
242
243 static void parse_keyfile_style(GKeyFile *kf, gchar **list,
244 const GeanyLexerStyle *default_style, GeanyLexerStyle *style)
245 {
246 gsize len;
247
248 g_return_if_fail(default_style);
249 g_return_if_fail(style);
250
251 *style = *default_style;
252
253 if (!list)
254 return;
255
256 len = g_strv_length(list);
257 if (len == 0)
258 return;
259 else if (len == 1)
260 {
261 gchar **items = g_strsplit(list[0], ",", 0);
262 if (items != NULL)
263 {
264 if (g_strv_length(items) > 0)
265 {
266 if (g_hash_table_lookup(named_style_hash, items[0]) != NULL)
267 {
268 if (!read_named_style(list[0], style))
269 geany_debug("Unable to read named style '%s'", items[0]);
270 g_strfreev(items);
271 return;
272 }
273 else if (strchr(list[0], ',') != NULL)
274 {
275 geany_debug("Unknown named style '%s'", items[0]);
276 g_strfreev(items);
277 return;
278 }
279 }
280 g_strfreev(items);
281 }
282 }
283
284 switch (len)
285 {
286 case 4:
287 style->italic = utils_atob(list[3]);
288 case 3:
289 style->bold = utils_atob(list[2]);
290 case 2:
291 parse_color(kf, list[1], &style->background);
292 case 1:
293 parse_color(kf, list[0], &style->foreground);
294 }
295 }
296
297
298 static void get_keyfile_style(GKeyFile *config, GKeyFile *configh,
299 const gchar *key_name, GeanyLexerStyle *style)
300 {
301 gchar **list;
302 gsize len;
303
304 g_return_if_fail(config);
305 g_return_if_fail(configh);
306 g_return_if_fail(key_name);
307 g_return_if_fail(style);
308
309 list = g_key_file_get_string_list(configh, "styling", key_name, &len, NULL);
310 if (list == NULL)
311 {
312 list = g_key_file_get_string_list(config, "styling", key_name, &len, NULL);
313 parse_keyfile_style(config, list, &gsd_default, style);
314 }
315 else
316 parse_keyfile_style(configh, list, &gsd_default, style);
317
318 g_strfreev(list);
319 }
320
321
322 static void convert_int(const gchar *int_str, gint *val)
323 {
324 gchar *end;
325 gint v = strtol(int_str, &end, 10);
326
327 if (int_str != end)
328 *val = v;
329 }
330
331
332 /* Get first and second integer numbers, store in foreground and background fields of @a style. */
333 static void get_keyfile_int(GKeyFile *config, GKeyFile *configh, const gchar *section,
334 const gchar *key, gint fdefault_val, gint sdefault_val,
335 GeanyLexerStyle *style)
336 {
337 gchar **list;
338 gsize len;
339 GeanyLexerStyle def = {fdefault_val, sdefault_val, FALSE, FALSE};
340
341 g_return_if_fail(config);
342 g_return_if_fail(configh);
343 g_return_if_fail(section);
344 g_return_if_fail(key);
345
346 list = g_key_file_get_string_list(configh, section, key, &len, NULL);
347 if (list == NULL)
348 list = g_key_file_get_string_list(config, section, key, &len, NULL);
349
350 *style = def;
351 if (!list)
352 return;
353
354 if (list[0])
355 {
356 convert_int(list[0], &style->foreground);
357 if (list[1])
358 {
359 convert_int(list[1], &style->background);
360 }
361 }
362 g_strfreev(list);
363 }
364
365
366 /* first or second can be NULL. */
367 static void get_keyfile_ints(GKeyFile *config, GKeyFile *configh, const gchar *section,
368 const gchar *key,
369 gint fdefault_val, gint sdefault_val,
370 gint *first, gint *second)
371 {
372 GeanyLexerStyle tmp_style;
373
374 get_keyfile_int(config, configh, section, key, fdefault_val, sdefault_val, &tmp_style);
375 if (first)
376 *first = tmp_style.foreground;
377 if (second)
378 *second = tmp_style.background;
379 }
380
381
382 static guint invert(guint icolour)
383 {
384 if (interface_prefs.highlighting_invert_all)
385 return 0xffffff - icolour;
386
387 return icolour;
388 }
389
390
391 static GeanyLexerStyle *get_style(guint ft_id, guint styling_index)
392 {
393 g_assert(ft_id < filetypes_array->len);
394
395 if (G_UNLIKELY(ft_id == GEANY_FILETYPES_NONE))
396 {
397 g_assert(styling_index < GCS_MAX);
398 return &common_style_set.styling[styling_index];
399 }
400 else
401 {
402 StyleSet *set = &style_sets[ft_id];
403
404 g_assert(styling_index < set->count);
405 return &set->styling[styling_index];
406 }
407 }
408
409
410 static void set_sci_style(ScintillaObject *sci, guint style, guint ft_id, guint styling_index)
411 {
412 GeanyLexerStyle *style_ptr = get_style(ft_id, styling_index);
413
414 SSM(sci, SCI_STYLESETFORE, style, invert(style_ptr->foreground));
415 SSM(sci, SCI_STYLESETBACK, style, invert(style_ptr->background));
416 SSM(sci, SCI_STYLESETBOLD, style, style_ptr->bold);
417 SSM(sci, SCI_STYLESETITALIC, style, style_ptr->italic);
418 }
419
420
421 void highlighting_free_styles(void)
422 {
423 guint i;
424
425 for (i = 0; i < filetypes_array->len; i++)
426 free_styleset(i);
427
428 if (named_style_hash)
429 g_hash_table_destroy(named_style_hash);
430
431 g_free(style_sets);
432 }
433
434
435 static GString *get_global_typenames(gint lang)
436 {
437 GString *s = NULL;
438
439 if (app->tm_workspace)
440 {
441 GPtrArray *tags_array = app->tm_workspace->global_tags;
442
443 if (tags_array)
444 {
445 s = symbols_find_tags_as_string(tags_array, TM_GLOBAL_TYPE_MASK, lang);
446 }
447 }
448 return s;
449 }
450
451
452 static gchar*
453 get_keyfile_whitespace_chars(GKeyFile *config, GKeyFile *configh)
454 {
455 return utils_get_setting(string, configh, config,
456 "settings", "whitespace_chars", GEANY_WHITESPACE_CHARS);
457 }
458
459
460 static void add_named_style(GKeyFile *config, const gchar *key)
461 {
462 const gchar group[] = "named_styles";
463 gchar **list;
464 gsize len;
465
466 list = g_key_file_get_string_list(config, group, key, &len, NULL);
467 /* we allow a named style to reference another style above it */
468 if (list && len >= 1)
469 {
470 GeanyLexerStyle *style = g_new0(GeanyLexerStyle, 1);
471
472 parse_keyfile_style(config, list, &gsd_default, style);
473 g_hash_table_insert(named_style_hash, g_strdup(key), style);
474 }
475 g_strfreev(list);
476 }
477
478
479 static void get_named_styles(GKeyFile *config)
480 {
481 const gchar group[] = "named_styles";
482 gchar **keys = g_key_file_get_keys(config, group, NULL, NULL);
483 gchar **ptr = keys;
484
485 if (!ptr)
486 return;
487
488 while (1)
489 {
490 const gchar *key = *ptr;
491
492 if (!key)
493 break;
494
495 /* don't replace already read default style with system one */
496 if (!g_str_equal(key, "default"))
497 add_named_style(config, key);
498
499 ptr++;
500 }
501 g_strfreev(keys);
502 }
503
504
505 static GKeyFile *utils_key_file_new(const gchar *filename)
506 {
507 GKeyFile *config = g_key_file_new();
508
509 g_key_file_load_from_file(config, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
510 return config;
511 }
512
513
514 static void load_named_styles(GKeyFile *config, GKeyFile *config_home)
515 {
516 const gchar *scheme = editor_prefs.color_scheme;
517 gboolean free_kf = FALSE;
518
519 if (named_style_hash)
520 g_hash_table_destroy(named_style_hash); /* reloading */
521
522 named_style_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
523
524 if (!EMPTY(scheme))
525 {
526 gchar *path, *path_home;
527
528 path = g_build_path(G_DIR_SEPARATOR_S, app->datadir, GEANY_COLORSCHEMES_SUBDIR, scheme, NULL);
529 path_home = g_build_path(G_DIR_SEPARATOR_S, app->configdir, GEANY_COLORSCHEMES_SUBDIR, scheme, NULL);
530
531 if (g_file_test(path, G_FILE_TEST_EXISTS) || g_file_test(path_home, G_FILE_TEST_EXISTS))
532 {
533 config = utils_key_file_new(path);
534 config_home = utils_key_file_new(path_home);
535 free_kf = TRUE;
536 }
537 /* if color scheme is missing, use default */
538 g_free(path);
539 g_free(path_home);
540 }
541 /* first set default to the "default" named style */
542 add_named_style(config, "default");
543 read_named_style("default", &gsd_default); /* in case user overrides but not with both colors */
544 add_named_style(config_home, "default");
545 read_named_style("default", &gsd_default);
546
547 get_named_styles(config);
548 /* home overrides any system named style */
549 get_named_styles(config_home);
550
551 if (free_kf)
552 {
553 g_key_file_free(config);
554 g_key_file_free(config_home);
555 }
556 }
557
558
559 static void styleset_common_init(GKeyFile *config, GKeyFile *config_home)
560 {
561 load_named_styles(config, config_home);
562
563 get_keyfile_style(config, config_home, "default", &common_style_set.styling[GCS_DEFAULT]);
564 get_keyfile_style(config, config_home, "selection", &common_style_set.styling[GCS_SELECTION]);
565 get_keyfile_style(config, config_home, "brace_good", &common_style_set.styling[GCS_BRACE_GOOD]);
566 get_keyfile_style(config, config_home, "brace_bad", &common_style_set.styling[GCS_BRACE_BAD]);
567 get_keyfile_style(config, config_home, "margin_linenumber", &common_style_set.styling[GCS_MARGIN_LINENUMBER]);
568 get_keyfile_style(config, config_home, "margin_folding", &common_style_set.styling[GCS_MARGIN_FOLDING]);
569 get_keyfile_style(config, config_home, "fold_symbol_highlight", &common_style_set.styling[GCS_FOLD_SYMBOL_HIGHLIGHT]);
570 get_keyfile_style(config, config_home, "current_line", &common_style_set.styling[GCS_CURRENT_LINE]);
571 get_keyfile_style(config, config_home, "caret", &common_style_set.styling[GCS_CARET]);
572 get_keyfile_style(config, config_home, "indent_guide", &common_style_set.styling[GCS_INDENT_GUIDE]);
573 get_keyfile_style(config, config_home, "white_space", &common_style_set.styling[GCS_WHITE_SPACE]);
574 get_keyfile_style(config, config_home, "marker_line", &common_style_set.styling[GCS_MARKER_LINE]);
575 get_keyfile_style(config, config_home, "marker_search", &common_style_set.styling[GCS_MARKER_SEARCH]);
576 get_keyfile_style(config, config_home, "marker_mark", &common_style_set.styling[GCS_MARKER_MARK]);
577 get_keyfile_style(config, config_home, "calltips", &common_style_set.styling[GCS_CALLTIPS]);
578
579 get_keyfile_ints(config, config_home, "styling", "folding_style",
580 1, 1, &common_style_set.fold_marker, &common_style_set.fold_lines);
581 get_keyfile_ints(config, config_home, "styling", "folding_horiz_line",
582 2, 0, &common_style_set.fold_draw_line, NULL);
583 get_keyfile_ints(config, config_home, "styling", "caret_width",
584 1, 0, &common_style_set.styling[GCS_CARET].background, NULL); /* caret.foreground used earlier */
585 get_keyfile_int(config, config_home, "styling", "line_wrap_visuals",
586 3, 0, &common_style_set.styling[GCS_LINE_WRAP_VISUALS]);
587 get_keyfile_int(config, config_home, "styling", "line_wrap_indent",
588 0, 0, &common_style_set.styling[GCS_LINE_WRAP_INDENT]);
589 get_keyfile_int(config, config_home, "styling", "translucency",
590 256, 256, &common_style_set.styling[GCS_TRANSLUCENCY]);
591 get_keyfile_int(config, config_home, "styling", "marker_translucency",
592 256, 256, &common_style_set.styling[GCS_MARKER_TRANSLUCENCY]);
593 get_keyfile_int(config, config_home, "styling", "line_height",
594 0, 0, &common_style_set.styling[GCS_LINE_HEIGHT]);
595
596 get_keyfile_wordchars(config, config_home, &common_style_set.wordchars);
597 whitespace_chars = get_keyfile_whitespace_chars(config, config_home);
598 }
599
600
601 static void set_character_classes(ScintillaObject *sci, guint ft_id)
602 {
603 const gchar *word = (ft_id == GEANY_FILETYPES_NONE ?
604 common_style_set.wordchars : style_sets[ft_id].wordchars);
605 gchar *whitespace;
606 guint i, j;
607
608 SSM(sci, SCI_SETWORDCHARS, 0, (sptr_t) word);
609
610 /* setting wordchars resets character classes, so we have to set whitespaces after
611 * wordchars, but we want wordchars to have precenence over whitepace chars */
612 whitespace = g_malloc0(strlen(whitespace_chars) + 1);
613 for (i = 0, j = 0; whitespace_chars[i] != 0; i++)
614 {
615 if (! strchr(word, whitespace_chars[i]))
616 whitespace[j++] = whitespace_chars[i];
617 }
618 whitespace[j] = 0;
619
620 SSM(sci, SCI_SETWHITESPACECHARS, 0, (sptr_t) whitespace);
621
622 g_free(whitespace);
623 }
624
625
626 static void styleset_common(ScintillaObject *sci, guint ft_id)
627 {
628 GeanyLexerStyle *style;
629
630 SSM(sci, SCI_STYLECLEARALL, 0, 0);
631
632 set_character_classes(sci, ft_id);
633
634 /* caret colour, style and width */
635 SSM(sci, SCI_SETCARETFORE, invert(common_style_set.styling[GCS_CARET].foreground), 0);
636 SSM(sci, SCI_SETCARETWIDTH, common_style_set.styling[GCS_CARET].background, 0);
637 if (common_style_set.styling[GCS_CARET].bold)
638 SSM(sci, SCI_SETCARETSTYLE, CARETSTYLE_BLOCK, 0);
639 else
640 SSM(sci, SCI_SETCARETSTYLE, CARETSTYLE_LINE, 0);
641
642 /* line height */
643 SSM(sci, SCI_SETEXTRAASCENT, common_style_set.styling[GCS_LINE_HEIGHT].foreground, 0);
644 SSM(sci, SCI_SETEXTRADESCENT, common_style_set.styling[GCS_LINE_HEIGHT].background, 0);
645
646 /* colourise the current line */
647 SSM(sci, SCI_SETCARETLINEBACK, invert(common_style_set.styling[GCS_CURRENT_LINE].background), 0);
648 /* bold=enable current line */
649 SSM(sci, SCI_SETCARETLINEVISIBLE, common_style_set.styling[GCS_CURRENT_LINE].bold, 0);
650
651 /* Translucency for current line and selection */
652 SSM(sci, SCI_SETCARETLINEBACKALPHA, common_style_set.styling[GCS_TRANSLUCENCY].foreground, 0);
653 SSM(sci, SCI_SETSELALPHA, common_style_set.styling[GCS_TRANSLUCENCY].background, 0);
654
655 /* line wrapping visuals */
656 SSM(sci, SCI_SETWRAPVISUALFLAGS,
657 common_style_set.styling[GCS_LINE_WRAP_VISUALS].foreground, 0);
658 SSM(sci, SCI_SETWRAPVISUALFLAGSLOCATION,
659 common_style_set.styling[GCS_LINE_WRAP_VISUALS].background, 0);
660 SSM(sci, SCI_SETWRAPSTARTINDENT, common_style_set.styling[GCS_LINE_WRAP_INDENT].foreground, 0);
661 SSM(sci, SCI_SETWRAPINDENTMODE, common_style_set.styling[GCS_LINE_WRAP_INDENT].background, 0);
662
663 /* Error indicator */
664 SSM(sci, SCI_INDICSETSTYLE, GEANY_INDICATOR_ERROR, INDIC_SQUIGGLEPIXMAP);
665 SSM(sci, SCI_INDICSETFORE, GEANY_INDICATOR_ERROR, invert(0x0000FF /* red, in BGR */));
666
667 /* Search indicator, used for 'Mark' matches */
668 SSM(sci, SCI_INDICSETSTYLE, GEANY_INDICATOR_SEARCH, INDIC_ROUNDBOX);
669 SSM(sci, SCI_INDICSETFORE, GEANY_INDICATOR_SEARCH,
670 invert(common_style_set.styling[GCS_MARKER_SEARCH].background));
671 SSM(sci, SCI_INDICSETALPHA, GEANY_INDICATOR_SEARCH, 60);
672
673 /* define marker symbols
674 * 0 -> line marker */
675 SSM(sci, SCI_MARKERDEFINE, 0, SC_MARK_SHORTARROW);
676 SSM(sci, SCI_MARKERSETFORE, 0, invert(common_style_set.styling[GCS_MARKER_LINE].foreground));
677 SSM(sci, SCI_MARKERSETBACK, 0, invert(common_style_set.styling[GCS_MARKER_LINE].background));
678 SSM(sci, SCI_MARKERSETALPHA, 0, common_style_set.styling[GCS_MARKER_TRANSLUCENCY].foreground);
679
680 /* 1 -> user marker */
681 SSM(sci, SCI_MARKERDEFINE, 1, SC_MARK_PLUS);
682 SSM(sci, SCI_MARKERSETFORE, 1, invert(common_style_set.styling[GCS_MARKER_MARK].foreground));
683 SSM(sci, SCI_MARKERSETBACK, 1, invert(common_style_set.styling[GCS_MARKER_MARK].background));
684 SSM(sci, SCI_MARKERSETALPHA, 1, common_style_set.styling[GCS_MARKER_TRANSLUCENCY].background);
685
686 /* 2 -> folding marker, other folding settings */
687 SSM(sci, SCI_SETMARGINTYPEN, 2, SC_MARGIN_SYMBOL);
688 SSM(sci, SCI_SETMARGINMASKN, 2, SC_MASK_FOLDERS);
689
690 /* drawing a horizontal line when text if folded */
691 switch (common_style_set.fold_draw_line)
692 {
693 case 1:
694 {
695 SSM(sci, SCI_SETFOLDFLAGS, 4, 0);
696 break;
697 }
698 case 2:
699 {
700 SSM(sci, SCI_SETFOLDFLAGS, 16, 0);
701 break;
702 }
703 default:
704 {
705 SSM(sci, SCI_SETFOLDFLAGS, 0, 0);
706 break;
707 }
708 }
709
710 /* choose the folding style - boxes or circles, I prefer boxes, so it is default ;-) */
711 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_EMPTY);
712 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_EMPTY);
713 switch (common_style_set.fold_marker)
714 {
715 case 2:
716 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_CIRCLEMINUS);
717 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_CIRCLEPLUS);
718 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_CIRCLEPLUSCONNECTED);
719 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_CIRCLEMINUSCONNECTED);
720 break;
721 default:
722 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_BOXMINUS);
723 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_BOXPLUS);
724 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_BOXPLUSCONNECTED);
725 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_BOXMINUSCONNECTED);
726 break;
727 case 3:
728 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_ARROWDOWN);
729 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_ARROW);
730 break;
731 case 4:
732 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_MINUS);
733 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_PLUS);
734 break;
735 }
736
737 /* choose the folding style - straight or curved, I prefer straight, so it is default ;-) */
738 switch (common_style_set.fold_lines)
739 {
740 case 2:
741 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNERCURVE);
742 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNERCURVE);
743 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE);
744 break;
745 default:
746 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNER);
747 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNER);
748 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE);
749 break;
750 case 0:
751 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_EMPTY);
752 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERTAIL, SC_MARK_EMPTY);
753 SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERSUB, SC_MARK_EMPTY);
754 break;
755 }
756 {
757 gint markers[] = {
758 SC_MARKNUM_FOLDEROPEN,
759 SC_MARKNUM_FOLDER,
760 SC_MARKNUM_FOLDERSUB,
761 SC_MARKNUM_FOLDERTAIL,
762 SC_MARKNUM_FOLDEREND,
763 SC_MARKNUM_FOLDEROPENMID,
764 SC_MARKNUM_FOLDERMIDTAIL
765 };
766 guint i;
767
768 foreach_range(i, G_N_ELEMENTS(markers))
769 {
770 SSM(sci, SCI_MARKERSETFORE, markers[i],
771 invert(common_style_set.styling[GCS_FOLD_SYMBOL_HIGHLIGHT].foreground));
772 SSM(sci, SCI_MARKERSETBACK, markers[i],
773 invert(common_style_set.styling[GCS_MARGIN_FOLDING].foreground));
774 }
775 }
776
777 /* set some common defaults */
778 sci_set_property(sci, "fold", "1");
779 sci_set_property(sci, "fold.compact", "0");
780 sci_set_property(sci, "fold.comment", "1");
781 sci_set_property(sci, "fold.preprocessor", "1");
782 sci_set_property(sci, "fold.at.else", "1");
783
784 style = &common_style_set.styling[GCS_SELECTION];
785 if (!style->bold && !style->italic)
786 {
787 geany_debug("selection style is set to invisible - ignoring!");
788 style->italic = TRUE;
789 style->background = 0xc0c0c0;
790 }
791 /* bold (3rd argument) is whether to override default foreground selection */
792 SSM(sci, SCI_SETSELFORE, style->bold, invert(style->foreground));
793 /* italic (4th argument) is whether to override default background selection */
794 SSM(sci, SCI_SETSELBACK, style->italic, invert(style->background));
795
796 SSM(sci, SCI_SETSTYLEBITS, SSM(sci, SCI_GETSTYLEBITSNEEDED, 0, 0), 0);
797
798 SSM(sci, SCI_SETFOLDMARGINCOLOUR, 1, invert(common_style_set.styling[GCS_MARGIN_FOLDING].background));
799 SSM(sci, SCI_SETFOLDMARGINHICOLOUR, 1, invert(common_style_set.styling[GCS_MARGIN_FOLDING].background));
800 set_sci_style(sci, STYLE_LINENUMBER, GEANY_FILETYPES_NONE, GCS_MARGIN_LINENUMBER);
801 set_sci_style(sci, STYLE_BRACELIGHT, GEANY_FILETYPES_NONE, GCS_BRACE_GOOD);
802 set_sci_style(sci, STYLE_BRACEBAD, GEANY_FILETYPES_NONE, GCS_BRACE_BAD);
803 set_sci_style(sci, STYLE_INDENTGUIDE, GEANY_FILETYPES_NONE, GCS_INDENT_GUIDE);
804
805 /* bold = common whitespace settings enabled */
806 SSM(sci, SCI_SETWHITESPACEFORE, common_style_set.styling[GCS_WHITE_SPACE].bold,
807 invert(common_style_set.styling[GCS_WHITE_SPACE].foreground));
808 SSM(sci, SCI_SETWHITESPACEBACK, common_style_set.styling[GCS_WHITE_SPACE].italic,
809 invert(common_style_set.styling[GCS_WHITE_SPACE].background));
810
811 if (common_style_set.styling[GCS_CALLTIPS].bold)
812 SSM(sci, SCI_CALLTIPSETFORE, invert(common_style_set.styling[GCS_CALLTIPS].foreground), 1);
813 if (common_style_set.styling[GCS_CALLTIPS].italic)
814 SSM(sci, SCI_CALLTIPSETBACK, invert(common_style_set.styling[GCS_CALLTIPS].background), 1);
815 }
816
817
818 /* Merge & assign global typedefs and user secondary keywords.
819 * keyword_idx is used for both style_sets[].keywords and scintilla keyword style number */
820 static void merge_type_keywords(ScintillaObject *sci, guint ft_id, guint keyword_idx)
821 {
822 const gchar *user_words = style_sets[ft_id].keywords[keyword_idx];
823 GString *s;
824
825 s = get_global_typenames(filetypes[ft_id]->lang);
826 if (G_UNLIKELY(s == NULL))
827 s = g_string_sized_new(200);
828 else
829 g_string_append_c(s, ' '); /* append a space as delimiter to the existing list of words */
830
831 g_string_append(s, user_words);
832
833 sci_set_keywords(sci, keyword_idx, s->str);
834 g_string_free(s, TRUE);
835 }
836
837
838 static void styleset_init_from_mapping(guint ft_id, GKeyFile *config, GKeyFile *config_home,
839 const HLStyle *styles, gsize n_styles,
840 const HLKeyword *keywords, gsize n_keywords)
841 {
842 gsize i;
843
844 /* styles */
845 new_styleset(ft_id, n_styles);
846 foreach_range(i, n_styles)
847 {
848 GeanyLexerStyle *style = &style_sets[ft_id].styling[i];
849
850 get_keyfile_style(config, config_home, styles[i].name, style);
851 }
852
853 /* keywords */
854 if (n_keywords < 1)
855 style_sets[ft_id].keywords = NULL;
856 else
857 {
858 style_sets[ft_id].keywords = g_new(gchar*, n_keywords + 1);
859 foreach_range(i, n_keywords)
860 get_keyfile_keywords(config, config_home, keywords[i].key, ft_id, i);
861 style_sets[ft_id].keywords[i] = NULL;
862 }
863 }
864
865
866 /* STYLE_DEFAULT will be set to match the first style. */
867 static void styleset_from_mapping(ScintillaObject *sci, guint ft_id, guint lexer,
868 const HLStyle *styles, gsize n_styles,
869 const HLKeyword *keywords, gsize n_keywords,
870 const HLProperty *properties, gsize n_properties)
871 {
872 gsize i;
873
874 g_assert(ft_id != GEANY_FILETYPES_NONE);
875
876 /* lexer */
877 sci_set_lexer(sci, lexer);
878
879 /* styles */
880 styleset_common(sci, ft_id);
881 if (n_styles > 0)
882 {
883 /* first style is also default one */
884 set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
885 foreach_range(i, n_styles)
886 {
887 if (styles[i].fill_eol)
888 SSM(sci, SCI_STYLESETEOLFILLED, styles[i].style, TRUE);
889 set_sci_style(sci, styles[i].style, ft_id, i);
890 }
891 }
892
893 /* keywords */
894 foreach_range(i, n_keywords)
895 {
896 if (keywords[i].merge)
897 merge_type_keywords(sci, ft_id, i);
898 else
899 sci_set_keywords(sci, keywords[i].id, style_sets[ft_id].keywords[i]);
900 }
901
902 /* properties */
903 foreach_range(i, n_properties)
904 sci_set_property(sci, properties[i].property, properties[i].value);
905 }
906
907
908
909 static void styleset_default(ScintillaObject *sci, guint ft_id)
910 {
911 sci_set_lexer(sci, SCLEX_NULL);
912
913 /* we need to set STYLE_DEFAULT before we call SCI_STYLECLEARALL in styleset_common() */
914 set_sci_style(sci, STYLE_DEFAULT, GEANY_FILETYPES_NONE, GCS_DEFAULT);
915
916 styleset_common(sci, ft_id);
917 }
918
919
920 static void get_key_values(GKeyFile *config, const gchar *group, gchar **keys, gchar **values)
921 {
922 while (*keys)
923 {
924 gchar *str = g_key_file_get_string(config, group, *keys, NULL);
925
926 if (str)
927 SETPTR(*values, str);
928
929 keys++;
930 values++;
931 }
932 }
933
934
935 static void read_properties(GeanyFiletype *ft, GKeyFile *config, GKeyFile *configh)
936 {
937 gchar group[] = "lexer_properties";
938 gchar **keys;
939 gchar **keysh = g_key_file_get_keys(configh, group, NULL, NULL);
940 gchar **ptr;
941
942 /* remove overridden keys from system keyfile */
943 foreach_strv(ptr, keysh)
944 g_key_file_remove_key(config, group, *ptr, NULL);
945
946 /* merge sys and user keys */
947 keys = g_key_file_get_keys(config, group, NULL, NULL);
948 keys = utils_strv_join(keys, keysh);
949
950 if (keys)
951 {
952 gchar **values = g_new0(gchar*, g_strv_length(keys) + 1);
953
954 style_sets[ft->id].property_keys = keys;
955 style_sets[ft->id].property_values = values;
956
957 get_key_values(config, group, keys, values);
958 get_key_values(configh, group, keys, values);
959 }
960 }
961
962
963 static guint get_lexer_filetype(GeanyFiletype *ft)
964 {
965 ft = FALLBACK(ft->lexer_filetype, ft);
966 return ft->id;
967 }
968
969
970 #define init_styleset_case(LANG_NAME) \
971 case (GEANY_FILETYPES_##LANG_NAME): \
972 styleset_init_from_mapping(filetype_idx, config, configh, \
973 highlighting_styles_##LANG_NAME, \
974 HL_N_ENTRIES(highlighting_styles_##LANG_NAME), \
975 highlighting_keywords_##LANG_NAME, \
976 HL_N_ENTRIES(highlighting_keywords_##LANG_NAME)); \
977 break
978
979 /* Called by filetypes_load_config(). */
980 void highlighting_init_styles(guint filetype_idx, GKeyFile *config, GKeyFile *configh)
981 {
982 GeanyFiletype *ft = filetypes[filetype_idx];
983 guint lexer_id = get_lexer_filetype(ft);
984 gchar *default_str;
985
986 if (!style_sets)
987 style_sets = g_new0(StyleSet, filetypes_array->len);
988
989 /* Clear old information if necessary - e.g. when reloading config */
990 free_styleset(filetype_idx);
991
992 read_properties(ft, config, configh);
993 /* If a default style exists, check it uses a named style
994 * Note: almost all filetypes have a "default" style, except HTML ones */
995 default_str = utils_get_setting(string, configh, config,
996 "styling", "default", "default");
997 ft->priv->warn_color_scheme = !g_ascii_isalpha(*default_str);
998 g_free(default_str);
999
1000 /* None filetype handled specially */
1001 if (filetype_idx == GEANY_FILETYPES_NONE)
1002 {
1003 styleset_common_init(config, configh);
1004 return;
1005 }
1006 /* All stylesets depend on filetypes.common */
1007 filetypes_load_config(GEANY_FILETYPES_NONE, FALSE);
1008
1009 switch (lexer_id)
1010 {
1011 init_styleset_case(ABAQUS);
1012 init_styleset_case(ADA);
1013 init_styleset_case(ASM);
1014 init_styleset_case(BASIC);
1015 init_styleset_case(BATCH);
1016 init_styleset_case(C);
1017 init_styleset_case(CAML);
1018 init_styleset_case(CMAKE);
1019 init_styleset_case(COBOL);
1020 init_styleset_case(CONF);
1021 init_styleset_case(CSS);
1022 init_styleset_case(D);
1023 init_styleset_case(DIFF);
1024 init_styleset_case(LISP);
1025 init_styleset_case(ERLANG);
1026 init_styleset_case(DOCBOOK);
1027 init_styleset_case(FERITE);
1028 init_styleset_case(F77);
1029 init_styleset_case(FORTH);
1030 init_styleset_case(FORTRAN);
1031 init_styleset_case(HASKELL);
1032 init_styleset_case(HAXE);
1033 init_styleset_case(AS);
1034 init_styleset_case(HTML);
1035 init_styleset_case(JAVA);
1036 init_styleset_case(JS);
1037 init_styleset_case(LATEX);
1038 init_styleset_case(LUA);
1039 init_styleset_case(MAKE);
1040 init_styleset_case(MATLAB);
1041 init_styleset_case(MARKDOWN);
1042 init_styleset_case(NSIS);
1043 init_styleset_case(OBJECTIVEC);
1044 init_styleset_case(PASCAL);
1045 init_styleset_case(PERL);
1046 init_styleset_case(PHP);
1047 init_styleset_case(PO);
1048 init_styleset_case(POWERSHELL);
1049 init_styleset_case(PYTHON);
1050 init_styleset_case(R);
1051 init_styleset_case(RUBY);
1052 init_styleset_case(RUST);
1053 init_styleset_case(SH);
1054 init_styleset_case(SQL);
1055 init_styleset_case(TCL);
1056 init_styleset_case(TXT2TAGS);
1057 init_styleset_case(VHDL);
1058 init_styleset_case(VERILOG);
1059 init_styleset_case(XML);
1060 init_styleset_case(YAML);
1061 default:
1062 if (ft->lexer_filetype)
1063 geany_debug("Filetype %s has a recursive lexer_filetype %s set!",
1064 ft->name, ft->lexer_filetype->name);
1065 }
1066
1067 /* should be done in filetypes.c really: */
1068 get_keyfile_wordchars(config, configh, &style_sets[filetype_idx].wordchars);
1069 }
1070
1071
1072 #define styleset_case(LANG_NAME) \
1073 case (GEANY_FILETYPES_##LANG_NAME): \
1074 styleset_from_mapping(sci, ft->id, highlighting_lexer_##LANG_NAME, \
1075 highlighting_styles_##LANG_NAME, \
1076 HL_N_ENTRIES(highlighting_styles_##LANG_NAME), \
1077 highlighting_keywords_##LANG_NAME, \
1078 HL_N_ENTRIES(highlighting_keywords_##LANG_NAME), \
1079 highlighting_properties_##LANG_NAME, \
1080 HL_N_ENTRIES(highlighting_properties_##LANG_NAME)); \
1081 break
1082
1083 /** Sets up highlighting and other visual settings.
1084 * @param sci Scintilla widget.
1085 * @param ft Filetype settings to use. */
1086 void highlighting_set_styles(ScintillaObject *sci, GeanyFiletype *ft)
1087 {
1088 guint lexer_id = get_lexer_filetype(ft);
1089
1090 filetypes_load_config(ft->id, FALSE); /* load filetypes.ext */
1091
1092 switch (lexer_id)
1093 {
1094 styleset_case(ABAQUS);
1095 styleset_case(ADA);
1096 styleset_case(ASM);
1097 styleset_case(BASIC);
1098 styleset_case(BATCH);
1099 styleset_case(C);
1100 styleset_case(CAML);
1101 styleset_case(CMAKE);
1102 styleset_case(COBOL);
1103 styleset_case(CONF);
1104 styleset_case(CSS);
1105 styleset_case(D);
1106 styleset_case(DIFF);
1107 styleset_case(LISP);
1108 styleset_case(ERLANG);
1109 styleset_case(DOCBOOK);
1110 styleset_case(FERITE);
1111 styleset_case(F77);
1112 styleset_case(FORTH);
1113 styleset_case(FORTRAN);
1114 styleset_case(HASKELL);
1115 styleset_case(HAXE);
1116 styleset_case(AS);
1117 styleset_case(HTML);
1118 styleset_case(JAVA);
1119 styleset_case(JS);
1120 styleset_case(LATEX);
1121 styleset_case(LUA);
1122 styleset_case(MAKE);
1123 styleset_case(MARKDOWN);
1124 styleset_case(MATLAB);
1125 styleset_case(NSIS);
1126 styleset_case(OBJECTIVEC);
1127 styleset_case(PASCAL);
1128 styleset_case(PERL);
1129 styleset_case(PHP);
1130 styleset_case(PO);
1131 styleset_case(POWERSHELL);
1132 styleset_case(PYTHON);
1133 styleset_case(R);
1134 styleset_case(RUBY);
1135 styleset_case(RUST);
1136 styleset_case(SH);
1137 styleset_case(SQL);
1138 styleset_case(TCL);
1139 styleset_case(TXT2TAGS);
1140 styleset_case(VHDL);
1141 styleset_case(VERILOG);
1142 styleset_case(XML);
1143 styleset_case(YAML);
1144 case GEANY_FILETYPES_NONE:
1145 default:
1146 styleset_default(sci, ft->id);
1147 }
1148 /* [lexer_properties] settings */
1149 if (style_sets[ft->id].property_keys)
1150 {
1151 gchar **prop = style_sets[ft->id].property_keys;
1152 gchar **val = style_sets[ft->id].property_values;
1153
1154 while (*prop)
1155 {
1156 sci_set_property(sci, *prop, *val);
1157 prop++;
1158 val++;
1159 }
1160 }
1161 }
1162
1163
1164 /** Retrieves a style @a style_id for the filetype @a ft_id.
1165 * If the style was not already initialised
1166 * (e.g. by by opening a file of this type), it will be initialised. The returned pointer is
1167 * owned by Geany and must not be freed.
1168 * @param ft_id Filetype ID, e.g. @c GEANY_FILETYPES_DIFF.
1169 * @param style_id A Scintilla lexer style, e.g. @c SCE_DIFF_ADDED. See scintilla/include/SciLexer.h.
1170 * @return A pointer to the style struct.
1171 * @see Scintilla messages @c SCI_STYLEGETFORE, etc, for use with scintilla_send_message(). */
1172 const GeanyLexerStyle *highlighting_get_style(gint ft_id, gint style_id)
1173 {
1174 g_return_val_if_fail(ft_id >= 0 && (guint) ft_id < filetypes_array->len, NULL);
1175 g_return_val_if_fail(style_id >= 0, NULL);
1176
1177 /* ensure filetype loaded */
1178 filetypes_load_config((guint) ft_id, FALSE);
1179
1180 /* TODO: style_id might not be the real array index (Scintilla styles are not always synced
1181 * with array indices) */
1182 return get_style((guint) ft_id, (guint) style_id);
1183 }
1184
1185
1186 static GtkWidget *scheme_tree = NULL;
1187
1188 enum
1189 {
1190 SCHEME_MARKUP,
1191 SCHEME_FILE,
1192 SCHEME_COLUMNS
1193 };
1194
1195 static void on_color_scheme_changed(GtkTreeSelection *treesel, gpointer dummy)
1196 {
1197 GtkTreeModel *model;
1198 GtkTreeIter iter;
1199 gchar *fname;
1200 gchar *path;
1201
1202 if (!gtk_tree_selection_get_selected(treesel, &model, &iter))
1203 return;
1204 gtk_tree_model_get(model, &iter, SCHEME_FILE, &fname, -1);
1205
1206 /* check if default item */
1207 if (!fname)
1208 {
1209 SETPTR(editor_prefs.color_scheme, NULL);
1210 filetypes_reload();
1211 return;
1212 }
1213 SETPTR(fname, utils_get_locale_from_utf8(fname));
1214
1215 /* fname is just the basename from the menu item, so prepend the custom files path */
1216 path = g_build_path(G_DIR_SEPARATOR_S, app->configdir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
1217 if (!g_file_test(path, G_FILE_TEST_EXISTS))
1218 {
1219 /* try the system path */
1220 g_free(path);
1221 path = g_build_path(G_DIR_SEPARATOR_S, app->datadir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
1222 }
1223 if (g_file_test(path, G_FILE_TEST_EXISTS))
1224 {
1225 SETPTR(editor_prefs.color_scheme, fname);
1226 fname = NULL;
1227 filetypes_reload();
1228 }
1229 else
1230 {
1231 SETPTR(fname, utils_get_utf8_from_locale(fname));
1232 ui_set_statusbar(TRUE, _("Could not find file '%s'."), fname);
1233 }
1234 g_free(path);
1235 g_free(fname);
1236 }
1237
1238
1239 static gchar *utils_get_setting_locale_string(GKeyFile *keyfile,
1240 const gchar *group, const gchar *key, const gchar *default_value)
1241 {
1242 gchar *result = g_key_file_get_locale_string(keyfile, group, key, NULL, NULL);
1243
1244 return FALLBACK(result, g_strdup(default_value));
1245 }
1246
1247
1248 static void add_color_scheme_item(GtkListStore *store,
1249 gchar *name, gchar *desc, const gchar *fn)
1250 {
1251 GtkTreeIter iter;
1252 gchar *markup;
1253
1254 /* reuse parameters */
1255 name = g_markup_escape_text(name, -1);
1256 desc = g_markup_escape_text(desc, -1);
1257 markup = g_strdup_printf("<big><b>%s</b></big>\n%s", name, desc);
1258 g_free(name);
1259 g_free(desc);
1260
1261 gtk_list_store_append(store, &iter);
1262 gtk_list_store_set(store, &iter, SCHEME_MARKUP, markup,
1263 SCHEME_FILE, fn, -1);
1264 g_free(markup);
1265
1266 if (utils_str_equal(fn, editor_prefs.color_scheme))
1267 {
1268 GtkTreeSelection *treesel =
1269 gtk_tree_view_get_selection(GTK_TREE_VIEW(scheme_tree));
1270
1271 gtk_tree_selection_select_iter(treesel, &iter);
1272 }
1273 }
1274
1275
1276 static void add_color_scheme_file(GtkListStore *store, const gchar *fname)
1277 {
1278 GKeyFile *hkeyfile, *skeyfile;
1279 gchar *path, *theme_name, *theme_desc;
1280 gchar *theme_fn = utils_get_utf8_from_locale(fname);
1281
1282 path = g_build_filename(app->configdir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
1283 hkeyfile = utils_key_file_new(path);
1284 SETPTR(path, g_build_filename(app->datadir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL));
1285 skeyfile = utils_key_file_new(path);
1286
1287 theme_name = utils_get_setting(locale_string, hkeyfile, skeyfile, "theme_info", "name", theme_fn);
1288 theme_desc = utils_get_setting(locale_string, hkeyfile, skeyfile, "theme_info", "description", NULL);
1289 add_color_scheme_item(store, theme_name, theme_desc, theme_fn);
1290
1291 g_free(path);
1292 g_free(theme_fn);
1293 g_free(theme_name);
1294 g_free(theme_desc);
1295 g_key_file_free(hkeyfile);
1296 g_key_file_free(skeyfile);
1297 }
1298
1299
1300 static gboolean add_color_scheme_items(GtkListStore *store)
1301 {
1302 GSList *list, *node;
1303
1304 add_color_scheme_item(store, _("Default"), _("Default"), NULL);
1305 list = utils_get_config_files(GEANY_COLORSCHEMES_SUBDIR);
1306
1307 foreach_slist(node, list)
1308 {
1309 gchar *fname = node->data;
1310
1311 if (g_str_has_suffix(fname, ".conf"))
1312 add_color_scheme_file(store, fname);
1313
1314 g_free(fname);
1315 }
1316 g_slist_free(list);
1317 return list != NULL;
1318 }
1319
1320
1321 static void on_color_scheme_dialog_response(GtkWidget *dialog,
1322 gint response, gpointer *dialog_ptr)
1323 {
1324 *dialog_ptr = NULL;
1325 gtk_widget_destroy(dialog);
1326 }
1327
1328
1329 void highlighting_show_color_scheme_dialog(void)
1330 {
1331 static GtkWidget *dialog = NULL;
1332 GtkListStore *store = gtk_list_store_new(SCHEME_COLUMNS,
1333 G_TYPE_STRING, G_TYPE_STRING);
1334 GtkCellRenderer *text_renderer;
1335 GtkTreeViewColumn *column;
1336 GtkTreeSelection *treesel;
1337 GtkWidget *vbox, *swin, *tree;
1338 GeanyDocument *doc;
1339
1340 doc = document_get_current();
1341 if (doc && doc->file_type->priv->warn_color_scheme)
1342 dialogs_show_msgbox_with_secondary(GTK_MESSAGE_WARNING,
1343 _("The current filetype overrides the default style."),
1344 _("This may cause color schemes to display incorrectly."));
1345
1346 scheme_tree = tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1347 g_object_unref(store);
1348 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
1349 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
1350
1351 text_renderer = gtk_cell_renderer_text_new();
1352 g_object_set(text_renderer, "wrap-mode", PANGO_WRAP_WORD, NULL);
1353 column = gtk_tree_view_column_new_with_attributes(
1354 NULL, text_renderer, "markup", SCHEME_MARKUP, NULL);
1355 gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
1356
1357 add_color_scheme_items(store);
1358
1359 treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
1360 g_signal_connect(treesel, "changed", G_CALLBACK(on_color_scheme_changed), NULL);
1361
1362 /* old dialog may still be showing */
1363 if (dialog)
1364 gtk_widget_destroy(dialog);
1365 dialog = gtk_dialog_new_with_buttons(_("Color Schemes"),
1366 GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT,
1367 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
1368 vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog));
1369 gtk_box_set_spacing(GTK_BOX(vbox), 6);
1370 gtk_widget_set_name(dialog, "GeanyDialog");
1371 gtk_window_set_default_size(GTK_WINDOW(dialog),
1372 GEANY_DEFAULT_DIALOG_HEIGHT * 7/4, GEANY_DEFAULT_DIALOG_HEIGHT);
1373
1374 swin = gtk_scrolled_window_new(NULL, NULL);
1375 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_ETCHED_IN);
1376 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
1377 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1378 gtk_container_add(GTK_CONTAINER(swin), tree);
1379 gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
1380 g_signal_connect(dialog, "response", G_CALLBACK(on_color_scheme_dialog_response), &dialog);
1381 gtk_widget_show_all(dialog);
1382 }
1383
1384
1385 /** Checks whether the given style is a string for the given lexer.
1386 *
1387 * @param lexer Scintilla lexer type (@c SCLEX_*).
1388 * @param style Scintilla style (@c SCE_*).
1389 *
1390 * @return @c TRUE if the style is a string, @c FALSE otherwise.
1391 */
1392 gboolean highlighting_is_string_style(gint lexer, gint style)
1393 {
1394 /* Don't forget STRINGEOL, to prevent completion whilst typing a string with no closing char. */
1395
1396 switch (lexer)
1397 {
1398 case SCLEX_CPP:
1399 return (style == SCE_C_CHARACTER ||
1400 style == SCE_C_STRING ||
1401 style == SCE_C_STRINGEOL ||
1402 style == SCE_C_STRINGRAW ||
1403 style == SCE_C_VERBATIM ||
1404 style == SCE_C_TRIPLEVERBATIM ||
1405 style == SCE_C_HASHQUOTEDSTRING ||
1406 style == SCE_C_ESCAPESEQUENCE);
1407
1408 case SCLEX_PASCAL:
1409 return (style == SCE_PAS_CHARACTER ||
1410 style == SCE_PAS_STRING ||
1411 style == SCE_PAS_STRINGEOL);
1412
1413 case SCLEX_D:
1414 return (style == SCE_D_STRING ||
1415 style == SCE_D_STRINGEOL ||
1416 style == SCE_D_CHARACTER ||
1417 style == SCE_D_STRINGB ||
1418 style == SCE_D_STRINGR);
1419
1420 case SCLEX_PYTHON:
1421 return (style == SCE_P_STRING ||
1422 style == SCE_P_TRIPLE ||
1423 style == SCE_P_TRIPLEDOUBLE ||
1424 style == SCE_P_CHARACTER ||
1425 style == SCE_P_STRINGEOL);
1426
1427 case SCLEX_F77:
1428 case SCLEX_FORTRAN:
1429 return (style == SCE_F_STRING1 ||
1430 style == SCE_F_STRING2 ||
1431 style == SCE_F_STRINGEOL);
1432
1433 case SCLEX_PERL:
1434 return (style == SCE_PL_STRING ||
1435 style == SCE_PL_CHARACTER ||
1436 style == SCE_PL_HERE_DELIM ||
1437 style == SCE_PL_HERE_Q ||
1438 style == SCE_PL_HERE_QQ ||
1439 style == SCE_PL_HERE_QX ||
1440 style == SCE_PL_POD ||
1441 style == SCE_PL_STRING_Q ||
1442 style == SCE_PL_STRING_QQ ||
1443 style == SCE_PL_STRING_QX ||
1444 style == SCE_PL_STRING_QR ||
1445 style == SCE_PL_STRING_QW ||
1446 style == SCE_PL_POD_VERB ||
1447 style == SCE_PL_XLAT
1448 /* we don't include any STRING_*_VAR for autocompletion */);
1449
1450 case SCLEX_PO:
1451 return (style == SCE_PO_MSGCTXT_TEXT ||
1452 style == SCE_PO_MSGCTXT_TEXT_EOL ||
1453 style == SCE_PO_MSGID_TEXT ||
1454 style == SCE_PO_MSGID_TEXT_EOL ||
1455 style == SCE_PO_MSGSTR_TEXT ||
1456 style == SCE_PO_MSGSTR_TEXT_EOL);
1457
1458 case SCLEX_R:
1459 return (style == SCE_R_STRING);
1460
1461 case SCLEX_RUBY:
1462 return (style == SCE_RB_CHARACTER ||
1463 style == SCE_RB_STRING ||
1464 style == SCE_RB_HERE_DELIM ||
1465 style == SCE_RB_HERE_Q ||
1466 style == SCE_RB_HERE_QQ ||
1467 style == SCE_RB_HERE_QX ||
1468 style == SCE_RB_POD);
1469
1470 case SCLEX_BASH:
1471 return (style == SCE_SH_STRING);
1472
1473 case SCLEX_SQL:
1474 return (style == SCE_SQL_STRING);
1475
1476 case SCLEX_TCL:
1477 return (style == SCE_TCL_IN_QUOTE);
1478
1479 case SCLEX_LUA:
1480 return (style == SCE_LUA_LITERALSTRING ||
1481 style == SCE_LUA_CHARACTER ||
1482 style == SCE_LUA_STRINGEOL ||
1483 style == SCE_LUA_STRING);
1484
1485 case SCLEX_HASKELL:
1486 case SCLEX_LITERATEHASKELL:
1487 return (style == SCE_HA_CHARACTER ||
1488 style == SCE_HA_STRINGEOL ||
1489 style == SCE_HA_STRING);
1490
1491 case SCLEX_FREEBASIC:
1492 return (style == SCE_B_STRING ||
1493 style == SCE_B_STRINGEOL);
1494
1495 case SCLEX_OCTAVE:
1496 return (style == SCE_MATLAB_STRING ||
1497 style == SCE_MATLAB_DOUBLEQUOTESTRING);
1498
1499 case SCLEX_XML:
1500 case SCLEX_HTML:
1501 return (
1502 style == SCE_HBA_STRING ||
1503 style == SCE_HBA_STRINGEOL ||
1504 style == SCE_HB_STRING ||
1505 style == SCE_HB_STRINGEOL ||
1506 style == SCE_H_CDATA ||
1507 style == SCE_H_DOUBLESTRING ||
1508 style == SCE_HJA_DOUBLESTRING ||
1509 style == SCE_HJA_SINGLESTRING ||
1510 style == SCE_HJA_STRINGEOL ||
1511 style == SCE_HJ_DOUBLESTRING ||
1512 style == SCE_HJ_SINGLESTRING ||
1513 style == SCE_HJ_STRINGEOL ||
1514 style == SCE_HPA_CHARACTER ||
1515 style == SCE_HPA_STRING ||
1516 style == SCE_HPA_TRIPLE ||
1517 style == SCE_HPA_TRIPLEDOUBLE ||
1518 style == SCE_HP_CHARACTER ||
1519 style == SCE_HPHP_HSTRING || /* HSTRING is a heredoc */
1520 style == SCE_HPHP_HSTRING_VARIABLE ||
1521 style == SCE_HPHP_SIMPLESTRING ||
1522 style == SCE_HP_STRING ||
1523 style == SCE_HP_TRIPLE ||
1524 style == SCE_HP_TRIPLEDOUBLE ||
1525 style == SCE_H_SGML_DOUBLESTRING ||
1526 style == SCE_H_SGML_SIMPLESTRING ||
1527 style == SCE_H_SINGLESTRING);
1528
1529 case SCLEX_CMAKE:
1530 return (style == SCE_CMAKE_STRINGDQ ||
1531 style == SCE_CMAKE_STRINGLQ ||
1532 style == SCE_CMAKE_STRINGRQ ||
1533 style == SCE_CMAKE_STRINGVAR);
1534
1535 case SCLEX_NSIS:
1536 return (style == SCE_NSIS_STRINGDQ ||
1537 style == SCE_NSIS_STRINGLQ ||
1538 style == SCE_NSIS_STRINGRQ ||
1539 style == SCE_NSIS_STRINGVAR);
1540
1541 case SCLEX_ADA:
1542 return (style == SCE_ADA_CHARACTER ||
1543 style == SCE_ADA_STRING ||
1544 style == SCE_ADA_CHARACTEREOL ||
1545 style == SCE_ADA_STRINGEOL);
1546
1547 case SCLEX_ABAQUS:
1548 return (style == SCE_ABAQUS_STRING);
1549
1550 case SCLEX_RUST:
1551 return (style == SCE_RUST_CHARACTER ||
1552 style == SCE_RUST_STRING ||
1553 style == SCE_RUST_STRINGR ||
1554 style == SCE_RUST_LEXERROR);
1555 }
1556 return FALSE;
1557 }
1558
1559
1560 /** Checks whether the given style is a comment for the given lexer.
1561 *
1562 * @param lexer Scintilla lexer type (@c SCLEX_*).
1563 * @param style Scintilla style (@c SCE_*).
1564 *
1565 * @return @c TRUE if the style is a comment, @c FALSE otherwise.
1566 */
1567 gboolean highlighting_is_comment_style(gint lexer, gint style)
1568 {
1569 switch (lexer)
1570 {
1571 case SCLEX_COBOL:
1572 case SCLEX_CPP:
1573 return (style == SCE_C_COMMENT ||
1574 style == SCE_C_COMMENTLINE ||
1575 style == SCE_C_COMMENTDOC ||
1576 style == SCE_C_PREPROCESSORCOMMENT ||
1577 style == SCE_C_PREPROCESSORCOMMENTDOC ||
1578 style == SCE_C_COMMENTLINEDOC ||
1579 style == SCE_C_COMMENTDOCKEYWORD ||
1580 style == SCE_C_COMMENTDOCKEYWORDERROR ||
1581 style == SCE_C_TASKMARKER);
1582
1583 case SCLEX_PASCAL:
1584 return (style == SCE_PAS_COMMENT ||
1585 style == SCE_PAS_COMMENT2 ||
1586 style == SCE_PAS_COMMENTLINE);
1587
1588 case SCLEX_D:
1589 return (style == SCE_D_COMMENT ||
1590 style == SCE_D_COMMENTLINE ||
1591 style == SCE_D_COMMENTDOC ||
1592 style == SCE_D_COMMENTNESTED ||
1593 style == SCE_D_COMMENTLINEDOC ||
1594 style == SCE_D_COMMENTDOCKEYWORD ||
1595 style == SCE_D_COMMENTDOCKEYWORDERROR);
1596
1597 case SCLEX_PYTHON:
1598 return (style == SCE_P_COMMENTLINE ||
1599 style == SCE_P_COMMENTBLOCK);
1600
1601 case SCLEX_F77:
1602 case SCLEX_FORTRAN:
1603 return (style == SCE_F_COMMENT);
1604
1605 case SCLEX_PERL:
1606 return (style == SCE_PL_COMMENTLINE);
1607
1608 case SCLEX_PROPERTIES:
1609 return (style == SCE_PROPS_COMMENT);
1610
1611 case SCLEX_PO:
1612 return (style == SCE_PO_COMMENT ||
1613 style == SCE_PO_PROGRAMMER_COMMENT);
1614
1615 case SCLEX_LATEX:
1616 return (style == SCE_L_COMMENT ||
1617 style == SCE_L_COMMENT2);
1618
1619 case SCLEX_MAKEFILE:
1620 return (style == SCE_MAKE_COMMENT);
1621
1622 case SCLEX_RUBY:
1623 return (style == SCE_RB_COMMENTLINE);
1624
1625 case SCLEX_BASH:
1626 return (style == SCE_SH_COMMENTLINE);
1627
1628 case SCLEX_R:
1629 return (style == SCE_R_COMMENT);
1630
1631 case SCLEX_SQL:
1632 return (style == SCE_SQL_COMMENT ||
1633 style == SCE_SQL_COMMENTLINE ||
1634 style == SCE_SQL_COMMENTDOC ||
1635 style == SCE_SQL_COMMENTLINEDOC ||
1636 style == SCE_SQL_COMMENTDOCKEYWORD ||
1637 style == SCE_SQL_COMMENTDOCKEYWORDERROR);
1638
1639 case SCLEX_TCL:
1640 return (style == SCE_TCL_COMMENT ||
1641 style == SCE_TCL_COMMENTLINE ||
1642 style == SCE_TCL_COMMENT_BOX ||
1643 style == SCE_TCL_BLOCK_COMMENT);
1644
1645 case SCLEX_OCTAVE:
1646 return (style == SCE_MATLAB_COMMENT);
1647
1648 case SCLEX_LUA:
1649 return (style == SCE_LUA_COMMENT ||
1650 style == SCE_LUA_COMMENTLINE ||
1651 style == SCE_LUA_COMMENTDOC);
1652
1653 case SCLEX_HASKELL:
1654 case SCLEX_LITERATEHASKELL:
1655 return (style == SCE_HA_COMMENTLINE ||
1656 style == SCE_HA_COMMENTBLOCK ||
1657 style == SCE_HA_COMMENTBLOCK2 ||
1658 style == SCE_HA_COMMENTBLOCK3 ||
1659 style == SCE_HA_LITERATE_COMMENT ||
1660 style == SCE_HA_LITERATE_CODEDELIM);
1661
1662 case SCLEX_FREEBASIC:
1663 return (style == SCE_B_COMMENT ||
1664 style == SCE_B_COMMENTBLOCK ||
1665 style == SCE_B_DOCLINE ||
1666 style == SCE_B_DOCBLOCK ||
1667 style == SCE_B_DOCKEYWORD);
1668
1669 case SCLEX_YAML:
1670 return (style == SCE_YAML_COMMENT);
1671
1672 case SCLEX_XML:
1673 case SCLEX_HTML:
1674 return (
1675 style == SCE_HBA_COMMENTLINE ||
1676 style == SCE_HB_COMMENTLINE ||
1677 style == SCE_H_COMMENT ||
1678 style == SCE_HJA_COMMENT ||
1679 style == SCE_HJA_COMMENTDOC ||
1680 style == SCE_HJA_COMMENTLINE ||
1681 style == SCE_HJ_COMMENT ||
1682 style == SCE_HJ_COMMENTDOC ||
1683 style == SCE_HJ_COMMENTLINE ||
1684 style == SCE_HPA_COMMENTLINE ||
1685 style == SCE_HP_COMMENTLINE ||
1686 style == SCE_HPHP_COMMENT ||
1687 style == SCE_HPHP_COMMENTLINE ||
1688 style == SCE_H_SGML_COMMENT);
1689
1690 case SCLEX_CMAKE:
1691 return (style == SCE_CMAKE_COMMENT);
1692
1693 case SCLEX_NSIS:
1694 return (style == SCE_NSIS_COMMENT ||
1695 style == SCE_NSIS_COMMENTBOX);
1696
1697 case SCLEX_ADA:
1698 return (style == SCE_ADA_COMMENTLINE ||
1699 style == SCE_NSIS_COMMENTBOX);
1700
1701 case SCLEX_ABAQUS:
1702 return (style == SCE_ABAQUS_COMMENT ||
1703 style == SCE_ABAQUS_COMMENTBLOCK);
1704
1705 case SCLEX_ASM:
1706 return (style == SCE_ASM_COMMENT ||
1707 style == SCE_ASM_COMMENTBLOCK ||
1708 style == SCE_ASM_COMMENTDIRECTIVE);
1709
1710 case SCLEX_RUST:
1711 return (style == SCE_RUST_COMMENTBLOCK ||
1712 style == SCE_RUST_COMMENTLINE ||
1713 style == SCE_RUST_COMMENTBLOCKDOC ||
1714 style == SCE_RUST_COMMENTLINEDOC);
1715 }
1716 return FALSE;
1717 }
1718
1719
1720 /** Checks whether the given style is normal code (not string, comment, preprocessor, etc).
1721 *
1722 * @param lexer Scintilla lexer type (@c SCLEX_*).
1723 * @param style Scintilla style (@c SCE_*).
1724 *
1725 * @return @c TRUE if the style is code, @c FALSE otherwise.
1726 */
1727 gboolean highlighting_is_code_style(gint lexer, gint style)
1728 {
1729 switch (lexer)
1730 {
1731 case SCLEX_CPP:
1732 {
1733 if (style == SCE_C_PREPROCESSOR)
1734 return FALSE;
1735 break;
1736 }
1737 case SCLEX_HASKELL:
1738 case SCLEX_LITERATEHASKELL:
1739 {
1740 if (style == SCE_HA_PREPROCESSOR)
1741 return FALSE;
1742 break;
1743 }
1744 }
1745 return !(highlighting_is_comment_style(lexer, style) ||
1746 highlighting_is_string_style(lexer, style));
1747 }
A fast and lightweight IDE