fxruby 1.6.23 → 1.6.24
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/.yardopts +4 -0
 - data/History.txt +4 -0
 - data/Manifest.txt +0 -1
 - data/README.rdoc +1 -1
 - data/Rakefile +3 -3
 - data/Rakefile.cross +5 -5
 - data/doap.rdf +1 -1
 - data/ext/fox16/FXRuby.cpp +1 -0
 - data/ext/fox16/core_wrap.cpp +64 -32
 - data/ext/fox16/dc_wrap.cpp +4 -2
 - data/ext/fox16/dialogs_wrap.cpp +75 -45
 - data/ext/fox16/extconf.rb +4 -3
 - data/ext/fox16/frames_wrap.cpp +35 -19
 - data/ext/fox16/fx3d_wrap.cpp +12 -4
 - data/ext/fox16/iconlist_wrap.cpp +2 -0
 - data/ext/fox16/icons_wrap.cpp +26 -13
 - data/ext/fox16/image_wrap.cpp +27 -13
 - data/ext/fox16/label_wrap.cpp +16 -10
 - data/ext/fox16/layout_wrap.cpp +30 -17
 - data/ext/fox16/list_wrap.cpp +2 -0
 - data/ext/fox16/mdi_wrap.cpp +9 -2
 - data/ext/fox16/menu_wrap.cpp +17 -10
 - data/ext/fox16/scintilla_wrap.cpp +1 -0
 - data/ext/fox16/table_wrap.cpp +2 -1
 - data/ext/fox16/text_wrap.cpp +2 -1
 - data/ext/fox16/treelist_wrap.cpp +3 -0
 - data/ext/fox16/ui_wrap.cpp +46 -21
 - data/lib/fox16/version.rb +1 -1
 - data/swig-interfaces/FXApp.i +1 -1
 - data/swig-interfaces/FXSplashWindow.i +2 -2
 - data/swig-interfaces/ruby-typemaps.i +8 -2
 - data/test/TC_FXApp.rb +4 -0
 - data/test/TC_FXButton.rb +4 -0
 - data/test/TC_FXGLViewer.rb +9 -0
 - data/test/TC_FXMessageBox.rb +4 -0
 - data/test/TC_FXScrollArea.rb +4 -0
 - data/test/TC_FXShell.rb +4 -0
 - data/test/TC_FXTopWindow.rb +4 -0
 - metadata +4 -5
 - data/README.git +0 -3
 
    
        data/ext/fox16/frames_wrap.cpp
    CHANGED
    
    | 
         @@ -1106,7 +1106,8 @@ static VALUE _wrap_new_FXArrowButton(int argc, VALUE *argv, VALUE self) { FXComp 
     | 
|
| 
       1106 
1106 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       1107 
1107 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       1108 
1108 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       1109 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 1109 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 1110 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1110 
1111 
     | 
    
         
             
                    result = (FXArrowButton *)new_FXArrowButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       1111 
1112 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1112 
1113 
     | 
    
         
             
            static VALUE _wrap_FXArrowButton_setState(int argc, VALUE *argv, VALUE self) { FXArrowButton *arg1 = (FXArrowButton *) 0 ;
         
     | 
| 
         @@ -1435,7 +1436,8 @@ static VALUE _wrap_new_FXColorBar(int argc, VALUE *argv, VALUE self) { FXComposi 
     | 
|
| 
       1435 
1436 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       1436 
1437 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       1437 
1438 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       1438 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 1439 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 1440 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1439 
1441 
     | 
    
         
             
                    result = (FXColorBar *)new_FXColorBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       1440 
1442 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1441 
1443 
     | 
    
         
             
            static VALUE _wrap_FXColorBar_setHue(int argc, VALUE *argv, VALUE self) { FXColorBar *arg1 = (FXColorBar *) 0 ; FXfloat arg2 ;
         
     | 
| 
         @@ -1754,7 +1756,8 @@ static VALUE _wrap_new_FXColorRing(int argc, VALUE *argv, VALUE self) { FXCompos 
     | 
|
| 
       1754 
1756 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       1755 
1757 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       1756 
1758 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       1757 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 1759 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 1760 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1758 
1761 
     | 
    
         
             
                    result = (FXColorRing *)new_FXColorRing(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       1759 
1762 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1760 
1763 
     | 
    
         
             
            static VALUE _wrap_FXColorRing_huee___(int argc, VALUE *argv, VALUE self) { FXColorRing *arg1 = (FXColorRing *) 0 ;
         
     | 
| 
         @@ -2057,7 +2060,8 @@ static VALUE _wrap_new_FXColorWell(int argc, VALUE *argv, VALUE self) { FXCompos 
     | 
|
| 
       2057 
2060 
     | 
    
         
             
                    arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2UINT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); } 
         
     | 
| 
       2058 
2061 
     | 
    
         
             
                if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) {
         
     | 
| 
       2059 
2062 
     | 
    
         
             
                    arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) { arg11 = NUM2INT(argv[10]); } 
         
     | 
| 
       2060 
     | 
    
         
            -
                if (argc > 11) { arg12 = NUM2INT(argv[11]); }  if (argc > 12) { arg13 = NUM2INT(argv[12]); }  {
         
     | 
| 
      
 2063 
     | 
    
         
            +
                if (argc > 11) { arg12 = NUM2INT(argv[11]); }  if (argc > 12) { arg13 = NUM2INT(argv[12]); }  { if (!arg1) {
         
     | 
| 
      
 2064 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2061 
2065 
     | 
    
         
             
                    result = (FXColorWell *)new_FXColorWell(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
         
     | 
| 
       2062 
2066 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2063 
2067 
     | 
    
         
             
            static VALUE _wrap_FXColorWell_setRGBA(int argc, VALUE *argv, VALUE self) { FXColorWell *arg1 = (FXColorWell *) 0 ;
         
     | 
| 
         @@ -2364,7 +2368,8 @@ static VALUE _wrap_new_FXColorWheel(int argc, VALUE *argv, VALUE self) { FXCompo 
     | 
|
| 
       2364 
2368 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       2365 
2369 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       2366 
2370 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       2367 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 2371 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 2372 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2368 
2373 
     | 
    
         
             
                    result = (FXColorWheel *)new_FXColorWheel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       2369 
2374 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2370 
2375 
     | 
    
         
             
            static VALUE _wrap_FXColorWheel_setHue(int argc, VALUE *argv, VALUE self) { FXColorWheel *arg1 = (FXColorWheel *) 0 ;
         
     | 
| 
         @@ -2765,7 +2770,8 @@ static VALUE _wrap_new_FXDial(int argc, VALUE *argv, VALUE self) { FXComposite * 
     | 
|
| 
       2765 
2770 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       2766 
2771 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       2767 
2772 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       2768 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 2773 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 2774 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2769 
2775 
     | 
    
         
             
                    result = (FXDial *)new_FXDial(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       2770 
2776 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2771 
2777 
     | 
    
         
             
            static VALUE _wrap_FXDial_setValue(int argc, VALUE *argv, VALUE self) { FXDial *arg1 = (FXDial *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -3211,7 +3217,8 @@ static VALUE _wrap_new_FXHeader(int argc, VALUE *argv, VALUE self) { FXComposite 
     | 
|
| 
       3211 
3217 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       3212 
3218 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       3213 
3219 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       3214 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 3220 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 3221 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       3215 
3222 
     | 
    
         
             
                    result = (FXHeader *)new_FXHeader(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       3216 
3223 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       3217 
3224 
     | 
    
         
             
            static VALUE _wrap_FXHeader_getNumItems(int argc, VALUE *argv, VALUE self) { FXHeader *arg1 = (FXHeader *) 0 ; FXint result;
         
     | 
| 
         @@ -3761,7 +3768,7 @@ static VALUE _wrap_new_FXImageFrame(int argc, VALUE *argv, VALUE self) { FXCompo 
     | 
|
| 
       3761 
3768 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       3762 
3769 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       3763 
3770 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       3764 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  {
         
     | 
| 
      
 3771 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       3765 
3772 
     | 
    
         
             
                    result = (FXImageFrame *)new_FXImageFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
         
     | 
| 
       3766 
3773 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       3767 
3774 
     | 
    
         
             
            static VALUE _wrap_FXImageFrame_setImage(int argc, VALUE *argv, VALUE self) { FXImageFrame *arg1 = (FXImageFrame *) 0 ;
         
     | 
| 
         @@ -3984,7 +3991,7 @@ static VALUE _wrap_new_FXBitmapFrame(int argc, VALUE *argv, VALUE self) { FXComp 
     | 
|
| 
       3984 
3991 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       3985 
3992 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       3986 
3993 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       3987 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  {
         
     | 
| 
      
 3994 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       3988 
3995 
     | 
    
         
             
                    result = (FXBitmapFrame *)new_FXBitmapFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
         
     | 
| 
       3989 
3996 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       3990 
3997 
     | 
    
         
             
            static VALUE _wrap_FXBitmapFrame_setBitmap(int argc, VALUE *argv, VALUE self) { FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
         
     | 
| 
         @@ -4403,7 +4410,8 @@ static VALUE _wrap_new_FXKnob(int argc, VALUE *argv, VALUE self) { FXComposite * 
     | 
|
| 
       4403 
4410 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       4404 
4411 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       4405 
4412 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       4406 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 4413 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 4414 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       4407 
4415 
     | 
    
         
             
                    result = (FXKnob *)new_FXKnob(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       4408 
4416 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       4409 
4417 
     | 
    
         
             
            static VALUE _wrap_FXKnob_valuee___(int argc, VALUE *argv, VALUE self) { FXKnob *arg1 = (FXKnob *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -4686,7 +4694,8 @@ static VALUE _wrap_new_FXProgressBar(int argc, VALUE *argv, VALUE self) { FXComp 
     | 
|
| 
       4686 
4694 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       4687 
4695 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       4688 
4696 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       4689 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 4697 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 4698 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       4690 
4699 
     | 
    
         
             
                    result = (FXProgressBar *)new_FXProgressBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       4691 
4700 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       4692 
4701 
     | 
    
         
             
            static VALUE _wrap_FXProgressBar_setProgress(int argc, VALUE *argv, VALUE self) { FXProgressBar *arg1 = (FXProgressBar *) 0 ;
         
     | 
| 
         @@ -5063,7 +5072,8 @@ static VALUE _wrap_new_FXRuler(int argc, VALUE *argv, VALUE self) { FXComposite 
     | 
|
| 
       5063 
5072 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       5064 
5073 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       5065 
5074 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       5066 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 5075 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 5076 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5067 
5077 
     | 
    
         
             
                    result = (FXRuler *)new_FXRuler(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       5068 
5078 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5069 
5079 
     | 
    
         
             
            static VALUE _wrap_FXRuler_setPosition(int argc, VALUE *argv, VALUE self) { FXRuler *arg1 = (FXRuler *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -5440,7 +5450,7 @@ static VALUE _wrap_new_FXSeparator(int argc, VALUE *argv, VALUE self) { FXCompos 
     | 
|
| 
       5440 
5450 
     | 
    
         
             
                if (argc > 2) { arg3 = NUM2INT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       5441 
5451 
     | 
    
         
             
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); } 
         
     | 
| 
       5442 
5452 
     | 
    
         
             
                if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) {
         
     | 
| 
       5443 
     | 
    
         
            -
                    arg10 = NUM2INT(argv[9]); }  {
         
     | 
| 
      
 5453 
     | 
    
         
            +
                    arg10 = NUM2INT(argv[9]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5444 
5454 
     | 
    
         
             
                    result = (FXSeparator *)new_FXSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
         
     | 
| 
       5445 
5455 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5446 
5456 
     | 
    
         
             
            static VALUE _wrap_FXSeparator_setSeparatorStyle(int argc, VALUE *argv, VALUE self) { FXSeparator *arg1 = (FXSeparator *) 0 ;
         
     | 
| 
         @@ -5645,7 +5655,7 @@ static VALUE _wrap_new_FXHorizontalSeparator(int argc, VALUE *argv, VALUE self) 
     | 
|
| 
       5645 
5655 
     | 
    
         
             
                if (argc > 2) { arg3 = NUM2INT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       5646 
5656 
     | 
    
         
             
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); } 
         
     | 
| 
       5647 
5657 
     | 
    
         
             
                if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) {
         
     | 
| 
       5648 
     | 
    
         
            -
                    arg10 = NUM2INT(argv[9]); }  {
         
     | 
| 
      
 5658 
     | 
    
         
            +
                    arg10 = NUM2INT(argv[9]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5649 
5659 
     | 
    
         
             
                    result = (FXHorizontalSeparator *)new_FXHorizontalSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
         
     | 
| 
       5650 
5660 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5651 
5661 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -5886,7 +5896,7 @@ static VALUE _wrap_new_FXVerticalSeparator(int argc, VALUE *argv, VALUE self) { 
     | 
|
| 
       5886 
5896 
     | 
    
         
             
                if (argc > 2) { arg3 = NUM2INT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       5887 
5897 
     | 
    
         
             
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); } 
         
     | 
| 
       5888 
5898 
     | 
    
         
             
                if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) {
         
     | 
| 
       5889 
     | 
    
         
            -
                    arg10 = NUM2INT(argv[9]); }  {
         
     | 
| 
      
 5899 
     | 
    
         
            +
                    arg10 = NUM2INT(argv[9]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5890 
5900 
     | 
    
         
             
                    result = (FXVerticalSeparator *)new_FXVerticalSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
         
     | 
| 
       5891 
5901 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5892 
5902 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -6283,7 +6293,8 @@ static VALUE _wrap_new_FXSlider(int argc, VALUE *argv, VALUE self) { FXComposite 
     | 
|
| 
       6283 
6293 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       6284 
6294 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       6285 
6295 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       6286 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 6296 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 6297 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       6287 
6298 
     | 
    
         
             
                    result = (FXSlider *)new_FXSlider(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       6288 
6299 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       6289 
6300 
     | 
    
         
             
            static VALUE _wrap_FXSlider_setValue(int argc, VALUE *argv, VALUE self) { FXSlider *arg1 = (FXSlider *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -6726,7 +6737,8 @@ static VALUE _wrap_new_FXRealSlider(int argc, VALUE *argv, VALUE self) { FXCompo 
     | 
|
| 
       6726 
6737 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       6727 
6738 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       6728 
6739 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       6729 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 6740 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 6741 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       6730 
6742 
     | 
    
         
             
                    result = (FXRealSlider *)new_FXRealSlider(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       6731 
6743 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       6732 
6744 
     | 
    
         
             
            static VALUE _wrap_FXRealSlider_setValue(int argc, VALUE *argv, VALUE self) { FXRealSlider *arg1 = (FXRealSlider *) 0 ;
         
     | 
| 
         @@ -7042,6 +7054,7 @@ static VALUE _wrap_new_FXStatusLine(int argc, VALUE *argv, VALUE self) { FXCompo 
     | 
|
| 
       7042 
7054 
     | 
    
         
             
                rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
         
     | 
| 
       7043 
7055 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXComposite, 1); if (argc > 1) {
         
     | 
| 
       7044 
7056 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXObject, 1); }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  {
         
     | 
| 
      
 7057 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       7045 
7058 
     | 
    
         
             
                    result = (FXStatusLine *)new_FXStatusLine(arg1,arg2,arg3); DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
         
     | 
| 
       7046 
7059 
     | 
    
         
             
                    if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       7047 
7060 
     | 
    
         
             
            static VALUE _wrap_FXStatusLine_setText(int argc, VALUE *argv, VALUE self) { FXStatusLine *arg1 = (FXStatusLine *) 0 ;
         
     | 
| 
         @@ -7675,7 +7688,8 @@ static VALUE _wrap_new_FXTextField(int argc, VALUE *argv, VALUE self) { FXCompos 
     | 
|
| 
       7675 
7688 
     | 
    
         
             
                if (argc > 4) { arg5 = NUM2UINT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) {
         
     | 
| 
       7676 
7689 
     | 
    
         
             
                    arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); } 
         
     | 
| 
       7677 
7690 
     | 
    
         
             
                if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) { arg11 = NUM2INT(argv[10]); }  if (argc > 11) {
         
     | 
| 
       7678 
     | 
    
         
            -
                    arg12 = NUM2INT(argv[11]); }  if (argc > 12) { arg13 = NUM2INT(argv[12]); }  {
         
     | 
| 
      
 7691 
     | 
    
         
            +
                    arg12 = NUM2INT(argv[11]); }  if (argc > 12) { arg13 = NUM2INT(argv[12]); }  { if (!arg1) {
         
     | 
| 
      
 7692 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       7679 
7693 
     | 
    
         
             
                    result = (FXTextField *)new_FXTextField(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
         
     | 
| 
       7680 
7694 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       7681 
7695 
     | 
    
         
             
            static VALUE _wrap_FXTextField_setEditable(int argc, VALUE *argv, VALUE self) { FXTextField *arg1 = (FXTextField *) 0 ;
         
     | 
| 
         @@ -8153,6 +8167,7 @@ static VALUE _wrap_new_FXToolBarTab(int argc, VALUE *argv, VALUE self) { FXCompo 
     | 
|
| 
       8153 
8167 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXObject, 1); }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); } 
         
     | 
| 
       8154 
8168 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       8155 
8169 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  {
         
     | 
| 
      
 8170 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       8156 
8171 
     | 
    
         
             
                    result = (FXToolBarTab *)new_FXToolBarTab(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
         
     | 
| 
       8157 
8172 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       8158 
8173 
     | 
    
         
             
            static VALUE _wrap_FXToolBarTab_collapse(int argc, VALUE *argv, VALUE self) { FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
         
     | 
| 
         @@ -8602,7 +8617,8 @@ static VALUE _wrap_new_FXGradientBar(int argc, VALUE *argv, VALUE self) { FXComp 
     | 
|
| 
       8602 
8617 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       8603 
8618 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); } 
         
     | 
| 
       8604 
8619 
     | 
    
         
             
                if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  if (argc > 10) {
         
     | 
| 
       8605 
     | 
    
         
            -
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  {
         
     | 
| 
      
 8620 
     | 
    
         
            +
                    arg11 = NUM2INT(argv[10]); }  if (argc > 11) { arg12 = NUM2INT(argv[11]); }  { if (!arg1) {
         
     | 
| 
      
 8621 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       8606 
8622 
     | 
    
         
             
                    result = (FXGradientBar *)new_FXGradientBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
         
     | 
| 
       8607 
8623 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       8608 
8624 
     | 
    
         
             
            static VALUE _wrap_FXGradientBar_getSegment(int argc, VALUE *argv, VALUE self) { FXGradientBar *arg1 = (FXGradientBar *) 0 ;
         
     | 
    
        data/ext/fox16/fx3d_wrap.cpp
    CHANGED
    
    | 
         @@ -5650,12 +5650,14 @@ static VALUE _wrap_FXGLVisual_allocate(VALUE self) { 
     | 
|
| 
       5650 
5650 
     | 
    
         
             
                     return vresult; }
         
     | 
| 
       5651 
5651 
     | 
    
         
             
            static VALUE _wrap_new_FXGLVisual(int argc, VALUE *argv, VALUE self) { FXApp *arg1 = (FXApp *) 0 ; FXuint arg2 ;
         
     | 
| 
       5652 
5652 
     | 
    
         
             
                FXGLVisual *result; if ((argc < 2) || (argc > 2)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
         
     | 
| 
       5653 
     | 
    
         
            -
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); arg2 = NUM2UINT(argv[1]); {
         
     | 
| 
      
 5653 
     | 
    
         
            +
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); arg2 = NUM2UINT(argv[1]); { if (!arg1) {
         
     | 
| 
      
 5654 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5654 
5655 
     | 
    
         
             
                    result = (FXGLVisual *)new_FXGLVisual(arg1,arg2); DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
         
     | 
| 
       5655 
5656 
     | 
    
         
             
                    if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5656 
5657 
     | 
    
         
             
            static VALUE _wrap_FXGLVisual_supported(int argc, VALUE *argv, VALUE self) { FXApp *arg1 = (FXApp *) 0 ; FXbool result;
         
     | 
| 
       5657 
5658 
     | 
    
         
             
                VALUE vresult = Qnil; if ((argc < 1) || (argc > 1)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
         
     | 
| 
       5658 
     | 
    
         
            -
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1);  
     | 
| 
      
 5659 
     | 
    
         
            +
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); { if (!arg1) {
         
     | 
| 
      
 5660 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  result = (FXbool)FXGLVisual_supported(arg1);
         
     | 
| 
       5659 
5661 
     | 
    
         
             
                vresult = result ? Qtrue : Qfalse; return vresult; }
         
     | 
| 
       5660 
5662 
     | 
    
         
             
            static VALUE _wrap_FXGLVisual_getRedSize(int argc, VALUE *argv, VALUE self) { FXGLVisual *arg1 = (FXGLVisual *) 0 ;
         
     | 
| 
       5661 
5663 
     | 
    
         
             
                FXint result; VALUE vresult = Qnil; if ((argc < 0) || (argc > 0))
         
     | 
| 
         @@ -5847,7 +5849,8 @@ static VALUE _wrap_new_FXGLContext__SWIG_0(int argc, VALUE *argv, VALUE self) { 
     | 
|
| 
       5847 
5849 
     | 
    
         
             
                FXGLVisual *arg2 = (FXGLVisual *) 0 ; FXGLContext *result; if ((argc < 2) || (argc > 2))
         
     | 
| 
       5848 
5850 
     | 
    
         
             
                rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
         
     | 
| 
       5849 
5851 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1);
         
     | 
| 
       5850 
     | 
    
         
            -
                SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXGLVisual, 1); {
         
     | 
| 
      
 5852 
     | 
    
         
            +
                SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXGLVisual, 1); { if (!arg1) {
         
     | 
| 
      
 5853 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5851 
5854 
     | 
    
         
             
                    result = (FXGLContext *)new_FXGLContext__SWIG_0(arg1,arg2); DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
         
     | 
| 
       5852 
5855 
     | 
    
         
             
                    if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5853 
5856 
     | 
    
         
             
            #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
         
     | 
| 
         @@ -5865,7 +5868,8 @@ static VALUE _wrap_new_FXGLContext__SWIG_1(int argc, VALUE *argv, VALUE self) { 
     | 
|
| 
       5865 
5868 
     | 
    
         
             
                if ((argc < 3) || (argc > 3)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
         
     | 
| 
       5866 
5869 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1);
         
     | 
| 
       5867 
5870 
     | 
    
         
             
                SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXGLVisual, 1);
         
     | 
| 
       5868 
     | 
    
         
            -
                SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXGLContext, 1); {
         
     | 
| 
      
 5871 
     | 
    
         
            +
                SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXGLContext, 1); { if (!arg1) {
         
     | 
| 
      
 5872 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5869 
5873 
     | 
    
         
             
                    result = (FXGLContext *)new_FXGLContext__SWIG_1(arg1,arg2,arg3);
         
     | 
| 
       5870 
5874 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5871 
5875 
     | 
    
         
             
            static VALUE _wrap_new_FXGLContext(int nargs, VALUE *args, VALUE self) { int argc; VALUE argv[3]; int ii; argc = nargs;
         
     | 
| 
         @@ -5944,6 +5948,7 @@ static VALUE _wrap_new_FXGLCanvas__SWIG_0(int argc, VALUE *argv, VALUE self) { F 
     | 
|
| 
       5944 
5948 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXObject, 1); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); } 
         
     | 
| 
       5945 
5949 
     | 
    
         
             
                if (argc > 4) { arg5 = NUM2UINT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) {
         
     | 
| 
       5946 
5950 
     | 
    
         
             
                    arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  {
         
     | 
| 
      
 5951 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5947 
5952 
     | 
    
         
             
                    result = (FXGLCanvas *)new_FXGLCanvas__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
         
     | 
| 
       5948 
5953 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5949 
5954 
     | 
    
         
             
            #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
         
     | 
| 
         @@ -5967,6 +5972,7 @@ static VALUE _wrap_new_FXGLCanvas__SWIG_1(int argc, VALUE *argv, VALUE self) { F 
     | 
|
| 
       5967 
5972 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_FXObject, 1); }  if (argc > 4) { arg5 = NUM2UINT(argv[4]); } 
         
     | 
| 
       5968 
5973 
     | 
    
         
             
                if (argc > 5) { arg6 = NUM2UINT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) {
         
     | 
| 
       5969 
5974 
     | 
    
         
             
                    arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  {
         
     | 
| 
      
 5975 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       5970 
5976 
     | 
    
         
             
                    result = (FXGLCanvas *)new_FXGLCanvas__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
         
     | 
| 
       5971 
5977 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       5972 
5978 
     | 
    
         
             
            static VALUE _wrap_new_FXGLCanvas(int nargs, VALUE *args, VALUE self) { int argc; VALUE argv[10]; int ii; argc = nargs;
         
     | 
| 
         @@ -7079,6 +7085,7 @@ static VALUE _wrap_new_FXGLViewer__SWIG_0(int argc, VALUE *argv, VALUE self) { F 
     | 
|
| 
       7079 
7085 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXObject, 1); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); } 
         
     | 
| 
       7080 
7086 
     | 
    
         
             
                if (argc > 4) { arg5 = NUM2UINT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) {
         
     | 
| 
       7081 
7087 
     | 
    
         
             
                    arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  {
         
     | 
| 
      
 7088 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       7082 
7089 
     | 
    
         
             
                    result = (FXGLViewer *)new_FXGLViewer__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
         
     | 
| 
       7083 
7090 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       7084 
7091 
     | 
    
         
             
            #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
         
     | 
| 
         @@ -7102,6 +7109,7 @@ static VALUE _wrap_new_FXGLViewer__SWIG_1(int argc, VALUE *argv, VALUE self) { F 
     | 
|
| 
       7102 
7109 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[3], (void **) &arg4, SWIGTYPE_p_FXObject, 1); }  if (argc > 4) { arg5 = NUM2UINT(argv[4]); } 
         
     | 
| 
       7103 
7110 
     | 
    
         
             
                if (argc > 5) { arg6 = NUM2UINT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) {
         
     | 
| 
       7104 
7111 
     | 
    
         
             
                    arg8 = NUM2INT(argv[7]); }  if (argc > 8) { arg9 = NUM2INT(argv[8]); }  if (argc > 9) { arg10 = NUM2INT(argv[9]); }  {
         
     | 
| 
      
 7112 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       7105 
7113 
     | 
    
         
             
                    result = (FXGLViewer *)new_FXGLViewer__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
         
     | 
| 
       7106 
7114 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       7107 
7115 
     | 
    
         
             
            static VALUE _wrap_new_FXGLViewer(int nargs, VALUE *args, VALUE self) { int argc; VALUE argv[10]; int ii; argc = nargs;
         
     | 
    
        data/ext/fox16/iconlist_wrap.cpp
    CHANGED
    
    | 
         @@ -1273,6 +1273,7 @@ static VALUE _wrap_new_FXIconList(int argc, VALUE *argv, VALUE self) { FXComposi 
     | 
|
| 
       1273 
1273 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXObject, 1); }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); } 
         
     | 
| 
       1274 
1274 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       1275 
1275 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  {
         
     | 
| 
      
 1276 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1276 
1277 
     | 
    
         
             
                    result = (FXIconList *)new_FXIconList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
         
     | 
| 
       1277 
1278 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1278 
1279 
     | 
    
         
             
            static VALUE _wrap_FXIconList_getNumItems(int argc, VALUE *argv, VALUE self) { FXIconList *arg1 = (FXIconList *) 0 ;
         
     | 
| 
         @@ -2641,6 +2642,7 @@ static VALUE _wrap_new_FXFileList(int argc, VALUE *argv, VALUE self) { FXComposi 
     | 
|
| 
       2641 
2642 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXObject, 1); }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); } 
         
     | 
| 
       2642 
2643 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       2643 
2644 
     | 
    
         
             
                    arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  if (argc > 7) { arg8 = NUM2INT(argv[7]); }  {
         
     | 
| 
      
 2645 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2644 
2646 
     | 
    
         
             
                    result = (FXFileList *)new_FXFileList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
         
     | 
| 
       2645 
2647 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2646 
2648 
     | 
    
         
             
            static VALUE _wrap_FXFileList_scan(int argc, VALUE *argv, VALUE self) { FXFileList *arg1 = (FXFileList *) 0 ;
         
     | 
    
        data/ext/fox16/icons_wrap.cpp
    CHANGED
    
    | 
         @@ -1142,7 +1142,8 @@ static VALUE _wrap_new_FXIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg1 = 
     | 
|
| 
       1142 
1142 
     | 
    
         
             
                            Check_Type(argv[1],T_ARRAY); if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
         
     | 
| 
       1143 
1143 
     | 
    
         
             
                                for(long i=0; i<RARRAY_LEN(argv[1]); i++){ arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i))); }
         
     | 
| 
       1144 
1144 
     | 
    
         
             
                                 }  }  }  }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); } 
         
     | 
| 
       1145 
     | 
    
         
            -
                if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1145 
     | 
    
         
            +
                if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1146 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1146 
1147 
     | 
    
         
             
                    result = (FXIcon *)new_FXIcon(arg1,(FXColor const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1147 
1148 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  FXFREE(&arg2);
         
     | 
| 
       1148 
1149 
     | 
    
         
             
                return self; }
         
     | 
| 
         @@ -1262,7 +1263,8 @@ static VALUE _wrap_FXIconSource_allocate(VALUE self) { 
     | 
|
| 
       1262 
1263 
     | 
    
         
             
                     return vresult; }
         
     | 
| 
       1263 
1264 
     | 
    
         
             
            static VALUE _wrap_new_FXIconSource(int argc, VALUE *argv, VALUE self) { FXApp *arg1 = (FXApp *) 0 ; FXIconSource *result;
         
     | 
| 
       1264 
1265 
     | 
    
         
             
                if ((argc < 1) || (argc > 1)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
         
     | 
| 
       1265 
     | 
    
         
            -
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); {  
     | 
| 
      
 1266 
     | 
    
         
            +
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); { if (!arg1) {
         
     | 
| 
      
 1267 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  { result = (FXIconSource *)new_FXIconSource(arg1);
         
     | 
| 
       1266 
1268 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1267 
1269 
     | 
    
         
             
            static void
         
     | 
| 
       1268 
1270 
     | 
    
         
             
            free_FXIconSource(FXIconSource *arg1) {
         
     | 
| 
         @@ -1424,7 +1426,8 @@ static VALUE _wrap_new_FXBMPIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       1424 
1426 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1425 
1427 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1426 
1428 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1427 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1429 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1430 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1428 
1431 
     | 
    
         
             
                    result = (FXBMPIcon *)new_FXBMPIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1429 
1432 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1430 
1433 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -1566,7 +1569,8 @@ static VALUE _wrap_new_FXGIFIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       1566 
1569 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1567 
1570 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1568 
1571 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1569 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1572 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1573 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1570 
1574 
     | 
    
         
             
                    result = (FXGIFIcon *)new_FXGIFIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1571 
1575 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1572 
1576 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -1691,7 +1695,8 @@ static VALUE _wrap_new_FXICOIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       1691 
1695 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1692 
1696 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1693 
1697 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1694 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1698 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1699 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1695 
1700 
     | 
    
         
             
                    result = (FXICOIcon *)new_FXICOIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1696 
1701 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1697 
1702 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -1838,6 +1843,7 @@ static VALUE _wrap_new_FXJPGIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       1838 
1843 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1839 
1844 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1840 
1845 
     | 
    
         
             
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) { arg7 = NUM2INT(argv[6]); }  {
         
     | 
| 
      
 1846 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1841 
1847 
     | 
    
         
             
                    result = (FXJPGIcon *)new_FXJPGIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7);
         
     | 
| 
       1842 
1848 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1843 
1849 
     | 
    
         
             
            static VALUE _wrap_FXJPGIcon_setQuality(int argc, VALUE *argv, VALUE self) { FXJPGIcon *arg1 = (FXJPGIcon *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -1987,7 +1993,8 @@ static VALUE _wrap_new_FXPCXIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       1987 
1993 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1988 
1994 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1989 
1995 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1990 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1996 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1997 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1991 
1998 
     | 
    
         
             
                    result = (FXPCXIcon *)new_FXPCXIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1992 
1999 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1993 
2000 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2132,7 +2139,8 @@ static VALUE _wrap_new_FXPNGIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2132 
2139 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2133 
2140 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2134 
2141 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2135 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2142 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2143 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2136 
2144 
     | 
    
         
             
                    result = (FXPNGIcon *)new_FXPNGIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2137 
2145 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2138 
2146 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2274,7 +2282,8 @@ static VALUE _wrap_new_FXPPMIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2274 
2282 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2275 
2283 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2276 
2284 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2277 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2285 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2286 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2278 
2287 
     | 
    
         
             
                    result = (FXPPMIcon *)new_FXPPMIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2279 
2288 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2280 
2289 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2416,7 +2425,8 @@ static VALUE _wrap_new_FXRGBIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2416 
2425 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2417 
2426 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2418 
2427 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2419 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2428 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2429 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2420 
2430 
     | 
    
         
             
                    result = (FXRGBIcon *)new_FXRGBIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2421 
2431 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2422 
2432 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2558,7 +2568,8 @@ static VALUE _wrap_new_FXTGAIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2558 
2568 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2559 
2569 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2560 
2570 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2561 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2571 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2572 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2562 
2573 
     | 
    
         
             
                    result = (FXTGAIcon *)new_FXTGAIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2563 
2574 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2564 
2575 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2703,7 +2714,8 @@ static VALUE _wrap_new_FXTIFIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2703 
2714 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2704 
2715 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2705 
2716 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = to_FXColor(argv[2]); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2706 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2717 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2718 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2707 
2719 
     | 
    
         
             
                    result = (FXTIFIcon *)new_FXTIFIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2708 
2720 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2709 
2721 
     | 
    
         
             
            static VALUE _wrap_FXTIFIcon_setCodec(int argc, VALUE *argv, VALUE self) { FXTIFIcon *arg1 = (FXTIFIcon *) 0 ; FXuint arg2 ;
         
     | 
| 
         @@ -2842,7 +2854,7 @@ static VALUE _wrap_new_FXXBMIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2842 
2854 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXuchar, 1); }  if (argc > 2) {
         
     | 
| 
       2843 
2855 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXuchar, 1); }  if (argc > 3) { arg4 = to_FXColor(argv[3]); } 
         
     | 
| 
       2844 
2856 
     | 
    
         
             
                if (argc > 4) { arg5 = NUM2UINT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  if (argc > 6) {
         
     | 
| 
       2845 
     | 
    
         
            -
                    arg7 = NUM2INT(argv[6]); }  {
         
     | 
| 
      
 2857 
     | 
    
         
            +
                    arg7 = NUM2INT(argv[6]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2846 
2858 
     | 
    
         
             
                    result = (FXXBMIcon *)new_FXXBMIcon(arg1,(FXuchar const *)arg2,(FXuchar const *)arg3,arg4,arg5,arg6,arg7);
         
     | 
| 
       2847 
2859 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2848 
2860 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2970,7 +2982,8 @@ static VALUE _wrap_new_FXXPMIcon(int argc, VALUE *argv, VALUE self) { FXApp *arg 
     | 
|
| 
       2970 
2982 
     | 
    
         
             
                                for (long i = 0; i < RARRAY_LEN(argv[1]); i++) { VALUE e = rb_ary_entry(argv[1], i);
         
     | 
| 
       2971 
2983 
     | 
    
         
             
                                    arg2[i] = (FXchar *) StringValuePtr(e); }  }  }  }  }  if (argc > 2) { arg3 = to_FXColor(argv[2]); } 
         
     | 
| 
       2972 
2984 
     | 
    
         
             
                if (argc > 3) { arg4 = NUM2UINT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) {
         
     | 
| 
       2973 
     | 
    
         
            -
                    arg6 = NUM2INT(argv[5]); }  {  
     | 
| 
      
 2985 
     | 
    
         
            +
                    arg6 = NUM2INT(argv[5]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2986 
     | 
    
         
            +
                    result = (FXXPMIcon *)new_FXXPMIcon(arg1,(FXchar const **)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       2974 
2987 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  FXFREE(&arg2);
         
     | 
| 
       2975 
2988 
     | 
    
         
             
                return self; }
         
     | 
| 
       2976 
2989 
     | 
    
         
             
            static void
         
     | 
    
        data/ext/fox16/image_wrap.cpp
    CHANGED
    
    | 
         @@ -1045,7 +1045,8 @@ static VALUE _wrap_new_FXBitmap(int argc, VALUE *argv, VALUE self) { FXApp *arg1 
     | 
|
| 
       1045 
1045 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1046 
1046 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1047 
1047 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1048 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 1048 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 1049 
     | 
    
         
            +
                    result = (FXBitmap *)new_FXBitmap(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       1049 
1050 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1050 
1051 
     | 
    
         
             
            static VALUE _wrap_FXBitmap_getData(int argc, VALUE *argv, VALUE self) { FXBitmap *arg1 = (FXBitmap *) 0 ; FXuchar *result;
         
     | 
| 
       1051 
1052 
     | 
    
         
             
                VALUE vresult = Qnil; if ((argc < 0) || (argc > 0)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
         
     | 
| 
         @@ -1223,6 +1224,7 @@ static VALUE _wrap_new_FXImage(int argc, VALUE *argv, VALUE self) { FXApp *arg1 
     | 
|
| 
       1223 
1224 
     | 
    
         
             
                rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
         
     | 
| 
       1224 
1225 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { arg2 = argv[1]; }  if (argc > 2) {
         
     | 
| 
       1225 
1226 
     | 
    
         
             
                    arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  {
         
     | 
| 
      
 1227 
     | 
    
         
            +
                    if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1226 
1228 
     | 
    
         
             
                    result = (FXImage *)new_FXImage(arg1,arg2,arg3,arg4,arg5); DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
         
     | 
| 
       1227 
1229 
     | 
    
         
             
                    if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1228 
1230 
     | 
    
         
             
            static VALUE _wrap_FXImage_getData(int argc, VALUE *argv, VALUE self) { FXImage *arg1 = (FXImage *) 0 ; FXMemoryBuffer *result;
         
     | 
| 
         @@ -1386,7 +1388,8 @@ static VALUE _wrap_new_FXBMPImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       1386 
1388 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1387 
1389 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1388 
1390 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1389 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 1391 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 1392 
     | 
    
         
            +
                    result = (FXBMPImage *)new_FXBMPImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       1390 
1393 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1391 
1394 
     | 
    
         
             
            static void
         
     | 
| 
       1392 
1395 
     | 
    
         
             
            free_FXBMPImage(FXBMPImage *arg1) {
         
     | 
| 
         @@ -1510,7 +1513,8 @@ static VALUE _wrap_new_FXGIFImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       1510 
1513 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1511 
1514 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1512 
1515 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1513 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 1516 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 1517 
     | 
    
         
            +
                    result = (FXGIFImage *)new_FXGIFImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       1514 
1518 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1515 
1519 
     | 
    
         
             
            static void
         
     | 
| 
       1516 
1520 
     | 
    
         
             
            free_FXGIFImage(FXGIFImage *arg1) {
         
     | 
| 
         @@ -1634,7 +1638,8 @@ static VALUE _wrap_new_FXICOImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       1634 
1638 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1635 
1639 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1636 
1640 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1637 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 1641 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 1642 
     | 
    
         
            +
                    result = (FXICOImage *)new_FXICOImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       1638 
1643 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1639 
1644 
     | 
    
         
             
            static void
         
     | 
| 
       1640 
1645 
     | 
    
         
             
            free_FXICOImage(FXICOImage *arg1) {
         
     | 
| 
         @@ -1761,7 +1766,8 @@ static VALUE _wrap_new_FXJPGImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       1761 
1766 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1762 
1767 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1763 
1768 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1764 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 1769 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 1770 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       1765 
1771 
     | 
    
         
             
                    result = (FXJPGImage *)new_FXJPGImage(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
         
     | 
| 
       1766 
1772 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1767 
1773 
     | 
    
         
             
            static VALUE _wrap_FXJPGImage_setQuality(int argc, VALUE *argv, VALUE self) { FXJPGImage *arg1 = (FXJPGImage *) 0 ; FXint arg2 ;
         
     | 
| 
         @@ -1895,7 +1901,8 @@ static VALUE _wrap_new_FXPCXImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       1895 
1901 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       1896 
1902 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       1897 
1903 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       1898 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 1904 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 1905 
     | 
    
         
            +
                    result = (FXPCXImage *)new_FXPCXImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       1899 
1906 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       1900 
1907 
     | 
    
         
             
            static void
         
     | 
| 
       1901 
1908 
     | 
    
         
             
            free_FXPCXImage(FXPCXImage *arg1) {
         
     | 
| 
         @@ -2022,7 +2029,8 @@ static VALUE _wrap_new_FXPNGImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2022 
2029 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2023 
2030 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2024 
2031 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2025 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 2032 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2033 
     | 
    
         
            +
                    result = (FXPNGImage *)new_FXPNGImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       2026 
2034 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2027 
2035 
     | 
    
         
             
            static void
         
     | 
| 
       2028 
2036 
     | 
    
         
             
            free_FXPNGImage(FXPNGImage *arg1) {
         
     | 
| 
         @@ -2146,7 +2154,8 @@ static VALUE _wrap_new_FXPPMImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2146 
2154 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2147 
2155 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2148 
2156 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2149 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 2157 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2158 
     | 
    
         
            +
                    result = (FXPPMImage *)new_FXPPMImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       2150 
2159 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2151 
2160 
     | 
    
         
             
            static void
         
     | 
| 
       2152 
2161 
     | 
    
         
             
            free_FXPPMImage(FXPPMImage *arg1) {
         
     | 
| 
         @@ -2270,7 +2279,8 @@ static VALUE _wrap_new_FXRGBImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2270 
2279 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2271 
2280 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2272 
2281 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2273 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 2282 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2283 
     | 
    
         
            +
                    result = (FXRGBImage *)new_FXRGBImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       2274 
2284 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2275 
2285 
     | 
    
         
             
            static void
         
     | 
| 
       2276 
2286 
     | 
    
         
             
            free_FXRGBImage(FXRGBImage *arg1) {
         
     | 
| 
         @@ -2394,7 +2404,8 @@ static VALUE _wrap_new_FXTGAImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2394 
2404 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2395 
2405 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2396 
2406 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2397 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 2407 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2408 
     | 
    
         
            +
                    result = (FXTGAImage *)new_FXTGAImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       2398 
2409 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2399 
2410 
     | 
    
         
             
            static void
         
     | 
| 
       2400 
2411 
     | 
    
         
             
            free_FXTGAImage(FXTGAImage *arg1) {
         
     | 
| 
         @@ -2521,7 +2532,8 @@ static VALUE _wrap_new_FXTIFImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2521 
2532 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) { { if (argv[1] != Qnil) {
         
     | 
| 
       2522 
2533 
     | 
    
         
             
                            Check_Type(argv[1], T_STRING); arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1])); }  else { arg2 = NULL; }  }
         
     | 
| 
       2523 
2534 
     | 
    
         
             
                     }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); }  if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) {
         
     | 
| 
       2524 
     | 
    
         
            -
                    arg5 = NUM2INT(argv[4]); }  {  
     | 
| 
      
 2535 
     | 
    
         
            +
                    arg5 = NUM2INT(argv[4]); }  { if (!arg1) { SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
      
 2536 
     | 
    
         
            +
                    result = (FXTIFImage *)new_FXTIFImage(arg1,(void const *)arg2,arg3,arg4,arg5);
         
     | 
| 
       2525 
2537 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2526 
2538 
     | 
    
         
             
            static VALUE _wrap_FXTIFImage_setCodec(int argc, VALUE *argv, VALUE self) { FXTIFImage *arg1 = (FXTIFImage *) 0 ; FXuint arg2 ;
         
     | 
| 
       2527 
2539 
     | 
    
         
             
                if ((argc < 1) || (argc > 1)) rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
         
     | 
| 
         @@ -2667,7 +2679,8 @@ static VALUE _wrap_new_FXXBMImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2667 
2679 
     | 
    
         
             
                SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FXApp, 1); if (argc > 1) {
         
     | 
| 
       2668 
2680 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_FXuchar, 1); }  if (argc > 2) {
         
     | 
| 
       2669 
2681 
     | 
    
         
             
                    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_FXuchar, 1); }  if (argc > 3) { arg4 = NUM2UINT(argv[3]); } 
         
     | 
| 
       2670 
     | 
    
         
            -
                if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  {
         
     | 
| 
      
 2682 
     | 
    
         
            +
                if (argc > 4) { arg5 = NUM2INT(argv[4]); }  if (argc > 5) { arg6 = NUM2INT(argv[5]); }  { if (!arg1) {
         
     | 
| 
      
 2683 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2671 
2684 
     | 
    
         
             
                    result = (FXXBMImage *)new_FXXBMImage(arg1,(FXuchar const *)arg2,(FXuchar const *)arg3,arg4,arg5,arg6);
         
     | 
| 
       2672 
2685 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  return self; }
         
     | 
| 
       2673 
2686 
     | 
    
         
             
            static void
         
     | 
| 
         @@ -2838,7 +2851,8 @@ static VALUE _wrap_new_FXXPMImage(int argc, VALUE *argv, VALUE self) { FXApp *ar 
     | 
|
| 
       2838 
2851 
     | 
    
         
             
                            Check_Type(argv[1], T_ARRAY); if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[1]))) {
         
     | 
| 
       2839 
2852 
     | 
    
         
             
                                for (long i = 0; i < RARRAY_LEN(argv[1]); i++) { VALUE e = rb_ary_entry(argv[1], i);
         
     | 
| 
       2840 
2853 
     | 
    
         
             
                                    arg2[i] = (FXchar *) StringValuePtr(e); }  }  }  }  }  if (argc > 2) { arg3 = NUM2UINT(argv[2]); } 
         
     | 
| 
       2841 
     | 
    
         
            -
                if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  {
         
     | 
| 
      
 2854 
     | 
    
         
            +
                if (argc > 3) { arg4 = NUM2INT(argv[3]); }  if (argc > 4) { arg5 = NUM2INT(argv[4]); }  { if (!arg1) {
         
     | 
| 
      
 2855 
     | 
    
         
            +
                        SWIG_exception(SWIG_ValueError,"Received a NULL pointer."); }  }  {
         
     | 
| 
       2842 
2856 
     | 
    
         
             
                    result = (FXXPMImage *)new_FXXPMImage(arg1,(FXchar const **)arg2,arg3,arg4,arg5);
         
     | 
| 
       2843 
2857 
     | 
    
         
             
                    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result); if(rb_block_given_p()){ rb_yield(self); }  }  FXFREE(&arg2);
         
     | 
| 
       2844 
2858 
     | 
    
         
             
                return self; }
         
     |