rubysdl-mswin32-1.8 2.1.0.1

data/lib/sdl.rb

@@ -0,0 +1,224 @@
+#
+# Ruby/SDL   Ruby extension library for SDL
+#  Copyright (C) 2001-2007 Ohbayashi Ippei
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#  This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#  You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# 
+require 'sdl.so'
+require 'forwardable'
+
+module SDL
+  VERSION = "2.1.0"
+
+  class Surface
+    def put(surface,x,y)
+      SDL::Surface.blit(surface,0,0,surface.w,surface.h,self,x,y)
+    end
+
+    def copyRect(x,y,w,h)
+      format = self.format
+      flagbase=SDL::SWSURFACE|SDL::HWSURFACE|SDL::SRCCOLORKEY|SDL::SRCALPHA
+      alpha_flag = self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL)
+      self.setAlpha(0,format.alpha)
+      begin
+        new_surface=Surface.new(flagbase&self.flags,w,h,self)
+      ensure
+        self.setAlpha(alpha_flag,format.alpha)
+      end
+      SDL.blitSurface(self,x,y,w,h,new_surface,0,0)
+      new_surface.setColorKey(self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
+                              format.colorkey )
+      new_surface.setAlpha(self.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
+                           format.alpha )
+      return new_surface
+    end
+    
+    def self.new(*args)
+      case args.size
+      when 4
+        create(*args)
+      when 8
+        createWithFormat(*args)
+      else
+        raise ArgumentError,"must be SDL::Surface.new(flags,w,h,surface) or SDL::Surface.new(flags,w,h,depth,Rmask,Gmask,Bmask,Amask)"
+      end
+    end
+
+    
+  end
+
+  def color2int(color,format)
+    case color
+    when Integer
+      return color
+    when Array
+      return format.mapRGB(*color)
+    else
+      raise Error,'first argument must be Integer or Array'
+    end
+  end
+  module_function :color2int
+    
+  module Mouse
+    module_function
+
+    def setCursor(bitmap,white,black,transparent,inverted,hot_x=0,hot_y=0)
+      if bitmap.w % 8 != 0 then
+	raise SDL::Error,"width of cursor must be muliple of 8"
+      end
+
+      white=SDL.color2int(white,bitmap.format)
+      black=SDL.color2int(black,bitmap.format)
+      transparent=SDL.color2int(transparent,bitmap.format)
+      inverted=SDL.color2int(inverted,bitmap.format)
+      
+      data=[]
+      mask=[]
+
+      i=-1
+      for y in 0..(bitmap.h-1)
+	for x in 0..(bitmap.w-1)
+	  if x%8 == 0 then
+            i+=1
+	    data[i]=mask[i]=0
+          else
+	    data[i] <<= 1
+	    mask[i] <<= 1
+	  end
+
+	  case bitmap.getPixel(x,y)
+	  when white
+	    mask[i] |= 0x01
+	  when black
+	    data[i] |= 0x01
+	    mask[i] |= 0x01
+	  when transparent
+	    # do nothing 
+	  when inverted
+	    data[i] |= 0x01
+	  end
+	end
+      end
+
+      setCursor_imp data.pack('C*'),mask.pack('C*'),bitmap.w,bitmap.h,hot_x,hot_y
+    end
+    
+  end # of module Mouse
+
+  if defined?(CollisionMap)
+    def Surface.transformBlit(src, dst, angle, xscale, yscale,
+                              px, py, qx, qy, flags)
+      transformed = src.transformSurface(src.colorkey, angle,
+                                         xscale, yscale, flags)
+      transformed.setColorKey(src.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
+                              src.colorkey )
+      transformed.setAlpha(src.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
+                           src.alpha )
+      rad = Math::PI*angle / 180.0
+      x = px - src.w/2.0 ; y = py - src.h/2.0
+        x *= xscale ; y *= yscale
+      dst_x = x*Math.cos(rad)-y*Math.sin(rad) 
+      dst_y = x*Math.sin(rad)+y*Math.cos(rad) 
+      dst_x += transformed.w / 2
+      dst_y += transformed.h / 2
+      Surface.blit(transformed, 0, 0, 0, 0, dst, qx-dst_x, qy-dst_y)
+    end
+  end
+  
+  class CD
+    def in_drive?
+      status > 0
+    end
+  end
+  
+  module_function
+
+  Rect = Struct.new( :x, :y, :w, :h )
+  
+  def convertRect(rect)
+    case rect
+    when NilClass
+      return Rect.new( 0, 0, 0, 0 )
+    when Array
+      return Rect.new( rect[0], rect[1], rect[2], rect[3] )
+    else
+      return rect
+    end
+  end
+
+  # FIX:
+  def blitSurface2(src,srcRect,dst,dstRect)
+    srcR = convertRect(srcRect)
+    dstR = convertRect(dstRect)
+    blitSurface( src, srcR.x, srcR.y, srcR.w, srcR.h , dst, dstR.x, dstR.y )
+  end
+  
+  if defined?(Mixer)
+    class << Mixer
+      alias open_imp open
+      private :open_imp
+      def open(frequency=Mixer::DEFAULT_FREQUENCY,format=Mixer::DEFAULT_FORMAT,
+	       cannels=Mixer::DEFAULT_CHANNELS,chunksize=4096)
+	open_imp(frequency,format,cannels,chunksize)
+      end
+    end
+  end
+
+  if defined?(MPEG)
+  end
+  if defined?(TTF)
+    class TTF
+      define_draw = proc{|t, n|
+        args = (1..n).map{|k| "arg#{k}"}.join(",")
+        module_eval(<<-EOS)
+          def draw#{t}(dst, text, x, y, #{args})
+            image = render#{t}(text, #{args})
+            dst.put(image, x, y)
+            image.destroy
+          end
+        EOS
+      }
+
+      define_draw["SolidUTF8", 3]
+      define_draw["BlendedUTF8", 3]
+      define_draw["ShadedUTF8",6]
+      if method_defined?(:drawSolid)
+        define_draw["Solid",3]
+        define_draw["Blended", 3]
+        define_draw["Shaded", 6]
+      end
+    end
+  end
+end
+
+if defined?(GL) then
+  class << GL
+    alias Begin_imp Begin
+    private :Begin_imp
+    def Begin(mode)
+      if block_given? then
+	begin
+	  Begin_imp(mode)
+	  yield
+	ensure
+	  End()
+	end
+      else
+	Begin_imp(mode)
+      end
+    end
+  end
+end
+
+require 'rubysdl_aliases.rb'
+require 'rubysdl_compatible_ver1.rb'

data/rubysdl_doc_old.en.rd

@@ -0,0 +1,2181 @@
+=begin
+
+= SDL
+
+Interface of this lib is very close to SDL.
+So you also had better refer to SDL document.
+
+nAll classes/modules in Ruby/SDL are in "module SDL".
+In this module number starts 0,not 1.
+
+== Class/Module
+* ((<Error handling>))
+  * ((<SDL::Error>))
+* ((<initialize>))
+* ((<video>))
+  * ((<SDL::Surface>))
+    * ((<SDL::Screen>))
+  * ((<SDL::CollisionMap>))
+  * ((<SDL::PixelFormat>))
+* ((<Event handling>))
+  * ((<SDL::Event>))
+  * ((<SDL::Event2>))
+  * ((<SDL::Key>)) (module)
+  * ((<SDL::Mouse>)) (module) 
+* ((<audio>))
+  * ((<SDL::Mixer>)) (module)
+  * ((<SDL::Mixer::Wave>))
+  * ((<SDL::Mixer::Music>))
+* ((<Window Manager>))
+  * ((<SDL::WM>)) (module)
+* ((<CDROM>))
+  * ((<SDL::CD>))
+* ((<Joystick handling>))
+  * ((<SDL::Joystick>))
+* ((<Font handling>))
+  * ((<SDL::BMFont>))
+  * ((<SDL::Kanji>))
+  * ((<SDL::TTF>))
+* ((<MPEG stream>))
+  * ((<SDL::MPEG>))
+* ((<Time>))
+* ((<Japanese input method with SDLSKK>))
+  * ((<SDL::SKK::Context>))
+  * ((<SDL::SKK::Dictionary>))
+  * ((<SDL::SKK::RomKanaRuleTable>))
+  * ((<SDL::SKK::Keybind>))
+* ((<3D drawing with OpenGL>))
+* ((<Others>))
+
+== Error handling
+=== SDL::Error
+
+SDL::Error is exception class. Almost all of errors in Ruby/SDL are
+reported by this class.
+
+==== super class
+
+StandardError
+
+== initialize
+
+=== module functions in module SDL
+
+--- SDL.init(flag)
+      Initialize SDL. This should be called before all other SDL functions. The
+      flags parameter specifies what part(s) of SDL to initialize.
+        SDL::INIT_AUDIO  initialize audio output functions
+        SDL::INIT_VIDEO  initialize video output functions and input functions
+        SDL::INIT_CDROM  initialize CD playback fucntions
+        SDL::INIT_JOYSTICK  initialize joystick input functions
+      You should call this method before calling other Ruby/SDL methods.
+
+--- SDL.quit
+      Quit SDL system. You needn't call this function normally because
+      this library call this function automatically when the process 
+      stops.
+
+      
+--- SDL.initedSystem(flag)
+--- SDL.inited_system(flag)
+      Not documented yet
+
+--- SDL.getenv
+--- SDL.putenv(envstr)
+      Change or add an environment variable on Win32. On other platforms
+      this method is equal to ENV.
+      
+      ((|envstr|)) should be of the form "name=value".
+
+      Returns nil, raise exception `SDL::Error' when it fails.
+
+      You should use this method to set SDL_WINDOWID or SDL_VIDEODRIVER.
+== video
+
+some functions need SGE or SDL_image
+
+=== functions in module SDL
+
+--- SDL.getVideoSurface
+--- SDL.get_video_surface
+      Not documented yet
+
+--- SDL.setVideoMode(w,h,bpp,flags)
+--- SDL.set_video_mode(w,h,bpp,flags)
+      Set up a video mode with the specified width, height and bits-per-pixel.
+      If bpp is 0, it is treated as the current display bits per pixel.
+      Return the instanse of ((<SDL::Screen>)), if succeeded.
+      Raise SDL::Error, if failed.
+      * SDL::SWSURFACE
+        
+        Create the video surface in system memory.
+
+      * SDL::HWSURFACE
+
+        Create the video surface in video memory.
+
+      * SDL::FULLSCREEN
+
+        SDL will attempt to use a fullscreen mode.
+
+      * SDL::SDL_DOUBLEBUF
+
+        Enable double buffering.
+        Calling ((<SDL::Screen#flip>)) will flip the  buffers and update
+        the screen.
+
+--- SDL.checkVideoMode(w,h,bpp,flags)
+--- SDL.check_video_mode(w,h,bpp,flags)
+      Check to see if a particular video mode is supported.
+      Returns 0 if the requested mode is not supported under any
+      bit depth, or returns the bits-per-pixel of the closest available mode
+      with the given width, height and requested surface flags (see 
+      SDL_SetVideoMode).
+
+      The bits-per-pixel value returned is only a suggested mode. You can
+      usually request and bpp you want when setting the video mode and SDL will
+      emulate that color depth with a shadow video surface.
+      
+      The arguments to checkVideoMode are the same ones you would pass to
+      ((<SDL.setVideoMode>)).
+
+--- SDL.listModes(flags)
+--- SDL.list_modes(flags)
+      Returns availanel screen demensions for the given flags.
+      Returns nil if there are no available dimensions.
+      Returns true if any dimension is okay.
+      Otherwise returns list of available dimensions in array.
+
+--- SDL.videoDriverName
+--- SDL.video_driver_name
+      Returns the name of initialized video driver like "x11" or "windib".
+      Raise exeption if video have not been initialized.
+
+--- SDL.setGamma(redgamma,greengamma,bluegamma)
+--- SDL.set_gamma(redgamma,greengamma,bluegamma)
+      Sets the "gamma function" for the display of each color component.
+      Gamma controls the brightness/contrast of colors displayed on
+      the screen. A gamma value of 1.0 is identity
+      (i.e., no adjustment is made).
+
+--- SDL.getGammaRamp
+--- SDL.get_gamma_ramp
+      Returns the gamma translation lookup tables currently used
+      by the display. Return value is array that has r, g, b table.
+      Each table is array that has 256 integer.
+
+--- SDL.setGammaRamp(table)
+--- SDL.set_gamma_ramp(table)
+      Sets the gamma lookup tables for the display for each color component.
+      table should be an array like what you can get
+      with ((<SDL.getGammaRamp>)).
+
+--- SDL.autoLock
+--- SDL.auto_lock
+--- SDL.autoLock?
+--- SDL.auto_lock?
+      Needs SGE
+
+      Returns whether Ruby/SDL locks surface automatically when
+      need.Default is true.
+
+      Please see ((<SDL::Surface#lock>)) to know more.
+
+--- SDL.autoLock=(autolocking)
+--- SDL.auto_lock=(autolocking)
+--- SDL.autoLockON
+--- SDL.auto_lock_on
+--- SDL.autoLockOFF
+--- SDL.auto_lock_off
+      Needs SGE
+
+      Set whether Ruby/SDL locks surface automatically when
+      needed.
+
+--- SDL.videoInfo
+--- SDL.video_info
+      Return  video information in the object of VideoInfo .
+      The contents are following.
+      Values represent boolean value are true/false .
+      Please read SDL document to know about this information.
+        SDL::VideoInfo#hw_available
+        SDL::VideoInfo#wm_available
+        SDL::VideoInfo#blit_hw
+        SDL::VideoInfo#blit_hw_CC
+        SDL::VideoInfo#blit_hw_A
+        SDL::VideoInfo#blit_sw
+        SDL::VideoInfo#blit_sw_CC
+        SDL::VideoInfo#blit_sw_A
+        SDL::VideoInfo#blit_fill
+        SDL::VideoInfo#video_mem
+        SDL::VideoInfo#bpp
+	
+--- SDL.blitSurface(src,srcX,srcY,srcW,srcH,dst,dstX,dstY)
+--- SDL.blit_surface(src,srcX,srcY,srcW,srcH,dst,dstX,dstY)
+      This performs a fast blit from the source surface to the destination
+      surface.
+
+      If srcX=srcY=srcW=srcH=0,the entire surface is copied.
+
+      The blit function should not be called on a locked surface.
+
+--- SDL.blitSurface2(src,srcRect,dst,dstRect)
+--- SDL.blit_surface2(src,src_rect,dst,dst_rect)
+      You use this function like:
+        blitSurface2(src,[0,32,32,32],dst,[100,200])
+      or
+        Rect = Struct.new( 'Rect', :x, :y, :w, :h )
+        
+        rect1 = Rect.new( 16, 0, 16, 16 )
+        rect2 = Rect.new( 120, 0, 0, 0 )
+        blitSurface2( src, rect1, dst, rect2 )
+      
+--- SDL.rotateXYScaled(src,dst,x,y,angle,xscale,yscale)
+--- SDL.rotateXY_scaled(src,dst,x,y,angle,xscale,yscale)
+      Needs SGE
+
+      Note that this function is different from SGE sge_rotate_xyscaled API
+      in that src and dst are changing.
+      Following two functions are same.
+      This is equal to blitSurface.
+
+      And note that this function ignores colorkey.
+
+      This method is obsolete. Please use ((<SDL.transform>)) or
+      ((<SDL.transformBlit>))
+
+--- SDL.rotateScaled(src,dst,x,y,angle,scale)
+--- SDL.rotate_scaled(src,dst,x,y,angle,scale)
+      Same as above, but with xscale=yscale.
+
+--- SDL.rotate(src,dst,x,y,angle)
+      Same as above, but with xscale=yscale=1.0.
+
+--- SDL.rotateScaledBlit(src,dst,x,y,angle,scale)
+--- SDL.rotate_scaled_blit(src,dst,x,y,angle,scale)
+      Needs SGE
+
+      Same as rotateScaled,but respect colorkey.
+
+--- SDL.rotateBlit(src,dst,x,y,angle)
+--- SDL.rotate_blit(src,dst,x,y,angle)
+      Same as rotateScaledBlit,but with scale=1.0;
+
+--- SDL.transform(src,dst,angle,xscale,yscale,px,py,qx,qy,flags)
+      Need SGE
+
+      Draw src surface to dst surface with scaling and rotation.
+      Ignore colorkey.
+
+      *src - The surface to be rotated and scaled
+      *src - The surface to be rotated and scaled
+      *angle - The rotation angle in degrees.
+      *xscale  yscale - The x and y scaling factor. Can be negative
+       (mirroring). 1.0 is 1:1 scale.
+      *px / py - The pivot point to rotate around in the src surface.
+      *qx / qy - The destination point on dst surface.
+      *flags
+        *0 - Default.
+        *SGE_TAA - Use the interpolating renderer. Much slower but
+         can look better.
+        *SGE_TSAFE - Don't asume that the src and dst surfaces has the
+         same pixel format. This is the default when the two surfaces
+         don't have the same BPP.
+         This is slower but will render wierd pixel formats right.
+        *SGE_TTMAP - Use texture mapping. This is a bit faster
+         but the result isn't
+         as nice as in the normal mode. This mode will also ignore the px/py
+         coordinates and the other flags.
+
+--- SDL.transformBlit(src,dst,angle,xscale,yscale,px,py,qx,qy,flags)
+--- SDL.transform_blit(src,dst,angle,xscale,yscale,px,py,qx,qy,flags)
+      Need SGE
+
+      Blit src surface to dst surface with scaling and rotation.
+      Same as ((<SDL.transform>)) , but respect colorkey.
+
+=== SDL::Surface
+
+This class have image.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::Surface.new(flag,w,h,format)
+--- SDL::Surface.new(flags,w,h,depth,Rmask,Gmask,Bmask,Amask)
+      Create an empty surface.
+      You must call this method after ((<SDL.setVideoMode>))
+
+      format must be the instance of ((<SDL::Surface>)), and create the
+      surface that has same bpp as specified surface.
+      
+      The flags specifies the type of surface that should be
+      created, it is an OR'd combination of the following possible values.
+      
+      * SDL::SWSURFACE
+
+        SDL will create the surface in system memory.
+
+      * SDL::HWSURFACE
+
+        SDL will attempt to create the surface in video memory.
+
+      * SDL::SRCCOLORKEY
+
+        With this flag SDL will attempt to find the best
+        location for this surface, either in system memory or
+        video memory, to obtain hardware colorkey blitting
+        support.
+
+      * SDL::SRCALPHA
+
+        With this flag SDL will attempt to find the best
+        location for this surface, either in system memory or
+        video memory, to obtain hardware alpha support.
+        
+--- SDL::Surface.new_from(pixels,w,h,depth,pitch,Rmask,Gmask,Bmask,Amask)
+      Create a surface from pixel data.
+      ((|pixels|)) must be String. ((|pitch|)) is the length of
+      each scanline in bytes.
+      
+--- SDL::Surface.loadBMP(filename)
+--- SDL::Surface.load_bmp(filename)
+      Loads a image from a named Windows BMP file and return
+      the instance of ((<SDL::Screen>)).
+
+      Raise SDL::Error if you have an error,for example file didn't exist.
+      
+--- SDL::Surface.load(filename)
+      Needs SDL_image
+      Loads a image from a named Windows BMP file and return
+      the instance of ((<SDL::Screen>)).
+
+      Available formats are BMP,PPX,XPM,PCX,GIF,JPEG,PNG,TGA.
+
+==== method
+
+--- SDL::Surface#saveBMP(filename)
+--- SDL::Surface#save_bmp(filename)
+      Saves the surface as a Windows BMP file named file.
+
+--- SDL::Surface#displayFormat
+--- SDL::Surface#display_format
+      This method copies self to a new surface of the pixel
+      format and colors of the video framebuffer, suitable for fast blitting
+      onto the display surface.
+      
+      If you want to take advantage of hardware colorkey or alpha blit
+      acceleration, you should set the colorkey and alpha value before calling
+      this method.
+
+--- SDL::Surface#displayFormatAlpha
+--- SDL::Surface#display_format_alpha
+      Same as ((<SDL::Surface#displayFormat>)), except respecting
+      alpha value per pixel.
+
+--- SDL::Surface#setColorKey(flag,key)
+--- SDL::Surface#set_color_key(flag,key)
+      Sets the color key (transparent pixel) in a blittable surface and enables
+      or disables RLE blit acceleration.
+      If flag is SDL::SRCCOLORKEY then key is the transparent pixel
+      value in the source image of a blit.
+      If flag is OR'd with SDL::RLEACCEL then the surface will be draw
+      using RLE acceleration when drawn with blitting.
+
+--- SDL::Surface#fillRect(x,y,w,h)
+--- SDL::Surface#fill_rect(x,y,w,h)
+      This function performs a fast fill of the given rectangle with color.
+
+--- SDL::Surface#setClipRect(x,y,w,h)
+--- SDL::Surface#set_clip_rect(x,y,w,h)
+      Sets the clipping rectangle for a surface. When this surface is the
+      destination of a blit, only the area within the clip rectangle will
+      be drawn into.
+      
+      The rectangle pointed to by rect will be clipped to the edges of the
+      surface so that the clip rectangle for a surface can never fall
+      outside the edges of the surface.
+
+--- SDL::Surface#getClipRect
+--- SDL::Surface#get_clip_rect
+      Returns the clipping rectangle for this surface.
+      Return value is an array including x, y, r, w value.
+
+--- SDL::Surface#setAlpha(flag,alpha)
+--- SDL::Surface#set_alpha(flag,alpha)
+      SDL_SetAlpha is used for setting the per-surface alpha and/or enabling
+      and disabling per-pixel alpha blending.
+      
+      flags is used to specify whether alpha blending should be used
+      (SDL::SRCALPHA) and whether the surface should use RLE acceleration
+      for blitting (SDL::RLEACCEL). flags can be an OR'd combination of these
+      two options, one of these options or 0. If SDL_SRCALPHA is not passed
+      as a flag then all alpha information is ignored when blitting
+      the surface. The alpha parameter is the per-surface alpha value,
+      a surface need not have an alpha channel to use
+      per-surface alpha and blitting can still be accelerated with
+      SDL_RLEACCEL. Setting the per-surface alpha value to 0 disables
+      per-surface alpha blending.
+
+--- SDL::Surface#h
+      Return height.
+
+--- SDL::Surface#w
+      Return width.
+
+--- SDL::Surface#format
+      Return pixel format.
+      See ((<SDL::PixelFormat>)).
+
+--- SDL::Surface#put(image,x,y)
+      Draw image on (x,y) in self.
+      This method are implemented using blitSurface.
+
+--- SDL::Surface#copyRect(x,y,w,h)
+--- SDL::Surface#copy_rect(x,y,w,h)
+      Copy given rect and return copyed surface.
+      
+--- SDL::Surface#lock
+      This method sets up a surface for directly accessing the pixels.You call
+      this before calling ((<SDL::Surface#getPixel>)) ,
+      ((<SDL::Surface#drawLine>)) or some other mehtods of Surface.
+
+      Between calls to ((<SDL::Surface#lock>)) and ((<SDL::Surface#unlock>)),
+      you can use methods that 'need locking'.
+      Once you are done accessing the surface, you
+      should use ((<SDL::Surface#unlock>)) to release it.
+      
+      Not all surfaces require locking. If ((<SDL::Surface#mustLock?>)) returns
+      false, then you can read and write to the surface at any time, and the
+      pixel format of the surface will not change.
+      
+      No operating system or library calls should be made between lock/unlock
+      pairs, as critical system locks may be held during this time.
+      
+      If ((<SDL.autoLock>)) returns true,you don't have to call this methods
+      because this library locks surface automatically.
+
+--- SDL::Surface#unlock
+      Unlock the surface.
+
+--- SDL::Surface#mustLock?
+--- SDL::Surface#must_lock?
+      Returns true if you must lock surface for directly accessing the pixels,
+      otherwise returns false.
+
+--- SDL::Surface#getPixel(x,y) 
+--- SDL::Surface#get_pixel(x,y) 
+--- SDL::Surface#[](x,y)
+      Needs SGE ,Needs lock
+      Gets the color of the specified pixel.
+      You can convert this color value to RGB with ((<SDL::Surface#getRGBA>)).
+      
+--- SDL::Surface#putPixel(x,y,color)
+--- SDL::Surface#put_pixel(x,y,color)
+--- SDL::Surface#[]=(x,y,color)
+      Needs SGE ,Needs lock
+      Changes the color of the pixel on (x, y).
+      You can specify color by [r, g, b], [r, g, b, a] array or integer
+      given by ((<SDL::Surface#mapRGBA>)).
+      
+--- SDL::Surface#drawLine(x1,y1,x2,y2,color)
+--- SDL::Surface#draw_line(x1,y1,x2,y2,color)
+      Needs SGE ,Needs lock
+      Draws a line from (x1,y1) to (x2,y2).
+
+--- SDL::Surface#drawRect(x,y,w,h,color)
+--- SDL::Surface#draw_rect(x,y,w,h,color)
+      Needs SGE ,Needs lock
+      Draws a rectangle.
+
+--- SDL::Surface#drawCircle(x,y,r,color)
+--- SDL::Surface#draw_circle(x,y,r,color)
+      Needs SGE ,Needs lock
+      Draws a circle.
+
+--- SDL::Surface#drawFilledCircle(x,y,r,color)
+--- SDL::Surface#draw_filled_circle(x,y,r,color)
+      Needs SGE ,Needs lock
+      Draws a filled circle.
+
+--- SDL::Surface#drawEllipse(x,y,rx,ry,color)
+--- SDL::Surface#draw_ellipse(x,y,rx,ry,color)
+      Needs SGE, Needs lock
+      Draws an ellipse.
+
+--- SDL::Surface#drawEllispe(x,y,rx,ry,color)
+      See drawEllipse.  This method exists for compatability but should not
+      be used.
+
+--- SDL::Surface#drawFilledEllipse(x,y,rx,ry,color)
+--- SDL::Surface#draw_filled_ellipse(x,y,rx,ry,color)
+      Needs SGE, Needs lock
+      Draws a filled ellipse.
+
+--- SDL::Surface#drawFilledEllispe(x,y,rx,ry,color)
+      See drawFilledEllipse.  This method exists for compatability but
+      should not be used.
+
+--- SDL::Surface#drawAALine(x1,y1,x2,y2,color)
+--- SDL::Surface#draw_aa_line(x1,y1,x2,y2,color)
+      Needs SGE ,Needs lock
+      
+      Draws an antialiased line from (x1,y1) to (x2,y2).
+      
+--- SDL::Surface#drawAACircle(x,y,r,color)
+--- SDL::Surface#draw_aa_circle(x,y,r,color)
+      Needs SGE ,Needs lock
+
+      Draws an antialiased circle.
+      
+--- SDL::Surface#drawAAFilledCircle(x,y,r,color)
+--- SDL::Surface#draw_aa_filled_circle(x,y,r,color)
+      Needs SGE ,Needs lock
+
+      Draws a filled antialiased circle.
+      
+--- SDL::Surface#drawAAEllipse(x,y,rx,ry,color)
+--- SDL::Surface#draw_aa_ellipse(x,y,rx,ry,color)
+      Needs SGE ,Needs lock
+
+      Draws an antialiased ellipse.
+      
+--- SDL::Surface#drawLineAlpha(x1,y1,x2,y2,color,alpha)
+--- SDL::Surface#draw_line_alpha(x1,y1,x2,y2,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws a line with alpha blending.
+      
+--- SDL::Surface#drawRectAlpha(x,y,w,h,color,alpha)
+--- SDL::Surface#draw_rect_alpha(x,y,w,h,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws a rectangle with alpha blending.
+      
+--- SDL::Surface#drawFilledRectAlpha(x,y,w,h,color,alpha)
+--- SDL::Surface#draw_filled_rect_alpha(x,y,w,h,color,alpha)
+      Needs SGE ,Needs lock
+
+      x
+      
+--- SDL::Surface#drawCircleAlpha(x,y,r,color,alpha)
+--- SDL::Surface#draw_circle_alpha(x,y,r,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws a circle with alpha blending.
+      
+--- SDL::Surface#drawFilledCircleAlpha(x,y,r,color,alpha)
+--- SDL::Surface#draw_filled_circle_alpha(x,y,r,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws a filled circle with alpha blending.
+      
+--- SDL::Surface#drawEllipseAlpha(x,y,rx,ry,color,alpha)
+--- SDL::Surface#draw_ellipse_alpha(x,y,rx,ry,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws an ellipse with alpha blending.
+      
+--- SDL::Surface#drawFilledEllipseAlpha(x,y,rx,ry,color,alpha)
+--- SDL::Surface#draw_filled_ellipse_alpha(x,y,rx,ry,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws a filled ellipse with alpha blending.
+      
+--- SDL::Surface#drawAALineAlpha(x1,y1,x2,y2,color,alpha)
+--- SDL::Surface#draw_aa_line_alpha(x1,y1,x2,y2,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws an antialiased line with alpha blending.
+      
+--- SDL::Surface#drawAACircleAlpha(x,y,r,color,alpha)
+--- SDL::Surface#draw_aa_circle_alpha(x,y,r,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws an antialiased circle with alpha blending.
+      
+--- SDL::Surface#drawAAEllipseAlpha(x,y,rx,ry,color,alpha)
+--- SDL::Surface#draw_aa_ellipse_alpha(x,y,rx,ry,color,alpha)
+      Needs SGE ,Needs lock
+
+      Draws an antialiased ellipse with alpha blending.
+
+--- SDL::Surface#drawBezier(x1,y1,x2,y2,x3,y3,x4,y4,level,color)
+--- SDL::Surface#draw_bezier(x1,y1,x2,y2,x3,y3,x4,y4,level,color)
+      Needs SGE ,Needs lock
+      
+      Draws a bezier curve from (x1,y1) to (x4,y4) with the control
+      points (x2,y2) and (x3,y3). level indicates how good precision
+      the function should use, 4-7 is normal.
+      
+--- SDL::Surface#drawAABezier(x1,y1,x2,y2,x3,y3,x4,y4,level,color)
+--- SDL::Surface#draw_aa_bezier(x1,y1,x2,y2,x3,y3,x4,y4,level,color)
+      Needs SGE ,Needs lock
+      
+      Draws a antialiased bezier curve from (x1,y1) to (x4,y4) with the control
+      points (x2,y2) and (x3,y3). level indicates how good precision
+      the function should use, 4-7 is normal.
+      
+--- SDL::Surface#drawBezierAlpha(x1,y1,x2,y2,x3,y3,x4,y4,level,color,alpha)
+--- SDL::Surface#draw_bezier_alpha(x1,y1,x2,y2,x3,y3,x4,y4,level,color,alpha)
+      Needs SGE ,Needs lock
+      
+      Draws an alpha bezier curve from (x1,y1) to (x4,y4) with the control
+      points (x2,y2) and (x3,y3). level indicates how good precision
+      the function should use, 4-7 is normal.
+      
+--- SDL::Surface#drawAABezierAlpha(x1,y1,x2,y2,x3,y3,x4,y4,level,color,alpha)
+--- SDL::Surface#draw_aa_bezier_alpha(x1,y1,x2,y2,x3,y3,x4,y4,level,color,alpha)
+      Needs SGE ,Needs lock
+      
+      Draws an antialiased alpha bezier curve from (x1,y1) to (x4,y4)
+       with the control
+      points (x2,y2) and (x3,y3). level indicates how good precision
+      the function should use, 4-7 is normal.
+
+--- SDL::Surface#rotateScaledSurface(angle,scale,bgcolor)
+--- SDL::Surface#rotate_scaled_surface(angle,scale,bgcolor)
+      Needs SGE
+      This function makes the instance of Surface with a rotated and scaled
+      copy of "self". "angle" is the rotation angle in degrees.
+      "scale" is the scaling value , 1.0 is the normal size.
+
+      This method is obsolete. Please use ((<SDL::Surface#transformSurface>)).
+
+--- SDL::Surface#rotateSurface(angle,bgcolor)
+--- SDL::Surface#rotate_surface(angle,bgcolor)
+      Same as above,but with scale=1.0 .
+
+--- SDL::Surface#transformSurface(bgcolor,angle,xscale,yscale,flags)
+--- SDL::Surface#transform_surface(bgcolor,angle,xscale,yscale,flags)
+      Creates a rotated and scaled image of src. See ((<SDL.transform>))
+      for more information.
+
+      * bgcolor - What background color should the new surface have.
+      
+--- SDL::Surface#mapRGB(r,g,b)
+--- SDL::Surface#map_rgb(r,g,b)
+    Maps the RGB color value to the pixel format of specified surface
+    and returns the pixel value as a integer.
+
+--- SDL::Surface#mapRGBA(r,g,b,a)
+--- SDL::Surface#map_rgba(r,g,b,a)
+      Same as above,but includes alpha value.
+
+--- SDL::Surface#getRGB(pixel)
+--- SDL::Surface#get_rgb(pixel)
+      Get RGB component values from a pixel stored in the specified pixel
+      format.Returns r,g,b value in array as [r,g,b].
+
+--- SDL::Surface#getRGBA(pixel)
+--- SDL::Surface#get_rgba(pixel)
+      Same as above, but return value includes alplah value.
+      Returns r,g,b,a in arrary as [r,g,b,a].
+
+--- SDL::Surface#bpp
+      Return bits per pixel on this surface.
+
+--- SDL::Surface#colorkey
+      Returns colorkey on this surface.
+
+--- SDL::Surface#alpha
+      Returns alpha on this surface.
+
+--- SDL::Surface#flags
+      Returns flags on this surface.
+
+--- SDL::Surface#Rmask
+--- SDL::Surface#Gmask
+--- SDL::Surface#Bmask
+--- SDL::Surface#Amask
+      Returns [RGBA] mask on this surface.
+
+--- SDL::Surface#pixels
+      Returns pixel data as String.
+      
+--- SDL::Surface#setPalette(flag,colors,firstcolor)
+--- SDL::Surface#set_palette(flag,colors,firstcolor)
+      Sets a portion of the palette for the given 8-bit surface.
+
+      Palettized (8-bit) screen surfaces with the SDL_HWPALETTE flag have two
+      palettes, a logical palette that is used for mapping blits to/from
+      the surface and a physical palette (that determines how the
+      hardware will map the colors to the display).
+
+      This method can modify either the logical or physical
+      palette by specifing SDL::LOGPAL or SDL::PHYSPAL in the flags parameter.
+
+      If you want to modify the palette from Xth to th, you will give
+      following array as colors, and X as firstcolor.
+        [ [rX,gX,bX],[rX+1,gX+1,bX+1], ... ,[rY,gY,bY] ]
+
+--- SDL::Surface#setColors(colors,firstcolor)
+--- SDL::Surface#set_colors(colors,firstcolor)
+      Same as ((<SDL::Surface#setPalette>)), but flag is
+      SDL::LOGPAL|SDL::PHYSPAL.
+
+--- SDL::Surface#getPalette
+--- SDL::Surface#get_palette
+      Returns the palette of the specified surface. Return value is array
+      as following.
+        [ [r0,g0,b0],[r1,g1,b1], ... ,[r255,g255,b255] ]
+      Returns nil if the surface have no palette.
+
+--- SDL::Surface#makeCollisionMap
+      Need SGE
+
+      Create a collision map.  Call SetColorKey first.  Every
+      non-transparent pixel in the surface is set to solid in the collision
+      map.  Returns an instance of CollisionMap.
+
+=== SDL::CollisionMap
+
+Need SGE
+
+This is a map of which pixels in a surface are solid and which are
+transparent.  Its methods can quickly determine whether or not two
+surfaces would overlap if drawn at particular coordinates.
+
+Only ((<SDL::Surface#makeCollisionMap>)) makes this object.
+
+==== class method
+
+--- SDL::CollisionMap#boundingBoxCheck(x1, y1, w1, h1, x2, y2, w2, h2)
+      Return true if the bounding boxes overlap.
+
+==== method
+
+--- SDL::CollisionMap#collisionCheck(x1, y1, collisionMap, x2, y2)
+      Determine if this collision map, if drawn with its upper-left
+      corner at (x1, y1), would collide with collisionMap if drawn
+      with its upper-left corner at (x2, y2).  If so, return the
+      coordinate of the last collision found as an array ([x, y]).
+      If no collision, returns nil.
+
+      This method calls boundingBoxCheck automatically.
+
+--- SDL::CollisionMap#boundingBoxCheck(x1, y1, collisionMap, x2, y2)
+      Return true if the bounding boxes of the two maps would overlap if
+      drawn with upper-left corners at (x1, y1) and (x2, y2).
+
+--- SDL::CollisionMap#clear(x1, y1, w, h)
+      Clear (make transparent) an area of the collision map.
+
+--- SDL::CollisionMap#set(x1, y1, w, h)
+      Set (make solid) an area of the collision map.
+
+=== SDL::Screen
+
+SDL display the image that the instance of "Screen" have.
+Only ((<SDL.setVideoMode>)) makes this object.
+In fact the class named "Screen" doesn't exist,and the object that
+SDL::setVideoMode returns is the instance of Surface with following
+singleton methods.
+
+==== super class
+
+((<SDL::Surface>))
+
+==== class method
+
+
+==== method
+
+--- SDL::Screen#updateRect(x,y,w,h)
+--- SDL::Screen#update_rect(x,y,w,h)
+      Makes sure the given  rectangle is updated on the given screen.
+      Thhis function should not be called while screen is locked.
+
+      If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
+      screen.
+
+--- SDL::Screen#updateRects(*rects)
+--- SDL::Screen#update_rects(*rects)
+    Makes sure the given list of rectangles is updated on the given screen.
+    Each rectagle is represented as an array of 4 elements([x, y, w, h]).
+    The rectangles must all be confined within the screen boundaries
+    (no clipping is done).
+
+
+--- SDL::Screen#flip
+      On hardware that supports double-buffering, this method sets up a flip
+      and returns. The hardware will wait for vertical retrace, and then swap
+      video buffers before the next video surface blit or lock will return. On
+      hardware that doesn't support double-buffering, this is equivalent to
+      calling ((<SDL::Screen#updateRect>))(0, 0, 0, 0)
+      
+      The SDL::DOUBLEBUF flag must have been passed to
+      ((<SDL.setVideoMode>)), when
+      setting the video mode for this method to perform hardware flipping.
+
+=== SDL::PixelFormat
+
+((<SDL::Surface>)) has all methods of ((<SDL::PixelFormat>)).
+This class is obsolete,
+and you should use ((<SDL::Surface>)) instead of ((<SDL::PixelFormat>)).
+
+In SDL you can use some type surface,for example 32bit color surface and
+16bit surface.Therefore you need the information about that type,and
+object of PixelFormat represents this information.
+
+In this lib,you use one integer to specify color.To change from r,g,b value
+to this integer you use ((<SDL::PixelFormat#mapRGB>)) and to change this integer
+to r,g,b value ((<SDL::PixelFormat#getRGB>))
+
+==== super class
+
+Object
+
+==== class method
+
+nothing
+
+==== method
+
+--- SDL::PixelFormat#mapRGB(r,g,b)
+    Maps the RGB color value to the specified pixel format and returns the
+    pixel value as a integer.
+
+--- SDL::PixelFormat#mapRGBA(r,g,b,a)
+      Same as above,but includes alpha value.
+
+--- SDL::PixelFormat#getRGB(pixel)
+      Get RGB component values from a pixel stored in the specified pixel
+      format.Returns r,g,b value in array as [r,g,b].
+
+--- SDL::PixelFormat#getRGBA(pixel)
+      Same as above, but return value includes alplah value.
+      Returns r,g,b,a in arrary as [r,g,b,a].
+
+--- SDL::PixelFormat#bpp
+      Return bits per pixel on this format.
+
+--- SDL::PixelFormat#colorkey
+      Not documented yet
+
+--- SDL::PixelFormat#alpha
+      Not documented yet
+
+== Event handling
+
+=== SDL::Event
+
+The class handling event.
+You had better use ((<SDL::Event2>)) instead of this class.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::Event.new
+      Create a new ((<SDL::Event>)) Object. 
+
+--- SDL::Event.appState
+--- SDL::Event.app_state
+      Returns the current state of the application. The value returned
+      is a bitwise combination of:
+        SDL::Event::APPMOUSEFOCUS
+        SDL::Event::APPINPUTFOCUS
+        SDL::Event::APPACTIVE
+        
+--- SDL::Event.enableUNICODE
+--- SDL::Event.enable_unicode
+      Enables UNICODE keyboard translation.
+      UNICODE translation is disabled by default.
+      If you will use SDLSKK on Ruby/SDL, you should enable translation.
+      
+--- SDL::Event.disableUNICODE
+--- SDL::Event.disable_unicode
+      Disable UNICODE keyboard translation.
+      
+--- SDL::Event.enableUNICODE?
+--- SDL::Event.enable_unicode?
+      Returns whether UNICODE keyboard translation is enabled.
+      
+==== method
+
+--- SDL::Event#poll
+      Polls for currently pending events, and returns 1 if there are any
+      pending events, or 0 if there are none available.
+      If there are any events ,the next event is removed from the queue
+      and stored in self.
+
+--- SDL::Event#wait
+      Waits indefinitely for the next available event, returning 1, or 0 if
+      there was an error while waiting for events.
+      The next event is removed from the queue and stored in self.
+
+--- SDL::Event#type
+      Returns the type of stored event.
+        SDL::Event::ACTIVEEVENT 
+        SDL::Event::KEYDOWN
+        SDL::Event::KEYUP
+        SDL::Event::MOUSEMOTION
+        SDL::Event::MOUSEBUTTONDOWN
+        SDL::Event::MOUSEBUTTONUP
+        SDL::Event::JOYAXISMOTION
+        SDL::Event::JOYBALLMOTION
+        SDL::Event::JOYHATMOTION
+        SDL::Event::JOYBUTTONDOWN
+        SDL::Event::JOYBUTTONUP
+        SDL::Event::QUIT
+        SDL::Event::SYSWMEVENT
+        SDL::Event::VIDEORESIZE
+
+--- SDL::Event#info
+      Return event information in array.
+      This method can handle all event.
+
+--- SDL::Event#keyPress?
+--- SDL::Event#key_press?
+      Returns true when you got key event and a key pressed down,
+      otherwise returns false.
+
+--- SDL::Event#keySym
+--- SDL::Event#key_sym
+      Returns SDL vertual keysym.
+
+--- SDL::Event#keyMod
+--- SDL::Event#key_mod
+      Returns Current Key modifiers.
+
+--- SDL::Event#gain?
+      On ACTIVEEVENT,
+      returns true when gaining focus in this event,otherwise retursn false.
+
+--- SDL::Event#appState
+--- SDL::Event#app_state
+      Returns the kind of ActiveEvent.
+      This value is following.
+        SDL::Event::APPMOUSEFOCUS
+        SDL::Event::APPINPUTFOCUS
+        SDL::Event::APPACTIVE
+
+--- SDL::Event#mouseX
+--- SDL::Event#mouse_x
+      Returns the X coordinate of the mouse.
+
+--- SDL::Event#mouseY
+--- SDL::Event#mouse_y
+      Returns the Y coordinate of the mouse.
+
+--- SDL::Event#mouseXrel
+--- SDL::Event#mouse_xrel
+      Returns the relative motion in the X direction.
+
+--- SDL::Event#mouseYrel
+--- SDL::Event#mouse_yrel
+      Returns the relative motion in the Y direction.
+
+--- SDL::Event#mouseButton
+--- SDL::Event#mouse_button
+      Returns the mouse button index.
+        SDL::Mouse::BUTTON_LEFT  
+        SDL::Mouse::BUTTON_MIDDLE  
+        SDL::Mouse::BUTTON_RIGHT 
+
+--- SDL::Event#mousePress?
+--- SDL::Event#mouse_press?
+      Returns true when this mouse event is SDL::Event::MOUSEBUTTONDOWN,
+      otherwise returns false.
+
+=== SDL::Event2
+Another event handling class.
+I think ((<SDL::Event2>)) is easier to use than ((<SDL::Event>))
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::Event2.poll
+    Polls for currently pending events, and returns the instance represents
+    that event.Returns nil if there is no pending event.
+    The class of that instance is following.
+      SDL::Event2::Active
+      SDL::Event2::KeyDown
+      SDL::Event2::KeyUp
+      SDL::Event2::MouseMotion
+      SDL::Event2::MouseButtonDown
+      SDL::Event2::MouseButtonUp
+      SDL::Event2::JoyAxis
+      SDL::Event2::JoyBall
+      SDL::Event2::JoyHat
+      SDL::Event2::JoyButtonUp
+      SDL::Event2::JoyButtonDown
+      SDL::Event2::Quit
+      SDL::Event2::SysWM
+      SDL::Event2::VideoResize
+    All of these classes are subclass of SDL::Event2.
+
+--- SDL::Event2.wait
+    Waits indefinitely for the next available event,returning the instance
+    represents that event.
+
+    Note that while waiting next event, ruby's interpreter is blocked
+    and it cannot switch other threads because ruby's thread is
+    user-level thread.
+    
+--- SDL::Event2.push(event)
+      Not documented yet.
+
+--- SDL::Event2.new
+      Not documented yet.
+
+--- SDL::Event2.appState
+--- SDL::Event2.app_state
+      Same as ((<SDL::Event.appState>)).
+
+--- SDL::Event2.enableUNICODE
+--- SDL::Event2.enable_unicode
+      Same as ((<SDL::Event.enableUNICODE>)).
+      
+--- SDL::Event2.disableUNICODE
+--- SDL::Event2.disable_unicode
+      Same as ((<SDL::Event2.disableUNICODE>)).
+      
+--- SDL::Event2.enableUNICODE?
+--- SDL::Event2.enable_unicode?
+      Same as ((<SDL::Event.enableUNICODE?>)).
+      
+==== method
+
+Nothing
+
+=== subclasses of SDL::Event2
+SDL::Event2.poll and SDL::Event2.wait return the instance of
+the subclasses of SDL::Event2.
+These classes and  following.
+
+==== SDL::Event2::Active
+This event occurs when mouse/keyboard focus gains/loss.
++ Method
+--- SDL::Event2::Active#gain
+      Returns true focus gains, otherwise returns false
+--- SDL::Event2::Active#state
+      Returns the kind of event.
+        SDL::Event::APPMOUSEFOCUS 
+        SDL::Event::APPINPUTFOCUS
+        SDL::Event::APPACTIVE   iconify or restored.
+
+==== SDL::Event2::KeyDown
+This event occurs when a key is pressed.
++ Method
+--- SDL::Event2::KeyDown#press
+      Returns true.
+--- SDL::Event2::KeyDown#sym
+      Returns the pressed key such as SDL::Key::ESCAPE.
+--- SDL::Event2::KeyDown#mod
+      Same as ((<SDL::Key.modState>)).
+--- SDL::Event2::KeyDown#unicode
+      Returns key input translated to UNICODE.If you will use this,
+      you need to call ((<SDL::Event2.enableUNICODE>)) beforehand.
+==== SDL::Event2::KeyUp
+This event occurs when a key is released.
++ Method
+--- SDL::Event2::KeyUp#press
+      Returns false.
+--- SDL::Event2::KeyUp#sym
+      Returns the released key such as SDL::Key::ESCAPE.
+--- SDL::Event2::KeyUp#mod
+      Same as ((<SDL::Key.modState>)).
+
+==== SDL::Event2::MouseMotion
+This event occurs when mouse is moved.
++ Method
+--- SDL::Event2::MouseMotion#state
+      Returns the button state.
+--- SDL::Event2::MouseMotion#x
+      Returns x of mouse cursor.
+--- SDL::Event2::MouseMotion#y
+      Returns y of mouse cursor.
+--- SDL::Event2::MouseMotion#xrel
+      Returns relative x coordinates.
+--- SDL::Event2::MouseMotion#yrel
+      Returns relative y coordinates.
+
+==== SDL::Event2::MouseButtonDown
+This event occurs when a mouse button is pressed.
++ Method
+--- SDL::Event2::MouseButtonDown#button
+      Returns the which button is pressed.
+        SDL::Mouse::BUTTON_LEFT
+        SDL::Mouse::BUTTON_MIDDLE
+        SDL::Mouse::BUTTON_RIGHT
+
+--- SDL::Event2::MouseButtonDown#press
+      Returns true.
+--- SDL::Event2::MouseButtonDown#x
+      Returns x of mouse cursor.
+--- SDL::Event2::MouseButtonDown#y
+      Returns y of mouse cursor.
+
+==== SDL::Event2::MouseButtonUp
+This event occurs when a mouse button is pressed.
++ Method
+--- SDL::Event2::MouseButtonUp#button
+      Returns the which button is released.
+        SDL::Mouse::BUTTON_LEFT
+        SDL::Mouse::BUTTON_MIDDLE
+        SDL::Mouse::BUTTON_RIGHT
+
+--- SDL::Event2::MouseButtonUp#press
+      Returns false.
+--- SDL::Event2::MouseButtonUp#x
+      Returns x of mouse cursor.
+--- SDL::Event2::MouseButtonUp#y
+      Returns y of mouse cursor.
+
+==== SDL::Event2::JoyAxis
+This event occurs when axis of joystick is moved.
++ Method
+--- SDL::Event2::JoyAxis#which
+      Returns joystick device index.
+--- SDL::Event2::JoyAxis#axis
+      Returns joystick axis index.
+--- SDL::Event2::JoyAxis#value
+      Returns axis value(from -32768 to 32767).
+
+==== SDL::Event2::JoyBall
+This event occurs when joystick trackball moves.
++ Method
+--- SDL::Event2::JoyBall#which
+      Returns joystick device index.
+--- SDL::Event2::JoyBall#ball
+      Returns joystick trackball index.
+--- SDL::Event2::JoyBall#xrel
+      Returns the relative motion in the X direction.
+--- SDL::Event2::JoyBall#yrel
+      Returns the relative motion in the Y direction.
+
+==== SDL::Event2::JoyHat
+This event occurs when joystick hat moves.
++ Method
+--- SDL::Event2::JoyHat#which
+      Returns joystick device index.
+--- SDL::Event2::JoyHat#hat
+      Returns joystick hat index.
+--- SDL::Event2::JoyHat#value
+      Returns hat position.
+      That values  is a logically OR'd combination
+      of the following values.
+        SDL::Joystick::HAT_CENTERED
+        SDL::Joystick::HAT_UP
+        SDL::Joystick::HAT_RIGHT
+        SDL::Joystick::HAT_DOWN
+        SDL::Joystick::HAT_LEFT
+
+      The following defines are also provided
+        SDL::Joystick::HAT_RIGHTUP
+        SDL::Joystick::HAT_RIGHTDOWN
+        SDL::Joystick::HAT_LEFTUP
+        SDL::Joystick::HAT_LEFTDOWN
+
+==== SDL::Event2::JoyButtonUp
+This event occurs when joystick button is released.
++ Method
+--- SDL::Event2::JoyButtonUp#which
+      Returns joystick device index.
+--- SDL::Event2::JoyButtonUp#button
+      Returns joystick button index.
+--- SDL::Event2::JoyButtonUp#press
+      Returns false.
+
+==== SDL::Event2::JoyButtonDown
+This event occurs when joysick button is pressed.
++ Method
+--- SDL::Event2::JoyButtonDown#which
+      Returns joystick device index.
+--- SDL::Event2::JoyButtonDown#button
+      Returns joystick button index.
+--- SDL::Event2::JoyButtonDown#press
+      Returns true.
+
+==== SDL::Event2::Quit
+This event occurs when quit requested, such as pressed exit button.
+
+==== SDL::Event2::SysWM
+This event occurs when platform-dependent window manager occurs.
+You can't get more information.
+
+==== SDL::Event2::VideoResize
+This event occurs when window are resized.
+You will get this event only when you call ((<SDL.setVideoMode>)) with
+SDL::RESIZABLE.
+
++ Method
+--- SDL::Event2::VideoResize#w
+      Returns new width of window.
+--- SDL::Event2::VideoResize#h
+      Returns new height of window.
+
+=== SDL::Key
+
+The module defines key constants.
+This module has some functions to get the key state.
+
+==== module functions
+
+--- SDL::Key.scan
+      scan key state.
+
+--- SDL::Key.press?(key)
+      Get key state that "scan" function scan.
+      return true if "key" is pressed and return false if "key" is released.
+
+--- SDL::Key.modState
+--- SDL::Key.mod_state
+      Returns the current of the modifier keys (CTRL,ATL,etc.).
+      The return value can be an OR'd combination of following constants.  
+        SDL::Key::MOD_NONE
+        SDL::Key::MOD_LSHIFT
+        SDL::Key::MOD_RSHIFT
+        SDL::Key::MOD_LCTRL
+        SDL::Key::MOD_RCTRL
+        SDL::Key::MOD_LALT
+        SDL::Key::MOD_RALT
+        SDL::Key::MOD_LMETA
+        SDL::Key::MOD_RMETA
+        SDL::Key::MOD_NUM
+        SDL::Key::MOD_CAPS
+        SDL::Key::MOD_MODE
+        SDL::Key::MOD_RESERVED
+        SDL::Key::MOD_CTRL = SDL::Key::MOD_LCTRL|SDL::Key::MOD_RCTRL
+        SDL::Key::MOD_SHIFT = SDL::Key::MOD_LSHIFT|SDL::Key::MOD_RSHIFT
+        SDL::Key::MOD_ALT = SDL::Key::MOD_LALT|SDL::Key::MOD_RALT
+        SDL::Key::MOD_META = SDL::Key::MOD_LMETA|SDL::Key::MOD_RMETA
+
+--- SDL::Key.enableKeyRepeat(delay,interval)
+--- SDL::Key.enable_key_repeat(delay,interval)
+      Set keyboard repeat rate.
+
+--- SDL::Key.disableKeyRepeat
+--- SDL::Key.disable_key_repeat
+      Disables key repeat.
+
+--- SDL::Key.getKeyName(key)
+--- SDL::Key.get_key_name(key)
+      Return the string of key name.
+      
+=== SDL::Mouse
+
+The module mouse constants and mouse functions.
+
+=== module functions
+
+--- SDL::Mouse.state
+      Return mouse state in array.
+      Return value is following,
+        [ x , y , pressLButton? , pressMButton? , pressRButton? ]
+
+--- SDL::Mouse.warp(x,y)
+      Set the position of the mouse cursor (generates a mouse motion event).
+
+--- SDL::Mouse.show
+      Show mouse cursor.
+
+--- SDL::Mouse.hide
+      Hide mouse cursor.
+
+--- SDL::Mouse.setCursor(bitmap,white,black,transparent,inverted,hot_x=0,hot_y=0)
+--- SDL::Mouse.set_cursor(bitmap,white,black,transparent,inverted,hot_x=0,hot_y=0)
+      Change mouse cursor. bitmap is form of cursor,instance of
+      ((<SDL::Surface>)).The cursor width must be a multiple of 8.
+      The cursor is created in black and white according to
+      bitmap and white,black,transparent,inverted.
+      white,black,transparent,inverted represents that elements in
+      bitmap as pixel value.
+
+== audio
+
+=== SDL::Mixer
+
+The module that have sound functions and constants.
+Note that volume is between 0 and 128.
+Needs SDL_mixer to use functions if this module.
+
+==== module functions
+
+--- SDL::Mixer.open(frequency=Mixer::DEFAULT_FREQUENCY,format=Mixer::DEFAULT_FORMAT,cannels=Mixer::DEFAULT_CHANNELS,chunksize=4096)
+      Initializes SDL_mixer.
+
+--- SDL::Mixer.spec
+      Returns the audio spec in array.
+        [ rate,format,channels ]
+
+--- SDL::Mixer.driverName
+--- SDL::Mixer.driver_name
+      Returns the current audio device name.
+      Raises SDL::Error if mixer is not initialized yet.
+
+--- SDL::Mixer.allocateChannels(numchannels)
+--- SDL::Mixer.allocate_channels(numchannels)
+      Dynamically change the number of channels managed by the mixer.
+      If decreasing the number of channels, the upper channels are
+      stopped.
+      This method returns the new number of allocated channels.
+
+--- SDL::Mixer.playChannel(channel,wave,looping)
+--- SDL::Mixer.play_channel(channel,wave,looping)
+      Play a wave on a specific channel.
+
+      If the specified channel is -1, play on the first free channel.
+      If 'loops' is greater than zero, loop the sound that many times.
+      If 'loops' is -1, loop inifinitely (~65000 times).
+
+      Returns which channel was used to play the sound.
+
+--- SDL::Mixer.play?(channel)
+      Returns whether specific channel is playing or not.
+
+      If the specified channel is -1, check all channels.
+
+--- SDL::Mixer.setVolume(channel,volume)
+--- SDL::Mixer.set_volume(channel,volume)
+      Set the volume in the range of 0-128 of a specific channel.
+      If the specified channel is -1, set volume for all channels.
+      Returns the original volume.
+      If the specified volume is -1, just return the current volume.
+
+--- SDL::Mixer.halt(channel)
+      Halt playing of a particular channel
+
+--- SDL::Mixer.pause(chennel)
+      Pause a particular channel
+
+--- SDL::Mixer.resume(channel)
+      Resume a particular channel
+
+--- SDL::Mixer.pause?(channel)
+      Returns whether a particular channel is pausing.
+
+--- SDL::Mixer.playMusic(music,loops)
+--- SDL::Mixer.play_music(music,loops)
+      Play a music.
+      
+--- SDL::Mixer.fadeInMusic(music,loops,ms)
+--- SDL::Mixer.fade_in_music(music,loops,ms)
+      Fade in the given music in ms milliseconds.
+      The meaning of loops is same as in ((<SDL::Mixer.playChannel>))
+
+--- SDL::Mixer.setVolumeMusic(volume)
+--- SDL::Mixer.set_volume_music(volume)
+      Sets the volume of music.
+
+--- SDL::Mixer.haltMusic
+--- SDL::Mixer.halt_music
+      Halts music.
+
+--- SDL::Mixer.fadeOutMusic(ms)
+--- SDL::Mixer.fade_out_music(ms)
+      Fade out the music in ms milliseconds.
+
+--- SDL::Mixer.pauseMusic
+--- SDL::Mixer.pause_music
+      Pauses music.
+
+--- SDL::Mixer.resumeMusic
+--- SDL::Mixer.resume_music
+      Resumes music.
+
+--- SDL::Mixer.rewindMusic
+--- SDL::Mixer.rewind_music
+      Rewinds music.
+
+--- SDL::Mixer.pauseMusic?
+--- SDL::Mixer.pause_music?
+      Returns whether the music is pausing.
+
+--- SDL::Mixer.playMusic?
+--- SDL::Mixer.play_music?
+      Returns whether the music is playing.
+
+=== SDL::Mixer::Wave
+
+The class handling wave
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::Mixer::Wave.load(filename)
+      Loads a wave file and returns the object of ((<SDL::Mixer::Wave>)).
+
+==== method
+
+--- SDL::Mixer::Wave#setVolume(volume)
+--- SDL::Mixer::Wave#set_volume(volume)
+      Set volume of self.
+
+=== SDL::Mixer::Music
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::Mixer::Music.load(filename)
+      Loads a music (.mod .s3m .it .xm .mid .mp3, .ogg) file and returns the
+      object of ((<SDL::Mixer::Music>)).
+
+      You have to setup your environment to play MIDI, Ogg Vorbis, and MP3 file.
+
+== Window Manager 
+
+=== SDL::WM
+
+The module that have the functions for window management.
+
+==== module functions
+
+--- SDL::WM.caption
+      Returns captions of the window title and icon name.
+
+--- SDL::WM.setCaption(title,icon)
+--- SDL::WM.set_caption(title,icon)
+      Set captions of the window title and icon name.
+
+--- SDL::WM.icon=(iconImage)
+--- SDL::WM.icon=(icon_image)
+      Sets the icon for the display window.
+      
+      This function must be called before the first call to
+      setVideoMode.
+
+      It takes an icon surface.
+
+--- SDL::WM.iconify
+      If the application is running in a window managed environment SDL
+      attempts to iconify/minimise it. If ((<SDL::WM.iconify>)) is successful,
+      the application will receive a APPACTIVE loss event.
+
+--- SDL::Screen#toggleFullScreen
+--- SDL::Screen#toggle_fullscreen
+      Toggles fullscreen mode.
+      
+== CDROM
+
+=== SDL::CD
+
+The class represents CDROM drive.
+
+Note that the information that you get with ((<SDL::CD#numTracks>)) is stored
+when you call ((<SDL::CD#status>)).
+
+A CD-ROM is organized into one or more tracks, each consisting of a
+certain number of "frames". Each frame is ~2K in size, and at normal
+playing speed, a CD plays 75 frames per second. SDL works with the
+number of frames on a CD.
+
+==== super class
+
+==== class method
+
+--- SDL::CD.numDrive
+--- SDL::CD.num_drive
+      Returns the number of CD-ROM drives on the system.
+
+--- SDL::CD.indexName(drive)
+--- SDL::CD.index_name(drive)
+      Returns a human-readable, system-dependent identifier for the CD-ROM.
+      drive is the index of the drive. Drive indices start to 0 and end at
+      SDL::CD.numDrive-1
+
+--- SDL::CD.open(drive)
+      Opens a CD-ROM drive for access.
+      It returns a object of CD.
+      Raises SDL::Error if the drive was invalid or busy.
+      Drives are numbered starting with 0. Drive 0 is the system default
+      CD-ROM.
+
+==== method
+
+--- SDL::CD#status
+      Stores the information of currentTrack,currentFrame,numTracks,trackType,
+      trackLenght .
+      This function returns the current status.
+      Status is described like so:
+        SDL::CD::TRAYEMPTY
+        SDL::CD::STOPPED
+        SDL::CD::PLAYING
+        SDL::CD::PAUSED
+        SDL::CD::ERROR
+
+--- SDL::CD#play(start,length)
+      Plays the given cdrom, starting a frame start for length frames.
+
+--- SDL::CD#playTrack(start_track,start_frame,ntracks,nframes)
+--- SDL::CD#play_track(start_track,start_frame,ntracks,nframes)
+      SDL_CDPlayTracks plays the given CD starting at track start_track, for
+      ntracks tracks.
+      
+      start_frame is the frame offset, from the beginning of the start_track,
+      at which to start. nframes is the frame offset, from the beginning of
+      the last track (start_track+ntracks), at which to end playing.
+
+      SDL::CD#playTracks should only be called after calling
+      ((<SDL::CD#status>)) to get track information about the CD.
+
+--- SDL::CD#pause
+      Pauses play.
+
+--- SDL::CD#resume
+      Resumes play.
+
+--- SDL::CD#stop
+      Stops play.
+
+--- SDL::CD#eject
+      Ejects cdrom.
+
+--- SDL::CD#numTracks
+--- SDL::CD#num_tracks
+      Returns the number of tracks on the CD.
+
+--- SDL::CD#currentTrack
+--- SDL::CD#current_track
+      Returns current track.
+
+--- SDL::CD#currentFrame
+--- SDL::CD#current_frame
+      Returns current frame.
+
+--- SDL::CD#trackType(track)
+--- SDL::CD#track_type(track)
+      Returns the track type of given track.
+      SDL::CD::AUDIO_TRACK
+      SDL::CD::DATA_TRACK
+
+--- SDL::CD#trackLength(track)
+--- SDL::CD#track_length(track)
+      Returns the track length in frame,of given track.
+
+== Joystick handling
+
+=== SDL::Joystick
+
+The class represents one joystick.
+
+=== super class
+
+Object
+
+=== class method
+
+--- SDL::Joystick.pall
+      Return whether ((<SDL::Joystick.updateAll>)) is called automatically.
+      
+--- SDL::JoyStick.pall=(polling)
+      Set whether ((<SDL::Joystick.updateAll>)) is called automatically and
+      whether joystick events are processed.
+      Default is true, and you shouldn't change.
+
+--- SDL::Joystick.num
+      Returns the number of attached joysticks.
+
+--- SDL::Joystick.indexName(index)
+--- SDL::Joystick.index_name(index)
+      Get the implementation dependent name of joystick. The index parameter
+      refers to the N'th joystick on the system.
+
+--- SDL::Joystick.open(index)
+      Opens a joystick for use within SDL. The index refers to the N'th
+      joystick in the system. A joystick must be opened before it game be
+      used.
+      Returns the object of Joystick.
+
+--- SDL::Joystick.open?(index)
+      Determines whether a joystick has already been opened within the
+      application. index refers to the N'th joystick on the system.
+
+--- SDL::Joystick.updateAll
+--- SDL::Joystick.update_all
+--- SDL::Joystick.update
+      Updates the state(position, buttons, etc.) of all open joysticks.
+
+=== method
+
+--- SDL::Joystick#index
+      Returns the index of self.
+
+--- SDL::Joystick#numAxes
+--- SDL::Joystick#num_axes
+      Return the number of axes available from a previously opened 
+      joystick.
+
+--- SDL::Joystick#numBalls
+--- SDL::Joystick#num_balls
+      Return the number of trackballs available.
+
+--- SDL::Joystick#numButtons
+--- SDL::Joystick#num_buttons
+      Returns the number of buttons available.
+
+--- SDL::Joystick#axis(axis_index)
+      Returns a 16-bit signed integer representing the current position of the
+      axis.
+      On most modern joysticks the X axis is usually represented by axis 0 and
+      the Y axis by axis 1. The value returned by Joystick#axis is a
+      signed integer (-32768 to 32768) representing the current position of
+      the axis, it maybe necessary to impose certain tolerances on these
+      values to account for jitter. It is worth noting that some joysticks use
+      axes 2 and 3 for extra buttons.
+
+--- SDL::Joystick#hat(hat_index)
+      The current state is returned as a 8bit unsigned integer
+      which is defined as an OR'd combination of one or more of the following
+        SDL::Joystick::HAT_CENTERED
+        SDL::Joystick::HAT_UP
+        SDL::Joystick::HAT_RIGHT
+        SDL::Joystick::HAT_DOWN
+        SDL::Joystick::HAT_LEFT
+        SDL::Joystick::HAT_RIGHTUP
+        SDL::Joystick::HAT_RIGHTDOWN
+        SDL::Joystick::HAT_LEFTUP
+        SDL::Joystick::HAT_LEFTDOWN
+
+--- SDL::Joystick#button(button_index)
+      Returns the current state of the given button.
+      Returns true if the button is pressed,otherwise 0.
+
+--- SDL::Joystick#ball(ball_index)
+      Returns the motion deltas in array, [ dx,dy ] .
+      Trackballs can only return relative motion since the last call to
+      Joystick#ball, these motion deltas a placed into dx and dy.
+
+== Font handling
+
+=== SDL::BMFont
+
+The class handles BitMap Font. This needs SGE.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::BMFont.open(filename,flags)
+      Open a font file and create a bitmap font object.
+      * SDL::BMFont::TRANSPARENT
+          Transparent(Should usually be set)
+      * SDL::BMFont::NOCONVERT
+      * SDL::BMFont::SFONT
+      * SDL::BMFont::PALETTE
+
+==== method
+--- SDL::BMFont#setColor(r,g,b)
+--- SDL::BMFont#set_color
+      Changes the color of the font.
+      This doesn't work on 'color font' or sfont.
+
+--- SDL::BMFont#height
+      Get the height of the font.
+      
+--- SDL::BMFont#width
+      Get the width of the font.
+      
+--- SDL::BMFont#textout(surface,string,x,y)
+      Render the given string on surface. (x,y) is the position
+      of the left top corner.
+
+=== SDL::Kanji
+This class handles bdf fonts. You can draw Japanese character with this
+class.
+
+==== super class
+
+Object
+
+==== class method
+--- SDL::Kanji.open(filename,size)
+      Open bdf font file and return font object.
+      You should specify font size as ((|size|)).
+      
+==== method
+--- SDL::Kanji#add(filename)
+      Open other bdf file and add lacked glyphs.
+      
+--- SDL::Kanji#setCodingSystem
+--- SDL::Kanji#set_coding_system
+      Set Character coding system. You can use following.
+      * SDL::Kanji::JIS
+      * SDL::Kanji::SJIS
+      * SDL::Kanji::EUC
+      
+      Default is SDL::Kanji::EUC.
+      
+--- SDL::Kanji#textwidth(text)
+      Return the width of text.
+      
+--- SDL::Kanji#width
+      Return the width of one ascii character.
+      
+--- SDL::Kanji#height
+      Return font height.
+      
+--- SDL::Kanji#put(surface,text,x,y,r,g,b)
+      Draw text on surface at (x,y) whose color is (r,g,b).
+      
+--- SDL::Kanji#putTate(surface,text,x,y,r,g,b)
+--- SDL::Kanji#put_tate(surface,text,x,y,r,g,b)
+      Draw Tategaki text.
+      
+=== SDL::TTF
+
+The class handles True Type Font. This needs SDL_ttf.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::TTF.init
+      You must call TTF.init first when you use True Type Font.
+
+--- SDL::TTF.open(filename,size,index=0)
+      Open a font file and create a font of the specified point size.
+
+      And you can specify font face with index. Need SDL_ttf 2.0.4 or
+      later to use this feature.
+
+==== method
+
+--- SDL::TTF#style
+      Returns the font style.
+
+--- SDL::TTF#style=(style)
+      Set font style.
+      style is an OR'd conbination of one or more of the following
+        SDL::TTF::STYLE_NORMAL
+        SDL::TTF::STYLE_BOLD
+        SDL::TTF::STYLE_ITALIC
+        SDL::TTF::STYLE_UNDERLINE
+
+--- SDL::TTF#textSize(text)
+--- SDL::TTF#text_size(text)
+      Get Text size on image in array. Return [width,height].
+
+--- SDL::TTF#faces
+      Need SDL_ttf 2.0.4 or later
+      Returns the number of face.
+
+--- SDL::TTF#fixedWidth?
+--- SDL::TTF#fixed_width?
+      Need SDL_ttf 2.0.4 or later.
+      Returns whether this font has fixed width or not.
+
+--- SDL::TTF#familyName
+--- SDL::TTF#family_name
+      Need SDL_ttf 2.0.4 or later
+      Returns the name of font family.
+
+--- SDL::TTF#styleName
+--- SDL::TTF#style_name
+      Need SDL_ttf 2.0.4 or later
+      Returns the name of style.
+
+--- SDL::TTF#height
+      Get the total height of the font - usually equal to point size.
+      
+--- SDL::TTF#ascent
+      Get the offset from the baseline to the top of the font
+      This is a positive value, relative to the baseline.
+      
+--- SDL::TTF#descent
+      Get the offset from the baseline to the bottom of the font
+      This is a negative value, relative to the baseline.
+      
+--- SDL::TTF#lineSkip
+--- SDL::TTF#line_skip
+      Get the recommended spacing between lines of text for this font.
+      
+--- SDL::TTF#drawSolidUTF8(dest,text,x,y,r,g,b)
+--- SDL::TTF#draw_solid_utf8(dest,text,x,y,r,g,b)
+      Draw text on "dest" at ("x","y"). r,g,b are color elements of text.
+      This function use colorkey internally.
+      Text must be UTF-8 (you can use ASCII code).
+
+--- SDL::TTF#drawBlendedUTF8(dest,text,x,y,r,g,b)
+--- SDL::TTF#draw_blended_utf8(dest,text,x,y,r,g,b)
+      Similar to drawSolidUTF8.
+      More beautiful than drawSolidUTF8,but more slowly than drawSolidUTF8.
+
+--- SDL::TTF#drawShadedUTF8(dest,text,x,y,fg_r,fg_g,fg_b,bg_r,bg_g,bg_b)
+--- SDL::TTF#draw_shaded_utf8(dest,text,x,y,fg_r,fg_g,fg_b,bg_r,bg_g,bg_b)
+      Similar to drawSolidUTF8.
+      This method is defferent from drawSolidUTF8 in that this method
+      fills the background of text with specified color.
+
+--- SDL::TTF#renderSolidUTF8(text,r,g,b)
+--- SDL::TTF#render_solid_utf8(text,r,g,b)
+      Draws text on the new surface and returns it.
+      If this method fails to render, you'll get nil.
+      This method draws text like drawSolidUTF8.
+      
+--- SDL::TTF#renderBlendedUTF8(text,r,g,b)
+--- SDL::TTF#render_blended_utf8(text,r,g,b)
+      Same as ((<SDL::TTF#renderSolidUTF8>)), but this method draws
+      like ((<SDL::TTF#drawBlendedUTF8>)).
+      
+--- SDL::TTF#renderShadedUTF8(text,fg_r,fg_g,fg_b,bg_r,bg_g,bg_b)
+--- SDL::TTF#render_shaded_utf8(text,fg_r,fg_g,fg_b,bg_r,bg_g,bg_b)
+      Same as ((<SDL::TTF#renderSolidUTF8>)), but this method draws
+      like ((<SDL::TTF#drawShadedUTF8>)).
+      
+== MPEG stream
+
+Needs SMPEG library.
+
+If you will play mpeg with sound, you should call ((<SDL.init>)) with
+SDL::INIT_AUDIO, and call ((<SDL::Mixer.open>)).
+
+Don't touch the destination surface while playing mpeg, because smpeg uses
+native thread.
+
+Don't play sound with ((<SDL::Mixer>)) when playing mpeg, because smpeg
+hooks SDL_Mixer's playback functions.
+
+=== SDL::MPEG
+
+This class handles MPEG stream
+
+==== super class 
+
+Object
+
+==== class method 
+
+--- SDL::MPEG.load(filename)
+--- SDL::MPEG.new(filename)
+      Create a new SDL::MPEG object from an MPEG file.
+
+==== �᥽�å�
+
+--- SDL::MPEG#info
+      Returns the current information of SDL::MPEG instance.
+      Return value is a instance of ((<SDL::MPEG::Info>))
+
+--- SDL::MPEG#enableAudio(enable)
+--- SDL::MPEG#enable_audio(enable)
+      Enable or disable audio playback in MPEG stream.
+      
+--- SDL::MPEG#enableVideo(enable)
+--- SDL::MPEG#enable_video(enable)
+      Enable or disable video playback in MPEG stream.
+
+--- SDL::MPEG#status
+      Returns the current status.Returns following value.
+        SDL::MPEG::ERROR
+        SDL::MPEG::STOPPED
+        SDL::MPEG::PLAYING
+
+--- SDL::MPEG#setVolume(volume)
+--- SDL::MPEG#set_volume(volume)
+      Set the audio volume of an MPEG stream, in the range 0-100.
+
+--- SDL::MPEG#setDisplay(surface)
+--- SDL::MPEG#set_display(surface)
+      Set the destination surface for MPEG video playback.
+
+--- SDL::MPEG#setLoop(repeat)
+--- SDL::MPEG#set_loop(repeat)
+      Set or clear looping play.
+      
+--- SDL::MPEG#scaleXY(w,h)
+--- SDL::MPEG#scale_xy(w,h)
+      Scale pixel display.
+
+--- SDL::MPEG#scale(scale)
+      Scale pixel display.
+
+--- SDL::MPEG#move(x,y)
+      Move the video display area within the destination surface.
+
+--- SDL::MPEG#setDisplayRegion(x,y,w,h)
+--- SDL::MPEG#set_display_region(x,y,w,h)
+      Set the region of the video to be shown.
+
+--- SDL::MPEG#play
+      Play an MPEG stream.
+
+      Warning: Don't access the surface while playing.
+
+--- SDL::MPEG#pause
+      Pause/Resume playback.
+
+--- SDL::MPEG#stop
+      Stop playback.
+
+--- SDL::MPEG#rewind
+      Rewind the play position of MPEG stream  to the begining of the MPEG.
+
+--- SDL::MPEG#seek(bytes)
+      Seek 'bytes' bytes in the MPEG stream.
+
+--- SDL::MPEG#skip(seconds)
+      Skip 'seconds' seconds in the MPEG stream.
+
+--- SDL::MPEG#renderFrame(framenum)
+--- SDL::MPEG#render_frame(framenum)
+      Render a particular frame in the MPEG video.
+
+--- SDL::MPEG#setFilter(filter)
+--- SDL::MPEG#set_filter(filter)
+      Set video filter. Available filter is following.
+        SDL::MPEG::NULL_FILTER  No filter
+        SDL::MPEG::BILINEAR_FILTER  Bilinear filter
+        SDL::MPEG::DEBLOCKING_FILTER  Deblocking filter
+
+=== SDL::MPEG::Info
+
+The instance of this class has the information of ((<SDL::MPEG>)).
+Get that with ((<SDL::MPEG#info>)).
+
+==== super class
+
+Object
+
+==== method
+
+--- SDL::MPEG::Info#has_audio
+--- SDL::MPEG::Info#has_video
+--- SDL::MPEG::Info#width
+--- SDL::MPEG::Info#height
+--- SDL::MPEG::Info#current_frame
+--- SDL::MPEG::Info#current_fps
+--- SDL::MPEG::Info#audio_string
+--- SDL::MPEG::Info#audio_current_frame
+--- SDL::MPEG::Info#current_offset
+--- SDL::MPEG::Info#total_size
+--- SDL::MPEG::Info#current_time
+--- SDL::MPEG::Info#total_time
+
+== Time
+
+=== module function
+
+--- SDL.getTicks
+--- SDL.get_ticks
+      Get the number of milliseconds since the SDL library initialization.
+      Note that this value wraps if the program runs for more than ~49 days.
+
+--- SDL.delay(ms)
+      Wait a specified number of milliseconds before returning. this
+      function will wait at least the specified time, but possible
+      longer due to OS scheduling.
+      
+== Japanese input method with SDLSKK
+      
+Needs SDLSKK library.
+
+You need calling ((<SDL::Event2.enableUNICODE>)) after calling ((<SDL.init>))
+to use SDLSKK.
+
+=== module function
+
+--- SDL::SKK.encoding=(encoding)
+      Set encoding of SDLSKK.
+      * SDL::SKK::EUCJP
+      * SDL::SKK::UTF8
+      * SDL::SKK::SJIS
+
+--- SDL::SKK.encoding
+      Return encoding.
+      
+=== SDL::SKK::Context
+
+This class represents the state of input.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::SKK::Context.new(dict,romkana_table,keybind,use_minibuffer)
+      Create an instance of ((<SDL::SKK::Context>)) from the dictionary,
+      the keybind and the RomKanaRuleTable. And if use_minibuffer is true, you
+      can use minibuffer.      
+      
+==== method
+
+--- SDL::SKK::Context#input(event)
+      Inputs from keyboard thorough event object.
+      
+--- SDL::SKK::Context#str
+      Returns input (Japanese) string.
+      
+--- SDL::SKK::Context#render_str(font,r,g,b)
+      Renders the text.
+
+--- SDL::SKK::Context#render_minibuffer_str(font,r,g,b)
+      Renders minibuffer text.
+
+--- SDL::SKK::Context#clear
+      Clears text and initializes context.
+
+--- SDL::SKK::Context#get_basic_mode
+      Returns whether context's state is basic mode.
+      
+      If this method returns true, and you get return, you can
+      stop inputting.
+      
+      
+=== SDL::SKK::Dictionary
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::SKK::Dictionary.new
+      Creates the instance of ((<SDL::SKK::Dictionary>)).
+      The content of that is empty just after creating.
+      
+==== method
+
+--- SDL::SKK::Dictionary#load(dictfile,users)
+      Load dictionary from file.
+      If users is true, then this method regards it as user's dictionary.
+      
+--- SDL::SKK::Dictionary#save(filename)
+      Save user's dictionary.
+      
+=== SDL::SKK::RomKanaRuleTable
+
+This class represents the rule of conversion from Alphabet to Japanese kana.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::SKK::RomKanaRuleTable.new(table_file)
+      Create the instance of ((<SDL::SKK::RomKanaRuleTable>)) from rule file.
+      
+==== method
+
+=== SDL::SKK::Keybind
+
+This class represents the keybind in SDLSKK input system.
+
+==== super class
+
+Object
+
+==== class method
+
+--- SDL::SKK::Keybind.new
+      Create the instance of ((<SDL::SKK::Keybind>)) without any keybind.
+
+==== method
+
+--- SDL::SKK::Keybind#set_key(key_str,cmd_str)
+      Set keybind.
+      
+      You can use following string as ((|key_str|)).
+      * alphabet and other ascii character
+      * "SPC" "TAB" "DEL" "RET" "UP" "DOWN" "RIGHT" "LEFT" "INSERT" "HOME" "END"
+        "PAGEUP" "PAGEDOWN" "F1" "F2" "F3" "F4" "F5" "F6" "F7" "F8" "F9" "F10"
+        "F11" "F12" "F13" "F14" "F15" "HELP"
+      * Modified key like "C-a" or "M-C-a"
+
+      And you can following as ((|cmd_str|))
+      * "backward-char",
+      * "forward-char",
+      * "backward-delete-char",
+      * "delete-char",
+      * "kakutei",
+      * "kettei",
+      * "space",
+      * "keyboard-quit",
+      * "set-mark-command",
+      * "kill-region",
+      * "yank",
+      * "copy",
+      * "graph-char",
+      * "upper-char",
+      * "lower-char",
+      * "abbrev-input",
+      * "latin-mode",
+      * "previous-candidate",
+      * "jisx0208-mode",
+      * "toggle-kana",
+      * "beginning-of-line"
+      * "end-of-line"
+      * "do-nothing"
+
+      You should not set any command on one ascii character like "a" or "/".
+
+--- SDL::SKK::Keybind#set_default_key
+      Set default keybind. You should call this method immediately after
+      call ((<SDL::SKK::Keybind.new>))
+
+--- SDL::SKK::Keybind#unset_key(key_str)
+      Unset keybind.
+
+== 3D drawing with OpenGL
+You can draw 3D graphics with OpenGL.
+
+How to use OpenGL.
+(1) require 'sdl'; require 'opengl'
+(2) Call ((<SDL.init>)) with SDL::INIT_VIDEO
+(3) Set attribute of OpenGL, please use ((<SDL.setGLAttr>))
+(4) Call ((<SDL.setVideoMode>)) with SDL::OPENGL
+(5) Use GL module methods to draw
+(6) Call ((<SDL.GLSwapBuffersn>)) instead of ((<SDL.flip>)) to update screen
+
+Please see sample/opengl.rb .
+
+=== module function
+--- SDL.setGLAttr(attr,val)
+--- SDL.set_GL_attr(attr,val)
+      Set the value of special SDL/OpenGL attribute.
+
+      List of attribute:
+      * SDL::GL_RED_SIZE
+      * SDL::GL_GREEN_SIZE
+      * SDL::GL_BLUE_SIZE
+      * SDL::GL_ALPHA_SIZE
+      * SDL::GL_BUFFER_SIZE
+      * SDL::GL_DOUBLEBUFFER
+      * SDL::GL_DEPTH_SIZE
+      * SDL::GL_STENCIL_SIZE
+      * SDL::GL_ACCUM_RED_SIZE
+      * SDL::GL_ACCUM_GREEN_SIZE
+      * SDL::GL_ACCUM_BLUE_SIZE
+      * SDL::GL_ACCUM_ALPHA_SIZE
+
+--- SDL.getGLAttr(attr)
+--- SDL.get_GL_attr(attr)
+      Get the value of special SDL/OpenGL attribute.
+      
+--- SDL.GLSwapBuffers
+--- SDL.GL_swap_buffers
+      Swap the OpenGL buffers, update display, if double-buffering is supported.
+      
+== Others
+=== Avoid pthread problem
+You can possibly avoid Ruby/SDL pthread problem when you put following 
+in your script.
+  require 'rbconfig'
+  
+  if RUBY_PLATFORM =~ /linux/
+    trap('INT','EXIT')
+    trap('EXIT','EXIT')
+  end
+
+=end