glfw 1.0.3 → 3.3.2.0

data/lib/glfw/stubs/cursor.rb

@@ -0,0 +1,21 @@
+
+module GLFW
+
+  ##
+  # Describes the application's mouse cursor object and how it appears for the window.
+  class Cursor
+
+    ##
+    # @overload initialize(shape)
+    #   Creates a new cursor using a standard shape defined by the operating system.
+    #   @param shape [Integer] An integer representing the shape of the cursor to create.
+    #
+    # @overload initialize(image, xhot = 0, yhot = 0)
+    #   Creates a new cursor using the specified image.
+    #   @param image [Image] A source image to use for the cursor's appearance.
+    #   @param xhot [Integer] The "hot-point" of the cursor on the x-axis, where 0 is the left edge of the image.
+    #   @param yhot [Integer] The "hot-point" of the cursor on the y-axis, where 0 is the top edge of the image.
+    def initialize(*argv)
+    end
+  end
+end

data/lib/glfw/stubs/gamepad_state.rb

@@ -0,0 +1,30 @@
+
+module GLFW
+
+    ##
+  # Describes the captured state of a gamepad.
+  class GamepadState
+
+    ##
+    # Queries the value of the axis at the specified index.
+    # 
+    # @param index [Integer] The desired index of the axis to query.
+    #
+    # @return [Float] The current axis value, or `0.0` if out of range.
+    # @note It is recommended to use the return value rounded to a specific precision, or "dead zone", as many devices
+    #   will report miniscule values even when stationary.
+    # @note Use the class constants prefixed with `AXIS` for strongly typed index values if desired.
+    def axis(index)
+    end
+
+    ##
+    # Queries the button state at the specified index.
+    #
+    # @param index [Integer] The desired index of the button to query.
+    #
+    # @return [Float] `true` if button is depressed, otherwise `false` if no input is detected or if index is out of range.
+    # @note Use the class constants prefixed with `BUTTON` for strongly typed index values if desired.
+    def button(index)
+    end
+  end
+end

data/lib/glfw/stubs/image.rb

@@ -0,0 +1,39 @@
+
+module GLFW
+
+  ##
+  # Object describing a raw image with uncompressed pixel data, with 32-bytes per pixel in RGBA byte order. 
+  #
+  # This class may also be used for creating textures with OpenGL, simply use `GL_RGBA` as the pixel format
+  # and pass the value of the {pixels} method.
+  class Image
+
+    ##
+    # @return [Integer] the width of the image, in pixel units.
+    attr_reader :width
+
+    ##
+    # @return [Integer] the height of the image, in pixel units.
+    attr_reader :height
+
+    ##
+    # @overload initialize(width, height, pixels = nil)
+    #
+    # @overload initialize(filename)
+    #
+    def initialize(width, height, pixels)
+    end
+
+    ##
+    # Gets the pixel data as a binary blob.
+    #
+    # @return [String] the pixel data.
+    def pixels
+    end
+
+    alias_method :columns, :width
+    alias_method :rows, :height
+    alias_method :to_blob, :pixels
+  end
+
+end

data/lib/glfw/stubs/joystick.rb

@@ -0,0 +1,125 @@
+
+module GLFW
+
+  ##
+  # Provides methods for interacting and querying joystick and gamepad peripherals.
+  module Joystick
+
+    ##
+    # Retrieves the state of the specified joystick remapped to an Xbox-like gamepad.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [GamepadState?] the gamepad input state of the joystick or `nil` if an error occurred.
+    def self.gamepad_state(jid)
+    end
+
+    ##
+    # Returns the name, encoded as UTF-8, of the specified joystick. 
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [String?] the UTF-8 encoded name of the gamepad, or `nil` if the joystick is not present, does not
+    #   have a mapping or an error occurred.
+    def self.name(jid)
+    end
+
+    ##
+    # Returns the human-readable name of the gamepad from the gamepad mapping assigned to the specified joystick.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [String?] the UTF-8 encoded name of the gamepad, or `nil` if the joystick is not present, does not
+    #   have a mapping or an error occurred.
+    def self.gamepad_name(jid)
+    end
+
+    ##
+    # Returns whether the specified joystick is present.
+    #
+    # @param jid [Integer] The joystick index to query.
+    # @return [Boolean] `true` if joystick is detected, otherwise `false`.
+    # @note There is no need to call this function before other functions that accept a joystick ID, as they all check
+    #   for presence before performing any other work.
+    def self.present?(jid)
+    end
+
+    ##
+    # Returns whether the specified joystick is both present and has a gamepad mapping.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [Boolean] `true` if joystick is detected and it has gamepad mappings, otherwise `false`
+    def self.gamepad?(jid)
+    end
+
+    ##
+    # Returns the SDL compatible GUID, as a UTF-8 encoded hexadecimal string, of the specified joystick
+    # The GUID is what connects a joystick to a gamepad mapping. A connected joystick will always have a
+    # GUID even if there is no gamepad mapping assigned to it.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [String?] The UTF-8 encoded GUID of the joystick, or `nil` if the joystick is not present or an error occurred.
+    def self.guid(jid)
+    end
+
+    ##
+    # Returns the state of all buttons of the specified joystick.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [Array<Boolean>] an array where each element represents the joystick button at the same index, whose value
+    #   if either `true` (pressed) or `false` (released).
+    def self.buttons(jid)
+    end
+
+    ##
+    # Returns the values of all axes of the specified joystick. Each element in the array is a value between
+    # `-1.0` and `1.0`.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [Array<Float>] an array where each element represents the joystick axis at the same index
+    def self.axes(jid)
+    end
+
+    ##
+    # Returns the state of all hats of the specified joystick.
+    #
+    # @param jid [Integer] The joystick index to query.
+    #
+    # @return [Array<Boolean>] an array where each element represents the joystick hats at the same index, whose value
+    #   if either `true` (pressed) or `false` (released).
+    def self.hats(jid)
+    end
+
+    ##
+    # Parses the specified ASCII encoded string(s) and updates the internal list with any gamepad mappings it finds.
+    # This string may contain either a single gamepad mapping or many mappings separated by newlines. 
+    #
+    # If there is already a gamepad mapping for a given GUID in the internal list, it will be replaced by the one
+    # passed to this function. If the library is terminated and re-initialized the internal list will revert to the
+    # built-in default.
+    #
+    # @note The parser supports standard SDL gamepad mappings.
+    #
+    # @param mapping [String,Array<String>] One or more mappings to update.
+    #
+    # @return [Integer] the number of mappings that were updated.
+    def self.update_mappings(*mapping)
+    end
+
+    ##
+    # @overload self.on_connection(&block)
+    #   When called with a block, sets a callback to be invoked when the connection state of a joystick is changed.
+    #   @yieldparam connected [Boolean] `true` if device was connected, otherwise `false` if disconectted.
+    #
+    # @overload self.on_connection
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def self.on_connection
+    end
+  end
+end

data/lib/glfw/stubs/monitor.rb

@@ -0,0 +1,115 @@
+
+module GLFW
+
+  ##
+  # Represents a handle to a physical monitor.
+  class Monitor
+
+    ##
+    # Retrieves an array of all connected monitors.
+    # @return [Array<Monitor>] an array of monitors.
+    # @see primary
+    def self.available
+    end
+
+    ##
+    # @return [Monitor] the primary or "default" monitor.
+    # @see available
+    def self.primary
+    end
+
+    ##
+    # @overload self.on_connection(&block)
+    #   When called with a block, sets a callback to be invoked when the connection
+    #   state of a monitor is changed.
+    #   @yieldparam connected [Boolean] `true` if device was connected, otherwise `false` if disconectted.
+    #
+    # @overload self.on_connection
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def self.on_connection
+    end
+
+    ##
+    # Generates an appropriately sized gamma ramp from the specified exponent and
+    # then sets the {gamma_ramp} with it. The value must be a finite number greater
+    # than zero.
+    #
+    # The software controlled gamma ramp is applied in addition to the hardware gamma
+    # correction, which today is usually an approximation of sRGB gamma. This means
+    # that setting a perfectly linear ramp, or gamma 1.0, will produce the default
+    # (usually sRGB-like) behavior.
+    #
+    # @param [Float] the desired exponent value, must be greater than `0.0` and finite.
+    #
+    # @return [void]
+    def gamma(exponent)
+    end
+
+    ##
+    # Sets teh gamma ramp of the monitor. The ramp is an array of 3 equally sized
+    # arrays of integers that range from `0` to `65535`. Each child array represents
+    # the ramp for a single color component, in RGB order.
+    #
+    # @note It is strongly recommended to use {gamma} instead of this method.
+    # @note On Windows, the maximum size of a gamma ramp is 256.
+    #
+    # @return [Array<Array<Integer>, Array<Integer> Array<Integer>>] the gamma ramp.
+    attr_accessor :gamma_ramp
+
+    ##
+    # The human-readable name of the specified monitor. The name typically reflects
+    # the make and model of the monitor and is not guaranteed to be unique among the
+    # connected monitors.
+    # @return [String] the monitor name.
+    attr_reader :name
+
+    ##
+    # @return [Size] the physical dimensions of the monitor, in millimeter units.
+    attr_reader :physical_size
+
+    ##
+    # @return [Size] the dimensions of the monitor, in screen coordinates.
+    attr_reader :size
+
+    ##
+    # The position, in screen coordinates, of the upper-left corner of the work area.
+    # The work area is defined as the area of the monitor not occluded by the operating
+    # system task bar where present. If no task bar exists then the work area is the
+    # monitor resolution in screen coordinates.
+    # @return [Point] the location of the monitor's work area.
+    attr_reader :client_position
+
+    ##
+    # The size of the "non-system" area of the monitor, in screen coordinates.
+    # The work area is defined as the area of the monitor not occluded by the operating
+    # system task bar where present. If no task bar exists then the work area is the
+    # monitor resolution in screen coordinates.
+    # @return [Size] the size of the monitor's work area.
+    attr_reader :client_size
+
+    ##
+    # @return [VideoMode] the current video mode for the monitor.
+    attr_reader :video_mode
+
+    ##
+    # @return [Array<VideoMode>] an array of all video modes available to the monitor.
+    attr_reader :video_modes
+
+    ##
+    # etrieves the content scale for the specified monitor. The content scale is the ratio
+    # between the current DPI and the platform's default DPI. This is especially important
+    # for text and any UI elements. If the pixel dimensions of your UI scaled by this look
+    # appropriate on your machine then it should appear at a reasonable size on other machines
+    # regardless of their DPI and scaling settings. This relies on the system DPI and scaling
+    # settings being somewhat correct.
+    #
+    # The content scale may depend on both the monitor resolution and pixel density and on user
+    # settings. It may be very different from the raw DPI calculated from the physical size and
+    # current resolution.
+    #
+    # @return [Vec2] the current content scale of the monitor.
+    attr_reader :content_scale
+  end
+end

data/lib/glfw/stubs/video_mode.rb

@@ -0,0 +1,32 @@
+
+module GLFW
+
+  ##
+  # Describes the video settings for a {Monitor}.
+  class VideoMode
+
+    ##
+    # @return [Integer] the width, in screen coordinates, of the video mode.
+    attr_reader :width
+
+    ##
+    # @return [Integer] the height, in screen coordinates, of the video mode.
+    attr_reader :height
+
+    ##
+    # @return [Integer] the bit depth of the red channel of the video mode.
+    attr_reader :red_bits
+
+    ##
+    # @return [Integer] the bit depth of the green channel of the video mode.
+    attr_reader :green_bits
+
+    ##
+    # @return [Integer] the bit depth of the blue channel of the video mode.
+    attr_reader :blue_bits
+
+    ##
+    # @return [Integer] the refresh rate, in Hz, of the video mode.
+    attr_reader :refresh_rate
+  end
+end

data/lib/glfw/stubs/window.rb

@@ -0,0 +1,626 @@
+
+module GLFW
+
+  ##
+  # Represents an application window and OpenGL context.
+  class Window
+
+    ##
+    # Resets all window hints that have been applied back to the "default" configuration.
+    # @return [void]
+    def self.default_hints
+    end
+
+    ##
+    # Sets a hint for the next window creation. Once set, the value will persist until changed with this function
+    # or the library is terminated.
+    #
+    # @param hint [Integer] A value indicating the hint to change. See the GLFW constants prefixed with `HINT`
+    #   for valid values for this parameter.
+    # @param value [Integer,Boolean,String] The desired value to set for this hint.  
+    # 
+    # @return [void]
+    def self.hint(hint, value)
+    end
+
+    ##
+    # @return [Window?] the {Window} whose context is current on the calling thread, or `nil` if none is found.
+    def self.current
+    end
+
+    ##
+    # Creates a new instance of the {Window} class.
+    #
+    # @param width [Integer] The desired width of the window, in screen coordinates.
+    # @param height [Integer] The desired height of the window, in screen coordinates.
+    # @param title [String?] The caption to display in the system menubar, window titlebar, etc.
+    # @param opts [Hash] The options hash.
+    # 
+    # @option opts [Boolean] :center (true) `true` to have window initially centered on screen.
+    # @option opts [Boolean] :vsync (true) `true` to enable vertical syncronization with the monitor refresh.
+    # @option opts [Monitor] :monitor (nil) Specifies a monitor to create the window on.
+    # @option opts [Window] :shared (nil) Specified another window instance to share context resources with.
+    # @option opts [Boolean] :full_window (false) Initializes window as "borderless fullscreen", which allows faster context switching.
+    # @option opts [Boolean] :fullscreen (false) Initializes window as fullscreen.
+    #
+    # @note The OpenGL coontext will automatically be made current on the thread for the new window.
+    def initialize(width, height, title = nil, **opts)
+    end
+
+    ##
+    # Destroys the window, reclaiming any resources it is using and invalidating it for further use.
+    # @return [void]
+    def destroy
+    end
+
+    alias_method :dispose, :destroy
+
+    ##
+    # Sets the OpenGL context of the window as current on the calling thread.
+    # @return [self]
+    # @see current?
+    def make_current
+    end
+
+    ##
+    # Returns value indicating if the OpenGL context of this window is current on the calling thread.
+    # @return [Boolean] `true` if context is current, otherwise `false`.
+    # @see make_current
+    def current?
+    end
+
+    ##
+    # Returns value indicating if the window currently contains the operating system input focus.
+    # @return [Boolean] `true` if window has input focus, otherwise `false`.
+    def focused?
+    end
+
+    ##
+    # Returns value indicating if window is currently minimized to the system toolbar.
+    # @return [Boolean] `true` if window is minimized, otherwsie `false`.
+    def minimized?
+    end
+
+    ##
+    # Returns value indicated if window is currently maximized to fill the work area of the monitor.
+    # @return [Boolean] `true` if window is maximized, otherwise `false`.
+    def maximized?
+    end
+
+    ##
+    # Returns value indicating if the mouse cursor is currently over thw window's client area.
+    # @return [Boolean] `true` if cursor is over the window, otherwise `false`.
+    def hovered?
+    end
+
+    ##
+    # Returns value indicating if window is currently in fullscreen mode on the monitor.
+    # @return [Boolean] `true` if window is fullscreen, otherwise `false`.
+    def fullscreen?
+    end
+
+    ##
+    # Modifies the behavior when a user resizes the window to stay locked to the specified aspect ratio.
+    #
+    # @param numerator [Integer] The numerator component of the aspect ratio.
+    # @param denominator [Integer] The denominator component of the aspect ratio.
+    #
+    # @return [void]
+    def aspect_ratio(numerator, denominator)
+    end
+
+    ##
+    # Sets the minimum and maximum sizes that a user can resize the window to.
+    #
+    # @param min [Size] The minimum size of the window's client area the user can resize to, in screen coordinates.
+    # @param max [Size] The maximum size of the window's client area the user can resize to, in screen coordinates.
+    #
+    # @return [void]
+    def size_limits(min, max)
+    end
+
+    ##
+    # Retrieves the size, in screen coordinates, of each edge of the frame of the specified window. This size includes the title bar, 
+    # if the window has one.
+    #
+    # @return [Array<Integer>] a 4-element array in the order of left, top, right, bottom, where each value is the size, in
+    #   screen coordinates, of the window's frame.
+    #
+    # @note Values will always be greater than or equal to `0`.
+    def frame_size
+    end
+
+    ##
+    # Moves the mouse cursor to the specified coordinates.
+    #
+    # @param x [Float] The location to move the cursor to on the x-axis in screen coordinates, relative to the window's client area.
+    # @param y [Float] The location to move the cursor to on the y-axis in screen coordinates, relative to the window's client area.
+    #
+    # @return [void]
+    def move_cursor(x, y)
+    end
+
+    ##
+    # Centers a window on the screen. Has no effect on fullscreen windows.
+    # @return [self]
+    def center
+    end
+
+    ##
+    # Sets the closing state of the window.
+    # 
+    # @param flag [Boolean] `true` to set window state to close, otherwise `false` to cancel a close action that is in progress.
+    #
+    # @return [self]
+    #
+    # @see closing?
+    # @see on_close
+    def close(flag = true)
+    end
+
+    ##
+    # Retrieves value indicating if window is currently set to close.
+    #
+    # return [Boolean] `true` if window is set to close, otherwise `false`.
+    #
+    # @see close
+    # @see on_close
+    def closing?
+    end
+
+    ##
+    # Typically called each frame, swaps the front and back buffers used for rendering, presenting the current back buffer to the
+    # user, while staging the current front buffer to be overwritten.
+    #
+    # @return [void]
+    def swap_buffers
+    end
+
+    ##
+    #  Makes the window visible if it was previously hidden.
+    #  If the window is already visible or is in full screen mode, this method does nothing.
+    #
+    # @return [self]
+    # @see hide
+    def show
+    end
+
+    ##
+    # Hides the window if it was previously visible.
+    # If the window is already hidden or is in full screen mode, this method does nothing.
+    #
+    # @return [self]
+    # @see show
+    def hide
+    end
+
+    ##
+    # Brings the specified window to front and sets input focus. The window should already be visible and not minimized.
+    # @return [self]
+    def focus
+    end
+
+    ##
+    # Mminimizes the window if it was previously restored. If the window is already iconified, this function does nothing.
+    # If the window is fullscreen, the original monitor resolution is restored until the window is restored.
+    #
+    # @return [self]
+    # @see maximize
+    # @see restore
+    def minimize
+    end
+
+    ##
+    # Maximizes the window if it was previously not maximized. If the window is already maximized, this function does nothing.
+    # If the window is fullscreen, this function does nothing.
+    #
+    # @return [self]
+    # @see minimize
+    # @see restore
+    def maximize
+    end
+
+    ##
+    # Restores the window if it was previously minimized or maximized. If the window is already restored, this function does nothing.
+    # If the window is fullscreen, the resolution chosen for the window is restored on the selected monitor.
+    #
+    # @return [self]
+    # @see minimize
+    # @see maximize
+    def restore
+    end
+
+    ##
+    # Requests user attention to the window. On platforms where this is not supported, attention is requested to the application as a whole.
+    # Once the user has given attention, usually by focusing the window or application, the system will end the request automatically.
+    #
+    # @return [self]
+    def request_attention
+    end
+
+    ##
+    # Returns the last state reported for the specified key to the window.
+    #
+    # @param key [Integer] The key to query.
+    #
+    # @return [Boolean] `true` if key is depressed, otherwise `false`.
+    # @see button?
+    # @see on_key
+    def key?(key)
+    end
+
+    ##
+    # Returns the last state reported for the specified mouse button to the window.
+    #
+    # @param key [Integer] The mouse button to query.
+    #
+    # @return [Boolean] `true` if mouse button is depressed, otherwise `false`.
+    # @see key?
+    # @see on_mouse_button
+    def button?(button)
+    end
+
+    ##
+    # Ssets the monitor that the window uses for full screen mode or, if the monitor is `nil`,
+    # makes it windowed mode.
+    #
+    # When setting a monitor, this function updates the width, height and refresh rate of the
+    # desired video mode and switches to the video mode closest to it. The window position is
+    # ignored when setting a monitor.
+    #
+    # When the monitor is `nil`, the position, width and height are used to place the window
+    # content area. The refresh rate is ignored when no monitor is specified.
+    #
+    # When a window transitions from full screen to windowed mode, this function restores any previous
+    # window settings such as whether it is decorated, floating, resizable, has size or aspect
+    # ratio limits, etc.
+    #
+    # @param monitor [Monitor?] The desired monitor, or `nil` to set windowed mode.
+    # @param position [Point] The desired location of the upper-left corner of the content area.
+    # @param size [Size] The desired size in screen coordinates of the content area or video mode.
+    # @param hz [Integer] The desired refresh rate, in Hz, of the video mode, or `-1` to ignore.
+    #
+    # @return [void]
+    def change_monitor(monitor, position, size, hz = -1)
+    end
+
+    ##
+    # @return [String?] the window caption displayed in the system menubar, window titlebar, etc.
+    attr_accessor :title
+
+    ##
+    # @return [Boolean] the visibility state of the window.
+    attr_accessor :visible
+
+    ##
+    # @return [Boolean] `true` if window is floating (always-on-top) of other application windows, otherwise `false`.
+    attr_accessor :topmost
+
+    ##
+    # The icon(s) to be displayed as a window decoration, on systems that support this functionality.
+    # @return [Image, Array<Image>] an image or array of possible images.
+    attr_accessor :icon
+
+    ##
+    # @return [Point] the position of the top-left corner of the window's client area, in screen coordinates.
+    attr_accessor :position
+
+    ##
+    # @return [Size] the size of the window's client area, in screen coordinates.
+    attr_accessor :size
+
+    ##
+    # @return [Cursor?] the mouse cursor the window uses, or `nil` if not specified.
+    attr_accessor :cursor
+
+    ##
+    # @return [Vec2] the location of the mouse cursor.
+    attr_accessor :cursor_pos
+
+    ##
+    # @return [Float] a value determining the visibility of the window (including frame), where `0.0` is invisible and `1.0` is fully opaque.
+    attr_accessor :opacity
+
+    ##
+    # @return [Boolean] a value indicating if the window will be decoarted with a frame, close widget, etc.
+    attr_accessor :decorated
+
+    ##
+    # @return [Boolean] a value indicating if window is resizable by the user.
+    attr_accessor :resizable
+
+    ##
+    # @return [String?] a string for the clipboard associated with the window.
+    attr_accessor :clipboard
+
+    ##
+    # @return [Boolean] a value indicating if window will automatically focus when being restored from minimized state, etc.
+    attr_accessor :auto_focus
+
+    ##
+    # @return [Integer] a value indicating the behavior of the mouse cursor.
+    # @see CURSOR_NORMAL
+    # @see CURSOR_HIDDEN
+    # @see CURSOR_DISABLED
+    attr_accessor :cursor_mode
+
+    ##
+    # @return [Boolean] a value indicating if input states for keys will persist until queried with {key?}.
+    attr_accessor :sticky_keys
+
+    ##
+    # @return [Boolean] a value indicating if input states for mouse buttons will persist until queried with {button?}.
+    attr_accessor :sticky_buttons
+
+    ##
+    # @return [Boolean] a value indicating if modifier bits for input callback functions will include {MOD_CAPS_LOCK}, {MOD_NUM_LOCK}, etc.
+    attr_accessor :lock_modifiers
+
+    ##
+    # When the cursor is disabled, raw (unscaled and unaccelerated) mouse motion can be enabled if available.
+    #
+    # Raw mouse motion is closer to the actual motion of the mouse across a surface. It is not affected by the
+    # scaling and acceleration applied to the motion of the desktop cursor. That processing is suitable for a
+    # cursor while raw motion is better for controlling for example a 3D camera. Because of this, raw mouse
+    # motion is only provided when the cursor is disabled.
+    #
+    # @return [Boolean] `true` if raw mouse motion is enabled, otherwise `false`.
+    attr_accessor :raw_mouse_motion
+
+    ##
+    # @return [Monitor?] the monitor the window is displayed on, or `nil` if not a fullscreen window. 
+    attr_reader :monitor
+
+    ##
+    # @return [Vec2] the current content scale of the window.
+    attr_reader :content_scale
+
+    ##
+    # @return [Size] the dimensions of the window's primary framebuffer, in pixel coordinates.
+    attr_reader :framebuffer_size
+
+    # @!group Callback Functions
+
+    ##
+    # @overload on_framebuffer_resize(&block)
+    #   When called with a block, sets a callback to be invoked when the window's framebuffer size changes.
+    #   @yieldparam width [Integer] The new width of the framebuffer, in pixel units.
+    #   @yieldparam height [Integer] The new height of the framebuffer, in pixel units.
+    #
+    # @overload on_framebuffer_resize
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see framebuffer_size
+    def on_framebuffer_resize
+    end
+
+    ##
+    # @overload on_resize(&block)
+    #   When called with a block, sets a callback to be invoked when the window size changes.
+    #   @yieldparam width [Integer] The new width of the window's client area, in screen coordinates.
+    #   @yieldparam height [Integer] The new height of the window's client area, in screen coordinates.
+    #
+    # @overload on_resize
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see size
+    def on_resize
+    end
+
+    ##
+    # @overload on_move(&block)
+    #   When called with a block, sets a callback to be invoked when the window's position is changed.
+    #   @yieldparam x [Integer] The new position of the window on the x-axis, in screen coordinates.
+    #   @yieldparam y [Integer] The new position of the window on the y-axis, in screen coordinates.
+    #
+    # @overload on_move
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see position
+    def on_move
+    end
+
+    ##
+    # @overload on_focus(&block)
+    #   When called with a block, sets a callback to be invoked when the window gains or loses input focus.
+    #   @yieldparam focused [Boolean] `true` if window has gained focus, otherwise `false` if it was lost.
+    #
+    # @overload on_focus
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see focus
+    # @see focused?
+    def on_focus
+    end
+
+    ##
+    # @overload on_refresh(&block)
+    #   When called with a block, sets a callback to be invoked when the content area of the window needs
+    #   to be redrawn, for example if the window has been exposed after having been covered by another window.
+    #   @yield No arguments are yielded to the block.
+    #
+    # @overload on_refresh
+    #   When called without a block, clears any callback that is set.
+    #
+    # @note On compositing window systems such as Aero, Compiz, Aqua or Wayland, where the window contents
+    #   are saved off-screen, this callback may be called only very infrequently or never at all.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def on_refresh
+    end
+
+    ##
+    # @overload on_close(&block)
+    #   When called with a block, sets a callback to be invoked when the window is flagged to close.
+    #   @yield No arguments are yielded to the block.
+    #
+    # @overload on_close
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see close
+    # @see closing?
+    def on_close
+    end
+
+    ##
+    # @overload on_minimize(&block)
+    #   When called with a block, sets a callback to be invoked when the window minimized or restored.
+    #   @yieldparam minimized [Boolean] `true` if window has been minimized, otherwise `false` if being restored.
+    #
+    # @overload on_minimize
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see minimize
+    # @see minimized?
+    def on_minimize
+    end
+
+    ##
+    # @overload on_maximize(&block)
+    #   When called with a block, sets a callback to be invoked when the window maximized or restored.
+    #   @yieldparam maximized [Boolean] `true` if window has been maximized, otherwise `false` if being restored.
+    #
+    # @overload on_maximize
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see maximize
+    # @see maximized?
+    def on_maximize
+    end
+
+    ##
+    # @overload on_file_drop(&block)
+    #   When called with a block, sets a callback to be invoked when a files/folders are drag-dropped onto
+    #   the windows client area.
+    #   @yieldparam paths [Array<String>] An array of the absolite paths of the filepaths that were dropped.
+    #
+    # @overload on_file_drop
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def on_file_drop
+    end
+
+    ##
+    # @overload on_cursor_move(&block)
+    #   When called with a block, sets a callback to be invoked when the mouse cursor moves.
+    #   @yieldparam x [Float] The new cursor position on the x-axis, in screen coordinates and 
+    #     relative to the top-left corner of the window's client area. 
+    #   @yieldparam y [Float] The new cursor position on the y-axis, in screen coordinates and
+    #     relative to the top-left corner of the window's client area.
+    #
+    # @overload on_cursor_move
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see cursor_pos
+    # @see move_cursor
+    def on_cursor_move
+    end
+
+    ##
+    # @overload on_scroll(&block)
+    #   When called with a block, sets a callback to be invoked when the mouse wheel is scrolled.
+    #   @yieldparam x [Float] The scroll amount on the x-axis, or `0.0` when not supported.
+    #   @yieldparam y [Float] The scroll amount on the y-axis. 
+    # 
+    # @overload on_scroll
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def on_scroll
+    end
+
+    ##
+    # @overload on_key(&block)
+    #   When called with a block, sets a callback to be invoked when a key state changes.
+    #   @yieldparam key [Integer] The keyboard key that was pressed or released.
+    #   @yieldparam scancode [Integer] The system-specific scancode of the key.
+    #   @yieldparam action [Integer] A value indicating the state of the key
+    #   @yieldparam modifiers [Integer] A bitfield value of modifier keys that were present during the action.
+    #   
+    # @overload on_key
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see key?
+    # @see RELEASE
+    # @see PRESS
+    # @see REPEAT
+    def on_key
+    end
+
+    ##
+    # @overload on_mouse_button(&block)
+    #   When called with a block, sets a callback to be invoked when a mouse button state changes.
+    #   @yieldparam button [Integer] The mouse button that was pressed or released.
+    #   @yieldparam action [Integer] A value indicating the state of the button.
+    #   @yieldparam modifiers [Integer] A bitfield value of modifier keys that were present during the action.
+    #
+    # @overload on_mouse_button
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see button?
+    # @see RELEASE
+    # @see PRESS
+    # @see REPEAT
+    def on_mouse_button
+    end
+
+    ##
+    # @overload on_cursor_enter(&block)
+    #   When called with a block, sets a callback to be invoked when the mouse cursor enters or leaves
+    #   the content area of the window.
+    #   @yieldparam entered [Booleab] `true` if cursor is entering the window, otherwise `false` when leaving.
+    #
+    # @overload on_cursor_enter
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def on_cursor_enter
+    end
+
+    ##
+    # The character callback is intended for Unicode text input. As it deals with characters, it is keyboard
+    # layout dependent, whereas the key callback is not. Characters do not map 1:1 to physical keys, as a key
+    # may produce zero, one or more characters. If you want to know whether a specific physical key was pressed
+    # or released, see the key callback instead.
+    #
+    # The character callback behaves as system text input normally does and will not be called if modifier keys
+    # are held down that would prevent normal text input on that platform, for example a Super (Command) key on
+    # macOS or Alt key on Windows.
+    #
+    # @overload on_char(&block)
+    #   When called with a block, sets a callback to be invoked when a Unicode character is input.
+    #   @yieldparam codepoint [Integer] A Unicode codepoint.
+    #
+    # @overload on_char
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    def on_char
+    end
+
+    ##
+    # @overload on_scale(&block)
+    #   When called with a block, sets a callback to be invoked when the window's content scale is changed.
+    #   @yieldparam x [Float] The new content scaling factor on the x-axis.
+    #   @yieldparam y [Float] The new content scaling factor on the y-axis.
+    #
+    # @overload on_scale
+    #   When called without a block, clears any callback that is set.
+    #
+    # @return [Proc?] the previous callback that was set, or `nil` if none existed.
+    # @see content_scale
+    def on_scale
+    end
+  end
+end