{

const int ColorsTable[] =

{

COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW,

COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE

};

# ifdef XCURSES

Xinitscr(1, const_cast<char **>(&window_title));

# else

initscr();

# endif // XCURSES

if (has_colors() && enable_colors)

{

start_color();

use_default_colors();

int num = 1;

# ifdef USE_PDCURSES

int i = 0;

# else

int i = -1;

# endif // USE_PDCURSES

for (; i < 8; ++i)

for (int j = 0; j < 8; ++j)

init_pair(num++, ColorsTable[j], i < 0 ? i : ColorsTable[i]);

}

noecho();

cbreak();

curs_set(0);

{

curs_set(1);

endwin();

size_t starty,

size_t width,

size_t height,

const std::string &title,

Color color,

Border border)

: m_window(0),

m_border_window(0),

m_start_x(startx),

m_start_y(starty),

m_width(width),

m_height(height),

m_window_timeout(-1),

m_color(color),

m_bg_color(Color::Default),

m_base_color(color),

m_base_bg_color(Color::Default),

m_border(border),

m_get_string_helper(0),

m_title(title),

m_history(0),

m_bold_counter(0),

m_underline_counter(0),

m_reverse_counter(0),

m_alt_charset_counter(0)

{

if (m_start_x > size_t(COLS)

|| m_start_y > size_t(LINES)

|| m_width+m_start_x > size_t(COLS)

|| m_height+m_start_y > size_t(LINES))

FatalError("Constructed window is bigger than terminal size");

if (m_border != Border::None)

{

m_border_window = newpad(m_height, m_width);

wattron(m_border_window, COLOR_PAIR(int(m_border)));

box(m_border_window, 0, 0);

m_start_x++;

m_start_y++;

m_width -= 2;

m_height -= 2;

}

if (!m_title.empty())

{

m_start_y += 2;

m_height -= 2;

}

m_window = newpad(m_height, m_width);

setColor(m_color);

keypad(m_window, 1);

: m_window(dupwin(rhs.m_window))

, m_border_window(dupwin(rhs.m_border_window))

, m_start_x(rhs.m_start_x)

, m_start_y(rhs.m_start_y)

, m_width(rhs.m_width)

, m_height(rhs.m_height)

, m_window_timeout(rhs.m_window_timeout)

, m_color(rhs.m_color)

, m_bg_color(rhs.m_bg_color)

, m_base_color(rhs.m_base_color)

, m_base_bg_color(rhs.m_base_bg_color)

, m_border(rhs.m_border)

, m_get_string_helper(rhs.m_get_string_helper)

, m_title(rhs.m_title)

, m_color_stack(rhs.m_color_stack)

, m_input_queue(rhs.m_input_queue)

, m_fds(rhs.m_fds)

, m_history(rhs.m_history ? new std::list<std::wstring>(*rhs.m_history) : 0)

, m_bold_counter(rhs.m_bold_counter)

, m_underline_counter(rhs.m_underline_counter)

, m_reverse_counter(rhs.m_reverse_counter)

, m_alt_charset_counter(rhs.m_alt_charset_counter)

{

: m_window(rhs.m_window)

, m_border_window(rhs.m_border_window)

, m_start_x(rhs.m_start_x)

, m_start_y(rhs.m_start_y)

, m_width(rhs.m_width)

, m_height(rhs.m_height)

, m_window_timeout(rhs.m_window_timeout)

, m_color(rhs.m_color)

, m_bg_color(rhs.m_bg_color)

, m_base_color(rhs.m_base_color)

, m_base_bg_color(rhs.m_base_bg_color)

, m_border(rhs.m_border)

, m_get_string_helper(rhs.m_get_string_helper)

, m_title(std::move(rhs.m_title))

, m_color_stack(std::move(rhs.m_color_stack))

, m_input_queue(std::move(rhs.m_input_queue))

, m_fds(std::move(rhs.m_fds))

, m_history(rhs.m_history)

, m_bold_counter(rhs.m_bold_counter)

, m_underline_counter(rhs.m_underline_counter)

, m_reverse_counter(rhs.m_reverse_counter)

, m_alt_charset_counter(rhs.m_alt_charset_counter)

{

rhs.m_window = 0;

rhs.m_border_window = 0;

rhs.m_history = 0;

{

if (fg == Color::Default)

fg = m_base_color;

if (fg != Color::Default)

wattron(m_window, COLOR_PAIR(int(bg)*8+int(fg)));

else

wattroff(m_window, COLOR_PAIR(int(m_color)));

m_color = fg;

m_bg_color = bg;

{

m_base_color = fg;

m_base_bg_color = bg;

{

if (border == Border::None && m_border != Border::None)

{

delwin(m_border_window);

m_start_x--;

m_start_y--;

m_height += 2;

m_width += 2;

recreate(m_width, m_height);

}

else if (border != Border::None && m_border == Border::None)

{

m_border_window = newpad(m_height, m_width);

wattron(m_border_window, COLOR_PAIR(int(border)));

box(m_border_window,0,0);

m_start_x++;

m_start_y++;

m_height -= 2;

m_width -= 2;

recreate(m_width, m_height);

}

else

{

wattron(m_border_window,COLOR_PAIR(int(border)));

box(m_border_window, 0, 0);

}

m_border = border;

{

if (m_title == new_title)

{

return;

}

else if (!new_title.empty() && m_title.empty())

{

m_start_y += 2;

m_height -= 2;

recreate(m_width, m_height);

}

else if (new_title.empty() && !m_title.empty())

{

m_start_y -= 2;

m_height += 2;

recreate(m_width, m_height);

}

m_title = new_title;

{

if (!m_history)

m_history = new std::list<std::wstring>;

{

delete m_history;

m_history = 0;

{

delwin(m_window);

m_window = newpad(height, width);

setTimeout(m_window_timeout);

setColor(m_color, m_bg_color);

keypad(m_window, 1);

{

m_start_x = new_x;

m_start_y = new_y;

if (m_border != Border::None)

{

m_start_x++;

m_start_y++;

}

if (!m_title.empty())

m_start_y += 2;

{

if (m_border != Border::None)

{

delwin(m_border_window);

m_border_window = newpad(height, width);

wattron(m_border_window, COLOR_PAIR(int(m_border)));

box(m_border_window, 0, 0);

width -= 2;

height -= 2;

}

if (!m_title.empty())

height -= 2;

m_height = height;

m_width = width;

{

adjustDimensions(new_width, new_height);

recreate(m_width, m_height);

{

if (m_border != Border::None)

{

::refresh();

prefresh(m_border_window, 0, 0, getStarty(), getStartX(), m_start_y+m_height, m_start_x+m_width);

}

if (!m_title.empty())

{

if (m_border != Border::None)

attron(COLOR_PAIR(int(m_border)));

else

attron(COLOR_PAIR(int(m_base_color)));

mvhline(m_start_y-1, m_start_x, 0, m_width);

attron(A_BOLD);

mvhline(m_start_y-2, m_start_x, 32, m_width); // clear title line

mvaddstr(m_start_y-2, m_start_x, m_title.c_str());

attroff(COLOR_PAIR(int(m_border)) | A_BOLD);

}

::refresh();

{

showBorder();

refresh();

{

m_window_timeout = timeout;

wtimeout(m_window, timeout);

{

int result;

// if there are characters in input queue, get them and

// return immediately.

if (!m_input_queue.empty())

{

result = m_input_queue.front();

m_input_queue.pop();

return result;

}

// in pdcurses polling stdin doesn't work, so we can't poll

// both stdin and other file descriptors in one select. the

// workaround is to set the timeout of select to 0, poll

// other file descriptors and then wait for stdin input with

// the given timeout. unfortunately, this results in delays

// since ncmpcpp doesn't see that data arrived while waiting

// for input from stdin, but it seems there is no better option.

fd_set fdset;

FD_ZERO(&fdset);

# if !defined(USE_PDCURSES)

FD_SET(STDIN_FILENO, &fdset);

timeval timeout = { m_window_timeout/1000, (m_window_timeout%1000)*1000 };

# else

timeval timeout = { 0, 0 };

# endif

int fd_max = STDIN_FILENO;

for (FDCallbacks::const_iterator it = m_fds.begin(); it != m_fds.end(); ++it)

{

if (it->first > fd_max)

fd_max = it->first;

FD_SET(it->first, &fdset);

}

if (select(fd_max+1, &fdset, 0, 0, m_window_timeout < 0 ? 0 : &timeout) > 0)

{

# if !defined(USE_PDCURSES)

result = FD_ISSET(STDIN_FILENO, &fdset) ? wgetch(m_window) : ERR;

# endif // !USE_PDCURSES

for (FDCallbacks::const_iterator it = m_fds.begin(); it != m_fds.end(); ++it)

if (FD_ISSET(it->first, &fdset))

it->second();

}

# if !defined(USE_PDCURSES)

else

result = ERR;

# else

result = wgetch(m_window);

# endif

return result;

{

int input;

size_t beginning, maxbeginning, minx, x, real_x, y, maxx, real_maxx;

getyx(m_window, y, x);

minx = real_maxx = maxx = real_x = x;

width--;

if (width == size_t(-1))

width = m_width-x-1;

curs_set(1);

std::wstring wbase = ToWString(base);

std::wstring *tmp = &wbase;

std::list<std::wstring>::iterator history_it = m_history->end();

std::string tmp_in;

wchar_t wc_in;

bool gotoend = 1;

bool block_scrolling = 0;

// disable scrolling if wide chars are used

for (std::wstring::const_iterator it = tmp->begin(); it != tmp->end(); ++it)

if (wcwidth(*it) > 1)

block_scrolling = 1;

beginning = -1;

do

{

if (tmp->empty())

block_scrolling = 0;

maxbeginning = block_scrolling ? 0 : (tmp->length() < width ? 0 : tmp->length()-width);

maxx = minx + (wideLength(*tmp) < width ? wideLength(*tmp) : width);

real_maxx = minx + (tmp->length() < width ? tmp->length() : width);

if (beginning > maxbeginning)

beginning = maxbeginning;

if (gotoend)

{

size_t real_real_maxx = minx;

size_t biggest_x = minx+width;

if (block_scrolling && maxx >= biggest_x)

{

size_t i = 0;

for (std::wstring::const_iterator it = tmp->begin(); i < width; ++it, ++real_real_maxx)

i += wcwidth(*it);

}

else

real_real_maxx = real_maxx;

real_x = real_real_maxx;

x = block_scrolling ? (maxx > biggest_x ? biggest_x : maxx) : maxx;

beginning = maxbeginning;

gotoend = 0;

}

mvwhline(m_window, y, minx, ' ', width+1);

if (!encrypted)

mvwprintw(m_window, y, minx, "%ls", tmp->substr(beginning, width+1).c_str());

else

mvwhline(m_window, y, minx, '*', maxx-minx);

if (m_get_string_helper)

{

if (!m_get_string_helper(*tmp))

break;

}

wmove(m_window, y, x);

prefresh(m_window, 0, 0, m_start_y, m_start_x, m_start_y+m_height-1, m_start_x+m_width-1);

input = readKey();

switch (input)

{

case ERR:

case KEY_MOUSE:

break;

case KEY_UP:

if (m_history && !encrypted && history_it != m_history->begin())

{

while (--history_it != m_history->begin())

if (!history_it->empty())

break;

tmp = &*history_it;

gotoend = 1;

}

break;

case KEY_DOWN:

if (m_history && !encrypted && history_it != m_history->end())

{

while (++history_it != m_history->end())

if (!history_it->empty())

break;

tmp = &(history_it == m_history->end() ? wbase : *history_it);

gotoend = 1;

}

break;

case KEY_RIGHT:

{

if (x < maxx)

{

real_x++;

x += std::max(wcwidth((*tmp)[beginning+real_x-minx-1]), 1);

}

else if (beginning < maxbeginning)

beginning++;

break;

}

case KEY_CTRL_H:

case KEY_BACKSPACE:

case KEY_BACKSPACE_2:

{

if (x <= minx && !beginning)

break;

}

case KEY_LEFT:

{

if (x > minx)

{

real_x--;

x -= std::max(wcwidth((*tmp)[beginning+real_x-minx]), 1);

}

else if (beginning > 0)

beginning--;

if (input != KEY_CTRL_H && input != KEY_BACKSPACE && input != KEY_BACKSPACE_2)

break; // backspace = left & delete.

}

case KEY_DC:

{

if ((real_x-minx)+beginning == tmp->length())

break;

tmp->erase(tmp->begin()+(real_x-minx)+beginning);

if (beginning && beginning == maxbeginning && real_x < maxx)

{

real_x++;

x++;

}

break;

}

case KEY_HOME:

{

real_x = x = minx;

beginning = 0;

break;

}

case KEY_END:

{

gotoend = 1;

break;

}

case KEY_ENTER:

break;

case KEY_CTRL_U:

tmp->clear();

real_maxx = maxx = real_x = x = minx;

maxbeginning = beginning = 0;

break;

default:

{

if (tmp->length() >= length_)

break;

tmp_in += input;

if (int(mbrtowc(&wc_in, tmp_in.c_str(), MB_CUR_MAX, 0)) < 0)

break;

int wcwidth_res = wcwidth(wc_in);

if (wcwidth_res > 1)

block_scrolling = 1;

if (wcwidth_res > 0) // is char printable? we want to ignore things like Ctrl-?, Fx etc.

{

if ((real_x-minx)+beginning >= tmp->length())

{

tmp->push_back(wc_in);

if (!beginning)

{

real_x++;

x += wcwidth(wc_in);

}

beginning++;

gotoend = 1;

}

else

{

tmp->insert(tmp->begin()+(real_x-minx)+beginning, wc_in);

if (x < maxx)

{

real_x++;

x += wcwidth(wc_in);

}

else if (beginning < maxbeginning)

beginning++;

}

}

tmp_in.clear();

}

}

}

while (input != KEY_ENTER);

curs_set(0);

if (m_history && !encrypted)

{

if (history_it != m_history->end())

{

m_history->push_back(*history_it);

tmp = &m_history->back();

m_history->erase(history_it);

}

else

m_history->push_back(*tmp);

}

return ToString(*tmp);

{

# ifndef USE_PDCURSES

return wmouse_trafo(m_window, &y, &x, 0);

# else

// wmouse_trafo is broken in pdcurses, use our own implementation

size_t u_x = x, u_y = y;

if (u_x >= m_start_x && u_x < m_start_x+m_width

&& u_y >= m_start_y && u_y < m_start_y+m_height)

{

x -= m_start_x;

y -= m_start_y;

return true;

}

return false;

# endif

{

if (m_border != Border::None)

return m_width+2;

else

return m_width;

{

size_t height = m_height;

if (m_border != Border::None)

height += 2;

if (!m_title.empty())

height += 2;

return height;

{

if (m_border != Border::None)

return m_start_x-1;

else

return m_start_x;

{

size_t starty = m_start_y;

if (m_border != Border::None)

starty--;

if (!m_title.empty())

starty -= 2;

return starty;

{

idlok(m_window, 1);

scrollok(m_window, 1);

switch (where)

{

case Scroll::Up:

wscrl(m_window, 1);

break;

case Scroll::Down:

wscrl(m_window, -1);

break;

case Scroll::PageUp:

wscrl(m_window, m_width);

break;

case Scroll::PageDown:

wscrl(m_window, -m_width);

break;

default:

break;

}

idlok(m_window, 0);

scrollok(m_window, 0);