module Curses

static VALUE
curses_escdelay_get(VALUE obj)
{
    return INT2NUM(ESCDELAY);
}

static VALUE
curses_escdelay_set(VALUE obj, VALUE val)
{
    ESCDELAY = NUM2INT(val);
    return INT2NUM(ESCDELAY);
}

static VALUE
curses_tabsize_get(VALUE ojb)
{
    return INT2NUM(TABSIZE);
}

static VALUE
curses_tabsize_set(VALUE obj, VALUE val)
{
    TABSIZE = NUM2INT(val);
    return INT2NUM(TABSIZE);
}

static VALUE
curses_addch(VALUE obj, VALUE ch)
{
    curses_stdscr();
    addch(OBJ2CHTYPE(ch));
    return Qnil;
}

static VALUE
curses_addstr(VALUE obj, VALUE str)
{
    StringValue(str);
#if defined(HAVE_ADDNWSTR) && defined(_WIN32)
    str = rb_str_export_to_enc(str, get_wide_encoding());
    curses_stdscr();
    if (!NIL_P(str)) {
        addnwstr((wchar_t *)RSTRING_PTR(str), RSTRING_LEN(str) / sizeof(wchar_t));
    }
#else
    str = rb_str_export_to_enc(str, terminal_encoding);
    curses_stdscr();
    if (!NIL_P(str)) {
        addstr(StringValueCStr(str));
    }
#endif
    return Qnil;
}

static VALUE
curses_assume_default_colors(VALUE obj, VALUE fg, VALUE bg)
{
    curses_stdscr();
    assume_default_colors(NUM2INT(fg), NUM2INT(bg));
    return Qnil;
}

static VALUE
curses_attroff(VALUE obj, VALUE attrs)
{
    curses_stdscr();
    return window_attroff(rb_stdscr,attrs);
    /* return INT2FIX(attroff(NUM2INT(attrs))); */
}

static VALUE
curses_attron(VALUE obj, VALUE attrs)
{
    curses_stdscr();
    return window_attron(rb_stdscr,attrs);
    /* return INT2FIX(attroff(NUM2INT(attrs))); */
}

static VALUE
curses_attrset(VALUE obj, VALUE attrs)
{
    curses_stdscr();
    return window_attrset(rb_stdscr,attrs);
    /* return INT2FIX(attroff(NUM2INT(attrs))); */
}

static VALUE
curses_beep(VALUE obj)
{
#ifdef HAVE_BEEP
    curses_stdscr();
    beep();
#endif
    return Qnil;
}

static VALUE
curses_bkgd(VALUE obj, VALUE ch)
{
#ifdef HAVE_BKGD
    curses_stdscr();
    return (bkgd(OBJ2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

static VALUE
curses_bkgdset(VALUE obj, VALUE ch)
{
#ifdef HAVE_BKGDSET
    curses_stdscr();
    bkgdset(OBJ2CHTYPE(ch));
#endif
    return Qnil;
}

static VALUE
curses_can_change_color(VALUE obj)
{
    curses_stdscr();
    return can_change_color() ? Qtrue : Qfalse;
}

static VALUE
curses_cbreak(VALUE obj)
{
    curses_stdscr();
    cbreak();
    return Qnil;
}

static VALUE
curses_clear(VALUE obj)
{
    curses_stdscr();
    wclear(stdscr);
    return Qnil;
}

static VALUE
curses_close_screen(VALUE self)
{
    curses_stdscr();
#ifdef HAVE_ISENDWIN
    if (!isendwin())
#endif
        endwin();
    rb_stdscr = 0;
    return Qnil;
}

static VALUE
curses_closed(VALUE self)
{
    curses_stdscr();
    if (isendwin()) {
        return Qtrue;
    }
    return Qfalse;
}

static VALUE
curses_clrtoeol(VALUE self)
{
    curses_stdscr();
    clrtoeol();
    return Qnil;
}

static VALUE
curses_color_content(VALUE obj, VALUE color)
{
    short r,g,b;

    curses_stdscr();
    color_content(NUM2INT(color),&r,&g,&b);
    return rb_ary_new3(3,INT2FIX(r),INT2FIX(g),INT2FIX(b));
}

static VALUE
curses_color_pair(VALUE obj, VALUE attrs)
{
    return CHTYPE2NUM(COLOR_PAIR(NUM2CHTYPE(attrs)));
}

static VALUE
curses_color_pairs(VALUE obj)
{
    return INT2FIX(COLOR_PAIRS);
}

static VALUE
curses_colors(VALUE obj)
{
    return INT2FIX(COLORS);
}

static VALUE
curses_cols(VALUE self)
{
    return INT2FIX(COLS);
}

static VALUE
curses_cbreak(VALUE obj)
{
    curses_stdscr();
    cbreak();
    return Qnil;
}

static VALUE
curses_curs_set(VALUE obj, VALUE visibility)
{
#ifdef HAVE_CURS_SET
    int n;
    curses_stdscr();
    return (n = curs_set(NUM2INT(visibility)) != ERR) ? INT2FIX(n) : Qnil;
#else
    return Qnil;
#endif
}

static VALUE
curses_def_prog_mode(VALUE obj)
{
    curses_stdscr();
    return def_prog_mode() == OK ? Qtrue : Qfalse;
}

static VALUE
curses_delch(VALUE obj)
{
    curses_stdscr();
    delch();
    return Qnil;
}

static VALUE
curses_deleteln(VALUE obj)
{
    curses_stdscr();
#if defined(HAVE_DELETELN) || defined(deleteln)
    deleteln();
#endif
    return Qnil;
}

static VALUE
curses_doupdate(VALUE obj)
{
    curses_stdscr();
#ifdef HAVE_DOUPDATE
    doupdate();
#else
    refresh();
#endif
    return Qnil;
}

static VALUE
curses_echo(VALUE obj)
{
    curses_stdscr();
    echo();
    return Qnil;
}

static VALUE
curses_erase(VALUE obj)
{
    curses_stdscr();
    werase(stdscr);
    return Qnil;
}

static VALUE
curses_flash(VALUE obj)
{
#ifdef HAVE_FLASH
    curses_stdscr();
    flash();
#endif
    return Qnil;
}

static VALUE
curses_flushinp(VALUE obj)
{
    curses_stdscr();
    flushinp();
    return Qnil;
}

static VALUE
curses_get_char(VALUE obj)
{
#ifdef HAVE_GET_WCH
    struct get_wch_arg arg;

    curses_stdscr();
    rb_thread_call_without_gvl(get_wch_func, &arg, RUBY_UBF_IO, 0);
    switch (arg.retval) {
    case OK:
        return keyboard_uint_chr(arg.ch);
    case KEY_CODE_YES:
        return key_code_value(arg.ch);
    }
    return Qnil;
#else
    int c;

    curses_stdscr();
    rb_thread_call_without_gvl(getch_func, &c, RUBY_UBF_IO, 0);
    if (c > 0xff) {
        return INT2NUM(c);
    }
    else if (c >= 0) {
        return keyboard_uint_chr(c);
    }
    else {
        return Qnil;
    }
#endif
}

HAVE_PDC_GET_KEY_MODIFIERS
static VALUE
curses_get_key_modifiers(VALUE obj)
{
    return ULONG2NUM(PDC_get_key_modifiers());
}

static VALUE
curses_getch(VALUE obj)
{
    int c;

    curses_stdscr();
    rb_thread_call_without_gvl(getch_func, &c, RUBY_UBF_IO, 0);
    if (c == EOF) return Qnil;
    if (rb_isprint(c)) {
        char ch = (char)c;

        return rb_external_str_new_with_enc(&ch, 1, keyboard_encoding);
    }
    return UINT2NUM(c);
}

static VALUE
curses_getmouse(VALUE obj)
{
    struct mousedata *mdata;
    VALUE val;

    curses_stdscr();
    val = TypedData_Make_Struct(cMouseEvent,struct mousedata,
                                &mousedata_type,mdata);
    mdata->mevent = (MEVENT*)xmalloc(sizeof(MEVENT));
    return (getmouse(mdata->mevent) == OK) ? val : Qnil;
}

static VALUE
curses_getstr(VALUE obj)
{
    char rtn[GETSTR_BUF_SIZE];

    curses_stdscr();
    rb_thread_call_without_gvl(getstr_func, rtn, RUBY_UBF_IO, 0);
    return rb_external_str_new_with_enc(rtn, strlen(rtn), keyboard_encoding);
}

static VALUE
curses_has_colors(VALUE obj)
{
    curses_stdscr();
    return has_colors() ? Qtrue : Qfalse;
}

static VALUE
curses_inch(VALUE obj)
{
    curses_stdscr();
    return CHTYPE2NUM(inch());
}

static VALUE
curses_init_color(VALUE obj, VALUE color, VALUE r, VALUE g, VALUE b)
{
    /* may have to raise exception on ERR */
    curses_stdscr();
    return (init_color(NUM2INT(color),NUM2INT(r),
                       NUM2INT(g),NUM2INT(b)) == OK) ? Qtrue : Qfalse;
}

static VALUE
curses_init_pair(VALUE obj, VALUE pair, VALUE f, VALUE b)
{
    /* may have to raise exception on ERR */
    curses_stdscr();
    return (init_pair(NUM2INT(pair),NUM2INT(f),NUM2INT(b)) == OK) ? Qtrue : Qfalse;
}

static VALUE
curses_init_screen(VALUE self)
{
    if (rb_stdscr) return rb_stdscr;
    initscr();
    if (stdscr == 0) {
        rb_raise(rb_eRuntimeError, "can't initialize curses");
    }
    rb_set_end_proc(curses_finalize, 0);
    clear();
    rb_stdscr = prep_window(cWindow, stdscr, 1);
    return rb_stdscr;
}

static VALUE
curses_insch(VALUE obj, VALUE ch)
{
    curses_stdscr();
    insch(OBJ2CHTYPE(ch));
    return Qnil;
}

static VALUE
curses_insertln(VALUE obj)
{
    curses_stdscr();
#if defined(HAVE_INSERTLN) || defined(insertln)
    insertln();
#endif
    return Qnil;
}

static VALUE
curses_get_keyboard_encoding(VALUE obj)
{
    return rb_enc_from_encoding(keyboard_encoding);
}

static VALUE
curses_set_keyboard_encoding(VALUE obj, VALUE enc)
{
    keyboard_encoding = rb_to_encoding(enc);
    return enc;
}

static VALUE
curses_keyname(VALUE obj, VALUE c)
{
#ifdef HAVE_KEYNAME
    int cc = curses_char(c);
    const char *name;

    curses_stdscr();
    name = keyname(cc);
    if (name) {
        return rb_str_new_cstr(name);
    }
    else {
        return Qnil;
    }
#else
    return Qnil;
#endif
}

static VALUE
curses_lines(VALUE self)
{
    return INT2FIX(LINES);
}

static VALUE
curses_mouseinterval(VALUE obj, VALUE interval)
{
    curses_stdscr();
    return mouseinterval(NUM2INT(interval)) ? Qtrue : Qfalse;
}

static VALUE
curses_mousemask(VALUE obj, VALUE mask)
{
    curses_stdscr();
    return ULONG2NUM(mousemask(NUM2UINT(mask),NULL));
}

static VALUE
curses_nl(VALUE obj)
{
    curses_stdscr();
    nl();
    return Qnil;
}

static VALUE
curses_nocbreak(VALUE obj)
{
    curses_stdscr();
    nocbreak();
    return Qnil;
}

static VALUE
curses_nocbreak(VALUE obj)
{
    curses_stdscr();
    nocbreak();
    return Qnil;
}

static VALUE
curses_noecho(VALUE obj)
{
    curses_stdscr();
    noecho();
    return Qnil;
}

static VALUE
curses_nonl(VALUE obj)
{
    curses_stdscr();
    nonl();
    return Qnil;
}

static VALUE
curses_noraw(VALUE obj)
{
    curses_stdscr();
    noraw();
    return Qnil;
}

static VALUE
curses_pair_content(VALUE obj, VALUE pair)
{
    short f,b;

    curses_stdscr();
    pair_content(NUM2INT(pair),&f,&b);
    return rb_ary_new3(2,INT2FIX(f),INT2FIX(b));
}

static VALUE
curses_pair_number(VALUE obj, VALUE attrs)
{
    curses_stdscr();
    return INT2FIX(PAIR_NUMBER(NUM2CHTYPE(attrs)));
}

static VALUE
curses_raw(VALUE obj)
{
    curses_stdscr();
    raw();
    return Qnil;
}

static VALUE
curses_refresh(VALUE obj)
{
    curses_stdscr();
    refresh();
    return Qnil;
}

static VALUE
curses_reset_prog_mode(VALUE obj)
{
    curses_stdscr();
    return reset_prog_mode() == OK ? Qtrue : Qfalse;
}

static VALUE
curses_resizeterm(VALUE obj, VALUE lin, VALUE col)
{
#if defined(HAVE_RESIZETERM)
    curses_stdscr();
    return (resizeterm(NUM2INT(lin),NUM2INT(col)) == OK) ? Qtrue : Qfalse;
#else
    return Qnil;
#endif
}

static VALUE
curses_resizeterm(VALUE obj, VALUE lin, VALUE col)
{
#if defined(HAVE_RESIZETERM)
    curses_stdscr();
    return (resizeterm(NUM2INT(lin),NUM2INT(col)) == OK) ? Qtrue : Qfalse;
#else
    return Qnil;
#endif
}

static VALUE
curses_return_key_modifiers(VALUE obj, VALUE flag)
{
    return INT2NUM(PDC_return_key_modifiers(RTEST(flag)));
}

static VALUE
curses_save_key_modifiers(VALUE obj, VALUE flag)
{
    return INT2NUM(PDC_save_key_modifiers(RTEST(flag)));
}

static VALUE
curses_scrl(VALUE obj, VALUE n)
{
    /* may have to raise exception on ERR */
#ifdef HAVE_SCRL
    curses_stdscr();
    return (scrl(NUM2INT(n)) == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

static VALUE
curses_setpos(VALUE obj, VALUE y, VALUE x)
{
    curses_stdscr();
    move(NUM2INT(y), NUM2INT(x));
    return Qnil;
}

static VALUE
curses_setscrreg(VALUE obj, VALUE top, VALUE bottom)
{
    /* may have to raise exception on ERR */
#ifdef HAVE_SETSCRREG
    curses_stdscr();
    return (setscrreg(NUM2INT(top), NUM2INT(bottom)) == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

static VALUE
curses_standend(VALUE obj)
{
    curses_stdscr();
    standend();
    return Qnil;
}

static VALUE
curses_standout(VALUE obj)
{
    curses_stdscr();
    standout();
    return Qnil;
}

static VALUE
curses_start_color(VALUE obj)
{
    /* may have to raise exception on ERR */
    curses_stdscr();
    return (start_color() == OK) ? Qtrue : Qfalse;
}

static VALUE
curses_init_screen(VALUE self)
{
    if (rb_stdscr) return rb_stdscr;
    initscr();
    if (stdscr == 0) {
        rb_raise(rb_eRuntimeError, "can't initialize curses");
    }
    rb_set_end_proc(curses_finalize, 0);
    clear();
    rb_stdscr = prep_window(cWindow, stdscr, 1);
    return rb_stdscr;
}

static VALUE
curses_get_terminal_encoding(VALUE obj)
{
    return rb_enc_from_encoding(terminal_encoding);
}

static VALUE
curses_set_terminal_encoding(VALUE obj, VALUE enc)
{
    terminal_encoding = rb_to_encoding(enc);
    return enc;
}

static VALUE
curses_timeout(VALUE obj, VALUE delay)
{
    curses_stdscr();
    timeout(NUM2INT(delay));
    return Qnil;
}

static VALUE
curses_unget_char(VALUE obj, VALUE ch)
{
    ID id_ord;
    unsigned int c;

    curses_stdscr();
    if (FIXNUM_P(ch)) {
        ungetch(NUM2UINT(ch));
    }
    else {
        StringValue(ch);
        CONST_ID(id_ord, "ord");
        c = NUM2UINT(rb_funcall(ch, id_ord, 0));
#ifdef HAVE_UNGET_WCH
        unget_wch(c);
#else
        if (c > 0xff) {
            rb_raise(rb_eRangeError, "Out of range: %u", c);
        }
        ungetch(c);
#endif
    }
    return Qnil;
}

static VALUE
curses_ungetch(VALUE obj, VALUE ch)
{
    int c = curses_char(ch);
    curses_stdscr();
    ungetch(c);
    return Qnil;
}

static VALUE
curses_ungetmouse(VALUE obj, VALUE mevent)
{
    struct mousedata *mdata;

    curses_stdscr();
    GetMOUSE(mevent,mdata);
    return (ungetmouse(mdata->mevent) == OK) ? Qtrue : Qfalse;
}

static VALUE
curses_use_default_colors(VALUE obj)
{
    curses_stdscr();
    use_default_colors();
    return Qnil;
}

# File lib/curses.rb, line 93
def chgat(...)
  Curses.stdscr.chgat(...)
end