ruby-libgd 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 310bd931469060390ec5d475ce151934d42afb9e51e3d9ddaa59075c8a4f88db
-  data.tar.gz: 4d5dcef0cb4eb3556f4aa88733fd541539b49e489b4820469425270662b06b4c
+  metadata.gz: d318d5d92026ec9ece18021d3cecef81707d64bfe134856d73f5ee007872ac89
+  data.tar.gz: 11b4e17352cd1ff477478297b2a3004f13760dc001b8ac04ee6b6a082feac04e
 SHA512:
-  metadata.gz: c3bb2ad496f6764c13c00d25f0e4d30b8b388915f45d16421ae85982148bd2ab0ee6e3abd5e5eba16e155fbeb2d1cd74e71fa509a733b49543f8ba0702a1eea8
-  data.tar.gz: 1cabca6431ea0b7db31f0341ff63e68420c70b137a3b902b09f7b0bcf86a98d9ce71c3e7e4de67a85d07af47d2c1213e688665333657bc30b0d1ab5c64a55345
+  metadata.gz: 4a6719d7ddcc0c9cda1ec061e57a021c5ea729003764e62e19c327ddea77a3160d1f36f6953e8d8c54d6d9e946333347c5093668ea6670a65af468aeb61a3f92
+  data.tar.gz: 0c4ba9ea4e0b4faed88aefcebe0164edfc4ab9722113914eeecd024863bedb187c6c4f2936a6822af0ad32b6f41b7d31fcdd781f35fdb1d3114888d8940c1e35

data/ext/gd/blit.c

@@ -1,10 +1,7 @@
 /**
-  - [ ] imagecopy — Copy part of an image
   - [ ] imagecopymerge — Copy and merge part of an image
   - [ ] imagecopymergegray — Copy and merge part of an image with gray scale
-  - [ ] imagecopyresampled — Copy and resize part of an image with resampling
-  - [ ] imagecopyresized — Copy and resize part of an image
-*/
+  */
 #include "ruby_gd.h"
 
 static VALUE gd_image_copy_merge(

data/ext/gd/filter.c

@@ -275,18 +275,14 @@ static VALUE gd_image_filter(int argc, VALUE *argv, VALUE self) {
     }
   }
   else if (strcmp(name, "box_blur") == 0) {
-
     if (!gdImageConvolution(wrap->img, kernel_box_blur, 9.0, 0.0)) {
       rb_raise(rb_eRuntimeError, "box_blur convolution failed");
     }
-
   }
   else if (strcmp(name, "gaussian_kernel") == 0) {
-
     if (!gdImageConvolution(wrap->img, kernel_gaussian, 16.0, 0.0)) {
       rb_raise(rb_eRuntimeError, "gaussian_kernel convolution failed");
     }
-
   }
   else if (strcmp(name, "emboss2") == 0) {
     if (!gdImageConvolution(wrap->img, kernel_emboss2, 1.0, 128.0)) {

data/ext/gd/image.c

@@ -1,24 +1,42 @@
 #include "ruby_gd.h"
 
-static VALUE gd_image_initialize(int argc, VALUE *argv, VALUE self) {
+static VALUE gd_image_alloc(VALUE klass) {
   gd_image_wrapper *wrap;
-  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
-
+  VALUE obj = TypedData_Make_Struct(klass, gd_image_wrapper, &gd_image_type, wrap);
   wrap->img = NULL;
+  return obj;
+}
+
+/* ---------------------------------------------------------
+ * Initialize
+ * --------------------------------------------------------- */
 
+static VALUE gd_image_initialize(int argc, VALUE *argv, VALUE self) {
   if (argc == 0) {
+    rb_raise(rb_eArgError, "width and height are required");
     return self;
   }
+
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+
+  wrap->img = NULL;
+
   if (argc != 2) {
     rb_raise(rb_eArgError, "expected 0 or 2 arguments");
   }
 
   int w = NUM2INT(argv[0]);
   int h = NUM2INT(argv[1]);
+
   if (w <= 0 || h <= 0)
     rb_raise(rb_eArgError, "width and height must be positive");
 
   wrap->img = gdImageCreateTrueColor(w,h);
+
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "gdImageCreateTrueColor failed");
+
   gdImageSaveAlpha(wrap->img, 1);
   gdImageAlphaBlending(wrap->img, 0);
 
@@ -27,12 +45,6 @@ static VALUE gd_image_initialize(int argc, VALUE *argv, VALUE self) {
 
   gdImageAlphaBlending(wrap->img, 1);
 
-  int t = gdTrueColorAlpha(0,0,0,127);
-  gdImageFilledRectangle(wrap->img, 0, 0, w-1, h-1, t);
-
-  if (!wrap->img)
-    rb_raise(rb_eRuntimeError, "gdImageCreateTrueColor failed");
-
   return self;
 }
 
@@ -58,7 +70,7 @@ static VALUE gd_image_initialize_true_color(VALUE self, VALUE width, VALUE heigh
   // Opcional: desactivar el fondo transparente si no lo necesitas
   gdImageSaveAlpha(wrap->img, 1);
   gdImageAlphaBlending(wrap->img, 0);
-  
+
   int t = gdTrueColorAlpha(0,0,0,127);
   gdImageFilledRectangle(wrap->img, 0,0, w-1, h-1, t);
 
@@ -66,30 +78,47 @@ static VALUE gd_image_initialize_true_color(VALUE self, VALUE width, VALUE heigh
 }
 
 static VALUE gd_image_s_new_true_color(VALUE klass, VALUE width, VALUE height) {
-  VALUE obj = rb_class_new_instance(0, NULL, klass);
-  gd_image_initialize_true_color(obj, width, height);
-  return obj;
+  VALUE img = rb_obj_alloc(klass);
+  rb_funcall(img, rb_intern("initialize"), 2, width, height);
+  return img;
 }
 
-static VALUE gd_image_clone(VALUE self) {
-  gd_image_wrapper *wrap;
-  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+/* ---------------------------------------------------------
+ * initialize_copy (correct way for clone/dup)
+ * --------------------------------------------------------- */
 
-  if (!wrap->img) rb_raise(rb_eRuntimeError, "cannot clone: image is NULL");
+static VALUE gd_image_initialize_copy(VALUE self, VALUE orig) {
+  gd_image_wrapper *src;
+  gd_image_wrapper *dst;
 
-  gdImagePtr copy = gdImageClone(wrap->img);
-  if (!copy) rb_raise(rb_eRuntimeError, "gdImageClone failed");
+  if (self == orig) return self;
 
-  VALUE obj = rb_class_new_instance(0, NULL, CLASS_OF(self));
-  gd_image_wrapper *w2;
-  TypedData_Get_Struct(obj, gd_image_wrapper, &gd_image_type, w2);
-  w2->img = copy;
+  TypedData_Get_Struct(orig, gd_image_wrapper, &gd_image_type, src);
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, dst);
 
-  return obj;
+  if (!src->img)
+    rb_raise(rb_eRuntimeError, "cannot copy: image is NULL");
+
+  if (dst->img) {
+    gdImageDestroy(dst->img);
+    dst->img = NULL;
+  }
+
+  dst->img = gdImageClone(src->img);
+
+  if (!dst->img)
+    rb_raise(rb_eRuntimeError, "gdImageClone failed");
+
+  return self;
 }
 
+/* ---------------------------------------------------------
+ * Free
+ * --------------------------------------------------------- */
+
 static void gd_image_free(void *ptr) {
   gd_image_wrapper *wrap = (gd_image_wrapper *)ptr;
+
   if (!wrap) return;
 
   if (wrap->img) {
@@ -104,17 +133,14 @@ static size_t gd_image_memsize(const void *ptr) {
 
 const rb_data_type_t gd_image_type = {
   "GD::Image",
-  { 0, gd_image_free, gd_image_memsize, 0 },  // <-- dcompact agregado
+  { 0, gd_image_free, gd_image_memsize, },
   0, 0,
   RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-static VALUE gd_image_alloc(VALUE klass) {
-  gd_image_wrapper *wrap;
-  VALUE obj = TypedData_Make_Struct(klass, gd_image_wrapper, &gd_image_type, wrap);
-  wrap->img = NULL;
-  return obj;
-}
+/* ---------------------------------------------------------
+ * Image loading
+ * --------------------------------------------------------- */
 
 static VALUE gd_image_open(VALUE klass, VALUE path) {
   const char *filename = StringValueCStr(path);
@@ -141,44 +167,44 @@ static VALUE gd_image_open(VALUE klass, VALUE path) {
   }
 
   fclose(f);
-  if (!img) rb_raise(rb_eRuntimeError, "image decode failed");
 
-  VALUE obj = rb_class_new_instance(0, NULL, klass);
+  if (!img)
+    rb_raise(rb_eRuntimeError, "image decode failed");
+
+  VALUE obj = rb_obj_alloc(klass);
+
   gd_image_wrapper *wrap;
   TypedData_Get_Struct(obj, gd_image_wrapper, &gd_image_type, wrap);
+
   wrap->img = img;
 
   return obj;
 }
 
-static VALUE gd_image_alpha_blending(VALUE self, VALUE flag) {
-    gd_image_wrapper *wrap;
-    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
-
-    gdImageAlphaBlending(wrap->img, RTEST(flag));
-    return self;
-}
-
-static VALUE gd_image_save_alpha(VALUE self, VALUE flag) {
-    gd_image_wrapper *wrap;
-    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
-
-    gdImageSaveAlpha(wrap->img, RTEST(flag));
-    return self;
-}
+/* ---------------------------------------------------------
+ * Image info
+ * --------------------------------------------------------- */
 
 static VALUE gd_image_width(VALUE self) {
-    gd_image_wrapper *wrap;
-    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
-    return INT2NUM(gdImageSX(wrap->img));
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "image not initialized");
+  return INT2NUM(gdImageSX(wrap->img));
 }
 
 static VALUE gd_image_height(VALUE self) {
-    gd_image_wrapper *wrap;
-    TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
-    return INT2NUM(gdImageSY(wrap->img));
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "image not initialized");
+  return INT2NUM(gdImageSY(wrap->img));
 }
 
+/* ---------------------------------------------------------
+ * Copy operations
+ * --------------------------------------------------------- */
+
 static VALUE gd_image_copy (
   VALUE self, VALUE src,
   VALUE dx, VALUE dy,
@@ -191,6 +217,9 @@ static VALUE gd_image_copy (
   TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, dst);
   TypedData_Get_Struct(src,  gd_image_wrapper, &gd_image_type, srcw);
 
+  if (!dst->img)  rb_raise(rb_eRuntimeError, "image not initialized");
+  if (!srcw->img) rb_raise(rb_eRuntimeError, "source image not initialized");
+
   gdImageCopy(
     dst->img,
     srcw->img,
@@ -216,6 +245,9 @@ static VALUE gd_image_copy_resize(int argc, VALUE *argv, VALUE self) {
   TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, dst);
   TypedData_Get_Struct(src_img, gd_image_wrapper, &gd_image_type, src);
 
+  if (!dst->img)  rb_raise(rb_eRuntimeError, "image not initialized");
+  if (!src->img)  rb_raise(rb_eRuntimeError, "source image not initialized");
+
   int dx = NUM2INT(dst_x);
   int dy = NUM2INT(dst_y);
   int sx = NUM2INT(src_x);
@@ -225,9 +257,7 @@ static VALUE gd_image_copy_resize(int argc, VALUE *argv, VALUE self) {
   int dw = NUM2INT(dst_w);
   int dh = NUM2INT(dst_h);
 
-  int do_resample = RTEST(resample);
-
-  if (do_resample) {
+  if (RTEST(resample)) {
     gdImageCopyResampled(
       dst->img, src->img,
       dx, dy,
@@ -248,12 +278,34 @@ static VALUE gd_image_copy_resize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
+/* ---------------------------------------------------------
+ * Flags
+ * --------------------------------------------------------- */
+
+static VALUE gd_image_alpha_blending(VALUE self, VALUE flag) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "image not initialized");
+  gdImageAlphaBlending(wrap->img, RTEST(flag));
+  return self;
+}
+
+static VALUE gd_image_save_alpha(VALUE self, VALUE flag) {
+  gd_image_wrapper *wrap;
+  TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
+  if (!wrap->img)
+    rb_raise(rb_eRuntimeError, "image not initialized");
+  gdImageSaveAlpha(wrap->img, RTEST(flag));
+  return self;
+}
+
 static VALUE gd_image_antialias(VALUE self, VALUE flag) {
   gd_image_wrapper *wrap;
   TypedData_Get_Struct(self, gd_image_wrapper, &gd_image_type, wrap);
 
   if (!wrap->img)
-    rb_raise(rb_eRuntimeError, "image is NULL");
+    rb_raise(rb_eRuntimeError, "image not initialized");
 
   if (RTEST(flag)) {
     int aa = gdTrueColorAlpha(255,255,255,0);
@@ -266,23 +318,31 @@ static VALUE gd_image_antialias(VALUE self, VALUE flag) {
   return flag;
 }
 
+/* ---------------------------------------------------------
+ * Class definition
+ * --------------------------------------------------------- */
 
 void gd_define_image(VALUE mGD) {
+
   VALUE cGDImage = rb_define_class_under(mGD, "Image", rb_cObject);
 
   rb_define_alloc_func(cGDImage, gd_image_alloc);
 
+  rb_define_method(cGDImage, "initialize", gd_image_initialize, -1);
+  rb_define_method(cGDImage, "initialize_copy", gd_image_initialize_copy, 1);
+
   rb_define_method(cGDImage, "width",  gd_image_width,  0);
   rb_define_method(cGDImage, "height", gd_image_height, 0);
-  rb_define_method(cGDImage, "initialize", gd_image_initialize, -1);
+
   rb_define_method(cGDImage, "copy_resize", gd_image_copy_resize, -1);
   rb_define_method(cGDImage, "copy", gd_image_copy, 7);
-  rb_define_method(cGDImage, "clone", gd_image_clone, 0);
+
   rb_define_singleton_method(cGDImage, "open", gd_image_open, 1);
   rb_define_singleton_method(cGDImage, "new_true_color", gd_image_s_new_true_color, 2);
+
   rb_define_method(cGDImage, "alpha_blending=", gd_image_alpha_blending, 1);
   rb_define_method(cGDImage, "save_alpha=", gd_image_save_alpha, 1);
+
   rb_define_method(cGDImage, "antialias=", gd_image_antialias, 1);
   rb_define_method(cGDImage, "antialias",  gd_image_antialias, 1);
-
 }

data/ext/gd/text.c

@@ -56,7 +56,7 @@ static VALUE gd_image_text_bbox(VALUE self, VALUE text, VALUE opts) {
   memset(&extra, 0, sizeof(extra));
 
   char *err = gdImageStringFTEx(
-    wrap->img,
+    NULL,
     brect,
     0,           /* no color, we don't draw */
     font,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-libgd
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Germán Alberto Giménez Silva
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Native Ruby bindings for libgd
 test_files: []