class Fox::FXDC

Public Class Methods

new(*args) click to toggle source
SWIGINTERN VALUE
_wrap_new_FXDC(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXDC *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDC", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  {
    if (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXDC *)new_FXDC(arg1);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

Public Instance Methods

clearClipMask(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_clearClipMask(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clearClipMask", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  FXDC_clearClipMask(arg1);
  return Qnil;
fail:
  return Qnil;
}
clearClipRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_clearClipRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clearClipRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  FXDC_clearClipRectangle(arg1);
  return Qnil;
fail:
  return Qnil;
}
clipChildren(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_clipChildren(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXbool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clipChildren", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = to_FXbool(argv[0]);
  FXDC_clipChildren(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
drawArc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawArc(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  FXDC_drawArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}
drawArcs(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawArcs(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXArc *arg2 = (FXArc *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArcs", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXArc[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXArc *pArc;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
      arg2[i] = *pArc;
    }
  }
  FXDC_drawArcs(arg1,(FXArc const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
drawArea(*args) click to toggle source
SWIGINTERN VALUE _wrap_FXDC_drawArea(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[11];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 11) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_FXDC_drawArea__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              {
                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_FXDC_drawArea__SWIG_1(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "drawArea", 
    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy)\n"
    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy, FXint dw, FXint dh)\n");
  
  return Qnil;
}
drawBitmap(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawBitmap(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXBitmap *arg2 = (FXBitmap *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawBitmap", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap const *","drawBitmap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXBitmap * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  FXDC_drawBitmap(arg1,(FXBitmap const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
drawCircle(x, y, r) click to toggle source

Draw a circle centered at (x, y), with specified radius.

Parameters:

x

x-coordinate of the circle’s center [Integer]

y

y-coordinate of the circle’s center [Integer]

r

radius of the circle, in pixels [Integer]

See also fillCircle.

# File lib/fox16/core.rb, line 608
def drawCircle(x, y, r)
  drawArc(x-r, y-r, 2*r, 2*r, 0, 360*64)
end
drawEllipse(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawEllipse(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawEllipse", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXDC_drawEllipse(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
drawFocusRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawFocusRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawFocusRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXDC_drawFocusRectangle(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
drawHashBox(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawHashBox(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 = (FXint) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawHashBox", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg6 = NUM2INT(argv[4]);
  }
  FXDC_drawHashBox(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}
drawIcon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawIcon(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXIcon *arg2 = (FXIcon *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIcon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIcon", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXIcon * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  FXDC_drawIcon(arg1,(FXIcon const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
drawIconShaded(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawIconShaded(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXIcon *arg2 = (FXIcon *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIconShaded", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconShaded", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXIcon * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  FXDC_drawIconShaded(arg1,(FXIcon const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
drawIconSunken(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawIconSunken(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXIcon *arg2 = (FXIcon *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIconSunken", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconSunken", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXIcon * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  FXDC_drawIconSunken(arg1,(FXIcon const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
drawImage(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawImage(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXImage *arg2 = (FXImage *) 0 ;
  FXint arg3 ;
  FXint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawImage", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage const *","drawImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXImage * >(argp2);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  FXDC_drawImage(arg1,(FXImage const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
drawImageText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawImageText(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXchar *arg4 = (FXchar *) 0 ;
  FXuint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawImageText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    Check_Type(argv[2], T_STRING);
    arg4 = StringValuePtr(argv[2]);
    arg5 = RSTRING_LEN(argv[2]);
  }
  FXDC_drawImageText(arg1,arg2,arg3,(char const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
drawLine(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawLine(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLine", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXDC_drawLine(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
drawLineSegments(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawLineSegments(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXSegment *arg2 = (FXSegment *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLineSegments", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXSegment[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXSegment *pSeg;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXSegment, pSeg);
      arg2[i] = *pSeg;
    }
  }
  FXDC_drawLineSegments(arg1,(FXSegment const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawLines(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawLines(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLines", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_drawLines(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawLinesRel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawLinesRel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLinesRel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_drawLinesRel(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawPoint(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawPoint(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXDC_drawPoint(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
drawPoints(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawPoints(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_drawPoints(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawPointsRel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawPointsRel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPointsRel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_drawPointsRel(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXDC_drawRectangle(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
drawRectangles(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawRectangles(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXRectangle *arg2 = (FXRectangle *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRectangles", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXRectangle *pRect;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
      arg2[i] = *pRect;
    }
  }
  FXDC_drawRectangles(arg1,(FXRectangle const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
drawRoundRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawRoundRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRoundRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  FXDC_drawRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}
drawText(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_drawText(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXchar *arg4 = (FXchar *) 0 ;
  FXuint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawText", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  {
    Check_Type(argv[2], T_STRING);
    arg4 = StringValuePtr(argv[2]);
    arg5 = RSTRING_LEN(argv[2]);
  }
  FXDC_drawText(arg1,arg2,arg3,(char const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
fillArc(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillArc(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillArc", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  FXDC_fillArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}
fillArcs(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillArcs(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXArc *arg2 = (FXArc *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillArcs", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXArc[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXArc *pArc;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
      arg2[i] = *pArc;
    }
  }
  FXDC_fillArcs(arg1,(FXArc const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
fillChord(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillChord(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillChord", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  FXDC_fillChord(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}
fillChords(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillChords(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXArc *arg2 = (FXArc *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillChords", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXArc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXArc const *","fillChords", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXArc * >(argp2);
  arg3 = NUM2UINT(argv[1]);
  FXDC_fillChords(arg1,(FXArc const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}
fillCircle(x, y, r) click to toggle source

Draw a filled circle centered at (x, y), with specified radius.

Parameters:

x

x-coordinate of the circle’s center [Integer]

y

y-coordinate of the circle’s center [Integer]

r

radius of the circle, in pixels [Integer]

See also drawCircle.

# File lib/fox16/core.rb, line 623
def fillCircle(x, y, r)
  fillArc(x-r, y-r, 2*r, 2*r, 0, 360*64)
end
fillComplexPolygon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillComplexPolygon(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillComplexPolygon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillComplexPolygon(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillComplexPolygonRel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillComplexPolygonRel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillComplexPolygonRel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillComplexPolygonRel(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillConcavePolygon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillConcavePolygon(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillConcavePolygon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillConcavePolygon(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillConcavePolygonRel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillConcavePolygonRel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillConcavePolygonRel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillConcavePolygonRel(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillPolygon(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillPolygon(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillPolygon", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillPolygon(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillPolygonRel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillPolygonRel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXPoint *arg2 = (FXPoint *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillPolygonRel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXPoint *pPoint;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
      arg2[i] = *pPoint;
    }
  }
  FXDC_fillPolygonRel(arg1,(FXPoint const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  FXDC_fillRectangle(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}
fillRectangles(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillRectangles(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXRectangle *arg2 = (FXRectangle *) 0 ;
  FXuint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRectangles", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  {
    Check_Type(argv[0], T_ARRAY);
    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
    for (FXuint i = 0; i < arg3; i++) {
      FXRectangle *pRect;
      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
      arg2[i] = *pRect;
    }
  }
  FXDC_fillRectangles(arg1,(FXRectangle const *)arg2,arg3);
  {
    delete [] arg2;
  }
  return Qnil;
fail:
  {
    delete [] arg2;
  }
  return Qnil;
}
fillRoundRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_fillRoundRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXint arg6 ;
  FXint arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRoundRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  arg6 = NUM2INT(argv[4]);
  arg7 = NUM2INT(argv[5]);
  FXDC_fillRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}
getApp(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getApp(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXApp *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getApp", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXApp *)((FXDC const *)arg1)->getApp();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getBackground(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getBackground(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getBackground", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXColor)((FXDC const *)arg1)->getBackground();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getClipHeight(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getClipHeight(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXint)((FXDC const *)arg1)->getClipHeight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getClipRectangle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getClipRectangle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXRectangle *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipRectangle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXRectangle *) &((FXDC const *)arg1)->getClipRectangle();
  vresult = FXRbGetRubyObj(result, "FXRectangle *");
  return vresult;
fail:
  return Qnil;
}
getClipWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getClipWidth(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXint)((FXDC const *)arg1)->getClipWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getClipX(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getClipX(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipX", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXint)((FXDC const *)arg1)->getClipX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getClipY(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getClipY(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipY", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXint)((FXDC const *)arg1)->getClipY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getDashOffset(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getDashOffset(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getDashOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXuint)((FXDC const *)arg1)->getDashOffset();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getDashPattern(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getDashPattern(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getDashPattern", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (VALUE)FXDC_getDashPattern((FXDC const *)arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}
getFillRule(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getFillRule(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFillRule result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFillRule", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXFillRule)((FXDC const *)arg1)->getFillRule();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFillStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getFillStyle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFillStyle result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFillStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXFillStyle)((FXDC const *)arg1)->getFillStyle();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getFont(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFont *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXFont *)((FXDC const *)arg1)->getFont();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getForeground(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getForeground(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getForeground", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXColor)((FXDC const *)arg1)->getForeground();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getFunction(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getFunction(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXFunction result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXFunction)((FXDC const *)arg1)->getFunction();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getLineCap(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getLineCap(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXCapStyle result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineCap", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXCapStyle)((FXDC const *)arg1)->getLineCap();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getLineJoin(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getLineJoin(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXJoinStyle result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineJoin", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXJoinStyle)((FXDC const *)arg1)->getLineJoin();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getLineStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getLineStyle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXLineStyle result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXLineStyle)((FXDC const *)arg1)->getLineStyle();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getLineWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getLineWidth(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXuint)((FXDC const *)arg1)->getLineWidth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
getStippleBitmap(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getStippleBitmap(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXBitmap *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getStippleBitmap", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXBitmap *)((FXDC const *)arg1)->getStippleBitmap();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXBitmap, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
getStipplePattern(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getStipplePattern(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXStipplePattern result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getStipplePattern", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXStipplePattern)((FXDC const *)arg1)->getStipplePattern();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}
getTile(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_getTile(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXImage *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getTile", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  result = (FXImage *)((FXDC const *)arg1)->getTile();
  {
    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
    vresult = FXRbGetRubyObj(result, ty);
  }
  return vresult;
fail:
  return Qnil;
}
readPixel(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_readPixel(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXColor result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","readPixel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (FXColor)FXDC_readPixel(arg1,arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}
setBackground(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setBackground(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXColor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setBackground", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = to_FXColor(argv[0]);
  FXDC_setBackground(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setClipMask(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setClipMask(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXBitmap *arg2 = (FXBitmap *) 0 ;
  FXint arg3 = (FXint) 0 ;
  FXint arg4 = (FXint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipMask", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setClipMask", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXBitmap * >(argp2);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = NUM2INT(argv[2]);
  }
  FXDC_setClipMask(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
setClipRectangle(*args) click to toggle source
SWIGINTERN VALUE _wrap_FXDC_setClipRectangle(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 6) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRectangle, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_FXDC_setClipRectangle__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
      }
      if (_v) {
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            {
              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
            }
            if (_v) {
              return _wrap_FXDC_setClipRectangle__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "setClipRectangle", 
    "    void setClipRectangle(FXint x, FXint y, FXint w, FXint h)\n"
    "    void setClipRectangle(FXRectangle const &rectangle)\n");
  
  return Qnil;
}
setClipRegion(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setClipRegion(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXRegion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipRegion", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setClipRegion", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setClipRegion", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXRegion * >(argp2);
  FXDC_setClipRegion(arg1,(FXRegion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}
setDashes(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setDashes(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXuint arg2 ;
  FXchar *arg3 = (FXchar *) 0 ;
  FXuint arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setDashes", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  {
    Check_Type(argv[1], T_ARRAY);
    arg3 = new FXchar[RARRAY_LEN(argv[1])];
    arg4 = static_cast<FXuint>( RARRAY_LEN(argv[1]) );
    for (FXuint i = 0; i < arg4; i++) {
      arg3[i] = NUM2INT(rb_ary_entry(argv[1], i));
    }
  }
  FXDC_setDashes(arg1,arg2,(char const *)arg3,arg4);
  {
    delete [] arg3;
  }
  return Qnil;
fail:
  {
    delete [] arg3;
  }
  return Qnil;
}
setFillRule(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setFillRule(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXFillRule arg2 = (FXFillRule) RULE_EVEN_ODD ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFillRule", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillRule","setFillRule", 2, argv[0] ));
    } 
    arg2 = static_cast< FXFillRule >(val2);
  }
  FXDC_setFillRule(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setFillStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setFillStyle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXFillStyle arg2 = (FXFillStyle) FILL_SOLID ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFillStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillStyle","setFillStyle", 2, argv[0] ));
    } 
    arg2 = static_cast< FXFillStyle >(val2);
  }
  FXDC_setFillStyle(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setFont(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setFont(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXFont *arg2 = (FXFont *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFont", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXFont * >(argp2);
  FXDC_setFont(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setForeground(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setForeground(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXColor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setForeground", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  arg2 = to_FXColor(argv[0]);
  FXDC_setForeground(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setFunction(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setFunction(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXFunction arg2 = (FXFunction) BLT_SRC ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFunction","setFunction", 2, argv[0] ));
    } 
    arg2 = static_cast< FXFunction >(val2);
  }
  FXDC_setFunction(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setLineCap(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setLineCap(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXCapStyle arg2 = (FXCapStyle) CAP_BUTT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineCap", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXCapStyle","setLineCap", 2, argv[0] ));
    } 
    arg2 = static_cast< FXCapStyle >(val2);
  }
  FXDC_setLineCap(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setLineJoin(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setLineJoin(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXJoinStyle arg2 = (FXJoinStyle) JOIN_MITER ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineJoin", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXJoinStyle","setLineJoin", 2, argv[0] ));
    } 
    arg2 = static_cast< FXJoinStyle >(val2);
  }
  FXDC_setLineJoin(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setLineStyle(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setLineStyle(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXLineStyle arg2 = (FXLineStyle) LINE_SOLID ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineStyle", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    ecode2 = SWIG_AsVal_int(argv[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXLineStyle","setLineStyle", 2, argv[0] ));
    } 
    arg2 = static_cast< FXLineStyle >(val2);
  }
  FXDC_setLineStyle(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setLineWidth(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setLineWidth(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXuint arg2 = (FXuint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  if (argc > 0) {
    arg2 = NUM2UINT(argv[0]);
  }
  FXDC_setLineWidth(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}
setStipple(*args) click to toggle source
SWIGINTERN VALUE _wrap_FXDC_setStipple(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
        }
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
        }
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
          }
          {
            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
          }
          if (_v) {
            return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "setStipple", 
    "    void setStipple(FXBitmap *bitmap, FXint dx, FXint dy)\n"
    "    void setStipple(FXStipplePattern pat, FXint dx, FXint dy)\n");
  
  return Qnil;
}
setTile(*args) click to toggle source
SWIGINTERN VALUE
_wrap_FXDC_setTile(int argc, VALUE *argv, VALUE self) {
  FXDC *arg1 = (FXDC *) 0 ;
  FXImage *arg2 = (FXImage *) 0 ;
  FXint arg3 = (FXint) 0 ;
  FXint arg4 = (FXint) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((argc < 1) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setTile", 1, self )); 
  }
  arg1 = reinterpret_cast< FXDC * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setTile", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< FXImage * >(argp2);
  if (argc > 1) {
    arg3 = NUM2INT(argv[1]);
  }
  if (argc > 2) {
    arg4 = NUM2INT(argv[2]);
  }
  FXDC_setTile(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}
stipple() click to toggle source
# File lib/fox16/aliases.rb, line 801
def stipple
  stippleBitmap.nil? ? stipplePattern : stippleBitmap
end