win 0.1.13 → 0.1.16

data/lib/win/extensions.rb

@@ -3,7 +3,20 @@ class String
   def snake_case
     gsub(/([a-z])([A-Z0-9])/, '\1_\2' ).downcase
   end
-  
+
+  # returns camel_case representation of string
+  def camel_case
+    if self.include? '_'
+      self.split('_').map{|e| e.capitalize}.join
+    else
+      unless self =~ (/^[A-Z]/)
+        self.capitalize
+      else
+        self
+      end
+    end
+  end
+
   # converts string to 'wide char' (Windows Unicode) format
   def to_w
     (self+"\x00").encode('utf-16LE')

data/lib/win/gui/input.rb

@@ -240,6 +240,30 @@ module Win
       #
       function :mouse_event, [:ulong, :ulong, :ulong, :ulong, :ulong, ], :void
 
+      ##
+      # GetCursorPos Function retrieves the cursor's position, in screen coordinates.
+      #
+      # [*Syntax*]: BOOL GetCursorPos( LPPOINT lpPoint );
+      #  Parameters
+      #
+      #  lpPoint
+      #  [out] Pointer to a POINT structure that receives the screen coordinates of the cursor.
+      #  Return Value
+      #
+      #  Returns nonzero if successful or zero otherwise. To get extended error information, call GetLastError.
+      #
+      #
+      #
+      #
+      #  Remarks
+      #
+      #  The cursor position is always specified in screen coordinates and is not affected by the mapping mode of the window that contains the cursor.
+      #
+      #  The calling process must have WINSTA_READATTRIBUTES access to the window station.
+      #
+      #  The input desktop must be the current desktop when you call GetCursorPos. 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.
+
+
       ##
       # 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

data/lib/win/gui/window.rb

@@ -1,4 +1,5 @@
 require 'win/library'
+require 'win/gui/message' # needed because some convenience methods work via PostMessage
 
 module Win
   module GUI
@@ -106,7 +107,7 @@ module Win
       # :call-seq:
       # window?( win_handle )
       #
-      function :IsWindow, [:ulong], :int, boolean: true
+      function :IsWindow, [:HWND], :int, boolean: true
 
       ##
       # The IsWindowVisible function retrieves the visibility state of the specified window.
@@ -129,7 +130,7 @@ module Win
       # :call-seq:
       #   [window_]visible?( win_handle )
       #
-      function :IsWindowVisible, [:ulong], :int, boolean: true, aliases: :visible?
+      function :IsWindowVisible, [:HWND], :int, boolean: true, aliases: :visible?
 
       ##
       # Tests whether the specified window is maximized.
@@ -143,7 +144,7 @@ module Win
       # :call-seq:
       #   zoomed?( win_handle ), maximized?( win_handle )
       #
-      function :IsZoomed, [:ulong], :int, boolean: true, aliases: :maximized?
+      function :IsZoomed, [:HWND], :int, boolean: true, aliases: :maximized?
 
       ##
       # Tests whether the specified window is minimized.
@@ -157,7 +158,7 @@ module Win
       # :call-seq:
       #   iconic?( win_handle ), minimized?( win_handle )
       #
-      function :IsIconic, [:ulong], :int, boolean: true, aliases: :minimized?
+      function :IsIconic, [:HWND], :int, boolean: true, aliases: :minimized?
 
       ##
       # Tests whether a window is a child (or descendant) window of a specified parent window.
@@ -176,7 +177,7 @@ module Win
       # :call-seq:
       #   child?( win_handle )
       #
-      function :IsChild, [:ulong, :ulong], :int, boolean: true
+      function :IsChild, [:HWND, :HWND], :int, boolean: true
 
       ##
       # The FindWindow function retrieves a handle to the top-level window whose class name and window name
@@ -214,7 +215,7 @@ module Win
       # :call-seq:
       #   win_handle = find_window( class_name, win_name )
       #
-      function :FindWindow, [:pointer, :pointer], :ulong, zeronil: true
+      function :FindWindow, [:pointer, :pointer], :HWND, zeronil: true
 
       ##
       # Unicode version of FindWindow (strings must be encoded as utf-16LE AND terminate with "\x00\x00")
@@ -222,7 +223,7 @@ module Win
       # :call-seq:
       #   win_handle = find_window_w( class_name, win_name )
       #
-      function :FindWindowW, [:pointer, :pointer], :ulong, zeronil: true
+      function :FindWindowW, [:pointer, :pointer], :HWND, zeronil: true
 
       ##
       #  The FindWindowEx function retrieves a handle to a window whose class name and window name match the specified
@@ -265,7 +266,7 @@ module Win
       # :call-seq:
       #   win_handle = find_window_ex( win_handle, after_child, class_name, win_name )
       #
-      function :FindWindowEx, [:ulong, :ulong, :pointer, :pointer], :ulong, zeronil: true
+      function :FindWindowEx, [:HWND, :HWND, :pointer, :pointer], :HWND, zeronil: true
 
       ##
       # GetWindowText returns the text of the specified window's title bar (if it has one).
@@ -305,7 +306,7 @@ module Win
       #:call-seq:
       #   text = [get_]window_text( win_handle )
       #
-      function :GetWindowText, [:ulong, :pointer, :int], :int, &return_string
+      function :GetWindowText, [:HWND, :pointer, :int], :int, &return_string
 
       ##
       # GetWindowTextW is a Unicode version of GetWindowText (returns rstripped utf-8 string)
@@ -314,7 +315,7 @@ module Win
       #:call-seq:
       #   text = [get_]window_text_w( win_handle )
       #
-      function :GetWindowTextW, [:ulong, :pointer, :int], :int, &return_string('utf-8')
+      function :GetWindowTextW, [:HWND, :pointer, :int], :int, &return_string('utf-8')
 
       ##
       # GetClassName retrieves the name of the class to which the specified window belongs.
@@ -337,7 +338,7 @@ module Win
       #:call-seq:
       #   text = [get_]class_name( win_handle )
       #
-      function :GetClassName, [:ulong, :pointer, :int], :int, &return_string
+      function :GetClassName, [:HWND, :pointer, :int], :int, &return_string
 
       ##
       # GetClassNameW is a Unicode version of GetClassName (returns rstripped utf-8 string)
@@ -346,7 +347,7 @@ module Win
       #:call-seq:
       #   text = [get_]class_name_w( win_handle )
       #
-      function :GetClassNameW, [:ulong, :pointer, :int], :int, &return_string('utf-8')
+      function :GetClassNameW, [:HWND, :pointer, :int], :int, &return_string('utf-8')
 
       ##
       # ShowWindow shows and hides windows (sets the specified window's show state).
@@ -367,9 +368,51 @@ module Win
       #:call-seq:
       #   was_visible = show_window( win_handle, cmd )
       #
-      function :ShowWindow, [:ulong, :int], :int, boolean: true,
+      function :ShowWindow, [:HWND, :int], :int, boolean: true,
                &->(api, handle, cmd=SW_SHOW) { api.call handle, cmd }
 
+      ##
+      # The CloseWindow function minimizes (but does not destroy) the specified window.
+      #
+      # [*Syntax*]: BOOL CloseWindow( HWND hWnd );
+      #
+      # hWnd:: [in] Handle to the window to be minimized.
+      #
+      # *Returns*:: If the function succeeds, the return value is nonzero (*true* in snake_case method). If the function
+      #             fails, the return value is zero (*false). To get extended error information, call GetLastError.
+      # ---
+      # *Remarks*:
+      # To destroy a window, an application must use the DestroyWindow function.
+      #
+      function :CloseWindow, [:HWND], :int, boolean: true
+
+      ##
+      # DestroyWindow function destroys the specified window. The function sends WM_DESTROY and WM_NCDESTROY messages
+      # to the window to deactivate it and remove the keyboard focus from it. The function also destroys the window's
+      # menu, flushes the thread message queue, destroys timers, removes clipboard ownership, and breaks the clipboard
+      # viewer chain (if the window is at the top of the viewer chain).
+      #
+      # If the specified window is a parent or owner window, DestroyWindow automatically destroys the associated child
+      # or owned windows when it destroys the parent or owner window. The function first destroys child or owned
+      # windows, and then it destroys the parent or owner window.
+      #
+      # DestroyWindow also destroys modeless dialog boxes created by the CreateDialog function.
+      #
+      # [*Syntax*]: BOOL DestroyWindow( HWND hWnd );
+      #
+      # hWnd:: [in] Handle to the window to be destroyed.
+      #
+      # *Returns*:: If the function succeeds, the return value is nonzero (snake_case method: *true*). If the function
+      #             fails, the return value is zero (*false*). To get extended error information, call GetLastError.
+      # ---
+      # *Remarks*:
+      # A thread <b>cannot use DestroyWindow to destroy a window created by a different thread.</b> Use a convenience
+      # method destroy_unowned_window instead (it relies on 
+      # If the window being destroyed is a child window that does not have the WS_EX_NOPARENTNOTIFY style, a
+      # WM_PARENTNOTIFY message is sent to the parent.
+      #
+      function :DestroyWindow, [:HWND], :int, boolean: true
+
       ##
       # GetWindowThreadProcessId retrieves the identifier of the thread that created the specified window
       # and, optionally, the identifier of the process that created the window.
@@ -392,11 +435,10 @@ module Win
       #:call-seq:
       #   thread, process_id = [get_]window_tread_process_id( win_handle )
       #
-      function :GetWindowThreadProcessId, [:ulong, :pointer], :long,
-               &->(api, *args) {
-               namespace.enforce_count( args, api.prototype, -1)
+      function :GetWindowThreadProcessId, [:HWND, :pointer], :long,
+               &->(api, handle) {
                process = FFI::MemoryPointer.new(:long).write_long(1)
-               thread = api.call(args.first, process)
+               thread = api.call(handle, process)
                thread == 0 ? [nil, nil] : [thread, process.read_long()] }
       # weird lambda literal instead of normal block is needed because current version of RDoc
       # goes crazy if block is attached to meta-definition
@@ -425,12 +467,11 @@ module Win
       #:call-seq:
       #   rect = [get_]window_rect( win_handle )
       #
-      function :GetWindowRect, [:ulong, :pointer], :int,
-               &->(api, *args) {
-               namespace.enforce_count( args, api.prototype, -1)
+      function :GetWindowRect, [:HWND, :pointer], :int,
+               &->(api, handle) {
                rect = FFI::MemoryPointer.new(:long, 4)
                #rect.write_array_of_long([0, 0, 0, 0])
-               res = api.call args.first, rect
+               res = api.call handle, rect
                res == 0 ? [nil, nil, nil, nil] :  rect.read_array_of_long(4) }
       # weird lambda literal instead of normal block is needed because current version of RDoc
       # goes crazy if block is attached to meta-definition
@@ -454,7 +495,7 @@ module Win
       # :call-seq:
       #  EnumWindowsProc callback block: {|win_handle, value| your callback code }
       #
-      callback :EnumWindowsProc, [:ulong, :long], :bool
+      callback :EnumWindowsProc, [:HWND, :long], :bool
 
       ##
       # The EnumWindows function enumerates all top-level windows on the screen by passing the handle to
@@ -561,7 +602,7 @@ module Win
       #:call-seq:
       #   handles = enum_child_windows( parent_handle, [value=0] ) {|handle, value| your callback procedure }
       #
-      function :EnumChildWindows, [:ulong, :EnumWindowsProc, :long], :bool, &return_enum
+      function :EnumChildWindows, [:HWND, :EnumWindowsProc, :long], :bool, &return_enum
 
       ##
       # GetForegroundWindow function returns a handle to the foreground window (the window with which the user
@@ -576,7 +617,7 @@ module Win
       #:call-seq:
       #   win_handle = [get_]foreground_window()
       #
-      function :GetForegroundWindow, [], :ulong, zeronil: true
+      function :GetForegroundWindow, [], :HWND, zeronil: true
 
       ##
       # The GetActiveWindow function retrieves the window handle to the active window attached to
@@ -593,7 +634,8 @@ module Win
       #:call-seq:
       #   win_handle = [get_]active_window()
       #
-      function :GetActiveWindow, [], :ulong, zeronil: true
+      function :GetActiveWindow, [], :HWND, zeronil: true
+
 
       # Convenience wrapper methods:
 
@@ -610,6 +652,27 @@ module Win
       def foreground?(win_handle)
         win_handle == foreground_window
       end
+
+      ##
+      # Shuts down the window <b>created by different thread</b> by posting WM_SYSCOMMAND, SC_CLOSE message to it.
+      # This closely emulates user clicking on X button of the target window. As it would be expected, this
+      # actually gives the target window chance to close gracefully (it may ask user to save data and stuff).
+      # I have not find so far how to REALLY destroy window in different thread without it asking user anything.
+      #
+      def shut_window( win_handle)
+        post_message(win_handle, Win::GUI::Message::WM_SYSCOMMAND, Win::GUI::Message::SC_CLOSE, 0)
+      end
+
+      ##
+      # Returns text associated with window by sending WM_GETTEXT message to it.
+      # ---
+      # *Remarks*: It is *different* from GetWindowText that returns only window title
+      #
+      def text( win_handle)
+        buffer = FFI::MemoryPointer.new :char, 1024
+        num_chars = send_message win_handle, Win::GUI::Message::WM_GETTEXT, buffer.size, buffer
+        num_chars == 0 ?  nil : buffer.get_bytes(0, num_chars)
+      end
     end
   end
 end

data/lib/win/library.rb

@@ -104,8 +104,10 @@ module Win
               # :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 typedefs:
+              # 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.
@@ -128,6 +130,7 @@ module Win
               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
@@ -177,7 +180,7 @@ module Win
               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:   :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
@@ -319,7 +322,7 @@ module Win
       # :zeronil:: Forces method to return nil if function result is zero
       #
       def function(name, params, returns, options={}, &def_block)
-        method_name, effective_names, aliases = generate_names(name, options)
+        snake_name, effective_names, aliases = generate_names(name, options)
         params, returns = generate_signature(params, returns)
         libs = ffi_libraries.map(&:name)
         boolean = options[:boolean]
@@ -339,27 +342,35 @@ module Win
         # Create API object that holds information about function names, params, etc
         api = API.new(namespace, name, effective_name, params, returns, libs)
 
-        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 }
+        # 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
-            ->(*args, &block){ def_block.(api, *args, &block) }
+            if zeronil
+              ->(*args, &block){ (res = block ? block[api[*args]] : api[*args]) != 0 ? res : nil }
+            elsif boolean
+              ->(*args, &block){ block ? block[api[*args]] : api[*args] != 0 }
+            else
+              ->(*args, &block){ block ? block[api[*args]] : api[*args] }
+            end
           end
-        else
-          if zeronil
-            ->(*args, &block){ (res = block ? block[api[*args]] : api[*args]) != 0 ? res : nil }
-          elsif boolean
-            ->(*args, &block){ block ? block[api[*args]] : api[*args] != 0 }
-          else
-            ->(*args, &block){ block ? block[api[*args]] : api[*args] }
+
+          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
 
-        define_method method_name, &method_body       # define snake_case method
-
-        aliases.each {|ali| alias_method ali, method_name }  # define aliases
+        aliases.each {|ali| alias_method ali, snake_name }  # define aliases
         api   #return api object from function declaration
       end
 
@@ -372,16 +383,16 @@ module Win
         effective_names = [name]
         effective_names += ["#{name}A", "#{name}W"] unless name =~ /[WA]$/
         aliases = ([options[:alias]] + [options[:aliases]]).flatten.compact
-        method_name = options[:rename] || name.snake_case
-        case method_name
+        snake_name = options[:rename] || name.snake_case
+        case snake_name
           when /^is_/
-            aliases << method_name.sub(/^is_/, '') + '?'
+            aliases << snake_name.sub(/^is_/, '') + '?'
           when /^set_/
-            aliases << method_name.sub(/^set_/, '')+ '='
+            aliases << snake_name.sub(/^set_/, '')+ '='
           when /^get_/
-            aliases << method_name.sub(/^get_/, '')
+            aliases << snake_name.sub(/^get_/, '')
         end
-        [method_name, effective_names, aliases]
+        [snake_name, effective_names, aliases]
       end
 
       ##
@@ -432,9 +443,10 @@ module Win
       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.extend ClassMethods
+
       klass.ffi_lib 'user32', 'kernel32'  # Default libraries
       klass.ffi_convention :stdcall
     end

data/spec/spec_helper.rb

@@ -74,6 +74,10 @@ module WinTest
   def not_a_handle
     123
   end
+
+  def buffer
+    FFI::MemoryPointer.new(:char, 1024)
+  end
 end
 
 module WinTestApp
@@ -86,15 +90,21 @@ module WinTestApp
     system TEST_APP_START
     sleep TEST_SLEEP_DELAY until (handle = find_window(nil, TEST_WIN_TITLE))
 
-    @launched_test_app = Window::Window.new handle
-#    app = "Test app"    #need to get rid of Window for JRuby
-#    class << app; self; end.send( :define_method, :handle, &lambda {handle})
-#    @launched_test_app = app
+    textarea = find_window_ex(handle, 0, TEST_TEXTAREA_CLASS, nil)
+    app = "Locknote" # App identifier
+
+    eigenklass = class << app; self; end      # Extracting app's eigenclass
+    eigenklass.class_eval do                  # Defining singleton methods on app
+      define_method(:handle) {handle}
+      define_method(:textarea) {textarea}
+    end
+
+    @launched_test_app = app
   end
 
   def close_test_app(app = @launched_test_app)
-    while app and app.respond_to? :handle and find_window(nil, TEST_WIN_TITLE)
-      post_message(app.handle, WM_SYSCOMMAND, SC_CLOSE, 0)
+    while app && app.respond_to?( :handle) && find_window(nil, TEST_WIN_TITLE)
+      shut_window app.handle
       sleep TEST_SLEEP_DELAY
     end
     @launched_test_app = nil
@@ -104,9 +114,9 @@ module WinTestApp
   def test_app
     app = launch_test_app
 
-    def app.textarea #define singleton method retrieving app's text area
-      Window::Window.new find_window_ex(self.handle, 0, TEST_TEXTAREA_CLASS, nil)
-    end
+#    def app.textarea #define singleton method retrieving app's text area
+#      Window::Window.new find_window_ex(self.handle, 0, TEST_TEXTAREA_CLASS, nil)
+#    end
 
     yield app
     close_test_app app

data/spec/win/dde_spec.rb

@@ -233,7 +233,8 @@ module WinDDETest
       describe '#dde_connect' do
         spec{ use{ conversation_handle = DdeConnect( instance_id=0, service=0, topic=0, context=nil) }}
         spec{ use{ conversation_handle = dde_connect( instance_id=0, service=0, topic=0, context=nil) }}
-          it 'connects to existing DDE server'
+
+        it 'connects to existing DDE server'
       end
 
       describe '#dde_disconnect' do

data/spec/win/error_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'win/error'
+require 'win/gui/window'
+
+module WinErrorTest
+  include WinTest
+  include Win::Error
+  include Win::GUI::Window
+
+  def buffer
+    FFI::MemoryPointer.new(:char, 1024)
+  end
+
+  describe Win::Error, ' contains a set of pre-defined Windows API functions' do
+    describe "#get_last_error" do
+      spec{ use{ err_code = GetLastError() }}
+      spec{ use{ err_message = get_last_error() }}
+
+      it "original api retrieves the calling thread's last-error code value" do
+        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE)
+        GetLastError().should == ERROR_FILE_NOT_FOUND
+        window_text(0)
+        GetLastError().should == ERROR_INVALID_WINDOW_HANDLE
+      end
+
+      it "enhanced api retrieves the message corresponding to last error code" do
+        find_window(TEST_IMPOSSIBLE, TEST_IMPOSSIBLE)
+        get_last_error.should == "The system cannot find the file specified."
+        window_text(0)
+        get_last_error.should == "Invalid window handle."
+      end
+
+    end # describe "#get_last_error"
+
+    describe "#format_message" do
+      spec{ use{ num_chars = FormatMessage(dw_flags=0, lp_source=nil, dw_message_id=0, dw_language_id=0, buffer, buffer.size, :int, 0) }}
+      spec{ use{ message = format_message(dw_flags=0, lp_source=nil, dw_message_id=0, dw_language_id=0, :int, 0) }}
+
+      it "original api Formats a message string. The function requires a message definition as input. The message definition " do
+        pending
+        num_chars = FormatMessage(dw_flags=0, nil, dw_message_id=0, dw_language_id=0, buffer, buffer.size, :int, 0)
+      end
+
+      it "snake_case api Formats a message string. The function requires a message definition as input. The message definition " do
+        pending
+        message = format_message(dw_flags=0, nil, dw_message_id=0, dw_language_id=0, lp_buffer=0, n_size=0,:int, 0)
+      end
+
+    end # describe format_message
+
+
+  end # describe Win::Error
+end

data/spec/win/extensions_spec.rb

@@ -14,16 +14,26 @@ module WinTest
       end
     end
 
+    context '#camel_case' do
+      it 'transforms snake_case strings' do
+        'get_char_width_32'.camel_case.should == 'GetCharWidth32'
+      end
+
+      it 'leaves CamelCase strings intact' do
+        'GetCharWidth32'.camel_case.should == 'GetCharWidth32'
+      end
+    end
+
     context '#to_w' do
       it 'transcodes string to utf-16LE' do
         'GetCharWidth32'.to_w.encoding.name.should == 'UTF-16LE'
       end
-      
+
       it 'ensures that encoded string is null-terminated' do
         'GetCharWidth32'.to_w.bytes.to_a[-2..-1].should == [0, 0]
       end
     end
-    
+
     context '#to_vkeys' do
       it 'transforms number char into [equivalent key code]' do
        ('0'..'9').each {|char| char.to_vkeys.should == char.unpack('C')}

data/spec/win/gui/input_spec.rb

@@ -14,15 +14,15 @@ module WinWindowTest
 
       it 'synthesizes a numeric keystrokes, emulating keyboard driver' do
         test_app do |app|
-          text = '123 456'
+          text = '12 34'
           text.upcase.each_byte do |b| # upcase needed since user32 keybd_event expects upper case chars
             keybd_event(b.ord, 0, KEYEVENTF_KEYDOWN, 0)
             sleep TEST_KEY_DELAY
             keybd_event(b.ord, 0, KEYEVENTF_KEYUP, 0)
             sleep TEST_KEY_DELAY
           end
-          app.textarea.text.should =~ Regexp.new(text)
-          7.times {keystroke(VK_CONTROL, 'Z'.ord)} # dirty hack!
+          text(app.textarea).should =~ Regexp.new(text)
+          5.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
     end
@@ -46,8 +46,8 @@ module WinWindowTest
         test_app do |app|
           keystroke(VK_CONTROL, 'A'.ord)
           keystroke(VK_SPACE)
-          app.textarea.text.should == ' '
-          2.times {keystroke(VK_CONTROL, 'Z'.ord)} # dirty hack!
+          text(app.textarea).should.should == ' '
+          2.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
     end
@@ -59,8 +59,8 @@ module WinWindowTest
         test_app do |app|
           text = '12 34'
           type_in(text)
-          app.textarea.text.should =~ Regexp.new(text)
-          5.times {keystroke(VK_CONTROL, 'Z'.ord)} # dirty hack!
+          text(app.textarea).should =~ Regexp.new(text)
+          5.times {keystroke(VK_CONTROL, 'Z'.ord)} # rolling back changes to allow window closing without dialog!
         end
       end
     end