Class: Notcurses::NcplaneOptions

Inherits:
Object
  • Object
show all
Defined in:
ext/notcurses/src/notcurses_wrap.c,
ext/notcurses/src/notcurses_wrap.c

Overview

Proxy of C Notcurses::NcplaneOptions struct

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

call-seq:

NcplaneOptions.new

Class constructor.



18759
18760
18761
18762
18763
18764
18765
18766
18767
18768
18769
18770
18771
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18759

SWIGINTERN VALUE
_wrap_new_NcplaneOptions(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (struct ncplane_options *)calloc(1, sizeof(struct ncplane_options));
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}

Instance Method Details

#cols(*args) ⇒ Object

call-seq:

cols -> unsigned int

Get value of attribute.



17993
17994
17995
17996
17997
17998
17999
18000
18001
18002
18003
18004
18005
18006
18007
18008
18009
18010
18011
18012
18013
18014
18015
18016
18017
18018
18019
18020
18021
18022
18023
18024
18025
18026
18027
18028
18029
18030
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17993

SWIGINTERN VALUE
_wrap_NcplaneOptions_cols_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","cols", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (unsigned int) ((arg1)->cols);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#cols=(*args) ⇒ Object

call-seq:

cols=(x) -> unsigned int

Set new value for attribute.



17947
17948
17949
17950
17951
17952
17953
17954
17955
17956
17957
17958
17959
17960
17961
17962
17963
17964
17965
17966
17967
17968
17969
17970
17971
17972
17973
17974
17975
17976
17977
17978
17979
17980
17981
17982
17983
17984
17985
17986
17987
17988
17989
17990
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17947

SWIGINTERN VALUE
_wrap_NcplaneOptions_cols_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","cols", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","cols", 2, argv[0] ));
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->cols = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#flags(*args) ⇒ Object

call-seq:

flags -> uint64_t

Get value of attribute.



18487
18488
18489
18490
18491
18492
18493
18494
18495
18496
18497
18498
18499
18500
18501
18502
18503
18504
18505
18506
18507
18508
18509
18510
18511
18512
18513
18514
18515
18516
18517
18518
18519
18520
18521
18522
18523
18524
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18487

SWIGINTERN VALUE
_wrap_NcplaneOptions_flags_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  uint64_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","flags", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (uint64_t) ((arg1)->flags);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#flags=(*args) ⇒ Object

call-seq:

flags=(x) -> uint64_t

Set new value for attribute.



18441
18442
18443
18444
18445
18446
18447
18448
18449
18450
18451
18452
18453
18454
18455
18456
18457
18458
18459
18460
18461
18462
18463
18464
18465
18466
18467
18468
18469
18470
18471
18472
18473
18474
18475
18476
18477
18478
18479
18480
18481
18482
18483
18484
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18441

SWIGINTERN VALUE
_wrap_NcplaneOptions_flags_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  uint64_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","flags", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "uint64_t","flags", 2, argv[0] ));
  } 
  arg2 = (uint64_t)(val2);
  if (arg1) (arg1)->flags = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#margin_b(*args) ⇒ Object

call-seq:

margin_b -> unsigned int

Get value of attribute.



18591
18592
18593
18594
18595
18596
18597
18598
18599
18600
18601
18602
18603
18604
18605
18606
18607
18608
18609
18610
18611
18612
18613
18614
18615
18616
18617
18618
18619
18620
18621
18622
18623
18624
18625
18626
18627
18628
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18591

SWIGINTERN VALUE
_wrap_NcplaneOptions_margin_b_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","margin_b", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (unsigned int) ((arg1)->margin_b);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#margin_b=(*args) ⇒ Object

call-seq:

margin_b=(x) -> unsigned int

Set new value for attribute.



18545
18546
18547
18548
18549
18550
18551
18552
18553
18554
18555
18556
18557
18558
18559
18560
18561
18562
18563
18564
18565
18566
18567
18568
18569
18570
18571
18572
18573
18574
18575
18576
18577
18578
18579
18580
18581
18582
18583
18584
18585
18586
18587
18588
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18545

SWIGINTERN VALUE
_wrap_NcplaneOptions_margin_b_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","margin_b", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","margin_b", 2, argv[0] ));
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->margin_b = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#margin_r(*args) ⇒ Object

call-seq:

margin_r -> unsigned int

Get value of attribute.



18695
18696
18697
18698
18699
18700
18701
18702
18703
18704
18705
18706
18707
18708
18709
18710
18711
18712
18713
18714
18715
18716
18717
18718
18719
18720
18721
18722
18723
18724
18725
18726
18727
18728
18729
18730
18731
18732
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18695

SWIGINTERN VALUE
_wrap_NcplaneOptions_margin_r_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","margin_r", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (unsigned int) ((arg1)->margin_r);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#margin_r=(*args) ⇒ Object

call-seq:

margin_r=(x) -> unsigned int

Set new value for attribute.



18649
18650
18651
18652
18653
18654
18655
18656
18657
18658
18659
18660
18661
18662
18663
18664
18665
18666
18667
18668
18669
18670
18671
18672
18673
18674
18675
18676
18677
18678
18679
18680
18681
18682
18683
18684
18685
18686
18687
18688
18689
18690
18691
18692
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18649

SWIGINTERN VALUE
_wrap_NcplaneOptions_margin_r_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","margin_r", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","margin_r", 2, argv[0] ));
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->margin_r = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#name(*args) ⇒ Object

call-seq:

name -> char const *

Get value of attribute.



18250
18251
18252
18253
18254
18255
18256
18257
18258
18259
18260
18261
18262
18263
18264
18265
18266
18267
18268
18269
18270
18271
18272
18273
18274
18275
18276
18277
18278
18279
18280
18281
18282
18283
18284
18285
18286
18287
18288
18289
18290
18291
18292
18293
18294
18295
18296
18297
18298
18299
18300
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18250

SWIGINTERN VALUE
_wrap_NcplaneOptions_name_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","name", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (char *) ((arg1)->name);
  {
    VALUE hash = rb_hash_new();
    VALUE obj;
    
    if (result == NULL) {
      obj = Qnil;
    } else {
      // Convert C string to Ruby string
      obj = rb_str_new2(result);
    }
    
    rb_hash_aset(hash, ID2SYM(rb_intern("return")), obj);
    vresult = hash;
  }
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#name=(*args) ⇒ Object

call-seq:

name=(x) -> char const *

Set new value for attribute.



18182
18183
18184
18185
18186
18187
18188
18189
18190
18191
18192
18193
18194
18195
18196
18197
18198
18199
18200
18201
18202
18203
18204
18205
18206
18207
18208
18209
18210
18211
18212
18213
18214
18215
18216
18217
18218
18219
18220
18221
18222
18223
18224
18225
18226
18227
18228
18229
18230
18231
18232
18233
18234
18235
18236
18237
18238
18239
18240
18241
18242
18243
18244
18245
18246
18247
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18182

SWIGINTERN VALUE
_wrap_NcplaneOptions_name_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","name", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","name", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  if (arg2) {
    size_t size = strlen((const char *)((const char *)(arg2))) + 1;
    arg1->name = (char const *)(char *)memcpy(malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
  } else {
    arg1->name = 0;
  }
  vresult = rb_ary_new();
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    VALUE obj = arg2 ? rb_str_new2(arg2) : Qnil;
    rb_hash_aset(vresult, ID2SYM(rb_intern("name")), obj);
  }
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

#resizecb(*args) ⇒ Object

call-seq:

resizecb(arg1) -> int (*)(struct ncplane *)

Get value of attribute.



18383
18384
18385
18386
18387
18388
18389
18390
18391
18392
18393
18394
18395
18396
18397
18398
18399
18400
18401
18402
18403
18404
18405
18406
18407
18408
18409
18410
18411
18412
18413
18414
18415
18416
18417
18418
18419
18420
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18383

SWIGINTERN VALUE
_wrap_NcplaneOptions_resizecb_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int (*result)(struct ncplane *) = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","resizecb", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (int (*)(struct ncplane *)) ((arg1)->resizecb);
  vresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_struct_ncplane__int);
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#resizecb=(*args) ⇒ Object

call-seq:

resizecb=(x) -> int (*)(struct ncplane *)

Set new value for attribute.



18321
18322
18323
18324
18325
18326
18327
18328
18329
18330
18331
18332
18333
18334
18335
18336
18337
18338
18339
18340
18341
18342
18343
18344
18345
18346
18347
18348
18349
18350
18351
18352
18353
18354
18355
18356
18357
18358
18359
18360
18361
18362
18363
18364
18365
18366
18367
18368
18369
18370
18371
18372
18373
18374
18375
18376
18377
18378
18379
18380
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18321

SWIGINTERN VALUE
_wrap_NcplaneOptions_resizecb_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  int (*arg2)(struct ncplane *) = (int (*)(struct ncplane *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","resizecb", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  {
    int res = SWIG_ConvertFunctionPtr(argv[0], (void**)(&arg2), SWIGTYPE_p_f_p_struct_ncplane__int);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "int (*)(struct ncplane *)","resizecb", 2, argv[0] )); 
    }
  }
  if (arg1) (arg1)->resizecb = arg2;
  vresult = rb_ary_new();
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("int (*)(struct ncplane *)");
    if (!ty) ty = SWIGTYPE_p_f_p_struct_ncplane__int;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg2, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("resizecb")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#rows(*args) ⇒ Object

call-seq:

rows -> unsigned int

Get value of attribute.



17889
17890
17891
17892
17893
17894
17895
17896
17897
17898
17899
17900
17901
17902
17903
17904
17905
17906
17907
17908
17909
17910
17911
17912
17913
17914
17915
17916
17917
17918
17919
17920
17921
17922
17923
17924
17925
17926
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17889

SWIGINTERN VALUE
_wrap_NcplaneOptions_rows_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","rows", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (unsigned int) ((arg1)->rows);
  vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#rows=(*args) ⇒ Object

call-seq:

rows=(x) -> unsigned int

Set new value for attribute.



17843
17844
17845
17846
17847
17848
17849
17850
17851
17852
17853
17854
17855
17856
17857
17858
17859
17860
17861
17862
17863
17864
17865
17866
17867
17868
17869
17870
17871
17872
17873
17874
17875
17876
17877
17878
17879
17880
17881
17882
17883
17884
17885
17886
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17843

SWIGINTERN VALUE
_wrap_NcplaneOptions_rows_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","rows", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","rows", 2, argv[0] ));
  } 
  arg2 = (unsigned int)(val2);
  if (arg1) (arg1)->rows = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#userptr(*args) ⇒ Object

call-seq:

userptr -> void *

Get value of attribute.



18112
18113
18114
18115
18116
18117
18118
18119
18120
18121
18122
18123
18124
18125
18126
18127
18128
18129
18130
18131
18132
18133
18134
18135
18136
18137
18138
18139
18140
18141
18142
18143
18144
18145
18146
18147
18148
18149
18150
18151
18152
18153
18154
18155
18156
18157
18158
18159
18160
18161
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18112

SWIGINTERN VALUE
_wrap_NcplaneOptions_userptr_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","userptr", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (void *) ((arg1)->userptr);
  {
    VALUE hash = rb_hash_new();
    VALUE obj;
    
    if (strcmp("void *", "void") == 0) {
      obj = Qnil;
    } else {
      obj = SWIG_Ruby_NewPointerObj(result, SWIGTYPE_p_void, 0);
    }
    
    rb_hash_aset(hash, ID2SYM(rb_intern("return")), obj);
    vresult = hash;
  }
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#userptr=(*args) ⇒ Object

call-seq:

userptr=(x) -> void *

Set new value for attribute.



18051
18052
18053
18054
18055
18056
18057
18058
18059
18060
18061
18062
18063
18064
18065
18066
18067
18068
18069
18070
18071
18072
18073
18074
18075
18076
18077
18078
18079
18080
18081
18082
18083
18084
18085
18086
18087
18088
18089
18090
18091
18092
18093
18094
18095
18096
18097
18098
18099
18100
18101
18102
18103
18104
18105
18106
18107
18108
18109
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 18051

SWIGINTERN VALUE
_wrap_NcplaneOptions_userptr_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","userptr", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","userptr", 2, argv[0] )); 
  }
  if (arg1) (arg1)->userptr = arg2;
  vresult = rb_ary_new();
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("void *");
    if (!ty) ty = SWIGTYPE_p_void;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg2, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("userptr")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#x(*args) ⇒ Object

call-seq:

x -> int

Get value of attribute.



17785
17786
17787
17788
17789
17790
17791
17792
17793
17794
17795
17796
17797
17798
17799
17800
17801
17802
17803
17804
17805
17806
17807
17808
17809
17810
17811
17812
17813
17814
17815
17816
17817
17818
17819
17820
17821
17822
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17785

SWIGINTERN VALUE
_wrap_NcplaneOptions_x_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","x", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (int) ((arg1)->x);
  vresult = SWIG_From_int((int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#x=(*args) ⇒ Object

call-seq:

x=(x) -> int

Set new value for attribute.



17739
17740
17741
17742
17743
17744
17745
17746
17747
17748
17749
17750
17751
17752
17753
17754
17755
17756
17757
17758
17759
17760
17761
17762
17763
17764
17765
17766
17767
17768
17769
17770
17771
17772
17773
17774
17775
17776
17777
17778
17779
17780
17781
17782
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17739

SWIGINTERN VALUE
_wrap_NcplaneOptions_x_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","x", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","x", 2, argv[0] ));
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->x = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#y(*args) ⇒ Object

call-seq:

y -> int

Get value of attribute.



17681
17682
17683
17684
17685
17686
17687
17688
17689
17690
17691
17692
17693
17694
17695
17696
17697
17698
17699
17700
17701
17702
17703
17704
17705
17706
17707
17708
17709
17710
17711
17712
17713
17714
17715
17716
17717
17718
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17681

SWIGINTERN VALUE
_wrap_NcplaneOptions_y_get(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","y", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  result = (int) ((arg1)->y);
  vresult = SWIG_From_int((int)(result));
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}

#y=(*args) ⇒ Object

call-seq:

y=(x) -> int

Set new value for attribute.



17635
17636
17637
17638
17639
17640
17641
17642
17643
17644
17645
17646
17647
17648
17649
17650
17651
17652
17653
17654
17655
17656
17657
17658
17659
17660
17661
17662
17663
17664
17665
17666
17667
17668
17669
17670
17671
17672
17673
17674
17675
17676
17677
17678
 
# File 'ext/notcurses/src/notcurses_wrap.c', line 17635

SWIGINTERN VALUE
_wrap_NcplaneOptions_y_set(int argc, VALUE *argv, VALUE self) {
  struct ncplane_options *arg1 = (struct ncplane_options *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ncplane_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct ncplane_options *","y", 1, self )); 
  }
  arg1 = (struct ncplane_options *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","y", 2, argv[0] ));
  } 
  arg2 = (int)(val2);
  if (arg1) (arg1)->y = arg2;
  {
    if (vresult == Qnil) {
      vresult = rb_hash_new();
    }
    if (!RB_TYPE_P(vresult, T_HASH)) {
      VALUE temp = rb_hash_new();
      rb_hash_aset(temp, ID2SYM(rb_intern("return")), vresult);
      vresult = temp;
    }
    
    swig_type_info *ty = SWIG_TypeQuery("struct ncplane_options *");
    if (!ty) ty = SWIGTYPE_p_ncplane_options;
    
    VALUE obj = SWIG_NewPointerObj((void *)arg1, ty, 0);
    rb_hash_aset(vresult, ID2SYM(rb_intern("self")), obj);
  }
  return vresult;
fail:
  return Qnil;
}