#include <algorithm>

#include <cstring>

#include <cstdio>

#include <cstdlib>

#include <iostream>

#include <sys/select.h>

#include <termios.h>

#include <unistd.h>

#include "utility/readline.h"

#include "utility/string.h"

#include "utility/wide_string.h"

#include "window.h"

namespace {

int maxColor;

namespace rl {

bool aborted;

NC::Window *w;

size_t start_x;

size_t start_y;

size_t width;

bool encrypted;

const char *base;

int read_key(FILE *)

}

void display_string()

}

int add_base()

}

}

int color_pair_counter;

std::vector<int> color_pair_map;

termios orig_termios;

}

namespace NC {

const short Color::transparent = -1;

const short Color::current = -2;

Color Color::Default(0, 0, true, false);

Color Color::Black(COLOR_BLACK, Color::current);

Color Color::Red(COLOR_RED, Color::current);

Color Color::Green(COLOR_GREEN, Color::current);

Color Color::Yellow(COLOR_YELLOW, Color::current);

Color Color::Blue(COLOR_BLUE, Color::current);

Color Color::Magenta(COLOR_MAGENTA, Color::current);

Color Color::Cyan(COLOR_CYAN, Color::current);

Color Color::White(COLOR_WHITE, Color::current);

Color Color::End(0, 0, false, true);

int Color::pairNumber() const

}

std::istream &operator>>(std::istream &is, Color &c)

{

const short invalid_color_value = -1337;

auto get_single_color = [](const std::string &s, bool background) {

short result = invalid_color_value;

if (s == "black")

result = COLOR_BLACK;

else if (s == "red")

result = COLOR_RED;

else if (s == "green")

result = COLOR_GREEN;

else if (s == "yellow")

result = COLOR_YELLOW;

else if (s == "blue")

result = COLOR_BLUE;

else if (s == "magenta")

result = COLOR_MAGENTA;

else if (s == "cyan")

result = COLOR_CYAN;

else if (s == "white")

result = COLOR_WHITE;

else if (background && s == "transparent")

result = NC::Color::transparent;

else if (background && s == "current")

result = NC::Color::current;

else if (std::all_of(s.begin(), s.end(), isdigit))

{

result = atoi(s.c_str());

if (result < (background ? 0 : 1) || result > 256)

result = invalid_color_value;

else

--result;

}

return result;

};

auto get_color = [](std::istream &is_) {

std::string result;

while (!is_.eof() && isalnum(is_.peek()))

result.push_back(is_.get());

return result;

};

std::string sc = get_color(is);

if (sc == "default")

c = Color::Default;

else if (sc == "end")

c = Color::End;

else

{

short fg = get_single_color(sc, false);

if (fg == invalid_color_value)

is.setstate(std::ios::failbit);

// Check if there is background color

else if (!is.eof() && is.peek() == '_')

{

is.get();

sc = get_color(is);

short bg = get_single_color(sc, true);

if (bg == invalid_color_value)

is.setstate(std::ios::failbit);

else

c = Color(fg, bg);

}

else

c = Color(fg, NC::Color::current);

}

return is;

}

NC::Format reverseFormat(NC::Format fmt)

}

namespace Mouse {

namespace {

bool supportEnabled = false;

}

void enable()

}

void disable()

}

}

int colorCount()

{

return maxColor;

}

void initScreen(bool enable_colors, bool enable_mouse)

}

void pauseScreen()

}

void unpauseScreen()

}

void destroyScreen()

}

Window::Window(size_t startx, size_t starty, size_t width, size_t height,

}

Window::Window(const Window &rhs)

}

Window::Window(Window &&rhs)

}

Window &Window::operator=(Window rhs)

{

std::swap(m_window, rhs.m_window);

std::swap(m_start_x, rhs.m_start_x);

std::swap(m_start_y, rhs.m_start_y);

std::swap(m_width, rhs.m_width);

std::swap(m_height, rhs.m_height);

std::swap(m_window_timeout, rhs.m_window_timeout);

std::swap(m_color, rhs.m_color);

std::swap(m_base_color, rhs.m_base_color);

std::swap(m_border, rhs.m_border);

std::swap(m_prompt_hook, rhs.m_prompt_hook);

std::swap(m_title, rhs.m_title);

std::swap(m_color_stack, rhs.m_color_stack);

std::swap(m_input_queue, rhs.m_input_queue);

std::swap(m_fds, rhs.m_fds);

std::swap(m_escape_terminal_sequences, rhs.m_escape_terminal_sequences);

std::swap(m_bold_counter, rhs.m_bold_counter);

std::swap(m_underline_counter, rhs.m_underline_counter);

std::swap(m_reverse_counter, rhs.m_reverse_counter);

std::swap(m_alt_charset_counter, rhs.m_alt_charset_counter);

std::swap(m_italic_counter, rhs.m_italic_counter);

return *this;

}

Window::~Window()

{

delwin(m_window);

}

void Window::setColor(Color c)

}

void Window::setBaseColor(const Color &color)

}

void Window::setBorder(Border border)

}

void Window::setTitle(const std::string &new_title)

}

void Window::recreate(size_t width, size_t height)

}

void Window::moveTo(size_t new_x, size_t new_y)

}

void Window::adjustDimensions(size_t width, size_t height)

}

void Window::resize(size_t new_width, size_t new_height)

}

void Window::refreshBorder() const

}

void Window::display()

}

void Window::refresh()

{

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

}

void Window::clear()

}

void Window::bold(bool bold_state) const

{

(bold_state ? wattron : wattroff)(m_window, A_BOLD);

}

void Window::underline(bool underline_state) const

{

(underline_state ? wattron : wattroff)(m_window, A_UNDERLINE);

}

void Window::reverse(bool reverse_state) const

{

(reverse_state ? wattron : wattroff)(m_window, A_REVERSE);

}

void Window::altCharset(bool altcharset_state) const

{

(altcharset_state ? wattron : wattroff)(m_window, A_ALTCHARSET);

}

void Window::italic(bool italic_state) const

{

(italic_state ? wattron : wattroff)(m_window, A_ITALIC);

}

void Window::setTimeout(int timeout)

{

m_window_timeout = timeout;

}

void Window::addFDCallback(int fd, void (*callback)())

{

m_fds.push_back(std::make_pair(fd, callback));

}

void Window::clearFDCallbacksList()

{

m_fds.clear();

}

bool Window::FDCallbacksListEmpty() const

{

return m_fds.empty();

}

Key::Type Window::getInputChar(int key)