src/highlighting.c

   1 /*
   2  *      highlighting.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  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License
  18  *      along with this program; if not, write to the Free Software
  19  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * @file highlighting.h
  24  * Syntax highlighting for the different filetypes, using the Scintilla lexers.
  25  */
  26
  27 #include "geany.h"
  28
  29 #include <stdlib.h>
  30 #include <ctype.h>
  31 #include <string.h>
  32
  33 #include "SciLexer.h"
  34 #include "highlighting.h"
  35 #include "editor.h"
  36 #include "utils.h"
  37 #include "filetypes.h"
  38 #include "symbols.h"
  39 #include "ui_utils.h"
  40 #include "utils.h"
  41 #include "main.h"
  42 #include "support.h"
  43 #include "sciwrappers.h"
  44
  45
  46 #define GEANY_COLORSCHEMES_SUBDIR "colorschemes"
  47
  48 /* Whitespace has to be set after setting wordchars. */
  49 #define GEANY_WHITESPACE_CHARS " \t" "!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~"
  50
  51
  52 static gchar *whitespace_chars;
  53
  54
  55 static void styleset_markup(ScintillaObject *sci, gboolean set_keywords);
  56
  57
  58 typedef struct
  59 {
  60         gsize                   count;          /* number of styles */
  61         GeanyLexerStyle *styling;               /* array of styles, NULL if not used or uninitialised */
  62         gchar                   **keywords;
  63         gchar                   *wordchars;     /* NULL used for style sets with no styles */
  64         gchar                   **property_keys;
  65         gchar                   **property_values;
  66 } StyleSet;
  67
  68 /* each filetype has a styleset but GEANY_FILETYPES_NONE uses common_style_set for styling */
  69 static StyleSet *style_sets = NULL;
  70
  71
  72 enum    /* Geany common styling */
  73 {
  74         GCS_DEFAULT,
  75         GCS_SELECTION,
  76         GCS_BRACE_GOOD,
  77         GCS_BRACE_BAD,
  78         GCS_MARGIN_LINENUMBER,
  79         GCS_MARGIN_FOLDING,
  80         GCS_FOLD_SYMBOL_HIGHLIGHT,
  81         GCS_CURRENT_LINE,
  82         GCS_CARET,
  83         GCS_INDENT_GUIDE,
  84         GCS_WHITE_SPACE,
  85         GCS_LINE_WRAP_VISUALS,
  86         GCS_LINE_WRAP_INDENT,
  87         GCS_TRANSLUCENCY,
  88         GCS_MARKER_LINE,
  89         GCS_MARKER_SEARCH,
  90         GCS_MARKER_MARK,
  91         GCS_MARKER_TRANSLUCENCY,
  92         GCS_LINE_HEIGHT,
  93         GCS_CALLTIPS,
  94         GCS_MAX
  95 };
  96
  97 static struct
  98 {
  99         GeanyLexerStyle  styling[GCS_MAX];
 100
 101         /* icon style, 1-4 */
 102         gint fold_marker;
 103         /* vertical line style, 0-2 */
 104         gint fold_lines;
 105         /* horizontal line when folded, 0-2 */
 106         gint fold_draw_line;
 107
 108         gchar                   *wordchars;
 109 } common_style_set;
 110
 111
 112 /* For filetypes.common [named_styles] section.
 113  * 0xBBGGRR format.
 114  * e.g. "comment" => &GeanyLexerStyle{0x0000d0, 0xffffff, FALSE, FALSE} */
 115 static GHashTable *named_style_hash = NULL;
 116
 117 /* 0xBBGGRR format, set by "default" named style. */
 118 static GeanyLexerStyle gsd_default = {0x000000, 0xffffff, FALSE, FALSE};
 119
 120
 121 /* Note: use sciwrappers.h instead where possible.
 122  * Do not use SSM in files unrelated to scintilla. */
 123 #define SSM(s, m, w, l) scintilla_send_message(s, m, w, l)
 124
 125 /* filetypes should use the filetypes.foo [lexer_properties] group instead of hardcoding */
 126 static void sci_set_property(ScintillaObject *sci, const gchar *name, const gchar *value)
 127 {
 128         SSM(sci, SCI_SETPROPERTY, (uptr_t) name, (sptr_t) value);
 129 }
 130
 131
 132 static void new_styleset(gint file_type_id, gint styling_count)
 133 {
 134         StyleSet *set = &style_sets[file_type_id];
 135
 136         set->count = styling_count;
 137         set->styling = g_new0(GeanyLexerStyle, styling_count);
 138 }
 139
 140
 141 static void free_styleset(gint file_type_id)
 142 {
 143         StyleSet *style_ptr;
 144         style_ptr = &style_sets[file_type_id];
 145
 146         style_ptr->count = 0;
 147         g_free(style_ptr->styling);
 148         style_ptr->styling = NULL;
 149         g_strfreev(style_ptr->keywords);
 150         style_ptr->keywords = NULL;
 151         g_free(style_ptr->wordchars);
 152         style_ptr->wordchars = NULL;
 153         g_strfreev(style_ptr->property_keys);
 154         style_ptr->property_keys = NULL;
 155         g_strfreev(style_ptr->property_values);
 156         style_ptr->property_values = NULL;
 157 }
 158
 159
 160 static void get_keyfile_keywords(GKeyFile *config, GKeyFile *configh,
 161                                 const gchar *key, gint ft_id, gint pos)
 162 {
 163         style_sets[ft_id].keywords[pos] =
 164                 utils_get_setting(string, configh, config, "keywords", key, "");
 165 }
 166
 167
 168 static void get_keyfile_wordchars(GKeyFile *config, GKeyFile *configh, gchar **wordchars)
 169 {
 170         *wordchars = utils_get_setting(string, configh, config,
 171                 "settings", "wordchars", GEANY_WORDCHARS);
 172 }
 173
 174
 175 static gboolean read_named_style(const gchar *named_style, GeanyLexerStyle *style)
 176 {
 177         GeanyLexerStyle *cs;
 178         gchar *comma, *name = NULL;
 179         const gchar *bold = NULL;
 180         const gchar *italic = NULL;
 181
 182         g_return_val_if_fail(named_style, FALSE);
 183         name = utils_strdupa(named_style);      /* named_style must not be written to, may be a static string */
 184
 185         comma = strstr(name, ",");
 186         if (comma)
 187         {
 188                 bold = strstr(comma, ",bold");
 189                 italic = strstr(comma, ",italic");
 190                 *comma = '\0';  /* terminate name to make lookup work */
 191         }
 192         cs = g_hash_table_lookup(named_style_hash, name);
 193
 194         if (cs)
 195         {
 196                 *style = *cs;
 197                 if (bold)
 198                         style->bold = !style->bold;
 199                 if (italic)
 200                         style->italic = !style->italic;
 201         }
 202         else
 203         {
 204                 *style = gsd_default;
 205         }
 206         return (cs != NULL);
 207 }
 208
 209
 210 static void parse_color(const gchar *str, gint *clr)
 211 {
 212         gint c;
 213
 214         /* ignore empty strings */
 215         if (G_UNLIKELY(! NZV(str)))
 216                 return;
 217
 218         c = utils_strtod(str, NULL, FALSE);
 219         if (c > -1)
 220         {
 221                 *clr = c;
 222                 return;
 223         }
 224         geany_debug("Bad color '%s'", str);
 225 }
 226
 227
 228 static void parse_keyfile_style(gchar **list,
 229                 const GeanyLexerStyle *default_style, GeanyLexerStyle *style)
 230 {
 231         gsize len;
 232         gchar *str;
 233
 234         g_return_if_fail(default_style);
 235         g_return_if_fail(style);
 236
 237         *style = *default_style;
 238
 239         if (!list)
 240                 return;
 241
 242         len = g_strv_length(list);
 243
 244         str = list[0];
 245         if (len == 1 && isalpha(str[0]))
 246         {
 247                 if (!read_named_style(str, style))
 248                         geany_debug(
 249                                 "No named style '%s'! Check filetype styles or %s color scheme.",
 250                                 str, NVL(editor_prefs.color_scheme, "filetypes.common"));
 251         }
 252         else
 253         {
 254                 switch (len)
 255                 {
 256                         case 4:
 257                                 style->italic = utils_atob(list[3]);
 258                         case 3:
 259                                 style->bold = utils_atob(list[2]);
 260                         case 2:
 261                                 parse_color(list[1], &style->background);
 262                         case 1:
 263                                 parse_color(list[0], &style->foreground);
 264                 }
 265         }
 266 }
 267
 268
 269 static void get_keyfile_style(GKeyFile *config, GKeyFile *configh,
 270                 const gchar *key_name, GeanyLexerStyle *style)
 271 {
 272         gchar **list;
 273         gsize len;
 274
 275         g_return_if_fail(config);
 276         g_return_if_fail(configh);
 277         g_return_if_fail(key_name);
 278         g_return_if_fail(style);
 279
 280         list = g_key_file_get_string_list(configh, "styling", key_name, &len, NULL);
 281         if (list == NULL)
 282                 list = g_key_file_get_string_list(config, "styling", key_name, &len, NULL);
 283
 284         parse_keyfile_style(list, &gsd_default, style);
 285         g_strfreev(list);
 286 }
 287
 288
 289 /* Convert 0xRRGGBB to 0xBBGGRR, which scintilla expects. */
 290 static gint rotate_rgb(gint color)
 291 {
 292         return ((color & 0xFF0000) >> 16) +
 293                 (color & 0x00FF00) +
 294                 ((color & 0x0000FF) << 16);
 295 }
 296
 297
 298 static void convert_int(const gchar *int_str, gint *val)
 299 {
 300         gchar *end;
 301         gint v = strtol(int_str, &end, 10);
 302
 303         if (int_str != end)
 304                 *val = v;
 305 }
 306
 307
 308 /* Get first and second integer numbers, store in foreground and background fields of @a style. */
 309 static void get_keyfile_int(GKeyFile *config, GKeyFile *configh, const gchar *section,
 310                                                         const gchar *key, gint fdefault_val, gint sdefault_val,
 311                                                         GeanyLexerStyle *style)
 312 {
 313         gchar **list;
 314         gsize len;
 315         GeanyLexerStyle def = {fdefault_val, sdefault_val, FALSE, FALSE};
 316
 317         g_return_if_fail(config);
 318         g_return_if_fail(configh);
 319         g_return_if_fail(section);
 320         g_return_if_fail(key);
 321
 322         list = g_key_file_get_string_list(configh, section, key, &len, NULL);
 323         if (list == NULL)
 324                 list = g_key_file_get_string_list(config, section, key, &len, NULL);
 325
 326         *style = def;
 327         if (!list)
 328                 return;
 329
 330         if (list[0])
 331         {
 332                 convert_int(list[0], &style->foreground);
 333                 if (list[1])
 334                 {
 335                         convert_int(list[1], &style->background);
 336                 }
 337         }
 338         g_strfreev(list);
 339 }
 340
 341
 342 /* first or second can be NULL. */
 343 static void get_keyfile_ints(GKeyFile *config, GKeyFile *configh, const gchar *section,
 344                                                         const gchar *key,
 345                                                         gint fdefault_val, gint sdefault_val,
 346                                                         gint *first, gint *second)
 347 {
 348         GeanyLexerStyle tmp_style;
 349
 350         get_keyfile_int(config, configh, section, key, fdefault_val, sdefault_val, &tmp_style);
 351         if (first)
 352                 *first = tmp_style.foreground;
 353         if (second)
 354                 *second = tmp_style.background;
 355 }
 356
 357
 358 static guint invert(guint icolour)
 359 {
 360         if (interface_prefs.highlighting_invert_all)
 361                 return utils_invert_color(icolour);
 362
 363         return icolour;
 364 }
 365
 366
 367 static GeanyLexerStyle *get_style(guint ft_id, guint styling_index)
 368 {
 369         g_assert(ft_id < filetypes_array->len);
 370
 371         if (G_UNLIKELY(ft_id == GEANY_FILETYPES_NONE))
 372         {
 373                 g_assert(styling_index < GCS_MAX);
 374                 return &common_style_set.styling[styling_index];
 375         }
 376         else
 377         {
 378                 StyleSet *set = &style_sets[ft_id];
 379
 380                 g_assert(styling_index < set->count);
 381                 return &set->styling[styling_index];
 382         }
 383 }
 384
 385
 386 static void set_sci_style(ScintillaObject *sci, gint style, guint ft_id, guint styling_index)
 387 {
 388         GeanyLexerStyle *style_ptr = get_style(ft_id, styling_index);
 389
 390         SSM(sci, SCI_STYLESETFORE, style,       invert(style_ptr->foreground));
 391         SSM(sci, SCI_STYLESETBACK, style,       invert(style_ptr->background));
 392         SSM(sci, SCI_STYLESETBOLD, style,       style_ptr->bold);
 393         SSM(sci, SCI_STYLESETITALIC, style,     style_ptr->italic);
 394 }
 395
 396
 397 void highlighting_free_styles()
 398 {
 399         guint i;
 400
 401         for (i = 0; i < filetypes_array->len; i++)
 402                 free_styleset(i);
 403
 404         if (named_style_hash)
 405                 g_hash_table_destroy(named_style_hash);
 406
 407         g_free(style_sets);
 408 }
 409
 410
 411 static GString *get_global_typenames(gint lang)
 412 {
 413         GString *s = NULL;
 414
 415         if (app->tm_workspace)
 416         {
 417                 GPtrArray *tags_array = app->tm_workspace->global_tags;
 418
 419                 if (tags_array)
 420                 {
 421                         s = symbols_find_tags_as_string(tags_array, TM_GLOBAL_TYPE_MASK, lang);
 422                 }
 423         }
 424         return s;
 425 }
 426
 427
 428 static gchar*
 429 get_keyfile_whitespace_chars(GKeyFile *config, GKeyFile *configh)
 430 {
 431         return utils_get_setting(string, configh, config,
 432                 "settings", "whitespace_chars", GEANY_WHITESPACE_CHARS);
 433 }
 434
 435
 436 static void add_named_style(GKeyFile *config, const gchar *key)
 437 {
 438         const gchar group[] = "named_styles";
 439         gchar **list;
 440         gsize len;
 441
 442         list = g_key_file_get_string_list(config, group, key, &len, NULL);
 443         /* we allow a named style to reference another style above it */
 444         if (list && len >= 1)
 445         {
 446                 GeanyLexerStyle *style = g_new0(GeanyLexerStyle, 1);
 447
 448                 parse_keyfile_style(list, &gsd_default, style);
 449                 g_hash_table_insert(named_style_hash, g_strdup(key), style);
 450         }
 451         g_strfreev(list);
 452 }
 453
 454
 455 static void get_named_styles(GKeyFile *config)
 456 {
 457         const gchar group[] = "named_styles";
 458         gchar **keys = g_key_file_get_keys(config, group, NULL, NULL);
 459         gchar **ptr = keys;
 460
 461         if (!ptr)
 462                 return;
 463
 464         while (1)
 465         {
 466                 const gchar *key = *ptr;
 467
 468                 if (!key)
 469                         break;
 470
 471                 /* don't replace already read default style with system one */
 472                 if (!g_str_equal(key, "default"))
 473                         add_named_style(config, key);
 474
 475                 ptr++;
 476         }
 477         g_strfreev(keys);
 478 }
 479
 480
 481 static GKeyFile *utils_key_file_new(const gchar *filename)
 482 {
 483         GKeyFile *config = g_key_file_new();
 484
 485         g_key_file_load_from_file(config, filename, G_KEY_FILE_KEEP_COMMENTS, NULL);
 486         return config;
 487 }
 488
 489
 490 static void load_named_styles(GKeyFile *config, GKeyFile *config_home)
 491 {
 492         const gchar *scheme = editor_prefs.color_scheme;
 493         gboolean free_kf = FALSE;
 494
 495         if (named_style_hash)
 496                 g_hash_table_destroy(named_style_hash); /* reloading */
 497
 498         named_style_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 499
 500         if (NZV(scheme))
 501         {
 502                 gchar *path, *path_home;
 503
 504                 path = g_build_path(G_DIR_SEPARATOR_S, app->datadir, GEANY_COLORSCHEMES_SUBDIR, scheme, NULL);
 505                 path_home = g_build_path(G_DIR_SEPARATOR_S, app->configdir, GEANY_COLORSCHEMES_SUBDIR, scheme, NULL);
 506
 507                 if (g_file_test(path, G_FILE_TEST_EXISTS) || g_file_test(path_home, G_FILE_TEST_EXISTS))
 508                 {
 509                         config = utils_key_file_new(path);
 510                         config_home = utils_key_file_new(path_home);
 511                         free_kf = TRUE;
 512                 }
 513                 /* if color scheme is missing, use default */
 514                 g_free(path);
 515                 g_free(path_home);
 516         }
 517         /* first set default to the "default" named style */
 518         add_named_style(config, "default");
 519         read_named_style("default", &gsd_default);      /* in case user overrides but not with both colors */
 520         add_named_style(config_home, "default");
 521         read_named_style("default", &gsd_default);
 522
 523         get_named_styles(config);
 524         /* home overrides any system named style */
 525         get_named_styles(config_home);
 526
 527         if (free_kf)
 528         {
 529                 g_key_file_free(config);
 530                 g_key_file_free(config_home);
 531         }
 532 }
 533
 534
 535 static void styleset_common_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
 536 {
 537         load_named_styles(config, config_home);
 538
 539         get_keyfile_style(config, config_home, "default", &common_style_set.styling[GCS_DEFAULT]);
 540         get_keyfile_style(config, config_home, "selection", &common_style_set.styling[GCS_SELECTION]);
 541         get_keyfile_style(config, config_home, "brace_good", &common_style_set.styling[GCS_BRACE_GOOD]);
 542         get_keyfile_style(config, config_home, "brace_bad", &common_style_set.styling[GCS_BRACE_BAD]);
 543         get_keyfile_style(config, config_home, "margin_linenumber", &common_style_set.styling[GCS_MARGIN_LINENUMBER]);
 544         get_keyfile_style(config, config_home, "margin_folding", &common_style_set.styling[GCS_MARGIN_FOLDING]);
 545         get_keyfile_style(config, config_home, "fold_symbol_highlight", &common_style_set.styling[GCS_FOLD_SYMBOL_HIGHLIGHT]);
 546         get_keyfile_style(config, config_home, "current_line", &common_style_set.styling[GCS_CURRENT_LINE]);
 547         get_keyfile_style(config, config_home, "caret", &common_style_set.styling[GCS_CARET]);
 548         get_keyfile_style(config, config_home, "indent_guide", &common_style_set.styling[GCS_INDENT_GUIDE]);
 549         get_keyfile_style(config, config_home, "white_space", &common_style_set.styling[GCS_WHITE_SPACE]);
 550         get_keyfile_style(config, config_home, "marker_line", &common_style_set.styling[GCS_MARKER_LINE]);
 551         get_keyfile_style(config, config_home, "marker_search", &common_style_set.styling[GCS_MARKER_SEARCH]);
 552         get_keyfile_style(config, config_home, "marker_mark", &common_style_set.styling[GCS_MARKER_MARK]);
 553         get_keyfile_style(config, config_home, "calltips", &common_style_set.styling[GCS_CALLTIPS]);
 554
 555         get_keyfile_ints(config, config_home, "styling", "folding_style",
 556                 1, 1, &common_style_set.fold_marker, &common_style_set.fold_lines);
 557         get_keyfile_ints(config, config_home, "styling", "folding_horiz_line",
 558                 2, 0, &common_style_set.fold_draw_line, NULL);
 559         get_keyfile_ints(config, config_home, "styling", "caret_width",
 560                 1, 0, &common_style_set.styling[GCS_CARET].background, NULL); /* caret.foreground used earlier */
 561         get_keyfile_int(config, config_home, "styling", "line_wrap_visuals",
 562                 3, 0, &common_style_set.styling[GCS_LINE_WRAP_VISUALS]);
 563         get_keyfile_int(config, config_home, "styling", "line_wrap_indent",
 564                 0, 0, &common_style_set.styling[GCS_LINE_WRAP_INDENT]);
 565         get_keyfile_int(config, config_home, "styling", "translucency",
 566                 256, 256, &common_style_set.styling[GCS_TRANSLUCENCY]);
 567         get_keyfile_int(config, config_home, "styling", "marker_translucency",
 568                 256, 256, &common_style_set.styling[GCS_MARKER_TRANSLUCENCY]);
 569         get_keyfile_int(config, config_home, "styling", "line_height",
 570                 0, 0, &common_style_set.styling[GCS_LINE_HEIGHT]);
 571
 572         get_keyfile_wordchars(config, config_home, &common_style_set.wordchars);
 573         whitespace_chars = get_keyfile_whitespace_chars(config, config_home);
 574 }
 575
 576
 577 static void styleset_common(ScintillaObject *sci, filetype_id ft_id)
 578 {
 579         SSM(sci, SCI_STYLECLEARALL, 0, 0);
 580
 581         SSM(sci, SCI_SETWORDCHARS, 0, (sptr_t) (ft_id == GEANY_FILETYPES_NONE ?
 582                 common_style_set.wordchars : style_sets[ft_id].wordchars));
 583         /* have to set whitespace after setting wordchars */
 584         SSM(sci, SCI_SETWHITESPACECHARS, 0, (sptr_t) whitespace_chars);
 585
 586         /* caret colour, style and width */
 587         SSM(sci, SCI_SETCARETFORE, invert(common_style_set.styling[GCS_CARET].foreground), 0);
 588         SSM(sci, SCI_SETCARETWIDTH, common_style_set.styling[GCS_CARET].background, 0);
 589         if (common_style_set.styling[GCS_CARET].bold)
 590                 SSM(sci, SCI_SETCARETSTYLE, CARETSTYLE_BLOCK, 0);
 591         else
 592                 SSM(sci, SCI_SETCARETSTYLE, CARETSTYLE_LINE, 0);
 593
 594         /* line height */
 595         SSM(sci, SCI_SETEXTRAASCENT, common_style_set.styling[GCS_LINE_HEIGHT].foreground, 0);
 596         SSM(sci, SCI_SETEXTRADESCENT, common_style_set.styling[GCS_LINE_HEIGHT].background, 0);
 597
 598         /* colourise the current line */
 599         SSM(sci, SCI_SETCARETLINEBACK, invert(common_style_set.styling[GCS_CURRENT_LINE].background), 0);
 600         /* bold=enable current line */
 601         SSM(sci, SCI_SETCARETLINEVISIBLE, common_style_set.styling[GCS_CURRENT_LINE].bold, 0);
 602
 603         /* Translucency for current line and selection */
 604         SSM(sci, SCI_SETCARETLINEBACKALPHA, common_style_set.styling[GCS_TRANSLUCENCY].foreground, 0);
 605         SSM(sci, SCI_SETSELALPHA, common_style_set.styling[GCS_TRANSLUCENCY].background, 0);
 606
 607         /* line wrapping visuals */
 608         SSM(sci, SCI_SETWRAPVISUALFLAGS,
 609                 common_style_set.styling[GCS_LINE_WRAP_VISUALS].foreground, 0);
 610         SSM(sci, SCI_SETWRAPVISUALFLAGSLOCATION,
 611                 common_style_set.styling[GCS_LINE_WRAP_VISUALS].background, 0);
 612         SSM(sci, SCI_SETWRAPSTARTINDENT, common_style_set.styling[GCS_LINE_WRAP_INDENT].foreground, 0);
 613         SSM(sci, SCI_SETWRAPINDENTMODE, common_style_set.styling[GCS_LINE_WRAP_INDENT].background, 0);
 614
 615         /* Error indicator */
 616         SSM(sci, SCI_INDICSETSTYLE, GEANY_INDICATOR_ERROR, INDIC_SQUIGGLE);
 617         SSM(sci, SCI_INDICSETFORE, GEANY_INDICATOR_ERROR, invert(rotate_rgb(0xff0000)));
 618
 619         /* Search indicator, used for 'Mark' matches */
 620         SSM(sci, SCI_INDICSETSTYLE, GEANY_INDICATOR_SEARCH, INDIC_ROUNDBOX);
 621         SSM(sci, SCI_INDICSETFORE, GEANY_INDICATOR_SEARCH,
 622                 invert(common_style_set.styling[GCS_MARKER_SEARCH].background));
 623         SSM(sci, SCI_INDICSETALPHA, GEANY_INDICATOR_SEARCH, 60);
 624
 625         /* define marker symbols
 626          * 0 -> line marker */
 627         SSM(sci, SCI_MARKERDEFINE, 0, SC_MARK_SHORTARROW);
 628         SSM(sci, SCI_MARKERSETFORE, 0, invert(common_style_set.styling[GCS_MARKER_LINE].foreground));
 629         SSM(sci, SCI_MARKERSETBACK, 0, invert(common_style_set.styling[GCS_MARKER_LINE].background));
 630         SSM(sci, SCI_MARKERSETALPHA, 0, common_style_set.styling[GCS_MARKER_TRANSLUCENCY].foreground);
 631
 632         /* 1 -> user marker */
 633         SSM(sci, SCI_MARKERDEFINE, 1, SC_MARK_PLUS);
 634         SSM(sci, SCI_MARKERSETFORE, 1, invert(common_style_set.styling[GCS_MARKER_MARK].foreground));
 635         SSM(sci, SCI_MARKERSETBACK, 1, invert(common_style_set.styling[GCS_MARKER_MARK].background));
 636         SSM(sci, SCI_MARKERSETALPHA, 1, common_style_set.styling[GCS_MARKER_TRANSLUCENCY].background);
 637
 638         /* 2 -> folding marker, other folding settings */
 639         SSM(sci, SCI_SETMARGINTYPEN, 2, SC_MARGIN_SYMBOL);
 640         SSM(sci, SCI_SETMARGINMASKN, 2, SC_MASK_FOLDERS);
 641
 642         /* drawing a horizontal line when text if folded */
 643         switch (common_style_set.fold_draw_line)
 644         {
 645                 case 1:
 646                 {
 647                         SSM(sci, SCI_SETFOLDFLAGS, 4, 0);
 648                         break;
 649                 }
 650                 case 2:
 651                 {
 652                         SSM(sci, SCI_SETFOLDFLAGS, 16, 0);
 653                         break;
 654                 }
 655                 default:
 656                 {
 657                         SSM(sci, SCI_SETFOLDFLAGS, 0, 0);
 658                         break;
 659                 }
 660         }
 661
 662         /* choose the folding style - boxes or circles, I prefer boxes, so it is default ;-) */
 663         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_EMPTY);
 664         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_EMPTY);
 665         switch (common_style_set.fold_marker)
 666         {
 667                 case 2:
 668                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_CIRCLEMINUS);
 669                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_CIRCLEPLUS);
 670                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_CIRCLEPLUSCONNECTED);
 671                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_CIRCLEMINUSCONNECTED);
 672                         break;
 673                 default:
 674                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_BOXMINUS);
 675                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_BOXPLUS);
 676                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEREND, SC_MARK_BOXPLUSCONNECTED);
 677                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPENMID, SC_MARK_BOXMINUSCONNECTED);
 678                         break;
 679                 case 3:
 680                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_ARROWDOWN);
 681                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_ARROW);
 682                         break;
 683                 case 4:
 684                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDEROPEN, SC_MARK_MINUS);
 685                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDER, SC_MARK_PLUS);
 686                         break;
 687         }
 688
 689         /* choose the folding style - straight or curved, I prefer straight, so it is default ;-) */
 690         switch (common_style_set.fold_lines)
 691         {
 692                 case 2:
 693                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNERCURVE);
 694                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNERCURVE);
 695                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE);
 696                         break;
 697                 default:
 698                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_TCORNER);
 699                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERTAIL, SC_MARK_LCORNER);
 700                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERSUB, SC_MARK_VLINE);
 701                         break;
 702                 case 0:
 703                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERMIDTAIL, SC_MARK_EMPTY);
 704                         SSM(sci, SCI_MARKERDEFINE, SC_MARKNUM_FOLDERTAIL, SC_MARK_EMPTY);
 705                         SSM(sci, SCI_MARKERDEFINE,  SC_MARKNUM_FOLDERSUB, SC_MARK_EMPTY);
 706                         break;
 707         }
 708         {
 709                 gint markers[] = {
 710                         SC_MARKNUM_FOLDEROPEN,
 711                         SC_MARKNUM_FOLDER,
 712                         SC_MARKNUM_FOLDERSUB,
 713                         SC_MARKNUM_FOLDERTAIL,
 714                         SC_MARKNUM_FOLDEREND,
 715                         SC_MARKNUM_FOLDEROPENMID,
 716                         SC_MARKNUM_FOLDERMIDTAIL
 717                 };
 718                 guint i;
 719
 720                 foreach_range(i, G_N_ELEMENTS(markers))
 721                 {
 722                         SSM(sci, SCI_MARKERSETFORE, markers[i],
 723                                 invert(common_style_set.styling[GCS_FOLD_SYMBOL_HIGHLIGHT].foreground));
 724                         SSM(sci, SCI_MARKERSETBACK, markers[i],
 725                                 invert(common_style_set.styling[GCS_MARGIN_FOLDING].foreground));
 726                 }
 727         }
 728
 729         /* set some common defaults */
 730         sci_set_property(sci, "fold", "1");
 731         sci_set_property(sci, "fold.compact", "0");
 732         sci_set_property(sci, "fold.comment", "1");
 733         sci_set_property(sci, "fold.preprocessor", "1");
 734         sci_set_property(sci, "fold.at.else", "1");
 735
 736         /* bold (3rd argument) is whether to override default foreground selection */
 737         if (common_style_set.styling[GCS_SELECTION].bold)
 738                 SSM(sci, SCI_SETSELFORE, 1, invert(common_style_set.styling[GCS_SELECTION].foreground));
 739         /* italic (4th argument) is whether to override default background selection */
 740         if (common_style_set.styling[GCS_SELECTION].italic)
 741                 SSM(sci, SCI_SETSELBACK, 1, invert(common_style_set.styling[GCS_SELECTION].background));
 742
 743         SSM(sci, SCI_SETSTYLEBITS, SSM(sci, SCI_GETSTYLEBITSNEEDED, 0, 0), 0);
 744
 745         SSM(sci, SCI_SETFOLDMARGINCOLOUR, 1, invert(common_style_set.styling[GCS_MARGIN_FOLDING].background));
 746         SSM(sci, SCI_SETFOLDMARGINHICOLOUR, 1, invert(common_style_set.styling[GCS_MARGIN_FOLDING].background));
 747         set_sci_style(sci, STYLE_LINENUMBER, GEANY_FILETYPES_NONE, GCS_MARGIN_LINENUMBER);
 748         set_sci_style(sci, STYLE_BRACELIGHT, GEANY_FILETYPES_NONE, GCS_BRACE_GOOD);
 749         set_sci_style(sci, STYLE_BRACEBAD, GEANY_FILETYPES_NONE, GCS_BRACE_BAD);
 750         set_sci_style(sci, STYLE_INDENTGUIDE, GEANY_FILETYPES_NONE, GCS_INDENT_GUIDE);
 751
 752         /* bold = common whitespace settings enabled */
 753         SSM(sci, SCI_SETWHITESPACEFORE, common_style_set.styling[GCS_WHITE_SPACE].bold,
 754                 invert(common_style_set.styling[GCS_WHITE_SPACE].foreground));
 755         SSM(sci, SCI_SETWHITESPACEBACK, common_style_set.styling[GCS_WHITE_SPACE].italic,
 756                 invert(common_style_set.styling[GCS_WHITE_SPACE].background));
 757
 758         if (common_style_set.styling[GCS_CALLTIPS].bold)
 759                 SSM(sci, SCI_CALLTIPSETFORE, invert(common_style_set.styling[GCS_CALLTIPS].foreground), 1);
 760         if (common_style_set.styling[GCS_CALLTIPS].italic)
 761                 SSM(sci, SCI_CALLTIPSETBACK, invert(common_style_set.styling[GCS_CALLTIPS].background), 1);
 762 }
 763
 764
 765 /* Merge & assign global typedefs and user secondary keywords.
 766  * keyword_idx is used for both style_sets[].keywords and scintilla keyword style number */
 767 static void merge_type_keywords(ScintillaObject *sci, gint ft_id, gint keyword_idx)
 768 {
 769         const gchar *user_words = style_sets[ft_id].keywords[keyword_idx];
 770         GString *s;
 771
 772         s = get_global_typenames(filetypes[ft_id]->lang);
 773         if (G_UNLIKELY(s == NULL))
 774                 s = g_string_sized_new(200);
 775         else
 776                 g_string_append_c(s, ' '); /* append a space as delimiter to the existing list of words */
 777
 778         g_string_append(s, user_words);
 779
 780         sci_set_keywords(sci, keyword_idx, s->str);
 781         g_string_free(s, TRUE);
 782 }
 783
 784
 785 /* All stylesets except None should call this. */
 786 static void
 787 apply_filetype_properties(ScintillaObject *sci, gint lexer, filetype_id ft_id)
 788 {
 789         g_assert(ft_id != GEANY_FILETYPES_NONE);
 790
 791         SSM(sci, SCI_SETLEXER, lexer, 0);
 792
 793         styleset_common(sci, ft_id);
 794 }
 795
 796
 797 /* names: the style names for the filetype. */
 798 static void load_style_entries(GKeyFile *config, GKeyFile *config_home, gint filetype_idx,
 799                 const gchar **names, gsize names_len)
 800 {
 801         guint i;
 802
 803         foreach_range(i, names_len)
 804         {
 805                 const gchar *name = names[i];
 806                 GeanyLexerStyle *style = &style_sets[filetype_idx].styling[i];
 807
 808                 get_keyfile_style(config, config_home, name, style);
 809         }
 810 }
 811
 812
 813 /* styles: the style IDs for the filetype.
 814  * STYLE_DEFAULT will be set to match the first style. */
 815 static void apply_style_entries(ScintillaObject *sci, gint filetype_idx,
 816                 gint *styles, gsize styles_len)
 817 {
 818         guint i;
 819
 820         g_return_if_fail(styles_len > 0);
 821
 822         set_sci_style(sci, STYLE_DEFAULT, filetype_idx, 0);
 823
 824         foreach_range(i, styles_len)
 825                 set_sci_style(sci, styles[i], filetype_idx, i);
 826 }
 827
 828
 829 /* call new_styleset(filetype_idx, >= 20) before using this. */
 830 static void
 831 styleset_c_like_init(GKeyFile *config, GKeyFile *config_home, gint filetype_idx)
 832 {
 833         const gchar *entries[] =
 834         {
 835                 "default",
 836                 "comment",
 837                 "commentline",
 838                 "commentdoc",
 839                 "number",
 840                 "word",
 841                 "word2",
 842                 "string",
 843                 "character",
 844                 "uuid",
 845                 "preprocessor",
 846                 "operator",
 847                 "identifier",
 848                 "stringeol",
 849                 "verbatim",
 850                 "verbatim", /* triple verbatims use the same style */
 851                 "regex",
 852                 "commentlinedoc",
 853                 "commentdockeyword",
 854                 "commentdockeyworderror",
 855                 "globalclass"
 856         };
 857
 858         new_styleset(filetype_idx, G_N_ELEMENTS(entries));
 859         load_style_entries(config, config_home, filetype_idx, entries, G_N_ELEMENTS(entries));
 860 }
 861
 862
 863 static void styleset_c_like(ScintillaObject *sci, gint ft_id, gint lexer)
 864 {
 865         gint styles[] = {
 866                 SCE_C_DEFAULT,
 867                 SCE_C_COMMENT,
 868                 SCE_C_COMMENTLINE,
 869                 SCE_C_COMMENTDOC,
 870                 SCE_C_NUMBER,
 871                 SCE_C_WORD,
 872                 SCE_C_WORD2,
 873                 SCE_C_STRING,
 874                 SCE_C_CHARACTER,
 875                 SCE_C_UUID,
 876                 SCE_C_PREPROCESSOR,
 877                 SCE_C_OPERATOR,
 878                 SCE_C_IDENTIFIER,
 879                 SCE_C_STRINGEOL,
 880                 SCE_C_VERBATIM,
 881                 SCE_C_TRIPLEVERBATIM,
 882                 SCE_C_REGEX,
 883                 SCE_C_COMMENTLINEDOC,
 884                 SCE_C_COMMENTDOCKEYWORD,
 885                 SCE_C_COMMENTDOCKEYWORDERROR,
 886                 /* used for local structs and typedefs */
 887                 SCE_C_GLOBALCLASS
 888         };
 889
 890         apply_filetype_properties(sci, lexer, ft_id);
 891         apply_style_entries(sci, ft_id, styles, G_N_ELEMENTS(styles));
 892
 893         /* Disable explicit //{ folding as it can seem like a bug */
 894         sci_set_property(sci, "fold.cpp.comment.explicit", "0");
 895 }
 896
 897
 898 static void styleset_c_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
 899 {
 900         styleset_c_like_init(config, config_home, ft_id);
 901
 902         style_sets[ft_id].keywords = g_new(gchar*, 4);
 903         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
 904         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
 905         get_keyfile_keywords(config, config_home, "docComment", ft_id, 2);
 906         style_sets[ft_id].keywords[3] = NULL;
 907 }
 908
 909
 910 static void styleset_c(ScintillaObject *sci, gint ft_id)
 911 {
 912         styleset_c_like(sci, ft_id, SCLEX_CPP);
 913
 914         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
 915         /* SCI_SETKEYWORDS = 1 - secondary + global tags file types, see below */
 916         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
 917         /* SCI_SETKEYWORDS = 3 is for current session types - see editor_lexer_get_type_keyword_idx() */
 918
 919         /* assign global types, merge them with user defined keywords and set them */
 920         merge_type_keywords(sci, ft_id, 1);
 921 }
 922
 923
 924 static void styleset_pascal_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
 925 {
 926         new_styleset(ft_id, 15);
 927         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
 928         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[1]);
 929         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[2]);
 930         get_keyfile_style(config, config_home, "comment2", &style_sets[ft_id].styling[3]);
 931         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[4]);
 932         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[5]);
 933         get_keyfile_style(config, config_home, "preprocessor2", &style_sets[ft_id].styling[6]);
 934         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[7]);
 935         get_keyfile_style(config, config_home, "hexnumber", &style_sets[ft_id].styling[8]);
 936         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[9]);
 937         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[10]);
 938         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[11]);
 939         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[12]);
 940         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[13]);
 941         get_keyfile_style(config, config_home, "asm", &style_sets[ft_id].styling[14]);
 942
 943         style_sets[ft_id].keywords = g_new(gchar*, 2);
 944         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
 945         style_sets[ft_id].keywords[1] = NULL;
 946 }
 947
 948
 949 static void styleset_pascal(ScintillaObject *sci, gint ft_id)
 950 {
 951         apply_filetype_properties(sci, SCLEX_PASCAL, ft_id);
 952
 953         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
 954
 955         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
 956         set_sci_style(sci, SCE_PAS_DEFAULT, ft_id, 0);
 957         set_sci_style(sci, SCE_PAS_IDENTIFIER, ft_id, 1);
 958         set_sci_style(sci, SCE_PAS_COMMENT, ft_id, 2);
 959         set_sci_style(sci, SCE_PAS_COMMENT2, ft_id, 3);
 960         set_sci_style(sci, SCE_PAS_COMMENTLINE, ft_id, 4);
 961         set_sci_style(sci, SCE_PAS_PREPROCESSOR, ft_id, 5);
 962         set_sci_style(sci, SCE_PAS_PREPROCESSOR2, ft_id, 6);
 963         set_sci_style(sci, SCE_PAS_NUMBER, ft_id, 7);
 964         set_sci_style(sci, SCE_PAS_HEXNUMBER, ft_id, 8);
 965         set_sci_style(sci, SCE_PAS_WORD, ft_id, 9);
 966         set_sci_style(sci, SCE_PAS_STRING, ft_id, 10);
 967         set_sci_style(sci, SCE_PAS_STRINGEOL, ft_id, 11);
 968         set_sci_style(sci, SCE_PAS_CHARACTER, ft_id, 12);
 969         set_sci_style(sci, SCE_PAS_OPERATOR, ft_id, 13);
 970         set_sci_style(sci, SCE_PAS_ASM, ft_id, 14);
 971 }
 972
 973
 974 static void styleset_makefile_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
 975 {
 976         new_styleset(ft_id, 7);
 977         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
 978         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
 979         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[2]);
 980         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[3]);
 981         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[4]);
 982         get_keyfile_style(config, config_home, "target", &style_sets[ft_id].styling[5]);
 983         get_keyfile_style(config, config_home, "ideol", &style_sets[ft_id].styling[6]);
 984
 985         style_sets[ft_id].keywords = NULL;
 986 }
 987
 988
 989 static void styleset_makefile(ScintillaObject *sci, gint ft_id)
 990 {
 991         apply_filetype_properties(sci, SCLEX_MAKEFILE, ft_id);
 992
 993         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
 994         set_sci_style(sci, SCE_MAKE_DEFAULT, ft_id, 0);
 995         set_sci_style(sci, SCE_MAKE_COMMENT, ft_id, 1);
 996         set_sci_style(sci, SCE_MAKE_PREPROCESSOR, ft_id, 2);
 997         set_sci_style(sci, SCE_MAKE_IDENTIFIER, ft_id, 3);
 998         set_sci_style(sci, SCE_MAKE_OPERATOR, ft_id, 4);
 999         set_sci_style(sci, SCE_MAKE_TARGET, ft_id, 5);
1000         set_sci_style(sci, SCE_MAKE_IDEOL, ft_id, 6);
1001 }
1002
1003
1004 static void styleset_diff_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1005 {
1006         new_styleset(ft_id, 8);
1007         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1008         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
1009         get_keyfile_style(config, config_home, "command", &style_sets[ft_id].styling[2]);
1010         get_keyfile_style(config, config_home, "header", &style_sets[ft_id].styling[3]);
1011         get_keyfile_style(config, config_home, "position", &style_sets[ft_id].styling[4]);
1012         get_keyfile_style(config, config_home, "deleted", &style_sets[ft_id].styling[5]);
1013         get_keyfile_style(config, config_home, "added", &style_sets[ft_id].styling[6]);
1014         get_keyfile_style(config, config_home, "changed", &style_sets[ft_id].styling[7]);
1015
1016         style_sets[ft_id].keywords = NULL;
1017 }
1018
1019
1020 static void styleset_diff(ScintillaObject *sci, gint ft_id)
1021 {
1022         apply_filetype_properties(sci, SCLEX_DIFF, ft_id);
1023
1024         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1025         set_sci_style(sci, SCE_DIFF_DEFAULT, ft_id, 0);
1026         set_sci_style(sci, SCE_DIFF_COMMENT, ft_id, 1);
1027         set_sci_style(sci, SCE_DIFF_COMMAND, ft_id, 2);
1028         set_sci_style(sci, SCE_DIFF_HEADER, ft_id, 3);
1029         set_sci_style(sci, SCE_DIFF_POSITION, ft_id, 4);
1030         set_sci_style(sci, SCE_DIFF_DELETED, ft_id, 5);
1031         set_sci_style(sci, SCE_DIFF_ADDED, ft_id, 6);
1032         set_sci_style(sci, SCE_DIFF_CHANGED, ft_id, 7);
1033 }
1034
1035
1036 static void styleset_lisp_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1037 {
1038         new_styleset(ft_id, 15);
1039         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1040         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
1041         get_keyfile_style(config, config_home, "multicomment", &style_sets[ft_id].styling[2]);
1042         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
1043         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[4]);
1044         get_keyfile_style(config, config_home, "special_keyword", &style_sets[ft_id].styling[5]);
1045         get_keyfile_style(config, config_home, "symbol", &style_sets[ft_id].styling[6]);
1046         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[7]);
1047         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[8]);
1048         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[9]);
1049         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
1050         get_keyfile_style(config, config_home, "special", &style_sets[ft_id].styling[11]);
1051         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[12]);
1052         get_keyfile_style(config, config_home, "macro", &style_sets[ft_id].styling[13]);
1053         get_keyfile_style(config, config_home, "macrodispatch", &style_sets[ft_id].styling[14]);
1054
1055         style_sets[ft_id].keywords = g_new(gchar*, 3);
1056         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
1057         get_keyfile_keywords(config, config_home, "special_keywords", ft_id, 1);
1058         style_sets[ft_id].keywords[2] = NULL;
1059 }
1060
1061
1062 static void styleset_lisp(ScintillaObject *sci, gint ft_id)
1063 {
1064         apply_filetype_properties(sci, SCLEX_LISP, ft_id);
1065
1066         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1067         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1068
1069         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1070         set_sci_style(sci, SCE_LISP_DEFAULT, ft_id, 0);
1071         set_sci_style(sci, SCE_LISP_COMMENT, ft_id, 1);
1072         set_sci_style(sci, SCE_LISP_MULTI_COMMENT, ft_id, 2);
1073         set_sci_style(sci, SCE_LISP_NUMBER, ft_id, 3);
1074         set_sci_style(sci, SCE_LISP_KEYWORD, ft_id, 4);
1075 /*
1076         set_sci_style(sci, SCE_LISP_SPECIAL_KEYWORD, ft_id, 5);
1077 */
1078         set_sci_style(sci, SCE_LISP_SYMBOL, ft_id, 6);
1079         set_sci_style(sci, SCE_LISP_STRING, ft_id, 7);
1080         set_sci_style(sci, SCE_LISP_STRINGEOL, ft_id, 8);
1081         set_sci_style(sci, SCE_LISP_IDENTIFIER, ft_id, 9);
1082         set_sci_style(sci, SCE_LISP_OPERATOR, ft_id, 10);
1083         set_sci_style(sci, SCE_LISP_SPECIAL, ft_id, 11);
1084 /*
1085         set_sci_style(sci, SCE_LISP_CHARACTER, ft_id, 12);
1086         set_sci_style(sci, SCE_LISP_MACRO, ft_id, 13);
1087         set_sci_style(sci, SCE_LISP_MACRO_DISPATCH, ft_id, 14);
1088 */
1089 }
1090
1091
1092 static void styleset_erlang_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1093 {
1094         new_styleset(ft_id, 26);
1095         get_keyfile_style(config, config_home, "default",                       &style_sets[ft_id].styling[0]);
1096         get_keyfile_style(config, config_home, "comment",                       &style_sets[ft_id].styling[1]);
1097         get_keyfile_style(config, config_home, "variable",                      &style_sets[ft_id].styling[2]);
1098         get_keyfile_style(config, config_home, "number",                        &style_sets[ft_id].styling[3]);
1099         get_keyfile_style(config, config_home, "keyword",                       &style_sets[ft_id].styling[4]);
1100         get_keyfile_style(config, config_home, "string",                        &style_sets[ft_id].styling[5]);
1101         get_keyfile_style(config, config_home, "operator",                      &style_sets[ft_id].styling[6]);
1102         get_keyfile_style(config, config_home, "atom",                          &style_sets[ft_id].styling[7]);
1103         get_keyfile_style(config, config_home, "function_name",         &style_sets[ft_id].styling[8]);
1104         get_keyfile_style(config, config_home, "character",                     &style_sets[ft_id].styling[9]);
1105         get_keyfile_style(config, config_home, "macro",                         &style_sets[ft_id].styling[10]);
1106         get_keyfile_style(config, config_home, "record",                        &style_sets[ft_id].styling[11]);
1107         get_keyfile_style(config, config_home, "preproc",                       &style_sets[ft_id].styling[12]);
1108         get_keyfile_style(config, config_home, "node_name",                     &style_sets[ft_id].styling[13]);
1109         get_keyfile_style(config, config_home, "comment_function",      &style_sets[ft_id].styling[14]);
1110         get_keyfile_style(config, config_home, "comment_module",        &style_sets[ft_id].styling[15]);
1111         get_keyfile_style(config, config_home, "comment_doc",           &style_sets[ft_id].styling[16]);
1112         get_keyfile_style(config, config_home, "comment_doc_macro",     &style_sets[ft_id].styling[17]);
1113         get_keyfile_style(config, config_home, "atom_quoted",           &style_sets[ft_id].styling[18]);
1114         get_keyfile_style(config, config_home, "macro_quoted",          &style_sets[ft_id].styling[19]);
1115         get_keyfile_style(config, config_home, "record_quoted",         &style_sets[ft_id].styling[20]);
1116         get_keyfile_style(config, config_home, "node_name_quoted",      &style_sets[ft_id].styling[21]);
1117         get_keyfile_style(config, config_home, "bifs",                          &style_sets[ft_id].styling[22]);
1118         get_keyfile_style(config, config_home, "modules",                       &style_sets[ft_id].styling[23]);
1119         get_keyfile_style(config, config_home, "modules_att",           &style_sets[ft_id].styling[24]);
1120         get_keyfile_style(config, config_home, "unknown",                       &style_sets[ft_id].styling[25]);
1121
1122         style_sets[ft_id].keywords = g_new(gchar*, 6);
1123         get_keyfile_keywords(config, config_home, "keywords",   ft_id, 0);
1124         get_keyfile_keywords(config, config_home, "bifs",               ft_id, 1);
1125         get_keyfile_keywords(config, config_home, "preproc",    ft_id, 2);
1126         get_keyfile_keywords(config, config_home, "module",             ft_id, 3);
1127         get_keyfile_keywords(config, config_home, "doc",                ft_id, 4);
1128         get_keyfile_keywords(config, config_home, "doc_macro",  ft_id, 5);
1129         style_sets[ft_id].keywords[6] = NULL;
1130 }
1131
1132
1133 static void styleset_erlang(ScintillaObject *sci, gint ft_id)
1134 {
1135         apply_filetype_properties(sci, SCLEX_ERLANG, ft_id);
1136
1137         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1138         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1139         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
1140         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
1141         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[4]);
1142         sci_set_keywords(sci, 5, style_sets[ft_id].keywords[5]);
1143
1144         set_sci_style(sci, STYLE_DEFAULT,                                       ft_id, 0);
1145         set_sci_style(sci, SCE_ERLANG_DEFAULT,                          ft_id, 0);
1146         set_sci_style(sci, SCE_ERLANG_COMMENT,                          ft_id, 1);
1147         set_sci_style(sci, SCE_ERLANG_VARIABLE,                         ft_id, 2);
1148         set_sci_style(sci, SCE_ERLANG_NUMBER,                           ft_id, 3);
1149         set_sci_style(sci, SCE_ERLANG_KEYWORD,                          ft_id, 4);
1150         set_sci_style(sci, SCE_ERLANG_STRING,                           ft_id, 5);
1151         set_sci_style(sci, SCE_ERLANG_OPERATOR,                         ft_id, 6);
1152         set_sci_style(sci, SCE_ERLANG_ATOM,                                     ft_id, 7);
1153         set_sci_style(sci, SCE_ERLANG_FUNCTION_NAME,            ft_id, 8);
1154         set_sci_style(sci, SCE_ERLANG_CHARACTER,                        ft_id, 9);
1155         set_sci_style(sci, SCE_ERLANG_MACRO,                            ft_id, 10);
1156         set_sci_style(sci, SCE_ERLANG_RECORD,                           ft_id, 11);
1157         set_sci_style(sci, SCE_ERLANG_PREPROC,                          ft_id, 12);
1158         set_sci_style(sci, SCE_ERLANG_NODE_NAME,                        ft_id, 13);
1159         set_sci_style(sci, SCE_ERLANG_COMMENT_FUNCTION,         ft_id, 14);
1160         set_sci_style(sci, SCE_ERLANG_COMMENT_MODULE,           ft_id, 15);
1161         set_sci_style(sci, SCE_ERLANG_COMMENT_DOC,                      ft_id, 16);
1162         set_sci_style(sci, SCE_ERLANG_COMMENT_DOC_MACRO,        ft_id, 17);
1163         set_sci_style(sci, SCE_ERLANG_ATOM_QUOTED,                      ft_id, 18);
1164         set_sci_style(sci, SCE_ERLANG_MACRO_QUOTED,                     ft_id, 19);
1165         set_sci_style(sci, SCE_ERLANG_RECORD_QUOTED,            ft_id, 20);
1166         set_sci_style(sci, SCE_ERLANG_NODE_NAME_QUOTED,         ft_id, 21);
1167         set_sci_style(sci, SCE_ERLANG_BIFS,                                     ft_id, 22);
1168         set_sci_style(sci, SCE_ERLANG_MODULES,                          ft_id, 23);
1169         set_sci_style(sci, SCE_ERLANG_MODULES_ATT,                      ft_id, 24);
1170         set_sci_style(sci, SCE_ERLANG_UNKNOWN,                          ft_id, 25);
1171 }
1172
1173
1174 static void styleset_latex_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1175 {
1176         new_styleset(ft_id, 5);
1177         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1178         get_keyfile_style(config, config_home, "command", &style_sets[ft_id].styling[1]);
1179         get_keyfile_style(config, config_home, "tag", &style_sets[ft_id].styling[2]);
1180         get_keyfile_style(config, config_home, "math", &style_sets[ft_id].styling[3]);
1181         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[4]);
1182
1183         style_sets[ft_id].keywords = g_new(gchar*, 2);
1184         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1185         style_sets[ft_id].keywords[1] = NULL;
1186 }
1187
1188
1189 static void styleset_latex(ScintillaObject *sci, gint ft_id)
1190 {
1191         apply_filetype_properties(sci, SCLEX_LATEX, ft_id);
1192
1193         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1194
1195         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1196         set_sci_style(sci, SCE_L_DEFAULT, ft_id, 0);
1197         set_sci_style(sci, SCE_L_COMMAND, ft_id, 1);
1198         set_sci_style(sci, SCE_L_TAG, ft_id, 2);
1199         set_sci_style(sci, SCE_L_MATH, ft_id, 3);
1200         set_sci_style(sci, SCE_L_COMMENT, ft_id, 4);
1201 }
1202
1203
1204 static void styleset_php_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1205 {
1206         style_sets[ft_id].styling = NULL;
1207         style_sets[ft_id].keywords = NULL;
1208 }
1209
1210
1211 static void styleset_php(ScintillaObject *sci, gint ft_id)
1212 {
1213         apply_filetype_properties(sci, SCLEX_HTML, ft_id);
1214
1215         /* use the same colouring as for XML */
1216         styleset_markup(sci, TRUE);
1217 }
1218
1219
1220 static void styleset_html_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1221 {
1222         style_sets[ft_id].styling = NULL;
1223         style_sets[ft_id].keywords = NULL;
1224 }
1225
1226
1227 static void styleset_html(ScintillaObject *sci, gint ft_id)
1228 {
1229         apply_filetype_properties(sci, SCLEX_HTML, ft_id);
1230
1231         /* use the same colouring for HTML; XML and so on */
1232         styleset_markup(sci, TRUE);
1233 }
1234
1235
1236 static void styleset_markup_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1237 {
1238         new_styleset(GEANY_FILETYPES_XML, 56);
1239         get_keyfile_style(config, config_home, "html_default", &style_sets[GEANY_FILETYPES_XML].styling[0]);
1240         get_keyfile_style(config, config_home, "html_tag", &style_sets[GEANY_FILETYPES_XML].styling[1]);
1241         get_keyfile_style(config, config_home, "html_tagunknown", &style_sets[GEANY_FILETYPES_XML].styling[2]);
1242         get_keyfile_style(config, config_home, "html_attribute", &style_sets[GEANY_FILETYPES_XML].styling[3]);
1243         get_keyfile_style(config, config_home, "html_attributeunknown", &style_sets[GEANY_FILETYPES_XML].styling[4]);
1244         get_keyfile_style(config, config_home, "html_number", &style_sets[GEANY_FILETYPES_XML].styling[5]);
1245         get_keyfile_style(config, config_home, "html_doublestring", &style_sets[GEANY_FILETYPES_XML].styling[6]);
1246         get_keyfile_style(config, config_home, "html_singlestring", &style_sets[GEANY_FILETYPES_XML].styling[7]);
1247         get_keyfile_style(config, config_home, "html_other", &style_sets[GEANY_FILETYPES_XML].styling[8]);
1248         get_keyfile_style(config, config_home, "html_comment", &style_sets[GEANY_FILETYPES_XML].styling[9]);
1249         get_keyfile_style(config, config_home, "html_entity", &style_sets[GEANY_FILETYPES_XML].styling[10]);
1250         get_keyfile_style(config, config_home, "html_tagend", &style_sets[GEANY_FILETYPES_XML].styling[11]);
1251         get_keyfile_style(config, config_home, "html_xmlstart", &style_sets[GEANY_FILETYPES_XML].styling[12]);
1252         get_keyfile_style(config, config_home, "html_xmlend", &style_sets[GEANY_FILETYPES_XML].styling[13]);
1253         get_keyfile_style(config, config_home, "html_script", &style_sets[GEANY_FILETYPES_XML].styling[14]);
1254         get_keyfile_style(config, config_home, "html_asp", &style_sets[GEANY_FILETYPES_XML].styling[15]);
1255         get_keyfile_style(config, config_home, "html_aspat", &style_sets[GEANY_FILETYPES_XML].styling[16]);
1256         get_keyfile_style(config, config_home, "html_cdata", &style_sets[GEANY_FILETYPES_XML].styling[17]);
1257         get_keyfile_style(config, config_home, "html_question", &style_sets[GEANY_FILETYPES_XML].styling[18]);
1258         get_keyfile_style(config, config_home, "html_value", &style_sets[GEANY_FILETYPES_XML].styling[19]);
1259         get_keyfile_style(config, config_home, "html_xccomment", &style_sets[GEANY_FILETYPES_XML].styling[20]);
1260
1261         get_keyfile_style(config, config_home, "sgml_default", &style_sets[GEANY_FILETYPES_XML].styling[21]);
1262         get_keyfile_style(config, config_home, "sgml_comment", &style_sets[GEANY_FILETYPES_XML].styling[22]);
1263         get_keyfile_style(config, config_home, "sgml_special", &style_sets[GEANY_FILETYPES_XML].styling[23]);
1264         get_keyfile_style(config, config_home, "sgml_command", &style_sets[GEANY_FILETYPES_XML].styling[24]);
1265         get_keyfile_style(config, config_home, "sgml_doublestring", &style_sets[GEANY_FILETYPES_XML].styling[25]);
1266         get_keyfile_style(config, config_home, "sgml_simplestring", &style_sets[GEANY_FILETYPES_XML].styling[26]);
1267         get_keyfile_style(config, config_home, "sgml_1st_param", &style_sets[GEANY_FILETYPES_XML].styling[27]);
1268         get_keyfile_style(config, config_home, "sgml_entity", &style_sets[GEANY_FILETYPES_XML].styling[28]);
1269         get_keyfile_style(config, config_home, "sgml_block_default", &style_sets[GEANY_FILETYPES_XML].styling[29]);
1270         get_keyfile_style(config, config_home, "sgml_1st_param_comment", &style_sets[GEANY_FILETYPES_XML].styling[30]);
1271         get_keyfile_style(config, config_home, "sgml_error", &style_sets[GEANY_FILETYPES_XML].styling[31]);
1272
1273         get_keyfile_style(config, config_home, "php_default", &style_sets[GEANY_FILETYPES_XML].styling[32]);
1274         get_keyfile_style(config, config_home, "php_simplestring", &style_sets[GEANY_FILETYPES_XML].styling[33]);
1275         get_keyfile_style(config, config_home, "php_hstring", &style_sets[GEANY_FILETYPES_XML].styling[34]);
1276         get_keyfile_style(config, config_home, "php_number", &style_sets[GEANY_FILETYPES_XML].styling[35]);
1277         get_keyfile_style(config, config_home, "php_word", &style_sets[GEANY_FILETYPES_XML].styling[36]);
1278         get_keyfile_style(config, config_home, "php_variable", &style_sets[GEANY_FILETYPES_XML].styling[37]);
1279         get_keyfile_style(config, config_home, "php_comment", &style_sets[GEANY_FILETYPES_XML].styling[38]);
1280         get_keyfile_style(config, config_home, "php_commentline", &style_sets[GEANY_FILETYPES_XML].styling[39]);
1281         get_keyfile_style(config, config_home, "php_operator", &style_sets[GEANY_FILETYPES_XML].styling[40]);
1282         get_keyfile_style(config, config_home, "php_hstring_variable", &style_sets[GEANY_FILETYPES_XML].styling[41]);
1283         get_keyfile_style(config, config_home, "php_complex_variable", &style_sets[GEANY_FILETYPES_XML].styling[42]);
1284
1285         get_keyfile_style(config, config_home, "jscript_start", &style_sets[GEANY_FILETYPES_XML].styling[43]);
1286         get_keyfile_style(config, config_home, "jscript_default", &style_sets[GEANY_FILETYPES_XML].styling[44]);
1287         get_keyfile_style(config, config_home, "jscript_comment", &style_sets[GEANY_FILETYPES_XML].styling[45]);
1288         get_keyfile_style(config, config_home, "jscript_commentline", &style_sets[GEANY_FILETYPES_XML].styling[46]);
1289         get_keyfile_style(config, config_home, "jscript_commentdoc", &style_sets[GEANY_FILETYPES_XML].styling[47]);
1290         get_keyfile_style(config, config_home, "jscript_number", &style_sets[GEANY_FILETYPES_XML].styling[48]);
1291         get_keyfile_style(config, config_home, "jscript_word", &style_sets[GEANY_FILETYPES_XML].styling[49]);
1292         get_keyfile_style(config, config_home, "jscript_keyword", &style_sets[GEANY_FILETYPES_XML].styling[50]);
1293         get_keyfile_style(config, config_home, "jscript_doublestring", &style_sets[GEANY_FILETYPES_XML].styling[51]);
1294         get_keyfile_style(config, config_home, "jscript_singlestring", &style_sets[GEANY_FILETYPES_XML].styling[52]);
1295         get_keyfile_style(config, config_home, "jscript_symbols", &style_sets[GEANY_FILETYPES_XML].styling[53]);
1296         get_keyfile_style(config, config_home, "jscript_stringeol", &style_sets[GEANY_FILETYPES_XML].styling[54]);
1297         get_keyfile_style(config, config_home, "jscript_regex", &style_sets[GEANY_FILETYPES_XML].styling[55]);
1298
1299         style_sets[GEANY_FILETYPES_XML].keywords = g_new(gchar*, 7);
1300         get_keyfile_keywords(config, config_home, "html", GEANY_FILETYPES_XML, 0);
1301         get_keyfile_keywords(config, config_home, "javascript", GEANY_FILETYPES_XML, 1);
1302         get_keyfile_keywords(config, config_home, "vbscript", GEANY_FILETYPES_XML, 2);
1303         get_keyfile_keywords(config, config_home, "python", GEANY_FILETYPES_XML, 3);
1304         get_keyfile_keywords(config, config_home, "php", GEANY_FILETYPES_XML, 4);
1305         get_keyfile_keywords(config, config_home, "sgml", GEANY_FILETYPES_XML, 5);
1306         style_sets[GEANY_FILETYPES_XML].keywords[6] = NULL;
1307 }
1308
1309
1310 static void styleset_markup(ScintillaObject *sci, gboolean set_keywords)
1311 {
1312         guint i;
1313         const gchar *keywords;
1314
1315         /* Used by several filetypes */
1316         if (style_sets[GEANY_FILETYPES_XML].styling == NULL)
1317                 filetypes_load_config(GEANY_FILETYPES_XML, FALSE);
1318
1319         /* manually initialise filetype Python for use with embedded Python */
1320         filetypes_load_config(GEANY_FILETYPES_PYTHON, FALSE);
1321
1322         /* Set keywords. If we don't want to use keywords, we must at least unset maybe previously set
1323          * keywords, e.g. when switching between filetypes. */
1324         for (i = 0; i < 5; i++)
1325         {
1326                 keywords = (set_keywords) ? style_sets[GEANY_FILETYPES_XML].keywords[i] : "";
1327                 sci_set_keywords(sci, i, keywords);
1328         }
1329         /* always set SGML keywords */
1330         sci_set_keywords(sci, 5, style_sets[GEANY_FILETYPES_XML].keywords[5]);
1331
1332         set_sci_style(sci, STYLE_DEFAULT, GEANY_FILETYPES_XML, 0);
1333         set_sci_style(sci, SCE_H_DEFAULT, GEANY_FILETYPES_XML, 0);
1334         set_sci_style(sci, SCE_H_TAG, GEANY_FILETYPES_XML, 1);
1335         set_sci_style(sci, SCE_H_TAGUNKNOWN, GEANY_FILETYPES_XML, 2);
1336         set_sci_style(sci, SCE_H_ATTRIBUTE, GEANY_FILETYPES_XML, 3);
1337         set_sci_style(sci, SCE_H_ATTRIBUTEUNKNOWN, GEANY_FILETYPES_XML, 4);
1338         set_sci_style(sci, SCE_H_NUMBER, GEANY_FILETYPES_XML, 5);
1339         set_sci_style(sci, SCE_H_DOUBLESTRING, GEANY_FILETYPES_XML, 6);
1340         set_sci_style(sci, SCE_H_SINGLESTRING, GEANY_FILETYPES_XML, 7);
1341         set_sci_style(sci, SCE_H_OTHER, GEANY_FILETYPES_XML, 8);
1342         set_sci_style(sci, SCE_H_COMMENT, GEANY_FILETYPES_XML, 9);
1343         set_sci_style(sci, SCE_H_ENTITY, GEANY_FILETYPES_XML, 10);
1344         set_sci_style(sci, SCE_H_TAGEND, GEANY_FILETYPES_XML, 11);
1345         SSM(sci, SCI_STYLESETEOLFILLED, SCE_H_XMLSTART, 1);
1346         set_sci_style(sci, SCE_H_XMLSTART, GEANY_FILETYPES_XML, 12);
1347         set_sci_style(sci, SCE_H_XMLEND, GEANY_FILETYPES_XML, 13);
1348         set_sci_style(sci, SCE_H_SCRIPT, GEANY_FILETYPES_XML, 14);
1349         SSM(sci, SCI_STYLESETEOLFILLED, SCE_H_ASP, 1);
1350         set_sci_style(sci, SCE_H_ASP, GEANY_FILETYPES_XML, 15);
1351         SSM(sci, SCI_STYLESETEOLFILLED, SCE_H_ASPAT, 1);
1352         set_sci_style(sci, SCE_H_ASPAT, GEANY_FILETYPES_XML, 16);
1353         set_sci_style(sci, SCE_H_CDATA, GEANY_FILETYPES_XML, 17);
1354         set_sci_style(sci, SCE_H_QUESTION, GEANY_FILETYPES_XML, 18);
1355         set_sci_style(sci, SCE_H_VALUE, GEANY_FILETYPES_XML, 19);
1356         set_sci_style(sci, SCE_H_XCCOMMENT, GEANY_FILETYPES_XML, 20);
1357
1358         set_sci_style(sci, SCE_H_SGML_DEFAULT, GEANY_FILETYPES_XML, 21);
1359         set_sci_style(sci, SCE_H_SGML_COMMENT, GEANY_FILETYPES_XML, 22);
1360         set_sci_style(sci, SCE_H_SGML_SPECIAL, GEANY_FILETYPES_XML, 23);
1361         set_sci_style(sci, SCE_H_SGML_COMMAND, GEANY_FILETYPES_XML, 24);
1362         set_sci_style(sci, SCE_H_SGML_DOUBLESTRING, GEANY_FILETYPES_XML, 25);
1363         set_sci_style(sci, SCE_H_SGML_SIMPLESTRING, GEANY_FILETYPES_XML, 26);
1364         set_sci_style(sci, SCE_H_SGML_1ST_PARAM, GEANY_FILETYPES_XML, 27);
1365         set_sci_style(sci, SCE_H_SGML_ENTITY, GEANY_FILETYPES_XML, 28);
1366         set_sci_style(sci, SCE_H_SGML_BLOCK_DEFAULT, GEANY_FILETYPES_XML, 29);
1367         set_sci_style(sci, SCE_H_SGML_1ST_PARAM_COMMENT, GEANY_FILETYPES_XML, 30);
1368         set_sci_style(sci, SCE_H_SGML_ERROR, GEANY_FILETYPES_XML, 31);
1369
1370         /* embedded JavaScript */
1371         set_sci_style(sci, SCE_HJ_START, GEANY_FILETYPES_XML, 43);
1372         set_sci_style(sci, SCE_HJ_DEFAULT, GEANY_FILETYPES_XML, 44);
1373         set_sci_style(sci, SCE_HJ_COMMENT, GEANY_FILETYPES_XML, 45);
1374         set_sci_style(sci, SCE_HJ_COMMENTLINE, GEANY_FILETYPES_XML, 46);
1375         set_sci_style(sci, SCE_HJ_COMMENTDOC, GEANY_FILETYPES_XML, 47);
1376         set_sci_style(sci, SCE_HJ_NUMBER, GEANY_FILETYPES_XML, 48);
1377         set_sci_style(sci, SCE_HJ_WORD, GEANY_FILETYPES_XML, 49);
1378         set_sci_style(sci, SCE_HJ_KEYWORD, GEANY_FILETYPES_XML, 50);
1379         set_sci_style(sci, SCE_HJ_DOUBLESTRING, GEANY_FILETYPES_XML, 51);
1380         set_sci_style(sci, SCE_HJ_SINGLESTRING, GEANY_FILETYPES_XML, 52);
1381         set_sci_style(sci, SCE_HJ_SYMBOLS, GEANY_FILETYPES_XML, 53);
1382         set_sci_style(sci, SCE_HJ_STRINGEOL, GEANY_FILETYPES_XML, 54);
1383         set_sci_style(sci, SCE_HJ_REGEX, GEANY_FILETYPES_XML, 55);
1384
1385         /* for HB, VBScript?, use the same styles as for JavaScript */
1386         set_sci_style(sci, SCE_HB_START, GEANY_FILETYPES_XML, 43);
1387         set_sci_style(sci, SCE_HB_DEFAULT, GEANY_FILETYPES_XML, 44);
1388         set_sci_style(sci, SCE_HB_COMMENTLINE, GEANY_FILETYPES_XML, 46);
1389         set_sci_style(sci, SCE_HB_NUMBER, GEANY_FILETYPES_XML, 48);
1390         set_sci_style(sci, SCE_HB_WORD, GEANY_FILETYPES_XML, 50);       /* keywords */
1391         set_sci_style(sci, SCE_HB_STRING, GEANY_FILETYPES_XML, 51);
1392         set_sci_style(sci, SCE_HB_IDENTIFIER, GEANY_FILETYPES_XML, 53);
1393         set_sci_style(sci, SCE_HB_STRINGEOL, GEANY_FILETYPES_XML, 54);
1394
1395         /* for HBA, VBScript?, use the same styles as for JavaScript */
1396         set_sci_style(sci, SCE_HBA_START, GEANY_FILETYPES_XML, 43);
1397         set_sci_style(sci, SCE_HBA_DEFAULT, GEANY_FILETYPES_XML, 44);
1398         set_sci_style(sci, SCE_HBA_COMMENTLINE, GEANY_FILETYPES_XML, 46);
1399         set_sci_style(sci, SCE_HBA_NUMBER, GEANY_FILETYPES_XML, 48);
1400         set_sci_style(sci, SCE_HBA_WORD, GEANY_FILETYPES_XML, 50);      /* keywords */
1401         set_sci_style(sci, SCE_HBA_STRING, GEANY_FILETYPES_XML, 51);
1402         set_sci_style(sci, SCE_HBA_IDENTIFIER, GEANY_FILETYPES_XML, 53);
1403         set_sci_style(sci, SCE_HBA_STRINGEOL, GEANY_FILETYPES_XML, 54);
1404
1405         /* for HJA, ASP Javascript, use the same styles as for JavaScript */
1406         set_sci_style(sci, SCE_HJA_START, GEANY_FILETYPES_XML, 43);
1407         set_sci_style(sci, SCE_HJA_DEFAULT, GEANY_FILETYPES_XML, 44);
1408         set_sci_style(sci, SCE_HJA_COMMENT, GEANY_FILETYPES_XML, 45);
1409         set_sci_style(sci, SCE_HJA_COMMENTLINE, GEANY_FILETYPES_XML, 46);
1410         set_sci_style(sci, SCE_HJA_COMMENTDOC, GEANY_FILETYPES_XML, 47);
1411         set_sci_style(sci, SCE_HJA_NUMBER, GEANY_FILETYPES_XML, 48);
1412         set_sci_style(sci, SCE_HJA_WORD, GEANY_FILETYPES_XML, 49);
1413         set_sci_style(sci, SCE_HJA_KEYWORD, GEANY_FILETYPES_XML, 50);
1414         set_sci_style(sci, SCE_HJA_DOUBLESTRING, GEANY_FILETYPES_XML, 51);
1415         set_sci_style(sci, SCE_HJA_SINGLESTRING, GEANY_FILETYPES_XML, 52);
1416         set_sci_style(sci, SCE_HJA_SYMBOLS, GEANY_FILETYPES_XML, 53);
1417         set_sci_style(sci, SCE_HJA_STRINGEOL, GEANY_FILETYPES_XML, 54);
1418
1419         /* for embedded Python we use the Python styles */
1420         set_sci_style(sci, SCE_HP_START, GEANY_FILETYPES_XML, 43);
1421         set_sci_style(sci, SCE_HP_DEFAULT, GEANY_FILETYPES_PYTHON, 0);
1422         set_sci_style(sci, SCE_HP_COMMENTLINE, GEANY_FILETYPES_PYTHON, 1);
1423         set_sci_style(sci, SCE_HP_NUMBER, GEANY_FILETYPES_PYTHON, 2);
1424         set_sci_style(sci, SCE_HP_STRING, GEANY_FILETYPES_PYTHON, 3);
1425         set_sci_style(sci, SCE_HP_CHARACTER, GEANY_FILETYPES_PYTHON, 4);
1426         set_sci_style(sci, SCE_HP_WORD, GEANY_FILETYPES_PYTHON, 5);
1427         set_sci_style(sci, SCE_HP_TRIPLE, GEANY_FILETYPES_PYTHON, 6);
1428         set_sci_style(sci, SCE_HP_TRIPLEDOUBLE, GEANY_FILETYPES_PYTHON, 7);
1429         set_sci_style(sci, SCE_HP_CLASSNAME, GEANY_FILETYPES_PYTHON, 8);
1430         set_sci_style(sci, SCE_HP_DEFNAME, GEANY_FILETYPES_PYTHON, 9);
1431         set_sci_style(sci, SCE_HP_OPERATOR, GEANY_FILETYPES_PYTHON, 10);
1432         set_sci_style(sci, SCE_HP_IDENTIFIER, GEANY_FILETYPES_PYTHON, 11);
1433
1434         /* for embedded HPA (what is this?) we use the Python styles */
1435         set_sci_style(sci, SCE_HPA_START, GEANY_FILETYPES_XML, 43);
1436         set_sci_style(sci, SCE_HPA_DEFAULT, GEANY_FILETYPES_PYTHON, 0);
1437         set_sci_style(sci, SCE_HPA_COMMENTLINE, GEANY_FILETYPES_PYTHON, 1);
1438         set_sci_style(sci, SCE_HPA_NUMBER, GEANY_FILETYPES_PYTHON, 2);
1439         set_sci_style(sci, SCE_HPA_STRING, GEANY_FILETYPES_PYTHON, 3);
1440         set_sci_style(sci, SCE_HPA_CHARACTER, GEANY_FILETYPES_PYTHON, 4);
1441         set_sci_style(sci, SCE_HPA_WORD, GEANY_FILETYPES_PYTHON, 5);
1442         set_sci_style(sci, SCE_HPA_TRIPLE, GEANY_FILETYPES_PYTHON, 6);
1443         set_sci_style(sci, SCE_HPA_TRIPLEDOUBLE, GEANY_FILETYPES_PYTHON, 7);
1444         set_sci_style(sci, SCE_HPA_CLASSNAME, GEANY_FILETYPES_PYTHON, 8);
1445         set_sci_style(sci, SCE_HPA_DEFNAME, GEANY_FILETYPES_PYTHON, 9);
1446         set_sci_style(sci, SCE_HPA_OPERATOR, GEANY_FILETYPES_PYTHON, 10);
1447         set_sci_style(sci, SCE_HPA_IDENTIFIER, GEANY_FILETYPES_PYTHON, 11);
1448
1449         /* PHP */
1450         set_sci_style(sci, SCE_HPHP_DEFAULT, GEANY_FILETYPES_XML, 32);
1451         set_sci_style(sci, SCE_HPHP_SIMPLESTRING, GEANY_FILETYPES_XML, 33);
1452         set_sci_style(sci, SCE_HPHP_HSTRING, GEANY_FILETYPES_XML, 34);
1453         set_sci_style(sci, SCE_HPHP_NUMBER, GEANY_FILETYPES_XML, 35);
1454         set_sci_style(sci, SCE_HPHP_WORD, GEANY_FILETYPES_XML, 36);
1455         set_sci_style(sci, SCE_HPHP_VARIABLE, GEANY_FILETYPES_XML, 37);
1456         set_sci_style(sci, SCE_HPHP_COMMENT, GEANY_FILETYPES_XML, 38);
1457         set_sci_style(sci, SCE_HPHP_COMMENTLINE, GEANY_FILETYPES_XML, 39);
1458         set_sci_style(sci, SCE_HPHP_OPERATOR, GEANY_FILETYPES_XML, 40);
1459         set_sci_style(sci, SCE_HPHP_HSTRING_VARIABLE, GEANY_FILETYPES_XML, 41);
1460         set_sci_style(sci, SCE_HPHP_COMPLEX_VARIABLE, GEANY_FILETYPES_XML, 42);
1461
1462         /* note: normally this would be in the filetype file instead */
1463         sci_set_property(sci, "fold.html", "1");
1464         sci_set_property(sci, "fold.html.preprocessor", "0");
1465 }
1466
1467
1468 static void styleset_java_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1469 {
1470         styleset_c_like_init(config, config_home, ft_id);
1471
1472         style_sets[ft_id].keywords = g_new(gchar*, 5);
1473         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1474         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
1475         get_keyfile_keywords(config, config_home, "doccomment", ft_id, 2);
1476         get_keyfile_keywords(config, config_home, "typedefs", ft_id, 3);
1477         style_sets[ft_id].keywords[4] = NULL;
1478 }
1479
1480
1481 static void styleset_java(ScintillaObject *sci, gint ft_id)
1482 {
1483         styleset_c_like(sci, ft_id, SCLEX_CPP);
1484
1485         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1486         /* SCI_SETKEYWORDS = 1 - secondary + global tags file types, see below */
1487         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
1488         /* SCI_SETKEYWORDS = 3 is for current session types - see editor_lexer_get_type_keyword_idx() */
1489         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[3]);
1490
1491         /* assign global types, merge them with user defined keywords and set them */
1492         merge_type_keywords(sci, ft_id, 1);
1493 }
1494
1495
1496 static void styleset_perl_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1497 {
1498         new_styleset(ft_id, 35);
1499         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1500         get_keyfile_style(config, config_home, "error", &style_sets[ft_id].styling[1]);
1501         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[2]);
1502         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
1503         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[4]);
1504         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[5]);
1505         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[6]);
1506         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[7]);
1507         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[8]);
1508         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[9]);
1509         get_keyfile_style(config, config_home, "scalar", &style_sets[ft_id].styling[10]);
1510         get_keyfile_style(config, config_home, "pod", &style_sets[ft_id].styling[11]);
1511         get_keyfile_style(config, config_home, "regex", &style_sets[ft_id].styling[12]);
1512         get_keyfile_style(config, config_home, "array", &style_sets[ft_id].styling[13]);
1513         get_keyfile_style(config, config_home, "hash", &style_sets[ft_id].styling[14]);
1514         get_keyfile_style(config, config_home, "symboltable", &style_sets[ft_id].styling[15]);
1515         get_keyfile_style(config, config_home, "backticks", &style_sets[ft_id].styling[16]);
1516         get_keyfile_style(config, config_home, "pod_verbatim", &style_sets[ft_id].styling[17]);
1517         get_keyfile_style(config, config_home, "reg_subst", &style_sets[ft_id].styling[18]);
1518         get_keyfile_style(config, config_home, "datasection", &style_sets[ft_id].styling[19]);
1519         get_keyfile_style(config, config_home, "here_delim", &style_sets[ft_id].styling[20]);
1520         get_keyfile_style(config, config_home, "here_q", &style_sets[ft_id].styling[21]);
1521         get_keyfile_style(config, config_home, "here_qq", &style_sets[ft_id].styling[22]);
1522         get_keyfile_style(config, config_home, "here_qx", &style_sets[ft_id].styling[23]);
1523         get_keyfile_style(config, config_home, "string_q", &style_sets[ft_id].styling[24]);
1524         get_keyfile_style(config, config_home, "string_qq", &style_sets[ft_id].styling[25]);
1525         get_keyfile_style(config, config_home, "string_qx", &style_sets[ft_id].styling[26]);
1526         get_keyfile_style(config, config_home, "string_qr", &style_sets[ft_id].styling[27]);
1527         get_keyfile_style(config, config_home, "string_qw", &style_sets[ft_id].styling[28]);
1528         get_keyfile_style(config, config_home, "variable_indexer", &style_sets[ft_id].styling[29]);
1529         get_keyfile_style(config, config_home, "punctuation", &style_sets[ft_id].styling[30]);
1530         get_keyfile_style(config, config_home, "longquote", &style_sets[ft_id].styling[31]);
1531         get_keyfile_style(config, config_home, "sub_prototype", &style_sets[ft_id].styling[32]);
1532         get_keyfile_style(config, config_home, "format_ident", &style_sets[ft_id].styling[33]);
1533         get_keyfile_style(config, config_home, "format", &style_sets[ft_id].styling[34]);
1534
1535
1536         style_sets[ft_id].keywords = g_new(gchar*, 2);
1537         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1538         style_sets[ft_id].keywords[1] = NULL;
1539 }
1540
1541
1542 static void styleset_perl(ScintillaObject *sci, gint ft_id)
1543 {
1544         apply_filetype_properties(sci, SCLEX_PERL, ft_id);
1545
1546         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1547
1548         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1549         set_sci_style(sci, SCE_PL_DEFAULT, ft_id, 0);
1550         set_sci_style(sci, SCE_PL_ERROR, ft_id, 1);
1551         set_sci_style(sci, SCE_PL_COMMENTLINE, ft_id, 2);
1552         set_sci_style(sci, SCE_PL_NUMBER, ft_id, 3);
1553         set_sci_style(sci, SCE_PL_WORD, ft_id, 4);
1554         set_sci_style(sci, SCE_PL_STRING, ft_id, 5);
1555         set_sci_style(sci, SCE_PL_CHARACTER, ft_id, 6);
1556         set_sci_style(sci, SCE_PL_PREPROCESSOR, ft_id, 7);
1557         set_sci_style(sci, SCE_PL_OPERATOR, ft_id, 8);
1558         set_sci_style(sci, SCE_PL_IDENTIFIER, ft_id, 9);
1559         set_sci_style(sci, SCE_PL_SCALAR, ft_id, 10);
1560         set_sci_style(sci, SCE_PL_POD, ft_id, 11);
1561         set_sci_style(sci, SCE_PL_REGEX, ft_id, 12);
1562         set_sci_style(sci, SCE_PL_ARRAY, ft_id, 13);
1563         set_sci_style(sci, SCE_PL_HASH, ft_id, 14);
1564         set_sci_style(sci, SCE_PL_SYMBOLTABLE, ft_id, 15);
1565         set_sci_style(sci, SCE_PL_BACKTICKS, ft_id, 16);
1566         set_sci_style(sci, SCE_PL_POD_VERB, ft_id, 17);
1567         set_sci_style(sci, SCE_PL_REGSUBST, ft_id, 18);
1568         set_sci_style(sci, SCE_PL_DATASECTION, ft_id, 19);
1569         set_sci_style(sci, SCE_PL_HERE_DELIM, ft_id, 20);
1570         set_sci_style(sci, SCE_PL_HERE_Q, ft_id, 21);
1571         set_sci_style(sci, SCE_PL_HERE_QQ, ft_id, 22);
1572         set_sci_style(sci, SCE_PL_HERE_QX, ft_id, 23);
1573         set_sci_style(sci, SCE_PL_STRING_Q, ft_id, 24);
1574         set_sci_style(sci, SCE_PL_STRING_QQ, ft_id, 25);
1575         set_sci_style(sci, SCE_PL_STRING_QX, ft_id, 26);
1576         set_sci_style(sci, SCE_PL_STRING_QR, ft_id, 27);
1577         set_sci_style(sci, SCE_PL_STRING_QW, ft_id, 28);
1578         set_sci_style(sci, SCE_PL_VARIABLE_INDEXER, ft_id, 29);
1579         set_sci_style(sci, SCE_PL_PUNCTUATION, ft_id, 30);
1580         set_sci_style(sci, SCE_PL_LONGQUOTE, ft_id, 31);
1581         set_sci_style(sci, SCE_PL_SUB_PROTOTYPE, ft_id, 32);
1582         set_sci_style(sci, SCE_PL_FORMAT_IDENT, ft_id, 33);
1583         set_sci_style(sci, SCE_PL_FORMAT, ft_id, 34);
1584 }
1585
1586
1587 static void styleset_python_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1588 {
1589         new_styleset(ft_id, 16);
1590         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1591         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[1]);
1592         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
1593         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[3]);
1594         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[4]);
1595         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[5]);
1596         get_keyfile_style(config, config_home, "triple", &style_sets[ft_id].styling[6]);
1597         get_keyfile_style(config, config_home, "tripledouble", &style_sets[ft_id].styling[7]);
1598         get_keyfile_style(config, config_home, "classname", &style_sets[ft_id].styling[8]);
1599         get_keyfile_style(config, config_home, "defname", &style_sets[ft_id].styling[9]);
1600         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
1601         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[11]);
1602         get_keyfile_style(config, config_home, "commentblock", &style_sets[ft_id].styling[12]);
1603         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[13]);
1604         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[14]);
1605         get_keyfile_style(config, config_home, "decorator", &style_sets[ft_id].styling[15]);
1606
1607         style_sets[ft_id].keywords = g_new(gchar*, 3);
1608         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1609         get_keyfile_keywords(config, config_home, "identifiers", ft_id, 1);
1610         style_sets[ft_id].keywords[2] = NULL;
1611 }
1612
1613
1614 static void styleset_python(ScintillaObject *sci, gint ft_id)
1615 {
1616         apply_filetype_properties(sci, SCLEX_PYTHON, ft_id);
1617
1618         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1619         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1620
1621         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1622         set_sci_style(sci, SCE_P_DEFAULT, ft_id, 0);
1623         set_sci_style(sci, SCE_P_COMMENTLINE, ft_id, 1);
1624         set_sci_style(sci, SCE_P_NUMBER, ft_id, 2);
1625         set_sci_style(sci, SCE_P_STRING, ft_id, 3);
1626         set_sci_style(sci, SCE_P_CHARACTER, ft_id, 4);
1627         set_sci_style(sci, SCE_P_WORD, ft_id, 5);
1628         set_sci_style(sci, SCE_P_TRIPLE, ft_id, 6);
1629         set_sci_style(sci, SCE_P_TRIPLEDOUBLE, ft_id, 7);
1630         set_sci_style(sci, SCE_P_CLASSNAME, ft_id, 8);
1631         set_sci_style(sci, SCE_P_DEFNAME, ft_id, 9);
1632         set_sci_style(sci, SCE_P_OPERATOR, ft_id, 10);
1633         set_sci_style(sci, SCE_P_IDENTIFIER, ft_id, 11);
1634         set_sci_style(sci, SCE_P_COMMENTBLOCK, ft_id, 12);
1635         set_sci_style(sci, SCE_P_STRINGEOL, ft_id, 13);
1636         set_sci_style(sci, SCE_P_WORD2, ft_id, 14);
1637         set_sci_style(sci, SCE_P_DECORATOR, ft_id, 15);
1638 }
1639
1640
1641 static void styleset_cmake_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1642 {
1643         new_styleset(ft_id, 15);
1644         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1645         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
1646         get_keyfile_style(config, config_home, "stringdq", &style_sets[ft_id].styling[2]);
1647         get_keyfile_style(config, config_home, "stringlq", &style_sets[ft_id].styling[3]);
1648         get_keyfile_style(config, config_home, "stringrq", &style_sets[ft_id].styling[4]);
1649         get_keyfile_style(config, config_home, "command", &style_sets[ft_id].styling[5]);
1650         get_keyfile_style(config, config_home, "parameters", &style_sets[ft_id].styling[6]);
1651         get_keyfile_style(config, config_home, "variable", &style_sets[ft_id].styling[7]);
1652         get_keyfile_style(config, config_home, "userdefined", &style_sets[ft_id].styling[8]);
1653         get_keyfile_style(config, config_home, "whiledef", &style_sets[ft_id].styling[9]);
1654         get_keyfile_style(config, config_home, "foreachdef", &style_sets[ft_id].styling[10]);
1655         get_keyfile_style(config, config_home, "ifdefinedef", &style_sets[ft_id].styling[11]);
1656         get_keyfile_style(config, config_home, "macrodef", &style_sets[ft_id].styling[12]);
1657         get_keyfile_style(config, config_home, "stringvar", &style_sets[ft_id].styling[13]);
1658         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[14]);
1659
1660         style_sets[ft_id].keywords = g_new(gchar*, 4);
1661         get_keyfile_keywords(config, config_home, "commands", ft_id, 0);
1662         get_keyfile_keywords(config, config_home, "parameters", ft_id, 1);
1663         get_keyfile_keywords(config, config_home, "userdefined", ft_id, 2);
1664         style_sets[ft_id].keywords[3] = NULL;
1665 }
1666
1667
1668 static void styleset_cmake(ScintillaObject *sci, gint ft_id)
1669 {
1670         apply_filetype_properties(sci, SCLEX_CMAKE, ft_id);
1671
1672         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1673         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1674         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
1675
1676         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1677         set_sci_style(sci, SCE_CMAKE_DEFAULT, ft_id, 0);
1678         set_sci_style(sci, SCE_CMAKE_COMMENT, ft_id, 1);
1679         set_sci_style(sci, SCE_CMAKE_STRINGDQ, ft_id, 2);
1680         set_sci_style(sci, SCE_CMAKE_STRINGLQ, ft_id, 3);
1681         set_sci_style(sci, SCE_CMAKE_STRINGRQ, ft_id, 4);
1682         set_sci_style(sci, SCE_CMAKE_COMMANDS, ft_id, 5);
1683         set_sci_style(sci, SCE_CMAKE_PARAMETERS, ft_id, 6);
1684         set_sci_style(sci, SCE_CMAKE_VARIABLE, ft_id, 7);
1685         set_sci_style(sci, SCE_CMAKE_USERDEFINED, ft_id, 8);
1686         set_sci_style(sci, SCE_CMAKE_WHILEDEF, ft_id, 9);
1687         set_sci_style(sci, SCE_CMAKE_FOREACHDEF, ft_id, 10);
1688         set_sci_style(sci, SCE_CMAKE_IFDEFINEDEF, ft_id, 11);
1689         set_sci_style(sci, SCE_CMAKE_MACRODEF, ft_id, 12);
1690         set_sci_style(sci, SCE_CMAKE_STRINGVAR, ft_id, 13);
1691         set_sci_style(sci, SCE_CMAKE_NUMBER, ft_id, 14);
1692 }
1693
1694
1695 static void styleset_cobol_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1696 {
1697         styleset_c_like_init(config, config_home, ft_id);
1698
1699         style_sets[ft_id].keywords = g_new(gchar*, 4);
1700         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1701         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
1702         get_keyfile_keywords(config, config_home, "extended_keywords", ft_id, 2);
1703         style_sets[ft_id].keywords[3] = NULL;
1704 }
1705
1706
1707 static void styleset_cobol(ScintillaObject *sci, gint ft_id)
1708 {
1709         styleset_c_like(sci, ft_id, SCLEX_COBOL);
1710
1711         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1712         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1713         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
1714 }
1715
1716
1717 static void styleset_r_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1718 {
1719         new_styleset(ft_id, 12);
1720
1721         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1722         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
1723         get_keyfile_style(config, config_home, "kword", &style_sets[ft_id].styling[2]);
1724         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[3]);
1725         get_keyfile_style(config, config_home, "basekword", &style_sets[ft_id].styling[4]);
1726         get_keyfile_style(config, config_home, "otherkword", &style_sets[ft_id].styling[5]);
1727         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[6]);
1728         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[7]);
1729         get_keyfile_style(config, config_home, "string2", &style_sets[ft_id].styling[8]);
1730         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[9]);
1731         get_keyfile_style(config, config_home, "infix", &style_sets[ft_id].styling[10]);
1732         get_keyfile_style(config, config_home, "infixeol", &style_sets[ft_id].styling[11]);
1733
1734         style_sets[ft_id].keywords = g_new(gchar*, 4);
1735         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1736         get_keyfile_keywords(config, config_home, "package", ft_id, 1);
1737         get_keyfile_keywords(config, config_home, "package_other", ft_id, 2);
1738         style_sets[ft_id].keywords[3] = NULL;
1739 }
1740
1741
1742 static void styleset_r(ScintillaObject *sci, gint ft_id)
1743 {
1744         apply_filetype_properties(sci, SCLEX_R, ft_id);
1745
1746         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1747         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
1748         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
1749
1750         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1751         set_sci_style(sci, SCE_R_DEFAULT, ft_id, 0);
1752         set_sci_style(sci, SCE_R_COMMENT, ft_id, 1);
1753         set_sci_style(sci, SCE_R_KWORD, ft_id, 2);
1754         set_sci_style(sci, SCE_R_OPERATOR, ft_id, 3);
1755         set_sci_style(sci, SCE_R_BASEKWORD, ft_id, 4);
1756         set_sci_style(sci, SCE_R_OTHERKWORD, ft_id, 5);
1757         set_sci_style(sci, SCE_R_NUMBER, ft_id, 6);
1758         set_sci_style(sci, SCE_R_STRING, ft_id, 7);
1759         set_sci_style(sci, SCE_R_STRING2, ft_id, 8);
1760         set_sci_style(sci, SCE_R_IDENTIFIER, ft_id, 9);
1761         set_sci_style(sci, SCE_R_INFIX, ft_id, 10);
1762         set_sci_style(sci, SCE_R_INFIXEOL, ft_id, 11);
1763 }
1764
1765
1766 static void styleset_ruby_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1767 {
1768         new_styleset(ft_id, 35);
1769         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1770         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[1]);
1771         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
1772         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[3]);
1773         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[4]);
1774         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[5]);
1775         get_keyfile_style(config, config_home, "global", &style_sets[ft_id].styling[6]);
1776         get_keyfile_style(config, config_home, "symbol", &style_sets[ft_id].styling[7]);
1777         get_keyfile_style(config, config_home, "classname", &style_sets[ft_id].styling[8]);
1778         get_keyfile_style(config, config_home, "defname", &style_sets[ft_id].styling[9]);
1779         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
1780         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[11]);
1781         get_keyfile_style(config, config_home, "modulename", &style_sets[ft_id].styling[12]);
1782         get_keyfile_style(config, config_home, "backticks", &style_sets[ft_id].styling[13]);
1783         get_keyfile_style(config, config_home, "instancevar", &style_sets[ft_id].styling[14]);
1784         get_keyfile_style(config, config_home, "classvar", &style_sets[ft_id].styling[15]);
1785         get_keyfile_style(config, config_home, "datasection", &style_sets[ft_id].styling[16]);
1786         get_keyfile_style(config, config_home, "heredelim", &style_sets[ft_id].styling[17]);
1787         get_keyfile_style(config, config_home, "worddemoted", &style_sets[ft_id].styling[18]);
1788         get_keyfile_style(config, config_home, "stdin", &style_sets[ft_id].styling[19]);
1789         get_keyfile_style(config, config_home, "stdout", &style_sets[ft_id].styling[20]);
1790         get_keyfile_style(config, config_home, "stderr", &style_sets[ft_id].styling[21]);
1791         get_keyfile_style(config, config_home, "datasection", &style_sets[ft_id].styling[22]);
1792         get_keyfile_style(config, config_home, "regex", &style_sets[ft_id].styling[23]);
1793         get_keyfile_style(config, config_home, "here_q", &style_sets[ft_id].styling[24]);
1794         get_keyfile_style(config, config_home, "here_qq", &style_sets[ft_id].styling[25]);
1795         get_keyfile_style(config, config_home, "here_qx", &style_sets[ft_id].styling[26]);
1796         get_keyfile_style(config, config_home, "string_q", &style_sets[ft_id].styling[27]);
1797         get_keyfile_style(config, config_home, "string_qq", &style_sets[ft_id].styling[28]);
1798         get_keyfile_style(config, config_home, "string_qx", &style_sets[ft_id].styling[29]);
1799         get_keyfile_style(config, config_home, "string_qr", &style_sets[ft_id].styling[30]);
1800         get_keyfile_style(config, config_home, "string_qw", &style_sets[ft_id].styling[31]);
1801         get_keyfile_style(config, config_home, "upper_bound", &style_sets[ft_id].styling[32]);
1802         get_keyfile_style(config, config_home, "error", &style_sets[ft_id].styling[33]);
1803         get_keyfile_style(config, config_home, "pod", &style_sets[ft_id].styling[34]);
1804
1805         style_sets[ft_id].keywords = g_new(gchar*, 2);
1806         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1807         style_sets[ft_id].keywords[1] = NULL;
1808 }
1809
1810
1811 static void styleset_ruby(ScintillaObject *sci, gint ft_id)
1812 {
1813         apply_filetype_properties(sci, SCLEX_RUBY, ft_id);
1814
1815         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1816
1817         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1818         set_sci_style(sci, SCE_RB_DEFAULT, ft_id, 0);
1819         set_sci_style(sci, SCE_RB_COMMENTLINE, ft_id, 1);
1820         set_sci_style(sci, SCE_RB_NUMBER, ft_id, 2);
1821         set_sci_style(sci, SCE_RB_STRING, ft_id, 3);
1822         set_sci_style(sci, SCE_RB_CHARACTER, ft_id, 4);
1823         set_sci_style(sci, SCE_RB_WORD, ft_id, 5);
1824         set_sci_style(sci, SCE_RB_GLOBAL, ft_id, 6);
1825         set_sci_style(sci, SCE_RB_SYMBOL, ft_id, 7);
1826         set_sci_style(sci, SCE_RB_CLASSNAME, ft_id, 8);
1827         set_sci_style(sci, SCE_RB_DEFNAME, ft_id, 9);
1828         set_sci_style(sci, SCE_RB_OPERATOR, ft_id, 10);
1829         set_sci_style(sci, SCE_RB_IDENTIFIER, ft_id, 11);
1830         set_sci_style(sci, SCE_RB_MODULE_NAME, ft_id, 12);
1831         set_sci_style(sci, SCE_RB_BACKTICKS, ft_id, 13);
1832         set_sci_style(sci, SCE_RB_INSTANCE_VAR, ft_id, 14);
1833         set_sci_style(sci, SCE_RB_CLASS_VAR, ft_id, 15);
1834         set_sci_style(sci, SCE_RB_DATASECTION, ft_id, 16);
1835         set_sci_style(sci, SCE_RB_HERE_DELIM, ft_id, 17);
1836         set_sci_style(sci, SCE_RB_WORD_DEMOTED, ft_id, 18);
1837         set_sci_style(sci, SCE_RB_STDIN, ft_id, 19);
1838         set_sci_style(sci, SCE_RB_STDOUT, ft_id, 20);
1839         set_sci_style(sci, SCE_RB_STDERR, ft_id, 21);
1840         set_sci_style(sci, SCE_RB_DATASECTION, ft_id, 22);
1841         set_sci_style(sci, SCE_RB_REGEX, ft_id, 23);
1842         set_sci_style(sci, SCE_RB_HERE_Q, ft_id, 24);
1843         set_sci_style(sci, SCE_RB_HERE_QQ, ft_id, 25);
1844         set_sci_style(sci, SCE_RB_HERE_QX, ft_id, 26);
1845         set_sci_style(sci, SCE_RB_STRING_Q, ft_id, 27);
1846         set_sci_style(sci, SCE_RB_STRING_QQ, ft_id, 28);
1847         set_sci_style(sci, SCE_RB_STRING_QX, ft_id, 29);
1848         set_sci_style(sci, SCE_RB_STRING_QR, ft_id, 30);
1849         set_sci_style(sci, SCE_RB_STRING_QW, ft_id, 31);
1850         set_sci_style(sci, SCE_RB_UPPER_BOUND, ft_id, 32);
1851         set_sci_style(sci, SCE_RB_ERROR, ft_id, 33);
1852         set_sci_style(sci, SCE_RB_POD, ft_id, 34);
1853 }
1854
1855
1856 static void styleset_sh_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1857 {
1858         new_styleset(ft_id, 14);
1859         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1860         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[1]);
1861         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
1862         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[3]);
1863         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[4]);
1864         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[5]);
1865         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[6]);
1866         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[7]);
1867         get_keyfile_style(config, config_home, "backticks", &style_sets[ft_id].styling[8]);
1868         get_keyfile_style(config, config_home, "param", &style_sets[ft_id].styling[9]);
1869         get_keyfile_style(config, config_home, "scalar", &style_sets[ft_id].styling[10]);
1870         get_keyfile_style(config, config_home, "error", &style_sets[ft_id].styling[11]);
1871         get_keyfile_style(config, config_home, "here_delim", &style_sets[ft_id].styling[12]);
1872         get_keyfile_style(config, config_home, "here_q", &style_sets[ft_id].styling[13]);
1873
1874         style_sets[ft_id].keywords = g_new(gchar*, 2);
1875         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
1876         style_sets[ft_id].keywords[1] = NULL;
1877 }
1878
1879
1880 static void styleset_sh(ScintillaObject *sci, gint ft_id)
1881 {
1882         apply_filetype_properties(sci, SCLEX_BASH, ft_id);
1883
1884         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1885
1886         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1887         set_sci_style(sci, SCE_SH_DEFAULT, ft_id, 0);
1888         set_sci_style(sci, SCE_SH_COMMENTLINE, ft_id, 1);
1889         set_sci_style(sci, SCE_SH_NUMBER, ft_id, 2);
1890         set_sci_style(sci, SCE_SH_WORD, ft_id, 3);
1891         set_sci_style(sci, SCE_SH_STRING, ft_id, 4);
1892         set_sci_style(sci, SCE_SH_CHARACTER, ft_id, 5);
1893         set_sci_style(sci, SCE_SH_OPERATOR, ft_id, 6);
1894         set_sci_style(sci, SCE_SH_IDENTIFIER, ft_id, 7);
1895         set_sci_style(sci, SCE_SH_BACKTICKS, ft_id, 8);
1896         set_sci_style(sci, SCE_SH_PARAM, ft_id, 9);
1897         set_sci_style(sci, SCE_SH_SCALAR, ft_id, 10);
1898         set_sci_style(sci, SCE_SH_ERROR, ft_id, 11);
1899         set_sci_style(sci, SCE_SH_HERE_DELIM, ft_id, 12);
1900         set_sci_style(sci, SCE_SH_HERE_Q, ft_id, 13);
1901 }
1902
1903
1904 static void styleset_xml(ScintillaObject *sci, gint ft_id)
1905 {
1906         apply_filetype_properties(sci, SCLEX_XML, ft_id);
1907
1908         /* use the same colouring for HTML; XML and so on */
1909         styleset_markup(sci, FALSE);
1910 }
1911
1912
1913 static void styleset_docbook_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
1914 {
1915         new_styleset(ft_id, 29);
1916         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
1917         get_keyfile_style(config, config_home, "tag", &style_sets[ft_id].styling[1]);
1918         get_keyfile_style(config, config_home, "tagunknown", &style_sets[ft_id].styling[2]);
1919         get_keyfile_style(config, config_home, "attribute", &style_sets[ft_id].styling[3]);
1920         get_keyfile_style(config, config_home, "attributeunknown", &style_sets[ft_id].styling[4]);
1921         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[5]);
1922         get_keyfile_style(config, config_home, "doublestring", &style_sets[ft_id].styling[6]);
1923         get_keyfile_style(config, config_home, "singlestring", &style_sets[ft_id].styling[7]);
1924         get_keyfile_style(config, config_home, "other", &style_sets[ft_id].styling[8]);
1925         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[9]);
1926         get_keyfile_style(config, config_home, "entity", &style_sets[ft_id].styling[10]);
1927         get_keyfile_style(config, config_home, "tagend", &style_sets[ft_id].styling[11]);
1928         get_keyfile_style(config, config_home, "xmlstart", &style_sets[ft_id].styling[12]);
1929         get_keyfile_style(config, config_home, "xmlend", &style_sets[ft_id].styling[13]);
1930         get_keyfile_style(config, config_home, "cdata", &style_sets[ft_id].styling[14]);
1931         get_keyfile_style(config, config_home, "question", &style_sets[ft_id].styling[15]);
1932         get_keyfile_style(config, config_home, "value", &style_sets[ft_id].styling[16]);
1933         get_keyfile_style(config, config_home, "xccomment", &style_sets[ft_id].styling[17]);
1934         get_keyfile_style(config, config_home, "sgml_default", &style_sets[ft_id].styling[18]);
1935         get_keyfile_style(config, config_home, "sgml_comment", &style_sets[ft_id].styling[19]);
1936         get_keyfile_style(config, config_home, "sgml_special", &style_sets[ft_id].styling[20]);
1937         get_keyfile_style(config, config_home, "sgml_command", &style_sets[ft_id].styling[21]);
1938         get_keyfile_style(config, config_home, "sgml_doublestring", &style_sets[ft_id].styling[22]);
1939         get_keyfile_style(config, config_home, "sgml_simplestring", &style_sets[ft_id].styling[23]);
1940         get_keyfile_style(config, config_home, "sgml_1st_param", &style_sets[ft_id].styling[24]);
1941         get_keyfile_style(config, config_home, "sgml_entity", &style_sets[ft_id].styling[25]);
1942         get_keyfile_style(config, config_home, "sgml_block_default", &style_sets[ft_id].styling[26]);
1943         get_keyfile_style(config, config_home, "sgml_1st_param_comment", &style_sets[ft_id].styling[27]);
1944         get_keyfile_style(config, config_home, "sgml_error", &style_sets[ft_id].styling[28]);
1945
1946         style_sets[ft_id].keywords = g_new(gchar*, 3);
1947         get_keyfile_keywords(config, config_home, "elements", ft_id, 0);
1948         get_keyfile_keywords(config, config_home, "dtd", ft_id, 1);
1949         style_sets[ft_id].keywords[2] = NULL;
1950 }
1951
1952
1953 static void styleset_docbook(ScintillaObject *sci, gint ft_id)
1954 {
1955         apply_filetype_properties(sci, SCLEX_XML, ft_id);
1956
1957         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
1958         sci_set_keywords(sci, 5, style_sets[ft_id].keywords[1]);
1959
1960         /* Unknown tags and attributes are highlighed in red.
1961          * If a tag is actually OK, it should be added in lower case to the htmlKeyWords string. */
1962
1963         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
1964         set_sci_style(sci, SCE_H_DEFAULT, ft_id, 0);
1965         set_sci_style(sci, SCE_H_TAG, ft_id, 1);
1966         set_sci_style(sci, SCE_H_TAGUNKNOWN, ft_id, 2);
1967         set_sci_style(sci, SCE_H_ATTRIBUTE, ft_id, 3);
1968         set_sci_style(sci, SCE_H_ATTRIBUTEUNKNOWN, ft_id, 4);
1969         set_sci_style(sci, SCE_H_NUMBER, ft_id, 5);
1970         set_sci_style(sci, SCE_H_DOUBLESTRING, ft_id, 6);
1971         set_sci_style(sci, SCE_H_SINGLESTRING, ft_id, 7);
1972         set_sci_style(sci, SCE_H_OTHER, ft_id, 8);
1973         set_sci_style(sci, SCE_H_COMMENT, ft_id, 9);
1974         set_sci_style(sci, SCE_H_ENTITY, ft_id, 10);
1975         set_sci_style(sci, SCE_H_TAGEND, ft_id, 11);
1976         SSM(sci, SCI_STYLESETEOLFILLED, SCE_H_XMLSTART, 1);
1977         set_sci_style(sci, SCE_H_XMLSTART, ft_id, 12);
1978         set_sci_style(sci, SCE_H_XMLEND, ft_id, 13);
1979         set_sci_style(sci, SCE_H_CDATA, ft_id, 14);
1980         set_sci_style(sci, SCE_H_QUESTION, ft_id, 15);
1981         set_sci_style(sci, SCE_H_VALUE, ft_id, 16);
1982         set_sci_style(sci, SCE_H_XCCOMMENT, ft_id, 17);
1983         set_sci_style(sci, SCE_H_SGML_DEFAULT, ft_id, 18);
1984         set_sci_style(sci, SCE_H_DEFAULT, ft_id, 19);
1985         set_sci_style(sci, SCE_H_SGML_SPECIAL, ft_id, 20);
1986         set_sci_style(sci, SCE_H_SGML_COMMAND, ft_id, 21);
1987         set_sci_style(sci, SCE_H_SGML_DOUBLESTRING, ft_id, 22);
1988         set_sci_style(sci, SCE_H_SGML_SIMPLESTRING, ft_id, 23);
1989         set_sci_style(sci, SCE_H_SGML_1ST_PARAM, ft_id, 24);
1990         set_sci_style(sci, SCE_H_SGML_ENTITY, ft_id, 25);
1991         set_sci_style(sci, SCE_H_SGML_BLOCK_DEFAULT, ft_id, 26);
1992         set_sci_style(sci, SCE_H_SGML_1ST_PARAM_COMMENT, ft_id, 27);
1993         set_sci_style(sci, SCE_H_SGML_ERROR, ft_id, 28);
1994 }
1995
1996
1997 static void styleset_default(ScintillaObject *sci, gint ft_id)
1998 {
1999         SSM(sci, SCI_SETLEXER, SCLEX_NULL, 0);
2000
2001         /* we need to set STYLE_DEFAULT before we call SCI_STYLECLEARALL in styleset_common() */
2002         set_sci_style(sci, STYLE_DEFAULT, GEANY_FILETYPES_NONE, GCS_DEFAULT);
2003
2004         styleset_common(sci, ft_id);
2005 }
2006
2007
2008 static void styleset_css_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2009 {
2010         new_styleset(ft_id, 23);
2011         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2012         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2013         get_keyfile_style(config, config_home, "tag", &style_sets[ft_id].styling[2]);
2014         get_keyfile_style(config, config_home, "class", &style_sets[ft_id].styling[3]);
2015         get_keyfile_style(config, config_home, "pseudoclass", &style_sets[ft_id].styling[4]);
2016         get_keyfile_style(config, config_home, "unknown_pseudoclass", &style_sets[ft_id].styling[5]);
2017         get_keyfile_style(config, config_home, "unknown_identifier", &style_sets[ft_id].styling[6]);
2018         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[7]);
2019         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[8]);
2020         get_keyfile_style(config, config_home, "doublestring", &style_sets[ft_id].styling[9]);
2021         get_keyfile_style(config, config_home, "singlestring", &style_sets[ft_id].styling[10]);
2022         get_keyfile_style(config, config_home, "attribute", &style_sets[ft_id].styling[11]);
2023         get_keyfile_style(config, config_home, "value", &style_sets[ft_id].styling[12]);
2024         get_keyfile_style(config, config_home, "id", &style_sets[ft_id].styling[13]);
2025         get_keyfile_style(config, config_home, "identifier2", &style_sets[ft_id].styling[14]);
2026         get_keyfile_style(config, config_home, "important", &style_sets[ft_id].styling[15]);
2027         get_keyfile_style(config, config_home, "directive", &style_sets[ft_id].styling[16]);
2028         get_keyfile_style(config, config_home, "identifier3", &style_sets[ft_id].styling[17]);
2029         get_keyfile_style(config, config_home, "pseudoelement", &style_sets[ft_id].styling[18]);
2030         get_keyfile_style(config, config_home, "extended_identifier", &style_sets[ft_id].styling[19]);
2031         get_keyfile_style(config, config_home, "extended_pseudoclass", &style_sets[ft_id].styling[20]);
2032         get_keyfile_style(config, config_home, "extended_pseudoelement", &style_sets[ft_id].styling[21]);
2033         get_keyfile_style(config, config_home, "media", &style_sets[ft_id].styling[22]);
2034
2035         style_sets[ft_id].keywords = g_new(gchar*, 9);
2036         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2037         get_keyfile_keywords(config, config_home, "pseudoclasses", ft_id, 1);
2038         get_keyfile_keywords(config, config_home, "secondary", ft_id, 2);
2039         get_keyfile_keywords(config, config_home, "css3_properties", ft_id, 3);
2040         get_keyfile_keywords(config, config_home, "pseudo_elements", ft_id, 4);
2041         get_keyfile_keywords(config, config_home, "browser_css_properties", ft_id, 5);
2042         get_keyfile_keywords(config, config_home, "browser_pseudo_classes", ft_id, 6);
2043         get_keyfile_keywords(config, config_home, "browser_pseudo_elements", ft_id, 7);
2044         style_sets[ft_id].keywords[8] = NULL;
2045 }
2046
2047
2048 static void styleset_css(ScintillaObject *sci, gint ft_id)
2049 {
2050         guint i;
2051
2052         apply_filetype_properties(sci, SCLEX_CSS, ft_id);
2053
2054         for (i = 0; i < 8; i++)
2055         {
2056                 sci_set_keywords(sci, i, style_sets[ft_id].keywords[i]);
2057         }
2058
2059         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2060         set_sci_style(sci, SCE_CSS_DEFAULT, ft_id, 0);
2061         set_sci_style(sci, SCE_CSS_COMMENT, ft_id, 1);
2062         set_sci_style(sci, SCE_CSS_TAG, ft_id, 2);
2063         set_sci_style(sci, SCE_CSS_CLASS, ft_id, 3);
2064         set_sci_style(sci, SCE_CSS_PSEUDOCLASS, ft_id, 4);
2065         set_sci_style(sci, SCE_CSS_UNKNOWN_PSEUDOCLASS, ft_id, 5);
2066         set_sci_style(sci, SCE_CSS_UNKNOWN_IDENTIFIER, ft_id, 6);
2067         set_sci_style(sci, SCE_CSS_OPERATOR, ft_id, 7);
2068         set_sci_style(sci, SCE_CSS_IDENTIFIER, ft_id, 8);
2069         set_sci_style(sci, SCE_CSS_DOUBLESTRING, ft_id, 9);
2070         set_sci_style(sci, SCE_CSS_SINGLESTRING, ft_id, 10);
2071         set_sci_style(sci, SCE_CSS_ATTRIBUTE, ft_id, 11);
2072         set_sci_style(sci, SCE_CSS_VALUE, ft_id, 12);
2073         set_sci_style(sci, SCE_CSS_ID, ft_id, 13);
2074         set_sci_style(sci, SCE_CSS_IDENTIFIER2, ft_id, 14);
2075         set_sci_style(sci, SCE_CSS_IMPORTANT, ft_id, 15);
2076         set_sci_style(sci, SCE_CSS_DIRECTIVE, ft_id, 16);
2077         set_sci_style(sci, SCE_CSS_IDENTIFIER3, ft_id, 17);
2078         set_sci_style(sci, SCE_CSS_PSEUDOELEMENT, ft_id, 18);
2079         set_sci_style(sci, SCE_CSS_EXTENDED_IDENTIFIER, ft_id, 19);
2080         set_sci_style(sci, SCE_CSS_EXTENDED_PSEUDOCLASS, ft_id, 20);
2081         set_sci_style(sci, SCE_CSS_EXTENDED_PSEUDOELEMENT, ft_id, 21);
2082         set_sci_style(sci, SCE_CSS_MEDIA, ft_id, 22);
2083 }
2084
2085
2086 static void styleset_nsis_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2087 {
2088         new_styleset(ft_id, 19);
2089         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2090         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2091         get_keyfile_style(config, config_home, "stringdq", &style_sets[ft_id].styling[2]);
2092         get_keyfile_style(config, config_home, "stringlq", &style_sets[ft_id].styling[3]);
2093         get_keyfile_style(config, config_home, "stringrq", &style_sets[ft_id].styling[4]);
2094         get_keyfile_style(config, config_home, "function", &style_sets[ft_id].styling[5]);
2095         get_keyfile_style(config, config_home, "variable", &style_sets[ft_id].styling[6]);
2096         get_keyfile_style(config, config_home, "label", &style_sets[ft_id].styling[7]);
2097         get_keyfile_style(config, config_home, "userdefined", &style_sets[ft_id].styling[8]);
2098         get_keyfile_style(config, config_home, "sectiondef", &style_sets[ft_id].styling[9]);
2099         get_keyfile_style(config, config_home, "subsectiondef", &style_sets[ft_id].styling[10]);
2100         get_keyfile_style(config, config_home, "ifdefinedef", &style_sets[ft_id].styling[11]);
2101         get_keyfile_style(config, config_home, "macrodef", &style_sets[ft_id].styling[12]);
2102         get_keyfile_style(config, config_home, "stringvar", &style_sets[ft_id].styling[13]);
2103         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[14]);
2104         get_keyfile_style(config, config_home, "sectiongroup", &style_sets[ft_id].styling[15]);
2105         get_keyfile_style(config, config_home, "pageex", &style_sets[ft_id].styling[16]);
2106         get_keyfile_style(config, config_home, "functiondef", &style_sets[ft_id].styling[17]);
2107         get_keyfile_style(config, config_home, "commentbox", &style_sets[ft_id].styling[18]);
2108
2109         style_sets[ft_id].keywords = g_new(gchar*, 5);
2110         get_keyfile_keywords(config, config_home, "functions", ft_id, 0);
2111         get_keyfile_keywords(config, config_home, "variables", ft_id, 1);
2112         get_keyfile_keywords(config, config_home, "lables", ft_id, 2);
2113         get_keyfile_keywords(config, config_home, "userdefined", ft_id, 3);
2114         style_sets[ft_id].keywords[4] = NULL;
2115 }
2116
2117
2118 static void styleset_nsis(ScintillaObject *sci, gint ft_id)
2119 {
2120         apply_filetype_properties(sci, SCLEX_NSIS, ft_id);
2121
2122         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2123         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2124         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2125         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
2126
2127         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2128         set_sci_style(sci, SCE_NSIS_DEFAULT, ft_id, 0);
2129         set_sci_style(sci, SCE_NSIS_COMMENT, ft_id, 1);
2130         set_sci_style(sci, SCE_NSIS_STRINGDQ, ft_id, 2);
2131         set_sci_style(sci, SCE_NSIS_STRINGLQ, ft_id, 3);
2132         set_sci_style(sci, SCE_NSIS_STRINGRQ, ft_id, 4);
2133         set_sci_style(sci, SCE_NSIS_FUNCTION, ft_id, 5);
2134         set_sci_style(sci, SCE_NSIS_VARIABLE, ft_id, 6);
2135         set_sci_style(sci, SCE_NSIS_LABEL, ft_id, 7);
2136         set_sci_style(sci, SCE_NSIS_USERDEFINED, ft_id, 8);
2137         set_sci_style(sci, SCE_NSIS_SECTIONDEF, ft_id, 9);
2138         set_sci_style(sci, SCE_NSIS_SUBSECTIONDEF, ft_id, 10);
2139         set_sci_style(sci, SCE_NSIS_IFDEFINEDEF, ft_id, 11);
2140         set_sci_style(sci, SCE_NSIS_MACRODEF, ft_id, 12);
2141         set_sci_style(sci, SCE_NSIS_STRINGVAR, ft_id, 13);
2142         set_sci_style(sci, SCE_NSIS_NUMBER, ft_id, 14);
2143         set_sci_style(sci, SCE_NSIS_SECTIONGROUP, ft_id, 15);
2144         set_sci_style(sci, SCE_NSIS_PAGEEX, ft_id, 16);
2145         set_sci_style(sci, SCE_NSIS_FUNCTIONDEF, ft_id, 17);
2146         set_sci_style(sci, SCE_NSIS_COMMENTBOX, ft_id, 18);
2147 }
2148
2149
2150 static void styleset_po_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2151 {
2152         new_styleset(ft_id, 9);
2153         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2154         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2155         get_keyfile_style(config, config_home, "msgid", &style_sets[ft_id].styling[2]);
2156         get_keyfile_style(config, config_home, "msgid_text", &style_sets[ft_id].styling[3]);
2157         get_keyfile_style(config, config_home, "msgstr", &style_sets[ft_id].styling[4]);
2158         get_keyfile_style(config, config_home, "msgstr_text", &style_sets[ft_id].styling[5]);
2159         get_keyfile_style(config, config_home, "msgctxt", &style_sets[ft_id].styling[6]);
2160         get_keyfile_style(config, config_home, "msgctxt_text", &style_sets[ft_id].styling[7]);
2161         get_keyfile_style(config, config_home, "fuzzy", &style_sets[ft_id].styling[8]);
2162
2163         style_sets[ft_id].keywords = NULL;
2164 }
2165
2166
2167 static void styleset_po(ScintillaObject *sci, gint ft_id)
2168 {
2169         apply_filetype_properties(sci, SCLEX_PO, ft_id);
2170
2171         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2172         set_sci_style(sci, SCE_PO_DEFAULT, ft_id, 0);
2173         set_sci_style(sci, SCE_PO_COMMENT, ft_id, 1);
2174         set_sci_style(sci, SCE_PO_MSGID, ft_id, 2);
2175         set_sci_style(sci, SCE_PO_MSGID_TEXT, ft_id, 3);
2176         set_sci_style(sci, SCE_PO_MSGSTR, ft_id, 4);
2177         set_sci_style(sci, SCE_PO_MSGSTR_TEXT, ft_id, 5);
2178         set_sci_style(sci, SCE_PO_MSGCTXT, ft_id, 6);
2179         set_sci_style(sci, SCE_PO_MSGCTXT_TEXT, ft_id, 7);
2180         set_sci_style(sci, SCE_PO_FUZZY, ft_id, 8);
2181 }
2182
2183
2184 static void styleset_conf_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2185 {
2186         new_styleset(ft_id, 6);
2187         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2188         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2189         get_keyfile_style(config, config_home, "section", &style_sets[ft_id].styling[2]);
2190         get_keyfile_style(config, config_home, "key", &style_sets[ft_id].styling[3]);
2191         get_keyfile_style(config, config_home, "assignment", &style_sets[ft_id].styling[4]);
2192         get_keyfile_style(config, config_home, "defval", &style_sets[ft_id].styling[5]);
2193
2194         style_sets[ft_id].keywords = NULL;
2195 }
2196
2197
2198 static void styleset_conf(ScintillaObject *sci, gint ft_id)
2199 {
2200         apply_filetype_properties(sci, SCLEX_PROPERTIES, ft_id);
2201
2202         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2203         set_sci_style(sci, SCE_PROPS_DEFAULT, ft_id, 0);
2204         set_sci_style(sci, SCE_PROPS_COMMENT, ft_id, 1);
2205         set_sci_style(sci, SCE_PROPS_SECTION, ft_id, 2);
2206         set_sci_style(sci, SCE_PROPS_KEY, ft_id, 3);
2207         set_sci_style(sci, SCE_PROPS_ASSIGNMENT, ft_id, 4);
2208         set_sci_style(sci, SCE_PROPS_DEFVAL, ft_id, 5);
2209 }
2210
2211
2212 static void styleset_asm_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2213 {
2214         new_styleset(ft_id, 15);
2215         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2216         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2217         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
2218         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[3]);
2219         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[4]);
2220         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[5]);
2221         get_keyfile_style(config, config_home, "cpuinstruction", &style_sets[ft_id].styling[6]);
2222         get_keyfile_style(config, config_home, "mathinstruction", &style_sets[ft_id].styling[7]);
2223         get_keyfile_style(config, config_home, "register", &style_sets[ft_id].styling[8]);
2224         get_keyfile_style(config, config_home, "directive", &style_sets[ft_id].styling[9]);
2225         get_keyfile_style(config, config_home, "directiveoperand", &style_sets[ft_id].styling[10]);
2226         get_keyfile_style(config, config_home, "commentblock", &style_sets[ft_id].styling[11]);
2227         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[12]);
2228         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[13]);
2229         get_keyfile_style(config, config_home, "extinstruction", &style_sets[ft_id].styling[14]);
2230
2231         style_sets[ft_id].keywords = g_new(gchar*, 4);
2232         get_keyfile_keywords(config, config_home, "instructions", ft_id, 0);
2233         get_keyfile_keywords(config, config_home, "registers", ft_id, 1);
2234         get_keyfile_keywords(config, config_home, "directives", ft_id, 2);
2235         style_sets[ft_id].keywords[3] = NULL;
2236 }
2237
2238
2239 static void styleset_asm(ScintillaObject *sci, gint ft_id)
2240 {
2241         apply_filetype_properties(sci, SCLEX_ASM, ft_id);
2242
2243         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2244         /*sci_set_keywords(sci, 1, style_sets[ft_id].keywords[0]);*/
2245         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[1]);
2246         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[2]);
2247         /*sci_set_keywords(sci, 5, style_sets[ft_id].keywords[0]);*/
2248
2249         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2250         set_sci_style(sci, SCE_ASM_DEFAULT, ft_id, 0);
2251         set_sci_style(sci, SCE_ASM_COMMENT, ft_id, 1);
2252         set_sci_style(sci, SCE_ASM_NUMBER, ft_id, 2);
2253         set_sci_style(sci, SCE_ASM_STRING, ft_id, 3);
2254         set_sci_style(sci, SCE_ASM_OPERATOR, ft_id, 4);
2255         set_sci_style(sci, SCE_ASM_IDENTIFIER, ft_id, 5);
2256         set_sci_style(sci, SCE_ASM_CPUINSTRUCTION, ft_id, 6);
2257         set_sci_style(sci, SCE_ASM_MATHINSTRUCTION, ft_id, 7);
2258         set_sci_style(sci, SCE_ASM_REGISTER, ft_id, 8);
2259         set_sci_style(sci, SCE_ASM_DIRECTIVE, ft_id, 9);
2260         set_sci_style(sci, SCE_ASM_DIRECTIVEOPERAND, ft_id, 10);
2261         set_sci_style(sci, SCE_ASM_COMMENTBLOCK, ft_id, 11);
2262         set_sci_style(sci, SCE_ASM_CHARACTER, ft_id, 12);
2263         set_sci_style(sci, SCE_ASM_STRINGEOL, ft_id, 13);
2264         set_sci_style(sci, SCE_ASM_EXTINSTRUCTION, ft_id, 14);
2265 }
2266
2267
2268 static void styleset_f77_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2269 {
2270         new_styleset(ft_id, 15);
2271         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2272         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2273         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
2274         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[3]);
2275         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[4]);
2276         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[5]);
2277         get_keyfile_style(config, config_home, "string2", &style_sets[ft_id].styling[6]);
2278         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[7]);
2279         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[8]);
2280         get_keyfile_style(config, config_home, "word3", &style_sets[ft_id].styling[9]);
2281         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[10]);
2282         get_keyfile_style(config, config_home, "operator2", &style_sets[ft_id].styling[11]);
2283         get_keyfile_style(config, config_home, "continuation", &style_sets[ft_id].styling[12]);
2284         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[13]);
2285         get_keyfile_style(config, config_home, "label", &style_sets[ft_id].styling[14]);
2286
2287         style_sets[ft_id].keywords = g_new(gchar*, 4);
2288         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2289         get_keyfile_keywords(config, config_home, "intrinsic_functions", ft_id, 1);
2290         get_keyfile_keywords(config, config_home, "user_functions", ft_id, 2);
2291         style_sets[ft_id].keywords[3] = NULL;
2292 }
2293
2294
2295 static void styleset_f77(ScintillaObject *sci, gint ft_id)
2296 {
2297         apply_filetype_properties(sci, SCLEX_F77, ft_id);
2298
2299         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2300         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2301         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2302
2303         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2304         set_sci_style(sci, SCE_F_DEFAULT, ft_id, 0);
2305         set_sci_style(sci, SCE_F_COMMENT, ft_id, 1);
2306         set_sci_style(sci, SCE_F_NUMBER, ft_id, 2);
2307         set_sci_style(sci, SCE_F_STRING1, ft_id, 3);
2308         set_sci_style(sci, SCE_F_OPERATOR, ft_id, 4);
2309         set_sci_style(sci, SCE_F_IDENTIFIER, ft_id, 5);
2310         set_sci_style(sci, SCE_F_STRING2, ft_id, 6);
2311         set_sci_style(sci, SCE_F_WORD, ft_id, 7);
2312         set_sci_style(sci, SCE_F_WORD2, ft_id, 8);
2313         set_sci_style(sci, SCE_F_WORD3, ft_id, 9);
2314         set_sci_style(sci, SCE_F_PREPROCESSOR, ft_id, 10);
2315         set_sci_style(sci, SCE_F_OPERATOR2, ft_id, 11);
2316         set_sci_style(sci, SCE_F_CONTINUATION, ft_id, 12);
2317         set_sci_style(sci, SCE_F_STRINGEOL, ft_id, 13);
2318         set_sci_style(sci, SCE_F_LABEL, ft_id, 14);
2319 }
2320
2321
2322 static void styleset_forth_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2323 {
2324         new_styleset(ft_id, 12);
2325
2326         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2327         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2328         get_keyfile_style(config, config_home, "commentml", &style_sets[ft_id].styling[2]);
2329         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[3]);
2330         get_keyfile_style(config, config_home, "control", &style_sets[ft_id].styling[4]);
2331         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[5]);
2332         get_keyfile_style(config, config_home, "defword", &style_sets[ft_id].styling[6]);
2333         get_keyfile_style(config, config_home, "preword1", &style_sets[ft_id].styling[7]);
2334         get_keyfile_style(config, config_home, "preword2", &style_sets[ft_id].styling[8]);
2335         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[9]);
2336         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[10]);
2337         get_keyfile_style(config, config_home, "locale", &style_sets[ft_id].styling[11]);
2338
2339         style_sets[ft_id].keywords = g_new(gchar*, 2);
2340         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2341         style_sets[ft_id].keywords[1] = NULL;
2342
2343 }
2344
2345
2346 static void styleset_forth(ScintillaObject *sci, gint ft_id)
2347 {
2348         apply_filetype_properties(sci, SCLEX_FORTH, ft_id);
2349
2350         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2351
2352         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2353         set_sci_style(sci, SCE_FORTH_DEFAULT, ft_id, 0);
2354         set_sci_style(sci, SCE_FORTH_COMMENT, ft_id, 1);
2355         set_sci_style(sci, SCE_FORTH_COMMENT_ML, ft_id, 2);
2356         set_sci_style(sci, SCE_FORTH_IDENTIFIER, ft_id, 3);
2357         set_sci_style(sci, SCE_FORTH_CONTROL, ft_id, 4);
2358         set_sci_style(sci, SCE_FORTH_KEYWORD, ft_id, 5);
2359         set_sci_style(sci, SCE_FORTH_DEFWORD, ft_id, 6);
2360         set_sci_style(sci, SCE_FORTH_PREWORD1, ft_id, 7);
2361         set_sci_style(sci, SCE_FORTH_PREWORD2, ft_id, 8);
2362         set_sci_style(sci, SCE_FORTH_NUMBER, ft_id, 9);
2363         set_sci_style(sci, SCE_FORTH_STRING, ft_id, 10);
2364         set_sci_style(sci, SCE_FORTH_LOCALE, ft_id, 11);
2365 }
2366
2367
2368 static void styleset_fortran_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2369 {
2370         new_styleset(ft_id, 15);
2371         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2372         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2373         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
2374         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[3]);
2375         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[4]);
2376         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[5]);
2377         get_keyfile_style(config, config_home, "string2", &style_sets[ft_id].styling[6]);
2378         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[7]);
2379         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[8]);
2380         get_keyfile_style(config, config_home, "word3", &style_sets[ft_id].styling[9]);
2381         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[10]);
2382         get_keyfile_style(config, config_home, "operator2", &style_sets[ft_id].styling[11]);
2383         get_keyfile_style(config, config_home, "continuation", &style_sets[ft_id].styling[12]);
2384         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[13]);
2385         get_keyfile_style(config, config_home, "label", &style_sets[ft_id].styling[14]);
2386
2387         style_sets[ft_id].keywords = g_new(gchar*, 4);
2388         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2389         get_keyfile_keywords(config, config_home, "intrinsic_functions", ft_id, 1);
2390         get_keyfile_keywords(config, config_home, "user_functions", ft_id, 2);
2391         style_sets[ft_id].keywords[3] = NULL;
2392 }
2393
2394
2395 static void styleset_fortran(ScintillaObject *sci, gint ft_id)
2396 {
2397         apply_filetype_properties(sci, SCLEX_FORTRAN, ft_id);
2398
2399         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2400         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2401         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2402
2403         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2404         set_sci_style(sci, SCE_F_DEFAULT, ft_id, 0);
2405         set_sci_style(sci, SCE_F_COMMENT, ft_id, 1);
2406         set_sci_style(sci, SCE_F_NUMBER, ft_id, 2);
2407         set_sci_style(sci, SCE_F_STRING1, ft_id, 3);
2408         set_sci_style(sci, SCE_F_OPERATOR, ft_id, 4);
2409         set_sci_style(sci, SCE_F_IDENTIFIER, ft_id, 5);
2410         set_sci_style(sci, SCE_F_STRING2, ft_id, 6);
2411         set_sci_style(sci, SCE_F_WORD, ft_id, 7);
2412         set_sci_style(sci, SCE_F_WORD2, ft_id, 8);
2413         set_sci_style(sci, SCE_F_WORD3, ft_id, 9);
2414         set_sci_style(sci, SCE_F_PREPROCESSOR, ft_id, 10);
2415         set_sci_style(sci, SCE_F_OPERATOR2, ft_id, 11);
2416         set_sci_style(sci, SCE_F_CONTINUATION, ft_id, 12);
2417         set_sci_style(sci, SCE_F_STRINGEOL, ft_id, 13);
2418         set_sci_style(sci, SCE_F_LABEL, ft_id, 14);
2419 }
2420
2421
2422 static void styleset_sql_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2423 {
2424         new_styleset(ft_id, 15);
2425         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2426         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2427         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[2]);
2428         get_keyfile_style(config, config_home, "commentdoc", &style_sets[ft_id].styling[3]);
2429         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[4]);
2430         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[5]);
2431         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[6]);
2432         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[7]);
2433         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[8]);
2434         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[9]);
2435         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[10]);
2436         get_keyfile_style(config, config_home, "sqlplus", &style_sets[ft_id].styling[11]);
2437         get_keyfile_style(config, config_home, "sqlplus_prompt", &style_sets[ft_id].styling[12]);
2438         get_keyfile_style(config, config_home, "sqlplus_comment", &style_sets[ft_id].styling[13]);
2439         get_keyfile_style(config, config_home, "quotedidentifier", &style_sets[ft_id].styling[14]);
2440
2441         style_sets[ft_id].keywords = g_new(gchar*, 2);
2442         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
2443         style_sets[ft_id].keywords[1] = NULL;
2444 }
2445
2446
2447 static void styleset_sql(ScintillaObject *sci, gint ft_id)
2448 {
2449         apply_filetype_properties(sci, SCLEX_SQL, ft_id);
2450
2451         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2452
2453         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2454         set_sci_style(sci, SCE_SQL_DEFAULT, ft_id, 0);
2455         set_sci_style(sci, SCE_SQL_COMMENT, ft_id, 1);
2456         set_sci_style(sci, SCE_SQL_COMMENTLINE, ft_id, 2);
2457         set_sci_style(sci, SCE_SQL_COMMENTDOC, ft_id, 3);
2458         set_sci_style(sci, SCE_SQL_NUMBER, ft_id, 4);
2459         set_sci_style(sci, SCE_SQL_WORD, ft_id, 5);
2460         set_sci_style(sci, SCE_SQL_WORD2, ft_id, 6);
2461         set_sci_style(sci, SCE_SQL_STRING, ft_id, 7);
2462         set_sci_style(sci, SCE_SQL_CHARACTER, ft_id, 8);
2463         set_sci_style(sci, SCE_SQL_OPERATOR, ft_id, 9);
2464         set_sci_style(sci, SCE_SQL_IDENTIFIER, ft_id, 10);
2465         set_sci_style(sci, SCE_SQL_SQLPLUS, ft_id, 11);
2466         set_sci_style(sci, SCE_SQL_SQLPLUS_PROMPT, ft_id, 12);
2467         set_sci_style(sci, SCE_SQL_SQLPLUS_COMMENT, ft_id, 13);
2468         set_sci_style(sci, SCE_SQL_QUOTEDIDENTIFIER, ft_id, 14);
2469 }
2470
2471
2472 static void styleset_markdown_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2473 {
2474         new_styleset(ft_id, 17);
2475
2476         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2477         get_keyfile_style(config, config_home, "strong", &style_sets[ft_id].styling[1]);
2478         get_keyfile_style(config, config_home, "emphasis", &style_sets[ft_id].styling[2]);
2479         get_keyfile_style(config, config_home, "header1", &style_sets[ft_id].styling[3]);
2480         get_keyfile_style(config, config_home, "header2", &style_sets[ft_id].styling[4]);
2481         get_keyfile_style(config, config_home, "header3", &style_sets[ft_id].styling[5]);
2482         get_keyfile_style(config, config_home, "header4", &style_sets[ft_id].styling[6]);
2483         get_keyfile_style(config, config_home, "header5", &style_sets[ft_id].styling[7]);
2484         get_keyfile_style(config, config_home, "header6", &style_sets[ft_id].styling[8]);
2485         get_keyfile_style(config, config_home, "ulist_item", &style_sets[ft_id].styling[9]);
2486         get_keyfile_style(config, config_home, "olist_item", &style_sets[ft_id].styling[10]);
2487         get_keyfile_style(config, config_home, "blockquote", &style_sets[ft_id].styling[11]);
2488         get_keyfile_style(config, config_home, "strikeout", &style_sets[ft_id].styling[12]);
2489         get_keyfile_style(config, config_home, "hrule", &style_sets[ft_id].styling[13]);
2490         get_keyfile_style(config, config_home, "link", &style_sets[ft_id].styling[14]);
2491         get_keyfile_style(config, config_home, "code", &style_sets[ft_id].styling[15]);
2492         get_keyfile_style(config, config_home, "codebk", &style_sets[ft_id].styling[16]);
2493
2494         style_sets[ft_id].keywords = NULL;
2495 }
2496
2497
2498 static void styleset_markdown(ScintillaObject *sci, gint ft_id)
2499 {
2500         apply_filetype_properties(sci, SCLEX_MARKDOWN, ft_id);
2501
2502         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2503         set_sci_style(sci, SCE_MARKDOWN_DEFAULT, ft_id, 0);
2504         set_sci_style(sci, SCE_MARKDOWN_LINE_BEGIN, ft_id, 0);
2505         set_sci_style(sci, SCE_MARKDOWN_PRECHAR, ft_id, 0);
2506         set_sci_style(sci, SCE_MARKDOWN_STRONG1, ft_id, 1);
2507         set_sci_style(sci, SCE_MARKDOWN_STRONG2, ft_id, 1);
2508         set_sci_style(sci, SCE_MARKDOWN_EM1, ft_id, 2);
2509         set_sci_style(sci, SCE_MARKDOWN_EM2, ft_id, 2);
2510         set_sci_style(sci, SCE_MARKDOWN_HEADER1, ft_id, 3);
2511         set_sci_style(sci, SCE_MARKDOWN_HEADER2, ft_id, 4);
2512         set_sci_style(sci, SCE_MARKDOWN_HEADER3, ft_id, 5);
2513         set_sci_style(sci, SCE_MARKDOWN_HEADER4, ft_id, 6);
2514         set_sci_style(sci, SCE_MARKDOWN_HEADER5, ft_id, 7);
2515         set_sci_style(sci, SCE_MARKDOWN_HEADER6, ft_id, 8);
2516         set_sci_style(sci, SCE_MARKDOWN_ULIST_ITEM, ft_id, 9);
2517         set_sci_style(sci, SCE_MARKDOWN_OLIST_ITEM, ft_id, 10);
2518         set_sci_style(sci, SCE_MARKDOWN_BLOCKQUOTE, ft_id, 11);
2519         set_sci_style(sci, SCE_MARKDOWN_STRIKEOUT, ft_id, 12);
2520         set_sci_style(sci, SCE_MARKDOWN_HRULE, ft_id, 13);
2521         set_sci_style(sci, SCE_MARKDOWN_LINK, ft_id, 14);
2522         set_sci_style(sci, SCE_MARKDOWN_CODE, ft_id, 15);
2523         set_sci_style(sci, SCE_MARKDOWN_CODE2, ft_id, 15);
2524         set_sci_style(sci, SCE_MARKDOWN_CODEBK, ft_id, 16);
2525 }
2526
2527
2528 static void styleset_haskell_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2529 {
2530         new_styleset(ft_id, 17);
2531
2532         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2533         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[1]);
2534         get_keyfile_style(config, config_home, "commentblock", &style_sets[ft_id].styling[2]);
2535         get_keyfile_style(config, config_home, "commentblock2", &style_sets[ft_id].styling[3]);
2536         get_keyfile_style(config, config_home, "commentblock3", &style_sets[ft_id].styling[4]);
2537         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[5]);
2538         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[6]);
2539         get_keyfile_style(config, config_home, "import", &style_sets[ft_id].styling[7]);
2540         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[8]);
2541         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[9]);
2542         get_keyfile_style(config, config_home, "class", &style_sets[ft_id].styling[10]);
2543         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[11]);
2544         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[12]);
2545         get_keyfile_style(config, config_home, "instance", &style_sets[ft_id].styling[13]);
2546         get_keyfile_style(config, config_home, "capital", &style_sets[ft_id].styling[14]);
2547         get_keyfile_style(config, config_home, "module", &style_sets[ft_id].styling[15]);
2548         get_keyfile_style(config, config_home, "data", &style_sets[ft_id].styling[16]);
2549
2550         style_sets[ft_id].keywords = g_new(gchar*, 2);
2551         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
2552         style_sets[ft_id].keywords[1] = NULL;
2553 }
2554
2555
2556 static void styleset_haskell(ScintillaObject *sci, gint ft_id)
2557 {
2558         apply_filetype_properties(sci, SCLEX_HASKELL, ft_id);
2559
2560         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2561
2562         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2563         set_sci_style(sci, SCE_HA_DEFAULT, ft_id, 0);
2564         set_sci_style(sci, SCE_HA_COMMENTLINE, ft_id, 1);
2565         set_sci_style(sci, SCE_HA_COMMENTBLOCK, ft_id, 2);
2566         set_sci_style(sci, SCE_HA_COMMENTBLOCK2, ft_id, 3);
2567         set_sci_style(sci, SCE_HA_COMMENTBLOCK3, ft_id, 4);
2568         set_sci_style(sci, SCE_HA_NUMBER, ft_id, 5);
2569         set_sci_style(sci, SCE_HA_KEYWORD, ft_id, 6);
2570         set_sci_style(sci, SCE_HA_IMPORT, ft_id, 7);
2571         set_sci_style(sci, SCE_HA_STRING, ft_id, 8);
2572         set_sci_style(sci, SCE_HA_CHARACTER, ft_id, 9);
2573         set_sci_style(sci, SCE_HA_CLASS, ft_id, 10);
2574         set_sci_style(sci, SCE_HA_OPERATOR, ft_id, 11);
2575         set_sci_style(sci, SCE_HA_IDENTIFIER, ft_id, 12);
2576         set_sci_style(sci, SCE_HA_INSTANCE, ft_id, 13);
2577         set_sci_style(sci, SCE_HA_CAPITAL, ft_id, 14);
2578         set_sci_style(sci, SCE_HA_MODULE, ft_id, 15);
2579         set_sci_style(sci, SCE_HA_DATA, ft_id, 16);
2580 }
2581
2582
2583 static void styleset_caml_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2584 {
2585         new_styleset(ft_id, 14);
2586
2587         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2588         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2589         get_keyfile_style(config, config_home, "comment1", &style_sets[ft_id].styling[2]);
2590         get_keyfile_style(config, config_home, "comment2", &style_sets[ft_id].styling[3]);
2591         get_keyfile_style(config, config_home, "comment3", &style_sets[ft_id].styling[4]);
2592         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[5]);
2593         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[6]);
2594         get_keyfile_style(config, config_home, "keyword2", &style_sets[ft_id].styling[7]);
2595         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[8]);
2596         get_keyfile_style(config, config_home, "char", &style_sets[ft_id].styling[9]);
2597         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
2598         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[11]);
2599         get_keyfile_style(config, config_home, "tagname", &style_sets[ft_id].styling[12]);
2600         get_keyfile_style(config, config_home, "linenum", &style_sets[ft_id].styling[13]);
2601
2602         style_sets[ft_id].keywords = g_new(gchar*, 3);
2603         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
2604         get_keyfile_keywords(config, config_home, "keywords_optional", ft_id, 1);
2605         style_sets[ft_id].keywords[2] = NULL;
2606 }
2607
2608
2609 static void styleset_caml(ScintillaObject *sci, gint ft_id)
2610 {
2611         apply_filetype_properties(sci, SCLEX_CAML, ft_id);
2612
2613         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2614         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2615
2616         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2617         set_sci_style(sci, SCE_CAML_DEFAULT, ft_id, 0);
2618         set_sci_style(sci, SCE_CAML_COMMENT, ft_id, 1);
2619         set_sci_style(sci, SCE_CAML_COMMENT1, ft_id, 2);
2620         set_sci_style(sci, SCE_CAML_COMMENT2, ft_id, 3);
2621         set_sci_style(sci, SCE_CAML_COMMENT3, ft_id, 4);
2622         set_sci_style(sci, SCE_CAML_NUMBER, ft_id, 5);
2623         set_sci_style(sci, SCE_CAML_KEYWORD, ft_id, 6);
2624         set_sci_style(sci, SCE_CAML_KEYWORD2, ft_id, 7);
2625         set_sci_style(sci, SCE_CAML_STRING, ft_id, 8);
2626         set_sci_style(sci, SCE_CAML_CHAR, ft_id, 9);
2627         set_sci_style(sci, SCE_CAML_OPERATOR, ft_id, 10);
2628         set_sci_style(sci, SCE_CAML_IDENTIFIER, ft_id, 11);
2629         set_sci_style(sci, SCE_CAML_TAGNAME, ft_id, 12);
2630         set_sci_style(sci, SCE_CAML_LINENUM, ft_id, 13);
2631 }
2632
2633
2634 static void styleset_tcl_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2635 {
2636         new_styleset(ft_id, 16);
2637         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2638         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2639         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[2]);
2640         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
2641         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[4]);
2642         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[5]);
2643         get_keyfile_style(config, config_home, "wordinquote", &style_sets[ft_id].styling[6]);
2644         get_keyfile_style(config, config_home, "inquote", &style_sets[ft_id].styling[7]);
2645         get_keyfile_style(config, config_home, "substitution", &style_sets[ft_id].styling[8]);
2646         get_keyfile_style(config, config_home, "modifier", &style_sets[ft_id].styling[9]);
2647         get_keyfile_style(config, config_home, "expand", &style_sets[ft_id].styling[10]);
2648         get_keyfile_style(config, config_home, "wordtcl", &style_sets[ft_id].styling[11]);
2649         get_keyfile_style(config, config_home, "wordtk", &style_sets[ft_id].styling[12]);
2650         get_keyfile_style(config, config_home, "worditcl", &style_sets[ft_id].styling[13]);
2651         get_keyfile_style(config, config_home, "wordtkcmds", &style_sets[ft_id].styling[14]);
2652         get_keyfile_style(config, config_home, "wordexpand", &style_sets[ft_id].styling[15]);
2653
2654         style_sets[ft_id].keywords = g_new(gchar*, 6);
2655         get_keyfile_keywords(config, config_home, "tcl", ft_id, 0);
2656         get_keyfile_keywords(config, config_home, "tk", ft_id, 1);
2657         get_keyfile_keywords(config, config_home, "itcl", ft_id, 2);
2658         get_keyfile_keywords(config, config_home, "tkcommands", ft_id, 3);
2659         get_keyfile_keywords(config, config_home, "expand", ft_id, 4);
2660         style_sets[ft_id].keywords[5] = NULL;
2661 }
2662
2663
2664 static void styleset_tcl(ScintillaObject *sci, gint ft_id)
2665 {
2666         apply_filetype_properties(sci, SCLEX_TCL, ft_id);
2667
2668         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2669         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2670         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2671         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
2672         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[4]);
2673
2674         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2675         set_sci_style(sci, SCE_TCL_DEFAULT, ft_id, 0);
2676         set_sci_style(sci, SCE_TCL_COMMENT, ft_id, 1);
2677         set_sci_style(sci, SCE_TCL_COMMENTLINE, ft_id, 2);
2678         set_sci_style(sci, SCE_TCL_NUMBER, ft_id, 3);
2679         set_sci_style(sci, SCE_TCL_OPERATOR, ft_id, 4);
2680         set_sci_style(sci, SCE_TCL_IDENTIFIER, ft_id, 5);
2681         set_sci_style(sci, SCE_TCL_WORD_IN_QUOTE, ft_id, 6);
2682         set_sci_style(sci, SCE_TCL_IN_QUOTE, ft_id, 7);
2683         set_sci_style(sci, SCE_TCL_SUBSTITUTION, ft_id, 8);
2684         set_sci_style(sci, SCE_TCL_MODIFIER, ft_id, 9);
2685         set_sci_style(sci, SCE_TCL_EXPAND, ft_id, 10);
2686         set_sci_style(sci, SCE_TCL_WORD, ft_id, 11);
2687         set_sci_style(sci, SCE_TCL_WORD2, ft_id, 12);
2688         set_sci_style(sci, SCE_TCL_WORD3, ft_id, 13);
2689         set_sci_style(sci, SCE_TCL_WORD4, ft_id, 14);
2690         set_sci_style(sci, SCE_TCL_WORD5, ft_id, 15);
2691 }
2692
2693 static void styleset_txt2tags_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2694 {
2695         new_styleset(ft_id, 22);
2696
2697         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2698         get_keyfile_style(config, config_home, "strong", &style_sets[ft_id].styling[1]);
2699         get_keyfile_style(config, config_home, "emphasis", &style_sets[ft_id].styling[2]);
2700         get_keyfile_style(config, config_home, "header1", &style_sets[ft_id].styling[3]);
2701         get_keyfile_style(config, config_home, "header2", &style_sets[ft_id].styling[4]);
2702         get_keyfile_style(config, config_home, "header3", &style_sets[ft_id].styling[5]);
2703         get_keyfile_style(config, config_home, "header4", &style_sets[ft_id].styling[6]);
2704         get_keyfile_style(config, config_home, "header5", &style_sets[ft_id].styling[7]);
2705         get_keyfile_style(config, config_home, "header6", &style_sets[ft_id].styling[8]);
2706         get_keyfile_style(config, config_home, "ulist_item", &style_sets[ft_id].styling[9]);
2707         get_keyfile_style(config, config_home, "olist_item", &style_sets[ft_id].styling[10]);
2708         get_keyfile_style(config, config_home, "blockquote", &style_sets[ft_id].styling[11]);
2709         get_keyfile_style(config, config_home, "strikeout", &style_sets[ft_id].styling[12]);
2710         get_keyfile_style(config, config_home, "hrule", &style_sets[ft_id].styling[13]);
2711         get_keyfile_style(config, config_home, "link", &style_sets[ft_id].styling[14]);
2712         get_keyfile_style(config, config_home, "code", &style_sets[ft_id].styling[15]);
2713         get_keyfile_style(config, config_home, "codebk", &style_sets[ft_id].styling[16]);
2714         get_keyfile_style(config, config_home, "underlined", &style_sets[ft_id].styling[17]);
2715         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[18]);
2716         get_keyfile_style(config, config_home, "option", &style_sets[ft_id].styling[19]);
2717         get_keyfile_style(config, config_home, "preproc", &style_sets[ft_id].styling[20]);
2718         get_keyfile_style(config, config_home, "postproc", &style_sets[ft_id].styling[21]);
2719
2720         style_sets[ft_id].keywords = NULL;
2721 }
2722
2723
2724 static void styleset_txt2tags(ScintillaObject *sci, gint ft_id)
2725 {
2726         apply_filetype_properties(sci, SCLEX_TXT2TAGS, ft_id);
2727
2728         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2729         set_sci_style(sci, SCE_TXT2TAGS_DEFAULT, ft_id, 0);
2730         set_sci_style(sci, SCE_TXT2TAGS_LINE_BEGIN, ft_id, 0);
2731         set_sci_style(sci, SCE_TXT2TAGS_PRECHAR, ft_id, 0);
2732         set_sci_style(sci, SCE_TXT2TAGS_STRONG1, ft_id, 1);
2733         set_sci_style(sci, SCE_TXT2TAGS_STRONG2, ft_id, 1);
2734         set_sci_style(sci, SCE_TXT2TAGS_EM1, ft_id, 2);
2735         set_sci_style(sci, SCE_TXT2TAGS_EM2, ft_id, 17);
2736         set_sci_style(sci, SCE_TXT2TAGS_HEADER1, ft_id, 3);
2737         set_sci_style(sci, SCE_TXT2TAGS_HEADER2, ft_id, 4);
2738         set_sci_style(sci, SCE_TXT2TAGS_HEADER3, ft_id, 5);
2739         set_sci_style(sci, SCE_TXT2TAGS_HEADER4, ft_id, 6);
2740         set_sci_style(sci, SCE_TXT2TAGS_HEADER5, ft_id, 7);
2741         set_sci_style(sci, SCE_TXT2TAGS_HEADER6, ft_id, 8);
2742         set_sci_style(sci, SCE_TXT2TAGS_ULIST_ITEM, ft_id, 9);
2743         set_sci_style(sci, SCE_TXT2TAGS_OLIST_ITEM, ft_id, 10);
2744         set_sci_style(sci, SCE_TXT2TAGS_BLOCKQUOTE, ft_id, 11);
2745         set_sci_style(sci, SCE_TXT2TAGS_STRIKEOUT, ft_id, 12);
2746         set_sci_style(sci, SCE_TXT2TAGS_HRULE, ft_id, 13);
2747         set_sci_style(sci, SCE_TXT2TAGS_LINK, ft_id, 14);
2748         set_sci_style(sci, SCE_TXT2TAGS_CODE, ft_id, 15);
2749         set_sci_style(sci, SCE_TXT2TAGS_CODE2, ft_id, 15);
2750         set_sci_style(sci, SCE_TXT2TAGS_CODEBK, ft_id, 16);
2751         set_sci_style(sci, SCE_TXT2TAGS_COMMENT, ft_id, 18);
2752         set_sci_style(sci, SCE_TXT2TAGS_OPTION, ft_id, 19);
2753         set_sci_style(sci, SCE_TXT2TAGS_PREPROC, ft_id, 20);
2754         set_sci_style(sci, SCE_TXT2TAGS_POSTPROC, ft_id, 21);
2755 }
2756
2757
2758 static void styleset_matlab_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2759 {
2760         new_styleset(ft_id, 9);
2761         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2762         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2763         get_keyfile_style(config, config_home, "command", &style_sets[ft_id].styling[2]);
2764         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
2765         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[4]);
2766         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[5]);
2767         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[6]);
2768         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[7]);
2769         get_keyfile_style(config, config_home, "doublequotedstring", &style_sets[ft_id].styling[8]);
2770
2771         style_sets[ft_id].keywords = g_new(gchar*, 2);
2772         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2773         style_sets[ft_id].keywords[1] = NULL;
2774 }
2775
2776
2777 static void styleset_matlab(ScintillaObject *sci, gint ft_id)
2778 {
2779         /* We use SCLEX_OCTAVE instead of SCLEX_MATLAB to also support Octave # comment char */
2780         apply_filetype_properties(sci, SCLEX_OCTAVE, ft_id);
2781
2782         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2783
2784         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2785         set_sci_style(sci, SCE_MATLAB_DEFAULT, ft_id, 0);
2786         set_sci_style(sci, SCE_MATLAB_COMMENT, ft_id, 1);
2787         set_sci_style(sci, SCE_MATLAB_COMMAND, ft_id, 2);
2788         set_sci_style(sci, SCE_MATLAB_NUMBER, ft_id, 3);
2789         set_sci_style(sci, SCE_MATLAB_KEYWORD, ft_id, 4);
2790         set_sci_style(sci, SCE_MATLAB_STRING, ft_id, 5);
2791         set_sci_style(sci, SCE_MATLAB_OPERATOR, ft_id, 6);
2792         set_sci_style(sci, SCE_MATLAB_IDENTIFIER, ft_id, 7);
2793         set_sci_style(sci, SCE_MATLAB_DOUBLEQUOTESTRING, ft_id, 8);
2794 }
2795
2796
2797 static void styleset_d_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2798 {
2799         new_styleset(ft_id, 18);
2800
2801         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2802         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2803         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[2]);
2804         get_keyfile_style(config, config_home, "commentdoc", &style_sets[ft_id].styling[3]);
2805         get_keyfile_style(config, config_home, "commentdocnested", &style_sets[ft_id].styling[4]);
2806         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[5]);
2807         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[6]);
2808         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[7]);
2809         get_keyfile_style(config, config_home, "word3", &style_sets[ft_id].styling[8]);
2810         get_keyfile_style(config, config_home, "typedef", &style_sets[ft_id].styling[9]);
2811         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[10]);
2812         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[11]);
2813         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[12]);
2814         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[13]);
2815         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[14]);
2816         get_keyfile_style(config, config_home, "commentlinedoc", &style_sets[ft_id].styling[15]);
2817         get_keyfile_style(config, config_home, "commentdockeyword", &style_sets[ft_id].styling[16]);
2818         get_keyfile_style(config, config_home, "commentdockeyworderror", &style_sets[ft_id].styling[17]);
2819
2820         style_sets[ft_id].keywords = g_new(gchar*, 5);
2821         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2822         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
2823         get_keyfile_keywords(config, config_home, "docComment", ft_id, 2);
2824         get_keyfile_keywords(config, config_home, "types", ft_id, 3);
2825         style_sets[ft_id].keywords[4] = NULL;
2826 }
2827
2828
2829 static void styleset_d(ScintillaObject *sci, gint ft_id)
2830 {
2831         apply_filetype_properties(sci, SCLEX_D, ft_id);
2832
2833         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2834         /* SCI_SETKEYWORDS = 1 - secondary + global tags file types, see below */
2835         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2836         /* SCI_SETKEYWORDS = 3 is for current session types - see editor_lexer_get_type_keyword_idx() */
2837         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[3]);
2838
2839         /* assign global types, merge them with user defined keywords and set them */
2840         merge_type_keywords(sci, ft_id, 1);
2841
2842         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2843         set_sci_style(sci, SCE_D_DEFAULT, ft_id, 0);
2844         set_sci_style(sci, SCE_D_COMMENT, ft_id, 1);
2845         set_sci_style(sci, SCE_D_COMMENTLINE, ft_id, 2);
2846         set_sci_style(sci, SCE_D_COMMENTDOC, ft_id, 3);
2847         set_sci_style(sci, SCE_D_COMMENTNESTED, ft_id, 4);
2848         set_sci_style(sci, SCE_D_NUMBER, ft_id, 5);
2849         set_sci_style(sci, SCE_D_WORD, ft_id, 6);
2850         set_sci_style(sci, SCE_D_WORD2, ft_id, 7);
2851         set_sci_style(sci, SCE_D_WORD3, ft_id, 8);
2852         set_sci_style(sci, SCE_D_TYPEDEF, ft_id, 9);
2853         set_sci_style(sci, SCE_D_WORD5, ft_id, 9);
2854         set_sci_style(sci, SCE_D_STRING, ft_id, 10);
2855         set_sci_style(sci, SCE_D_STRINGB, ft_id, 10);
2856         set_sci_style(sci, SCE_D_STRINGR, ft_id, 10);
2857         set_sci_style(sci, SCE_D_STRINGEOL, ft_id, 11);
2858         set_sci_style(sci, SCE_D_CHARACTER, ft_id, 12);
2859         set_sci_style(sci, SCE_D_OPERATOR, ft_id, 13);
2860         set_sci_style(sci, SCE_D_IDENTIFIER, ft_id, 14);
2861         set_sci_style(sci, SCE_D_COMMENTLINEDOC, ft_id, 15);
2862         set_sci_style(sci, SCE_D_COMMENTDOCKEYWORD, ft_id, 16);
2863         set_sci_style(sci, SCE_D_COMMENTDOCKEYWORDERROR, ft_id, 17);
2864 }
2865
2866
2867 static void styleset_ferite_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2868 {
2869         styleset_c_like_init(config, config_home, ft_id);
2870
2871         style_sets[ft_id].keywords = g_new(gchar*, 4);
2872         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
2873         get_keyfile_keywords(config, config_home, "types", ft_id, 1);
2874         get_keyfile_keywords(config, config_home, "docComment", ft_id, 2);
2875         style_sets[ft_id].keywords[3] = NULL;
2876 }
2877
2878
2879 static void styleset_ferite(ScintillaObject *sci, gint ft_id)
2880 {
2881         styleset_c_like(sci, ft_id, SCLEX_CPP);
2882
2883         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2884         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2885         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2886 }
2887
2888
2889 static void styleset_vhdl_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2890 {
2891         new_styleset(ft_id, 15);
2892
2893         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2894         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2895         get_keyfile_style(config, config_home, "comment_line_bang", &style_sets[ft_id].styling[2]);
2896         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
2897         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[4]);
2898         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[5]);
2899         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[6]);
2900         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[7]);
2901         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[8]);
2902         get_keyfile_style(config, config_home, "stdoperator", &style_sets[ft_id].styling[9]);
2903         get_keyfile_style(config, config_home, "attribute", &style_sets[ft_id].styling[10]);
2904         get_keyfile_style(config, config_home, "stdfunction", &style_sets[ft_id].styling[11]);
2905         get_keyfile_style(config, config_home, "stdpackage", &style_sets[ft_id].styling[12]);
2906         get_keyfile_style(config, config_home, "stdtype", &style_sets[ft_id].styling[13]);
2907         get_keyfile_style(config, config_home, "userword", &style_sets[ft_id].styling[14]);
2908
2909         style_sets[ft_id].keywords = g_new(gchar*, 8);
2910         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
2911         get_keyfile_keywords(config, config_home, "operators", ft_id, 1);
2912         get_keyfile_keywords(config, config_home, "attributes", ft_id, 2);
2913         get_keyfile_keywords(config, config_home, "std_functions", ft_id, 3);
2914         get_keyfile_keywords(config, config_home, "std_packages", ft_id, 4);
2915         get_keyfile_keywords(config, config_home, "std_types", ft_id, 5);
2916         get_keyfile_keywords(config, config_home, "userwords", ft_id, 6);
2917         style_sets[ft_id].keywords[7] = NULL;
2918 }
2919
2920
2921 static void styleset_vhdl(ScintillaObject *sci, gint ft_id)
2922 {
2923         apply_filetype_properties(sci, SCLEX_VHDL, ft_id);
2924
2925         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2926         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2927         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2928         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
2929         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[4]);
2930         sci_set_keywords(sci, 5, style_sets[ft_id].keywords[5]);
2931         sci_set_keywords(sci, 6, style_sets[ft_id].keywords[6]);
2932
2933         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2934         set_sci_style(sci, SCE_VHDL_DEFAULT, ft_id, 0);
2935         set_sci_style(sci, SCE_VHDL_COMMENT, ft_id, 1);
2936         set_sci_style(sci, SCE_VHDL_COMMENTLINEBANG, ft_id, 2);
2937         set_sci_style(sci, SCE_VHDL_NUMBER, ft_id, 3);
2938         set_sci_style(sci, SCE_VHDL_STRING, ft_id, 4);
2939         set_sci_style(sci, SCE_VHDL_OPERATOR, ft_id, 5);
2940         set_sci_style(sci, SCE_VHDL_IDENTIFIER, ft_id, 6);
2941         set_sci_style(sci, SCE_VHDL_STRINGEOL, ft_id, 7);
2942         set_sci_style(sci, SCE_VHDL_KEYWORD, ft_id, 8);
2943         set_sci_style(sci, SCE_VHDL_STDOPERATOR, ft_id, 9);
2944         set_sci_style(sci, SCE_VHDL_ATTRIBUTE, ft_id, 10);
2945         set_sci_style(sci, SCE_VHDL_STDFUNCTION, ft_id, 11);
2946         set_sci_style(sci, SCE_VHDL_STDPACKAGE, ft_id, 12);
2947         set_sci_style(sci, SCE_VHDL_STDTYPE, ft_id, 13);
2948         set_sci_style(sci, SCE_VHDL_USERWORD, ft_id, 14);
2949 }
2950
2951
2952 static void styleset_verilog_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
2953 {
2954         new_styleset(ft_id, 14);
2955
2956         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
2957         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
2958         get_keyfile_style(config, config_home, "comment_line", &style_sets[ft_id].styling[2]);
2959         get_keyfile_style(config, config_home, "comment_line_bang", &style_sets[ft_id].styling[3]);
2960         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[4]);
2961         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[5]);
2962         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[6]);
2963         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[7]);
2964         get_keyfile_style(config, config_home, "word3", &style_sets[ft_id].styling[8]);
2965         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[9]);
2966         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
2967         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[11]);
2968         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[12]);
2969         get_keyfile_style(config, config_home, "userword", &style_sets[ft_id].styling[13]);
2970
2971         style_sets[ft_id].keywords = g_new(gchar*, 4);
2972         get_keyfile_keywords(config, config_home, "word", ft_id, 0);
2973         get_keyfile_keywords(config, config_home, "word2", ft_id, 1);
2974         get_keyfile_keywords(config, config_home, "word3", ft_id, 2);
2975         style_sets[ft_id].keywords[3] = NULL;
2976 }
2977
2978
2979 static void styleset_verilog(ScintillaObject *sci, gint ft_id)
2980 {
2981         apply_filetype_properties(sci, SCLEX_VERILOG, ft_id);
2982
2983         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
2984         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
2985         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
2986
2987         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
2988         set_sci_style(sci, SCE_V_DEFAULT, ft_id, 0);
2989         set_sci_style(sci, SCE_V_COMMENT, ft_id, 1);
2990         set_sci_style(sci, SCE_V_COMMENTLINE, ft_id, 2);
2991         set_sci_style(sci, SCE_V_COMMENTLINEBANG, ft_id, 3);
2992         set_sci_style(sci, SCE_V_NUMBER, ft_id, 4);
2993         set_sci_style(sci, SCE_V_WORD, ft_id,5);
2994         set_sci_style(sci, SCE_V_STRING, ft_id, 6);
2995         set_sci_style(sci, SCE_V_WORD2, ft_id, 7);
2996         set_sci_style(sci, SCE_V_WORD3, ft_id, 8);
2997         set_sci_style(sci, SCE_V_PREPROCESSOR, ft_id, 9);
2998         set_sci_style(sci, SCE_V_OPERATOR, ft_id, 10);
2999         set_sci_style(sci, SCE_V_IDENTIFIER, ft_id, 11);
3000         set_sci_style(sci, SCE_V_STRINGEOL, ft_id, 12);
3001         set_sci_style(sci, SCE_V_USER, ft_id, 13);
3002 }
3003
3004
3005 static void styleset_yaml_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3006 {
3007         new_styleset(ft_id, 10);
3008
3009         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
3010         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
3011         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[2]);
3012         get_keyfile_style(config, config_home, "keyword", &style_sets[ft_id].styling[3]);
3013         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[4]);
3014         get_keyfile_style(config, config_home, "reference", &style_sets[ft_id].styling[5]);
3015         get_keyfile_style(config, config_home, "document", &style_sets[ft_id].styling[6]);
3016         get_keyfile_style(config, config_home, "text", &style_sets[ft_id].styling[7]);
3017         get_keyfile_style(config, config_home, "error", &style_sets[ft_id].styling[8]);
3018         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[9]);
3019
3020         style_sets[ft_id].keywords = g_new(gchar*, 2);
3021         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
3022         style_sets[ft_id].keywords[1] = NULL;
3023 }
3024
3025
3026 static void styleset_yaml(ScintillaObject *sci, gint ft_id)
3027 {
3028         apply_filetype_properties(sci, SCLEX_YAML, ft_id);
3029
3030         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3031
3032         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
3033         set_sci_style(sci, SCE_YAML_DEFAULT, ft_id, 0);
3034         set_sci_style(sci, SCE_YAML_COMMENT, ft_id, 1);
3035         set_sci_style(sci, SCE_YAML_IDENTIFIER, ft_id, 2);
3036         set_sci_style(sci, SCE_YAML_KEYWORD, ft_id, 3);
3037         set_sci_style(sci, SCE_YAML_NUMBER, ft_id, 4);
3038         set_sci_style(sci, SCE_YAML_REFERENCE, ft_id, 5);
3039         set_sci_style(sci, SCE_YAML_DOCUMENT, ft_id, 6);
3040         set_sci_style(sci, SCE_YAML_TEXT, ft_id, 7);
3041         set_sci_style(sci, SCE_YAML_ERROR, ft_id, 8);
3042         set_sci_style(sci, SCE_YAML_OPERATOR, ft_id, 9);
3043 }
3044
3045
3046 static void styleset_js_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3047 {
3048         styleset_c_like_init(config, config_home, ft_id);
3049
3050         style_sets[ft_id].keywords = g_new(gchar*, 3);
3051         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
3052         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
3053         style_sets[ft_id].keywords[2] = NULL;
3054 }
3055
3056
3057 static void styleset_js(ScintillaObject *sci, gint ft_id)
3058 {
3059         styleset_c_like(sci, ft_id, SCLEX_CPP);
3060
3061         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3062         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
3063 }
3064
3065
3066 static void styleset_lua_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3067 {
3068         new_styleset(ft_id, 20);
3069
3070         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
3071         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
3072         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[2]);
3073         get_keyfile_style(config, config_home, "commentdoc", &style_sets[ft_id].styling[3]);
3074         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[4]);
3075         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[5]);
3076         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[6]);
3077         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[7]);
3078         get_keyfile_style(config, config_home, "literalstring", &style_sets[ft_id].styling[8]);
3079         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[9]);
3080         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[10]);
3081         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[11]);
3082         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[12]);
3083         get_keyfile_style(config, config_home, "function_basic", &style_sets[ft_id].styling[13]);
3084         get_keyfile_style(config, config_home, "function_other", &style_sets[ft_id].styling[14]);
3085         get_keyfile_style(config, config_home, "coroutines", &style_sets[ft_id].styling[15]);
3086         get_keyfile_style(config, config_home, "word5", &style_sets[ft_id].styling[16]);
3087         get_keyfile_style(config, config_home, "word6", &style_sets[ft_id].styling[17]);
3088         get_keyfile_style(config, config_home, "word7", &style_sets[ft_id].styling[18]);
3089         get_keyfile_style(config, config_home, "word8", &style_sets[ft_id].styling[19]);
3090
3091         style_sets[ft_id].keywords = g_new(gchar*, 9);
3092         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
3093         get_keyfile_keywords(config, config_home, "function_basic", ft_id, 1);
3094         get_keyfile_keywords(config, config_home, "function_other", ft_id, 2);
3095         get_keyfile_keywords(config, config_home, "coroutines", ft_id, 3);
3096         get_keyfile_keywords(config, config_home, "user1", ft_id, 4);
3097         get_keyfile_keywords(config, config_home, "user2", ft_id, 5);
3098         get_keyfile_keywords(config, config_home, "user3", ft_id, 6);
3099         get_keyfile_keywords(config, config_home, "user4", ft_id, 7);
3100         style_sets[ft_id].keywords[8] = NULL;
3101 }
3102
3103
3104 static void styleset_lua(ScintillaObject *sci, gint ft_id)
3105 {
3106         apply_filetype_properties(sci, SCLEX_LUA, ft_id);
3107
3108         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3109         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
3110         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
3111         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
3112         sci_set_keywords(sci, 4, style_sets[ft_id].keywords[4]);
3113         sci_set_keywords(sci, 5, style_sets[ft_id].keywords[5]);
3114         sci_set_keywords(sci, 6, style_sets[ft_id].keywords[6]);
3115         sci_set_keywords(sci, 7, style_sets[ft_id].keywords[7]);
3116
3117         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
3118         set_sci_style(sci, SCE_LUA_DEFAULT, ft_id, 0);
3119         set_sci_style(sci, SCE_LUA_COMMENT, ft_id, 1);
3120         set_sci_style(sci, SCE_LUA_COMMENTLINE, ft_id, 2);
3121         set_sci_style(sci, SCE_LUA_COMMENTDOC, ft_id, 3);
3122         set_sci_style(sci, SCE_LUA_NUMBER, ft_id, 4);
3123         set_sci_style(sci, SCE_LUA_WORD, ft_id, 5);
3124         set_sci_style(sci, SCE_LUA_STRING, ft_id, 6);
3125         set_sci_style(sci, SCE_LUA_CHARACTER, ft_id, 7);
3126         set_sci_style(sci, SCE_LUA_LITERALSTRING, ft_id, 8);
3127         set_sci_style(sci, SCE_LUA_PREPROCESSOR, ft_id, 9);
3128         set_sci_style(sci, SCE_LUA_OPERATOR, ft_id, 10);
3129         set_sci_style(sci, SCE_LUA_IDENTIFIER, ft_id, 11);
3130         set_sci_style(sci, SCE_LUA_STRINGEOL, ft_id, 12);
3131         set_sci_style(sci, SCE_LUA_WORD2, ft_id, 13);
3132         set_sci_style(sci, SCE_LUA_WORD3, ft_id, 14);
3133         set_sci_style(sci, SCE_LUA_WORD4, ft_id, 15);
3134         set_sci_style(sci, SCE_LUA_WORD5, ft_id, 16);
3135         set_sci_style(sci, SCE_LUA_WORD6, ft_id, 17);
3136         set_sci_style(sci, SCE_LUA_WORD7, ft_id, 18);
3137         set_sci_style(sci, SCE_LUA_WORD8, ft_id, 19);
3138 }
3139
3140
3141 static void styleset_basic_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3142 {
3143         new_styleset(ft_id, 19);
3144
3145         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
3146         get_keyfile_style(config, config_home, "comment", &style_sets[ft_id].styling[1]);
3147         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[2]);
3148         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[3]);
3149         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[4]);
3150         get_keyfile_style(config, config_home, "preprocessor", &style_sets[ft_id].styling[5]);
3151         get_keyfile_style(config, config_home, "operator", &style_sets[ft_id].styling[6]);
3152         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[7]);
3153         get_keyfile_style(config, config_home, "date", &style_sets[ft_id].styling[8]);
3154         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[9]);
3155         get_keyfile_style(config, config_home, "word2", &style_sets[ft_id].styling[10]);
3156         get_keyfile_style(config, config_home, "word3", &style_sets[ft_id].styling[11]);
3157         get_keyfile_style(config, config_home, "word4", &style_sets[ft_id].styling[12]);
3158         get_keyfile_style(config, config_home, "constant", &style_sets[ft_id].styling[13]);
3159         get_keyfile_style(config, config_home, "asm", &style_sets[ft_id].styling[14]);
3160         get_keyfile_style(config, config_home, "label", &style_sets[ft_id].styling[15]);
3161         get_keyfile_style(config, config_home, "error", &style_sets[ft_id].styling[16]);
3162         get_keyfile_style(config, config_home, "hexnumber", &style_sets[ft_id].styling[17]);
3163         get_keyfile_style(config, config_home, "binnumber", &style_sets[ft_id].styling[18]);
3164
3165         style_sets[ft_id].keywords = g_new(gchar*, 5);
3166         get_keyfile_keywords(config, config_home, "keywords", ft_id, 0);
3167         get_keyfile_keywords(config, config_home, "preprocessor", ft_id, 1);
3168         get_keyfile_keywords(config, config_home, "user1", ft_id, 2);
3169         get_keyfile_keywords(config, config_home, "user2", ft_id, 3);
3170         style_sets[ft_id].keywords[4] = NULL;
3171 }
3172
3173
3174 static void styleset_basic(ScintillaObject *sci, gint ft_id)
3175 {
3176         apply_filetype_properties(sci, SCLEX_FREEBASIC, ft_id);
3177
3178         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3179         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
3180         sci_set_keywords(sci, 2, style_sets[ft_id].keywords[2]);
3181         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[3]);
3182
3183         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
3184         set_sci_style(sci, SCE_B_DEFAULT, ft_id, 0);
3185         set_sci_style(sci, SCE_B_COMMENT, ft_id, 1);
3186         set_sci_style(sci, SCE_B_NUMBER, ft_id, 2);
3187         set_sci_style(sci, SCE_B_KEYWORD, ft_id, 3);
3188         set_sci_style(sci, SCE_B_STRING, ft_id, 4);
3189         set_sci_style(sci, SCE_B_PREPROCESSOR, ft_id, 5);
3190         set_sci_style(sci, SCE_B_OPERATOR, ft_id, 6);
3191         set_sci_style(sci, SCE_B_IDENTIFIER, ft_id, 7);
3192         set_sci_style(sci, SCE_B_DATE, ft_id, 8);
3193         set_sci_style(sci, SCE_B_STRINGEOL, ft_id, 9);
3194         set_sci_style(sci, SCE_B_KEYWORD2, ft_id, 10);
3195         set_sci_style(sci, SCE_B_KEYWORD3, ft_id, 11);
3196         set_sci_style(sci, SCE_B_KEYWORD4, ft_id, 12);
3197         set_sci_style(sci, SCE_B_CONSTANT, ft_id, 13);
3198         set_sci_style(sci, SCE_B_ASM, ft_id, 14); /* (still?) unused by the lexer */
3199         set_sci_style(sci, SCE_B_LABEL, ft_id, 15);
3200         set_sci_style(sci, SCE_B_ERROR, ft_id, 16);
3201         set_sci_style(sci, SCE_B_HEXNUMBER, ft_id, 17);
3202         set_sci_style(sci, SCE_B_BINNUMBER, ft_id, 18);
3203 }
3204
3205
3206 static void styleset_actionscript_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3207 {
3208         styleset_c_like_init(config, config_home, ft_id);
3209
3210         style_sets[ft_id].keywords = g_new(gchar *, 4);
3211         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
3212         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
3213         get_keyfile_keywords(config, config_home, "classes", ft_id, 2);
3214         style_sets[ft_id].keywords[3] = NULL;
3215 }
3216
3217
3218 static void styleset_actionscript(ScintillaObject *sci, gint ft_id)
3219 {
3220         styleset_c_like(sci, ft_id, SCLEX_CPP);
3221
3222         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3223         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[2]);
3224         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[1]);
3225 }
3226
3227
3228 static void styleset_haxe_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3229 {
3230         styleset_c_like_init(config, config_home, ft_id);
3231
3232         style_sets[ft_id].keywords = g_new(gchar*, 4);
3233         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
3234         get_keyfile_keywords(config, config_home, "secondary", ft_id, 1);
3235         get_keyfile_keywords(config, config_home, "classes", ft_id, 2);
3236         style_sets[ft_id].keywords[3] = NULL;
3237 }
3238
3239
3240 static void styleset_haxe(ScintillaObject *sci, gint ft_id)
3241 {
3242         styleset_c_like(sci, ft_id, SCLEX_CPP);
3243
3244         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3245         sci_set_keywords(sci, 1, style_sets[ft_id].keywords[1]);
3246         sci_set_keywords(sci, 3, style_sets[ft_id].keywords[2]);
3247 }
3248
3249
3250 static void styleset_ada_init(gint ft_id, GKeyFile *config, GKeyFile *config_home)
3251 {
3252         new_styleset(ft_id, 12);
3253
3254         get_keyfile_style(config, config_home, "default", &style_sets[ft_id].styling[0]);
3255         get_keyfile_style(config, config_home, "word", &style_sets[ft_id].styling[1]);
3256         get_keyfile_style(config, config_home, "identifier", &style_sets[ft_id].styling[2]);
3257         get_keyfile_style(config, config_home, "number", &style_sets[ft_id].styling[3]);
3258         get_keyfile_style(config, config_home, "delimiter", &style_sets[ft_id].styling[4]);
3259         get_keyfile_style(config, config_home, "character", &style_sets[ft_id].styling[5]);
3260         get_keyfile_style(config, config_home, "charactereol", &style_sets[ft_id].styling[6]);
3261         get_keyfile_style(config, config_home, "string", &style_sets[ft_id].styling[7]);
3262         get_keyfile_style(config, config_home, "stringeol", &style_sets[ft_id].styling[8]);
3263         get_keyfile_style(config, config_home, "label", &style_sets[ft_id].styling[9]);
3264         get_keyfile_style(config, config_home, "commentline", &style_sets[ft_id].styling[10]);
3265         get_keyfile_style(config, config_home, "illegal", &style_sets[ft_id].styling[11]);
3266
3267         style_sets[ft_id].keywords = g_new(gchar*, 2);
3268         get_keyfile_keywords(config, config_home, "primary", ft_id, 0);
3269         style_sets[ft_id].keywords[1] = NULL;
3270 }
3271
3272
3273 static void styleset_ada(ScintillaObject *sci, gint ft_id)
3274 {
3275         apply_filetype_properties(sci, SCLEX_ADA, ft_id);
3276
3277         sci_set_keywords(sci, 0, style_sets[ft_id].keywords[0]);
3278
3279         set_sci_style(sci, STYLE_DEFAULT, ft_id, 0);
3280         set_sci_style(sci, SCE_ADA_DEFAULT, ft_id, 0);
3281         set_sci_style(sci, SCE_ADA_WORD, ft_id, 1);
3282         set_sci_style(sci, SCE_ADA_IDENTIFIER, ft_id, 2);
3283         set_sci_style(sci, SCE_ADA_NUMBER, ft_id, 3);
3284         set_sci_style(sci, SCE_ADA_DELIMITER, ft_id, 4);
3285         set_sci_style(sci, SCE_ADA_CHARACTER, ft_id, 5);
3286         set_sci_style(sci, SCE_ADA_CHARACTEREOL, ft_id, 6);
3287         set_sci_style(sci, SCE_ADA_STRING, ft_id, 7);
3288         set_sci_style(sci, SCE_ADA_STRINGEOL, ft_id, 8);
3289         set_sci_style(sci, SCE_ADA_LABEL, ft_id, 9);
3290         set_sci_style(sci, SCE_ADA_COMMENTLINE, ft_id, 10);
3291         set_sci_style(sci, SCE_ADA_ILLEGAL, ft_id, 11);
3292 }
3293
3294
3295 static void get_key_values(GKeyFile *config, const gchar *group, gchar **keys, gchar **values)
3296 {
3297         while (*keys)
3298         {
3299                 gchar *str = g_key_file_get_string(config, group, *keys, NULL);
3300
3301                 if (str)
3302                         setptr(*values, str);
3303
3304                 keys++;
3305                 values++;
3306         }
3307 }
3308
3309
3310 static void read_properties(GeanyFiletype *ft, GKeyFile *config, GKeyFile *configh)
3311 {
3312         gchar group[] = "lexer_properties";
3313         gchar **keys;
3314         gchar **keysh = g_key_file_get_keys(configh, group, NULL, NULL);
3315         gchar **ptr;
3316
3317         /* remove overridden keys from system keyfile */
3318         foreach_strv(ptr, keysh)
3319                 g_key_file_remove_key(config, group, *ptr, NULL);
3320
3321         /* merge sys and user keys */
3322         keys = g_key_file_get_keys(config, group, NULL, NULL);
3323         keys = utils_strv_join(keys, keysh);
3324
3325         if (keys)
3326         {
3327                 gchar **values = g_new0(gchar*, g_strv_length(keys) + 1);
3328
3329                 style_sets[ft->id].property_keys = keys;
3330                 style_sets[ft->id].property_values = values;
3331
3332                 get_key_values(config, group, keys, values);
3333                 get_key_values(configh, group, keys, values);
3334         }
3335 }
3336
3337
3338 static gint get_lexer_filetype(GeanyFiletype *ft)
3339 {
3340         ft = NVL(ft->lexer_filetype, ft);
3341         return ft->id;
3342 }
3343
3344
3345 /* lang_name is the name used for the styleset_foo_init function, e.g. foo. */
3346 #define init_styleset_case(ft_id, init_styleset_func) \
3347         case (ft_id): \
3348                 init_styleset_func(filetype_idx, config, configh); \
3349                 break
3350
3351 /* Called by filetypes_load_config(). */
3352 void highlighting_init_styles(gint filetype_idx, GKeyFile *config, GKeyFile *configh)
3353 {
3354         GeanyFiletype *ft = filetypes[filetype_idx];
3355         gint lexer_id = get_lexer_filetype(ft);
3356
3357         if (!style_sets)
3358                 style_sets = g_new0(StyleSet, filetypes_array->len);
3359
3360         /* Clear old information if necessary - e.g. when reloading config */
3361         free_styleset(filetype_idx);
3362
3363         read_properties(ft, config, configh);
3364
3365         /* None filetype handled specially */
3366         if (filetype_idx == GEANY_FILETYPES_NONE)
3367         {
3368                 styleset_common_init(GEANY_FILETYPES_NONE, config, configh);
3369                 return;
3370         }
3371         /* All stylesets depend on filetypes.common */
3372         filetypes_load_config(GEANY_FILETYPES_NONE, FALSE);
3373
3374         switch (lexer_id)
3375         {
3376                 init_styleset_case(GEANY_FILETYPES_ADA,         styleset_ada_init);
3377                 init_styleset_case(GEANY_FILETYPES_ASM,         styleset_asm_init);
3378                 init_styleset_case(GEANY_FILETYPES_BASIC,       styleset_basic_init);
3379                 init_styleset_case(GEANY_FILETYPES_C,           styleset_c_init);
3380                 init_styleset_case(GEANY_FILETYPES_CAML,        styleset_caml_init);
3381                 init_styleset_case(GEANY_FILETYPES_CMAKE,       styleset_cmake_init);
3382                 init_styleset_case(GEANY_FILETYPES_COBOL,       styleset_cobol_init);
3383                 init_styleset_case(GEANY_FILETYPES_CONF,        styleset_conf_init);
3384                 init_styleset_case(GEANY_FILETYPES_CSS,         styleset_css_init);
3385                 init_styleset_case(GEANY_FILETYPES_D,           styleset_d_init);
3386                 init_styleset_case(GEANY_FILETYPES_DIFF,        styleset_diff_init);
3387                 init_styleset_case(GEANY_FILETYPES_LISP,        styleset_lisp_init);
3388                 init_styleset_case(GEANY_FILETYPES_ERLANG,      styleset_erlang_init);
3389                 init_styleset_case(GEANY_FILETYPES_DOCBOOK,     styleset_docbook_init);
3390                 init_styleset_case(GEANY_FILETYPES_FERITE,      styleset_ferite_init);
3391                 init_styleset_case(GEANY_FILETYPES_F77,         styleset_f77_init);
3392                 init_styleset_case(GEANY_FILETYPES_FORTH,       styleset_forth_init);
3393                 init_styleset_case(GEANY_FILETYPES_FORTRAN,     styleset_fortran_init);
3394                 init_styleset_case(GEANY_FILETYPES_HASKELL,     styleset_haskell_init);
3395                 init_styleset_case(GEANY_FILETYPES_HAXE,        styleset_haxe_init);
3396                 init_styleset_case(GEANY_FILETYPES_AS,          styleset_actionscript_init);
3397                 init_styleset_case(GEANY_FILETYPES_HTML,        styleset_html_init);
3398                 init_styleset_case(GEANY_FILETYPES_JAVA,        styleset_java_init);
3399                 init_styleset_case(GEANY_FILETYPES_JS,          styleset_js_init);
3400                 init_styleset_case(GEANY_FILETYPES_LATEX,       styleset_latex_init);
3401                 init_styleset_case(GEANY_FILETYPES_LUA,         styleset_lua_init);
3402                 init_styleset_case(GEANY_FILETYPES_MAKE,        styleset_makefile_init);
3403                 init_styleset_case(GEANY_FILETYPES_MATLAB,      styleset_matlab_init);
3404                 init_styleset_case(GEANY_FILETYPES_MARKDOWN,    styleset_markdown_init);
3405                 init_styleset_case(GEANY_FILETYPES_NSIS,        styleset_nsis_init);
3406                 init_styleset_case(GEANY_FILETYPES_PASCAL,      styleset_pascal_init);
3407                 init_styleset_case(GEANY_FILETYPES_PERL,        styleset_perl_init);
3408                 init_styleset_case(GEANY_FILETYPES_PHP,         styleset_php_init);
3409                 init_styleset_case(GEANY_FILETYPES_PO,          styleset_po_init);
3410                 init_styleset_case(GEANY_FILETYPES_PYTHON,      styleset_python_init);
3411                 init_styleset_case(GEANY_FILETYPES_R,           styleset_r_init);
3412                 init_styleset_case(GEANY_FILETYPES_RUBY,        styleset_ruby_init);
3413                 init_styleset_case(GEANY_FILETYPES_SH,          styleset_sh_init);
3414                 init_styleset_case(GEANY_FILETYPES_SQL,         styleset_sql_init);
3415                 init_styleset_case(GEANY_FILETYPES_TCL,         styleset_tcl_init);
3416                 init_styleset_case(GEANY_FILETYPES_TXT2TAGS, styleset_txt2tags_init);
3417                 init_styleset_case(GEANY_FILETYPES_VHDL,        styleset_vhdl_init);
3418                 init_styleset_case(GEANY_FILETYPES_VERILOG,     styleset_verilog_init);
3419                 init_styleset_case(GEANY_FILETYPES_XML,         styleset_markup_init);
3420                 init_styleset_case(GEANY_FILETYPES_YAML,        styleset_yaml_init);
3421                 default:
3422                         if (ft->lexer_filetype)
3423                                 geany_debug("Filetype %s has a recursive lexer_filetype %s set!",
3424                                         ft->name, ft->lexer_filetype->name);
3425         }
3426
3427         /* should be done in filetypes.c really: */
3428         get_keyfile_wordchars(config, configh, &style_sets[filetype_idx].wordchars);
3429 }
3430
3431
3432 /* lang_name is the name used for the styleset_foo function, e.g. foo. */
3433 #define styleset_case(ft_id, styleset_func) \
3434         case (ft_id): \
3435                 styleset_func(sci, ft->id); \
3436                 break
3437
3438 /** Sets up highlighting and other visual settings.
3439  * @param sci Scintilla widget.
3440  * @param ft Filetype settings to use. */
3441 void highlighting_set_styles(ScintillaObject *sci, GeanyFiletype *ft)
3442 {
3443         gint lexer_id = get_lexer_filetype(ft);
3444
3445         filetypes_load_config(ft->id, FALSE);   /* load filetypes.ext */
3446
3447         switch (lexer_id)
3448         {
3449                 styleset_case(GEANY_FILETYPES_ADA,              styleset_ada);
3450                 styleset_case(GEANY_FILETYPES_ASM,              styleset_asm);
3451                 styleset_case(GEANY_FILETYPES_BASIC,    styleset_basic);
3452                 styleset_case(GEANY_FILETYPES_C,                styleset_c);
3453                 styleset_case(GEANY_FILETYPES_CAML,             styleset_caml);
3454                 styleset_case(GEANY_FILETYPES_CMAKE,    styleset_cmake);
3455                 styleset_case(GEANY_FILETYPES_COBOL,            styleset_cobol);
3456                 styleset_case(GEANY_FILETYPES_CONF,             styleset_conf);
3457                 styleset_case(GEANY_FILETYPES_CSS,              styleset_css);
3458                 styleset_case(GEANY_FILETYPES_D,                styleset_d);
3459                 styleset_case(GEANY_FILETYPES_DIFF,             styleset_diff);
3460                 styleset_case(GEANY_FILETYPES_LISP,             styleset_lisp);
3461                 styleset_case(GEANY_FILETYPES_ERLANG,   styleset_erlang);
3462                 styleset_case(GEANY_FILETYPES_DOCBOOK,  styleset_docbook);
3463                 styleset_case(GEANY_FILETYPES_FERITE,   styleset_ferite);
3464                 styleset_case(GEANY_FILETYPES_F77,              styleset_f77);
3465                 styleset_case(GEANY_FILETYPES_FORTH,    styleset_forth);
3466                 styleset_case(GEANY_FILETYPES_FORTRAN,  styleset_fortran);
3467                 styleset_case(GEANY_FILETYPES_HASKELL,  styleset_haskell);
3468                 styleset_case(GEANY_FILETYPES_HAXE,             styleset_haxe);
3469                 styleset_case(GEANY_FILETYPES_AS,               styleset_actionscript);
3470                 styleset_case(GEANY_FILETYPES_HTML,             styleset_html);
3471                 styleset_case(GEANY_FILETYPES_JAVA,             styleset_java);
3472                 styleset_case(GEANY_FILETYPES_JS,               styleset_js);
3473                 styleset_case(GEANY_FILETYPES_LATEX,    styleset_latex);
3474                 styleset_case(GEANY_FILETYPES_LUA,              styleset_lua);
3475                 styleset_case(GEANY_FILETYPES_MAKE,             styleset_makefile);
3476                 styleset_case(GEANY_FILETYPES_MARKDOWN, styleset_markdown);
3477                 styleset_case(GEANY_FILETYPES_MATLAB,   styleset_matlab);
3478                 styleset_case(GEANY_FILETYPES_NSIS,             styleset_nsis);
3479                 styleset_case(GEANY_FILETYPES_PASCAL,   styleset_pascal);
3480                 styleset_case(GEANY_FILETYPES_PERL,             styleset_perl);
3481                 styleset_case(GEANY_FILETYPES_PHP,              styleset_php);
3482                 styleset_case(GEANY_FILETYPES_PO,               styleset_po);
3483                 styleset_case(GEANY_FILETYPES_PYTHON,   styleset_python);
3484                 styleset_case(GEANY_FILETYPES_R,                styleset_r);
3485                 styleset_case(GEANY_FILETYPES_RUBY,             styleset_ruby);
3486                 styleset_case(GEANY_FILETYPES_SH,               styleset_sh);
3487                 styleset_case(GEANY_FILETYPES_SQL,              styleset_sql);
3488                 styleset_case(GEANY_FILETYPES_TCL,              styleset_tcl);
3489                 styleset_case(GEANY_FILETYPES_TXT2TAGS, styleset_txt2tags);
3490                 styleset_case(GEANY_FILETYPES_VHDL,             styleset_vhdl);
3491                 styleset_case(GEANY_FILETYPES_VERILOG,  styleset_verilog);
3492                 styleset_case(GEANY_FILETYPES_XML,              styleset_xml);
3493                 styleset_case(GEANY_FILETYPES_YAML,             styleset_yaml);
3494                 case GEANY_FILETYPES_NONE:
3495                 default:
3496                         styleset_default(sci, ft->id);
3497         }
3498         /* [lexer_properties] settings */
3499         if (style_sets[ft->id].property_keys)
3500         {
3501                 gchar **prop = style_sets[ft->id].property_keys;
3502                 gchar **val = style_sets[ft->id].property_values;
3503
3504                 while (*prop)
3505                 {
3506                         sci_set_property(sci, *prop, *val);
3507                         prop++;
3508                         val++;
3509                 }
3510         }
3511 }
3512
3513
3514 /** Retrieves a style @a style_id for the filetype @a ft_id.
3515  * If the style was not already initialised
3516  * (e.g. by by opening a file of this type), it will be initialised. The returned pointer is
3517  * owned by Geany and must not be freed.
3518  * @param ft_id Filetype ID, e.g. @c GEANY_FILETYPES_DIFF.
3519  * @param style_id A Scintilla lexer style, e.g. @c SCE_DIFF_ADDED. See scintilla/include/SciLexer.h.
3520  * @return A pointer to the style struct.
3521  * @see Scintilla messages @c SCI_STYLEGETFORE, etc, for use with scintilla_send_message(). */
3522 const GeanyLexerStyle *highlighting_get_style(gint ft_id, gint style_id)
3523 {
3524         if (ft_id < 0 || ft_id >= (gint)filetypes_array->len)
3525                 return NULL;
3526
3527         /* ensure filetype loaded */
3528         filetypes_load_config(ft_id, FALSE);
3529
3530         /* TODO: style_id might not be the real array index (Scintilla styles are not always synced
3531          * with array indices) */
3532         return get_style(ft_id, style_id);
3533 }
3534
3535
3536 static void
3537 on_color_scheme_clicked(GtkMenuItem *menuitem, gpointer user_data)
3538 {
3539         gchar *fname;
3540         gchar *path;
3541
3542         /* prevent callback on setting initial value */
3543         if (!GTK_WIDGET_MAPPED(menuitem))
3544                 return;
3545
3546         /* check if default item */
3547         if (!user_data)
3548         {
3549                 setptr(editor_prefs.color_scheme, NULL);
3550                 filetypes_reload();
3551                 return;
3552         }
3553         fname = g_strdup(g_object_get_data(G_OBJECT(menuitem), "colorscheme_file"));
3554         setptr(fname, utils_get_locale_from_utf8(fname));
3555
3556         /* fname is just the basename from the menu item, so prepend the custom files path */
3557         path = g_build_path(G_DIR_SEPARATOR_S, app->configdir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
3558         if (!g_file_test(path, G_FILE_TEST_EXISTS))
3559         {
3560                 /* try the system path */
3561                 g_free(path);
3562                 path = g_build_path(G_DIR_SEPARATOR_S, app->datadir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
3563         }
3564         if (g_file_test(path, G_FILE_TEST_EXISTS))
3565         {
3566                 setptr(editor_prefs.color_scheme, fname);
3567                 fname = NULL;
3568                 filetypes_reload();
3569         }
3570         else
3571         {
3572                 setptr(fname, utils_get_utf8_from_locale(fname));
3573                 ui_set_statusbar(TRUE, _("Could not find file '%s'."), fname);
3574         }
3575         g_free(path);
3576         g_free(fname);
3577 }
3578
3579
3580 static gchar *utils_get_setting_locale_string(GKeyFile *keyfile,
3581                 const gchar *group, const gchar *key, const gchar *default_value)
3582 {
3583         gchar *result = g_key_file_get_locale_string(keyfile, group, key, NULL, NULL);
3584
3585         return NVL(result, g_strdup(default_value));
3586 }
3587
3588
3589 static void add_color_scheme_item(GtkWidget *menu, const gchar *fname)
3590 {
3591         static GSList *group = NULL;
3592         GtkWidget *item;
3593
3594         if (!fname)
3595         {
3596                 item = gtk_radio_menu_item_new_with_mnemonic(group, _("_Default"));
3597         }
3598         else
3599         {
3600                 GKeyFile *hkeyfile, *skeyfile;
3601                 gchar *path, *theme_name, *tooltip;
3602                 gchar *theme_fn = utils_get_utf8_from_locale(fname);
3603
3604                 path = utils_build_path(app->configdir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL);
3605                 hkeyfile = utils_key_file_new(path);
3606                 setptr(path, utils_build_path(app->datadir, GEANY_COLORSCHEMES_SUBDIR, fname, NULL));
3607                 skeyfile = utils_key_file_new(path);
3608
3609                 theme_name = utils_get_setting(locale_string, hkeyfile, skeyfile, "theme_info", "name", theme_fn);
3610                 item = gtk_radio_menu_item_new_with_label(group, theme_name);
3611                 g_object_set_data_full(G_OBJECT(item), "colorscheme_file", theme_fn, g_free);
3612
3613                 tooltip = utils_get_setting(locale_string, hkeyfile, skeyfile, "theme_info", "description", NULL);
3614                 if (tooltip != NULL)
3615                 {
3616                         gtk_widget_set_tooltip_text(item, tooltip);
3617                         g_free(tooltip);
3618                 }
3619                 g_free(path);
3620                 g_free(theme_name);
3621                 g_key_file_free(hkeyfile);
3622                 g_key_file_free(skeyfile);
3623         }
3624
3625         group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
3626         if (utils_str_equal(editor_prefs.color_scheme, fname))
3627                 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
3628
3629         gtk_widget_show(item);
3630         gtk_container_add(GTK_CONTAINER(menu), item);
3631         g_signal_connect(item, "activate",
3632                 G_CALLBACK(on_color_scheme_clicked), GINT_TO_POINTER(fname != NULL));
3633 }
3634
3635
3636 static gboolean add_color_scheme_items(GtkWidget *menu)
3637 {
3638         GSList *list, *node;
3639
3640         g_return_val_if_fail(menu, FALSE);
3641
3642         add_color_scheme_item(menu, NULL);
3643         list = utils_get_config_files(GEANY_COLORSCHEMES_SUBDIR);
3644
3645         foreach_slist(node, list)
3646         {
3647                 gchar *fname = node->data;
3648
3649                 if (g_str_has_suffix(fname, ".conf"))
3650                         add_color_scheme_item(menu, fname);
3651
3652                 g_free(fname);
3653         }
3654         g_slist_free(list);
3655         return list != NULL;
3656 }
3657
3658
3659 static void create_color_scheme_menu(void)
3660 {
3661         GtkWidget *item, *menu, *root;
3662
3663         menu = ui_lookup_widget(main_widgets.window, "menu_view_editor1_menu");
3664         item = ui_image_menu_item_new(GTK_STOCK_SELECT_COLOR, _("_Color Schemes"));
3665         gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item);
3666         root = item;
3667
3668         menu = gtk_menu_new();
3669         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
3670
3671         add_color_scheme_items(menu);
3672         gtk_widget_show_all(root);
3673 }
3674
3675
3676 void highlighting_init(void)
3677 {
3678         create_color_scheme_menu();
3679 }
3680
3681
3682 /** Checks whether the given style is a string for the given lexer.
3683  *
3684  * @param lexer Scintilla lexer type (@c SCLEX_*).
3685  * @param style Scintilla style (@c SCE_*).
3686  *
3687  * @return @c TRUE if the style is a string, @c FALSE otherwise.
3688  */
3689 gboolean highlighting_is_string_style(gint lexer, gint style)
3690 {
3691         /* Don't forget STRINGEOL, to prevent completion whilst typing a string with no closing char. */
3692
3693         switch (lexer)
3694         {
3695                 case SCLEX_CPP:
3696                         return (style == SCE_C_CHARACTER ||
3697                                 style == SCE_C_STRING ||
3698                                 style == SCE_C_STRINGEOL ||
3699                                 style == SCE_C_STRINGRAW ||
3700                                 style == SCE_C_VERBATIM ||
3701                                 style == SCE_C_TRIPLEVERBATIM);
3702
3703                 case SCLEX_PASCAL:
3704                         return (style == SCE_PAS_CHARACTER ||
3705                                 style == SCE_PAS_STRING ||
3706                                 style == SCE_PAS_STRINGEOL);
3707
3708                 case SCLEX_D:
3709                         return (style == SCE_D_STRING ||
3710                                 style == SCE_D_STRINGEOL ||
3711                                 style == SCE_D_CHARACTER ||
3712                                 style == SCE_D_STRINGB ||
3713                                 style == SCE_D_STRINGR);
3714
3715                 case SCLEX_PYTHON:
3716                         return (style == SCE_P_STRING ||
3717                                 style == SCE_P_TRIPLE ||
3718                                 style == SCE_P_TRIPLEDOUBLE ||
3719                                 style == SCE_P_CHARACTER ||
3720                                 style == SCE_P_STRINGEOL);
3721
3722                 case SCLEX_F77:
3723                 case SCLEX_FORTRAN:
3724                         return (style == SCE_F_STRING1 ||
3725                                 style == SCE_F_STRING2 ||
3726                                 style == SCE_F_STRINGEOL);
3727
3728                 case SCLEX_PERL:
3729                         return (/*style == SCE_PL_STRING ||*/ /* may want variable autocompletion "$(foo)" */
3730                                 style == SCE_PL_CHARACTER ||
3731                                 style == SCE_PL_HERE_DELIM ||
3732                                 style == SCE_PL_HERE_Q ||
3733                                 style == SCE_PL_HERE_QQ ||
3734                                 style == SCE_PL_HERE_QX ||
3735                                 style == SCE_PL_POD ||
3736                                 style == SCE_PL_STRING_Q ||
3737                                 style == SCE_PL_STRING_QQ ||
3738                                 style == SCE_PL_STRING_QX ||
3739                                 style == SCE_PL_STRING_QR ||
3740                                 style == SCE_PL_STRING_QW ||
3741                                 style == SCE_PL_POD_VERB);
3742
3743                 case SCLEX_R:
3744                         return (style == SCE_R_STRING);
3745
3746                 case SCLEX_RUBY:
3747                         return (style == SCE_RB_CHARACTER ||
3748                                 style == SCE_RB_STRING ||
3749                                 style == SCE_RB_HERE_DELIM ||
3750                                 style == SCE_RB_HERE_Q ||
3751                                 style == SCE_RB_HERE_QQ ||
3752                                 style == SCE_RB_HERE_QX ||
3753                                 style == SCE_RB_POD);
3754
3755                 case SCLEX_BASH:
3756                         return (style == SCE_SH_STRING);
3757
3758                 case SCLEX_SQL:
3759                         return (style == SCE_SQL_STRING);
3760
3761                 case SCLEX_TCL:
3762                         return (style == SCE_TCL_IN_QUOTE);
3763
3764                 case SCLEX_LUA:
3765                         return (style == SCE_LUA_LITERALSTRING ||
3766                                 style == SCE_LUA_CHARACTER ||
3767                                 style == SCE_LUA_STRINGEOL ||
3768                                 style == SCE_LUA_STRING);
3769
3770                 case SCLEX_HASKELL:
3771                         return (style == SCE_HA_CHARACTER ||
3772                                 style == SCE_HA_STRING);
3773
3774                 case SCLEX_FREEBASIC:
3775                         return (style == SCE_B_STRING ||
3776                                 style == SCE_B_STRINGEOL);
3777
3778                 case SCLEX_OCTAVE:
3779                         return (style == SCE_MATLAB_STRING ||
3780                                 style == SCE_MATLAB_DOUBLEQUOTESTRING);
3781
3782                 case SCLEX_HTML:
3783                         return (
3784                                 style == SCE_HBA_STRING ||
3785                                 style == SCE_HBA_STRINGEOL ||
3786                                 style == SCE_HB_STRING ||
3787                                 style == SCE_HB_STRINGEOL ||
3788                                 style == SCE_H_CDATA ||
3789                                 style == SCE_H_DOUBLESTRING ||
3790                                 style == SCE_HJA_DOUBLESTRING ||
3791                                 style == SCE_HJA_SINGLESTRING ||
3792                                 style == SCE_HJA_STRINGEOL ||
3793                                 style == SCE_HJ_DOUBLESTRING ||
3794                                 style == SCE_HJ_SINGLESTRING ||
3795                                 style == SCE_HJ_STRINGEOL ||
3796                                 style == SCE_HPA_CHARACTER ||
3797                                 style == SCE_HPA_STRING ||
3798                                 style == SCE_HPA_TRIPLE ||
3799                                 style == SCE_HPA_TRIPLEDOUBLE ||
3800                                 style == SCE_HP_CHARACTER ||
3801                                 style == SCE_HPHP_HSTRING ||  /* HSTRING is a heredoc */
3802                                 style == SCE_HPHP_HSTRING_VARIABLE ||
3803                                 style == SCE_HPHP_SIMPLESTRING ||
3804                                 style == SCE_HP_STRING ||
3805                                 style == SCE_HP_TRIPLE ||
3806                                 style == SCE_HP_TRIPLEDOUBLE ||
3807                                 style == SCE_H_SGML_DOUBLESTRING ||
3808                                 style == SCE_H_SGML_SIMPLESTRING ||
3809                                 style == SCE_H_SINGLESTRING);
3810
3811                 case SCLEX_CMAKE:
3812                         return (style == SCE_CMAKE_STRINGDQ ||
3813                                 style == SCE_CMAKE_STRINGLQ ||
3814                                 style == SCE_CMAKE_STRINGRQ ||
3815                                 style == SCE_CMAKE_STRINGVAR);
3816
3817                 case SCLEX_NSIS:
3818                         return (style == SCE_NSIS_STRINGDQ ||
3819                                 style == SCE_NSIS_STRINGLQ ||
3820                                 style == SCE_NSIS_STRINGRQ ||
3821                                 style == SCE_NSIS_STRINGVAR);
3822
3823                 case SCLEX_ADA:
3824                         return (style == SCE_ADA_CHARACTER ||
3825                                 style == SCE_ADA_STRING ||
3826                                 style == SCE_ADA_CHARACTEREOL ||
3827                                 style == SCE_ADA_STRINGEOL);
3828         }
3829         return FALSE;
3830 }
3831
3832
3833 /** Checks whether the given style is a comment for the given lexer.
3834  *
3835  * @param lexer Scintilla lexer type (@c SCLEX_*).
3836  * @param style Scintilla style (@c SCE_*).
3837  *
3838  * @return @c TRUE if the style is a comment, @c FALSE otherwise.
3839  */
3840 gboolean highlighting_is_comment_style(gint lexer, gint style)
3841 {
3842         switch (lexer)
3843         {
3844                 case SCLEX_COBOL:
3845                 case SCLEX_CPP:
3846                         return (style == SCE_C_COMMENT ||
3847                                 style == SCE_C_COMMENTLINE ||
3848                                 style == SCE_C_COMMENTDOC ||
3849                                 style == SCE_C_COMMENTLINEDOC ||
3850                                 style == SCE_C_COMMENTDOCKEYWORD ||
3851                                 style == SCE_C_COMMENTDOCKEYWORDERROR);
3852
3853                 case SCLEX_PASCAL:
3854                         return (style == SCE_PAS_COMMENT ||
3855                                 style == SCE_PAS_COMMENT2 ||
3856                                 style == SCE_PAS_COMMENTLINE);
3857
3858                 case SCLEX_D:
3859                         return (style == SCE_D_COMMENT ||
3860                                 style == SCE_D_COMMENTLINE ||
3861                                 style == SCE_D_COMMENTDOC ||
3862                                 style == SCE_D_COMMENTNESTED ||
3863                                 style == SCE_D_COMMENTLINEDOC ||
3864                                 style == SCE_D_COMMENTDOCKEYWORD ||
3865                                 style == SCE_D_COMMENTDOCKEYWORDERROR);
3866
3867                 case SCLEX_PYTHON:
3868                         return (style == SCE_P_COMMENTLINE ||
3869                                 style == SCE_P_COMMENTBLOCK);
3870
3871                 case SCLEX_F77:
3872                 case SCLEX_FORTRAN:
3873                         return (style == SCE_F_COMMENT);
3874
3875                 case SCLEX_PERL:
3876                         return (style == SCE_PL_COMMENTLINE);
3877
3878                 case SCLEX_PROPERTIES:
3879                         return (style == SCE_PROPS_COMMENT);
3880
3881                 case SCLEX_PO:
3882                         return (style == SCE_PO_COMMENT);
3883
3884                 case SCLEX_LATEX:
3885                         return (style == SCE_L_COMMENT);
3886
3887                 case SCLEX_MAKEFILE:
3888                         return (style == SCE_MAKE_COMMENT);
3889
3890                 case SCLEX_RUBY:
3891                         return (style == SCE_RB_COMMENTLINE);
3892
3893                 case SCLEX_BASH:
3894                         return (style == SCE_SH_COMMENTLINE);
3895
3896                 case SCLEX_R:
3897                         return (style == SCE_R_COMMENT);
3898
3899                 case SCLEX_SQL:
3900                         return (style == SCE_SQL_COMMENT ||
3901                                 style == SCE_SQL_COMMENTLINE ||
3902                                 style == SCE_SQL_COMMENTDOC);
3903
3904                 case SCLEX_TCL:
3905                         return (style == SCE_TCL_COMMENT ||
3906                                 style == SCE_TCL_COMMENTLINE ||
3907                                 style == SCE_TCL_COMMENT_BOX ||
3908                                 style == SCE_TCL_BLOCK_COMMENT);
3909
3910                 case SCLEX_OCTAVE:
3911                         return (style == SCE_MATLAB_COMMENT);
3912
3913                 case SCLEX_LUA:
3914                         return (style == SCE_LUA_COMMENT ||
3915                                 style == SCE_LUA_COMMENTLINE ||
3916                                 style == SCE_LUA_COMMENTDOC);
3917
3918                 case SCLEX_HASKELL:
3919                         return (style == SCE_HA_COMMENTLINE ||
3920                                 style == SCE_HA_COMMENTBLOCK ||
3921                                 style == SCE_HA_COMMENTBLOCK2 ||
3922                                 style == SCE_HA_COMMENTBLOCK3);
3923
3924                 case SCLEX_FREEBASIC:
3925                         return (style == SCE_B_COMMENT);
3926
3927                 case SCLEX_YAML:
3928                         return (style == SCE_YAML_COMMENT);
3929
3930                 case SCLEX_HTML:
3931                         return (
3932                                 style == SCE_HBA_COMMENTLINE ||
3933                                 style == SCE_HB_COMMENTLINE ||
3934                                 style == SCE_H_COMMENT ||
3935                                 style == SCE_HJA_COMMENT ||
3936                                 style == SCE_HJA_COMMENTDOC ||
3937                                 style == SCE_HJA_COMMENTLINE ||
3938                                 style == SCE_HJ_COMMENT ||
3939                                 style == SCE_HJ_COMMENTDOC ||
3940                                 style == SCE_HJ_COMMENTLINE ||
3941                                 style == SCE_HPA_COMMENTLINE ||
3942                                 style == SCE_HP_COMMENTLINE ||
3943                                 style == SCE_HPHP_COMMENT ||
3944                                 style == SCE_HPHP_COMMENTLINE ||
3945                                 style == SCE_H_SGML_COMMENT);
3946
3947                 case SCLEX_CMAKE:
3948                         return (style == SCE_CMAKE_COMMENT);
3949
3950                 case SCLEX_NSIS:
3951                         return (style == SCE_NSIS_COMMENT ||
3952                                 style == SCE_NSIS_COMMENTBOX);
3953
3954                 case SCLEX_ADA:
3955                         return (style == SCE_ADA_COMMENTLINE ||
3956                                 style == SCE_NSIS_COMMENTBOX);
3957         }
3958         return FALSE;
3959 }
3960
3961
3962 /** Checks whether the given style is normal code (not string, comment, preprocessor, etc).
3963  *
3964  * @param lexer Scintilla lexer type (@c SCLEX_*).
3965  * @param style Scintilla style (@c SCE_*).
3966  *
3967  * @return @c TRUE if the style is code, @c FALSE otherwise.
3968  */
3969 gboolean highlighting_is_code_style(gint lexer, gint style)
3970 {
3971         switch (lexer)
3972         {
3973                 case SCLEX_CPP:
3974                         if (style == SCE_C_PREPROCESSOR)
3975                                 return FALSE;
3976                         break;
3977         }
3978         return !(highlighting_is_comment_style(lexer, style) ||
3979                 highlighting_is_string_style(lexer, style));
3980 }
3981