gosu_android 0.0.1

data/lib/gosu_android/graphics/imageData.rb

@@ -0,0 +1,23 @@
+module Gosu
+  #Contains information about the underlying OpenGL texture and the
+  #u/v space used for image data. Can be retrieved from some images
+  #to use them in OpenGL operations.  
+  class GLTexInfo < Struct.new(:tex_name, :left, :right, :top, :bottom); end 
+    
+  #The ImageData class is an abstract base class for drawable images.
+  #Instances of classes derived by ImageData are usually returned by
+  #Graphics::createImage and usually only used to implement drawing
+  #primitives like Image, which then provide a more specialized and
+  #intuitive drawing interface.  
+  class ImageData
+    def width; end
+    def height; end
+    
+    def draw( x1,  y1,  c1, x2,  y2,  c2, x3,  y3,  c3, x4,  y4,  c4, z, mode);
+    end  
+        
+    def gl_tex_info; end
+    def to_bitmap; end      
+  end
+  
+end

data/lib/gosu_android/graphics/largeImageData.rb

@@ -0,0 +1,116 @@
+require 'gosu_android/graphics/imageData'
+
+module Gosu
+
+    class LargeImageData < ImageData
+      def initilialize(graphics, source, part_width, part_height, border_flags)
+        @full_width = source.width()
+        @full_height = source.height()
+        @parts_x = (1.0 * source.width() / @part_width).ceil.truncate
+        @parts_y = (1.0 * source.height() / @part_height).ceil.truncate
+        @part_width = part_width
+        @part_height = part_height
+        @graphics = graphics
+
+        @parts = Array.new(@parts_x * @parts_y)
+
+        @parts_y.times do |y|
+          @parts_x.times do |x|
+            #The right-most parts don't necessarily have the full width.
+            src_width = @part_width
+            if (x == @parts_x - 1 and source.width() % @part_width != 0)
+                src_width = source.width() % @part_width
+            end
+            #Same for the parts on the bottom.
+            src_height = @part_height
+            if (y == @parts_y - 1 and source.height() % @part_height != 0)
+                src_height = source.height() % @part_height
+            end
+            localBorderFlags = BF_TILEABLE
+            if (x == 0)
+                localBorderFlags = (localBorderFlags & ~BF_TILEABLE_LEFT) | (borderFlags & BF_TILEABLE_LEFT)
+            end
+            if (x == @parts_x - 1)
+                localBorderFlags = (localBorderFlags & ~BF_TILEABLE_RIGHT) | (borderFlags & BF_TILEABLE_RIGHT)
+            end
+            if (y == 0)
+                localBorderFlags = (localBorderFlags & ~BF_TILEABLE_TOP) | (borderFlags & BF_TILEABLE_TOP)
+            end
+            if (y == @parts_y - 1)
+                localBorderFlags = (localBorderFlags & ~BF_TILEABLE_BOTTOM) | (borderFlags & BF_TILEABLE_BOTTOM)
+            end
+
+            @parts[y * @parts_x + x] = @graphics.create_image(source, x * @part_width, y * @part_height, src_width, src_height, localBorderFlags)
+          end
+        end
+      end
+
+      def width
+        @full_width
+      end
+
+      def height
+        @full_height
+      end
+
+      def ipl(a,b,ratio)
+        a+(b-a)*ratio
+      end
+
+      def draw( x1,  y1,  c1, x2,  y2,  c2, x3,  y3,  c3, x4,  y4,  c4, z, mode)
+
+        if Gosu::reorder_coordinates_if_necessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4)
+          x3, y3, c3, x4, y4, c4 = x4, y4,c4, x3, y3, c3
+        end
+
+        c = Color::NONE
+
+        @parts_y.times do |py|
+          @parts_x.times do |px|
+            part = @parts[py * @parts_x + px];
+
+            rel_xl = (px.to_f * @part_width) / width
+            rel_xr = (px.to_f * @part_width + part.width) / width
+            rel_yt = (py.to_f * @part_height) / height
+            rel_yb = (py.to_f * @part_height + part.height) / height
+
+            abs_xtl = ipl(ipl(x1, x3, rel_yt), ipl(x2, x4, rel_yt), rel_xl)
+            abs_xtr = ipl(ipl(x1, x3, rel_yt), ipl(x2, x4, rel_yt), rel_xr)
+            abs_xbl = ipl(ipl(x1, x3, rel_yb), ipl(x2, x4, rel_yb), rel_xl)
+            abs_xbr = ipl(ipl(x1, x3, rel_yb), ipl(x2, x4, rel_yb), rel_xr)
+
+            abs_ytl = ipl(ipl(y1, y3, rel_yt), ipl(y2, y4, rel_yt), rel_xl)
+            abs_ytr = ipl(ipl(y1, y3, rel_yt), ipl(y2, y4, rel_yt), rel_xr)
+            abs_ybl = ipl(ipl(y1, y3, rel_yb), ipl(y2, y4, rel_yb), rel_xl)
+            abs_ybr = ipl(ipl(y1, y3, rel_yb), ipl(y2, y4, rel_yb), rel_xr)
+
+            part.draw(abs_xtl, abs_ytl, c, abs_xtr, abs_ytr, c,
+                abs_xbl, abs_ybl, c, abs_xbr, abs_ybr, c, z, mode)
+          end
+        end
+
+      end
+
+      def gl_tex_info
+        0
+      end
+
+      def to_bitmap()
+        bitmap = Bitmap.new(width, height)
+        @parts_y.times do |y|
+          @parts_x.times do |x|
+            bitmap.insert(@parts[y * @parts_x + x].to_bitmap, x * @part_width, y * @part_height)
+          end
+        end
+        bitmap
+      end
+
+      def insert(bitmap, at_x, at_y)
+        @parts_y.times do |y|
+          @parts_x.times do |x|
+            @parts[y * @parts_x + x].insert(bitmap, at_x - x* @part_width, at_y -y * part_height)
+          end
+        end
+      end
+    end
+end

data/lib/gosu_android/graphics/renderState.rb

@@ -0,0 +1,5 @@
+module Gosu
+  java_import 'gosu.java.RenderState'
+  java_import 'gosu.java.RenderStateManager'
+end
+

data/lib/gosu_android/graphics/texChunk.rb

@@ -0,0 +1,68 @@
+require 'gosu_android/graphics/imageData'
+require 'gosu_android/graphics/common'
+
+module Gosu
+  class TexChunk < ImageData
+    def initialize(graphics, queues, texture, x, y, w, h, padding)
+      #Define object destructor
+      ObjectSpace.define_finalizer(self,
+                    self.class.method(:finalize).to_proc)
+      @graphics = graphics
+      @queues = queues
+      @texture = texture
+      @x = x
+      @y = y
+      @w = w
+      @h = h
+      @padding = padding
+      @info = GLTexInfo.new
+      @info.tex_name = @texture.tex_name
+      #Force float division
+      @info.left = @x.to_f / @texture.size
+      @info.top = @y.to_f / @texture.size
+      @info.right = (@x.to_f + @w) / @texture.size
+      @info.bottom = (@y.to_f + @h) / @texture.size
+    end
+
+    def TexChunk.finalize(id)
+      @texture.free(@x - @padding, @y - @padding)
+    end
+
+    def width
+      @w
+    end
+
+    def height
+      @h
+    end
+
+    def draw( x1,  y1,  c1, x2,  y2,  c2, x3,  y3,  c3, x4,  y4,  c4, z, mode)
+      op = @queues.op_pool.newDrawOp
+      op.render_state.tex_name = @info.tex_name
+      op.render_state.mode = mode
+
+      if Gosu::reorder_coordinates_if_necessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4)
+        x3, y3, c3, x4, y4, c4 = x4, y4,c4, x3, y3, c3
+      end
+      op.vertices_or_block_index = 4
+      op.vertices[0].set(x1, y1, c1)
+      op.vertices[1].set(x2, y2, c2)
+      op.vertices[2].set(x3, y3, c3)
+      op.vertices[3].set(x4, y4, c4)
+
+      op.left = @info.left
+      op.top = @info.top
+      op.right = @info.right
+      op.bottom = @info.bottom
+
+      op.z = z
+      @queues.schedule_draw_op(op)
+    end
+
+    def glTexInfo
+      @info
+    end
+
+    def to_bitmap; end
+  end
+end

data/lib/gosu_android/graphics/texture.rb

@@ -0,0 +1,86 @@
+require 'gosu_android/graphics/blockAllocator'
+require 'gosu_android/graphics/texChunk'
+require 'gosu_android/requires'
+
+module Gosu
+  class Texture
+
+    def initialize(size, gl)
+      #Set finalize
+      ObjectSpace.define_finalizer(self,
+                          self.class.method(:finalize).to_proc)
+      @size = size
+      @allocator = BlockAllocator.new(@size, @size)
+      @num = 0
+      @gl = gl
+      @name = [0].to_java(:int)
+      @gl.glGenTextures(1, @name, 0)
+      if @name[0] == -1
+        raise "Couldn't create OpenGL texture"
+      end
+      @gl.glBindTexture(JavaImports::GL10::GL_TEXTURE_2D, @name[0])
+
+      @gl.glTexImage2D(JavaImports::GL10::GL_TEXTURE_2D, 0, JavaImports::GL10::GL_RGBA, @allocator.width,
+        @allocator.height, 0, JavaImports::GL10::GL_RGBA, JavaImports::GL10::GL_UNSIGNED_BYTE, nil)
+=begin
+      #TODO Should create an empty texture to be filled later
+      pixel = [0]
+      pbb = JavaImports::ByteBuffer.allocateDirect(pixel.length*4)
+      pbb.order(JavaImports::ByteOrder.nativeOrder)
+      pixel_buffer = pbb.asIntBuffer
+      pixel_buffer.put(pixel.to_java(:int))
+      pixel_buffer.position(0)
+      JavaImports::GLUtils.texImage2D(JavaImports::GL10::GL_TEXTURE_2D, 0, 4, @allocator.width, @allocator.height, 0,
+                 JavaImports::GL10::GL_RGBA, JavaImports::GL10::GL_UNSIGNED_BYTE, pixel_buffer)
+
+      @gl.glTexImage2D(JavaImports::GL10::GL_TEXTURE_2D, 0, 4, @allocator.width, @allocator.height, 0,
+                 JavaImports::GL10::GL_RGBA, JavaImports::GL10::GL_UNSIGNED_BYTE, pixel_buffer)
+
+      @gl.glTexParameterf(JavaImports::GL10::GL_TEXTURE_2D,
+        JavaImports::GL10::GL_TEXTURE_MIN_FILTER, JavaImports::GL10::GL_LINEAR)
+      @gl.glTexParameteri(JavaImports::GL10::GL_TEXTURE_2D,
+        JavaImports::GL10::GL_TEXTURE_WRAP_S, JavaImports::GL10::GL_CLAMP_TO_EDGE)
+      @gl.glTexParameteri(JavaImports::GL10::GL_TEXTURE_2D,
+        JavaImports::GL10::GL_TEXTURE_WRAP_T, JavaImports::GL10::GL_CLAMP_TO_EDGE)
+=end
+      @gl.glTexParameterf(JavaImports::GL10::GL_TEXTURE_2D, JavaImports::GL10::GL_TEXTURE_MIN_FILTER, JavaImports::GL10::GL_NEAREST)
+      @gl.glTexParameterf(JavaImports::GL10::GL_TEXTURE_2D, JavaImports::GL10::GL_TEXTURE_MAG_FILTER, JavaImports::GL10::GL_LINEAR)
+    end
+
+    def Texture.finalize(id)
+      @gl.glDeleteTextures(1, @name)
+    end
+
+    def tex_name
+      @name[0]
+    end
+
+    def size
+      @allocator.width
+    end
+
+    def try_alloc(graphics, queues, ptr, bmp, padding)
+      alloc_info = @allocator.alloc(bmp.width, bmp.height)
+      if (not alloc_info[0])
+          return nil
+      end
+      block = alloc_info[1]
+      result = TexChunk.new(graphics, queues, ptr, block.left + padding, block.top + padding,
+                                block.width - 2 * padding, block.height - 2 * padding, padding)
+
+      @gl.glTexSubImage2D(JavaImports::GL10::GL_TEXTURE_2D, 0, block.left, block.top, block.width, block.height,
+        Color::GL_FORMAT, JavaImports::GL10::GL_UNSIGNED_BYTE, bmp.data_java)
+      #@gl.glBindTexture(JavaImports::GL10::GL_TEXTURE_2D, @name[0])
+      #JavaImports::GLUtils.texImage2D(JavaImports::GL10::GL_TEXTURE_2D, 0, bmp.to_open_gl, 0)
+
+      @num += 1
+      result
+    end
+
+    def free(x, y)
+      @allocator.free(x, y)
+      @num -= 1
+    end
+
+  end
+end

data/lib/gosu_android/input/buttons.rb

@@ -0,0 +1,128 @@
+require 'gosu_android/requires'
+
+
+module Gosu
+  Kb0 = JavaImports::KeyEvent::KEYCODE_0
+  Kb1 = JavaImports::KeyEvent::KEYCODE_1
+  Kb2 = JavaImports::KeyEvent::KEYCODE_2
+  Kb3 = JavaImports::KeyEvent::KEYCODE_3
+  Kb4 = JavaImports::KeyEvent::KEYCODE_4
+  Kb5 = JavaImports::KeyEvent::KEYCODE_5
+  Kb6 = JavaImports::KeyEvent::KEYCODE_6
+  Kb7 = JavaImports::KeyEvent::KEYCODE_7
+  Kb8 = JavaImports::KeyEvent::KEYCODE_8
+  Kb9 = JavaImports::KeyEvent::KEYCODE_9
+  KbA = JavaImports::KeyEvent::KEYCODE_A
+  KbB = JavaImports::KeyEvent::KEYCODE_B
+  KbC = JavaImports::KeyEvent::KEYCODE_C
+  KbD = JavaImports::KeyEvent::KEYCODE_D
+  KbE = JavaImports::KeyEvent::KEYCODE_E
+  KbF = JavaImports::KeyEvent::KEYCODE_F
+  KbG = JavaImports::KeyEvent::KEYCODE_G
+  KbH = JavaImports::KeyEvent::KEYCODE_H
+  KbI = JavaImports::KeyEvent::KEYCODE_I
+  KbJ = JavaImports::KeyEvent::KEYCODE_J
+  KbK = JavaImports::KeyEvent::KEYCODE_K
+  KbL = JavaImports::KeyEvent::KEYCODE_L
+  KbM = JavaImports::KeyEvent::KEYCODE_M
+  KbN = JavaImports::KeyEvent::KEYCODE_N
+  KbO = JavaImports::KeyEvent::KEYCODE_O
+  KbP = JavaImports::KeyEvent::KEYCODE_P
+  KbQ = JavaImports::KeyEvent::KEYCODE_Q
+  KbR = JavaImports::KeyEvent::KEYCODE_R
+  KbS = JavaImports::KeyEvent::KEYCODE_S
+  KbT = JavaImports::KeyEvent::KEYCODE_T
+  KbU = JavaImports::KeyEvent::KEYCODE_U
+  KbV = JavaImports::KeyEvent::KEYCODE_V
+  KbW = JavaImports::KeyEvent::KEYCODE_W
+  KbX = JavaImports::KeyEvent::KEYCODE_X
+  KbY = JavaImports::KeyEvent::KEYCODE_Y
+  KbZ = JavaImports::KeyEvent::KEYCODE_Z
+  KbBackspace = JavaImports::KeyEvent::KEYCODE_DEL
+  KbDelete = JavaImports::KeyEvent::KEYCODE_DEL
+  KbDown = JavaImports::KeyEvent::KEYCODE_DPAD_DOWN
+  # On Numpad
+  KbHome = JavaImports::KeyEvent::KEYCODE_HOME
+  KbLeft = JavaImports::KeyEvent::KEYCODE_DPAD_LEFT
+  KbLeftAlt = JavaImports::KeyEvent::KEYCODE_ALT_LEFT
+  KbLeftShift = JavaImports::KeyEvent::KEYCODE_SHIFT_LEFT
+  KbPageDown = JavaImports::KeyEvent::KEYCODE_PAGE_DOWN
+  KbPageUp = JavaImports::KeyEvent::KEYCODE_PAGE_UP
+  # Above the right shift key
+  KbReturn = JavaImports::KeyEvent::KEYCODE_ENTER
+  KbRight = JavaImports::KeyEvent::KEYCODE_DPAD_RIGHT
+  KbRightAlt = JavaImports::KeyEvent::KEYCODE_ALT_RIGHT
+  #KbRightControl = JavaImports::KeyEvent::KEYCODE_CTRL_RIGHT
+  KbRightShift = JavaImports::KeyEvent::KEYCODE_SHIFT_RIGHT
+  KbSpace = JavaImports::KeyEvent::KEYCODE_SPACE
+  KbTab = JavaImports::KeyEvent::KEYCODE_TAB
+  KbUp = JavaImports::KeyEvent::KEYCODE_DPAD_UP
+  #TODO Fix mouse buttons, Mouse access to motion event
+  #MsLeft = JavaImports::MotionEvent::BUTTON_PRIMARY
+  #MsMiddle = JavaImports::MotionEvent::BUTTON_TERTIARY
+  #MsRight = JavaImports::MotionEvent::BUTTON_SECONDARY
+  #TODO Axis wheel is not right
+  #MsWheelDown = JavaImports::MotionEvent::AXIS_WHEEL
+  #MsWheelUp = JavaImports::MotionEvent::AXIS_WHEEL
+  NoButton = 0xffffffff
+  #Not Supported GpDown, GpLeft, GpRight, GpUp
+
+  #Load supported buttons on android above 3.0.0
+  if android.os.Build::VERSION::SDK_INT >= 11
+    KbEnd = JavaImports::KeyEvent::KEYCODE_MOVE_END
+    # On Numpad
+    KbEnter = JavaImports::KeyEvent::KEYCODE_NUMPAD_ENTER
+    KbEscape = JavaImports::KeyEvent::KEYCODE_ESCAPE
+    KbF1 = JavaImports::KeyEvent::KEYCODE_F1
+    KbF10 = JavaImports::KeyEvent::KEYCODE_F10
+    KbF11 = JavaImports::KeyEvent::KEYCODE_F11
+    KbF12 = JavaImports::KeyEvent::KEYCODE_F12
+    KbF2 = JavaImports::KeyEvent::KEYCODE_F2
+    KbF3 = JavaImports::KeyEvent::KEYCODE_F3
+    KbF4 = JavaImports::KeyEvent::KEYCODE_F4
+    KbF5 = JavaImports::KeyEvent::KEYCODE_F5
+    KbF6 = JavaImports::KeyEvent::KEYCODE_F6
+    KbF7 = JavaImports::KeyEvent::KEYCODE_F7
+    KbF8 = JavaImports::KeyEvent::KEYCODE_F8
+    KbF9 = JavaImports::KeyEvent::KEYCODE_F9
+    KbInsert = JavaImports::KeyEvent::KEYCODE_INSERT
+    KbLeftControl = JavaImports::KeyEvent::KEYCODE_CTRL_LEFT
+    KbNumpad0 = JavaImports::KeyEvent::KEYCODE_NUMPAD_0
+    KbNumpad1 = JavaImports::KeyEvent::KEYCODE_NUMPAD_1
+    KbNumpad2 = JavaImports::KeyEvent::KEYCODE_NUMPAD_2
+    KbNumpad3 = JavaImports::KeyEvent::KEYCODE_NUMPAD_3
+    KbNumpad4 = JavaImports::KeyEvent::KEYCODE_NUMPAD_4
+    KbNumpad5 = JavaImports::KeyEvent::KEYCODE_NUMPAD_5
+    KbNumpad6 = JavaImports::KeyEvent::KEYCODE_NUMPAD_6
+    KbNumpad7 = JavaImports::KeyEvent::KEYCODE_NUMPAD_7
+    KbNumpad8 = JavaImports::KeyEvent::KEYCODE_NUMPAD_8
+    KbNumpad9 = JavaImports::KeyEvent::KEYCODE_NUMPAD_9
+    KbNumpadAdd = JavaImports::KeyEvent::KEYCODE_NUMPAD_ADD
+    KbNumpadDivide = JavaImports::KeyEvent::KEYCODE_NUMPAD_DIVIDE
+    KbNumpadMultiply = JavaImports::KeyEvent::KEYCODE_NUMPAD_MULTIPLY
+    KbNumpadSubtract = JavaImports::KeyEvent::KEYCODE_NUMPAD_SUBTRACT
+    # Above the right shift key
+    KbRightControl = JavaImports::KeyEvent::KEYCODE_CTRL_RIGHT
+  end
+
+  #Load supported buttons on android above 4.0.0
+  if android.os.Build::VERSION::SDK_INT >= 15
+    Game pad
+    GpButton0 = JavaImports::KeyEvent::KEYCODE_BUTTON_1
+    GpButton1 = JavaImports::KeyEvent::KEYCODE_BUTTON_2
+    GpButton10 = JavaImports::KeyEvent::KEYCODE_BUTTON_11
+    GpButton11 = JavaImports::KeyEvent::KEYCODE_BUTTON_12
+    GpButton12 = JavaImports::KeyEvent::KEYCODE_BUTTON_13
+    GpButton13 = JavaImports::KeyEvent::KEYCODE_BUTTON_14
+    GpButton14 = JavaImports::KeyEvent::KEYCODE_BUTTON_15
+    GpButton15 = JavaImports::KeyEvent::KEYCODE_BUTTON_16
+    GpButton2 = JavaImports::KeyEvent::KEYCODE_BUTTON_3
+    GpButton3 = JavaImports::KeyEvent::KEYCODE_BUTTON_4
+    GpButton4 = JavaImports::KeyEvent::KEYCODE_BUTTON_5
+    GpButton5 = JavaImports::KeyEvent::KEYCODE_BUTTON_6
+    GpButton6 = JavaImports::KeyEvent::KEYCODE_BUTTON_7
+    GpButton7 = JavaImports::KeyEvent::KEYCODE_BUTTON_8
+    GpButton8 = JavaImports::KeyEvent::KEYCODE_BUTTON_9
+    GpButton9 = JavaImports::KeyEvent::KEYCODE_BUTTON_10
+  end
+end

data/lib/gosu_android/input/input.rb

@@ -0,0 +1,120 @@
+require 'gosu_android/input/buttons'
+
+module Gosu
+  class Button
+    attr_reader :id
+    def initialize(*args)
+      case args.length
+      when 0
+        @id = NoButton
+      when 1
+        @id = args[0]
+      else
+        raise ArgumentError
+      end
+    end
+
+    # Tests whether two Buttons identify the same physical button.
+    def == other
+      self.id == other.id
+    end
+
+    def > other
+      self.id > other.id
+    end
+
+    def < other
+      self.id < other.id
+    end
+  end
+
+  # Struct that saves information about a touch on the surface of a multi-
+  # touch device.
+  class Touch < Struct.new(:id, :x, :y); end
+
+
+  # Manages initialization and shutdown of the input system. Only one Input
+  # instance can exist per application.
+  class Input
+
+    def initialize(display, window)
+      @display = display
+      @window = window
+      @touch_event_list = []
+      @key_event_list = []
+      @id = 0
+    end
+
+    def feed_touch_event(event)
+      @touch_event_list.push event
+    end
+
+    def feed_key_event(keyCode, event)
+      @key_event_list.push [keyCode, event]
+    end
+
+    # Returns the character a button usually produces, or 0.
+    def id_to_char(btn); end
+
+    # Returns the button that has to be pressed to produce the
+    # given character, or noButton.
+    def char_to_id(ch); end
+
+    # Returns true if a button is currently pressed.
+    # Updated every tick.
+    def down(btn); end
+
+    # Returns the horizontal position of the mouse relative to the top
+    # left corner of the window given to Input's constructor.
+    def mouseX; end
+
+    # Returns true if a button is currently pressed.
+    # Updated every tick.
+    def mouseY; end
+
+    # Immediately moves the mouse as far towards the desired position
+    # as possible. x and y are relative to the window just as in the mouse
+    # position accessors.
+    def set_mouse_position(x,  y); end
+
+    # Undocumented for the moment. Also applies to currentTouches().
+    def set_mouse_factors(factorX,  factorY); end
+
+    # Currently known touches.
+    def currentTouches; end
+
+    # Accelerometer positions in all three dimensions (smoothened).
+    def accelerometerX; end
+    def accelerometerY; end
+    def accelerometerZ; end
+
+    # Collects new information about which buttons are pressed, where the
+    # mouse is and calls onButtonUp/onButtonDown, if assigned.
+    def update
+      @touch_event_list.each do |touch_event|
+        touch_event.getPointerCount.times do |index|
+          touch = Touch.new(touch_event. getPointerId(index), touch_event.getX(index), touch_event.getY(index))
+          case touch_event.getAction
+          when JavaImports::MotionEvent::ACTION_DOWN
+            @window.touch_began(touch)
+          when JavaImports::MotionEvent::ACTION_MOVE
+            @window.touch_moved(touch)
+          when JavaImports::MotionEvent::ACTION_UP
+            @window.touch_ended(touch)
+          end
+        end
+      end
+      @touch_event_list = []
+    end
+
+    # Assignable events that are called by update. You can bind these to your own functions.
+    # If you use the Window class, it will assign forward these to its own methods.
+    def button_down; end
+    def button_up; end
+
+    # Returns the currently active TextInput instance, or 0.
+    def text_input; end
+    # Sets the currently active TextInput, or clears it (input = 0).
+    def set_text_input(input); end
+  end
+end