wet-winobj 0.1-mswin32

data/src/wet/winobjects/WinEdit.rb

@@ -0,0 +1,125 @@
+=begin license
+Copyright (c) 2005, Qantom Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+Neither the name of Qantom Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(based on BSD Open Source License)
+=end
+
+require 'wet/winobjects/Window.rb'
+
+
+module Wet
+    module Winobjects
+=begin rdoc
+    Class to represent a Win32 edit box. 
+=end
+        class WinEdit < Window
+        
+            @@known_class_names = ["Edit"]
+
+=begin rdoc
+    Constructor to create a new WinEdit. Typically not invoked
+    directly. WinEdits are created using helper methods. 
+=end
+            def initialize(hwnd)
+                super(hwnd)
+                if @hwnd != -1
+                    find_styles
+                end
+            end
+            
+=begin rdoc
+        Is the Window object a possible candidate for this class?
+        Return true if yes. False otherwise. 
+=end
+#Note : - in the interest of reusable design, I had first put it this as a method
+#in Window. But then I realized that each class may have to make complex 
+#calculations - eg. A label could be a static or an edit field set to read-only
+            def WinEdit.candidate_match?(win_element)
+                is_match = false
+                @@known_class_names.each do |e|                    
+                    if TextUtils.compare_text(win_element.win_class,e) 
+                        is_match = true 
+                        break 
+                    end
+                end
+                return is_match            
+            end 
+            
+=begin rdoc
+    Set the text in the textfield. 
+=end
+            def set(text)
+                assert_object_exists
+                return do_set_text(@hwnd, text) 
+            end
+            
+=begin rdoc
+            Retreive the text that has been set for this 
+            object. 
+=end
+            def text()
+                assert_object_exists
+                return do_get_text(@hwnd) 
+            end
+            
+            
+=begin rdoc
+            If the WinEdit is actually being used as a label to display text, 
+            get that display text and return it. The display_text is only
+            applicable if the control's readonly is set to 'true' 
+=end
+            def display_text()
+                assert_object_exists
+                ret_text = ""
+                if is_readonly
+                    ret_text = text()
+                end
+                return ret_text
+            end
+            
+=begin rdoc
+            Is this textfield supposed to be readonly. return 
+            true or false
+=end
+            def is_readonly()
+                assert_object_exists
+                return @is_readonly
+            end
+
+=begin rdoc
+            Is this textfield supposed to be a password control? return 
+            true or false
+=end
+            def is_password()
+                assert_object_exists
+                return @is_password
+            end
+            
+            def to_s()
+                str = "WinEdit(label:="
+                if label != nil
+                    str = str + label()
+                end
+                str = str + ")" 
+                return str 
+            end
+            
+            private
+            def find_styles()
+                super
+                
+                @is_password = @control_style & ES_PASSWORD == ES_PASSWORD
+                @is_readonly = @control_style & ES_READONLY == ES_READONLY 
+            end
+            
+        end
+    end
+end

data/src/wet/winobjects/WinLabel.rb

@@ -0,0 +1,112 @@
+=begin license
+Copyright (c) 2005, Qantom Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+Neither the name of Qantom Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(based on BSD Open Source License)
+=end
+
+module Wet
+    module Winobjects
+    
+=begin rdoc
+    Class to represent a Win32 textual label. 
+=end
+        class WinLabel < Window	    
+            @@known_class_names = ["Static"]
+    
+
+=begin rdoc
+    Constructor to create a new WinLabel. Typically not invoked
+    directly. WinLabels are created using helper methods. 
+=end    
+            def initialize(hwnd)
+                super
+                if @hwnd != -1
+                    found = find_labelled
+                    if found != -1
+                        @label_for=Window::create(found)
+                        @label_for.set_label(self)
+                    end
+                end
+            end
+            
+=begin rdoc
+            Which control is this WinLabel element a 'label' for? Return
+            the WinObject to which the current Label element is 
+            associated
+=end
+            def labelled_control()
+                return @label_for
+            end
+            
+=begin rdoc
+        Is the Window object a possible candidate for this class?
+        Return true if yes. False otherwise. 
+=end
+#Note : - in the interest of reusable design, I had first put it this as a method
+#in Window. But then I realized that each class may have to make complex 
+#calculations - eg. A label could be a static or an edit field set to read-only
+#Note : Right now only Static fields are supported
+            def WinLabel.candidate_match?(win_element)
+                is_match = false
+                @@known_class_names.each do |e|                    
+                    if TextUtils.compare_text(win_element.win_class,e) 
+                        is_match = true 
+                        break 
+                    end
+                end
+                return is_match            
+            end            
+            
+=begin rdoc
+        Get the text that that is being displayed
+=end
+            def display_text()
+                assert_object_exists
+                return text()
+            end
+    
+            def to_s()
+                find_labelled()
+                str = "WinLabel(text:="
+                str = str + text()
+                str = str + ")" 
+                return str 
+            end
+            
+            private
+            def find_labelled()
+                #This may start falling over - There are a few additional tests 
+                #that you'll need to do - 
+                #a) Does this label have '&' character - if dont consider this as
+                #a label. 
+                is_label_found = false
+                cur_wnd = @hwnd
+                found_wnd = -1
+                while !is_label_found
+                    cur_wnd=next_window(cur_wnd)
+                    
+                    if cur_wnd != 0 
+                        if Window.new(cur_wnd).is_tab_stop
+                            is_label_found = true
+                            found_wnd = cur_wnd
+                            break
+                        end
+                    else
+                        break
+                    end
+                end
+                return found_wnd
+            end
+            
+        end
+	end
+    
+end

data/src/wet/winobjects/WinObjects.rb

@@ -0,0 +1,35 @@
+=begin license
+Copyright (c) 2005, Qantom Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+Neither the name of Qantom Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(based on BSD Open Source License)
+=end
+require 'wet/winobjects/WinUtils.rb'
+require 'wet/winobjects/Window.rb'
+require 'wet/winobjects/WinEdit.rb'
+require 'wet/winobjects/WinComboBox.rb'
+require 'wet/winobjects/WinButton.rb'
+require 'wet/winobjects/WinCheckbox.rb'
+require 'wet/winobjects/WinRadio.rb'
+require 'wet/winobjects/WinLabel.rb'
+require 'wet/winobjects/AppWindow.rb'
+require 'wet/winobjects/WinDialog.rb'
+require 'wet/utils/CompileUtils.rb'
+require 'wet/exceptions/CompileExceptions.rb'
+require 'wet/exceptions/RuntimeExceptions.rb'
+
+module Wet
+    module Winobjects    
+        include Wet::Utils
+        include WinUtils
+        include Wet::Exceptions
+
+    end    
+end

data/src/wet/winobjects/WinRadio.rb

@@ -0,0 +1,75 @@
+=begin license
+Copyright (c) 2005, Qantom Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+Neither the name of Qantom Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(based on BSD Open Source License)
+=end
+
+module Wet
+    module Winobjects
+=begin
+    Class to represent a win32 button
+=end
+        class WinRadio < WinButton
+    
+            @@known_class_names = ["Button"]
+            
+
+            
+=begin rdoc
+        Is the Window object a possible candidate for this class?
+        Return true if yes. False otherwise. 
+=end
+#Note : - in the interest of reusable design, I had first put it this as a method
+#in Window. But then I realized that each class may have to make complex 
+#calculations - eg. A label could be a static or an edit field set to read-only
+            def WinRadio.candidate_match?(win_element)
+                is_match = false
+                @@known_class_names.each do |e|                    
+                    if TextUtils.compare_text(win_element.win_class,e) 
+                        tmp_button = WinButton.new(win_element.hwnd) 
+                        if tmp_button.is_radio()                        
+                            is_match = true 
+                            break 
+                        end
+                    end
+                end
+                return is_match            
+            end 
+            
+=begin rdoc
+            Is the radio button 'selected'?(checked)
+            Return true if yes. False otherwise
+=end
+            def is_set()
+                assert_object_exists
+                return button_state()== BST_CHECKED
+            end
+            
+=begin rdoc
+            Set this radio button to 'checked' state. 
+=end
+            def set()
+                assert_object_exists
+                do_set_check_on(@hwnd) 
+            end
+            
+            def to_s()
+                str = "WinRadio(text:="
+                str = str + text()
+                str = str + ")" 
+                return str 
+            end
+
+            
+        end
+    end
+    
+end

data/src/wet/winobjects/WinUtils.rb

@@ -0,0 +1,231 @@
+=begin license
+Copyright (c) 2005, Qantom Software
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+Neither the name of Qantom Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(based on BSD Open Source License)
+=end
+
+
+
+=begin rdoc
+    Win32 utils that are used to handle various Popups. Avoid using methods
+    from this module. This are typicall called by the various popup classes 
+    (Like ModalDialog, FileChooser, etc.)
+=end 
+
+require 'dl/import'
+require 'win32ole'
+require 'dl/struct'
+require 'Win32API'
+require 'wet/constants/winconstants'
+require 'wet/utils/TextUtils'
+
+module Wet
+
+    module WinUtils
+    include Wet::Utils
+
+        User32 = DL.dlopen("user32")    
+
+        
+        $continue_enum = 1    
+        $stop_enum = 0 
+        
+        $get_caption_length = User32['GetWindowTextLengthA', 'LL'] 
+        $get_caption = User32['GetWindowTextA', 'LLpL']
+        $enum_child_windows  = User32['EnumChildWindows' , 'ILPP' ]
+        $enum_windows = User32['EnumWindows', 'IPP']
+        $get_class_name = User32['GetClassName', 'ILpI']
+        $get_window = User32['GetWindow', 'LLI']
+        $get_active_popup = User32['GetLastActivePopup', 'LL']
+        $set_active_window = User32['SetActiveWindow', 'LL']
+        $get_active_window = User32['GetActiveWindow', 'L']
+        $show_window = User32['ShowWindow', 'ILI']
+        $destroy_window = User32['DestroyWindow', 'IL']
+        $get_window_long = User32['GetWindowLongA', 'LLL' ]
+        
+        $get_parent = User32['GetParent', 'LL']
+        $post_message = User32['PostMessage', 'ILIPP']
+        $send_message = User32['SendMessage',  'ILIPP']  
+        
+        $send_message_for_get = User32['SendMessage',  'ILIIS']  
+        
+        
+        ### Call backs :- There seems to be some limitation on the number
+        ### of dll callbacks that can be defined. Therefore all callbacks have
+        ### to be defned as globals. I am not sure about what the limitation is
+        ### but it seems to be around 32 at a time. If we exceed this limit - we'll
+        ### need to find another way out. 
+        #Call back for enumering children        
+        
+        $child_windows_callback = DL.callback('ILP') { |hwnd, passed_param|                
+                eval passed_param    
+                $continue_enum
+            }
+        
+        
+        
+        def class_name(hwnd)
+            buffer = " " * 32
+            len, arr = $get_class_name.call(hwnd, buffer, buffer.size)
+            return arr[1].to_s()
+        end
+        
+        def enabled_popup(hwnd)
+            res, arr = $get_window.call(hwnd, GW_ENABLEDPOPUP)
+            if res === hwnd || res == 0
+                res = -1
+            end
+            return res
+        end
+        
+        def parent_window(hwnd)
+            res, arr = $get_parent.call(hwnd)
+            return res
+        end
+        
+        #candidate for private class
+        def enum_windows()            
+            enum_windows_callback = DL.callback('ILP') {|hwnd,lparam|
+                sleep 0.05
+                eval lparam
+                $continue_enum
+            }
+            reqd_objects = []
+            to_eval = "reqd_objects << hwnd"
+            $enum_windows.call(enum_windows_callback, to_eval)
+            return reqd_objects        
+        end
+        
+        #Technically you can use the enum_windows method and acheive this
+        #However since enum_windows will go ahead and find each window, this
+        #method is more efficient - it breaks on first find. 
+        def find_window(title)            
+            reqd_handle = -1 
+            enum_windows_callback = DL.callback('ILP') {|hwnd,lparam|
+                sleep 0.05
+                win_title = window_caption(hwnd)
+                if TextUtils.compare_text(win_title, title) 
+                    #puts "Found window!!!#{win_title}"
+                    reqd_handle = hwnd
+                    $stop_enum
+                else
+                    $continue_enum
+                end                
+            }
+            
+            $enum_windows.call(enum_windows_callback, "")
+            return reqd_handle
+        end
+        
+        def set_active_window(hwnd)
+            res, arr = $show_window.call(hwnd, SW_MINIMIZE) 
+            res, arr = $show_window.call(hwnd, SW_SHOWNORMAL) 
+            return res
+        end
+
+        def do_maximize(hwnd)
+            res, arr = $show_window.call(hwnd, SW_MINIMIZE) 
+            res, arr = $show_window.call(hwnd, SW_MAXIMIZE)
+            return res
+        end
+        
+        def do_minimize(hwnd)
+            res, arr = $show_window.call(hwnd, SW_MINIMIZE) 
+            return res
+        end
+        
+        def do_destroy_window(hwnd)
+            do_maximize(hwnd) 
+            res, arr = $destroy_window.call(hwnd) 
+            return res
+        end
+        
+        def get_window_style(hwnd)
+            res, arr = $get_window_long.call(hwnd, GWL_STYLE) 
+            return res
+        end
+        
+        
+        def window_caption(hwnd)
+            len, arr = $get_caption_length.call(hwnd) 
+            captionBuffer = " " * (len)
+            res, arr = $get_caption.call(hwnd, captionBuffer, len+1)
+            return arr[1].to_s()
+        end
+        
+        def owner(hwnd)
+            res, arr = $get_window.call(hwnd, GW_OWNER)
+            return res
+        end
+        
+        def next_window(hwnd)
+            res, arr = $get_window.call(hwnd, GW_HWNDNEXT) 
+            return res
+        end
+        
+        
+        def children(hwnd, required_class = nil)
+            count = 0
+            ### BAD BAD UGLY way of doing it(using the constant var)
+            ### - There seems to be some
+            ## limitation on the number of Dll callbacks that can be defined. 
+            ## Temporary workaround - Please clean this part of the code. 
+            $reqd_children_objects = []
+            if required_class == nil
+                to_eval = "$reqd_children_objects << hwnd"
+            else
+                to_eval = "if class_name(hwnd) == required_class;"  \
+                               "$reqd_children_objects << hwnd;end"
+            end
+            #to_eval = "puts 'hello'"
+            $enum_child_windows.call(hwnd,  $child_windows_callback, to_eval) 
+            
+            # I just hate that I have to use global variables - However given the callback count 
+            #limitation of DL api, Iam forced to use it. Introducing atleast some gaurd - As soon
+            # as we are done with what we we want to do - set the global variable to nil
+            retn_objects = []
+            $reqd_children_objects.each do |r|
+                retn_objects << r
+            end
+            $reqd_objects = nil
+            return retn_objects
+        end
+        
+        def do_button_click(hwnd)
+            r,rs = $post_message.call(hwnd,BM_CLICK, nil, nil) 
+            return r
+        end
+        
+        def do_set_text(hwnd, txt)
+            r,rs = $send_message.call(hwnd, WM_SETTEXT, nil, txt) 
+        end
+        
+        def do_get_text(hwnd)
+            buff = " " * 256        
+            r  ,rs  = $send_message_for_get.call(hwnd , WM_GETTEXT , 256 , buff )
+            str = buff.slice(0, r)
+            return str       
+        end
+        
+        def do_get_button_state(hwnd)
+            r, arr = $send_message_for_get.call(hwnd, BM_GETSTATE, 0, 0.to_s)
+            return r
+        end
+        
+        def do_set_check_on(hwnd)
+            r, arr = $send_message_for_get.call(hwnd, BM_SETCHECK, BST_CHECKED, 0.to_s)
+        end
+        
+        def do_set_check_off(hwnd)
+            r, arr = $send_message_for_get.call(hwnd, BM_SETCHECK, BST_UNCHECKED, 0.to_s)
+        end        
+    end
+end