require 'ffi'
require 'win/extensions'
# Related Windows API functions are grouped by topic and defined in separate namespaces (modules),
# that also contain related constants and convenience methods. For example, Win::DDE module
# contains only functions related to DDE protocol such as DdeInitialize() as well as constants
# such as DMLERR_NO_ERROR, APPCLASS_STANDARD, etc. So if you need only DDE-related functions,
# there is no need to load all the other modules, clogging your namespaces - just <b> require 'win/dde' </b>
# and be done with it. Win is just a top level namespace (container) that holds all the other modules.
#
module Win
module Errors # :nodoc:
class NotFoundError < NameError # :nodoc:
def initialize(name=nil, libs=nil)
super %Q[Function #{name ? "'#{name}' ": ""}not found#{libs ? " in #{libs}" : ""}"]
end
end
end
# WIN::Library is a module that extends FFI::Library and is used to connect to Windows API functions
# and wrap them into Ruby methods using 'function' declaration. If you do not see your favorite Windows
# API functions among those already defined, you can easily 'include Win::Library’ into your module
# and declare them using ‘function’ class method (macro) - it does a lot of heavy lifting for you and
# can be customized with options and code blocks to give you reusable API wrapper methods with the exact
# behavior you need.
#
module Library
# Win::Library::API is a wrapper for callable function API object that mimics Win32::API
class API
# The name of the DLL(s) that export this API function
attr_reader :dll_name
# Ruby namespace (module) where this API function is attached
attr_reader :namespace
# The name of the function passed to the constructor
attr_reader :function_name
# The name of the actual Windows API function. For example, if you passed 'GetUserName' to the
# constructor, then the effective function name would be either 'GetUserNameA' or 'GetUserNameW'.
attr_accessor :effective_function_name
# The prototype, returned as an array of FFI types
attr_reader :prototype
# The return type (:void for no return value)
attr_reader :return_type
def initialize( namespace, function_name, effective_function_name, prototype, return_type, dll_name )
@namespace = namespace
@function_name = function_name
@effective_function_name = effective_function_name
@prototype = prototype
@return_type = return_type
@dll_name = dll_name
end
# Calls underlying CamelCase Windows API function with supplied args
def call( *args )
@namespace.send(@function_name.to_sym, *args)
end
# alias_method :[], :call
end
# Contains class methods (macros) that can be used in any module mixing in Win::Library
module ClassMethods
# Mapping of Windows API types and one-letter shortcuts into FFI types.
# Like :ATOM => :ushort, :LPARAM => :long, :c => :char, :i => :int
TYPES = {
# FFI type shortcuts
C: :uchar, #– 8-bit unsigned character (byte)
c: :char, # 8-bit character (byte)
# :int8 – 8-bit signed integer
# :uint8 – 8-bit unsigned integer
S: :ushort, # – 16-bit unsigned integer (Win32/API: S used for string params)
s: :short, # – 16-bit signed integer
# :uint16 – 16-bit unsigned integer
# :int16 – 16-bit signed integer
I: :uint, # 32-bit unsigned integer
i: :int, # 32-bit signed integer
# :uint32 – 32-bit unsigned integer
# :int32 – 32-bit signed integer
L: :ulong, # unsigned long int – platform-specific size
l: :long, # long int – platform-specific size. For discussion of platforms, see:
# (http://groups.google.com/group/ruby-ffi/browse_thread/thread/4762fc77130339b1)
# :int64 – 64-bit signed integer
# :uint64 – 64-bit unsigned integer
# :long_long – 64-bit signed integer
# :ulong_long – 64-bit unsigned integer
F: :float, # 32-bit floating point
D: :double, # 64-bit floating point (double-precision)
P: :pointer, # pointer – platform-specific size
p: :string, # C-style (NULL-terminated) character string (Win32API: S)
B: :bool, # (?? 1 byte in C++)
V: :void, # For functions that return nothing (return type void).
v: :void, # For functions that return nothing (return type void).
# For function argument type only:
# :buffer_in – Similar to :pointer, but optimized for Buffers that the function can only read (not write).
# :buffer_out – Similar to :pointer, but optimized for Buffers that the function can only write (not read).
# :buffer_inout – Similar to :pointer, but may be optimized for Buffers.
# :varargs – Variable arguments
# :enum - Enumerable type (should be defined)
# :char_array - ??
# Windows-specific type defs (ms-help://MS.MSDNQTR.v90.en/winprog/winprog/windows_data_types.htm):
ATOM: :ushort, # Atom ~= Symbol: Atom table stores strings and corresponding identifiers. Application
# places a string in an atom table and receives a 16-bit integer, called an atom, that
# can be used to access the string. Placed string is called an atom name.
# See: http://msdn.microsoft.com/en-us/library/ms648708%28VS.85%29.aspx
BOOL: :bool,
BOOLEAN: :bool,
BYTE: :uchar, # Byte (8 bits). Declared as unsigned char
#CALLBACK: K, # Win32.API gem-specific ?? MSDN: #define CALLBACK __stdcall
CHAR: :char, # 8-bit Windows (ANSI) character. See http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
COLORREF: :uint32, # Red, green, blue (RGB) color value (32 bits). See COLORREF for more info.
DWORD: :uint32, # 32-bit unsigned integer. The range is 0 through 4,294,967,295 decimal.
DWORDLONG: :uint64, # 64-bit unsigned integer. The range is 0 through 18,446,744,073,709,551,615 decimal.
DWORD_PTR: :ulong, # Unsigned long type for pointer precision. Use when casting a pointer to a long type
# to perform pointer arithmetic. (Also commonly used for general 32-bit parameters that have
# been extended to 64 bits in 64-bit Windows.) BaseTsd.h: #typedef ULONG_PTR DWORD_PTR;
DWORD32: :uint32,
DWORD64: :uint64,
HALF_PTR: :int, # Half the size of a pointer. Use within a structure that contains a pointer and two small fields.
# BaseTsd.h: #ifdef (_WIN64) typedef int HALF_PTR; #else typedef short HALF_PTR;
HACCEL: :ulong, # (L) Handle to an accelerator table. WinDef.h: #typedef HANDLE HACCEL;
# See http://msdn.microsoft.com/en-us/library/ms645526%28VS.85%29.aspx
HANDLE: :ulong, # (L) Handle to an object. WinNT.h: #typedef PVOID HANDLE;
# todo: Platform-dependent! Need to change to :uint64 for Win64
HBITMAP: :ulong, # (L) Handle to a bitmap: http://msdn.microsoft.com/en-us/library/dd183377%28VS.85%29.aspx
HBRUSH: :ulong, # (L) Handle to a brush. http://msdn.microsoft.com/en-us/library/dd183394%28VS.85%29.aspx
HCOLORSPACE: :ulong, # (L) Handle to a color space. http://msdn.microsoft.com/en-us/library/ms536546%28VS.85%29.aspx
HCURSOR: :ulong, # (L) Handle to a cursor. http://msdn.microsoft.com/en-us/library/ms646970%28VS.85%29.aspx
HCONV: :ulong, # (L) Handle to a dynamic data exchange (DDE) conversation.
HCONVLIST: :ulong, # (L) Handle to a DDE conversation list. HANDLE - L ?
HDDEDATA: :ulong, # (L) Handle to DDE data (structure?)
HDC: :ulong, # (L) Handle to a device context (DC). http://msdn.microsoft.com/en-us/library/dd183560%28VS.85%29.aspx
HDESK: :ulong, # (L) Handle to a desktop. http://msdn.microsoft.com/en-us/library/ms682573%28VS.85%29.aspx
HDROP: :ulong, # (L) Handle to an internal drop structure.
HDWP: :ulong, # (L) Handle to a deferred window position structure.
HENHMETAFILE: :ulong, #(L) Handle to an enhanced metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
HFILE: :uint, # (I) Special file handle to a file opened by OpenFile, not CreateFile.
# WinDef.h: #typedef int HFILE;
HFONT: :ulong, # (L) Handle to a font. http://msdn.microsoft.com/en-us/library/dd162470%28VS.85%29.aspx
HGDIOBJ: :ulong, # (L) Handle to a GDI object.
HGLOBAL: :ulong, # (L) Handle to a global memory block.
HHOOK: :ulong, # (L) Handle to a hook. http://msdn.microsoft.com/en-us/library/ms632589%28VS.85%29.aspx
HICON: :ulong, # (L) Handle to an icon. http://msdn.microsoft.com/en-us/library/ms646973%28VS.85%29.aspx
HINSTANCE: :ulong, # (L) Handle to an instance. This is the base address of the module in memory.
# HMODULE and HINSTANCE are the same today, but were different in 16-bit Windows.
HKEY: :ulong, # (L) Handle to a registry key.
HKL: :ulong, # (L) Input locale identifier.
HLOCAL: :ulong, # (L) Handle to a local memory block.
HMENU: :ulong, # (L) Handle to a menu. http://msdn.microsoft.com/en-us/library/ms646977%28VS.85%29.aspx
HMETAFILE: :ulong, # (L) Handle to a metafile. http://msdn.microsoft.com/en-us/library/dd145051%28VS.85%29.aspx
HMODULE: :ulong, # (L) Handle to an instance. Same as HINSTANCE today, but was different in 16-bit Windows.
HMONITOR: :ulong, # (L) Рandle to a display monitor. WinDef.h: if(WINVER >= 0x0500) typedef HANDLE HMONITOR;
HPALETTE: :ulong, # (L) Handle to a palette.
HPEN: :ulong, # (L) Handle to a pen. http://msdn.microsoft.com/en-us/library/dd162786%28VS.85%29.aspx
HRESULT: :long, # Return code used by COM interfaces. For more info, Structure of the COM Error Codes.
# To test an HRESULT value, use the FAILED and SUCCEEDED macros.
HRGN: :ulong, # (L) Handle to a region. http://msdn.microsoft.com/en-us/library/dd162913%28VS.85%29.aspx
HRSRC: :ulong, # (L) Handle to a resource.
HSZ: :ulong, # (L) Handle to a DDE string.
HWINSTA: :ulong, # (L) Handle to a window station. http://msdn.microsoft.com/en-us/library/ms687096%28VS.85%29.aspx
HWND: :ulong, # (L) Handle to a window. http://msdn.microsoft.com/en-us/library/ms632595%28VS.85%29.aspx
INT: :int, # 32-bit signed integer. The range is -2147483648 through 2147483647 decimal.
INT_PTR: :int, # Signed integer type for pointer precision. Use when casting a pointer to an integer
# to perform pointer arithmetic. BaseTsd.h:
#if defined(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;
INT32: :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
INT64: :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
LANGID: :ushort, # Language identifier. For more information, see Locales. WinNT.h: #typedef WORD LANGID;
# See http://msdn.microsoft.com/en-us/library/dd318716%28VS.85%29.aspx
LCID: :uint32, # Locale identifier. For more information, see Locales.
LCTYPE: :uint32, # Locale information type. For a list, see Locale Information Constants.
LGRPID: :uint32, # Language group identifier. For a list, see EnumLanguageGroupLocales.
LONG: :long, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
LONG32: :int32, # 32-bit signed integer. The range is -2,147,483,648 through +...647 decimal.
LONG64: :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
LONGLONG: :int64, # 64-bit signed integer. The range is –9,223,372,036,854,775,808 through +...807
LONG_PTR: :long, # Signed long type for pointer precision. Use when casting a pointer to a long to
# perform pointer arithmetic. BaseTsd.h:
#if defined(_WIN64) typedef __int64 LONG_PTR; #else typedef long LONG_PTR;
LPARAM: :long, # Message parameter. WinDef.h as follows: #typedef LONG_PTR LPARAM;
LPBOOL: :pointer, # Pointer to a BOOL. WinDef.h as follows: #typedef BOOL far *LPBOOL;
LPBYTE: :pointer, # Pointer to a BYTE. WinDef.h as follows: #typedef BYTE far *LPBYTE;
LPCOLORREF: :pointer, # Pointer to a COLORREF value. WinDef.h as follows: #typedef DWORD *LPCOLORREF;
LPCSTR: :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
# See Character Sets Used By Fonts. http://msdn.microsoft.com/en-us/library/dd183415%28VS.85%29.aspx
LPCTSTR: :pointer, # An LPCWSTR if UNICODE is defined, an LPCSTR otherwise.
LPCVOID: :pointer, # Pointer to a constant of any type. WinDef.h as follows: typedef CONST void *LPCVOID;
LPCWSTR: :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
LPDWORD: :pointer, # Pointer to a DWORD. WinDef.h as follows: typedef DWORD *LPDWORD;
LPHANDLE: :pointer, # Pointer to a HANDLE. WinDef.h as follows: typedef HANDLE *LPHANDLE;
LPINT: :pointer, # Pointer to an INT.
LPLONG: :pointer, # Pointer to an LONG.
LPSTR: :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters.
LPTSTR: :pointer, # An LPWSTR if UNICODE is defined, an LPSTR otherwise.
LPVOID: :pointer, # Pointer to any type.
LPWORD: :pointer, # Pointer to a WORD.
LPWSTR: :pointer, # Pointer to a null-terminated string of 16-bit Unicode characters.
LRESULT: :long, # Signed result of message processing. WinDef.h: typedef LONG_PTR LRESULT;
PBOOL: :pointer, # Pointer to a BOOL.
PBOOLEAN: :pointer, # Pointer to a BOOL.
PBYTE: :pointer, # Pointer to a BYTE.
PCHAR: :pointer, # Pointer to a CHAR.
PCSTR: :pointer, # Pointer to a constant null-terminated string of 8-bit Windows (ANSI) characters.
PCTSTR: :pointer, # A PCWSTR if UNICODE is defined, a PCSTR otherwise.
PCWSTR: :pointer, # Pointer to a constant null-terminated string of 16-bit Unicode characters.
PDWORD: :pointer, # Pointer to a DWORD.
PDWORDLONG: :pointer, # Pointer to a DWORDLONG.
PDWORD_PTR: :pointer, # Pointer to a DWORD_PTR.
PDWORD32: :pointer, # Pointer to a DWORD32.
PDWORD64: :pointer, # Pointer to a DWORD64.
PFLOAT: :pointer, # Pointer to a FLOAT.
PHALF_PTR: :pointer, # Pointer to a HALF_PTR.
PHANDLE: :pointer, # Pointer to a HANDLE.
PHKEY: :pointer, # Pointer to an HKEY.
PINT: :pointer, # Pointer to an INT.
PINT_PTR: :pointer, # Pointer to an INT_PTR.
PINT32: :pointer, # Pointer to an INT32.
PINT64: :pointer, # Pointer to an INT64.
PLCID: :pointer, # Pointer to an LCID.
PLONG: :pointer, # Pointer to a LONG.
PLONGLONG: :pointer, # Pointer to a LONGLONG.
PLONG_PTR: :pointer, # Pointer to a LONG_PTR.
PLONG32: :pointer, # Pointer to a LONG32.
PLONG64: :pointer, # Pointer to a LONG64.
POINTER_32: :pointer, # 32-bit pointer. On a 32-bit system, this is a native pointer. On a 64-bit system, this is a truncated 64-bit pointer.
POINTER_64: :pointer, # 64-bit pointer. On a 64-bit system, this is a native pointer. On a 32-bit system, this is a sign-extended 32-bit pointer.
POINTER_SIGNED: :pointer, # A signed pointer.
POINTER_UNSIGNED: :pointer, # An unsigned pointer.
PSHORT: :pointer, # Pointer to a SHORT.
PSIZE_T: :pointer, # Pointer to a SIZE_T.
PSSIZE_T: :pointer, # Pointer to a SSIZE_T.
PSTR: :pointer, # Pointer to a null-terminated string of 8-bit Windows (ANSI) characters. For more information, see Character Sets Used By Fonts.
PTBYTE: :pointer, # Pointer to a TBYTE.
PTCHAR: :pointer, # Pointer to a TCHAR.
PTSTR: :pointer, # A PWSTR if UNICODE is defined, a PSTR otherwise.
PUCHAR: :pointer, # Pointer to a UCHAR.
PUHALF_PTR: :pointer, # Pointer to a UHALF_PTR.
PUINT: :pointer, # Pointer to a UINT.
PUINT_PTR: :pointer, # Pointer to a UINT_PTR.
PUINT32: :pointer, # Pointer to a UINT32.
PUINT64: :pointer, # Pointer to a UINT64.
PULONG: :pointer, # Pointer to a ULONG.
PULONGLONG: :pointer, # Pointer to a ULONGLONG.
PULONG_PTR: :pointer, # Pointer to a ULONG_PTR.
PULONG32: :pointer, # Pointer to a ULONG32.
PULONG64: :pointer, # Pointer to a ULONG64.
PUSHORT: :pointer, # Pointer to a USHORT.
PVOID: :pointer, # Pointer to any type.
PWCHAR: :pointer, # Pointer to a WCHAR.
PWORD: :pointer, # Pointer to a WORD.
PWSTR: :pointer, # Pointer to a null- terminated string of 16-bit Unicode characters.
# For more information, see Character Sets Used By Fonts.
SC_HANDLE: :ulong, # (L) Handle to a service control manager database.
# See SCM Handles http://msdn.microsoft.com/en-us/library/ms685104%28VS.85%29.aspx
SC_LOCK: :pointer, # Lock to a service control manager database. For more information, see SCM Handles.
SERVICE_STATUS_HANDLE: :ulong, # (L) Handle to a service status value. See SCM Handles.
SHORT: :short, # A 16-bit integer. The range is –32768 through 32767 decimal.
SIZE_T: :ulong, # The maximum number of bytes to which a pointer can point. Use for a count that must span the full range of a pointer.
SSIZE_T: :long, # Signed SIZE_T.
TBYTE: :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
TCHAR: :short, # A WCHAR if UNICODE is defined, a CHAR otherwise.TCHAR:
UCHAR: :uchar, # Unsigned CHAR (8 bit)
UHALF_PTR: :uint, # Unsigned HALF_PTR. Use within a structure that contains a pointer and two small fields.
UINT: :uint, # Unsigned INT. The range is 0 through 4294967295 decimal.
UINT_PTR: :uint, # Unsigned INT_PTR.
UINT32: :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
UINT64: :uint64, # Unsigned INT64. The range is 0 through 18446744073709551615 decimal.
ULONG: :ulong, # Unsigned LONG. The range is 0 through 4294967295 decimal.
ULONGLONG: :ulong_long, # 64-bit unsigned integer. The range is 0 through 18446744073709551615 decimal.
ULONG_PTR: :ulong, # Unsigned LONG_PTR.
ULONG32: :uint32, # Unsigned INT32. The range is 0 through 4294967295 decimal.
ULONG64: :uint64, # Unsigned LONG64. The range is 0 through 18446744073709551615 decimal.
UNICODE_STRING: :pointer, # Pointer to some string structure??
USHORT: :ushort, # Unsigned SHORT. The range is 0 through 65535 decimal.
USN: :ulong_long, # Update sequence number (USN).
VOID: [], # Any type ? Only use it to indicate no arguments or no return value
WCHAR: :ushort, # 16-bit Unicode character. For more information, see Character Sets Used By Fonts.
# In WinNT.h: typedef wchar_t WCHAR;
#WINAPI: K, # Calling convention for system functions. WinDef.h: define WINAPI __stdcall
WORD: :ushort, # 16-bit unsigned integer. The range is 0 through 65535 decimal.
WPARAM: :uint # Message parameter. WinDef.h as follows: typedef UINT_PTR WPARAM;
}
##
# Defines new method wrappers for Windows API function call:
# - Defines method with original (CamelCase) API function name and original signature (matches MSDN description)
# - Defines method with snake_case name (converted from CamelCase function name) with enhanced API signature
# When defined snake_case method is called, it converts the arguments you provided into ones required by
# original API (adding defaults, mute and transitory args as necessary), executes API function call
# and (optionally) transforms the result before returning it. If a block is attached to
# method invocation, raw result is yielded to this block before final transformation take place
# - Defines aliases for enhanced method with more Rubyesque names for getters, setters and tests:
# GetWindowText -> window_test, SetWindowText -> window_text=, IsZoomed -> zoomed?
# ---
# You may modify default behavior of defined method by providing optional *def_block* to function definition.
# If you do so, snake_case method is defined based on your *def_block*. It receives callable API
# object for function being defined, arguments and (optional) runtime block with which the method
# will be called. Results coming from &def_block are then transformed and returned.
# So, your *def_block* should specify all the behavior of the method being defined. You can use *def_block* to:
# - Change original signature of API function, provide argument defaults, check argument types
# - Pack arguments into strings/structs for [in] or [in/out] parameters that expect a pointer
# - Allocate buffers/structs for pointers required by API functions [out] parameters
# - Unpack [out] and [in/out] parameters returned as pointers
# - Explicitly return results of API call that are returned in [out] and [in/out] parameters
# - Convert attached runtime blocks into callback functions and stuff them into [in] callback parameters
# - do other stuff that you think is appropriate to make Windows API function behavior more Ruby-like...
# ---
# Accepts following options:
# :dll:: Use this dll instead of default 'user32'
# :rename:: Use this name instead of standard (conventional) function name
# :alias(es):: Provides additional alias(es) for defined method
# :boolean:: Forces method to return true/false instead of nonzero/zero
# :zeronil:: Forces method to return nil if function result is zero
#
def function(name, params, returns, options={}, &def_block)
snake_name, effective_names, aliases = generate_names(name, options)
params, returns = generate_signature(params, returns)
libs = ffi_libraries.map(&:name)
boolean = options[:boolean]
zeronil = options[:zeronil]
effective_name = effective_names.inject(nil) do |func, effective_name|
func || begin
# tries to attach basic CamelCase method via FFI
attach_function(name, effective_name, params.dup, returns)
effective_name
rescue FFI::NotFoundError
nil
end
end
raise Win::Errors::NotFoundError.new(name, libs) unless effective_name
# Create API object that holds information about function names, params, etc
api = API.new(namespace, name, effective_name, params, returns, libs)
# Only define enhanced API if snake_name is different from original name (e.g. keybd_event)
unless snake_name.to_s == name.to_s
method_body = if def_block
if zeronil
->(*args, &block){ (res = def_block.(api, *args, &block)) != 0 ? res : nil }
elsif boolean
->(*args, &block){ def_block.(api, *args, &block) != 0 }
else
->(*args, &block){ def_block.(api, *args, &block) }
end
else
if zeronil
->(*args, &block){ (res = block ? block[api.call(*args)] : api.call(*args)) != 0 ? res : nil }
elsif boolean
->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) != 0 }
else
->(*args, &block){ block ? block[api.call(*args)] : api.call(*args) }
end
end
define_method snake_name, &method_body # define snake_case instance method
eigenklass = class << self; self; end # Extracting eigenclass
eigenklass.class_eval do
define_method snake_name, &method_body # define snake_case class method
end
end
aliases.each {|ali| alias_method ali, snake_name } # define aliases
api #return api object from function declaration
end
# Try to define platform-specific function, rescue error, return message
#
def try_function(name, params, returns, options={}, &def_block)
begin
function name, params, returns, options={}, &def_block
rescue Win::Errors::NotFoundError
"This platform does not support function #{name}"
end
end
# Generates possible effective names for function in Win32 dll (name+A/W),
# Rubyesque name and aliases for method(s) defined based on function name,
#
def generate_names(name, options={})
name = name.to_s
effective_names = [name]
effective_names += ["#{name}A", "#{name}W"] unless name =~ /[WA]$/
aliases = ([options[:alias]] + [options[:aliases]]).flatten.compact
snake_name = options[:rename] || name.snake_case
case snake_name
when /^is_/
aliases << snake_name.sub(/^is_/, '') + '?'
when /^set_/
aliases << snake_name.sub(/^set_/, '')+ '='
when /^get_/
aliases << snake_name.sub(/^get_/, '')
end
[snake_name, effective_names, aliases]
end
##
# Generates params and returns (signature) containing only FFI-compliant types
#
def generate_signature(params, returns)
params = params.split(//) if params.respond_to?(:split) # Convert params string into array
params.map! {|param| TYPES[param.to_sym] || param} # Convert chars into FFI type symbols
returns = TYPES[returns.to_sym] || returns # Convert chars into FFI type symbols
[params, returns]
end
##
# Wrapper for FFI::Library#callback() that converts Win32/shortcut argument types into FFI-compliant types.
# This method overrides FFI.callback which must be aliased to FFI.attach_callback
#
def callback(name, params, returns)
params, returns = generate_signature(params, returns)
attach_callback name.to_sym, params, returns
end
##
# :method: namespace
# This method is meta-generated when Win::Library module is included into other module/class.
# It returns reference to including (host) class/module for use by Win::Library::API and class methods.
##
# Ensures that args count is equal to params count plus diff
#
def enforce_count(args, params, diff = 0)
num_args = args.size
num_params = params.size + diff #params == 'V' ? 0 : params.size + diff
if num_args != num_params
raise ArgumentError, "wrong number of arguments (#{num_args} for #{num_params})"
end
end
end
##
# Hook executed when Win::Library is included into class or module. It extends host class/module
# with both FFI::Library methods and Win::Library macro methods like 'function'.
#
def self.included(klass)
klass.extend FFI::Library
eigenklass = class << klass; self; end # Extracting host class's eigenclass
eigenklass.class_eval do
define_method(:namespace) {klass} # Defining new class method for host pointing to itself
alias_method :attach_callback, :callback
include ClassMethods
end
klass.ffi_lib 'user32', 'kernel32' # Default libraries
klass.ffi_convention :stdcall
end
end
end