mcabber: comparison mcabber/mcabber/screen.c

equal deleted inserted replaced

-:0dc317b5599d
+:ffd0e57e9563
 GList    *top;      // If top is NULL, we'll display the last lines
 char      cleared;  // For ex, user has issued a /clear command...
 char      lock;
 char      refcount; // refcount > 0 if there are other users of this struct
 // e.g. with symlinked history
-} buffdata;
+} buffdata_t;
 typedef struct {
 WINDOW *win;
 PANEL  *panel;
-buffdata *bd;
+buffdata_t *bd;
-} winbuf;
+} winbuf_t;
 struct dimensions {
 int l;
 int c;
 };
 static PANEL *rosterPanel, *chatPanel, *activechatPanel, *inputPanel;
 static PANEL *mainstatusPanel, *chatstatusPanel;
 static PANEL *logPanel;
 static int maxY, maxX;
 static int prev_chatwidth;
-static winbuf *statusWindow;
+static winbuf_t *statusWindow;
-static winbuf *currentWindow;
+static winbuf_t *currentWindow;
 static GList  *statushbuf;
 static int roster_hidden;
 static int chatmode;
 static int multimode;
 typedef struct {
 char *seqstr;
 guint mkeycode;
 gint  value;
-} keyseq;
+} keyseq_t;
 GSList *keyseqlist;
 static void add_keyseq(char *seqstr, guint mkeycode, gint value);
 static void scr_write_in_window(const char *winId, const char *text,
 #endif
 #ifdef WITH_ASPELL
 AspellConfig *config;
 AspellSpeller *checker;
 #endif
-} spell_checker;
+} spell_checker_t;
 GSList* spell_checkers = NULL;
 #endif
 typedef struct {
 int color_pair;
 int color_attrib;
-} ccolor;
+} ccolor_t;
 typedef struct {
 char *status, *wildcard;
-ccolor *color;
+ccolor_t *color;
 GPatternSpec *compiled;
-} rostercolor;
+} rostercolor_t;
 static GSList *rostercolrules = NULL;
 static GHashTable *muccolors = NULL, *nickcolors = NULL;
 typedef struct {
 bool manual; // Manually set?
-ccolor *color;
+ccolor_t *color;
-} nickcolor;
+} nickcolor_t;
 static int nickcolcount = 0;
-static ccolor ** nickcols = NULL;
+static ccolor_t ** nickcols = NULL;
-static muccoltype glob_muccol = MC_OFF;
+static muccol_t glob_muccol = MC_OFF;
 /* Functions */
 static int find_color(const char *name)
 {
 scr_LogPrint(LPRINT_LOGNORM, "ERROR: Wrong color: %s", name);
 return -1;
 }
-static ccolor *get_user_color(const char *color)
+static ccolor_t *get_user_color(const char *color)
 {
 bool isbright = FALSE;
 int cl;
-ccolor *ccol;
+ccolor_t *ccol;
 if (!strncmp(color, "bright", 6)) {
 isbright = TRUE;
 color += 6;
 }
 cl = find_color(color);
 if (cl < 0)
 return NULL;
-ccol = g_new0(ccolor, 1);
+ccol = g_new0(ccolor_t, 1);
 ccol->color_attrib = isbright ? A_BOLD : A_NORMAL;
 ccol->color_pair = cl + COLOR_max; // User colors come after the internal ones
 return ccol;
 }
 // Sets the coloring mode for given MUC
 // The MUC room does not need to be in the roster at that time
 // muc - the JID of room
 // type - the new type
-void scr_muc_color(const char *muc, muccoltype type)
+void scr_muc_color(const char *muc, muccol_t type)
 {
 gchar *muclow = g_utf8_strdown(muc, -1);
 if (type == MC_REMOVE) { // Remove it
 if (strcmp(muc, "*")) {
 if (muccolors && g_hash_table_lookup(muccolors, muclow))
 scr_LogPrint(LPRINT_NORMAL, "Can not remove global coloring mode");
 }
 g_free(muclow);
 } else { // Add or overwrite
 if (strcmp(muc, "*")) {
-muccoltype *value = g_new(muccoltype, 1);
+muccol_t *value = g_new(muccol_t, 1);
 *value = type;
 ensure_string_htable(&muccolors, g_free);
 g_hash_table_replace(muccolors, muclow, value);
 } else {
 glob_muccol = type;
 bool need_update = FALSE;
 snick = g_strdup_printf("<%s>", nick);
 mnick = g_strdup_printf("*%s ", nick);
 if (!strcmp(color, "-")) { // Remove the color
 if (nickcolors) {
-nickcolor *nc = g_hash_table_lookup(nickcolors, snick);
+nickcolor_t *nc = g_hash_table_lookup(nickcolors, snick);
 if (nc) { // Have this nick already
 nc->manual = FALSE;
 nc = g_hash_table_lookup(nickcolors, mnick);
 assert(nc); // Must have both at the same time
 nc->manual = FALSE;
 }
 g_free(snick); // They are not saved in the hash
 g_free(mnick);
 need_update = TRUE;
 } else {
-ccolor *cl = get_user_color(color);
+ccolor_t *cl = get_user_color(color);
 if (!cl) {
 scr_LogPrint(LPRINT_NORMAL, "No such color name");
 g_free(snick);
 g_free(mnick);
 } else {
-nickcolor *nc = g_new(nickcolor, 1);
+nickcolor_t *nc = g_new(nickcolor_t, 1);
 ensure_string_htable(&nickcolors, NULL);
 nc->manual = TRUE;
 nc->color = cl;
 // Free the struct, if any there already
 g_free(g_hash_table_lookup(nickcolors, mnick));
 if (need_update && chatmode &&
 (buddy_gettype(BUDDATA(current_buddy)) & ROSTER_TYPE_ROOM))
 scr_update_buddy_window();
 }
-static void free_rostercolrule(rostercolor *col)
+static void free_rostercolrule(rostercolor_t *col)
 {
 g_free(col->status);
 g_free(col->wildcard);
 g_free(col->color);
 g_pattern_spec_free(col->compiled);
 const char *color)
 {
 GSList *head;
 GSList *found = NULL;
 for (head = rostercolrules; head; head = g_slist_next(head)) {
-rostercolor *rc = head->data;
+rostercolor_t *rc = head->data;
 if ((!strcmp(status, rc->status)) && (!strcmp(wildcard, rc->wildcard))) {
 found = head;
 break;
 }
 }
 } else {
 scr_LogPrint(LPRINT_NORMAL, "No such color rule, nothing removed");
 return FALSE;
 }
 } else {
-ccolor *cl = get_user_color(color);
+ccolor_t *cl = get_user_color(color);
 if (!cl) {
 scr_LogPrint(LPRINT_NORMAL, "No such color name");
 return FALSE;
 }
 if (found) {
-rostercolor *rc = found->data;
+rostercolor_t *rc = found->data;
 g_free(rc->color);
 rc->color = cl;
 } else {
-rostercolor *rc = g_new(rostercolor, 1);
+rostercolor_t *rc = g_new(rostercolor_t, 1);
 rc->status = g_strdup(status);
 rc->wildcard = g_strdup(wildcard);
 rc->compiled = g_pattern_spec_new(wildcard);
 rc->color = cl;
 rostercolrules = g_slist_prepend(rostercolrules, rc);
 while (ncolors < ncolor_end && *ncolors) {
 if ((*ncolors == ' ') || (*ncolors == '\t')) {
 ncolors++;
 } else {
 char *end = ncolors;
-ccolor *cl;
+ccolor_t *cl;
 while (*end && (*end != ' ') && (*end != '\t'))
 end++;
 *end = '\0';
 cl = get_user_color(ncolors);
 if (!cl) {
 }
 g_free(ncolor_start);
 }
 if (!nickcols) { // Fallback to have something
 nickcolcount = 1;
-nickcols = g_new(ccolor*, 1);
+nickcols = g_new(ccolor_t*, 1);
-*nickcols = g_new(ccolor, 1);
+*nickcols = g_new(ccolor_t, 1);
 (*nickcols)->color_pair = COLOR_GENERAL;
 (*nickcols)->color_attrib = A_NORMAL;
 }
 }
 const gchar *message, gpointer user_data)
 {
 scr_log_print(LPRINT_NORMAL, "[%s] %s", log_domain, message);
 }
-static winbuf *scr_search_window(const char *winId, int special)
+static winbuf_t *scr_search_window(const char *winId, int special)
 {
 char *id;
-winbuf *wbp;
+winbuf_t *wbp;
 if (special)
 return statusWindow; // Only one special window atm.
 if (!winId)
 return (scr_search_window(bjid, FALSE) != NULL);
 }
 //  scr_new_buddy(title, dontshow)
 // Note: title (aka winId/jid) can be NULL for special buffers
-static winbuf *scr_new_buddy(const char *title, int dont_show)
+static winbuf_t *scr_new_buddy(const char *title, int dont_show)
 {
-winbuf *tmp;
+winbuf_t *tmp;
 char *id;
-tmp = g_new0(winbuf, 1);
+tmp = g_new0(winbuf_t, 1);
 tmp->win = activechatWnd;
 tmp->panel = activechatPanel;
 if (!dont_show) {
 }
 update_panels();
 // If title is NULL, this is a special buffer
 if (!title) {
-tmp->bd = g_new0(buffdata, 1);
+tmp->bd = g_new0(buffdata_t, 1);
 return tmp;
 }
 id = hlog_get_log_jid(title);
 if (id) {
 // This is a symlinked history log file.
 // Let's check if the target JID buffer has already been created.
-winbuf *wb = scr_search_window(id, FALSE);
+winbuf_t *wb = scr_search_window(id, FALSE);
 if (!wb)
 wb = scr_new_buddy(id, TRUE);
 tmp->bd = wb->bd;
 tmp->bd->refcount++;
 g_free(id);
 } else {  // Load buddy history from file (if enabled)
-tmp->bd = g_new0(buffdata, 1);
+tmp->bd = g_new0(buffdata_t, 1);
 hlog_read_history(title, &tmp->bd->hbuf, scr_gettextwidth());
 // Set a readmark to separate new content
 hbuf_set_readmark(tmp->bd->hbuf, TRUE);
 }
 return timepreflen;
 }
 //  scr_update_window()
 // (Re-)Display the given chat window.
-static void scr_update_window(winbuf *win_entry)
+static void scr_update_window(winbuf_t *win_entry)
 {
 int n, mark_offset = 0;
 guint prefixwidth;
 char pref[96];
 hbb_line **lines, *line;
 // The MUC nick - overwrite with proper color
 if (line->mucnicklen) {
 char *mucjid;
 char tmp;
-nickcolor *actual = NULL;
+nickcolor_t *actual = NULL;
-muccoltype type, *typetmp;
+muccol_t type, *typetmp;
 // Store the char after the nick
 tmp = line->text[line->mucnicklen];
 type = glob_muccol;
 // Terminate the string after the nick
 g_free(mucjid);
 // Need to generate a color for the specified nick?
 if ((type == MC_ALL) && (!nickcolors ||
 !g_hash_table_lookup(nickcolors, line->text))) {
 char *snick, *mnick;
-nickcolor *nc;
+nickcolor_t *nc;
 const char *p = line->text;
 unsigned int nicksum = 0;
 snick = g_strdup(line->text);
 mnick = g_strdup(line->text);
-nc = g_new(nickcolor, 1);
+nc = g_new(nickcolor_t, 1);
 ensure_string_htable(&nickcolors, NULL);
 while (*p)
 nicksum += *p++;
 nc->color = nickcols[nicksum % nickcolcount];
 nc->manual = FALSE;
 }
 g_free(lines);
 }
-static winbuf *scr_create_window(const char *winId, int special, int dont_show)
+static winbuf_t *scr_create_window(const char *winId, int special, int dont_show)
 {
 if (special) {
 if (!statusWindow) {
 statusWindow = scr_new_buddy(NULL, dont_show);
 statusWindow->bd->hbuf = statushbuf;
 //  scr_show_window()
 // Display the chat window with the given identifier.
 // "special" must be true if this is a special buffer window.
 static void scr_show_window(const char *winId, int special)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 win_entry = scr_search_window(winId, special);
 if (!win_entry) {
 win_entry = scr_create_window(winId, special, FALSE);
 static void scr_write_in_window(const char *winId, const char *text,
 time_t timestamp, unsigned int prefix_flags,
 int force_show, unsigned mucnicklen,
 gpointer xep184)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 char *text_locale;
 int dont_show = FALSE;
 int special;
 guint num_history_blocks;
 bool setmsgflg = FALSE;
 return;
 }
 static void resize_win_buffer(gpointer key, gpointer value, gpointer data)
 {
-winbuf *wbp = value;
+winbuf_t *wbp = value;
 struct dimensions *dim = data;
 int chat_x_pos, chat_y_pos;
 int new_chatwidth;
 if (!(wbp && wbp->win))
 wprintw(chatstatusWnd, "#");
 }
 }
 if (chatmode && !isgrp) {
-winbuf *win_entry;
+winbuf_t *win_entry;
 win_entry = scr_search_window(buddy_getjid(BUDDATA(current_buddy)), isspe);
 if (win_entry && win_entry->bd->lock)
 mvwprintw(chatstatusWnd, 0, 0, "*");
 }
 int color = get_color(COLOR_ROSTER);
 if ((!isspe) && (!isgrp)) { // Look for color rules
 GSList *head;
 const char *bjid = buddy_getjid(BUDDATA(buddy));
 for (head = rostercolrules; head; head = g_slist_next(head)) {
-rostercolor *rc = head->data;
+rostercolor_t *rc = head->data;
 if (g_pattern_match_string(rc->compiled, bjid) &&
 (!strcmp("*", rc->status) || strchr(rc->status, status))) {
 color = compose_color(rc->color);
 break;
 }
 scr_show_window(jidto, FALSE);
 }
 void scr_remove_receipt_flag(const char *bjid, gconstpointer xep184)
 {
-winbuf *win_entry = scr_search_window(bjid, FALSE);
+winbuf_t *win_entry = scr_search_window(bjid, FALSE);
 if (win_entry && xep184) {
 hbuf_remove_receipt(win_entry->bd->hbuf, xep184);
 if (chatmode && (buddy_search_jid(bjid) == current_buddy))
 scr_update_buddy_window();
 }
 // Scroll up/down the current buddy window,
 // - half a screen if nblines is 0,
 // - up if updown == -1, down if updown == 1
 void scr_buffer_scroll_up_down(int updown, unsigned int nblines)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 int n, nbl;
 GList *hbuf_top;
 guint isspe;
 // Get win_entry
 //  scr_buffer_clear()
 // Clear the current buddy window (used for the /clear command)
 void scr_buffer_clear(void)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 isspe = buddy_gettype(BUDDATA(current_buddy)) & ROSTER_TYPE_SPECIAL;
 update_panels();
 }
 //  buffer_purge()
 // key: winId/jid
-// value: winbuf structure
+// value: winbuf_t structure
 // data: int, set to 1 if the buffer should be closed.
 // NOTE: does not work for special buffers.
 // Returns TRUE IFF the win_entry can be closed and freed.
 static gboolean buffer_purge(gpointer key, gpointer value, gpointer data)
 {
 int *p_closebuf = data;
-winbuf *win_entry = value;
+winbuf_t *win_entry = value;
 gboolean retval = FALSE;
 // Delete the current hbuf
 // unless we close the buffer *and* this is a shared bd structure
 if (!(*p_closebuf && win_entry->bd->refcount))
 //  scr_buffer_purge(closebuf, jid)
 // Purge/Drop the current buddy buffer or jid's buffer if jid != NULL.
 // If closebuf is 1, close the buffer.
 void scr_buffer_purge(int closebuf, const char *jid)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 guint isspe;
 const char *cjid;
 char *ljid = NULL;
 guint hold_chatmode = FALSE;
 // lock = 1 : lock
 // lock = 0 : unlock
 // lock = -1: toggle lock status
 void scr_buffer_scroll_lock(int lock)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 isspe = buddy_gettype(BUDDATA(current_buddy)) & ROSTER_TYPE_SPECIAL;
 // If action = 1, set the readmark flag on the last message
 // If action = 0, reset the readmark flag
 // If action = -1, remove the readmark flag iff it is on the last line
 void scr_buffer_readmark(gchar action)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 guint isspe;
 int autolock;
 // Get win_entry
 if (!current_buddy) return;
 //  scr_buffer_top_bottom()
 // Jump to the head/tail of the current buddy window
 // (top if topbottom == -1, bottom topbottom == 1)
 void scr_buffer_top_bottom(int topbottom)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 isspe = buddy_gettype(BUDDATA(current_buddy)) & ROSTER_TYPE_SPECIAL;
 //  scr_buffer_search(direction, text)
 // Jump to the next line containing text
 // (backward search if direction == -1, forward if topbottom == 1)
 void scr_buffer_search(int direction, const char *text)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 GList *current_line, *search_res;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 //  scr_buffer_percent(n)
 // Jump to the specified position in the buffer, in %
 void scr_buffer_percent(int pc)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 GList *search_res;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 //  scr_buffer_date(t)
 // Jump to the first line after date t in the buffer
 // t is a date in seconds since `00:00:00 1970-01-01 UTC'
 void scr_buffer_date(time_t t)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 GList *search_res;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 //  scr_buffer_jump_readmark()
 // Jump to the buffer readmark, if there's one
 void scr_buffer_jump_readmark(void)
 {
-winbuf *win_entry;
+winbuf_t *win_entry;
 GList *search_res;
 guint isspe;
 // Get win_entry
 if (!current_buddy) return;
 g_free(extfname);
 }
 //  buffer_list()
 // key: winId/jid
-// value: winbuf structure
+// value: winbuf_t structure
 // data: none.
 static void buffer_list(gpointer key, gpointer value, gpointer data)
 {
 GList *head;
-winbuf *win_entry = value;
+winbuf_t *win_entry = value;
 head = g_list_first(win_entry->bd->hbuf);
 scr_LogPrint(LPRINT_NORMAL, " %s  (%u/%u)", (const char *) key,
 g_list_length(head), hbuf_get_blocks_number(head));
 if (special)
 current_id = buddy_getname(BUDDATA(current_buddy));
 else
 current_id = buddy_getjid(BUDDATA(current_buddy));
 if (current_id) {
-winbuf *win_entry = scr_search_window(current_id, special);
+winbuf_t *win_entry = scr_search_window(current_id, special);
 if (!win_entry) return;
 iscurrentlocked = win_entry->bd->lock;
 }
 } else {
 current_id = NULL;
 // TODO: avoid code duplication with scr_setmsgflag_if_needed()
 void scr_setattentionflag_if_needed(const char *bjid, int special,
 guint value, enum setuiprio_ops action)
 {
 const char *current_id;
-winbuf *wb;
+winbuf_t *wb;
 bool iscurrentlocked = FALSE;
 if (!bjid)
 return;
 if (special)
 current_id = buddy_getname(BUDDATA(current_buddy));
 else
 current_id = buddy_getjid(BUDDATA(current_buddy));
 if (current_id) {
-winbuf *win_entry = scr_search_window(current_id, special);
+winbuf_t *win_entry = scr_search_window(current_id, special);
 if (!win_entry) return;
 iscurrentlocked = win_entry->bd->lock;
 }
 } else {
 current_id = NULL;
 refresh_inputline();
 }
 static void add_keyseq(char *seqstr, guint mkeycode, gint value)
 {
-keyseq *ks;
+keyseq_t *ks;
 // Let's make sure the length is correct
 if (strlen(seqstr) > MAX_KEYSEQ_LENGTH) {
 scr_LogPrint(LPRINT_LOGNORM, "add_keyseq(): key sequence is too long!");
 return;
 }
-ks = g_new0(keyseq, 1);
+ks = g_new0(keyseq_t, 1);
 ks->seqstr = g_strdup(seqstr);
 ks->mkeycode = mkeycode;
 ks->value = value;
 keyseqlist = g_slist_append(keyseqlist, ks);
 }
 // Return value:
 // -1  if "seq" matches no known sequence
 //  0  if "seq" could match 1 or more known sequences
 // >0  if "seq" matches a key sequence; the mkey code is returned
 //     and *ret is set to the matching keyseq structure.
-static inline gint match_keyseq(int *iseq, keyseq **ret)
+static inline gint match_keyseq(int *iseq, keyseq_t **ret)
 {
 GSList *ksl;
-keyseq *ksp;
+keyseq_t *ksp;
 char *p, c;
 int *i;
 int needmore = FALSE;
 for (ksl = keyseqlist; ksl; ksl = g_slist_next(ksl)) {
 if (len)
 return 0;
 return c;
 }
-void scr_getch(keycode *kcode)
+void scr_getch(keycode_t *kcode)
 {
-keyseq *mks = NULL;
+keyseq_t *mks = NULL;
 int  ks[MAX_KEYSEQ_LENGTH+1];
 int i;
-memset(kcode, 0, sizeof(keycode));
+memset(kcode, 0, sizeof(keycode_t));
 memset(ks,  0, sizeof(ks));
 kcode->value = wgetch(inputWnd);
 if (utf8_mode) {
 bool ismeta = (kcode->value == 27);
 if (colors_stalled)
 parse_colors();
 doupdate();
 }
-static void bindcommand(keycode kcode)
+static void bindcommand(keycode_t kcode)
 {
 gchar asciikey[16], asciicode[16];
 const gchar *boundcmd;
 if (kcode.utf8)
 process_command(mkcmdstr("roster down"), TRUE);
 }
 //  scr_process_key(key)
 // Handle the pressed key, in the command line (bottom).
-void scr_process_key(keycode kcode)
+void scr_process_key(keycode_t kcode)
 {
 int key = kcode.value;
 int display_char = FALSE;
 int vi_search = FALSE;
 static int ex_or_search_mode = FALSE;
 }
 #if defined(WITH_ENCHANT) || defined(WITH_ASPELL)
 static void spell_checker_free(gpointer data)
 {
-spell_checker* sc = data;
+spell_checker_t *sc = data;
 #ifdef WITH_ENCHANT
 enchant_broker_free_dict(sc->broker, sc->checker);
 enchant_broker_free(sc->broker);
 #endif
 #ifdef WITH_ASPELL
 delete_aspell_config(sc->config);
 #endif
 g_free(sc);
 }
-static spell_checker* new_spell_checker(const char* spell_lang)
+static spell_checker_t* new_spell_checker(const char* spell_lang)
 {
-spell_checker* sc = g_new(spell_checker, 1);
+spell_checker_t *sc = g_new(spell_checker_t, 1);
 #ifdef WITH_ASPELL
 const char *spell_encoding = settings_opt_get("spell_encoding");
 AspellCanHaveError *possible_err;
 sc->config = new_aspell_config();
 if (spell_encoding)
 // initialization
 void spellcheck_init(void)
 {
 int spell_enable            = settings_opt_get_int("spell_enable");
 const char *spell_lang     = settings_opt_get("spell_lang");
-gchar** langs;
+gchar **langs;
-gchar** lang_iter;
+gchar **lang_iter;
-spell_checker* sc;
+spell_checker_t *sc;
 if (!spell_enable)
 return;
 spellcheck_deinit();
 }
 typedef struct {
 const char* str;
 int len;
-} spell_substring;
+} spell_substring_t;
 static int spellcheckword(gconstpointer sc_ptr, gconstpointer substr_ptr)
 {
-spell_checker* sc = (spell_checker*) sc_ptr;
+spell_checker_t *sc = (spell_checker_t*) sc_ptr;
-spell_substring* substr = (spell_substring*) substr_ptr;
+spell_substring_t *substr = (spell_substring_t*) substr_ptr;
 #ifdef WITH_ENCHANT
 // enchant_dict_check will return 0 on good word
 return enchant_dict_check(sc->checker, substr->str, substr->len);
 #endif
 #ifdef WITH_ASPELL
 // Spell checking function
 static void spellcheck(char *line, char *checked)
 {
 const char *start, *line_start;
-spell_substring substr;
+spell_substring_t substr;
 if (inputLine[0] == 0 || inputLine[0] == COMMAND_CHAR)
 return;
 // Give up early if not languages are loaded

changeset 2337	ffd0e57e9563
parent 2334	6ad3cada768c
child 2338	6424627913be