class Fox::FXDC

A device context is used to maintain the state of the graphics drawing system. Defining your drawing code in terms of the Abstract Device Context allows the drawing commands to be rendered on different types of surfaces, such as windows and images (FXDCWindow), or on paper (FXDCPrint). WYSYWYG may be obtained by using the same identical drawing code in your application regardless of the actual device surface being utilized.

Drawing (BITBLT) functions¶ ↑

BLT_CLR: D := 0
BLT_SRC_AND_DST: D := S & D
BLT_SRC_AND_NOT_DST: D := S & ~D
BLT_SRC: D := S
BLT_NOT_SRC_AND_DST: D := ~S & D
BLT_DST: D := D
BLT_SRC_XOR_DST: D := S ^ D
BLT_SRC_OR_DST: D := S | D
BLT_NOT_SRC_AND_NOT_DST: D := ~S & ~D == D := ~(S | D)
BLT_NOT_SRC_XOR_DST: D := ~S ^ D
BLT_NOT_DST: D := ~D
BLT_SRC_OR_NOT_DST: D := S | ~D
BLT_NOT_SRC: D := ~S
BLT_NOT_SRC_OR_DST: D := ~S | D
BLT_NOT_SRC_OR_NOT_DST: D := ~S | ~D == ~(S & D)
BLT_SET: D := 1

Line Styles¶ ↑

LINE_SOLID: Solid lines
LINE_ONOFF_DASH: On-off dashed lines
LINE_DOUBLE_DASH: Double dashed lines

Line Cap Styles¶ ↑

CAP_NOT_LAST: Don’t include last end cap
CAP_BUTT: Butting line end caps
CAP_ROUND: Round line end caps
CAP_PROJECTING: Projecting line end caps

Line Join Styles¶ ↑

JOIN_MITER: Mitered or pointy joints
JOIN_ROUND: Round line joints
JOIN_BEVEL: Beveled or flat joints

Fill Styles¶ ↑

FILL_SOLID: Fill with solid color
FILL_TILED: Fill with tiled bitmap
FILL_STIPPLED: Fill where stipple mask is 1
FILL_OPAQUESTIPPLED: Fill with foreground where mask is 1, background otherwise

Fill Rules¶ ↑

RULE_EVEN_ODD: Even odd polygon filling
RULE_WINDING: Winding rule polygon filling

Stipple/dither patterns¶ ↑

STIPPLE_0: Stipple pattern 0
STIPPLE_NONE: Stipple pattern 0
STIPPLE_BLACK: All ones
STIPPLE_1: Stipple pattern 1
STIPPLE_2: Stipple pattern 2
STIPPLE_3: Stipple pattern 3
STIPPLE_4: Stipple pattern 4
STIPPLE_5: Stipple pattern 5
STIPPLE_6: Stipple pattern 6
STIPPLE_7: Stipple pattern 7
STIPPLE_8: Stipple pattern 8
STIPPLE_GRAY: 50% gray
STIPPLE_9: Stipple pattern 9
STIPPLE_10: Stipple pattern 10
STIPPLE_11: Stipple pattern 11
STIPPLE_12: Stipple pattern 12
STIPPLE_13: Stipple pattern 13
STIPPLE_14: Stipple pattern 14
STIPPLE_15: Stipple pattern 15
STIPPLE_16: Stipple pattern 16
STIPPLE_WHITE: All zeroes
STIPPLE_HORZ: Horizontal hatch pattern
STIPPLE_VERT: Vertical hatch pattern
STIPPLE_CROSS: Cross-hatch pattern
STIPPLE_DIAG: Diagonal // hatch pattern
STIPPLE_REVDIAG: Reverse diagonal \ hatch pattern
STIPPLE_CROSSDIAG: Cross-diagonal hatch pattern

Attributes

app [R]

Application {FXApp}

background [RW]

Background drawing color {FXColor}

clipHeight [R]

Height of clip rectangle, in pixels [Integer]

clipRectangle [R]

Clip rectangle {FXRectangle}

clipRegion [W]

Clip region {FXRegion}

clipWidth [R]

Width of clip rectangle, in pixels [Integer]

clipX [R]

X-coordinate of clip rectangle [Integer]

clipY [R]

Y-coordinate of clip rectangle [Integer]

dashLength [R]

Dash length [Integer]

dashOffset [R]

Dash offset [Integer]

dashPattern [R]

Dash pattern [String]

fillRule [RW]

Fill rule, one of RULE_EVEN_ODD or RULE_WINDING [Integer]

fillStyle [RW]

Fill style, one of FILL_SOLID, FILL_TILED, FILL_STIPPLED or FILL_OPAQUESTIPPLED [Integer]

font [RW]

Font to draw text with {FXFont}

foreground [RW]

Foreground drawing color {FXColor}

function [RW]

Raster op function, one of BLT_CLR, BLT_SRC, BLT_DST, etc. (see list above) [Integer]

lineCap [RW]

Line cap style, one of CAP_NOT_LAST, CAP_BUTT, CAP_ROUND or CAP_PROJECTING [Integer]

lineJoin [RW]

Line join style, one of JOIN_MITER, JOIN_ROUND or JOIN_BEVEL [Integer]

lineStyle [RW]

Line style, one of LINE_SOLID, LINE_ONOFF_DASH or LINE_DOUBLE_DASH [Integer]

lineWidth [RW]

Line width; a line width of zero means thinnest and fastest possible [Integer]

stipple [RW]

Stipple pattern [FXBitmap or Integer]

tile [RW]

Tile image {FXImage}

Public Class Methods

new (*args)

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;
}

new (app)

Source

# File rdoc-sources/FXDC.rb, line 199
def initialize(app) ; end

Construct dummy DC

Public Instance Methods

clearClipMask (*args)

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)

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)

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)

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)

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)

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 = 0;
    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 = 0;
    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)

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)

Source

# 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

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.

drawEllipse (*args)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Source

# 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

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.

fillComplexPolygon (*args)

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)

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)

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)

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;
}

fillEllipse (x, y, w, h)

Source

# File rdoc-sources/FXDC.rb, line 446
def fillEllipse(x, y, w, h); end

Draw a filled ellipse.

fillPolygon (*args)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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 = 0;
    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 = 0;
    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)

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 = 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 *","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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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 = 0;
    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 = 0;
    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)

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 ()

Source

# File lib/fox16/aliases.rb, line 801
def stipple
  stippleBitmap.nil? ? stipplePattern : stippleBitmap
end

Stipple pattern [FXBitmap or Integer]