Class: Curses::Menu

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

Instance Method Summary collapse

Constructor Details

#initialize(items) ⇒ Object

call-seq:

new(items)

Construct a new Curses::Menu.



3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
 
# File 'ext/curses/curses.c', line 3297

static VALUE
menu_initialize(VALUE obj, VALUE items)
{
    struct menudata *menup;
    ITEM **menu_items;
    int i;
    ID id_new;

    Check_Type(items, T_ARRAY);
    curses_init_screen();
    TypedData_Get_Struct(obj, struct menudata, &menudata_type, menup);
    if (menup->menu) {
	rb_raise(rb_eRuntimeError, "already initialized menu");
    }
    menup->items = rb_ary_new();
    menu_items = ALLOC_N(ITEM *, RARRAY_LEN(items) + 1);
    CONST_ID(id_new, "new");
    for (i = 0; i < RARRAY_LEN(items); i++) {
	VALUE item = RARRAY_AREF(items, i);
	struct itemdata *itemp;

	if (RB_TYPE_P(item, T_ARRAY)) {
	    item = rb_apply(cItem, id_new, item);
	}
	GetITEM(item, itemp);
	menu_items[i] = itemp->item;
	rb_ary_push(menup->items, item);
    }
    menu_items[RARRAY_LEN(items)] = NULL;
    menup->menu = new_menu(menu_items);
    if (menup->menu == NULL) {
	check_curses_error(errno);
    }

    return obj;
}

Instance Method Details

#back_pattern ⇒ Object 



83
84
85
 
# File 'lib/curses.rb', line 83

def back_pattern
  driver(Curses::REQ_BACK_PATTERN)
end

#clear_pattern ⇒ Object 



79
80
81
 
# File 'lib/curses.rb', line 79

def clear_pattern
  driver(Curses::REQ_CLEAR_PATTERN)
end

#current_item ⇒ Object

call-seq:

current_item

Returns the current item.



3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
 
# File 'ext/curses/curses.c', line 3487

static VALUE
menu_get_current_item(VALUE obj)
{
    struct menudata *menup;
    ITEM *item;

    GetMENU(obj, menup);
    item = current_item(menup->menu);
    if (item == NULL) {
	return Qnil;
    }
    return item_new(item);
}

#current_item=(item) ⇒ Object

call-seq:

current_item=(item)

Sets the current item.



3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
 
# File 'ext/curses/curses.c', line 3509

static VALUE
menu_set_current_item(VALUE obj, VALUE item)
{
    struct menudata *menup;
    struct itemdata *itemp;

    GetMENU(obj, menup);
    GetITEM(item, itemp);
    set_current_item(menup->menu, itemp->item);
    return item;
}

#down_item ⇒ Object 



39
40
41
 
# File 'lib/curses.rb', line 39

def down_item
  driver(Curses::REQ_DOWN_ITEM)
end

#driver(command) ⇒ Object

call-seq:

driver(command)

Perform the command on the menu.



3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
 
# File 'ext/curses/curses.c', line 3384

static VALUE
menu_driver_m(VALUE obj, VALUE command)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = menu_driver(menup->menu, NUM2INT(command));
    check_curses_error(error);

    return obj;
}

#first_item ⇒ Object 



59
60
61
 
# File 'lib/curses.rb', line 59

def first_item
  driver(Curses::REQ_FIRST_ITEM)
end

#format ⇒ Object

call-seq:

format

Get the maximum size of the menu.



3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
 
# File 'ext/curses/curses.c', line 3609

static VALUE
menu_format_m(VALUE obj)
{
    struct menudata *menup;
    int rows, cols;

    GetMENU(obj, menup);
    menu_format(menup->menu, &rows, &cols);
    return rb_assoc_new(INT2NUM(rows), INT2NUM(cols));
}

#item_count ⇒ Object

call-seq:

item_count

Returns the count of items in the menu.



3405
3406
3407
3408
3409
3410
3411
3412
 
# File 'ext/curses/curses.c', line 3405

static VALUE
menu_item_count(VALUE obj)
{
    struct menudata *menup;

    GetMENU(obj, menup);
    return INT2NUM(item_count(menup->menu));
}

#items ⇒ Object

call-seq:

items

Returns the items of the menu.



3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
 
# File 'ext/curses/curses.c', line 3422

static VALUE
menu_get_items(VALUE obj)
{
    struct menudata *menup;
    ITEM **items;
    int count, i;
    VALUE ary;

    GetMENU(obj, menup);
    items = menu_items(menup->menu);
    if (items == NULL) {
	return Qnil;
    }
    count = item_count(menup->menu);
    ary = rb_ary_new();
    for (i = 0; i < count; i++) {
	rb_ary_push(ary, item_new(items[i]));
    }
    return ary;
}

#items=(items) ⇒ Object

call-seq:

items=(items)

Returns the items of the menu.



3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
 
# File 'ext/curses/curses.c', line 3451

static VALUE
menu_set_items(VALUE obj, VALUE items)
{
    struct menudata *menup;
    ITEM **old_items, **new_items;
    int i, error;

    Check_Type(items, T_ARRAY);
    GetMENU(obj, menup);
    old_items = menu_items(menup->menu);
    new_items = ALLOC_N(ITEM*, RARRAY_LEN(items) + 1);
    for (i = 0; i < RARRAY_LEN(items); i++) {
	struct itemdata *itemp;
	GetITEM(RARRAY_AREF(items, i), itemp);
	new_items[i] = itemp->item;
    }
    new_items[RARRAY_LEN(items)] = NULL;
    error = set_menu_items(menup->menu, new_items);
    if (error != E_OK) {
	xfree(new_items);
	check_curses_error(error);
	return items;
    }
    xfree(old_items);
    menup->items = rb_ary_dup(items);
    return items;
}

#last_item ⇒ Object 



63
64
65
 
# File 'lib/curses.rb', line 63

def last_item
  driver(Curses::REQ_LAST_ITEM)
end

#left_item ⇒ Object 



27
28
29
 
# File 'lib/curses.rb', line 27

def left_item
  driver(Curses::REQ_LEFT_ITEM)
end

#next_item ⇒ Object 



67
68
69
 
# File 'lib/curses.rb', line 67

def next_item
  driver(Curses::REQ_NEXT_ITEM)
end

#next_match ⇒ Object 



87
88
89
 
# File 'lib/curses.rb', line 87

def next_match
  driver(Curses::REQ_NEXT_MATCH)
end

#opts(opts) ⇒ Object

call-seq:

opts

Get the current option bits of the menu.



3688
3689
3690
3691
3692
3693
3694
3695
 
# File 'ext/curses/curses.c', line 3688

static VALUE
menu_opts_m(VALUE obj, VALUE opts)
{
    struct menudata *menup;

    GetMENU(obj, menup);
    return INT2NUM(menu_opts(menup->menu));
}

#opts_off(opts) ⇒ Object

call-seq:

opts_off(opts)

Turn off the option bits of the menu.



3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
 
# File 'ext/curses/curses.c', line 3668

static VALUE
menu_opts_off_m(VALUE obj, VALUE opts)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = menu_opts_off(menup->menu, NUM2INT(opts));
    check_curses_error(error);
    return obj;
}

#opts_on(opts) ⇒ Object

call-seq:

opts_on(opts)

Turn on the option bits of the menu.



3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
 
# File 'ext/curses/curses.c', line 3648

static VALUE
menu_opts_on_m(VALUE obj, VALUE opts)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = menu_opts_on(menup->menu, NUM2INT(opts));
    check_curses_error(error);
    return obj;
}

#post ⇒ Object

call-seq:

post

Post the menu.



3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
 
# File 'ext/curses/curses.c', line 3342

static VALUE
menu_post(VALUE obj)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = post_menu(menup->menu);
    check_curses_error(error);

    return obj;
}

#prev_item ⇒ Object 



71
72
73
 
# File 'lib/curses.rb', line 71

def prev_item
  driver(Curses::REQ_PREV_ITEM)
end

#prev_match ⇒ Object 



91
92
93
 
# File 'lib/curses.rb', line 91

def prev_match
  driver(Curses::REQ_PREV_MATCH)
end

#right_item ⇒ Object 



31
32
33
 
# File 'lib/curses.rb', line 31

def right_item
  driver(Curses::REQ_RIGHT_ITEM)
end

#scale ⇒ Object

call-seq:

scale

Return the minimum rows and columns required for the subwindow of the menu.



3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
 
# File 'ext/curses/curses.c', line 3569

static VALUE
menu_scale(VALUE obj)
{
    struct menudata *menup;
    int error, rows, columns;

    GetMENU(obj, menup);
    error = scale_menu(menup->menu, &rows, &columns);
    check_curses_error(error);
    return rb_assoc_new(INT2NUM(rows), INT2NUM(columns));
}

#scroll_down_line ⇒ Object 



47
48
49
 
# File 'lib/curses.rb', line 47

def scroll_down_line
  driver(Curses::REQ_SCR_DLINE)
end

#scroll_down_page ⇒ Object 



55
56
57
 
# File 'lib/curses.rb', line 55

def scroll_down_page
  driver(Curses::REQ_SCR_DPAGE)
end

#scroll_up_line ⇒ Object 



43
44
45
 
# File 'lib/curses.rb', line 43

def scroll_up_line
  driver(Curses::REQ_SCR_ULINE)
end

#scroll_up_page ⇒ Object 



51
52
53
 
# File 'lib/curses.rb', line 51

def scroll_up_page
  driver(Curses::REQ_SCR_UPAGE)
end

#set_format(rows, cols) ⇒ Object

call-seq:

set_format(rows, cols)

Set the maximum size of the menu.



3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
 
# File 'ext/curses/curses.c', line 3589

static VALUE
menu_set_format(VALUE obj, VALUE rows, VALUE cols)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = set_menu_format(menup->menu, NUM2INT(rows), NUM2INT(cols));
    check_curses_error(error);
    return obj;
}

#set_opts(opts) ⇒ Object

call-seq:

set_opts(opts)

Set the option bits of the menu.



3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
 
# File 'ext/curses/curses.c', line 3628

static VALUE
menu_set_opts(VALUE obj, VALUE opts)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = set_menu_opts(menup->menu, NUM2INT(opts));
    check_curses_error(error);
    return obj;
}

#set_sub(win) ⇒ Object

call-seq:

set_sub=(win)

Set the subwindow of the menu.



3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
 
# File 'ext/curses/curses.c', line 3549

static VALUE
menu_set_sub(VALUE obj, VALUE win)
{
    struct menudata *menup;
    struct windata *winp;

    GetMENU(obj, menup);
    GetWINDOW(win, winp);
    set_menu_sub(menup->menu, winp->window);
    return win;
}

#set_win(win) ⇒ Object

call-seq:

set_win=(win)

Set the window of the menu.



3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
 
# File 'ext/curses/curses.c', line 3529

static VALUE
menu_set_win(VALUE obj, VALUE win)
{
    struct menudata *menup;
    struct windata *winp;

    GetMENU(obj, menup);
    GetWINDOW(win, winp);
    set_menu_win(menup->menu, winp->window);
    return win;
}

#toggle_item ⇒ Object 



75
76
77
 
# File 'lib/curses.rb', line 75

def toggle_item
  driver(Curses::REQ_TOGGLE_ITEM)
end

#unpost ⇒ Object

call-seq:

unpost

Unpost the menu.



3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
 
# File 'ext/curses/curses.c', line 3363

static VALUE
menu_unpost(VALUE obj)
{
    struct menudata *menup;
    int error;

    GetMENU(obj, menup);
    error = unpost_menu(menup->menu);
    check_curses_error(error);

    return obj;
}

#up_item ⇒ Object 



35
36
37
 
# File 'lib/curses.rb', line 35

def up_item
  driver(Curses::REQ_UP_ITEM)
end