gosu 0.14.0.pre2 → 0.14.0

data/src/MarkupParser.hpp

@@ -54,8 +54,8 @@ namespace Gosu
         void flush_to_consumer();
 
     public:
-        MarkupParser(const char* markup, unsigned base_flags, bool split_words,
+        MarkupParser(unsigned base_flags, bool split_words,
                      std::function<void (std::vector<FormattedString>)> consumer);
-        void parse();
+        void parse(const std::string& markup);
     };
 }

data/src/Resolution.cpp

@@ -1,86 +1,117 @@
-#include <Gosu/Gosu.hpp>
+#include <Gosu/Platform.hpp>
+#ifndef GOSU_IS_IPHONE // iPhone definitions live in WindowUIKit.cpp
 
-#ifdef GOSU_IS_WIN
-#include <windows.h>
+#include <Gosu/Window.hpp>
+#include "GraphicsImpl.hpp"
+#include <SDL.h>
 
-// On Windows, do not use the SDL 2 code below. It reports 2560x1920 in my Windows VM, which is
-// running at 2560x1080. (SDL 2.0.3)
+static SDL_DisplayMode display_mode(Gosu::Window* window)
+{
+    static struct VideoSubsystem {
+        VideoSubsystem()  { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+        ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
+    } subsystem;
+    
+    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    SDL_DisplayMode result;
+    SDL_GetDesktopDisplayMode(index, &result);
+    return result;
+}
 
-unsigned Gosu::screen_width()
+unsigned Gosu::screen_width(Window* window)
 {
-    return GetSystemMetrics(SM_CXSCREEN);
+    return display_mode(window).w;
 }
 
-unsigned Gosu::screen_height()
+unsigned Gosu::screen_height(Window* window)
 {
-    return GetSystemMetrics(SM_CYSCREEN);
+    return display_mode(window).h;
 }
 
-static SIZE calculate_available_size()
+#ifdef GOSU_IS_MAC
+#import <AppKit/AppKit.h>
+
+static NSSize max_window_size(Gosu::Window* window)
+{
+    // Keep in sync with SDL_cocoawindow.m.
+    auto style = NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSWindowStyleMaskMiniaturizable;
+
+    auto index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    auto screen_frame = NSScreen.screens[index].visibleFrame;
+    return [NSWindow contentRectForFrameRect:screen_frame styleMask:style].size;
+}
+
+unsigned Gosu::available_width(Window* window)
+{
+    return max_window_size(window).width;
+}
+
+unsigned Gosu::available_height(Window* window)
+{
+    return max_window_size(window).height;
+}
+#endif
+
+#ifdef GOSU_IS_WIN
+#include <windows.h>
+#include <SDL_syswm.h>
+
+static SIZE max_window_size(Gosu::Window* window)
 {
     RECT work_area;
-    SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+    
+    if (window == nullptr) {
+        // Easy case: Return the work area of the primary monitor.
+        SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
+    } else {
+        // Return the work area of the monitor the window is on.
+        SDL_SysWMinfo wm_info;
+        SDL_VERSION(&wm_info.version);
+        SDL_GetWindowWMInfo(Gosu::shared_window(), &wm_info);
+        HMONITOR monitor = MonitorFromWindow(wm_info.info.win.window, MONITOR_DEFAULTTONEAREST);
+        
+        MONITORINFO monitor_info;
+        monitor_info.cbSize = sizeof(monitor_info);
+        GetMonitorInfo(monitor, &monitor_info);
+        work_area = monitor_info.rcWork;
+    }
     
     RECT window_size = work_area;
-    // Note: This should be kept in sync with STYLE_NORMAL in SDL_windowswindow.c.
+    // Keep in sync with STYLE_NORMAL in SDL_windowswindow.c.
     DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
     AdjustWindowRectEx(&window_size, style, FALSE, 0);
     
+    // Because AdjustWindowRectEx will make our rect larger, not smaller, we need to perform some
+    // unintuitive math here.
     SIZE size;
     size.cx = 2 * (work_area.right - work_area.left) - (window_size.right - window_size.left);
     size.cy = 2 * (work_area.bottom - work_area.top) - (window_size.bottom - window_size.top);
     return size;
 }
 
-static SIZE available_size = calculate_available_size();
-
-unsigned Gosu::available_width()
-{
-    return available_size.cx;
-}
-
-unsigned Gosu::available_height()
-{
-    return available_size.cy;
-}
-#elif !defined(GOSU_IS_IPHONE)
-#include <SDL.h>
-
-static SDL_DisplayMode current_display_mode = { 0, 0 };
-
-unsigned Gosu::screen_width()
+unsigned Gosu::available_width(Window* window)
 {
-    // TODO - not thread-safe
-    if (current_display_mode.w == 0) {
-        SDL_Init(SDL_INIT_VIDEO);
-        SDL_GetDisplayMode(0, 0, &current_display_mode);
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-    }
-    return current_display_mode.w;
+    return max_window_size(window).cx;
 }
 
-unsigned Gosu::screen_height()
+unsigned Gosu::available_height(Window* window)
 {
-    // TODO - not thread-safe
-    if (current_display_mode.h == 0) {
-        SDL_Init(SDL_INIT_VIDEO);
-        SDL_GetDisplayMode(0, 0, &current_display_mode);
-        SDL_QuitSubSystem(SDL_INIT_VIDEO);
-    }
-    return current_display_mode.h;
+    return max_window_size(window).cy;
 }
+#endif
 
+#ifdef GOSU_IS_X
 // Pessimistic fallback implementation for available_width / available_height.
-
-#if !defined(GOSU_IS_MAC)
-unsigned Gosu::available_width()
+// TODO: Look at this NET_WORKAREA based implementation: https://github.com/glfw/glfw/pull/989/files
+unsigned Gosu::available_width(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_width() * 0.9);
+    return static_cast<unsigned>(Gosu::screen_width(window) * 0.9);
 }
 
-unsigned Gosu::available_height()
+unsigned Gosu::available_height(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_height() * 0.8);
+    return static_cast<unsigned>(Gosu::screen_height(window) * 0.8);
 }
 #endif
+
 #endif

data/src/RubyGosu.cxx

@@ -2786,6 +2786,7 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_0(Gosu::Window &window,std::string co
     }
 SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
         std::string font_name = Gosu::default_font_name();
+        unsigned font_flags = 0;
         
         if (options) {
             Check_Type(options, T_HASH);
@@ -2802,7 +2803,15 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
                     VALUE rb_string = rb_obj_as_string(value);
                     font_name = StringValueCStr(rb_string);
                 }
-                // TODO - would be nice & trivial to support :bold => false and :italic => true here
+                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 {
                     static bool issued_warning = false;
                     if (!issued_warning) {
@@ -2813,7 +2822,15 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
             }
         }
         
-        return new Gosu::Font(height, font_name);
+        return new Gosu::Font(height, font_name, font_flags);
+    }
+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");
+      }
+      return self->markup_width(markup) * scale_x;
     }
 SWIGINTERN Gosu::Image *new_Gosu_Image(VALUE source,VALUE options=0){
         Gosu::Bitmap bmp;
@@ -2877,12 +2894,13 @@ 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 &text,int font_height,VALUE options=0){
+SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &markup,double font_height,VALUE options=0){
         std::string font = Gosu::default_font_name();
-        int width = 0;
-        int spacing = 0;
+        int width = -1;
+        double spacing = 0;
         Gosu::Alignment align = Gosu::AL_LEFT;
-        unsigned flags = 0;
+        unsigned image_flags = 0;
+        unsigned font_flags = 0;
         
         if (options) {
             Check_Type(options, T_HASH);
@@ -2898,6 +2916,15 @@ SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,int font_he
                 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);
 
@@ -2922,10 +2949,10 @@ SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,int font_he
                     width = NUM2INT(value);
                 }
                 else if (!strcmp(key_string, "spacing")) {
-                    spacing = NUM2INT(value);
+                    spacing = NUM2DBL(value);
                 }
                 else if (!strcmp(key_string, "retro")) {
-                    if (RTEST(value)) flags |= Gosu::IF_RETRO;
+                    if (RTEST(value)) image_flags |= Gosu::IF_RETRO;
                 }
                 else {
                     static bool issued_warning = false;
@@ -2937,14 +2964,9 @@ SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,int font_he
             }
         }
         
-        Gosu::Bitmap bitmap;
-        if (width == 0) {
-            bitmap = Gosu::create_text(text, font, font_height);
-        }
-        else {
-            bitmap = Gosu::create_text(text, font, font_height, spacing, width, align);
-        }
-        return new Gosu::Image(bitmap, flags);
+        Gosu::Bitmap bitmap = Gosu::layout_markup(markup, font, font_height, spacing, width,
+                                                  align, font_flags);
+        return new Gosu::Image(bitmap, image_flags);
     }
 SWIGINTERN std::vector< Gosu::Image > Gosu_Image_load_tiles__SWIG_0(VALUE source,int tile_width,int tile_height,VALUE options=0){
         Gosu::Bitmap bmp;
@@ -5193,63 +5215,7 @@ 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 ;
-  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 const *","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 const *)arg1)->text_width((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_draw(int argc, VALUE *argv, VALUE self) {
+_wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   std::string *arg2 = 0 ;
   double arg3 ;
@@ -5278,46 +5244,46 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
   }
   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", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_markup", 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", 2, argv[0] )); 
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_markup", 2, argv[0] )); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw", 2, argv[0])); 
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_markup", 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", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_markup", 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", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_markup", 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", 5, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_markup", 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", 6, argv[4] ));
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_markup", 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", 7, argv[5] ));
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_markup", 7, argv[5] ));
     } 
     arg7 = static_cast< double >(val7);
   }
@@ -5362,7 +5328,7 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      ((Gosu::Font const *)arg1)->draw((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+      ((Gosu::Font const *)arg1)->draw_markup((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
@@ -5377,7 +5343,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
+_wrap_Font_draw_markup_rel(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   std::string *arg2 = 0 ;
   double arg3 ;
@@ -5412,56 +5378,56 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
   }
   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_rel", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_markup_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_rel", 2, argv[0] )); 
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_markup_rel", 2, argv[0] )); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_rel", 2, argv[0])); 
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_markup_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_rel", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_markup_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_rel", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_markup_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_rel", 5, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_markup_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_rel", 6, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_markup_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_rel", 7, argv[5] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_markup_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_rel", 8, argv[6] ));
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","draw_markup_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_rel", 9, argv[7] ));
+      SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","draw_markup_rel", 9, argv[7] ));
     } 
     arg9 = static_cast< double >(val9);
   }
@@ -5506,7 +5472,7 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      ((Gosu::Font const *)arg1)->draw_rel((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+      ((Gosu::Font const *)arg1)->draw_markup_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());
@@ -5521,200 +5487,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Font_draw_rot(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) 1 ;
-  double arg8 = (double) 1 ;
-  Gosu::Color arg9 = (Gosu::Color) Gosu::Color::WHITE ;
-  Gosu::AlphaMode arg10 = (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 ;
-  
-  if ((argc < 5) || (argc > 9)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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_rot", 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_rot", 2, argv[0] )); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_rot", 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_rot", 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_rot", 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_rot", 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_rot", 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_rot", 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_rot", 8, argv[6] ));
-    } 
-    arg8 = static_cast< double >(val8);
-  }
-  if (argc > 7) {
-    {
-      if (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) {
-        arg9 = Gosu::Color(NUM2ULONG(argv[7]));
-      }
-      else {
-        void* ptr;
-        int res = SWIG_ConvertPtr(argv[7], &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 {
-          arg9 = *reinterpret_cast<Gosu::Color*>(ptr);
-        }
-      }
-    }
-  }
-  if (argc > 8) {
-    {
-      const char* cstr = Gosu::cstr_from_symbol(argv[8]);
-      
-      if (!strcmp(cstr, "default")) {
-        arg10 = Gosu::AM_DEFAULT;
-      }
-      else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
-        arg10 = Gosu::AM_ADD;
-      }
-      else if (!strcmp(cstr, "multiply")) {
-        arg10 = Gosu::AM_MULTIPLY;
-      }
-      else {
-        SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
-          ":multiply)");
-      }
-    }
-  }
-  {
-    try {
-      ((Gosu::Font const *)arg1)->draw_rot((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
-    }
-    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_set_image__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
-  std::string arg2 ;
-  unsigned int arg3 ;
-  Gosu::Image *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
-  void *argp4 ;
-  int res4 = 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_Gosu__Font, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","set_image", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
-  {
-    std::string *ptr = (std::string *)0;
-    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
-    if (!SWIG_IsOK(res) || !ptr) {
-      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","set_image", 2, argv[0] )); 
-    }
-    arg2 = *ptr;
-    if (SWIG_IsNewObj(res)) delete ptr;
-  }
-  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","set_image", 3, argv[1] ));
-  } 
-  arg3 = static_cast< unsigned int >(val3);
-  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Gosu__Image,  0 );
-  if (!SWIG_IsOK(res4)) {
-    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Gosu::Image const &","set_image", 4, argv[2] )); 
-  }
-  if (!argp4) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Image const &","set_image", 4, argv[2])); 
-  }
-  arg4 = reinterpret_cast< Gosu::Image * >(argp4);
-  {
-    try {
-      (arg1)->set_image(arg2,arg3,(Gosu::Image const &)*arg4);
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Font_set_image__SWIG_1(int argc, VALUE *argv, VALUE self) {
+_wrap_Font_set_image(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   std::string arg2 ;
   Gosu::Image *arg3 = 0 ;
@@ -5762,69 +5535,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_Font_set_image(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 == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Font, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        void *vptr = 0;
-        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Gosu__Image, 0);
-        _v = SWIG_CheckState(res);
-        if (_v) {
-          return _wrap_Font_set_image__SWIG_1(nargs, args, self);
-        }
-      }
-    }
-  }
-  if (argc == 4) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Font, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          void *vptr = 0;
-          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Gosu__Image, 0);
-          _v = SWIG_CheckState(res);
-          if (_v) {
-            return _wrap_Font_set_image__SWIG_0(nargs, args, self);
-          }
-        }
-      }
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 5, "Font.set_image", 
-    "    void Font.set_image(std::string codepoint, unsigned int font_flags, Gosu::Image const &image)\n"
-    "    void Font.set_image(std::string codepoint, Gosu::Image const &image)\n");
-  
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_new_Font__SWIG_0(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
@@ -5960,31 +5670,87 @@ SWIGINTERN VALUE _wrap_new_Font(int nargs, VALUE *args, VALUE self) {
       }
     }
   }
-  if (argc == 3) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
-      _v = SWIG_CheckState(res);
-      if (_v) {
-        {
-          int res = SWIG_AsVal_int(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_new_Font__SWIG_0(nargs, args, self);
-        }
-      }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Font__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "Font.new", 
+    "    Font.new(Gosu::Window &window, std::string const &font_name, int height)\n"
+    "    Font.new(int height, VALUE options)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Font_markup_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 *","markup_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 &","markup_width", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","markup_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","markup_width", 3, argv[1] ));
+    } 
+    arg3 = static_cast< double >(val3);
+  }
+  {
+    try {
+      result = (double)Gosu_Font_markup_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:
-  Ruby_Format_OverloadedError( argc, 3, "Font.new", 
-    "    Font.new(Gosu::Window &window, std::string const &font_name, int height)\n"
-    "    Font.new(int height, VALUE options)\n");
-  
+  if (SWIG_IsNewObj(res2)) delete arg2;
   return Qnil;
 }
 
@@ -7129,10 +6895,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
   std::string *arg1 = 0 ;
-  int arg2 ;
+  double arg2 ;
   VALUE arg3 = (VALUE) 0 ;
   int res1 = SWIG_OLDOBJ ;
-  int val2 ;
+  double val2 ;
   int ecode2 = 0 ;
   Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
@@ -7151,11 +6917,11 @@ _wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
     }
     arg1 = ptr;
   }
-  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu_Image_from_text", 2, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu_Image_from_text", 2, argv[1] ));
   } 
-  arg2 = static_cast< int >(val2);
+  arg2 = static_cast< double >(val2);
   if (argc > 2) {
     arg3 = argv[2];
   }
@@ -8881,98 +8647,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_screen_width(int argc, VALUE *argv, VALUE self) {
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  {
-    try {
-      result = (unsigned int)Gosu::screen_width();
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_screen_height(int argc, VALUE *argv, VALUE self) {
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  {
-    try {
-      result = (unsigned int)Gosu::screen_height();
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_available_width(int argc, VALUE *argv, VALUE self) {
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  {
-    try {
-      result = (unsigned int)Gosu::available_width();
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_available_height(int argc, VALUE *argv, VALUE self) {
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  {
-    try {
-      result = (unsigned int)Gosu::available_height();
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 static swig_class SwigClassWindow;
 
 SWIGINTERN VALUE
@@ -10235,6 +9909,138 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_screen_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","Gosu::screen_width", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::screen_width(arg1);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_screen_height(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","Gosu::screen_height", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::screen_height(arg1);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_available_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","Gosu::available_width", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::available_width(arg1);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_available_height(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","Gosu::available_height", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::available_height(arg1);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_char_to_button_id(int argc, VALUE *argv, VALUE self) {
   std::string arg1 ;
@@ -11864,8 +11670,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "VERSION", SWIG_From_std_string(static_cast< std::string >(Gosu::VERSION)));
   rb_define_const(mGosu, "LICENSES", SWIG_From_std_string(static_cast< std::string >(Gosu::LICENSES)));
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(0)));
-  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(13)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(3)));
+  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(14)));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(0)));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
   rb_define_module_function(mGosu, "degrees_to_radians", VALUEFUNC(_wrap_degrees_to_radians), -1);
@@ -11923,11 +11729,10 @@ 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, "text_width", VALUEFUNC(_wrap_Font_text_width), -1);
-  rb_define_method(SwigClassFont.klass, "draw", VALUEFUNC(_wrap_Font_draw), -1);
-  rb_define_method(SwigClassFont.klass, "draw_rel", VALUEFUNC(_wrap_Font_draw_rel), -1);
-  rb_define_method(SwigClassFont.klass, "draw_rot", VALUEFUNC(_wrap_Font_draw_rot), -1);
+  rb_define_method(SwigClassFont.klass, "draw_markup", VALUEFUNC(_wrap_Font_draw_markup), -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, "markup_width", VALUEFUNC(_wrap_Font_markup_width), -1);
   SwigClassFont.mark = 0;
   SwigClassFont.destroy = (void (*)(void *)) free_Gosu_Font;
   SwigClassFont.trackObjects = 1;
@@ -12252,10 +12057,6 @@ SWIGEXPORT void Init_gosu(void) {
   SwigClassTextInput.mark = 0;
   SwigClassTextInput.destroy = (void (*)(void *)) free_Gosu_TextInput;
   SwigClassTextInput.trackObjects = 1;
-  rb_define_module_function(mGosu, "screen_width", VALUEFUNC(_wrap_screen_width), -1);
-  rb_define_module_function(mGosu, "screen_height", VALUEFUNC(_wrap_screen_height), -1);
-  rb_define_module_function(mGosu, "available_width", VALUEFUNC(_wrap_available_width), -1);
-  rb_define_module_function(mGosu, "available_height", VALUEFUNC(_wrap_available_height), -1);
   rb_define_module_function(mGosu, "disown_Window", VALUEFUNC(_wrap_disown_Window), -1);
   
   SwigClassWindow.klass = rb_define_class_under(mGosu, "Window", rb_cObject);
@@ -12295,6 +12096,10 @@ SWIGEXPORT void Init_gosu(void) {
   SwigClassWindow.mark = (void (*)(void *)) mark_window;
   SwigClassWindow.destroy = (void (*)(void *)) free_Gosu_Window;
   SwigClassWindow.trackObjects = 1;
+  rb_define_module_function(mGosu, "screen_width", VALUEFUNC(_wrap_screen_width), -1);
+  rb_define_module_function(mGosu, "screen_height", VALUEFUNC(_wrap_screen_height), -1);
+  rb_define_module_function(mGosu, "available_width", VALUEFUNC(_wrap_available_width), -1);
+  rb_define_module_function(mGosu, "available_height", VALUEFUNC(_wrap_available_height), -1);
   rb_define_module_function(mGosu, "char_to_button_id", VALUEFUNC(_wrap_char_to_button_id), -1);
   rb_define_module_function(mGosu, "button_id_to_char", VALUEFUNC(_wrap_button_id_to_char), -1);
   rb_define_module_function(mGosu, "button_down?", VALUEFUNC(_wrap_button_downq___), -1);