static void prompt_onDraw(ToxWindow *self, Tox *m)
{
int x2, y2;
getmaxyx(self->window, y2, x2);
ChatContext *ctx = self->chatwin;
pthread_mutex_lock(&Winthread.lock);
line_info_print(self);
pthread_mutex_unlock(&Winthread.lock);
wclear(ctx->linewin);
curs_set(1);
if (ctx->len > 0)
mvwprintw(ctx->linewin, 1, 0, "%ls", &ctx->line[ctx->start]);
StatusBar *statusbar = self->stb;
mvwhline(statusbar->topline, 1, 0, ACS_HLINE, x2);
wmove(statusbar->topline, 0, 0);
pthread_mutex_lock(&Winthread.lock);
TOX_CONNECTION connection = statusbar->connection;
pthread_mutex_unlock(&Winthread.lock);
if (connection != TOX_CONNECTION_NONE) {
int colour = MAGENTA;
const char *status_text = "ERROR";
pthread_mutex_lock(&Winthread.lock);
TOX_USER_STATUS status = statusbar->status;
pthread_mutex_unlock(&Winthread.lock);
switch (status) {
case TOX_USER_STATUS_NONE:
status_text = "Online";
colour = GREEN;
break;
case TOX_USER_STATUS_AWAY:
status_text = "Away";
colour = YELLOW;
break;
case TOX_USER_STATUS_BUSY:
status_text = "Busy";
colour = RED;
break;
}
wattron(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
wprintw(statusbar->topline, " [%s]", status_text);
wattroff(statusbar->topline, COLOR_PAIR(colour) | A_BOLD);
wattron(statusbar->topline, A_BOLD);
pthread_mutex_lock(&Winthread.lock);
wprintw(statusbar->topline, " %s", statusbar->nick);
pthread_mutex_unlock(&Winthread.lock);
wattroff(statusbar->topline, A_BOLD);
} else {
wprintw(statusbar->topline, " [Offline]");
wattron(statusbar->topline, A_BOLD);
pthread_mutex_lock(&Winthread.lock);
wprintw(statusbar->topline, " %s", statusbar->nick);
pthread_mutex_unlock(&Winthread.lock);
wattroff(statusbar->topline, A_BOLD);
}
/* Reset statusbar->statusmsg on window resize */
if (x2 != self->x) {
char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
pthread_mutex_lock(&Winthread.lock);
size_t slen = tox_self_get_status_message_size(m);
tox_self_get_status_message (m, (uint8_t*) statusmsg);
statusmsg[slen] = '\0';
snprintf(statusbar->statusmsg, sizeof(statusbar->statusmsg), "%s", statusmsg);
statusbar->statusmsg_len = strlen(statusbar->statusmsg);
pthread_mutex_unlock(&Winthread.lock);
}
self->x = x2;
/* Truncate note if it doesn't fit in statusbar */
uint16_t maxlen = x2 - getcurx(statusbar->topline) - 3;
pthread_mutex_lock(&Winthread.lock);
if (statusbar->statusmsg_len > maxlen) {
statusbar->statusmsg[maxlen - 3] = '\0';
strcat(statusbar->statusmsg, "...");
statusbar->statusmsg_len = maxlen;
}
if (statusbar->statusmsg[0])
wprintw(statusbar->topline, " : %s", statusbar->statusmsg);
pthread_mutex_unlock(&Winthread.lock);
mvwhline(self->window, y2 - CHATBOX_HEIGHT, 0, ACS_HLINE, x2);
int y, x;
getyx(self->window, y, x);
(void) x;
int new_x = ctx->start ? x2 - 1 : MAX(0, wcswidth(ctx->line, ctx->pos));
wmove(self->window, y + 1, new_x);
wrefresh(self->window);
if (self->help->active)
help_onDraw(self);
}
int con_x()
{
return getcurx(conio_scr)+1;
}
static void friendlist_onDraw(ToxWindow *self, Tox *m)
{
curs_set(0);
werase(self->window);
int x2, y2;
getmaxyx(self->window, y2, x2);
bool fix_statuses = x2 != self->x; /* true if window max x value has changed */
wattron(self->window, COLOR_PAIR(CYAN));
wprintw(self->window, " Press the");
wattron(self->window, A_BOLD);
wprintw(self->window, " h ");
wattroff(self->window, A_BOLD);
wprintw(self->window, "key for help\n\n");
wattroff(self->window, COLOR_PAIR(CYAN));
if (blocklist_view == 1) {
blocklist_onDraw(self, m, y2, x2);
return;
}
uint64_t cur_time = get_unix_time();
struct tm cur_loc_tm = *localtime((const time_t *) &cur_time);
wattron(self->window, A_BOLD);
wprintw(self->window, " Online: ");
wattroff(self->window, A_BOLD);
wprintw(self->window, "%d/%d \n\n", Friends.num_online, Friends.num_friends);
if ((y2 - FLIST_OFST) <= 0)
return;
uint32_t selected_num = 0;
/* Determine which portion of friendlist to draw based on current position */
int page = Friends.num_selected / (y2 - FLIST_OFST);
int start = (y2 - FLIST_OFST) * page;
int end = y2 - FLIST_OFST + start;
int i;
for (i = start; i < Friends.num_friends && i < end; ++i) {
uint32_t f = Friends.index[i];
bool f_selected = false;
if (Friends.list[f].active) {
if (i == Friends.num_selected) {
wattron(self->window, A_BOLD);
wprintw(self->window, " > ");
wattroff(self->window, A_BOLD);
selected_num = f;
f_selected = true;
} else {
wprintw(self->window, " ");
}
if (Friends.list[f].connection_status != TOX_CONNECTION_NONE) {
TOX_USER_STATUS status = Friends.list[f].status;
int colour = MAGENTA;
switch (status) {
case TOX_USER_STATUS_NONE:
colour = GREEN;
break;
case TOX_USER_STATUS_AWAY:
colour = YELLOW;
break;
case TOX_USER_STATUS_BUSY:
colour = RED;
break;
}
wattron(self->window, COLOR_PAIR(colour) | A_BOLD);
wprintw(self->window, "%s ", ONLINE_CHAR);
wattroff(self->window, COLOR_PAIR(colour) | A_BOLD);
if (f_selected)
wattron(self->window, COLOR_PAIR(BLUE));
wattron(self->window, A_BOLD);
wprintw(self->window, "%s", Friends.list[f].name);
wattroff(self->window, A_BOLD);
if (f_selected)
wattroff(self->window, COLOR_PAIR(BLUE));
/* Reset Friends.list[f].statusmsg on window resize */
if (fix_statuses) {
char statusmsg[TOX_MAX_STATUS_MESSAGE_LENGTH];
pthread_mutex_lock(&Winthread.lock);
tox_friend_get_status_message(m, Friends.list[f].num, (uint8_t *) statusmsg, NULL);
size_t s_len = tox_friend_get_status_message_size(m, Friends.list[f].num, NULL);
statusmsg[s_len] = '\0';
pthread_mutex_unlock(&Winthread.lock);
filter_str(statusmsg, s_len);
snprintf(Friends.list[f].statusmsg, sizeof(Friends.list[f].statusmsg), "%s", statusmsg);
Friends.list[f].statusmsg_len = strlen(Friends.list[f].statusmsg);
}
/* Truncate note if it doesn't fit on one line */
size_t maxlen = x2 - getcurx(self->window) - 2;
if (Friends.list[f].statusmsg_len > maxlen) {
Friends.list[f].statusmsg[maxlen - 3] = '\0';
strcat(Friends.list[f].statusmsg, "...");
Friends.list[f].statusmsg[maxlen] = '\0';
Friends.list[f].statusmsg_len = maxlen;
}
if (Friends.list[f].statusmsg_len > 0)
wprintw(self->window, " %s", Friends.list[f].statusmsg);
wprintw(self->window, "\n");
} else {
wprintw(self->window, "%s ", OFFLINE_CHAR);
if (f_selected)
wattron(self->window, COLOR_PAIR(BLUE));
wattron(self->window, A_BOLD);
wprintw(self->window, "%s", Friends.list[f].name);
wattroff(self->window, A_BOLD);
if (f_selected)
wattroff(self->window, COLOR_PAIR(BLUE));
uint64_t last_seen = Friends.list[f].last_online.last_on;
if (last_seen != 0) {
int day_dist = (
cur_loc_tm.tm_yday - Friends.list[f].last_online.tm.tm_yday
+ ((cur_loc_tm.tm_year - Friends.list[f].last_online.tm.tm_year) * 365)
);
const char *hourmin = Friends.list[f].last_online.hour_min_str;
switch (day_dist) {
case 0:
wprintw(self->window, " Last seen: Today %s\n", hourmin);
break;
case 1:
wprintw(self->window, " Last seen: Yesterday %s\n", hourmin);
break;
default:
wprintw(self->window, " Last seen: %d days ago\n", day_dist);
break;
}
} else {
wprintw(self->window, " Last seen: Never\n");
}
}
}
}
self->x = x2;
if (Friends.num_friends) {
wmove(self->window, y2 - 1, 1);
wattron(self->window, A_BOLD);
wprintw(self->window, "Key: ");
wattroff(self->window, A_BOLD);
int i;
for (i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
wprintw(self->window, "%02X", Friends.list[selected_num].pub_key[i] & 0xff);
}
wrefresh(self->window);
draw_del_popup();
if (self->help->active)
help_onDraw(self);
}
static int
Remainder(WINDOW *txtwin)
{
int result = getmaxx(txtwin) - getcurx(txtwin);
return (result > 0) ? result : 0;
}
/*
* wyswietla ponownie linie wprowadzenia tekstu (prompt + aktualnie wpisany tekst)
* przy okazji jesli jest aspell to sprawdza czy tekst jest poprawny.
*/
void ncurses_redraw_input(unsigned int ch) {
int x, y;
/* draw prompt */
werase(input);
wmove(input, 0, 0);
if (!ncurses_lines) {
gchar *tmp = ekg_recode_to_locale(format_find(
ncurses_current->prompt ? "ncurses_prompt_query" : "ncurses_prompt_none"));
gchar *tmp2 = format_string(tmp, "\037"); /* unit separator */
fstring_t *prompt_f = fstring_new(tmp2);
gchar *s = prompt_f->str, *s2;
fstr_attr_t *a = prompt_f->attr, *a2;
g_free(tmp2);
g_free(tmp);
if (ncurses_current->prompt) {
/* find our \037 */
for (s2 = s, a2 = a; *s2 != '\037'; s2++, a2++)
g_assert(*s2);
*s2 = '\0'; /* and split the original string using it */
}
ncurses_fstring_print(input, s, a, -1);
if (ncurses_current->prompt) {
if (!ncurses_simple_print(input, ncurses_current->prompt,
*a2, input->_maxx / 4)) {
/* don't change colors or anything
* just disable bold to distinguish */
wattroff(input, A_BOLD); /* XXX? */
waddstr(input, ncurses_hellip);
}
s2++, a2++;
ncurses_fstring_print(input, s2, a2, -1);
}
fstring_free(prompt_f);
}
getyx(input, y, x);
ncurses_current->prompt_len = x;
/* XXX: cleanup, optimize */
{
int cur_posx = -1, cur_posy = 0;
const int width = input->_maxx - x;
if ((line_index - line_start >= width) || (line_index - line_start < 2))
line_start = line_index - width/2;
if (line_start < 0)
line_start = 0;
ncurses_redraw_input_already_exec = 1;
wattrset(input, color_pair(COLOR_WHITE, COLOR_BLACK));
if (ncurses_lines) {
int i, x;
cur_posy = lines_index - lines_start;
for (i = 0; i < MULTILINE_INPUT_SIZE; i++) {
if (!ncurses_lines[lines_start + i])
break;
wmove(input, i, 0);
x = ncurses_redraw_input_line(ncurses_lines[lines_start + i]);
if (lines_index == (lines_start + i))
cur_posx = x;
}
wattrset(input, color_pair(COLOR_BLACK, COLOR_BLACK) | A_BOLD);
if (lines_start>0)
mvwaddch(input, 0, input->_maxx, '^');
if (g_strv_length((char **) ncurses_lines)-lines_start > MULTILINE_INPUT_SIZE)
mvwaddch(input, MULTILINE_INPUT_SIZE-1, input->_maxx, 'v');
wattrset(input, A_NORMAL);
} else {
#if 0
if (ncurses_noecho) {
static char *funnything = ncurses_funnything;
waddch(input, ' '); /* XXX why here? If you want to add space after propt, add it in theme */
waddch(input, *funnything);
wmove(input, 0, getcurx(input)-1);
if (!*(++funnything))
funnything = ncurses_funnything;
return;
}
#endif
cur_posx = ncurses_redraw_input_line(ncurses_line);
}
/* this mut be here if we don't want 'timeout' after pressing ^C */
if (ch == 3) ncurses_commit();
if (cur_posx != -1) {
wmove(input, cur_posy, cur_posx);
curs_set(1);
} else {
wmove(input, 0, 0); // XXX ???
curs_set(0);
}
}
}
static void
draw_status(struct nh_player_info *pi, nh_bool threeline)
{
char buf[ui_flags.mapwidth];
int i, j, k;
if (!statuswin)
return;
if (ui_flags.statusheight < 2) {
werase(statuswin);
return;
}
/* penultimate line */
wmove(statuswin, (threeline ? 1 : 0), 0);
draw_bar(15, pi->hp, pi->hpmax, TRUE);
wprintw(statuswin, " Def:%d %s:%d", 10 - pi->ac,
pi->monnum == pi->cur_monnum ? "Xp" : "HD", pi->level);
if (threeline && pi->monnum == pi->cur_monnum) {
/* keep this synced with newuexp in exper.c */
long newuexp = 10L * (1L << pi->level);
if (pi->level >= 10)
newuexp = 10000L * (1L << (pi->level - 10));
if (pi->level >= 20)
newuexp = 10000000L * ((long)(pi->level - 19));
wprintw(statuswin, "(%ld)", newuexp - pi->xp);
}
wprintw(statuswin, " %s", pi->level_desc);
wclrtoeol(statuswin);
/* last line */
wmove(statuswin, (threeline ? 2 : 1), 0);
draw_bar(15, pi->en, pi->enmax, FALSE);
wprintw(statuswin, " %c%ld S:%ld T:%ld", pi->coinsym, pi->gold, pi->score,
pi->moves);
if (getcurx(statuswin) > 0)
wclrtoeol(statuswin);
/* status */
int mainframe_color = CLR_GRAY;
j = getmaxx(statuswin) + 1;
for (i = 0; i < pi->nr_items; i++) {
int color = CLR_WHITE, colorattr;
j -= strlen(pi->statusitems[i]) + 1;
for (k = 0; statuscolors[k].name; k++) {
if (!strcmp(pi->statusitems[i], statuscolors[k].name)) {
color = statuscolors[k].color;
if (statuscolors[k].framecolor != -1)
mainframe_color = statuscolors[k].framecolor;
break;
}
}
colorattr = curses_color_attr(color, 0);
wmove(statuswin, (threeline ? 2 : 1), j);
wattron(statuswin, colorattr);
wprintw(statuswin, "%s", pi->statusitems[i]);
wattroff(statuswin, colorattr);
}
/* frame color */
if (pi->hp * 7 <= pi->hpmax)
mainframe_color = CLR_ORANGE;
else if (pi->hp * 3 <= pi->hpmax)
mainframe_color = CLR_RED;
if (ui_flags.current_followmode != FM_PLAY)
mainframe_color = CLR_BLACK; /* a hint that we can't write */
/* We change the frame color via palette manipulation, because it's awkward
to correctly redraw otherwise. However, we don't want to do color
mapping logic here. So we copy an existing palette entry. */
uncursed_color fgcode, bgcode;
pair_content(PAIR_NUMBER(curses_color_attr(mainframe_color, 0)),
&fgcode, &bgcode);
init_pair(MAINFRAME_PAIR, fgcode, bgcode);
/* name */
if (threeline) {
sprintf(buf, "%.12s the %s %s", pi->plname,
(pi->align == A_CHAOTIC) ? "Chaotic" :
(pi->align == A_NEUTRAL) ? "Neutral" :
"Lawful", pi->rank);
wmove(statuswin, 0, 0);
} else {
sprintf(buf, "%.12s, %s", pi->plname, pi->rank);
wmove(statuswin, 0, getmaxx(statuswin) - strlen(buf));
}
wprintw(statuswin, "%s", buf);
if (getcurx(statuswin) > 0)
wclrtoeol(statuswin);
/* abilities (in threeline mode) "In:18 Wi:18 Ch:18" = 17 chars */
if (threeline) {
wmove(statuswin, 0, getmaxx(statuswin) - (pi->st == 18 ? 20 : 17));
wprintw(statuswin, "Dx:%-2d Co:%-2d St:%-2d", pi->dx, pi->co, pi->st);
if (pi->st == 18 && pi->st_extra == 100)
wprintw(statuswin, "/**");
else if (pi->st == 18)
wprintw(statuswin, "/%02d", pi->st_extra);
wmove(statuswin, 1, getmaxx(statuswin) - (pi->st == 18 ? 20 : 17));
wprintw(statuswin, "In:%-2d Wi:%-2d Ch:%-2d", pi->in, pi->wi, pi->ch);
}
}
/* Readline callback.
Redisplay the command line with its prompt after readline has
changed the edited text. */
void
tui_redisplay_readline (void)
{
int prev_col;
int height;
int col;
int c_pos;
int c_line;
int in;
WINDOW *w;
const char *prompt;
int start_line;
/* Detect when we temporarily left SingleKey and now the readline
edit buffer is empty, automatically restore the SingleKey
mode. The restore must only be done if the command has finished.
The command could call prompt_for_continue and we must not
restore SingleKey so that the prompt and normal keymap are used. */
if (tui_current_key_mode == TUI_ONE_COMMAND_MODE && rl_end == 0
&& !gdb_in_secondary_prompt_p (current_ui))
tui_set_key_mode (TUI_SINGLE_KEY_MODE);
if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
prompt = "";
else
prompt = tui_rl_saved_prompt;
c_pos = -1;
c_line = -1;
w = TUI_CMD_WIN->generic.handle;
start_line = TUI_CMD_WIN->detail.command_info.start_line;
wmove (w, start_line, 0);
prev_col = 0;
height = 1;
for (in = 0; prompt && prompt[in]; in++)
{
waddch (w, prompt[in]);
col = getcurx (w);
if (col <= prev_col)
height++;
prev_col = col;
}
for (in = 0; in <= rl_end; in++)
{
unsigned char c;
if (in == rl_point)
{
getyx (w, c_line, c_pos);
}
if (in == rl_end)
break;
c = (unsigned char) rl_line_buffer[in];
if (CTRL_CHAR (c) || c == RUBOUT)
{
waddch (w, '^');
waddch (w, CTRL_CHAR (c) ? UNCTRL (c) : '?');
}
else if (c == '\t')
{
/* Expand TABs, since ncurses on MS-Windows doesn't. */
col = getcurx (w);
do
{
waddch (w, ' ');
col++;
} while ((col % 8) != 0);
}
else
{
waddch (w, c);
}
if (c == '\n')
TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
col = getcurx (w);
if (col < prev_col)
height++;
prev_col = col;
}
wclrtobot (w);
TUI_CMD_WIN->detail.command_info.start_line = getcury (w);
if (c_line >= 0)
wmove (w, c_line, c_pos);
TUI_CMD_WIN->detail.command_info.start_line -= height - 1;
wrefresh (w);
fflush(stdout);
}
/*#DOC*/
int view_curX(View v)
{
return getcurx(view_win(v));
}
static void
_win_print(ProfWin *window, const char show_char, int pad_indent, GDateTime *time,
int flags, theme_item_t theme_item, const char * const from, const char * const message, DeliveryReceipt *receipt)
{
// flags : 1st bit = 0/1 - me/not me
// 2nd bit = 0/1 - date/no date
// 3rd bit = 0/1 - eol/no eol
// 4th bit = 0/1 - color from/no color from
// 5th bit = 0/1 - color date/no date
gboolean me_message = FALSE;
int offset = 0;
int colour = theme_attrs(THEME_ME);
size_t indent = 0;
char *time_pref = NULL;
switch (window->type) {
case WIN_CHAT:
time_pref = prefs_get_string(PREF_TIME_CHAT);
break;
case WIN_MUC:
time_pref = prefs_get_string(PREF_TIME_MUC);
break;
case WIN_MUC_CONFIG:
time_pref = prefs_get_string(PREF_TIME_MUCCONFIG);
break;
case WIN_PRIVATE:
time_pref = prefs_get_string(PREF_TIME_PRIVATE);
break;
case WIN_XML:
time_pref = prefs_get_string(PREF_TIME_XMLCONSOLE);
break;
default:
time_pref = prefs_get_string(PREF_TIME_CONSOLE);
break;
}
gchar *date_fmt = NULL;
if (g_strcmp0(time_pref, "off") == 0) {
date_fmt = g_strdup("");
} else {
date_fmt = g_date_time_format(time, time_pref);
}
prefs_free_string(time_pref);
assert(date_fmt != NULL);
if(strlen(date_fmt) != 0){
indent = 3 + strlen(date_fmt);
}
if ((flags & NO_DATE) == 0) {
if (date_fmt && strlen(date_fmt)) {
if ((flags & NO_COLOUR_DATE) == 0) {
wattron(window->layout->win, theme_attrs(THEME_TIME));
}
wprintw(window->layout->win, "%s %c ", date_fmt, show_char);
if ((flags & NO_COLOUR_DATE) == 0) {
wattroff(window->layout->win, theme_attrs(THEME_TIME));
}
}
}
if (strlen(from) > 0) {
if (flags & NO_ME) {
colour = theme_attrs(THEME_THEM);
}
if (flags & NO_COLOUR_FROM) {
colour = 0;
}
if (receipt && !receipt->received) {
colour = theme_attrs(THEME_RECEIPT_SENT);
}
wattron(window->layout->win, colour);
if (strncmp(message, "/me ", 4) == 0) {
wprintw(window->layout->win, "*%s ", from);
offset = 4;
me_message = TRUE;
} else {
wprintw(window->layout->win, "%s: ", from);
wattroff(window->layout->win, colour);
}
}
if (!me_message) {
if (receipt && !receipt->received) {
wattron(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
} else {
wattron(window->layout->win, theme_attrs(theme_item));
}
}
if (prefs_get_boolean(PREF_WRAP)) {
_win_print_wrapped(window->layout->win, message+offset, indent, pad_indent);
} else {
wprintw(window->layout->win, "%s", message+offset);
}
if ((flags & NO_EOL) == 0) {
int curx = getcurx(window->layout->win);
if (curx != 0) {
wprintw(window->layout->win, "\n");
}
}
if (me_message) {
wattroff(window->layout->win, colour);
} else {
if (receipt && !receipt->received) {
wattroff(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
} else {
wattroff(window->layout->win, theme_attrs(theme_item));
}
}
g_free(date_fmt);
}
static void
_win_print_wrapped(WINDOW *win, const char * const message, size_t indent, int pad_indent)
{
int starty = getcury(win);
int wordi = 0;
char *word = malloc(strlen(message) + 1);
gchar *curr_ch = g_utf8_offset_to_pointer(message, 0);
while (*curr_ch != '\0') {
// handle space
if (*curr_ch == ' ') {
waddch(win, ' ');
curr_ch = g_utf8_next_char(curr_ch);
// handle newline
} else if (*curr_ch == '\n') {
waddch(win, '\n');
_win_indent(win, indent + pad_indent);
curr_ch = g_utf8_next_char(curr_ch);
// handle word
} else {
wordi = 0;
int wordlen = 0;
while (*curr_ch != ' ' && *curr_ch != '\n' && *curr_ch != '\0') {
size_t ch_len = mbrlen(curr_ch, 4, NULL);
int offset = 0;
while (offset < ch_len) {
word[wordi++] = curr_ch[offset++];
}
curr_ch = g_utf8_next_char(curr_ch);
}
word[wordi] = '\0';
wordlen = utf8_display_len(word);
int curx = getcurx(win);
int cury = getcury(win);
int maxx = getmaxx(win);
// wrap required
if (curx + wordlen > maxx) {
int linelen = maxx - (indent + pad_indent);
// word larger than line
if (wordlen > linelen) {
gchar *word_ch = g_utf8_offset_to_pointer(word, 0);
while(*word_ch != '\0') {
curx = getcurx(win);
cury = getcury(win);
gboolean firstline = cury == starty;
if (firstline && curx < indent) {
_win_indent(win, indent);
}
if (!firstline && curx < (indent + pad_indent)) {
_win_indent(win, indent + pad_indent);
}
gchar copy[wordi+1];
g_utf8_strncpy(copy, word_ch, 1);
waddstr(win, copy);
word_ch = g_utf8_next_char(word_ch);
}
// newline and print word
} else {
waddch(win, '\n');
curx = getcurx(win);
cury = getcury(win);
gboolean firstline = cury == starty;
if (firstline && curx < indent) {
_win_indent(win, indent);
}
if (!firstline && curx < (indent + pad_indent)) {
_win_indent(win, indent + pad_indent);
}
waddstr(win, word);
}
// no wrap required
} else {
curx = getcurx(win);
cury = getcury(win);
gboolean firstline = cury == starty;
if (firstline && curx < indent) {
_win_indent(win, indent);
}
if (!firstline && curx < (indent + pad_indent)) {
_win_indent(win, indent + pad_indent);
}
waddstr(win, word);
}
}
// consume first space of next line
int curx = getcurx(win);
int cury = getcury(win);
gboolean firstline = (cury == starty);
if (!firstline && curx == 0 && *curr_ch == ' ') {
curr_ch = g_utf8_next_char(curr_ch);
}
}
free(word);
}
void tx_wcoloreol(WINDOW *win)
{
scrollok(win, 0);
wprintw(win, "%*c", getmaxx(win) - getcurx(win) - 1, ' ');
}
