void handle_terminal_resize(bool redraw = true);

    if (termsz.x < 80 || termsz.y < 24)

    if ((termsz.x < 80 || termsz.y < 24) && !crawl_state.need_save)

    // If the view is too short, force it to minimum height.
    if (viewsz.y < VIEW_MIN_HEIGHT)
        viewsz.y = VIEW_MIN_HEIGHT;

    if (viewsz.x < VIEW_MIN_WIDTH)
        viewsz.x = VIEW_MIN_WIDTH;

}
////////////////////////////////////////////////////////////////////////////
// Term resize handling (generic).
void handle_terminal_resize(bool redraw)
{
    crawl_state.terminal_resized = false;
    
    if (crawl_state.terminal_resize_handler)
        (*crawl_state.terminal_resize_handler)();
    else
        crawl_view.init_geometry();
    
    if (redraw)
        redraw_screen();

static bool io_inited = false;

    io_inited = true;

    crawl_state.io_inited = true;

    if (!io_inited)

    if (!crawl_state.io_inited)

    io_inited = false;

    crawl_state.io_inited = false;

#include "stuff.h"
#include "view.h"

static void unix_handle_terminal_resize();

    crawl_state.terminal_resize_handler = unix_handle_terminal_resize;

int getch_ck() {

int getch_ck()
{

    switch (c) {

    switch (c)
    {

#if defined(USE_UNIX_SIGNALS) && defined(SIGHUP_SAVE)

#if defined(USE_UNIX_SIGNALS)
static void handle_sigwinch(int)
{
    if (crawl_state.waiting_for_comand)
        handle_terminal_resize();
    else
        crawl_state.terminal_resized = true;
}

#ifdef SIGHUP_SAVE

#endif // SIGHUP_SAVE

#endif // USE_UNIX_SIGNALS && SIGHUP_SAVE

#endif // USE_UNIX_SIGNALS

        fprintf(stderr, "Unable to create message window!");
        exit(1);

        if (crawl_state.need_save)
            save_game(true);
        // Never reaches here unless the game didn't need saving.
        end(1, false, "Unable to create message window!");

static void unix_handle_terminal_resize()
{
    unixcurses_shutdown();
    unixcurses_startup();
}

    signal(SIGWINCH, handle_sigwinch);

    if (Message_Window)
    {
        delwin(Message_Window);
        Message_Window = NULL;
    }
        

#ifdef SIGHUP_SAVE
    signal(SIGHUP, SIG_DFL);

    signal(SIGWINCH, SIG_DFL);
#endif

    view_max_width = VIEW_MIN_WIDTH;

    view_max_width = VIEW_BASE_WIDTH;

    scroll_margin_x   = 4;
    scroll_margin_y   = 4;

    scroll_margin_x   = 2;
    scroll_margin_y   = 2;

// Track stuff for SIGHUP handling.

// Track various aspects of Crawl game state.

    bool waiting_for_comand; // True when the game is waiting for a command.
    bool terminal_resized;   // True if the term was resized and we need to
                             // take action to handle it.
    
    bool io_inited;         // Is curses or the equivalent initialised?

    int (*multibyte_strlen)(const std::string &s);

    int  (*multibyte_strlen)(const std::string &s);
    void (*terminal_resize_handler)();

    game_state() : need_save(false), saving_game(false),
        updating_scores(false), shopping(false), seen_hups(0),
        unicode_ok(false), glyph2strfn(NULL), multibyte_strlen(NULL)

    game_state() : waiting_for_comand(false), terminal_resized(false),
                   io_inited(false), need_save(false), saving_game(false),
                   updating_scores(false), shopping(false), seen_hups(0),
                   unicode_ok(false), glyph2strfn(NULL), multibyte_strlen(NULL),
                   terminal_resize_handler(NULL)

#define VIEW_MIN_WIDTH  33

#define VIEW_BASE_WIDTH 33
#define VIEW_MIN_WIDTH  17

    if (crawl_state.terminal_resized)
        handle_terminal_resize();
    

        crawl_state.waiting_for_comand = true;

        crawl_state.waiting_for_comand = false;