void init_feature_table( void );

void init_feature_table();

int get_number_of_lines(void);
int get_number_of_cols(void);

int get_message_window_height();

//---------------------------------------------------------------
//
// get_number_of_lines
//
// Made this a function instead of a #define.  This should help
// considering the fact that the curses version is a macro 
// (curses tends to be implemented with a large number of 
// preprocessor macros, which can wreak havoc with things
// like the C++ string class, so we want to isolate that
// away to keep portability up). 
//
// Other OSes might want to hook into reading system environment 
// variables or player set options to determine the screen size 
// (see the Options and SysEnv structures, as well as initfile.cc).
//
// This might be better to move to the lib*.cc files, but we
// don't really have a standard API defined for them, or the
// all important libdos.cc.  It would be a good idea to eventually
// head that way. -- bwr
//
//---------------------------------------------------------------
int get_number_of_lines(void)
{
#ifdef UNIX
    return (get_number_of_lines_from_curses());
#else
    return (25);
#endif
}

int get_number_of_cols(void)

int get_message_window_height()

#ifdef UNIX
    return (get_number_of_cols_from_curses());
#else
    return (80);
#endif

    return (get_number_of_lines() - VIEW_EY);

        mesclr(true);

        mesclr();

char Message_Line = 0;                // line of next (previous?) message

int Message_Line = 0;                // line of next (previous?) message
int New_Message_Count = 0;

static bool need_prefix = false;

    textcolor(LIGHTGREY);

    const int num_lines = get_message_window_height();
    
    if (New_Message_Count == num_lines - 1)
        more();
    
    if (need_prefix)
    {
        message_out( Message_Line, colour, "-", 1, false );
        need_prefix = false;
    }

    const int num_lines = get_number_of_lines();

    message_out( Message_Line, colour, inf,
                 Options.delay_message_clear? 2 : 1 );

    if (Message_Line == num_lines - 18) // ( Message_Line == 8 )
        more();

    New_Message_Count++;
    if (Message_Line < num_lines - 1)
        Message_Line++;

    gotoxy( (Options.delay_message_clear) ? 2 : 1, Message_Line + 18 );
    textcolor( colour );
    cprintf("%s", inf);
    //

    Message_Line++;

    if (Options.delay_message_clear 
            && channel != MSGCH_PROMPT 
            && Message_Line == num_lines - 18)
    {
        more();
    }

        /* Put the message into Store_Message, and move the '---' line forward */

        // Put the message into Store_Message, and move the '---' line forward

    New_Message_Count = 0;

        gotoxy( 1, Message_Line + 18 );
        textcolor( channel_to_colour( MSGCH_PLAIN, 0 ) );
        cprintf( ">" );

        need_prefix = true;

#ifdef DOS_TERM
    window(1, 18, 78, 25);
    clrscr();
    window(1, 1, 80, 25);
#endif
#ifdef PLAIN_TERM
    int startLine = 18;
    gotoxy(1, startLine);
#ifdef UNIX
    clear_to_end_of_screen();
#else
    int numLines = get_number_of_lines() - startLine + 1;
    char blankline[81];
    memset(blankline, ' ', sizeof blankline);
    blankline[80] = 0;
    for (int i = 0; i < numLines; i++)
    {
        cprintf( blankline );
        if (i < numLines - 1)
        {
            cprintf(EOL);
        }
    }
#endif
#endif

    clear_message_window();
    need_prefix = false;

#ifdef PLAIN_TERM
    gotoxy( 2, get_number_of_lines() );
#endif

    message_out(get_message_window_height() - 1,
                LIGHTGREY, "--more--", 2, false);

#ifdef DOS_TERM
    window(1, 18, 80, 25);
    gotoxy(2, 7);
#endif
    textcolor(LIGHTGREY);
#ifdef DOS
    cprintf(EOL);
#endif
    cprintf("--more--");

    mesclr( (Message_Line >= get_number_of_lines() - 18) );

    mesclr( !Options.delay_message_clear &&
            Message_Line >= get_message_window_height() - 1 );

    formatted_string(const std::string &s, bool init_style = false);

    formatted_string(const std::string &s, int init_colour = 0);

formatted_string::formatted_string(const std::string &s, bool init_style)

formatted_string::formatted_string(const std::string &s, int init_colour)

    if (init_style)
        ops.push_back(LIGHTGREY);

    if (init_colour)
        ops.push_back(init_colour);

void message_out(int mline, int colour, const char *str, int firstcol = 0,
                 bool newline = true);
void clear_message_window();

int get_number_of_lines();
int get_number_of_cols();

}
int get_number_of_lines()
{
    return (25);

int get_number_of_cols()
{
    return (80);
}

void message_out(int mline, int colour, const char *str, int firstcol = 0,
                 bool newline = true);
void clear_message_window();
int get_number_of_lines();
int get_number_of_cols();

int get_number_of_lines_from_curses(void);
int get_number_of_cols_from_curses(void);

static int curs_fg_attr(int col);
static int curs_bg_attr(int col);

static WINDOW *Message_Window;
static void setup_message_window()
{
    extern int get_message_window_height();
    
    Message_Window = newwin( get_message_window_height(), get_number_of_cols(),
                             VIEW_EY, 0 );
    if (!Message_Window)
    {
        fprintf(stderr, "Unable to create message window!");
        exit(1);
    }
    
    scrollok(Message_Window, true);
    idlok(Message_Window, true);
}
void clear_message_window()
{
    wattrset( Message_Window, curs_fg_attr(LIGHTGREY) );
    werase( Message_Window );
    wrefresh( Message_Window );
}

void message_out(int which_line, int color, const char *s, int firstcol,
                 bool newline)
{
    extern int get_message_window_height();
    wattrset( Message_Window, curs_fg_attr(color) );
    if (!firstcol)
        firstcol = Options.delay_message_clear? 1 : 0;
    else
        firstcol--;
    
    mvwaddstr(Message_Window, which_line, firstcol, s);
    if (newline && which_line == get_message_window_height() - 1)
        scroll(Message_Window);
    wrefresh(Message_Window);
}

    setup_message_window();

int get_number_of_lines_from_curses(void)

int get_number_of_lines(void)

int get_number_of_cols_from_curses(void)

int get_number_of_cols(void)

void textcolor(int col)

static int curs_fg_attr(int col)

    attrset( COLOR_PAIR(pair) | flags | Character_Set );

    return ( COLOR_PAIR(pair) | flags | Character_Set );

void textcolor(int col)
{
    attrset( curs_fg_attr(col) );
}

void textbackground(int col)

static int curs_bg_attr(int col)

    attrset( COLOR_PAIR(pair) | flags | Character_Set );

    return ( COLOR_PAIR(pair) | flags | Character_Set );
}
void textbackground(int col)
{
    attrset( curs_bg_attr(col) );

int get_number_of_lines();
int get_number_of_cols();

void message_out(int mline, int colour, const char *str, int firstcol = 0,
                 bool newline = true);
void clear_message_window();

void clear_message_window()
{
    window(1, 18, 78, 25);
    clrscr();
    window(1, 1, 80, 25);
}

int get_number_of_lines()
{
    return (25);
}
int get_number_of_cols()
{
    return (80);
}