src/plugins/themes.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

/*
 * themes.c
 * vim: expandtab:ts=4:sts=4:sw=4
 *
 * Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
 *
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <https://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give permission to
 * link the code of portions of this program with the OpenSSL library under
 * certain conditions as described in each individual source file, and
 * distribute linked combinations including the two.
 *
 * You must obey the GNU General Public License in all respects for all of the
 * code used other than OpenSSL. If you modify file(s) with this exception, you
 * may extend this exception to your version of the file(s), but you are not
 * obligated to do so. If you do not wish to do so, delete this exception
 * statement from your version. If you delete this exception statement from all
 * source files in the program, then also delete it here.
 *
 */

#include "config.h"

#include <stdlib.h>

#include <glib.h>
#include <glib/gstdio.h>

#include "common.h"
#include "config/theme.h"
#include "config/files.h"

static GKeyFile* themes;

void
plugin_themes_init(void)
{
    char* themes_file = files_get_data_path(FILE_PLUGIN_THEMES);

    if (g_file_test(themes_file, G_FILE_TEST_EXISTS)) {
        g_chmod(themes_file, S_IRUSR | S_IWUSR);
    }

    themes = g_key_file_new();
    g_key_file_load_from_file(themes, themes_file, G_KEY_FILE_KEEP_COMMENTS, NULL);

    gsize g_data_size;
    gchar* g_data = g_key_file_to_data(themes, &g_data_size, NULL);
    g_file_set_contents(themes_file, g_data, g_data_size, NULL);
    g_chmod(themes_file, S_IRUSR | S_IWUSR);
    g_free(g_data);
    free(themes_file);
}

void
plugin_themes_close(void)
{
    g_key_file_free(themes);
    themes = NULL;
}

theme_item_t
plugin_themes_get(const char* const group, const char* const key, const char* const def)
{
    if (group && key && g_key_file_has_key(themes, group, key, NULL)) {
        gchar* result = g_key_file_get_string(themes, group, key, NULL);

        theme_item_t ret;

        if (g_strcmp0(result, "white") == 0)
            ret = THEME_WHITE;
        else if (g_strcmp0(result, "bold_white") == 0)
            ret = THEME_WHITE_BOLD;
        else if (g_strcmp0(result, "red") == 0)
            ret = THEME_RED;
        else if (g_strcmp0(result, "bold_red") == 0)
            ret = THEME_RED_BOLD;
        else if (g_strcmp0(result, "green") == 0)
            ret = THEME_GREEN;
        else if (g_strcmp0(result, "bold_green") == 0)
            ret = THEME_GREEN_BOLD;
        else if (g_strcmp0(result, "blue") == 0)
            ret = THEME_BLUE;
        else if (g_strcmp0(result, "bold_blue") == 0)
            ret = THEME_BLUE_BOLD;
        else if (g_strcmp0(result, "yellow") == 0)
            ret = THEME_YELLOW;
        else if (g_strcmp0(result, "bold_yellow") == 0)
            ret = THEME_YELLOW_BOLD;
        else if (g_strcmp0(result, "cyan") == 0)
            ret = THEME_CYAN;
        else if (g_strcmp0(result, "bold_cyan") == 0)
            ret = THEME_CYAN_BOLD;
        else if (g_strcmp0(result, "magenta") == 0)
            ret = THEME_MAGENTA;
        else if (g_strcmp0(result, "bold_magenta") == 0)
            ret = THEME_MAGENTA_BOLD;
        else if (g_strcmp0(result, "black") == 0)
            ret = THEME_BLACK;
        else if (g_strcmp0(result, "bold_black") == 0)
            ret = THEME_BLACK_BOLD;

        else if (g_strcmp0(def, "white") == 0)
            ret = THEME_WHITE;
        else if (g_strcmp0(def, "bold_white") == 0)
            ret = THEME_WHITE_BOLD;
        else if (g_strcmp0(def, "red") == 0)
            ret = THEME_RED;
        else if (g_strcmp0(def, "bold_red") == 0)
            ret = THEME_RED_BOLD;
        else if (g_strcmp0(def, "green") == 0)
            ret = THEME_GREEN;
        else if (g_strcmp0(def, "bold_green") == 0)
            ret = THEME_GREEN_BOLD;
        else if (g_strcmp0(def, "blue") == 0)
            ret = THEME_BLUE;
        else if (g_strcmp0(def, "bold_blue") == 0)
            ret = THEME_BLUE_BOLD;
        else if (g_strcmp0(def, "yellow") == 0)
            ret = THEME_YELLOW;
        else if (g_strcmp0(def, "bold_yellow") == 0)
            ret = THEME_YELLOW_BOLD;
        else if (g_strcmp0(def, "cyan") == 0)
            ret = THEME_CYAN;
        else if (g_strcmp0(def, "bold_cyan") == 0)
            ret = THEME_CYAN_BOLD;
        else if (g_strcmp0(def, "magenta") == 0)
            ret = THEME_MAGENTA;
        else if (g_strcmp0(def, "bold_magenta") == 0)
            ret = THEME_MAGENTA_BOLD;
        else if (g_strcmp0(def, "black") == 0)
            ret = THEME_BLACK;
        else if (g_strcmp0(def, "bold_black") == 0)
            ret = THEME_BLACK_BOLD;

        else
            ret = THEME_TEXT;

        g_free(result);

        return ret;

    } else {
        if (g_strcmp0(def, "white") == 0)
            return THEME_WHITE;
        else if (g_strcmp0(def, "bold_white") == 0)
            return THEME_WHITE_BOLD;
        else if (g_strcmp0(def, "red") == 0)
            return THEME_RED;
        else if (g_strcmp0(def, "bold_red") == 0)
            return THEME_RED_BOLD;
        else if (g_strcmp0(def, "green") == 0)
            return THEME_GREEN;
        else if (g_strcmp0(def, "bold_green") == 0)
            return THEME_GREEN_BOLD;
        else if (g_strcmp0(def, "blue") == 0)
            return THEME_BLUE;
        else if (g_strcmp0(def, "bold_blue") == 0)
            return THEME_BLUE_BOLD;
        else if (g_strcmp0(def, "yellow") == 0)
            return THEME_YELLOW;
        else if (g_strcmp0(def, "bold_yellow") == 0)
            return THEME_YELLOW_BOLD;
        else if (g_strcmp0(def, "cyan") == 0)
            return THEME_CYAN;
        else if (g_strcmp0(def, "bold_cyan") == 0)
            return THEME_CYAN_BOLD;
        else if (g_strcmp0(def, "magenta") == 0)
            return THEME_MAGENTA;
        else if (g_strcmp0(def, "bold_magenta") == 0)
            return THEME_MAGENTA_BOLD;
        else if (g_strcmp0(def, "black") == 0)
            return THEME_BLACK;
        else if (g_strcmp0(def, "bold_black") == 0)
            return THEME_BLACK_BOLD;

        else
            return THEME_TEXT;
    }
}
/* 
 * windows.c
 *
 * Copyright (C) 2012 James Booth <boothj5@gmail.com>
 * 
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <glib.h>
#ifdef HAVE_LIBNOTIFY
#include <libnotify/notify.h>
#endif
#ifdef HAVE_NCURSES_H
#include <ncurses.h>
#endif
#ifdef HAVE_NCURSES_NCURSES_H
#include <ncurses/ncurses.h>
#endif

#include "command.h"
#include "contact.h"
#include "log.h"
#include "preferences.h"
#include "ui.h"

#define CONS_WIN_TITLE "_cons"
#define PAD_SIZE 200
#define NUM_WINS 10

// holds console at index 0 and chat wins 1 through to 9
static struct prof_win _wins[NUM_WINS];

// the window currently being displayed
static int _curr_prof_win = 0;

// shortcut pointer to console window
static WINDOW * _cons_win = NULL;

// current window state
static int dirty;

// max columns for main windows, never resize below
static int max_cols = 0;

static void _create_windows(void);
static void _cons_splash_logo(void);
static void _cons_show_basic_help(void);
static int _find_prof_win_index(const char * const contact);
static int _new_prof_win(const char * const contact);
static void _current_window_refresh(void);
static void _win_switch_if_active(const int i);
static void _win_show_time(WINDOW *win);
static void _win_show_user(WINDOW *win, const char * const user, const int colour);
static void _win_show_message(WINDOW *win, const char * const message);
static void _show_status_string(WINDOW *win, const char * const from, 
    const char * const show, const char * const status, const char * const pre, 
    const char * const default_show);
static void _cons_show_typing(const char * const short_from);
static void _cons_show_incoming_message(const char * const short_from, 
    const int win_index);
static void _win_handle_switch(const int * const ch);
static void _win_handle_page(const int * const ch);
static void _win_resize_all(void);
static gint _win_get_unread(void);

#ifdef HAVE_LIBNOTIFY
static void _win_notify(const char * const message, int timeout, 
    const char * const category);
static void _win_notify_remind(gint unread);
static void _win_notify_message(char * short_from);
static void _win_notify_typing(char * short_from);
#endif

void
gui_init(void)
{
    log_info("Initialising UI");
    initscr();
    cbreak();
    keypad(stdscr, TRUE);

    if (has_colors()) {    
        use_default_colors();
        start_color();

        init_pair(1, prefs_get_text(), prefs_get_bkgnd());
        init_pair(2, prefs_get_online(), prefs_get_bkgnd());
        init_pair(3, prefs_get_text(), prefs_get_bar());
        init_pair(4, prefs_get_bar_draw(), prefs_get_bar());
        init_pair(5, prefs_get_offline(), prefs_get_bkgnd());
        init_pair(6, prefs_get_err(), prefs_get_bkgnd());
        init_pair(7, prefs_get_inc(), prefs_get_bkgnd());
        init_pair(8, prefs_get_bar_text(), prefs_get_bar());

        //statuses
        init_pair(9, prefs_get_away(), prefs_get_bkgnd());
        init_pair(10, prefs_get_chat(), prefs_get_bkgnd());
        init_pair(11, prefs_get_dnd(), prefs_get_bkgnd());
        init_pair(12, prefs_get_xa(), prefs_get_bkgnd());
    }

    refresh();

    create_title_bar();
    create_status_bar();
    create_input_window();
    _create_windows();

    dirty = TRUE;
}

void
gui_refresh(void)
{
    title_bar_refresh();
    status_bar_refresh();

    if (dirty) {
        _current_window_refresh();
        dirty = FALSE;
    }

    inp_put_back();
}

void
gui_close(void)
{
#ifdef HAVE_LIBNOTIFY
    if (notify_is_initted()) {
        notify_uninit();
    }
#endif
    endwin();
}

void
gui_resize(const int ch, const char * const input, const int size)
{
    log_info("Resizing UI");
    title_bar_resize();
    status_bar_resize();
    _win_resize_all();
    inp_win_resize(input, size);
    dirty = TRUE;
}

int
win_close_win(void)
{
    if (win_in_chat()) {
        // reset the chat win to unused
        strcpy(_wins[_curr_prof_win].from, "");
        wclear(_wins[_curr_prof_win].win);

        // set it as inactive in the status bar
        status_bar_inactive(_curr_prof_win);
        
        // go back to console window
        _curr_prof_win = 0;
        title_bar_title();

        dirty = TRUE;
    
        // success
        return 1;
    } else {
        // didn't close anything
        return 0;
    }
}

int
win_in_chat(void)
{
    return ((_curr_prof_win != 0) && 
        (strcmp(_wins[_curr_prof_win].from, "") != 0));
}

char *
win_get_recipient(void)
{
    struct prof_win current = _wins[_curr_prof_win];
    char *recipient = (char *) malloc(sizeof(char) * (strlen(current.from) + 1));
    strcpy(recipient, current.from);
    return recipient;
}

void 
win_show_typing(const char * const from)
{
    char from_cpy[strlen(from) + 1];
    strcpy(from_cpy, from);
    char *short_from = strtok(from_cpy, "/");

    int win_index = _find_prof_win_index(short_from);

    // no chat window for user
    if (win_index == NUM_WINS) {
        _cons_show_typing(short_from);

    // have chat window but not currently in it
    } else if (win_index != _curr_prof_win) {
        _cons_show_typing(short_from);
        dirty = TRUE;

    // in chat window with user
    } else {
        title_bar_set_typing(TRUE);
        title_bar_draw();

        status_bar_active(win_index);
        dirty = TRUE;
   }

#ifdef HAVE_LIBNOTIFY
    if (prefs_get_notify())
        _win_notify_typing(short_from);
#endif
}

void
win_remind(void)
{
#ifdef HAVE_LIBNOTIFY
    gint unread = _win_get_unread();
    if (unread > 0) {
        _win_notify_remind(unread);
    }
#endif
}

void
win_show_incomming_msg(const char * const from, const char * const message) 
{
    char from_cpy[strlen(from) + 1];
    strcpy(from_cpy, from);
    char *short_from = strtok(from_cpy, "/");

    int win_index = _find_prof_win_index(short_from);
    if (win_index == NUM_WINS)
        win_index = _new_prof_win(short_from);

    WINDOW *win = _wins[win_index].win;
    _win_show_time(win);
    _win_show_user(win, short_from, 1);
    _win_show_message(win, message);
    
    // currently viewing chat window with sender
    if (win_index == _curr_prof_win) {
        title_bar_set_typing(FALSE);
        title_bar_draw();
        status_bar_active(win_index);
        dirty = TRUE;

    // not currently viewing chat window with sender
    } else {
        status_bar_new(win_index);
        _cons_show_incoming_message(short_from, win_index);
        if (prefs_get_flash())
            flash();

        _wins[win_index].unread++;
    }

    if (prefs_get_beep())
        beep();
#ifdef HAVE_LIBNOTIFY
    if (prefs_get_notify())
        _win_notify_message(short_from);
#endif
}

#ifdef HAVE_LIBNOTIFY
static void
_win_notify(const char * const message, int timeout, 
    const char * const category)
{
    gboolean notify_initted = notify_is_initted();

    if (!notify_initted) {
        notify_initted = notify_init("Profanity");
    }

    if (notify_initted) {
        NotifyNotification *notification;
        notification = notify_notification_new("Profanity", message, NULL);
        notify_notification_set_timeout(notification, timeout);
        notify_notification_set_category(notification, category);
        notify_notification_set_urgency(notification, NOTIFY_URGENCY_NORMAL);

        GError *error = NULL;
        notify_notification_show(notification, &error);
    } else {
        log_error("Libnotify initialisation error.");
    }
}

static void
_win_notify_remind(gint unread)
{
    char message[20];
    if (unread == 1) {
        sprintf(message, "1 unread message");
    } else {
        sprintf(message, "%d unread messages", unread);
    }
    
    _win_notify(message, 5000, "Incoming message");
}

static void
_win_notify_message(char * short_from)
{
    char message[strlen(short_from) + 1 + 10];
    sprintf(message, "%s: message.", short_from);
   
    _win_notify(message, 10000, "Incoming message"); 
}

static void
_win_notify_typing(char * short_from)
{
    char message[strlen(short_from) + 1 + 11];
    sprintf(message, "%s: typing...", short_from);
    
    _win_notify(message, 10000, "Incoming message");
}
#endif

void
win_show_outgoing_msg(const char * const from, const char * const to, 
    const char * const message)
{
    int win_index = _find_prof_win_index(to);
    if (win_index == NUM_WINS) 
        win_index = _new_prof_win(to);

    WINDOW *win = _wins[win_index].win;
    _win_show_time(win);
    _win_show_user(win, from, 0);
    _win_show_message(win, message);
    
    status_bar_active(win_index);
    
    if (win_index == _curr_prof_win) {
        dirty = TRUE;
    } else {
        status_bar_new(win_index);
    }
}

void
win_show(const char * const msg)
{
    WINDOW *win = _wins[_curr_prof_win].win;
    _win_show_time(win);
    wprintw(win, "%s\n", msg); 

    dirty = TRUE;
}

void
win_bad_show(const char * const msg)
{
    WINDOW *win = _wins[_curr_prof_win].win;
    _win_show_time(win);
    wattron(win, COLOUR_ERR);
    wprintw(win, "%s\n", msg);
    wattroff(win, COLOUR_ERR);
    
    dirty = TRUE;
}

void
win_contact_online(const char * const from, const char * const show, 
    const char * const status)
{
    _show_status_string(_cons_win, from, show, status, "++", "online");

    int win_index = _find_prof_win_index(from);
    if (win_index != NUM_WINS) {
        WINDOW *win = _wins[win_index].win;
        _show_status_string(win, from, show, status, "++", "online");
    }
    
    if (win_index == _curr_prof_win)
        dirty = TRUE;
}

void
win_contact_offline(const char * const from, const char * const show, 
    const char * const status)
{
    _show_status_string(_cons_win, from, show, status, "--", "offline");

    int win_index = _find_prof_win_index(from);
    if (win_index != NUM_WINS) {
        WINDOW *win = _wins[win_index].win;
        _show_status_string(win, from, show, status, "--", "offline");
    }
    
    if (win_index == _curr_prof_win)
        dirty = TRUE;
}

void
win_disconnected(void)
{
    int i;
    // show message in all active chats
    for (i = 1; i < NUM_WINS; i++) {
        if (strcmp(_wins[i].from, "") != 0) {
            WINDOW *win = _wins[_curr_prof_win].win;
            _win_show_time(win);
            wattron(win, COLOUR_ERR);
            wprintw(win, "%s\n", "Lost connection.");
            wattroff(win, COLOUR_ERR);
    
            // if current win, set dirty
            if (i == _curr_prof_win) {
                dirty = TRUE;
            }
        }
    }
}

void
cons_prefs(void)
{
    cons_show("");
    cons_show("Current preferences:");
    cons_show("");
    
    if (prefs_get_beep())
        cons_show("Terminal beep           : ON");
    else
        cons_show("Terminal beep           : OFF");    
    
    if (prefs_get_flash())
        cons_show("Terminal flash          : ON");
    else
        cons_show("Terminal flash          : OFF");    
    
    if (prefs_get_notify())
        cons_show("Message notifications   : ON");
    else
        cons_show("Message notifications   : OFF");    

    if (prefs_get_typing())
        cons_show("Typing notifications    : ON");
    else
        cons_show("Typing notifications    : OFF");    

    if (prefs_get_showsplash())
        cons_show("Splash screen           : ON");
    else
        cons_show("Splash screen           : OFF");    
    
    if (prefs_get_chlog())
        cons_show("Chat logging            : ON");
    else
        cons_show("Chat logging            : OFF");    

    char remind_period[50];
    sprintf(remind_period, 
                  "Message reminder period : %d seconds", prefs_get_remind());

    cons_show(remind_period);

    cons_show("");

    if (_curr_prof_win == 0)
        dirty = TRUE;
}

static void
_cons_show_basic_help(void)
{
    cons_show("");

    GSList *basic_helpers = cmd_get_basic_help();
    while (basic_helpers != NULL) {
        struct cmd_help_t *help = (struct cmd_help_t *)basic_helpers->data;
        char line[25 + 2 + strlen(help->short_help)];
        sprintf(line, "%-25s: %s", help->usage, help->short_help);
        cons_show(line);
        basic_helpers = g_slist_next(basic_helpers);
    }

    cons_show("");
}

void
cons_help(void)
{
    cons_show("");
    cons_show("Basic Commands:");
    _cons_show_basic_help();

    cons_show("Settings:");
    cons_show("");

    GSList *settings_helpers = cmd_get_settings_help();
    while (settings_helpers != NULL) {
        struct cmd_help_t *help = (struct cmd_help_t *)settings_helpers->data;
        char line[25 + 2 + strlen(help->short_help)];
        sprintf(line, "%-25s: %s", help->usage, help->short_help);
        cons_show(line);
        settings_helpers = g_slist_next(settings_helpers);
    }

    cons_show("");
    cons_show("Status changes:");
    cons_show("");

    GSList *status_helpers = cmd_get_status_help();
    while (status_helpers != NULL) {
        struct cmd_help_t *help = (struct cmd_help_t *)status_helpers->data;
        char line[25 + 2 + strlen(help->short_help)];
        sprintf(line, "%-25s: %s", help->usage, help->short_help);
        cons_show(line);
        status_helpers = g_slist_next(status_helpers);
    }

    cons_show("");
    cons_show("Navigation:");
    cons_show("");
    cons_show("F1                       : This console window.");
    cons_show("F2-F10                   : Chat windows.");
    cons_show("UP, DOWN                 : Navigate input history.");
    cons_show("LEFT, RIGHT, HOME, END   : Edit current input.");
    cons_show("TAB                      : Autocomplete command/recipient/login");
    cons_show("PAGE UP, PAGE DOWN       : Page the main window.");
    cons_show("");

    if (_curr_prof_win == 0)
        dirty = TRUE;
}

void
cons_show_online_contacts(GSList *list)
{
    _win_show_time(_cons_win);
    wprintw(_cons_win, "Online contacts:\n");

    GSList *curr = list;

    while(curr) {
        PContact contact = curr->data;
        _win_show_time(_cons_win);
        const char *show = p_contact_show(contact);    

        if (strcmp(show, "online") == 0) {
            wattron(_cons_win, COLOUR_ONLINE);
        } else if (strcmp(show, "away") == 0) {
            wattron(_cons_win, COLOUR_AWAY);
        } else if (strcmp(show, "chat") == 0) {
            wattron(_cons_win, COLOUR_CHAT);
        } else if (strcmp(show, "dnd") == 0) {
            wattron(_cons_win, COLOUR_DND);
        } else if (strcmp(show, "xa") == 0) {
            wattron(_cons_win, COLOUR_XA);
        } else {
            wattron(_cons_win, COLOUR_OFFLINE);
        }

        wprintw(_cons_win, "%s", p_contact_name(contact));
        wprintw(_cons_win, " is %s", show);
    
        if (p_contact_status(contact))
            wprintw(_cons_win, ", \"%s\"", p_contact_status(contact));
    
        wprintw(_cons_win, "\n");

        if (strcmp(show, "online") == 0) {
            wattroff(_cons_win, COLOUR_ONLINE);
        } else if (strcmp(show, "away") == 0) {
            wattroff(_cons_win, COLOUR_AWAY);
        } else if (strcmp(show, "chat") == 0) {
            wattroff(_cons_win, COLOUR_CHAT);
        } else if (strcmp(show, "dnd") == 0) {
            wattroff(_cons_win, COLOUR_DND);
        } else if (strcmp(show, "xa") == 0) {
            wattroff(_cons_win, COLOUR_XA);
        } else {
            wattroff(_cons_win, COLOUR_OFFLINE);
        }

        curr = g_slist_next(curr);
    }
}

void
cons_bad_show(const char * const msg)
{
    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_ERR);
    wprintw(_cons_win, "%s\n", msg);
    wattroff(_cons_win, COLOUR_ERR);
    
    if (_curr_prof_win == 0)
        dirty = TRUE;
}

void
cons_show(const char * const msg)
{
    _win_show_time(_cons_win);
    wprintw(_cons_win, "%s\n", msg); 
    
    if (_curr_prof_win == 0)
        dirty = TRUE;
}

void
cons_bad_command(const char * const cmd)
{
    _win_show_time(_cons_win);
    wprintw(_cons_win, "Unknown command: %s\n", cmd);
    
    if (_curr_prof_win == 0)
        dirty = TRUE;
}

void
win_handle_special_keys(const int * const ch)
{
    _win_handle_switch(ch);
    _win_handle_page(ch);
}

void
win_page_off(void)
{
    int rows = getmaxy(stdscr);
    _wins[_curr_prof_win].paged = 0;
    
    int y = getcury(_wins[_curr_prof_win].win);

    int size = rows - 3;

    _wins[_curr_prof_win].y_pos = y - (size - 1);
    if (_wins[_curr_prof_win].y_pos < 0)
        _wins[_curr_prof_win].y_pos = 0;

    dirty = TRUE;
}

static void
_create_windows(void)
{
    int rows, cols;
    getmaxyx(stdscr, rows, cols);
    max_cols = cols;

    // create the console window in 0
    struct prof_win cons;
    strcpy(cons.from, CONS_WIN_TITLE);
    cons.win = newpad(PAD_SIZE, cols);
    wbkgd(cons.win, COLOUR_TEXT);
    cons.y_pos = 0;
    cons.paged = 0;
    cons.unread = 0;
    scrollok(cons.win, TRUE);

    _wins[0] = cons;
    _cons_win = _wins[0].win;
    
    if (prefs_get_showsplash()) {
        _cons_splash_logo();
    } else {
        _win_show_time(_cons_win);
        wprintw(_cons_win, "Welcome to Profanity, version %s\n", PACKAGE_VERSION);
    }

    _win_show_time(_cons_win);
    wprintw(_cons_win, "Copyright (C) 2012 James Booth <%s>.\n", PACKAGE_BUGREPORT);
    _win_show_time(_cons_win);
    wprintw(_cons_win, "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "This is free software; you are free to change and redistribute it.\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "There is NO WARRANTY, to the extent permitted by law.\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "Type '/help' to show complete help.\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "\n");
        
    prefresh(_cons_win, 0, 0, 1, 0, rows-3, cols-1);

    dirty = TRUE;
    
    // create the chat windows
    int i;
    for (i = 1; i < NUM_WINS; i++) {
        struct prof_win chat;
        strcpy(chat.from, "");
        chat.win = newpad(PAD_SIZE, cols);
        wbkgd(chat.win, COLOUR_TEXT);
        chat.y_pos = 0;
        chat.paged = 0;
        chat.unread = 0;
        scrollok(chat.win, TRUE);
        _wins[i] = chat;
    }    
}

static void
_cons_splash_logo(void)
{
    _win_show_time(_cons_win);
    wprintw(_cons_win, "Welcome to\n");


    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "                   ___            _           \n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "                  / __)          (_)_         \n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, " ____   ____ ___ | |__ ____ ____  _| |_ _   _ \n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "|  _ \\ / ___) _ \\|  __) _  |  _ \\| |  _) | | |\n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "| | | | |  | |_| | | ( ( | | | | | | |_| |_| |\n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "| ||_/|_|   \\___/|_|  \\_||_|_| |_|_|\\___)__  |\n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_OFFLINE);
    wprintw(_cons_win, "|_|                                    (____/ \n");
    wattroff(_cons_win, COLOUR_OFFLINE);

    _win_show_time(_cons_win);
    wprintw(_cons_win, "\n");
    _win_show_time(_cons_win);
    wprintw(_cons_win, "Version %s\n", PACKAGE_VERSION);
}

static int
_find_prof_win_index(const char * const contact)
{
    // find the chat window for recipient
    int i;
    for (i = 1; i < NUM_WINS; i++)
        if (strcmp(_wins[i].from, contact) == 0)
            break;

    return i;
}

static int
_new_prof_win(const char * const contact)
{
    int i;
    // find the first unused one
    for (i = 1; i < NUM_WINS; i++)
        if (strcmp(_wins[i].from, "") == 0)
            break;

    // set it up
    strcpy(_wins[i].from, contact);
    wclear(_wins[i].win);

    return i;
}

static void
_win_switch_if_active(const int i)
{
    win_page_off();
    if (strcmp(_wins[i].from, "") != 0) {
        _curr_prof_win = i;
        win_page_off();
        
        _wins[i].unread = 0;

        if (i == 0) {
            title_bar_title();
        } else {
            title_bar_set_recipient(_wins[i].from);
            title_bar_draw();;
            status_bar_active(i);
        }
    }

    dirty = TRUE;
}

static void
_win_show_time(WINDOW *win)
{
    GDateTime *time = g_date_time_new_now_local(); 
    gchar *date_fmt = g_date_time_format(time, "%H:%M");
    wprintw(win, "%s - ", date_fmt);
    g_date_time_unref(time);
    g_free(date_fmt);
}

static void
_win_show_user(WINDOW *win, const char * const user, const int colour)
{
    if (colour)
        wattron(win, COLOUR_ONLINE);
    wprintw(win, "%s: ", user);
    if (colour)
        wattroff(win, COLOUR_ONLINE);
}

static void
_win_show_message(WINDOW *win, const char * const message)
{
    wprintw(win, "%s\n", message);
}

static void
_current_window_refresh(void)
{
    int rows, cols;
    getmaxyx(stdscr, rows, cols);

    WINDOW *current = _wins[_curr_prof_win].win;
    prefresh(current, _wins[_curr_prof_win].y_pos, 0, 1, 0, rows-3, cols-1);
}

void
_win_resize_all(void)
{
    int rows, cols;
    getmaxyx(stdscr, rows, cols);

    // only make the pads bigger, to avoid data loss on cropping
    if (cols > max_cols) {
        max_cols = cols;

        int i;
        for (i = 0; i < NUM_WINS; i++) {
            wresize(_wins[i].win, PAD_SIZE, cols);
        }
    }
    
    WINDOW *current = _wins[_curr_prof_win].win;
    prefresh(current, _wins[_curr_prof_win].y_pos, 0, 1, 0, rows-3, cols-1);
}

static void
_show_status_string(WINDOW *win, const char * const from, 
    const char * const show, const char * const status, const char * const pre, 
    const char * const default_show)
{
    _win_show_time(win);    

    if (show != NULL) {
        if (strcmp(show, "away") == 0) {
            wattron(win, COLOUR_AWAY);
        } else if (strcmp(show, "chat") == 0) {
            wattron(win, COLOUR_CHAT);
        } else if (strcmp(show, "dnd") == 0) {
            wattron(win, COLOUR_DND);
        } else if (strcmp(show, "xa") == 0) {
            wattron(win, COLOUR_XA);
        }
    } else if (strcmp(default_show, "online") == 0) {
        wattron(win, COLOUR_ONLINE);
    } else {
        wattron(win, COLOUR_OFFLINE);
    }

    wprintw(win, "%s %s", pre, from);

    if (show != NULL) 
        wprintw(win, " is %s", show);
    else
        wprintw(win, " is %s", default_show);
        
    if (status != NULL)
        wprintw(win, ", \"%s\"", status);
    
    wprintw(win, "\n");
    
    if (show != NULL) {
        if (strcmp(show, "away") == 0) {
            wattroff(win, COLOUR_AWAY);
        } else if (strcmp(show, "chat") == 0) {
            wattroff(win, COLOUR_CHAT);
        } else if (strcmp(show, "dnd") == 0) {
            wattroff(win, COLOUR_DND);
        } else if (strcmp(show, "xa") == 0) {
            wattroff(win, COLOUR_XA);
        }
    } else if (strcmp(default_show, "online") == 0) {
        wattroff(win, COLOUR_ONLINE);
    } else {
        wattroff(win, COLOUR_OFFLINE);
    }
}

static void
_cons_show_typing(const char * const short_from)
{
    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_INC);
    wprintw(_cons_win, "!! %s is typing a message...\n", short_from);
    wattroff(_cons_win, COLOUR_INC);
}

static void
_cons_show_incoming_message(const char * const short_from, const int win_index)
{
    _win_show_time(_cons_win);
    wattron(_cons_win, COLOUR_INC);
    wprintw(_cons_win, "<< incoming from %s (%d)\n", short_from, win_index + 1);
    wattroff(_cons_win, COLOUR_INC);
}

static void
_win_handle_switch(const int * const ch)
{
    if (*ch == KEY_F(1)) {
        _win_switch_if_active(0);
    } else if (*ch == KEY_F(2)) {
        _win_switch_if_active(1);
    } else if (*ch == KEY_F(3)) {
        _win_switch_if_active(2);
    } else if (*ch == KEY_F(4)) {
        _win_switch_if_active(3);
    } else if (*ch == KEY_F(5)) {
        _win_switch_if_active(4);
    } else if (*ch == KEY_F(6)) {
        _win_switch_if_active(5);
    } else if (*ch == KEY_F(7)) {
        _win_switch_if_active(6);
    } else if (*ch == KEY_F(8)) {
        _win_switch_if_active(7);
    } else if (*ch == KEY_F(9)) {
        _win_switch_if_active(8);
    } else if (*ch == KEY_F(10)) {
        _win_switch_if_active(9);
    }
}

static void
_win_handle_page(const int * const ch)
{
    int rows = getmaxy(stdscr);
    int y = getcury(_wins[_curr_prof_win].win);

    int page_space = rows - 4;
    int *page_start = &_wins[_curr_prof_win].y_pos;
    
    // page up
    if (*ch == KEY_PPAGE) {
        *page_start -= page_space;
    
        // went past beginning, show first page
        if (*page_start < 0)
            *page_start = 0;
       
        _wins[_curr_prof_win].paged = 1;
        dirty = TRUE;

    // page down
    } else if (*ch == KEY_NPAGE) {
        *page_start += page_space;

        // only got half a screen, show full screen
        if ((y - (*page_start)) < page_space)
            *page_start = y - page_space;

        // went past end, show full screen
        else if (*page_start >= y)
            *page_start = y - page_space;
           
        _wins[_curr_prof_win].paged = 1;
        dirty = TRUE;
    }
}

static gint
_win_get_unread(void)
{
    int i;
    gint result = 0;
    for (i = 0; i < NUM_WINS; i++) {
        result += _wins[i].unread;
    }
    return result;
}