class Fox::FXBitmap

A bitmap is a rectangular array of pixels. It supports two representations of these pixels: a client-side pixel buffer, and a server-side pixmap which is stored in an organization directly compatible with the screen, for fast drawing onto the device. The server-side representation is not directly accessible from the current process at it lives in the process of the X server or GDI (on Microsoft Windows). The client-side pixel array is of size height x (width+7)/8 bytes; in other words, 8 pixels packed into a single byte, starting with bit zero on the left.

Image rendering hints¶ ↑

BITMAP_KEEP: Keep pixel data in client
BITMAP_OWNED: Pixel data is owned by image
BITMAP_SHMI: Using shared memory image
BITMAP_SHMP: Using shared memory pixmap

Public Class Methods

new (*args)

Source

SWIGINTERN VALUE
_wrap_new_FXBitmap(int argc, VALUE *argv, VALUE self) {
  FXApp *arg1 = (FXApp *) 0 ;
  void *arg2 = (void *) 0 ;
  FXuint arg3 = (FXuint) 0 ;
  FXint arg4 = (FXint) 1 ;
  FXint arg5 = (FXint) 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXBitmap *result = 0 ;
  
  if ((argc < 1) || (argc > 5)) {
    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 *","FXBitmap", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FXApp * >(argp1);
  if (argc > 1) {
    {
      if (argv[1] != Qnil) {
        Check_Type(argv[1], T_STRING);
        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
      } else {
        arg2 = NULL;
      }
    }
  }
  if (argc > 2) {
    arg3 = NUM2UINT(argv[2]);
  }
  if (argc > 3) {
    arg4 = NUM2INT(argv[3]);
  }
  if (argc > 4) {
    arg5 = NUM2INT(argv[4]);
  }
  {
    if (!arg1) {
      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
    }
  }
  {
    result = (FXBitmap *)new_FXBitmap(arg1,(void const *)arg2,arg3,arg4,arg5);
    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
    if(rb_block_given_p()){
      rb_yield(self);
    }
  }
  return self;
fail:
  return Qnil;
}

new (app, *args, &blk)

Source

# File lib/fox16/kwargs.rb, line 319
def initialize(app, *args, &blk)
  argument_names = %w{pixels opts width height}
  default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
  params = {}
  params = args.pop if args.last.is_a? Hash
  args.each_with_index { |e, i| params[argument_names[i].intern] = e }
  params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
  params = default_params.merge(params)
  old_initialize(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
end

Also aliased as: old_initialize

Public Instance Methods

create (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_create(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_create(arg1);
  return Qnil;
fail:
  return Qnil;
}

crop (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_crop(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXint arg4 ;
  FXint arg5 ;
  FXbool arg6 = (FXbool) 0 ;
  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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","crop", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = NUM2INT(argv[2]);
  arg5 = NUM2INT(argv[3]);
  if (argc > 4) {
    arg6 = to_FXbool(argv[4]);
  }
  FXBitmap_crop(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}

data (*args)

Alias for: getData

destroy (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_destroy(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_destroy(arg1);
  return Qnil;
fail:
  return Qnil;
}

detach (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_detach(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","detach", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_detach(arg1);
  return Qnil;
fail:
  return Qnil;
}

fill (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_fill(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","fill", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = to_FXbool(argv[0]);
  FXBitmap_fill(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

getData (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_getData(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXuchar *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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getData", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  result = (FXuchar *)((FXBitmap const *)arg1)->getData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

Also aliased as: data

getOptions (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_getOptions(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  result = (FXuint)((FXBitmap const *)arg1)->getOptions();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}

getPixel (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_getPixel(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  FXbool 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getPixel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  result = (FXbool)((FXBitmap const *)arg1)->getPixel(arg2,arg3);
  vresult = result ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

load (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_load(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXStream *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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  FXBitmap_load(arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}

loadPixels (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_loadPixels(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","loadPixels", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  result = (bool)FXBitmap_loadPixels(arg1,*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

mirror (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_mirror(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXbool arg2 ;
  FXbool 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","mirror", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = to_FXbool(argv[0]);
  arg3 = to_FXbool(argv[1]);
  FXBitmap_mirror(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

old_initialize (app, *args, &blk)

Alias for: new

options ()

Source

# File rdoc-sources/FXBitmap.rb, line 56
def options; end

Return the option flags.

options= (opts)

Source

# File rdoc-sources/FXBitmap.rb, line 59
def options=(opts); end

Set the options.

release (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_release(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","release", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_release(arg1);
  return Qnil;
fail:
  return Qnil;
}

render (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_render(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","render", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_render(arg1);
  return Qnil;
fail:
  return Qnil;
}

resize (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_resize(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXBitmap_resize(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

restore (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_restore(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","restore", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  FXBitmap_restore(arg1);
  return Qnil;
fail:
  return Qnil;
}

rotate (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_rotate(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXint 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  FXBitmap_rotate(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

save (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_save(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXStream *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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  FXBitmap_save((FXBitmap const *)arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}

savePixels (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_savePixels(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXStream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","savePixels", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< FXStream * >(argp2);
  result = (bool)FXBitmap_savePixels((FXBitmap const *)arg1,*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

scale (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_scale(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  FXBitmap_scale(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}

setData (*args)

Source

SWIGINTERN VALUE _wrap_FXBitmap_setData(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) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_FXBitmap_setData__SWIG_0(nargs, args, self);
        }
        {
          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
        }
        if (_v) {
          return _wrap_FXBitmap_setData__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 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) {
              return _wrap_FXBitmap_setData__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "setData", 
    "    void setData(FXuchar *pix, FXuint opts)\n"
    "    void setData(FXuchar *pix, FXuint opts, FXint w, FXint h)\n");
  
  return Qnil;
}

setOptions (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_setOptions(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXuint 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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2UINT(argv[0]);
  (arg1)->setOptions(arg2);
  return Qnil;
fail:
  return Qnil;
}

setPixel (*args)

Source

SWIGINTERN VALUE
_wrap_FXBitmap_setPixel(int argc, VALUE *argv, VALUE self) {
  FXBitmap *arg1 = (FXBitmap *) 0 ;
  FXint arg2 ;
  FXint arg3 ;
  FXbool arg4 ;
  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_FXBitmap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setPixel", 1, self )); 
  }
  arg1 = reinterpret_cast< FXBitmap * >(argp1);
  arg2 = NUM2INT(argv[0]);
  arg3 = NUM2INT(argv[1]);
  arg4 = to_FXbool(argv[2]);
  (arg1)->setPixel(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}