SDLRuby 0.1.0

data/lib/SDLRuby/surface/surface_renderer.rb

@@ -0,0 +1,26 @@
+module SDLRuby
+  class Surface
+    module SurfaceRenderer
+      include SDL
+
+      # サーフェス用のレンダラーは複数作ることができる。
+      # また、サーフェス側からはそれが見えない。
+      # サーフェスのインスタンスごとにレンダラーを保持する。
+      # そのためテクスチャーの共有ができない。
+      # このケースはサーフェスインスタンスをdup, cloneした時のみだろう。
+      # この分離が認められない場合は、サーフェス側のポインターの中にレンダラーを埋め込む。
+      #
+
+      def init_renderer(*)
+        ptr = SDL.SDL_CreateSoftwareRenderer(self)
+        raise SDLError if ptr.null?
+        ptr.free = SDL_DESTROY_RENDERER
+        @renderer = ptr
+      end
+
+      private def renderer = @renderer ||= init_renderer
+
+      def destroy_renderer = @renderer = @renderer.call_free
+    end
+  end
+end

data/lib/SDLRuby/surface.rb

@@ -0,0 +1,179 @@
+require_relative 'palette'
+require_relative 'pixel_formatter'
+require_relative 'renderer'
+require_relative 'surface/pixel_format'
+require_relative 'surface/surface_renderer'
+
+module SDLRuby
+  class Surface
+    include PixelFormatter, Renderer, SDL, SurfaceRenderer
+    extend Forwardable
+
+    class << self
+      include SDL
+
+      def load(src)
+        ptr = SDL.SDL_LoadBMP_RW(SDL.SDL_RWFromFile(src, "rb"), 1)
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+
+      def create(width, height, format = SDL_PIXELFORMAT_ARGB8888)
+        ptr = SDL.SDL_CreateRGBSurfaceWithFormat(0, width, height, 0, format)
+        raise SDLError if ptr.null?
+
+        new(ptr)
+      end
+    end
+
+    def initialize(ptr, add_ref: nil)
+      @st = SDL_Surface.new(ptr, SDL_FREE_SURFACE)
+      @st.refcount += 1 if add_ref
+
+      @format = PixelFormat.new(@st.format, add_ref: true)
+    end
+
+    def_delegators :@st, :h, :pitch, :refcount, :to_ptr, :w
+    def_delegators :@format, :format, :palette
+
+    def palette=(pal)
+      @format.palette = pal
+    end
+
+    def ==(other) = other.respond_to?(:to_ptr) && @st.to_ptr == other.to_ptr
+
+    def alpha_mod
+      a = SDL.tmp_value("Uint8")
+      err = SDL.SDL_GetSurfaceAlphaMod(self, a)
+      raise SDLError if err < 0
+      a.value
+    end
+
+    def alpha_mod=(n)
+      err = SDL.SDL_SetSurfaceAlphaMod(self, n)
+      raise SDLError if err < 0
+    end
+
+    def blend_mode
+      a = SDL.tmp_value("int")
+      err = SDL.SDL_GetSurfaceBlendMode(self, a)
+      raise SDLError if err < 0
+      a.value
+    end
+
+    def blend_mode=(blend)
+      err = SDL.SDL_SetSurfaceBlendMode(self, blend)
+      raise SDLError if err < 0
+    end
+
+    def blit(src, src_rect: nil, dst_rect: nil)
+      src_r &&= Rect[*src_rect]
+      dst_r &&= Rect[*dst_rect]
+
+      # src, dstのrectサイズが一致している場合、内部でSDL_BlitSurfaceを呼び出している。
+      # Blit, BlitScaled 呼び出しの分岐は不要。
+      #
+      err = SDL.SDL_UpperBlitScaled(src, src_r, self, dst_r)
+      raise SDLError if err < 0
+    end
+
+    def clear(color)
+      err = SDL.SDL_FillRect(self, nil, @format.to_pixel(color))
+      raise SDLError if err < 0
+    end
+
+    def clip
+      r = Rect[]
+      SDL.SDL_GetClipRect(self, r)
+      r.to_a
+    end
+
+    def clip=(rect)
+      SDL.SDL_SetClipRect(self, Rect[*rect])
+    end
+
+    def color_key
+      v = SDL.tmp_value("Uint32")
+      err = SDL.SDL_GetColorKey(self, v)
+      raise SDLError if err < 0
+
+      @format.to_color(v.value)
+    end
+
+    def color_key=(color)
+      err = if color
+              SDL.SDL_SetColorKey(self, 1, @format.to_pixel(color))
+            else
+              SDL.SDL_SetColorKey(self, 0, 0)
+            end
+      raise SDLError if err < 0
+    end
+
+    def color_key? = SDL.SDL_HasColorKey(self) == 1
+
+    def color_mod
+      r, g, b = SDL.tmp_value("Uint8", "Uint8", "Uint8")
+      err = SDL.SDL_GetSurfaceColorMod(self, r, g, b)
+      raise SDLError if err < 0
+
+      [r.value, g.value, b.value]
+    end
+
+    def color_mod=(color)
+      r, g, b = *color
+      err = SDL.SDL_SetSurfaceColorMod(self, r, g, b)
+      raise SDLError if err < 0
+    end
+
+    def fill(color, *i)
+      size = f.count
+      count = size / 4
+      raise ArgumentError if count.zero? || (size % 4).nonzero?
+      ptr = i.pack("i*")
+
+      err = SDL.SDL_FillRects(self, ptr, count, @format.to_pixel(color))
+      raise SDLError if err < 0
+    end
+
+    def lock
+      err = SDL.SDL_LockSurface(self)
+      raise SDLError if err < 0
+    end
+
+    def rle? = SDL.SDL_HasSurfaceRLE(self) != 0
+
+    def rle=(b)
+      err = SDL.SDL_SetSurfaceRLE(self, b ? 1 : 0)
+      raise SDLError if err < 0
+    end
+
+    def save(file)
+      err = SDL.SDL_SaveBMP_RW(self, SDL.SDL_RWFromFile(src, "rb"), 1)
+      raise SDLError if err < 0
+    end
+
+    def size = [w, h]
+
+    def synchronize(&)
+      lock
+      begin
+        yield
+      ensure
+        unlock
+      end
+    end
+
+    def to_s = synchronize { @st.pixels.to_str(h * pitch) }
+
+    def to_surface(format = nil)
+      return self unless format
+
+      ptr = SDL.SDL_ConvertSurface(self, format, 0)
+      raise SDLError if ptr.null?
+      Surface.new(ptr)
+    end
+
+    def unlock = SDL.SDL_UnlockSurface(self)
+  end
+end

data/lib/SDLRuby/text_input.rb

@@ -0,0 +1,38 @@
+module SDLRuby
+  module TextInput
+    class << self
+      include SDL
+
+      # テキスト入力イベントが有効かチェックする
+      def active? = SDL.SDL_IsTextInputActive != 0
+
+      # コンポジションウィンドウ/IMEをIMEを無効化せずに閉じる
+      #
+      def hide = SDL.SDL_ClearComposition
+
+      # テキスト入力で使う領域を設定する
+      # ※ 表示はされるが指定が行われない。調査が必要。
+      # もし指定ができないのならば show メソッドに名前を変えた方が良い。
+      # NOTICE:
+      # システムの IMEウィンドウを使う場合はSDL_HINT_IME_SHOW_UIヒントを1に設定する。
+      # これはウィンドウの生成前に行う必要がある。※SDL_Initの後でも問題はない。
+      #
+      def rect=(rect)
+        SDL.SDL_SetTextInputRect(Rect[*rect])
+      end
+
+      # 環境がスクリーンキーボードに対応しているかチェックする
+      def screen_keyboard_supported? = SDL.SDL_HasScreenKeyboardSupport != 0
+
+      # スクリーンキーボードが指定のウィンドウに表示されているかチェックする
+      def screen_keyboard_shown?(window) = SDL.SDL_IsScreenKeyboardShown(window) != 0
+
+      # IMEコンポジット(変換中ウィンドウ・矩形)または変換候補が現在表示されているかを戻す
+      def shown? = SDL.SDL_IsTextInputShown != 0
+
+      def start = SDL.SDL_StartTextInput
+
+      def stop = SDL.SDL_StopTextInput
+    end
+  end
+end

data/lib/SDLRuby/texture.rb

@@ -0,0 +1,93 @@
+module SDLRuby
+  class Texture
+    require_relative 'pixel_formatter'
+
+    include PixelFormatter, SDL
+
+    attr_reader :format, :h, :w
+
+    def initialize(ptr)
+      ptr.free = SDL_DESTROY_TEXTURE
+      @ptr = ptr
+
+      query
+    end
+
+    def alpha_mod
+      v = SDL.tmp_value("Uint8")
+      err = SDL.SDL_GetTextureAlphaMod(self, v)
+      raise SDLError if err < 0
+
+      v.value
+    end
+
+    def alpha_mod=(n)
+      err = SDL.SDL_SetTextureAlphaMod(self, n)
+      raise SDLError if err < 0
+    end
+
+    def blend_mode
+      v = SDL.tmp_value("int")
+      err = SDL.SDL_GetTextureBlendMode(self, v)
+      raise SDLError if err < 0
+
+      v.value
+    end
+
+    def blend_mode=(n)
+      err = SDL.SDL_SetTextureBlendMode(self, n)
+      raise SDLError if err < 0
+    end
+
+    def color_mod
+      r, g, b = SDL.tmp_value("Uint8", "Uint8", "Uint8")
+      err = SDL.SDL_GetTextureColorMod(self, r, g, b)
+      raise SDLError if err < 0
+
+      [r.value, g.value, b.value]
+    end
+
+    def color_mod=(color)
+      r, g, b = *color
+      err = SDL.SDL_SetTextureColorMod(self, r, g, b)
+      raise SDLError if err < 0
+    end
+
+    private def query
+      format, access, w, h = SDL.tmp_value("Uint32", "int", "int", "int")
+      err = SDL.SDL_QueryTexture(@ptr, format, access, w, h)
+      raise SDLError if err < 0
+
+      @format = format.value
+      @access = access.value
+      @w = w.value
+      @h = h.value
+    end
+
+    def scale_mode
+      v = SDL.tmp_value("int")
+      err = SDL.SDL_GetTextureScaleMode(self, v)
+      raise SDLError if err < 0
+
+      v.value
+    end
+
+    def scale_mode=(n)
+      err = SDL.SDL_SetTextureScaleMode(self, n)
+      raise SDLError if err < 0
+    end
+
+    def size = [@w, @h]
+
+    def to_ptr = @ptr
+
+    def to_surface
+      ptr = SDL.tmp_value("void*")
+      err = SDL.SDL_LockTextureToSurface(self, nil, ptr)
+      raise SDLError if err < 0
+      SDL.SDL_UnlockTexture(self)
+
+      Surface.new(ptr.value)
+    end
+  end
+end

data/lib/SDLRuby/ttf/include/SDL_ttf.h.rb

@@ -0,0 +1,54 @@
+module SDLRuby::TTF
+  typealias "TTF_Font", "struct _TTF_Font"
+  typealias "TTF_Direction", "int"
+  extern "const SDL_version * TTF_Linked_Version(void)"
+  extern "void TTF_GetFreeTypeVersion(int *major, int *minor, int *patch)"
+  extern "void TTF_GetHarfBuzzVersion(int *major, int *minor, int *patch)"
+  extern "void TTF_ByteSwappedUNICODE(SDL_bool swapped)"
+  extern "int TTF_Init(void)"
+  extern "TTF_Font * TTF_OpenFont(const char *file, int ptsize)"
+  extern "TTF_Font * TTF_OpenFontIndex(const char *file, int ptsize, long index)"
+  extern "TTF_Font * TTF_OpenFontRW(SDL_RWops *src, int freesrc, int ptsize)"
+  extern "TTF_Font * TTF_OpenFontIndexRW(SDL_RWops *src, int freesrc, int ptsize, long index)"
+  extern "TTF_Font * TTF_OpenFontDPI(const char *file, int ptsize, unsigned int hdpi, unsigned int vdpi)"
+  extern "TTF_Font * TTF_OpenFontIndexDPI(const char *file, int ptsize, long index, unsigned int hdpi, unsigned int vdpi)"
+  extern "TTF_Font * TTF_OpenFontDPIRW(SDL_RWops *src, int freesrc, int ptsize, unsigned int hdpi, unsigned int vdpi)"
+  extern "TTF_Font * TTF_OpenFontIndexDPIRW(SDL_RWops *src, int freesrc, int ptsize, long index, unsigned int hdpi, unsigned int vdpi)"
+  extern "int TTF_SetFontSize(TTF_Font *font, int ptsize)"
+  extern "int TTF_SetFontSizeDPI(TTF_Font *font, int ptsize, unsigned int hdpi, unsigned int vdpi)"
+  extern "int TTF_GetFontStyle(const TTF_Font *font)"
+  extern "void TTF_SetFontStyle(TTF_Font *font, int style)"
+  extern "int TTF_GetFontOutline(const TTF_Font *font)"
+  extern "void TTF_SetFontOutline(TTF_Font *font, int outline)"
+  extern "int TTF_GetFontHinting(const TTF_Font *font)"
+  extern "void TTF_SetFontHinting(TTF_Font *font, int hinting)"
+  extern "int TTF_GetFontWrappedAlign(const TTF_Font *font)"
+  extern "void TTF_SetFontWrappedAlign(TTF_Font *font, int align)"
+  extern "int TTF_FontHeight(const TTF_Font *font)"
+  extern "int TTF_FontAscent(const TTF_Font *font)"
+  extern "int TTF_FontDescent(const TTF_Font *font)"
+  extern "int TTF_FontLineSkip(const TTF_Font *font)"
+  extern "int TTF_GetFontKerning(const TTF_Font *font)"
+  extern "void TTF_SetFontKerning(TTF_Font *font, int allowed)"
+  extern "long TTF_FontFaces(const TTF_Font *font)"
+  extern "int TTF_FontFaceIsFixedWidth(const TTF_Font *font)"
+  extern "const char * TTF_FontFaceFamilyName(const TTF_Font *font)"
+  extern "const char * TTF_FontFaceStyleName(const TTF_Font *font)"
+  extern "int TTF_GlyphIsProvided32(TTF_Font *font, Uint32 ch)"
+  extern "int TTF_GlyphMetrics32(TTF_Font *font, Uint32 ch, int *minx, int *maxx, int *miny, int *maxy, int *advance)"
+  extern "int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h)"
+  extern "int TTF_MeasureUTF8(TTF_Font *font, const char *text, int measure_width, int *extent, int *count)"
+  extern "SDL_Surface * TTF_RenderUTF8_Solid(TTF_Font *font, const char *text, SDL_Color fg)"
+  extern "SDL_Surface * TTF_RenderUTF8_Solid_Wrapped(TTF_Font *font, const char *text, SDL_Color fg, Uint32 wrapLength)"
+  extern "SDL_Surface * TTF_RenderUTF8_Shaded(TTF_Font *font, const char *text, SDL_Color fg, SDL_Color bg)"
+  extern "SDL_Surface * TTF_RenderUTF8_Shaded_Wrapped(TTF_Font *font, const char *text, SDL_Color fg, SDL_Color bg, Uint32 wrapLength)"
+  extern "SDL_Surface * TTF_RenderUTF8_Blended(TTF_Font *font, const char *text, SDL_Color fg)"
+  extern "SDL_Surface * TTF_RenderUTF8_Blended_Wrapped(TTF_Font *font, const char *text, SDL_Color fg, Uint32 wrapLength)"
+  extern "SDL_Surface * TTF_RenderUTF8_LCD(TTF_Font *font, const char *text, SDL_Color fg, SDL_Color bg)"
+  extern "SDL_Surface * TTF_RenderUTF8_LCD_Wrapped(TTF_Font *font, const char *text, SDL_Color fg, SDL_Color bg, Uint32 wrapLength)"
+  extern "void TTF_CloseFont(TTF_Font *font)"
+  extern "void TTF_Quit(void)"
+  extern "int TTF_WasInit(void)"
+  extern "int TTF_SetFontDirection(TTF_Font *font, TTF_Direction direction)"
+  extern "int TTF_SetFontScriptName(TTF_Font *font, const char *script)"
+end

data/lib/SDLRuby/ttf/ttf.rb

@@ -0,0 +1,41 @@
+module SDLRuby
+  module TTF
+    require_relative "include/SDL_ttf.h"
+
+    # ZERO WIDTH NO-BREAKSPACE (Unicode byte order mark)
+    #
+    UNICODE_BOM_NATIVE  = 0xFEFF
+    UNICODE_BOM_SWAPPED = 0xFFFE
+
+    # Font style flags
+    #
+    TTF_STYLE_NORMAL        = 0x00
+    TTF_STYLE_BOLD          = 0x01
+    TTF_STYLE_ITALIC        = 0x02
+    TTF_STYLE_UNDERLINE     = 0x04
+    TTF_STYLE_STRIKETHROUGH = 0x08
+
+    # Hinting flags
+    #
+    TTF_HINTING_NORMAL         = 0
+    TTF_HINTING_LIGHT          = 1
+    TTF_HINTING_MONO           = 2
+    TTF_HINTING_NONE           = 3
+    TTF_HINTING_LIGHT_SUBPIXEL = 4
+
+    # Special layout option for rendering wrapped text
+    #
+    TTF_WRAPPED_ALIGN_LEFT   = 0
+    TTF_WRAPPED_ALIGN_CENTER = 1
+    TTF_WRAPPED_ALIGN_RIGHT  = 2
+
+    # Direction flags
+    #
+    TTF_DIRECTION_LTR = 0
+    TTF_DIRECTION_RTL = 1
+    TTF_DIRECTION_TTB = 2
+    TTF_DIRECTION_BTT = 3
+
+    TTF_CLOSE_FONT = import_symbol("TTF_CloseFont").to_int
+  end
+end

data/lib/SDLRuby/ttf.rb

@@ -0,0 +1,54 @@
+require 'fiddle/import'
+
+module SDLRuby
+  module TTF
+    include SDL
+    extend Fiddle::Importer
+
+    dlload "SDL2_ttf"
+
+    typealias "Uint32", "uint32_t"
+    typealias "SDL_bool", "int"
+    typealias "SDL_Color", "void*"
+
+    require_relative 'ttf/ttf'
+
+    class << self
+      def byte_swapped_unicode=(b)
+        TTF.TTF_ByteSwappedUNICODE(b ? 1 : 0)
+      end
+
+      def free_type_version
+        major, minor, patch = SDL.tmp_value("int", "int", "int")
+        TTF.TTF_GetFreeTypeVersion(major, minor, patch)
+
+        "#{major}.#{minor}.#{patch}"
+      end
+
+      def harf_bazz_version
+        major, minor, patch = SDL.tmp_value("int", "int", "int")
+        TTF.TTF_GetHarfBuzzVersion(major, minor, patch)
+
+        "#{major}.#{minor}.#{patch}"
+      end
+
+      def init
+        return if init?
+        err = TTF.TTF_Init
+        raise SDLError if err < 0
+      end
+
+      # 初期化した回数を戻す。その回数分だけquitを呼ばなければならない。
+      #
+      def init? = TTF.TTF_WasInit.nonzero?
+
+      # 使用中のフォントがある場合、quitを呼ぶとフォントを閉じることができなくなる！
+      # これを呼び出す前に全てのフォントを閉じておくこと。
+      # しかし、Rubyがポインターを管理するためアプリケーションでは制御できないだろう・・・
+      #
+      def quit = TTF.TTF_Quit
+
+      def version = SDL_version.new(TTF.TTF_Linked_Version).to_a.join(".")
+    end
+  end
+end

data/lib/SDLRuby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SDLRuby
+  VERSION = "0.1.0"
+end

data/lib/SDLRuby/window/accessor.rb

@@ -0,0 +1,125 @@
+module SDLRuby
+  class Window
+    module Accessor
+      def boarder_size
+        t, l, b, r = SDL.tmp_value("int", "int", "int", "int")
+        err = SDL.SDL_GetWindowBordersSize(self, t, l, b, r)
+        raise SDLError if err < 0
+
+        [t.value, l.value, b.value, r.value]
+      end
+
+      def h
+        v = SDL.tmp_value("int")
+        SDL.SDL_GetWindowSize(self, nil, v)
+        v.value
+      end
+
+      def h=(n)
+        SDL.SDL_SetWindowSize(self, w, n)
+      end
+
+      def icon=(surface)
+        SDL.SDL_SetWindowIcon(self, surface)
+      end
+
+      def maximum_size
+        w, h = SDL.tmp_value("int", "int")
+        SDL.SDL_GetWindowMaximumSize(self, w, h)
+
+        [w.value, h.value]
+      end
+
+      def maximum_size=(wh)
+        SDL.SDL_SetWindowMaximumSize(self, *wh)
+      end
+
+      def minimum_size
+        w, h = SDL.tmp_value("int", "int")
+        SDL.SDL_GetWindowMinimumSize(self, w, h)
+
+        [w.value, h.value]
+      end
+
+      def minimum_size=(wh)
+        SDL.SDL_SetWindowMinimumSize(self, *wh)
+      end
+
+      def opacity
+        f = SDL.tmp_value("float")
+        err = SDL.SDL_GetWindowOpacity(self, f)
+        raise SDLError if err < 0
+
+        f.value
+      end
+
+      def opacity=(f)
+        err = SDL.SDL_SetWindowOpacity(self, f)
+        raise SDLError if err < 0
+      end
+
+      def pos
+        vx, vy = SDL.tmp_value("int", "int")
+        SDL.SDL_GetWindowPosition(self, vx, vy)
+        [vx.value, vy.value]
+      end
+
+      def pos=(xy)
+        SDL.SDL_SetWindowPosition(self, *xy)
+      end
+
+      def size
+        vw, vh = SDL.tmp_value("int", "int")
+        SDL.SDL_GetWindowSize(self, vw, vh)
+        [vw.value, vh.value]
+      end
+
+      def size=(wh)
+        SDL.SDL_SetWindowSize(self, *wh)
+      end
+
+      def size_in_pixels
+        vw, vh = SDL.tmp_value("int", "int")
+        SDL.SDL_GetWindowSizeInPixels(self, vw, vh)
+
+        [vw.value, vh.value]
+      end
+
+      def title = SDL.SDL_GetWindowTitle(self).to_s.force_encoding("UTF-8")
+
+      def title=(s)
+        SDL.SDL_SetWindowTitle(self, s.encode("UTF-8"))
+      end
+
+      def w
+        v = SDL.tmp_value("int")
+        SDL.SDL_GetWindowSize(self, v, nil)
+        v.value
+      end
+
+      def w=(n)
+        SDL.SDL_SetWindowSize(self, n, h)
+      end
+
+      def x
+        v = SDL.tmp_value("int")
+        SDL.SDL_GetWindowPosition(self, v, nil)
+        v.value
+      end
+
+      def x=(n)
+        SDL.SDL_SetWindowPosition(self, n, y)
+      end
+
+      def y
+        v = SDL.tmp_value("int")
+        SDL.SDL_GetWindowPosition(self, nil, v)
+        v.value
+      end
+
+      def y=(n)
+        SDL.SDL_SetWindowPosition(self, x, n)
+      end
+    end
+  end
+end

data/lib/SDLRuby/window/controller.rb

@@ -0,0 +1,53 @@
+module SDLRuby
+  class Window
+    module Controller
+      def always_on_top = SDL.SDL_SetWindowAlwaysOnTop(self)
+
+      def always_on_top? = flags & SDL_WINDOW_ALWAYS_ON_TOP != 0
+
+      def border=(obj)
+        SDL.SDL_SetWindowBordered(self, obj ? 1 : 0)
+      end
+
+      def borderless? = flags & SDL_WINDOW_BORDERLESS != 0
+
+      def fullscreen=(obj)
+        err = SDL.SDL_SetWindowFullscreen(self, obj ? SDL_WINDOW_FULLSCREEN : 0)
+        raise SDLError if err < 0
+      end
+
+      def fullscreen? = flags & SDL_WINDOW_FULLSCREEN != 0
+
+      def fullscreen_desktop=(obj)
+        err = SDL.SDL_SetWindowFullscreen(self, obj ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0)
+        raise SDLError if err < 0
+      end
+
+      def fullscreen_desktop? = flags & SDL_WINDOW_FULLSCREEN_DESKTOP != 0
+
+      def hide = SDL.SDL_HideWindow(self)
+
+      def hidden? = flags & SDL_WINDOW_HIDDEN != 0
+
+      def maximize = SDL.SDL_MaximizeWindow(self)
+
+      def maximized? = flags & SDL_WINDOW_MAXIMIZED != 0
+
+      def minimize = SDL.SDL_MinimizeWindow(self)
+
+      def minimized? = flags & SDL_WINDOW_MINIMIZED != 0
+
+      def resizable=(obj)
+        SDL.SDL_SetWindowResizable(self, obj ? 1 : 0)
+      end
+
+      def resizable? = flags & SDL_WINDOW_RESIZABLE != 0
+
+      def restore = SDL.SDL_RestoreWindow(self)
+
+      def show = SDL.SDL_ShowWindow(self)
+
+      def shown? = flags & SDL_WINDOW_SHOWN != 0
+    end
+  end
+end