src/highlighting.c

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