ruby-sfml 3.0.0.0 → 3.0.0.1

data/lib/sfml/graphics/render_target.rb

@@ -15,8 +15,23 @@ module SFML
     # through the right CSFML draw function for whichever target they're
     # being rendered to.
     module RenderTarget
-      def clear(color = Color::BLACK)
-        _csfml(:clear, @handle, color.to_native)
+      # Clear the target's colour buffer (and optionally the stencil
+      # buffer in the same call). Pass `stencil:` to clear the stencil
+      # buffer to the given integer; pass only `stencil:` to clear the
+      # stencil without touching colour.
+      #
+      #   target.clear                              # default black
+      #   target.clear(SFML::Color.cornflower_blue) # only colour
+      #   target.clear(SFML::Color.black, stencil: 0)  # both
+      #   target.clear(stencil: 0)                  # only stencil
+      def clear(color = nil, stencil: nil)
+        if stencil && color
+          _csfml(:clearColorAndStencil, @handle, color.to_native, _stencil_value(stencil))
+        elsif stencil
+          _csfml(:clearStencil, @handle, _stencil_value(stencil))
+        else
+          _csfml(:clear, @handle, (color || Color::BLACK).to_native)
+        end
         self
       end
 
@@ -141,6 +156,12 @@ module SFML
       def _csfml(suffix, *args)
         C::Graphics.public_send(:"#{self.class::CSFML_PREFIX}_#{suffix}", *args)
       end
+
+      def _stencil_value(int)
+        v = C::Graphics::StencilValue.new
+        v[:value] = Integer(int)
+        v
+      end
     end
   end
 end

data/lib/sfml/graphics/render_window.rb

@@ -112,6 +112,52 @@ module SFML
       Vector2.new(v[:x], v[:y])
     end
 
+    # Replace the window's title-bar / taskbar icon with the pixels from
+    # the given SFML::Image. The OS scales it as needed; 32×32 RGBA
+    # is the typical sweet spot.
+    def icon=(image)
+      raise ArgumentError, "RenderWindow#icon= requires a SFML::Image" unless image.is_a?(Image)
+
+      size = C::System::Vector2u.new
+      size[:x] = image.width
+      size[:y] = image.height
+      C::Graphics.sfRenderWindow_setIcon(@handle, size, C::Graphics.sfImage_getPixelsPtr(image.handle))
+    end
+
+    # Constrain user-driven resizes. Accepts a [w, h] Array, a Vector2,
+    # or nil to clear the limit. When set, the OS won't let the user
+    # drag the window smaller (or larger) than this — programmatic
+    # `size=` is not affected.
+    def minimum_size=(value)
+      C::Graphics.sfRenderWindow_setMinimumSize(@handle, _vec2u_or_nil(value))
+    end
+
+    def maximum_size=(value)
+      C::Graphics.sfRenderWindow_setMaximumSize(@handle, _vec2u_or_nil(value))
+    end
+
+    # OS-specific native handle for the underlying window — `HWND` on
+    # Windows, `NSView*` on macOS, X11 `Window` xid on Linux.
+    def native_handle
+      C::Graphics.sfRenderWindow_getNativeHandle(@handle)
+    end
+
+    # Wrap an existing OS-level window. `handle` is a platform native
+    # handle (Integer address or FFI::Pointer). Useful for embedding
+    # the renderer inside another framework's window (Qt, Gtk, raw
+    # Win32, NSView).
+    def self.from_handle(handle)
+      ptr = handle.is_a?(FFI::Pointer) ? handle : FFI::Pointer.new(:void, Integer(handle))
+      raw = C::Graphics.sfRenderWindow_createFromHandle(ptr, nil)
+      raise Error, "sfRenderWindow_createFromHandle returned NULL" if raw.null?
+
+      win = allocate
+      win.instance_variable_set(:@handle,
+        FFI::AutoPointer.new(raw, C::Graphics.method(:sfRenderWindow_destroy)))
+      win.instance_variable_set(:@event_buffer, C::Window::Event.new)
+      win
+    end
+
     # Convenience driver loop. Yields the per-frame delta (SFML::Time) and
     # auto-pumps events + display. The block is responsible for #clear and
     # any drawing.
@@ -136,6 +182,15 @@ module SFML
 
     private
 
+    def _vec2u_or_nil(value)
+      return nil if value.nil?
+
+      vec = value.is_a?(Vector2) ? value : Vector2.new(*value)
+      v = C::System::Vector2u.new
+      v[:x] = Integer(vec.x); v[:y] = Integer(vec.y)
+      v
+    end
+
     def parse_args(args)
       case args.length
       when 2

data/lib/sfml/graphics/shader.rb

@@ -28,8 +28,17 @@ module SFML
   #   [a, b, c]                  → vec3
   #   [a, b, c, d]               → vec4
   #
-  # Need an int / bvec / matrix / array uniform? Use the explicit setters
-  # (#set_int, #set_ivec2, etc.) — they exist for completeness.
+  # Array uniforms (`uniform vec2 positions[8];` and friends):
+  #   [[x, y], [x, y], ...]      → vec2[]
+  #   [[x, y, z], ...]           → vec3[]
+  #   [[x, y, z, w], ...]        → vec4[]
+  #   [Vector2[a, b], ...]       → vec2[]   (also accepts Vector2 / Vector3)
+  #
+  # Float arrays (`uniform float weights[N];`) are ambiguous with vec3
+  # at length 3, so use the explicit `#set_float_array` setter.
+  #
+  # Need an int / bvec / matrix uniform? Use `#set_int`, `#set_ivec2`,
+  # etc. — they exist for completeness.
   class Shader
     # Class-level: is GLSL available on the current GPU at all?
     def self.available?
@@ -85,16 +94,23 @@ module SFML
       when :current_texture
         C::Graphics.sfShader_setCurrentTextureUniform(@handle, n)
       when Array
-        case value.length
-        when 2 then self[name] = Vector2.new(*value)
-        when 3 then self[name] = Vector3.new(*value)
-        when 4
-          v = C::Graphics::GlslVec4.new
-          v[:x] = value[0].to_f; v[:y] = value[1].to_f
-          v[:z] = value[2].to_f; v[:w] = value[3].to_f
-          C::Graphics.sfShader_setVec4Uniform(@handle, n, v)
+        raise ArgumentError, "Shader uniform array must not be empty" if value.empty?
+
+        first = value.first
+        if first.is_a?(Array) || first.is_a?(Vector2) || first.is_a?(Vector3)
+          _set_vec_array_uniform(n, value)
         else
-          raise ArgumentError, "Shader uniform array must be length 2, 3, or 4 (got #{value.length})"
+          case value.length
+          when 2 then self[name] = Vector2.new(*value)
+          when 3 then self[name] = Vector3.new(*value)
+          when 4
+            v = C::Graphics::GlslVec4.new
+            v[:x] = value[0].to_f; v[:y] = value[1].to_f
+            v[:z] = value[2].to_f; v[:w] = value[3].to_f
+            C::Graphics.sfShader_setVec4Uniform(@handle, n, v)
+          else
+            raise ArgumentError, "Shader uniform array must be length 2, 3, or 4 (got #{value.length})"
+          end
         end
       else
         raise ArgumentError,
@@ -114,8 +130,52 @@ module SFML
       C::Graphics.sfShader_setIvec2Uniform(@handle, name.to_s, v)
     end
 
+    # Set a `uniform float arr[N];` from a plain Ruby array of numbers.
+    # Float arrays can't be inferred via `[]=` because they'd collide
+    # with the vec3 case at length 3.
+    def set_float_array(name, values)
+      buf = FFI::MemoryPointer.new(:float, values.length)
+      buf.write_array_of_float(values.map(&:to_f))
+      C::Graphics.sfShader_setFloatUniformArray(@handle, name.to_s, buf, values.length)
+    end
+
     attr_reader :handle # :nodoc:
 
+    private
+
+    # Detect the inner length (2/3/4), pack a contiguous float buffer,
+    # and dispatch to the matching CSFML setVec*UniformArray.
+    def _set_vec_array_uniform(name, elements)
+      raise ArgumentError, "uniform array must not be empty" if elements.empty?
+
+      flat = elements.flat_map do |el|
+        case el
+        when Vector2 then [el.x.to_f, el.y.to_f]
+        when Vector3 then [el.x.to_f, el.y.to_f, el.z.to_f]
+        when Array   then el.map(&:to_f)
+        else
+          raise ArgumentError, "uniform array element must be Array/Vector2/Vector3 (got #{el.class})"
+        end
+      end
+
+      stride = flat.length / elements.length
+      raise ArgumentError, "uniform array elements must all be the same length" \
+        unless flat.length == stride * elements.length
+
+      buf = FFI::MemoryPointer.new(:float, flat.length)
+      buf.write_array_of_float(flat)
+
+      case stride
+      when 2 then C::Graphics.sfShader_setVec2UniformArray(@handle, name, buf, elements.length)
+      when 3 then C::Graphics.sfShader_setVec3UniformArray(@handle, name, buf, elements.length)
+      when 4 then C::Graphics.sfShader_setVec4UniformArray(@handle, name, buf, elements.length)
+      else
+        raise ArgumentError, "uniform array elements must be length 2, 3, or 4 (got #{stride})"
+      end
+    end
+
+    public
+
     # @!visibility private
     def self._wrap(ptr)
       shader = allocate

data/lib/sfml/graphics/stencil_mode.rb

@@ -0,0 +1,93 @@
+module SFML
+  # How a draw call interacts with the stencil buffer. The classic
+  # use is masking — first you draw a "mask" shape that writes a
+  # value into the stencil buffer, then you draw the masked content
+  # with a comparison that only lets pixels through where the
+  # stencil matches.
+  #
+  #   target.clear(SFML::Color.black, stencil: 0)
+  #
+  #   # Phase 1 — write the mask shape into the stencil buffer.
+  #   write = SFML::StencilMode.new(
+  #     comparison: :always, update_operation: :replace, reference: 1,
+  #     only_write_mask: true,   # don't actually paint colour
+  #   )
+  #   target.draw(mask_circle, stencil_mode: write)
+  #
+  #   # Phase 2 — draw the content; only pixels where stencil == 1
+  #   # survive.
+  #   read = SFML::StencilMode.new(
+  #     comparison: :equal, update_operation: :keep, reference: 1,
+  #   )
+  #   target.draw(scene, stencil_mode: read)
+  #
+  # `stencilOnly` (`only_write_mask:`) is a niche flag — set it to
+  # true on the mask-write pass if you don't want the mask shape
+  # itself to be visible in the colour buffer.
+  class StencilMode
+    # Order matches sfStencilComparison in CSFML 3.
+    COMPARISONS = %i[never less less_equal greater greater_equal equal not_equal always].freeze
+    COMPARISON_INDEX = COMPARISONS.each_with_index.to_h.freeze
+
+    # Order matches sfStencilUpdateOperation in CSFML 3.
+    OPERATIONS = %i[keep zero replace increment decrement invert].freeze
+    OPERATION_INDEX = OPERATIONS.each_with_index.to_h.freeze
+
+    attr_reader :comparison, :update_operation, :reference, :mask, :only_write_mask
+
+    def initialize(comparison: :always, update_operation: :keep,
+                   reference: 0, mask: 0xFFFFFFFF, only_write_mask: false)
+      raise ArgumentError, "Unknown stencil comparison: #{comparison.inspect}" \
+        unless COMPARISON_INDEX.key?(comparison)
+      raise ArgumentError, "Unknown stencil update_operation: #{update_operation.inspect}" \
+        unless OPERATION_INDEX.key?(update_operation)
+
+      @comparison       = comparison
+      @update_operation = update_operation
+      @reference        = Integer(reference)
+      @mask             = Integer(mask)
+      @only_write_mask  = !!only_write_mask
+      freeze
+    end
+
+    def ==(other)
+      other.is_a?(StencilMode) &&
+        comparison == other.comparison &&
+        update_operation == other.update_operation &&
+        reference == other.reference &&
+        mask == other.mask &&
+        only_write_mask == other.only_write_mask
+    end
+    alias eql? ==
+    def hash = [comparison, update_operation, reference, mask, only_write_mask].hash
+
+    def to_s
+      "StencilMode(#{comparison}, #{update_operation}, ref=#{reference}, " \
+        "mask=#{format('0x%08X', mask)}, only_write=#{only_write_mask})"
+    end
+    alias inspect to_s
+
+    # @!visibility private
+    # Write our fields into a CSFML StencilMode struct (typically a
+    # sub-struct of an existing RenderStates buffer).
+    def populate(struct)
+      struct[:comparison]       = COMPARISON_INDEX[@comparison]
+      struct[:update_operation] = OPERATION_INDEX[@update_operation]
+      struct[:reference][:value] = @reference
+      struct[:mask][:value]      = @mask
+      struct[:only_write_mask]  = @only_write_mask
+      struct
+    end
+
+    # @!visibility private
+    def self.from_native(struct)
+      new(
+        comparison:       COMPARISONS[struct[:comparison]],
+        update_operation: OPERATIONS[struct[:update_operation]],
+        reference:        struct[:reference][:value],
+        mask:             struct[:mask][:value],
+        only_write_mask:  struct[:only_write_mask],
+      )
+    end
+  end
+end

data/lib/sfml/graphics/vertex_buffer.rb

@@ -0,0 +1,127 @@
+module SFML
+  # GPU-resident vertex buffer. Same shape as VertexArray but the
+  # vertices live in video memory, so a draw call only ships an
+  # index/handle instead of re-uploading the geometry every frame.
+  # Useful for static meshes, large tilemaps, particle systems with
+  # mostly-static positions.
+  #
+  #   buf = SFML::VertexBuffer.new(
+  #     vertices,
+  #     primitive_type: :triangles,
+  #     usage:          :static,
+  #   )
+  #   window.draw(buf)
+  #
+  # Update later (full or partial):
+  #
+  #   buf.update(new_vertices)              # full replace
+  #   buf.update(some_vertices, offset: 32) # patch in place
+  #
+  # If the GPU doesn't support OpenGL vertex buffer objects,
+  # `SFML::VertexBuffer.available?` returns false and you should
+  # fall back to `VertexArray`.
+  class VertexBuffer
+    USAGES       = C::Graphics::VERTEX_BUFFER_USAGES
+    USAGE_INDEX  = USAGES.each_with_index.to_h.freeze
+
+    PRIMITIVE_TYPES = VertexArray::PRIMITIVE_TYPES
+    PRIMITIVE_INDEX = VertexArray::PRIMITIVE_INDEX
+
+    def self.available?
+      C::Graphics.sfVertexBuffer_isAvailable
+    end
+
+    # Build a buffer either from an Array of vertices or by giving an
+    # explicit `count:` to allocate empty (then fill via #update).
+    def initialize(vertices = nil, count: nil, primitive_type: :points, usage: :stream)
+      n = vertices ? vertices.length : Integer(count || 0)
+      raise ArgumentError, "give either `vertices` or `count:`" if n.zero? && vertices.nil?
+
+      ptype = PRIMITIVE_INDEX.fetch(primitive_type) do
+        raise ArgumentError,
+              "Unknown primitive type: #{primitive_type.inspect} " \
+              "(expected one of #{PRIMITIVE_TYPES.inspect})"
+      end
+      uidx = USAGE_INDEX.fetch(usage) do
+        raise ArgumentError,
+              "Unknown VertexBuffer usage: #{usage.inspect} " \
+              "(expected one of #{USAGES.inspect})"
+      end
+
+      ptr = C::Graphics.sfVertexBuffer_create(n, ptype, uidx)
+      raise Error, "sfVertexBuffer_create returned NULL " \
+                   "(VBOs unavailable on this GPU?)" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfVertexBuffer_destroy))
+
+      update(vertices) if vertices && !vertices.empty?
+    end
+
+    def count = C::Graphics.sfVertexBuffer_getVertexCount(@handle)
+    alias size  count
+    alias length count
+
+    def primitive_type
+      PRIMITIVE_TYPES[C::Graphics.sfVertexBuffer_getPrimitiveType(@handle)] || :unknown
+    end
+
+    def primitive_type=(type)
+      idx = PRIMITIVE_INDEX.fetch(type) do
+        raise ArgumentError, "Unknown primitive type: #{type.inspect}"
+      end
+      C::Graphics.sfVertexBuffer_setPrimitiveType(@handle, idx)
+    end
+
+    def usage
+      USAGES[C::Graphics.sfVertexBuffer_getUsage(@handle)] || :unknown
+    end
+
+    def usage=(value)
+      idx = USAGE_INDEX.fetch(value) do
+        raise ArgumentError, "Unknown VertexBuffer usage: #{value.inspect}"
+      end
+      C::Graphics.sfVertexBuffer_setUsage(@handle, idx)
+    end
+
+    # Replace `vertices.length` slots starting at `offset`. Pass an
+    # array longer than the buffer to grow it (CSFML expands when
+    # offset==0 and length > current).
+    def update(vertices, offset: 0)
+      n   = vertices.length
+      buf = FFI::MemoryPointer.new(C::Graphics::Vertex, n)
+      vertices.each_with_index do |v, i|
+        slot = C::Graphics::Vertex.new(buf + i * C::Graphics::Vertex.size)
+        slot[:position][:x]   = v.position.x.to_f
+        slot[:position][:y]   = v.position.y.to_f
+        slot[:color][:r]      = v.color.r
+        slot[:color][:g]      = v.color.g
+        slot[:color][:b]      = v.color.b
+        slot[:color][:a]      = v.color.a
+        slot[:tex_coords][:x] = v.tex_coords.x.to_f
+        slot[:tex_coords][:y] = v.tex_coords.y.to_f
+      end
+
+      ok = C::Graphics.sfVertexBuffer_update(@handle, buf, n, Integer(offset))
+      raise Error, "sfVertexBuffer_update failed " \
+                   "(buffer too small or driver rejected the upload?)" unless ok
+      self
+    end
+
+    def native_handle = C::Graphics.sfVertexBuffer_getNativeHandle(@handle)
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:VertexBuffer, @handle, states_ptr)
+    end
+
+    # Draw a slice of this buffer instead of the whole thing. Useful
+    # when you've packed several meshes back-to-back and want to
+    # render one at a time.
+    def draw_range_on(target, first, count, states_ptr = nil)
+      C::Graphics.public_send(
+        :"#{target.class::CSFML_PREFIX}_drawVertexBufferRange",
+        target.handle, @handle, Integer(first), Integer(count), states_ptr,
+      )
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/network/ftp.rb

@@ -0,0 +1,184 @@
+module SFML
+  module Network
+    # CSFML's FTP client. Useful for the rare game that needs to fetch
+    # extra content from a plain-FTP server. For anything modern,
+    # Ruby's stdlib `Net::FTP` (and the Net::FTP gem) is a much nicer
+    # tool — this binding exists for parity with CSFML.
+    #
+    #   ftp = SFML::Network::Ftp.new
+    #   ftp.connect("ftp.example.com").ok?      #=> true
+    #   ftp.login_anonymous.ok?                  #=> true
+    #   ftp.directory_listing("/").names         #=> ["pub", "incoming", ...]
+    #   ftp.download("/pub/file.bin", "/tmp/")
+    #   ftp.disconnect
+    #
+    # Each call returns a Response (or DirectoryResponse / ListingResponse
+    # for commands that return a path or a list). All responses expose
+    # `#ok?`, `#status` (Integer), `#status_symbol`, `#message`.
+    class Ftp
+      DEFAULT_PORT    = 21
+      DEFAULT_TIMEOUT = SFML::Time.zero
+
+      # FTP status codes mapped to symbols. The transport-error ones
+      # at ≥ 1000 are SFML's, not RFC 959.
+      STATUS_NAMES = {
+        110 => :restart_marker_reply, 120 => :service_ready_soon,
+        125 => :data_connection_already_opened, 150 => :opening_data_connection,
+        200 => :ok, 211 => :system_status, 212 => :directory_status,
+        213 => :file_status, 214 => :help_message,
+        215 => :system_type, 220 => :service_ready, 221 => :closing_connection,
+        225 => :data_connection_opened, 226 => :closing_data_connection,
+        227 => :entering_passive_mode, 230 => :logged_in,
+        250 => :file_action_ok, 257 => :directory_ok,
+        331 => :need_password, 332 => :need_account_to_log_in,
+        350 => :need_information,
+        421 => :service_unavailable, 425 => :data_connection_unavailable,
+        426 => :transfer_aborted, 450 => :file_action_aborted,
+        451 => :local_error, 452 => :insufficient_storage_space,
+        500 => :command_unknown, 501 => :parameters_unknown,
+        502 => :command_not_implemented, 503 => :bad_command_sequence,
+        504 => :parameter_not_implemented, 530 => :not_logged_in,
+        532 => :need_account_to_store, 550 => :file_unavailable,
+        551 => :page_type_unknown, 552 => :not_enough_memory,
+        553 => :filename_not_allowed,
+        1000 => :invalid_response, 1001 => :connection_failed,
+        1002 => :connection_closed, 1003 => :invalid_file,
+      }.freeze
+
+      def initialize
+        ptr = C::Network.sfFtp_create
+        raise Error, "sfFtp_create returned NULL" if ptr.null?
+
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfFtp_destroy))
+      end
+
+      # Connect to an FTP server. `host` may be an IP string ("1.2.3.4")
+      # or hostname ("ftp.example.com"); pass timeout as a SFML::Time
+      # or numeric seconds (default 0 = no timeout).
+      def connect(host, port: DEFAULT_PORT, timeout: DEFAULT_TIMEOUT)
+        addr = IpAddress.from_string(host).struct
+        t    = timeout.is_a?(Time) ? timeout : Time.seconds(timeout.to_f)
+        Response._take_ownership(C::Network.sfFtp_connect(@handle, addr, Integer(port), t.to_native))
+      end
+
+      def login_anonymous
+        Response._take_ownership(C::Network.sfFtp_loginAnonymous(@handle))
+      end
+
+      def login(user, password)
+        Response._take_ownership(C::Network.sfFtp_login(@handle, user.to_s, password.to_s))
+      end
+
+      def disconnect = Response._take_ownership(C::Network.sfFtp_disconnect(@handle))
+      def keep_alive = Response._take_ownership(C::Network.sfFtp_keepAlive(@handle))
+
+      def working_directory
+        DirectoryResponse._take_ownership(C::Network.sfFtp_getWorkingDirectory(@handle))
+      end
+
+      def directory_listing(directory = "")
+        ListingResponse._take_ownership(C::Network.sfFtp_getDirectoryListing(@handle, directory.to_s))
+      end
+
+      def change_directory(directory)
+        Response._take_ownership(C::Network.sfFtp_changeDirectory(@handle, directory.to_s))
+      end
+
+      def parent_directory
+        Response._take_ownership(C::Network.sfFtp_parentDirectory(@handle))
+      end
+
+      def create_directory(name)
+        DirectoryResponse._take_ownership(C::Network.sfFtp_createDirectory(@handle, name.to_s))
+      end
+
+      def delete_directory(name)
+        Response._take_ownership(C::Network.sfFtp_deleteDirectory(@handle, name.to_s))
+      end
+
+      def rename_file(file, new_name)
+        Response._take_ownership(C::Network.sfFtp_renameFile(@handle, file.to_s, new_name.to_s))
+      end
+
+      def delete_file(name)
+        Response._take_ownership(C::Network.sfFtp_deleteFile(@handle, name.to_s))
+      end
+
+      def download(remote, local, mode: :binary)
+        idx = C::Network::FTP_TRANSFER_MODES.index(mode) ||
+          raise(ArgumentError, "Unknown FTP transfer mode: #{mode.inspect}")
+        Response._take_ownership(C::Network.sfFtp_download(@handle, remote.to_s, local.to_s, idx))
+      end
+
+      def upload(local, remote, mode: :binary, append: false)
+        idx = C::Network::FTP_TRANSFER_MODES.index(mode) ||
+          raise(ArgumentError, "Unknown FTP transfer mode: #{mode.inspect}")
+        Response._take_ownership(C::Network.sfFtp_upload(@handle, local.to_s, remote.to_s, idx, !!append))
+      end
+
+      def send_command(command, parameter = "")
+        Response._take_ownership(C::Network.sfFtp_sendCommand(@handle, command.to_s, parameter.to_s))
+      end
+
+      attr_reader :handle # :nodoc:
+
+      # Generic response: most FTP operations return this.
+      class Response
+        def ok?           = C::Network.sfFtpResponse_isOk(@handle)
+        def status        = C::Network.sfFtpResponse_getStatus(@handle)
+        def status_symbol = STATUS_NAMES[status] || status
+        def message       = C::Network.sfFtpResponse_getMessage(@handle).to_s
+        attr_reader :handle # :nodoc:
+
+        # @!visibility private
+        def self._take_ownership(ptr)
+          obj = allocate
+          obj.instance_variable_set(:@handle,
+            FFI::AutoPointer.new(ptr, C::Network.method(:sfFtpResponse_destroy)))
+          obj
+        end
+      end
+
+      # Returned by working_directory and create_directory — adds the
+      # `#directory` accessor on top of Response.
+      class DirectoryResponse
+        def ok?           = C::Network.sfFtpDirectoryResponse_isOk(@handle)
+        def status        = C::Network.sfFtpDirectoryResponse_getStatus(@handle)
+        def status_symbol = STATUS_NAMES[status] || status
+        def message       = C::Network.sfFtpDirectoryResponse_getMessage(@handle).to_s
+        def directory     = C::Network.sfFtpDirectoryResponse_getDirectory(@handle).to_s
+        attr_reader :handle # :nodoc:
+
+        # @!visibility private
+        def self._take_ownership(ptr)
+          obj = allocate
+          obj.instance_variable_set(:@handle,
+            FFI::AutoPointer.new(ptr, C::Network.method(:sfFtpDirectoryResponse_destroy)))
+          obj
+        end
+      end
+
+      # Returned by directory_listing — adds the `#names` array.
+      class ListingResponse
+        def ok?           = C::Network.sfFtpListingResponse_isOk(@handle)
+        def status        = C::Network.sfFtpListingResponse_getStatus(@handle)
+        def status_symbol = STATUS_NAMES[status] || status
+        def message       = C::Network.sfFtpListingResponse_getMessage(@handle).to_s
+        def count         = C::Network.sfFtpListingResponse_getCount(@handle)
+        attr_reader :handle # :nodoc:
+
+        def names
+          Array.new(count) { |i| C::Network.sfFtpListingResponse_getName(@handle, i).to_s }
+        end
+
+        # @!visibility private
+        def self._take_ownership(ptr)
+          obj = allocate
+          obj.instance_variable_set(:@handle,
+            FFI::AutoPointer.new(ptr, C::Network.method(:sfFtpListingResponse_destroy)))
+          obj
+        end
+      end
+    end
+  end
+end