gosu 1.0.0.pre2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee520b114c06651017a9aac042728e418654c2721bd483fe3de6c44be2acc1de
-  data.tar.gz: 2da43a5b2e1a19d45e1be85acceb48210c70a9fb866e03ca392c6232c8e89186
+  metadata.gz: 9c9b393a63015707256dca78e9079b01dbc004d85b89c6bf68d021085f65a905
+  data.tar.gz: 60396892082e2fa81a7ab03f8662fe00630745f84b1e0a47e9abcd7bed5c7692
 SHA512:
-  metadata.gz: af2d2f9ac8121b4edae0ab5fd2bdd9aa69c0209741ae2af4dabc99419ab0ba9520c0dafa51640132db79c1496f2993f40ab000c475e562d079b59fdecd3227e7
-  data.tar.gz: 0ee8ff41e302362370ed40d2d640444a89a232ddd35a072d4c038941b6412ea7662d06ea5acdabe8ffc1739ca73aade3d88ec0b4090bb7db8023b5ec777f97d2
+  metadata.gz: fb477140be8f524abfeb3694277bd815690c4c0ae432ac011956a43640f49309aca3c0a9b3619c17cc83461ae5c9c9b6fb1bfa155e72f1be19b4f166e23b3022
+  data.tar.gz: 24707e94f193a4fe949a447a01b732057860eb271a8a0d61ba6c45a0b1b5da8c2894ffc65d3ff3fe2b97fe7e8b9c5b38b9995d4d443d014fe6059f520f900393

data/include/Gosu/Font.hpp

@@ -40,7 +40,7 @@ namespace Gosu
         
         //! Returns the width, in pixels, the given text would occupy if drawn.
         double text_width(const std::string& text) const;
-        //! Returns the width, in pixels, the given text would occupy if drawn.
+        //! Returns the width, in pixels, the given markup would occupy if drawn.
         double markup_width(const std::string& markup) const;
         
         //! Draws text so the top left corner of the text is at (x; y).

data/lib/gosu/patches.rb

@@ -18,26 +18,12 @@ class ::Numeric
   end
 end
 
-class Gosu::Font
-  # draw_text will stop parsing markup in Gosu 1.0.
-  alias_method :draw_text, :draw_markup
-  # draw_text_rel will stop parsing markup in Gosu 1.0.
-  alias_method :draw_text_rel, :draw_markup_rel
-  # text_width will stop parsing markup in Gosu 1.0.
-  alias_method :text_width, :markup_width
-end
-
 class Gosu::Image
   BlobHelper = Struct.new(:columns, :rows, :to_blob)
   
   def self.from_blob(width, height, rgba = "\0\0\0\0" * (width * height))
     self.new(BlobHelper.new(width, height, rgba))
   end
-  
-  # from_markup will stop parsing markup in Gosu 1.0.
-  def self.from_markup(*args)
-    self.from_text(*args)
-  end
 end
 
 # Color constants.

data/lib/gosu/preview.rb

@@ -3,8 +3,6 @@ warn "gosu/preview.rb has been removed in Gosu 0.9.0, and Gosu itself \n" +
   "Notable differences:\n" +
   "• no global $window variable\n" +
   "• no global Gosu.mouse_x and Gosu.mouse_y functions\n" +
-  "• Image#initialize et.al. use an options hash now\n" +
-  "If you cannot update your code base right now, you should require \n" +
-  "Gosu 0.8.x in your Gemfile: gem 'gosu', '~> 0.8.0'";
+  "• Image#initialize et.al. use an options hash now";
 
 require 'gosu'

data/src/RubyGosu.cxx

@@ -2856,11 +2856,19 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
         
         return new Gosu::Font(height, font_name, font_flags);
     }
+SWIGINTERN double Gosu_Font_text_width(Gosu::Font *self,std::string const &markup,double scale_x=1.0){
+      static bool issued_warning = false;
+      if (scale_x != 1.0 && !issued_warning) {
+          issued_warning = true;
+          rb_warn("The second argument to Gosu::Font#text_width is deprecated, multiply the result instead");
+      }
+      return self->text_width(markup) * scale_x;
+    }
 SWIGINTERN double Gosu_Font_markup_width(Gosu::Font *self,std::string const &markup,double scale_x=1.0){
       static bool issued_warning = false;
       if (scale_x != 1.0 && !issued_warning) {
           issued_warning = true;
-          rb_warn("The second argument to Font#markup_width and Font#text_width is deprecated, multiply the result instead");
+          rb_warn("The second argument to Gosu::Font#markup_width is deprecated, multiply the result instead");
       }
       return self->markup_width(markup) * scale_x;
     }
@@ -2926,7 +2934,81 @@ SWIGINTERN Gosu::Image *Gosu_Image_subimage(Gosu::Image *self,int x,int y,int w,
         std::unique_ptr<Gosu::ImageData> image_data = self->data().subimage(x, y, w, h);
         return image_data.get() ? new Gosu::Image(std::move(image_data)) : nullptr;
     }
-SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &markup,double font_height,VALUE options=0){
+SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,double font_height,VALUE options=0){
+        std::string font = Gosu::default_font_name();
+        int width = -1;
+        double spacing = 0;
+        Gosu::Alignment align = Gosu::AL_LEFT;
+        unsigned image_flags = 0;
+        unsigned font_flags = 0;
+
+        if (options) {
+            Check_Type(options, T_HASH);
+
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keys_size = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+
+            for (int i = 0; i < keys_size; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* key_string = Gosu::cstr_from_symbol(key);
+
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(key_string, "font")) {
+                    font = StringValuePtr(value);
+                }
+                else if (!strcmp(key_string, "bold")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_BOLD;
+                }
+                else if (!strcmp(key_string, "italic")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_ITALIC;
+                }
+                else if (!strcmp(key_string, "underline")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_UNDERLINE;
+                }
+                else if (!strcmp(key_string, "align")) {
+                    const char* cstr = Gosu::cstr_from_symbol(value);
+
+                    if (!strcmp(cstr, "left")) {
+                        align = Gosu::AL_LEFT;
+                    }
+                    else if (!strcmp(cstr, "center")) {
+                        align = Gosu::AL_CENTER;
+                    }
+                    else if (!strcmp(cstr, "right")) {
+                        align = Gosu::AL_RIGHT;
+                    }
+                    else if (!strcmp(cstr, "justify")) {
+                        align = Gosu::AL_JUSTIFY;
+                    }
+                    else {
+                        rb_raise(rb_eArgError, "Argument passed to :align must be a valid text "
+                                               "alignment (:left, :center, :right, :justify)");
+                    }
+                }
+                else if (!strcmp(key_string, "width")) {
+                    width = NUM2INT(value);
+                }
+                else if (!strcmp(key_string, "spacing")) {
+                    spacing = NUM2DBL(value);
+                }
+                else if (!strcmp(key_string, "retro")) {
+                    if (RTEST(value)) image_flags |= Gosu::IF_RETRO;
+                }
+                else {
+                    static bool issued_warning = false;
+                    if (!issued_warning) {
+                        issued_warning = true;
+                        rb_warn("Unknown keyword argument: :%s", key_string);
+                    }
+                }
+            }
+        }
+
+        Gosu::Bitmap bitmap = Gosu::layout_text(text, font, font_height, spacing, width,
+                                                align, font_flags);
+        return new Gosu::Image(bitmap, image_flags);
+    }
+SWIGINTERN Gosu::Image *Gosu_Image_from_markup(std::string const &markup,double font_height,VALUE options=0){
         std::string font = Gosu::default_font_name();
         int width = -1;
         double spacing = 0;
@@ -5281,6 +5363,134 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_draw_text(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 ;
+  double arg4 ;
+  Gosu::ZPos arg5 ;
+  double arg6 = (double) 1 ;
+  double arg7 = (double) 1 ;
+  Gosu::Color arg8 = (Gosu::Color) Gosu::Color::WHITE ;
+  Gosu::AlphaMode arg9 = (Gosu::AlphaMode) Gosu::AM_DEFAULT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  
+  if ((argc < 4) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_text", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_text", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_text", 3, argv[1] ));
+  } 
+  arg3 = static_cast< double >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_text", 4, argv[2] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_text", 5, argv[3] ));
+  } 
+  arg5 = static_cast< Gosu::ZPos >(val5);
+  if (argc > 4) {
+    ecode6 = SWIG_AsVal_double(argv[4], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_text", 6, argv[4] ));
+    } 
+    arg6 = static_cast< double >(val6);
+  }
+  if (argc > 5) {
+    ecode7 = SWIG_AsVal_double(argv[5], &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_text", 7, argv[5] ));
+    } 
+    arg7 = static_cast< double >(val7);
+  }
+  if (argc > 6) {
+    {
+      if (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) {
+        arg8 = Gosu::Color(NUM2ULONG(argv[6]));
+      }
+      else {
+        void* ptr;
+        int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        if (!SWIG_IsOK(res)) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid value");
+        }
+        else if (ptr == nullptr) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+        }
+        else {
+          arg8 = *reinterpret_cast<Gosu::Color*>(ptr);
+        }
+      }
+    }
+  }
+  if (argc > 7) {
+    {
+      const char* cstr = Gosu::cstr_from_symbol(argv[7]);
+      
+      if (!strcmp(cstr, "default")) {
+        arg9 = Gosu::AM_DEFAULT;
+      }
+      else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
+        arg9 = Gosu::AM_ADD;
+      }
+      else if (!strcmp(cstr, "multiply")) {
+        arg9 = Gosu::AM_MULTIPLY;
+      }
+      else {
+        SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
+          ":multiply)");
+      }
+    }
+  }
+  {
+    try {
+      ((Gosu::Font const *)arg1)->draw_text((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -5409,6 +5619,150 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_draw_text_rel(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 ;
+  double arg4 ;
+  Gosu::ZPos arg5 ;
+  double arg6 ;
+  double arg7 ;
+  double arg8 = (double) 1 ;
+  double arg9 = (double) 1 ;
+  Gosu::Color arg10 = (Gosu::Color) Gosu::Color::WHITE ;
+  Gosu::AlphaMode arg11 = (Gosu::AlphaMode) Gosu::AM_DEFAULT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val9 ;
+  int ecode9 = 0 ;
+  
+  if ((argc < 6) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_text_rel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_text_rel", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_text_rel", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_text_rel", 3, argv[1] ));
+  } 
+  arg3 = static_cast< double >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_text_rel", 4, argv[2] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_text_rel", 5, argv[3] ));
+  } 
+  arg5 = static_cast< Gosu::ZPos >(val5);
+  ecode6 = SWIG_AsVal_double(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_text_rel", 6, argv[4] ));
+  } 
+  arg6 = static_cast< double >(val6);
+  ecode7 = SWIG_AsVal_double(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_text_rel", 7, argv[5] ));
+  } 
+  arg7 = static_cast< double >(val7);
+  if (argc > 6) {
+    ecode8 = SWIG_AsVal_double(argv[6], &val8);
+    if (!SWIG_IsOK(ecode8)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","draw_text_rel", 8, argv[6] ));
+    } 
+    arg8 = static_cast< double >(val8);
+  }
+  if (argc > 7) {
+    ecode9 = SWIG_AsVal_double(argv[7], &val9);
+    if (!SWIG_IsOK(ecode9)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","draw_text_rel", 9, argv[7] ));
+    } 
+    arg9 = static_cast< double >(val9);
+  }
+  if (argc > 8) {
+    {
+      if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) {
+        arg10 = Gosu::Color(NUM2ULONG(argv[8]));
+      }
+      else {
+        void* ptr;
+        int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        if (!SWIG_IsOK(res)) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid value");
+        }
+        else if (ptr == nullptr) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+        }
+        else {
+          arg10 = *reinterpret_cast<Gosu::Color*>(ptr);
+        }
+      }
+    }
+  }
+  if (argc > 9) {
+    {
+      const char* cstr = Gosu::cstr_from_symbol(argv[9]);
+      
+      if (!strcmp(cstr, "default")) {
+        arg11 = Gosu::AM_DEFAULT;
+      }
+      else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
+        arg11 = Gosu::AM_ADD;
+      }
+      else if (!strcmp(cstr, "multiply")) {
+        arg11 = Gosu::AM_MULTIPLY;
+      }
+      else {
+        SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
+          ":multiply)");
+      }
+    }
+  }
+  {
+    try {
+      ((Gosu::Font const *)arg1)->draw_text_rel((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_draw_markup_rel(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -5766,6 +6120,62 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_text_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 = (double) 1.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","text_width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","text_width", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","text_width", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_double(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","text_width", 3, argv[1] ));
+    } 
+    arg3 = static_cast< double >(val3);
+  }
+  {
+    try {
+      result = (double)Gosu_Font_text_width(arg1,(std::string const &)*arg2,arg3);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_double(static_cast< double >(result));
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return vresult;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_markup_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -7015,6 +7425,56 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Image_from_markup(int argc, VALUE *argv, VALUE self) {
+  std::string *arg1 = 0 ;
+  double arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  double val2 ;
+  int ecode2 = 0 ;
+  Gosu::Image *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","Gosu_Image_from_markup", 1, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu_Image_from_markup", 1, argv[0])); 
+    }
+    arg1 = ptr;
+  }
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu_Image_from_markup", 2, argv[1] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (argc > 2) {
+    arg3 = argv[2];
+  }
+  {
+    try {
+      result = (Gosu::Image *)Gosu_Image_from_markup((std::string const &)*arg1,arg2,arg3);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return vresult;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Image_load_tiles__SWIG_0(int argc, VALUE *argv, VALUE self) {
   VALUE arg1 = (VALUE) 0 ;
@@ -12024,9 +12484,12 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassFont.klass, "name", VALUEFUNC(_wrap_Font_name), -1);
   rb_define_method(SwigClassFont.klass, "height", VALUEFUNC(_wrap_Font_height), -1);
   rb_define_method(SwigClassFont.klass, "flags", VALUEFUNC(_wrap_Font_flags), -1);
+  rb_define_method(SwigClassFont.klass, "draw_text", VALUEFUNC(_wrap_Font_draw_text), -1);
   rb_define_method(SwigClassFont.klass, "draw_markup", VALUEFUNC(_wrap_Font_draw_markup), -1);
+  rb_define_method(SwigClassFont.klass, "draw_text_rel", VALUEFUNC(_wrap_Font_draw_text_rel), -1);
   rb_define_method(SwigClassFont.klass, "draw_markup_rel", VALUEFUNC(_wrap_Font_draw_markup_rel), -1);
   rb_define_method(SwigClassFont.klass, "set_image", VALUEFUNC(_wrap_Font_set_image), -1);
+  rb_define_method(SwigClassFont.klass, "text_width", VALUEFUNC(_wrap_Font_text_width), -1);
   rb_define_method(SwigClassFont.klass, "markup_width", VALUEFUNC(_wrap_Font_markup_width), -1);
   SwigClassFont.mark = 0;
   SwigClassFont.destroy = (void (*)(void *)) free_Gosu_Font;
@@ -12063,6 +12526,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassImage.klass, "gl_tex_info", VALUEFUNC(_wrap_Image_gl_tex_info), -1);
   rb_define_method(SwigClassImage.klass, "subimage", VALUEFUNC(_wrap_Image_subimage), -1);
   rb_define_singleton_method(SwigClassImage.klass, "from_text", VALUEFUNC(_wrap_Image_from_text), -1);
+  rb_define_singleton_method(SwigClassImage.klass, "from_markup", VALUEFUNC(_wrap_Image_from_markup), -1);
   rb_define_singleton_method(SwigClassImage.klass, "load_tiles", VALUEFUNC(_wrap_Image_load_tiles), -1);
   rb_define_method(SwigClassImage.klass, "to_blob", VALUEFUNC(_wrap_Image_to_blob), -1);
   rb_define_method(SwigClassImage.klass, "columns", VALUEFUNC(_wrap_Image_columns), -1);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0
 platform: ruby
 authors:
 - Julian Raschke
@@ -225,7 +225,6 @@ files:
 - lib/gosu/preview.rb
 - lib/gosu/run.rb
 - lib/gosu/swig_patches.rb
-- lib/gosu/zen.rb
 - lib64/OpenAL32.dll
 - lib64/SDL2.dll
 - rdoc/gosu.rb
@@ -333,9 +332,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.2.3
 signing_key:

data/lib/gosu/zen.rb

@@ -1,89 +0,0 @@
-require 'gosu/preview'
-
-module Gosu
-  module Zen
-    
-    @@window_args = [800, 600, {}]
-    @@options = {}
-    
-    def window width, height, options = nil
-      if $window.nil?
-        @@window_args[0] = width
-        @@window_args[1] = height
-        @@window_args[2].merge! options if options
-      else
-        raise "window size can only be set before the window is created"
-      end
-    end
-    
-    def set what, value
-      if $window.nil?
-        @@options[what.to_sym] = value
-      else
-        $window.send "#{what}=", value
-      end
-    end
-    
-    def init &body
-      ZenWindow.send :define_method, :init, &body
-    end
-    
-    def button_down id = nil, &body
-      m = id ? "button_down_#{id}" : :button_down_other
-      ZenWindow.send :define_method, m, &body
-    end
-    
-    def button_up id = nil, &body
-      m = id ? "button_up_#{id}" : :button_up_other
-      ZenWindow.send :define_method, m, &body
-    end
-    
-    def update &body
-      ZenWindow.send :define_method, :update, &body
-    end
-    
-    def draw &body
-      ZenWindow.send :define_method, :draw, &body
-    end
-    
-    def run!
-      window = ZenWindow.new *@@window_args
-      @@options.each do |opt, value|
-        window.send "#{opt}=", value
-      end
-      window.show
-    end
-    
-    def Zen.included mod
-      at_exit { run! unless $! }
-    end
-    
-  end
-  
-  class ZenWindow < Window
-    def initialize *args
-      super
-      init
-    end
-    
-    def init
-    end
-    
-    def button_down id
-      m = :"button_down_#{id}"
-      respond_to?(m) ? send(m) : button_down_other(id)
-    end
-    
-    def button_up id
-      m = :"button_up_#{id}"
-      respond_to?(m) ? send(m) : button_up_other(id)
-    end
-    
-    def button_down_other id
-    end
-    
-    def button_up_other id
-    end
-    
-  end
-end