win 0.0.6 → 0.1.0

data/README.rdoc

@@ -15,19 +15,19 @@ This is still work in progress, only a small portion of Windows API wrapped so f
 == SUMMARY
 
 So you want to write a simple program that makes some Windows API function calls.
-You searched MSDN high and low and you now know exactly what functions you need.
-All you want is just putting those function calls into your Ruby code without too
-much pain. You'd love this to be more or less natural extension of your Ruby code,
-preferably not turning your code base into an ugly spaghetty of CamelCase calls,
-String/Array pack/unpack gymnastics, buffer/pointer allocations, extracting return
-values from [in/out] parameters and checking return codes for 0.
+You searched MSDN high and low and you know exactly what functions you need.
+You just want to put these function calls into your Ruby code without too much pain.
+You'd love this to be more or less natural extension of your Ruby code, preferably
+not turning your code base into an ugly spaghetty of CamelCase calls, String/Array
+pack/unpack gymnastics, buffer/pointer allocations, extracting return values
+from [in/out] parameters and checking return codes for 0.
 
 You have several options at this point. You can use 'win32-api' or 'ffi' libraries
 to connect your ruby code to Windows API and manually define wrapper methods for
 needed function calls. This is definitely a valid approach, even if it is a bit
-low-level one: you'll have to handle (somewhat) gory details of callback announcement,
-argument preparation, mimicking pointers with Strings or declaring pointers explicitly
-with FFI and other stuff (like manually defining about a gazillion obscure Windows
+low-level one: you'll have to handle (somewhat) gory details of callback announcements,
+argument preparation, mimicking pointers with Strings, declaring pointers explicitly
+with FFI and other stuff (like manually assigning about a gazillion obscure Windows
 constants). As an example, consider the amount of code needed to complete a task as
 simple as getting unicode title text for the window that you already have handle for
 (using win32-api):
@@ -68,7 +68,7 @@ It helps you to cut some of the declaration slack though:
      buffer.force_encoding('utf-16LE').encode('utf-8').rstrip
   end
 
-But still it seems like TOO MUCH code for something that should (ideally) look like this:
+But still, it seems like TOO MUCH code for something that should (ideally) look like this:
 
   title = window_text_w(window_handle)
 
@@ -78,8 +78,8 @@ natural inside Ruby code. Following the principle of least surprise, we define w
 * Require minimum arguments with sensible defaults
 * Return appropriate values explicitly (several return values if necessary)
 * Have sensible returns (false/true instead of 0/nonzero for test functions, nil if find function fails, etc)
-* Accept blocks where callback is expected
-* Are partitioned into related namespaces, so that you can load only the modules you need
+* Accept blocks where callback is needed, provide default callback if no block given
+* Are partitioned into appropriate namespaces, so that you can load only the modules you really need
 
 Well, we even keep a backup solution for those diehard Win32 API longtimers who would rather
 allocate their buffer strings by hand and mess with obscure return codes. If you use original
@@ -94,10 +94,10 @@ such as DMLERR_NO_ERROR, APPCLASS_STANDARD, etc. So if you need only DDE-related
 there is no need to load all the other modules, clogging your namespaces - just require 'win/dde'
 and be done with it.
 
-And if you do not see your favorite Windows API functions amoung those already defined, it is
-quite easy to 'include Win::Library' into your module and define new ones with '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.
+And if you do not see your favorite Windows API functions among those already defined, it is
+quite easy to 'include Win::Library' into your module and define new ones with 'function' 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.
 
 == REQUIREMENTS:
 
@@ -114,20 +114,45 @@ Contributors always welcome!
   $ gem install win
 
 == SYNOPSIS
+=== Using pre-defined Windows API functions:
 
-  require 'win/window'
+  require 'win/gui'
 
   class MyClass
-    include Win::Window
+    include Win::Gui::Window
 
     fg_window = foreground_window
     puts window_text(fg_window)
     show_window(fg_window) unless minimized?(fg_window)
-    hide_window(fg_window) if maximized?(fg_window)
     ...
   end
 
-== CREDITS:
+=== Defining your own Windows API functions:
+
+  require 'win/library'
+
+  module YourLibModule
+    include Win::Library
+
+    # Customizing method behavior: zeronil forces function to return nil instead of 0, rename renames method
+    function :FindWindow, [:pointer, :pointer], :ulong, zeronil: true, rename: my_find
+
+    # Customizing even further: your own method extension in attached block
+    function :GetWindowText, [ :pointer, :pointer, :int ], :int do |api, handle|
+      buffer = FFI::MemoryPointer.new :char, 512
+      buffer.put_string(0, "\x00" * 511)
+      num_chars = api.call(handle, buffer, 512)
+      return nil if num_chars == 0
+      string = buffer.get_bytes(0, num_chars)
+    end
+  end
+
+  extend YourLibModule
+
+  handle = my_find(nil, nil)    # find ANY window
+  puts window_text(handle)      # print window title
+
+== PRIOR ART:
 
 This library started as an extension of ideas and code described in excellent book
 "Scripted GUI Testing with Ruby" by Ian Dees. 'win32-api' and 'windows-pr' gems by

data/Rakefile

@@ -5,8 +5,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "win"
-    gem.summary = %Q{A collection of pre-defined Windows API functions with Rubyesque interfaces}
-    gem.description = %Q{A collection of pre-defined Windows API functions with Rubyesque interfaces}
+    gem.summary = %Q{Rubyesque interfaces and wrappers for Windows API functions pre-defined using FFI }
+    gem.description = %Q{Rubyesque interfaces and wrappers for Windows API functions pre-defined using FFI }
     gem.email = "arvitallian@gmail.com"
     gem.homepage = "http://github.com/arvicco/win"
     gem.authors = ["arvicco"]

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.1.0

data/lib/win/dde.rb

@@ -122,17 +122,7 @@ module Win
     #
     function 'RegisterClipboardFormat', 'P', 'I', zeronil: true
 
-    # Procedure that calls (DdeInitialize) function expecting a DdeCallback. Runtime block is converted
-    # into Dde callback and registered with DdeInitialize. Returns DDE init status and DDE instance id.
-    #
-    return_id_status = ->(api, id=0, cmd, &block){
-        raise ArgumentError, 'No callback block' unless block
-
-        status = api.call(id = [id].pack('L'), block, cmd, 0)
-        id = status == 0 ? id.unpack('L').first : nil
-        [id, status] }
-
-    # DdeCallabck declaration
+    # DdeCallaback declaration
     # MSDN syntax: HDDEDATA CALLBACK DdeCallback( UINT uType, UINT uFmt, HCONV hconv, HDDEDATA hsz1, HDDEDATA hsz2,
     #                                             HDDEDATA hdata, HDDEDATA dwData1, HDDEDATA dwData2);
     callback :dde_callback, [:uint, :uint, :HCONV, :HDDEDATA, :HDDEDATA, :HDDEDATA, :HDDEDATA, :HDDEDATA], :HDDEDATA
@@ -187,7 +177,15 @@ module Win
     # :call-seq:
     # id_inst, status = dde_initialize( id_inst = 0, cmd ) {|callback args| callback block}
     #
-    function 'DdeInitialize', [:pointer, :dde_callback, :DWORD, :DWORD], :uint, &return_id_status
+    function 'DdeInitialize', [:pointer, :dde_callback, :DWORD, :DWORD], :uint,
+             &->(api, old_id=0, cmd, &block){
+             raise ArgumentError, 'No callback block' unless block
+             id = FFI::MemoryPointer.new(:long)
+             id.write_long(old_id)
+             status = api.call(id, block, cmd, 0)
+             id = status == 0 ? id.read_long() : nil
+             [id, status] }
+    # weird lambda literal instead of block is needed because RDoc goes crazy if block is attached to meta-definition
 
     ##
     # The DdeCreateStringHandle function creates a handle that identifies the specified string.
@@ -209,7 +207,7 @@ module Win
     # Return Value (L) or nil: If the function succeeds, the return value is a string handle.
     #   If the function fails, the return value is 0(changed to nil in enhanced version).
     #   The DdeGetLastError function can be used to get the error code, which can be one of the following values:
-    #DMLERR_NO_ERROR, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
+    # DMLERR_NO_ERROR, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
     #
     # Remarks: The value of a string handle is not related to the case of the string it identifies.
     #   When an application either creates a string handle or receives one in the callback function
@@ -217,7 +215,7 @@ module Win
     #   handle when it is no longer needed. An instance-specific string handle cannot be mapped from string
     #   handle to string and back to string handle.
     #
-    function 'DdeCreateStringHandle', [:DWORD, :pointer, :int], :HSZ
+    function 'DdeCreateStringHandle', [:DWORD, :pointer, :int], :HSZ, zeronil: true
 
   end
-end
+end

data/lib/win/extensions.rb

@@ -21,4 +21,4 @@ class String
       raise "Can't convert unknown character: #{self}"
     end
   end
-end
+end

data/lib/win/gui/convenience.rb

@@ -0,0 +1,142 @@
+require 'win/library'
+require 'win/gui/window'
+require 'win/gui/message'
+require 'win/gui/input'
+
+module Win
+  module Gui
+    # Contains convenience methods and extra wrappers for Windows Gui related functions
+    #
+    module Convenience
+      include Win::Gui::Window
+      include Win::Gui::Message
+      include Win::Gui::Input
+
+      # Internal constants:
+
+      # Key event delay
+      KEY_DELAY  = 0.00001
+      # Wait delay
+      SLEEP_DELAY = 0.001
+      # Timeout waiting for Window to be closed
+      CLOSE_TIMEOUT = 1
+
+      # Convenience wrapper methods:
+
+      # Hides the window and activates another window
+      def hide_window(win_handle)
+        show_window(win_handle, SW_HIDE)
+      end
+
+      ##
+      # Tests if given window handle points to foreground (topmost) window
+      #
+      def foreground?(win_handle)
+        win_handle == foreground_window
+      end
+
+      ##
+      # Emulates combinations of (any amount of) keys pressed one after another (Ctrl+Alt+P) and then released
+      # *keys should be a sequence of a virtual-key codes. The codes must be a value in the range 1 to 254.
+      # For a complete list, see msdn:Virtual Key Codes.
+      def keystroke(*keys)
+        return if keys.empty?
+        keybd_event keys.first, 0, KEYEVENTF_KEYDOWN, 0
+        sleep KEY_DELAY
+        keystroke *keys[1..-1]
+        sleep KEY_DELAY
+        keybd_event keys.first, 0, KEYEVENTF_KEYUP, 0
+      end
+
+      # types text message into window holding the focus
+      def type_in(message)
+        message.scan(/./m) do |char|
+          keystroke(*char.to_vkeys)
+        end
+      end
+
+      # finds top-level dialog window by title and yields found dialog window to block if given
+      def dialog(title, seconds=3)
+        d = begin
+          win = WrapWindow.top_level(title, seconds)
+          yield(win) ? win : nil
+        rescue TimeoutError
+        end
+        d.wait_for_close if d
+        return d
+      end
+
+      # This class is a thin wrapper around window handle
+      class WrapWindow
+        include Win::Gui::Window
+        extend Win::Gui::Window
+        include Win::Gui::Message
+
+        attr_reader :handle
+
+        # find top level window by title, return wrapped Window object
+        def self.top_level(title, seconds=3)
+          @handle = timeout(seconds) do
+            sleep SLEEP_DELAY while (h = find_window nil, title) == nil; h
+          end
+          WrapWindow.new @handle
+        end
+
+        def initialize(handle)
+          @handle = handle
+        end
+
+        # find child window (control) by title, window class, or control ID:
+        def child(id)
+          result = case id
+            when String
+              by_title = find_window_ex @handle, 0, nil, id.gsub('_', '&' )
+              by_class = find_window_ex @handle, 0, id, nil
+              by_title ? by_title : by_class
+            when Fixnum
+              get_dlg_item @handle, id
+            when nil
+              find_window_ex @handle, 0, nil, nil
+            else
+              nil
+          end
+          raise "Control '#{id}' not found" unless result
+          WrapWindow.new result
+        end
+
+        def children
+          enum_child_windows(@handle).map{|child_handle| WrapWindow.new child_handle}
+        end
+
+        # emulate click of the control identified by id
+        def click(id)
+          h = child(id).handle
+          rectangle = [0, 0, 0, 0].pack 'LLLL'
+          get_window_rect h, rectangle
+          left, top, right, bottom = rectangle.unpack 'LLLL'
+          center = [(left + right) / 2, (top + bottom) / 2]
+          set_cursor_pos *center
+          mouse_event MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0
+          mouse_event MOUSEEVENTF_LEFTUP, 0, 0, 0, 0
+        end
+
+        def close
+          post_message @handle, WM_SYSCOMMAND, SC_CLOSE, 0
+        end
+
+        def wait_for_close
+          timeout(CLOSE_TIMEOUT) do
+            sleep SLEEP_DELAY while window_visible?(@handle)
+          end
+        end
+
+        def text
+          buffer = "\x0" * 2048
+          length = send_message @handle, WM_GETTEXT, buffer.length, buffer
+          length == 0 ? '' : buffer[0..length - 1]
+        end
+      end
+    end
+  end
+end
+

data/lib/win/gui/dialog.rb

@@ -0,0 +1,15 @@
+require 'win/library'
+
+module Win
+  module Gui
+    # Contains constants and Win32API functions related to dialog manipulation
+    #
+    module Dialog
+      include Win::Library
+
+      function 'GetDlgItem', 'LL', 'L'
+    end
+  end
+end
+
+

data/lib/win/gui/input.rb

@@ -0,0 +1,255 @@
+require 'win/library'
+
+module Win
+  module Gui
+    # Contains constants and Win32API functions related to end user input
+    #
+    module Input
+      include Win::Library
+
+      # Windows keyboard-related Constants:
+
+      # Key down keyboard event (the key is being depressed)
+      KEYEVENTF_KEYDOWN = 0
+      # Key up keyboard event (the key is being released)
+      KEYEVENTF_KEYUP = 2
+      # Extended kb event. If specified, the scan code was preceded by a prefix byte having the value 0xE0 (224).
+      KEYEVENTF_EXTENDEDKEY = 1
+
+      # Virtual key codes:
+
+      # Control-break processing
+      VK_CANCEL   = 0x03
+      #  Backspace? key
+      VK_BACK     = 0x08
+      #  Tab key
+      VK_TAB      = 0x09
+      #  Shift key
+      VK_SHIFT    = 0x10
+      #  Ctrl key
+      VK_CONTROL  = 0x11
+      #  ENTER key
+      VK_RETURN   = 0x0D
+      #  ALT key
+      VK_ALT      = 0x12
+      #  ALT key alias
+      VK_MENU     = 0x12
+      #  PAUSE key
+      VK_PAUSE    = 0x13
+      #  CAPS LOCK key
+      VK_CAPITAL  = 0x14
+      #  ESC key
+      VK_ESCAPE   = 0x1B
+      #  SPACEBAR
+      VK_SPACE    = 0x20
+      #  PAGE UP key
+      VK_PRIOR    = 0x21
+      #  PAGE DOWN key
+      VK_NEXT     = 0x22
+      #  END key
+      VK_END      = 0x23
+      #  HOME key
+      VK_HOME     = 0x24
+      #  LEFT ARROW key
+      VK_LEFT     = 0x25
+      #  UP ARROW key
+      VK_UP       = 0x26
+      #  RIGHT ARROW key
+      VK_RIGHT    = 0x27
+      #  DOWN ARROW key
+      VK_DOWN     = 0x28
+      #  SELECT key
+      VK_SELECT   = 0x29
+      #  PRINT key
+      VK_PRINT    = 0x2A
+      #  EXECUTE key
+      VK_EXECUTE  = 0x2B
+      #  PRINT SCREEN key
+      VK_SNAPSHOT = 0x2C
+      #  INS key
+      VK_INSERT   = 0x2D
+      #  DEL key
+      VK_DELETE   = 0x2E
+      #  HELP key
+      VK_HELP     = 0x2F
+
+#  Public Type MOUSEINPUT
+#  dx As Long
+#  dy As Long
+#  mouseData As Long
+#  dwFlags As Long
+#  time As Long
+#  dwExtraInfo As Long
+#  End Type
+#
+#  Public Type INPUT_TYPE
+#  dwType As Long
+#  xi(0 To 23) As Byte
+#  End Type
+
+
+
+      # dwFlags:
+      # Specifies that the dx and dy parameters contain normalized absolute coordinates. If not set, those parameters
+      # contain relative data: the change in position since the last reported position. This flag can be set, or not
+      # set, regardless of what kind of mouse or mouse-like device, if any, is connected to the system. For further
+      # information about relative mouse motion, see mouse_event Remarks section.
+      MOUSEEVENTF_ABSOLUTE = 0x8000
+      #Specifies that movement occurred.
+      MOUSEEVENTF_MOVE = 0x01
+      #Specifies that the left button is down.
+      MOUSEEVENTF_LEFTDOWN = 0x02
+      #Specifies that the left button is up.
+      MOUSEEVENTF_LEFTUP  = 0x04
+      #Specifies that the right button is down.
+      MOUSEEVENTF_RIGHTDOWN = 0x08
+      #Specifies that the right button is up.
+      MOUSEEVENTF_RIGHTUP = 0x010
+      #Specifies that the middle button is down.
+      MOUSEEVENTF_MIDDLEDOWN = 0x20
+      #Specifies that the middle button is up.
+      MOUSEEVENTF_MIDDLEUP = 0x040
+      #Windows NT/2000/XP: Specifies that the wheel has been moved, if the mouse has a wheel. The amount of movement
+      #is specified in dwData
+      MOUSEEVENTF_WHEEL = 0x80
+      #Windows 2000/XP: Specifies that an X button was pressed.
+      MOUSEEVENTF_XDOWN = 0x100
+      #Windows 2000/XP: Specifies that an X button was released.
+      MOUSEEVENTF_XUP = 0x200
+
+      # dwData:
+      # One wheel click is defined as WHEEL_DELTA, which is 120.
+      WHEEL_DELTA = 120
+      # Set if the first X button was pressed or released.
+      XBUTTON1    = 1
+      # Set if the second X button was pressed or released.
+      XBUTTON2    = 2
+      # Indicates NO data if dwFlags are NOT any of MOUSEEVENTF_WHEEL, MOUSEEVENTF_XDOWN, or MOUSEEVENTF_XUP
+      INPUT_MOUSE = 0
+
+
+      ##
+      # The keybd_event function synthesizes a keystroke. The system can use such a synthesized keystroke to generate
+      # a WM_KEYUP or WM_KEYDOWN message. The keyboard driver's interrupt handler calls the keybd_event function.
+      #
+      # !!!! Windows NT/2000/XP/Vista:This function has been superseded. Use SendInput instead.
+      #
+      # Syntax: VOID keybd_event( BYTE bVk, BYTE bScan, DWORD dwFlags, PTR dwExtraInfo);
+      #
+      # Parameters:
+      #   bVk [C] - [in] Specifies a virtual-key code. The code must be a value in the range 1 to 254.
+      #      For a complete list, see Virtual-Key Codes.
+      #   bScan [C] - [in] Specifies a hardware scan code for the key.
+      #   dwFlags [L] - [in] Specifies various aspects of function operation. This parameter can be
+      #     one or more of the following values:
+      # KEYEVENTF_EXTENDEDKEY, KEYEVENTF_KEYUP, KEYEVENTF_KEYDOWN
+      #   dwExtraInfo [L] -[in] Specifies an additional value associated with the key stroke.
+      #
+      # Return Value: none
+      #
+      # Remarks: An application can simulate a press of the PRINTSCRN key in order to obtain a screen snapshot and save
+      # it to the clipboard. To do this, call keybd_event with the bVk parameter set to VK_SNAPSHOT.
+      #
+      # Windows NT/2000/XP: The keybd_event function can toggle the NUM LOCK, CAPS LOCK, and SCROLL LOCK keys.
+      # Windows 95/98/Me: The keybd_event function can toggle only the CAPS LOCK and SCROLL LOCK keys.
+      #
+      function 'keybd_event', 'IILL', 'V'
+
+      ##
+      # The mouse_event function synthesizes mouse motion and button clicks.
+      # !!!! Windows NT/2000/XP: This function has been superseded. Use SendInput instead.
+      #
+      # Syntax: VOID mouse_event( DWORD dwFlags, DWORD dx, DWORD dy, DWORD dwData, ULONG_PTR dwExtraInfo );
+      #
+      # Parameters:
+      #   flags (I) - [in] Specifies various aspects of mouse motion and button clicking. This parameter can be
+      #     certain combinations of the following values. The values that specify mouse button status are set to
+      #     indicate changes in status, not ongoing conditions. For example, if the left mouse button is pressed
+      #     and held down, MOUSEEVENTF_LEFTDOWN is set when the left button is first pressed, but not for subsequent
+      #     motions. Similarly, MOUSEEVENTF_LEFTUP is set only when the button is first released. You cannot specify
+      #     both MOUSEEVENTF_WHEEL and either MOUSEEVENTF_XDOWN or MOUSEEVENTF_XUP simultaneously, because they
+      #     both require use of the dwData field:
+      # MOUSEEVENTF_ABSOLUTE, MOUSEEVENTF_MOVE, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_RIGHTDOWN,
+      # MOUSEEVENTF_RIGHTUP, MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_WHEEL, MOUSEEVENTF_XDOWN,
+      # MOUSEEVENTF_XUP
+      #   dx (I) - [in] Specifies the mouse's absolute position along the x-axis or its amount of motion since the
+      #     last mouse event was generated, depending on the setting of MOUSEEVENTF_ABSOLUTE. Absolute data is
+      #     specified as the mouse's actual x-coordinate; relative data is specified as the number of mickeys moved.
+      #     A mickey is the amount that a mouse has to move for it to report that it has moved.
+      #   dy (I) - [in] Specifies the mouse's absolute position along the y-axis or its amount of motion since the
+      #     last mouse event was generated, depending on the setting of MOUSEEVENTF_ABSOLUTE. Absolute data is
+      #     specified as the mouse's actual y-coordinate; relative data is specified as the number of mickeys moved.
+      #   data (I) - [in] If flags contains MOUSEEVENTF_WHEEL, then data specifies the amount of wheel movement.
+      #     A positive value indicates that the wheel was rotated forward, away from the user; a negative value
+      #     indicates that the wheel was rotated backward, toward the user. One wheel click is defined as
+      #     WHEEL_DELTA, which is 120. If flags contains MOUSEEVENTF_WHHEEL, then data specifies the amount of
+      #     wheel movement. A positive value indicates that the wheel was rotated to the right; a negative value
+      #     indicates that the wheel was rotated to the left. One wheel click is defined as WHEEL_DELTA, which is 120.
+      #     Windows 2000/XP: If flags contains MOUSEEVENTF_XDOWN or MOUSEEVENTF_XUP, then data specifies which X
+      #     buttons were pressed or released. This value may be any combination of the following flags.
+      #     If flags is not MOUSEEVENTF_WHEEL, MOUSEEVENTF_XDOWN, or MOUSEEVENTF_XUP, then data should be zero.
+      # XBUTTON1 - Set if the first X button was pressed or released.
+      # XBUTTON2 - Set if the second X button was pressed or released.
+      #   extra_info (P) - [in] Specifies an additional value associated with the mouse event. An application
+      #     calls GetMessageExtraInfo to obtain this extra information.
+      #
+      # NO Return Value
+      #
+      # Remarks: If the mouse has moved, indicated by MOUSEEVENTF_MOVE being set, dx and dy hold information about
+      # that motion. The information is specified as absolute or relative integer values. If MOUSEEVENTF_ABSOLUTE
+      # value is specified, dx and dy contain normalized absolute coordinates between 0 and 65,535. The event
+      # procedure maps these coordinates onto the display surface. Coordinate (0,0) maps onto the upper-left corner
+      # of the display surface, (65535,65535) maps onto the lower-right corner. If the MOUSEEVENTF_ABSOLUTE value
+      # is not specified, dx and dy specify relative motions from when the last mouse event was generated (the last
+      # reported position). Positive values mean the mouse moved right (or down); negative values mean the mouse
+      # moved left (or up). Relative mouse motion is subject to the settings for mouse speed and acceleration level.
+      # An end user sets these values using the Mouse application in Control Panel. An application obtains and sets
+      # these values with the SystemParametersInfo function. The system applies two tests to the specified relative
+      # mouse motion when applying acceleration. If the specified distance along either the x or y axis is greater
+      # than the first mouse threshold value, and the mouse acceleration level is not zero, the operating system
+      # doubles the distance. If the specified distance along either the x- or y-axis is greater than the second
+      # mouse threshold value, and the mouse acceleration level is equal to two, the operating system doubles the
+      # distance that resulted from applying the first threshold test. It is thus possible for the operating system
+      # to multiply relatively-specified mouse motion along the x- or y-axis by up to four times. Once acceleration
+      # has been applied, the system scales the resultant value by the desired mouse speed. Mouse speed can range
+      # from 1 (slowest) to 20 (fastest) and represents how much the pointer moves based on the distance the mouse
+      # moves. The default value is 10, which results in no additional modification to the mouse motion. The
+      # mouse_event function is used to synthesize mouse events by applications that need to do so. It is also used
+      # by applications that need to obtain more information from the mouse than its position and button state.
+      # For example, if a tablet manufacturer wants to pass pen-based information to its own applications, it can
+      # write a DLL that communicates directly to the tablet hardware, obtains the extra information, and saves it
+      # in a queue. The DLL then calls mouse_event with the standard button and x/y position data, along with,
+      # in the dwExtraInfo parameter, some pointer or index to the queued extra information. When the application
+      # needs the extra information, it calls the DLL with the pointer or index stored in dwExtraInfo, and the DLL
+      # returns the extra information.
+      #
+      #
+      function 'mouse_event', 'IIIIP', 'V'
+
+      ##
+      # SetCursorPos Function moves the cursor to the specified screen coordinates. If the new coordinates are not
+      # within the screen rectangle set by the most recent ClipCursor function call, the system automatically adjusts
+      # the coordinates so that the cursor stays within the rectangle.
+      #
+      # Syntax: BOOL SetCursorPos( int X, int Y );
+      #
+      # Parameters:
+      #  X (i) - [in] Specifies the new x-coordinate of the cursor, in screen coordinates.
+      #  Y (i) - [in] Specifies the new y-coordinate of the cursor, in screen coordinates.
+      #
+      # Return Value: Nonzero if successful or zero otherwise. To get extended error information, call GetLastError.
+      # Enhanced to return true/false instead of nonzero/zero
+      #
+      # Remarks: The cursor is a shared resource. A window should move the cursor only when the cursor is in the
+      # window's client area. The calling process must have WINSTA_WRITEATTRIBUTES access to the window station.
+      # The input desktop must be the current desktop when you call SetCursorPos. Call OpenInputDesktop to determine
+      # whether the current desktop is the input desktop. If it is not, call SetThreadDesktop with the HDESK returned
+      # by OpenInputDesktop to switch to that desktop.
+      #
+      # :call-seq:
+      #   success = set_cursor_pos(x,y)
+      #
+      function :SetCursorPos, [:int, :int], :bool
+    end
+  end
+end

data/lib/win/gui/message.rb

@@ -0,0 +1,22 @@
+require 'win/library'
+
+module Win
+  module Gui
+    # Contains constants and Win32API functions related to inter-Window messaging
+    #
+    module Message
+      include Win::Library
+
+      # Windows Message Get Text
+      WM_GETTEXT = 0x000D
+      # Windows Message Sys Command
+      WM_SYSCOMMAND = 0x0112
+      # Sys Command Close
+      SC_CLOSE = 0xF060
+
+      function 'PostMessage', 'LLLL', 'L'
+      function 'SendMessage', 'LLLP', 'L'
+    end
+  end
+end
+