Class: Curses::Window

Inherits:
Object
  • Object
show all
Defined in:
ext/curses/curses.c,
ext/curses/curses.c

Overview

Description

The means by which to create and manage frames or windows. While there may be more than one window at a time, only one window will receive input.

Usage

require "curses"

Curses.init_screen

my_str = "LOOK! PONIES!"

height, width = 12, my_str.length + 10
top, left = (Curses.lines - height) / 2, (Curses.cols - width) / 2
bwin = Curses::Window.new(height, width, top, left)
bwin.box("\\", "/")
bwin.refresh

win = bwin.subwin(height - 4, width - 4, top + 2, left + 2)
win.setpos(2, 3)
win.addstr(my_str)
# or even
win << "\nOH REALLY?"
win << "\nYES!! " + my_str
win.refresh
win.getch
win.close

Direct Known Subclasses

Pad

Instance Method Summary collapse

Constructor Details

#new(height, width, top, left) ⇒ Object

Construct a new Curses::Window with constraints of height lines, width columns, begin at top line, and begin left most column.

A new window using full screen is called as Curses::Window.new(0,0,0,0)


1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
# File 'ext/curses/curses.c', line 1708

static VALUE
window_initialize(VALUE obj, VALUE h, VALUE w, VALUE top, VALUE left)
{
    struct windata *winp;
    WINDOW *window;

    curses_init_screen(Qnil);
    TypedData_Get_Struct(obj, struct windata, &windata_type, winp);
    if (winp->window) delwin(winp->window);
    window = newwin(NUM2INT(h), NUM2INT(w), NUM2INT(top), NUM2INT(left));
    wclear(window);
    winp->window = window;

    return obj;
}

Instance Method Details

#<<(str) ⇒ Object

call-seq:

<<(str)

Add String str to the current string.

See also Curses::Window.addstr


2381
2382
2383
2384
2385
2386
# File 'ext/curses/curses.c', line 2381

static VALUE
window_addstr2(VALUE obj, VALUE str)
{
    window_addstr(obj, str);
    return obj;
}

#addch(ch) ⇒ Object

Add a character ch, with attributes, to the window, then advance the cursor.

see also the system manual for curs_addch(3)


2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
# File 'ext/curses/curses.c', line 2315

static VALUE
window_addch(VALUE obj, VALUE ch)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    waddch(winp->window, OBJ2CHTYPE(ch));

    return Qnil;
}

#addstr(str) ⇒ Object

add a string of characters str, to the window and advance cursor


2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
# File 'ext/curses/curses.c', line 2351

static VALUE
window_addstr(VALUE obj, VALUE str)
{
    if (!NIL_P(str)) {
	struct windata *winp;

	StringValue(str);
#if defined(HAVE_WADDNWSTR) && defined(_WIN32)
	str = rb_str_export_to_enc(str, get_wide_encoding());
	GetWINDOW(obj, winp);
	waddnwstr(winp->window, (wchar_t *)RSTRING_PTR(str), RSTRING_LEN(str) / sizeof(wchar_t));
#else
	str = rb_str_export_to_enc(str, terminal_encoding);
	GetWINDOW(obj, winp);
	waddstr(winp->window, StringValueCStr(str));
#endif
    }
    return Qnil;
}

#attroff(attrs) ⇒ Object

Turns off the named attributes attrs without affecting any others.

See also Curses::Window.attrset


2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
# File 'ext/curses/curses.c', line 2668

static VALUE
window_attroff(VALUE obj, VALUE attrs)
{
#ifdef HAVE_WATTROFF
    struct windata *winp;

    GetWINDOW(obj,winp);
    return INT2FIX(wattroff(winp->window,NUM2INT(attrs)));
#else
    return Qtrue;
#endif
}

#attron(attrs) ⇒ Object

Turns on the named attributes attrs without turning any other attributes on or off.

See also Curses::Window.attrset


2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
# File 'ext/curses/curses.c', line 2690

static VALUE
window_attron(VALUE obj, VALUE attrs)
{
#ifdef HAVE_WATTRON
    struct windata *winp;
    VALUE val;

    GetWINDOW(obj,winp);
    val = INT2FIX(wattron(winp->window,NUM2INT(attrs)));
    if (rb_block_given_p()) {
	rb_yield(val);
	wattroff(winp->window,NUM2INT(attrs));
	return val;
    }
    else{
	return val;
    }
#else
    return Qtrue;
#endif
}

#attrset(attrs) ⇒ Object

Sets the current attributes of the given window to attrs.

The following video attributes, defined in <curses.h>, can be passed to the routines Curses::Window.attron, Curses::Window.attroff, and Curses::Window.attrset, or OR'd with the characters passed to addch.

A_NORMAL        Normal display (no highlight)
A_STANDOUT      Best highlighting mode of the terminal.
A_UNDERLINE     Underlining
A_REVERSE       Reverse video
A_BLINK         Blinking
A_DIM           Half bright
A_BOLD          Extra bright or bold
A_PROTECT       Protected mode
A_INVIS         Invisible or blank mode
A_ALTCHARSET    Alternate character set
A_CHARTEXT      Bit-mask to extract a character
COLOR_PAIR(n)   Color-pair number n

TODO: provide some examples here.

see also system manual curs_attr(3)


2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
# File 'ext/curses/curses.c', line 2738

static VALUE
window_attrset(VALUE obj, VALUE attrs)
{
#ifdef HAVE_WATTRSET
    struct windata *winp;

    GetWINDOW(obj,winp);
    return INT2FIX(wattrset(winp->window,NUM2INT(attrs)));
#else
    return Qtrue;
#endif
}

#begxObject

A getter for the beginning column (X coord) of the window


2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
# File 'ext/curses/curses.c', line 2194

static VALUE
window_begx(VALUE obj)
{
    struct windata *winp;
    int x, RB_UNUSED_VAR(y);

    GetWINDOW(obj, winp);
#ifdef getbegyx
    getbegyx(winp->window, y, x);
#else
    x = winp->window->_begx;
#endif
    return INT2FIX(x);
}

#begyObject

A getter for the beginning line (Y coord) of the window


2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
# File 'ext/curses/curses.c', line 2174

static VALUE
window_begy(VALUE obj)
{
    struct windata *winp;
    int RB_UNUSED_VAR(x), y;

    GetWINDOW(obj, winp);
#ifdef getbegyx
    getbegyx(winp->window, y, x);
#else
    y = winp->window->_begy;
#endif
    return INT2FIX(y);
}

#bkgd(ch) ⇒ Object

Set the background of the current window and apply character Integer ch to every character.

see also Curses.bkgd


2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
# File 'ext/curses/curses.c', line 2781

static VALUE
window_bkgd(VALUE obj, VALUE ch)
{
#ifdef HAVE_WBKGD
    struct windata *winp;

    GetWINDOW(obj,winp);
    return (wbkgd(winp->window, OBJ2CHTYPE(ch)) == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

#bkgdset(ch) ⇒ Object

Manipulate the background of the current window with character Integer ch

see also Curses.bkgdset


2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
# File 'ext/curses/curses.c', line 2760

static VALUE
window_bkgdset(VALUE obj, VALUE ch)
{
#ifdef HAVE_WBKGDSET
    struct windata *winp;

    GetWINDOW(obj,winp);
    wbkgdset(winp->window, OBJ2CHTYPE(ch));
#endif
    return Qnil;
}

#box(vert = nil, hor = nil, corn = nil) ⇒ Object

set the characters to frame the window in. The vertical vert and horizontal hor character.

win = Curses::Window.new(5,5,5,5) win.box(?|, ?-)


2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
# File 'ext/curses/curses.c', line 2220

static VALUE
window_box(int argc, VALUE *argv, VALUE self)
{
    struct windata *winp;
    VALUE vert, hor, corn;

    rb_scan_args(argc, argv, "03", &vert, &hor, &corn);

    GetWINDOW(self, winp);
    box(winp->window,
	NIL_P(vert) ? 0 : OBJ2CHTYPE(vert),
	NIL_P(hor) ? 0 : OBJ2CHTYPE(hor));

    if (!NIL_P(corn)) {
	int cur_x, cur_y, x, y;
	chtype c;

	c = OBJ2CHTYPE(corn);
	getyx(winp->window, cur_y, cur_x);
	x = NUM2INT(window_maxx(self)) - 1;
	y = NUM2INT(window_maxy(self)) - 1;
	wmove(winp->window, 0, 0);
	waddch(winp->window, c);
	wmove(winp->window, y, 0);
	waddch(winp->window, c);
	wmove(winp->window, y, x);
	waddch(winp->window, c);
	wmove(winp->window, 0, x);
	waddch(winp->window, c);
	wmove(winp->window, cur_y, cur_x);
    }

    return Qnil;
}

#clearObject

Clear the window.


1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
# File 'ext/curses/curses.c', line 1805

static VALUE
window_clear(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wclear(winp->window);

    return Qnil;
}

#closeObject

Deletes the window, and frees the memory


1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
# File 'ext/curses/curses.c', line 1788

static VALUE
window_close(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    delwin(winp->window);
    winp->window = 0;

    return Qnil;
}

#clrtoeolObject

Clear the window to the end of line, that the cursor is currently on.


1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
# File 'ext/curses/curses.c', line 1841

static VALUE
window_clrtoeol(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wclrtoeol(winp->window);

    return Qnil;
}

#color_set(col) ⇒ Object

Sets the current color of the given window to the foreground/background combination described by the Fixnum col.


2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
# File 'ext/curses/curses.c', line 2606

static VALUE
window_color_set(VALUE obj, VALUE col)
{
    struct windata *winp;
    int res;

    GetWINDOW(obj, winp);
    res = wcolor_set(winp->window, NUM2INT(col), NULL);
    return (res == OK) ? Qtrue : Qfalse;
}

#curxObject

A getter for the current column (X coord) of the window


2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
# File 'ext/curses/curses.c', line 2110

static VALUE
window_curx(VALUE obj)
{
    struct windata *winp;
    int x, RB_UNUSED_VAR(y);

    GetWINDOW(obj, winp);
    getyx(winp->window, y, x);
    return INT2FIX(x);
}

#curyObject

A getter for the current line (Y coord) of the window


2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
# File 'ext/curses/curses.c', line 2094

static VALUE
window_cury(VALUE obj)
{
    struct windata *winp;
    int RB_UNUSED_VAR(x), y;

    GetWINDOW(obj, winp);
    getyx(winp->window, y, x);
    return INT2FIX(y);
}

#delchObject

Delete the character under the cursor


2471
2472
2473
2474
2475
2476
2477
2478
2479
# File 'ext/curses/curses.c', line 2471

static VALUE
window_delch(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wdelch(winp->window);
    return Qnil;
}

#deletelnObject

Delete the line under the cursor.


2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
# File 'ext/curses/curses.c', line 2487

static VALUE
window_deleteln(VALUE obj)
{
#if defined(HAVE_WDELETELN) || defined(wdeleteln)
    struct windata *winp;

    GetWINDOW(obj, winp);
    wdeleteln(winp->window);
#endif
    return Qnil;
}

#derwin(height, width, relative_top, relative_left) ⇒ Object

Construct a new subwindow with constraints of height lines, width columns, begin at top line, and begin left most column relative to the parent window.


1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
# File 'ext/curses/curses.c', line 1761

static VALUE
window_derwin(VALUE obj, VALUE height, VALUE width, VALUE top, VALUE left)
{
    struct windata *winp;
    WINDOW *window;
    VALUE win;
    int h, w, t, l;

    h = NUM2INT(height);
    w = NUM2INT(width);
    t = NUM2INT(top);
    l = NUM2INT(left);
    GetWINDOW(obj, winp);
    window = derwin(winp->window, h, w, t, l);
    win = prep_window(rb_obj_class(obj), window);

    return win;
}

#eraseObject

Erase the window.


1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
# File 'ext/curses/curses.c', line 1822

static VALUE
window_erase(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    werase(winp->window);

    return Qnil;
}

#get_charObject

Read and returns a character or function key from the window. A single or multibyte character is represented by a String, and a function key is represented by an Integer. Returns nil if no input is ready.

See Curses::Key to all the function KEY_* available


4724
4725
4726
4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747
4748
4749
4750
4751
4752
4753
4754
4755
4756
4757
4758
# File 'ext/curses/curses.c', line 4724

static VALUE
window_get_char(VALUE obj)
{
#ifdef HAVE_WGET_WCH
    struct windata *winp;
    struct wget_wch_arg arg;

    GetWINDOW(obj, winp);
    arg.win = winp->window;
    rb_thread_call_without_gvl(wget_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
    struct windata *winp;
    struct wgetch_arg arg;

    GetWINDOW(obj, winp);
    arg.win = winp->window;
    rb_thread_call_without_gvl(wgetch_func, (void *)&arg, RUBY_UBF_IO, 0);
    if (arg.c > 0xff) {
	return INT2NUM(arg.c);
    }
    else if (arg.c >= 0) {
	return keyboard_uint_chr(arg.c);
    }
    else {
	return Qnil;
    }
#endif
}

#getbkgdObject

Returns an Integer (ch) for the character property in the current window.


2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
# File 'ext/curses/curses.c', line 2799

static VALUE
window_getbkgd(VALUE obj)
{
#ifdef HAVE_WGETBKGD
    chtype c;
    struct windata *winp;

    GetWINDOW(obj,winp);
    return (c = getbkgd(winp->window) != ERR) ? ULONG2NUM(c) : Qnil;
#else
    return Qnil;
#endif
}

#getchObject

Read and returns a character from the window.

See Curses::Key to all the function KEY_* available


2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
# File 'ext/curses/curses.c', line 2409

static VALUE
window_getch(VALUE obj)
{
    struct windata *winp;
    struct wgetch_arg arg;
    int c;

    GetWINDOW(obj, winp);
    arg.win = winp->window;
    rb_thread_call_without_gvl(wgetch_func, (void *)&arg, RUBY_UBF_IO, 0);
    c = arg.c;
    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);
}

#getstrObject

This is equivalent to a series of Curses::Window.getch calls


2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
# File 'ext/curses/curses.c', line 2452

static VALUE
window_getstr(VALUE obj)
{
    struct windata *winp;
    struct wgetstr_arg arg;

    GetWINDOW(obj, winp);
    arg.win = winp->window;
    rb_thread_call_without_gvl(wgetstr_func, (void *)&arg, RUBY_UBF_IO, 0);
    return rb_external_str_new_with_enc(arg.rtn, strlen(arg.rtn),
				       	keyboard_encoding);
}

#idlok(bool) ⇒ Object

If bool is true curses considers using the hardware insert/delete line feature of terminals so equipped.

If bool is false, disables use of line insertion and deletion. This option should be enabled only if the application needs insert/delete line, for example, for a screen editor.

It is disabled by default because insert/delete line tends to be visually annoying when used in applications where it is not really needed. If insert/delete line cannot be used, curses redraws the changed portions of all lines.


2558
2559
2560
2561
2562
2563
2564
2565
2566
# File 'ext/curses/curses.c', line 2558

static VALUE
window_idlok(VALUE obj, VALUE bf)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    idlok(winp->window, RTEST(bf) ? TRUE : FALSE);
    return Qnil;
}

#inchObject

Returns the character at the current position of the window.


2298
2299
2300
2301
2302
2303
2304
2305
# File 'ext/curses/curses.c', line 2298

static VALUE
window_inch(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    return CHTYPE2NUM(winch(winp->window));
}

#insch(ch) ⇒ Object

Insert a character ch, before the cursor, in the current window


2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
# File 'ext/curses/curses.c', line 2333

static VALUE
window_insch(VALUE obj, VALUE ch)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    winsch(winp->window, OBJ2CHTYPE(ch));

    return Qnil;
}

#insertlnObject

Inserts a line above the cursor, and the bottom line is lost


2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
# File 'ext/curses/curses.c', line 2505

static VALUE
window_insertln(VALUE obj)
{
#if defined(HAVE_WINSERTLN) || defined(winsertln)
    struct windata *winp;

    GetWINDOW(obj, winp);
    winsertln(winp->window);
#endif
    return Qnil;
}

#keypad(bool) ⇒ Object

Enables the keypad of the user's terminal.

If enabled (bool is true), the user can press a function key (such as an arrow key) and wgetch returns a single value representing the function key, as in KEY_LEFT. If disabled (bool is false), curses does not treat function keys specially and the program has to interpret the escape sequences itself. If the keypad in the terminal can be turned on (made to transmit) and off (made to work locally), turning on this option causes the terminal keypad to be turned on when Curses::Window.getch is called.

The default value for keypad is false.


2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
# File 'ext/curses/curses.c', line 2862

static VALUE
window_keypad(VALUE obj, VALUE val)
{
    struct windata *winp;

    GetWINDOW(obj,winp);
    /* keypad() of NetBSD's libcurses returns no value */
#if defined(__NetBSD__) && !defined(NCURSES_VERSION)
    keypad(winp->window,(RTEST(val) ? TRUE : FALSE));
    return Qnil;
#else
    /* may have to raise exception on ERR */
    return (keypad(winp->window,RTEST(val) ? TRUE : FALSE)) == OK ?
	Qtrue : Qfalse;
#endif
}

#keypad(bool) ⇒ Object

Enables the keypad of the user's terminal.

If enabled (bool is true), the user can press a function key (such as an arrow key) and wgetch returns a single value representing the function key, as in KEY_LEFT. If disabled (bool is false), curses does not treat function keys specially and the program has to interpret the escape sequences itself. If the keypad in the terminal can be turned on (made to transmit) and off (made to work locally), turning on this option causes the terminal keypad to be turned on when Curses::Window.getch is called.

The default value for keypad is false.


2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
# File 'ext/curses/curses.c', line 2862

static VALUE
window_keypad(VALUE obj, VALUE val)
{
    struct windata *winp;

    GetWINDOW(obj,winp);
    /* keypad() of NetBSD's libcurses returns no value */
#if defined(__NetBSD__) && !defined(NCURSES_VERSION)
    keypad(winp->window,(RTEST(val) ? TRUE : FALSE));
    return Qnil;
#else
    /* may have to raise exception on ERR */
    return (keypad(winp->window,RTEST(val) ? TRUE : FALSE)) == OK ?
	Qtrue : Qfalse;
#endif
}

#line_touched?(line) ⇒ Boolean

Return true if the specified line has been modified since the last call of refresh.

Returns:

  • (Boolean)

2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
# File 'ext/curses/curses.c', line 2013

static VALUE
window_line_touched(VALUE obj, VALUE line)
{
    struct windata *winp;
    int result, n;

    GetWINDOW(obj, winp);
    n = NUM2INT(line);
    result = is_linetouched(winp->window, n);
    if (result == ERR) {
	rb_raise(rb_eArgError, "Invalid line %d", n);
    }
    return result ? Qtrue : Qfalse;
}

#maxxObject

A getter for the maximum columns for the window


2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
# File 'ext/curses/curses.c', line 2150

static VALUE
window_maxx(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
#if defined(getmaxx)
    return INT2FIX(getmaxx(winp->window));
#elif defined(getmaxyx)
    {
	int x, RB_UNUSED_VAR(y);
	getmaxyx(winp->window, y, x);
	return INT2FIX(x);
    }
#else
    return INT2FIX(winp->window->_maxx+1);
#endif
}

#maxyObject

A getter for the maximum lines for the window


2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
# File 'ext/curses/curses.c', line 2126

static VALUE
window_maxy(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
#if defined(getmaxy)
    return INT2FIX(getmaxy(winp->window));
#elif defined(getmaxyx)
    {
	int RB_UNUSED_VAR(x), y;
	getmaxyx(winp->window, y, x);
	return INT2FIX(y);
    }
#else
    return INT2FIX(winp->window->_maxy+1);
#endif
}

#move(y, x) ⇒ Object

Moves the window so that the upper left-hand corner is at position (y, x)


2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
# File 'ext/curses/curses.c', line 2037

static VALUE
window_move(VALUE obj, VALUE y, VALUE x)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    mvwin(winp->window, NUM2INT(y), NUM2INT(x));

    return Qnil;
}

#move_relative(x, y) ⇒ Object

Moves the derived or subwindow inside its parent window. The screen-relative parameters of the window are not changed.


2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
# File 'ext/curses/curses.c', line 2056

static VALUE
window_move_relative(VALUE obj, VALUE y, VALUE x)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    mvderwin(winp->window, NUM2INT(y), NUM2INT(x));

    return Qnil;
}

#nodelay=(bool) ⇒ Object

When in no-delay mode Curses::Window#getch is a non-blocking call. If no input is ready #getch returns ERR.

When in delay mode (bool is false which is the default), Curses::Window#getch blocks until a key is pressed.


2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
# File 'ext/curses/curses.c', line 2895

static VALUE
window_nodelay(VALUE obj, VALUE val)
{
    struct windata *winp;
    GetWINDOW(obj,winp);

    /* nodelay() of NetBSD's libcurses returns no value */
#if defined(__NetBSD__) && !defined(NCURSES_VERSION)
    nodelay(winp->window, RTEST(val) ? TRUE : FALSE);
    return Qnil;
#else
    return nodelay(winp->window,RTEST(val) ? TRUE : FALSE) == OK ? Qtrue : Qfalse;
#endif
}

#noutrefreshObject

Refreshes the windows and lines.

Curses::Window.noutrefresh allows multiple updates with more efficiency than Curses::Window.refresh alone.


1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
# File 'ext/curses/curses.c', line 1877

static VALUE
window_noutrefresh(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
#ifdef HAVE_DOUPDATE
    wnoutrefresh(winp->window);
#else
    wrefresh(winp->window);
#endif

    return Qnil;
}

#redrawObject

Redraws the entire window.


1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
# File 'ext/curses/curses.c', line 1898

static VALUE
window_redraw(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    redrawwin(winp->window);

    return Qnil;
}

#refreshObject

Refreshes the windows and lines.


1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
# File 'ext/curses/curses.c', line 1858

static VALUE
window_refresh(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wrefresh(winp->window);

    return Qnil;
}

#resize(lines, cols) ⇒ Object

Resize the current window to Fixnum lines and Fixnum cols


2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
# File 'ext/curses/curses.c', line 2820

static VALUE
window_resize(VALUE obj, VALUE lin, VALUE col)
{
#if defined(HAVE_WRESIZE)
    struct windata *winp;

    GetWINDOW(obj,winp);
    return wresize(winp->window, NUM2INT(lin), NUM2INT(col)) == OK ? Qtrue : Qfalse;
#else
    return Qnil;
#endif
}

#scrl(num) ⇒ Object

Scrolls the current window Fixnum num lines. The current cursor position is not changed.

For positive num, it scrolls up.

For negative num, it scrolls down.


2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
# File 'ext/curses/curses.c', line 2645

static VALUE
window_scrl(VALUE obj, VALUE n)
{
#ifdef HAVE_WSCRL
    struct windata *winp;

    GetWINDOW(obj, winp);
    /* may have to raise exception on ERR */
    return (wscrl(winp->window,NUM2INT(n)) == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

#scrollObject

Scrolls the current window up one line.


2623
2624
2625
2626
2627
2628
2629
2630
2631
# File 'ext/curses/curses.c', line 2623

static VALUE
window_scroll(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    /* may have to raise exception on ERR */
    return (scroll(winp->window) == OK) ? Qtrue : Qfalse;
}

#scrollok(bool) ⇒ Object

Controls what happens when the cursor of a window is moved off the edge of the window or scrolling region, either as a result of a newline action on the bottom line, or typing the last character of the last line.

If disabled, (bool is false), the cursor is left on the bottom line.

If enabled, (bool is true), the window is scrolled up one line (Note that to get the physical scrolling effect on the terminal, it is also necessary to call Curses::Window.idlok)


2532
2533
2534
2535
2536
2537
2538
2539
2540
# File 'ext/curses/curses.c', line 2532

static VALUE
window_scrollok(VALUE obj, VALUE bf)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    scrollok(winp->window, RTEST(bf) ? TRUE : FALSE);
    return Qnil;
}

#setpos(y, x) ⇒ Object

A setter for the position of the cursor in the current window, using coordinates x and y


2079
2080
2081
2082
2083
2084
2085
2086
2087
# File 'ext/curses/curses.c', line 2079

static VALUE
window_setpos(VALUE obj, VALUE y, VALUE x)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wmove(winp->window, NUM2INT(y), NUM2INT(x));
    return Qnil;
}

#setscrreg(top, bottom) ⇒ Object

Set a software scrolling region in a window. top and bottom are lines numbers of the margin.

If this option and Curses::Window.scrollok are enabled, an attempt to move off the bottom margin line causes all lines in the scrolling region to scroll one line in the direction of the first line. Only the text of the window is scrolled.


2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
# File 'ext/curses/curses.c', line 2582

static VALUE
window_setscrreg(VALUE obj, VALUE top, VALUE bottom)
{
#ifdef HAVE_WSETSCRREG
    struct windata *winp;
    int res;

    GetWINDOW(obj, winp);
    res = wsetscrreg(winp->window, NUM2INT(top), NUM2INT(bottom));
    /* may have to raise exception on ERR */
    return (res == OK) ? Qtrue : Qfalse;
#else
    return Qfalse;
#endif
}

#standendObject

Enables the Normal display (no highlight)

This is equivalent to Curses::Window.attron(A_NORMAL)

see also Curses::Window.attrset


2283
2284
2285
2286
2287
2288
2289
2290
2291
# File 'ext/curses/curses.c', line 2283

static VALUE
window_standend(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wstandend(winp->window);
    return Qnil;
}

#standoutObject

Enables the best highlighting mode of the terminal.

This is equivalent to Curses::Window.attron(A_STANDOUT)

see also Curses::Window.attrset


2264
2265
2266
2267
2268
2269
2270
2271
2272
# File 'ext/curses/curses.c', line 2264

static VALUE
window_standout(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    wstandout(winp->window);
    return Qnil;
}

#subwin(height, width, top, left) ⇒ Object

Construct a new subwindow with constraints of height lines, width columns, begin at top line, and begin left most column.


1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
# File 'ext/curses/curses.c', line 1732

static VALUE
window_subwin(VALUE obj, VALUE height, VALUE width, VALUE top, VALUE left)
{
    struct windata *winp;
    WINDOW *window;
    VALUE win;
    int h, w, t, l;

    h = NUM2INT(height);
    w = NUM2INT(width);
    t = NUM2INT(top);
    l = NUM2INT(left);
    GetWINDOW(obj, winp);
    window = subwin(winp->window, h, w, t, l);
    win = prep_window(rb_obj_class(obj), window);

    return win;
}

#timeout=(delay) ⇒ Object

Sets block and non-blocking reads for the window.

  • If delay is negative, blocking read is used (i.e., waits indefinitely for input).

  • If delay is zero, then non-blocking read is used (i.e., read returns ERR if no input is waiting).

  • If delay is positive, then read blocks for delay milliseconds, and returns ERR if there is still no input.


2924
2925
2926
2927
2928
2929
2930
2931
2932
# File 'ext/curses/curses.c', line 2924

static VALUE
window_timeout(VALUE obj, VALUE delay)
{
    struct windata *winp;
    GetWINDOW(obj,winp);

    wtimeout(winp->window,NUM2INT(delay));
    return Qnil;
}

#touchObject

Treat the window as if it has been modified since the last call of refresh.


1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
# File 'ext/curses/curses.c', line 1918

static VALUE
window_touch(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    touchwin(winp->window);

    return Qnil;
}

#touch_line(y, n, changed = true) ⇒ Object

Make n lines from line y look as if they have (changed = true) or have not (changed = false) been modified since the last call of refresh.


1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
# File 'ext/curses/curses.c', line 1979

static VALUE
window_touch_line(int argc, VALUE *argv, VALUE obj)
{
    struct windata *winp;
    VALUE y, n, changed;
    int result;

    rb_scan_args(argc, argv, "12", &y, &n, &changed);
    if (argc < 2) {
	n = INT2NUM(1);
    }
    if (argc < 3) {
	changed = Qtrue;
    }
    GetWINDOW(obj, winp);
    result = wtouchln(winp->window, NUM2INT(y), NUM2INT(n), RTEST(changed));
    if (result == ERR) {
	rb_raise(rb_eRangeError, "Out of window");
    }

    return Qnil;
}

#touched?Boolean

Return true if the window has been modified since the last call of refresh.

Returns:

  • (Boolean)

1959
1960
1961
1962
1963
1964
1965
1966
# File 'ext/curses/curses.c', line 1959

static VALUE
window_touched(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    return is_wintouched(winp->window) ? Qtrue : Qfalse;
}

#untouchObject

Treat the window as if it has not been modified since the last call of refresh.


1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
# File 'ext/curses/curses.c', line 1939

static VALUE
window_untouch(VALUE obj)
{
    struct windata *winp;

    GetWINDOW(obj, winp);
    untouchwin(winp->window);

    return Qnil;
}