#Wintir is based on the guitest and watir automation
require "Win32API"
require 'win32ole'
#require "cguitest"


module Wintir
  module GuiTest
    #Find Window
    FindWindow = Win32API.new('user32', 'FindWindow', ["P", "P"], "L")
    #Find sub windows
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    #Get Some Extra Details
    GetClientRect = Win32API.new('user32','GetClientRect','LP','I')
    GetWindowRect = Win32API.new('user32','GetWindowRect','LP','I')
    
    
    class Rect
      # TODO - rather than having Rect know how to unpack the buffer, the caller should
      # do that, and then pass the 4 parameters.  This decouples Rect from knowledge of
      # how the buffer is packed.
      def initialize(buf)
        @left,@top,@right,@bottom = buf.unpack("llll")
        width
        height
        #puts @left,@top,@right,@bottom
      end
      attr_accessor :left, :top, :right, :bottom

      def width
        @width = @right - @left
        #puts @right - @left
      end
      attr_accessor :width

      def height
        @height = @bottom - @top
        #puts @bottom - @top
      end
      attr_accessor :height
    end
    
    def assign_com how, what
      #Find window's handle 
      com = FindWindow.call(how, what)
      query_window com
      
      puts com
      
      return com      
    end
    
    def query_window com
      buf = "\0" * 16
      GetWindowRect.call(com, buf)
      @Rect = Rect.new(buf)
    end
      
  end
end

module Wintir
  class ObjectAssert
    
    SendMessage = Win32API.new("user32", "SendMessage", ['L'] * 4, 'L')
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    
    #Does the object exist
    def object_exists(obj)
     
      #puts obj.com
      
      obj_id = FindWindowEx.call(obj.com,0,obj.name.to_s,obj.caption.to_s) 
      @obj_id = obj_id
  
      return obj_id
 
    end
    attr_accessor :left, :top, :right, :bottom, :obj_id
    #Object Visible/Enabled
    def object_style(obj)
      #puts obj
    end
  end
end


module Wintir
  
  class DialogWindow
 
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    GetWindowTextA = Win32API.new('user32','GetWindowTextA','LPI','I')
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    
    def initialize(container, dialog_name)
      #puts container
      @container = container
      get_dialog(dialog_name)
    end
    
    attr_accessor :com
    
    def get_dialog(dialog_name)
      
      #create dialog_title space
      dialog_title = "".center(256)
      
      #32770 is the name for a dialog - brilliant!
      d_hwnd = FindWindowEx.call(0, 0, "#32770", 0)
      
      #Confirm the dialog_name is the one we're after
      GetWindowTextA.call(d_hwnd, dialog_title, 200)
      
      #puts dialog_name
      #puts d_hwnd
      #puts dialog_title.rstrip
      
      
      @com = d_hwnd 
      
    end
    
    def close
       SendMessageA.call(self.com, 16, 0, 0)
    end
      
    def click_button
      #puts "click the button then"
    end

	def static_text
		puts self.com
		t_hwnd = FindWindowEx.call(self.com, 0, 'Static', '')	
		 puts "id #{t_hwnd}"
	end
	

    attr_accessor :name, :attached_text, :zorder, :caption
    
    def button(describe = nil)
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      Button.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
    end
    
    def combo_list(describe = nil)
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      Combo_List.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
     end
    
    def list_box(describe=nil)
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      List_Box.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
    end
    
    def static(describe = nil)
      @static = describe
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      Static_Text.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
    end
    
    def tabs(describe=nil)
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      TabControl.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
    end
    
  end
  
  class Dialog < DialogWindow
    INPUT_TYPES = ["caption", "button", "attached_text", "zorder"]
  end
  
end

#FileMenuInput Class
module Wintir
  class FileMenuInput
    
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    SendMessageAB  = Win32API.new('user32', 'SendMessage', ["L", "L", "P", "P"], "L")
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    PostMessageA = Win32API.new('user32','PostMessageA','LIIL','I')
    GetMenu = Win32API.new('user32','GetMenu','L','L')
    GetMenuA = Win32API.new('user32','GetMenu','I', 'I')
    GetMenuItemCount = Win32API.new('user32','GetMenuItemCount','L','I')
    GetMenuStringA = Win32API.new('user32','GetMenuStringA','LIPII','I')
    GetMenuString = Win32API.new('user32','GetMenuString','LIPII','I')
    GetSubMenu = Win32API.new('user32','GetSubMenu','LI','L')
    GetMenuItemID = Win32API.new('user32','GetMenuItemID','LI','I')
   
    
    WM_SETTEXT  = 0x000C
    
    def initialize(container, menu_path)
      
      #puts  container.com
      @container = container
      get_application_menu(menu_path)
           
    end
    
    attr_accessor :container
    
    def click
      #puts "click"
    end

    def get_application_menu(menu_path)
     
      #Delare menu item false
      top_level_menu_item = false
      sub_level_menu_item = false
     
      mi = menu_path.split('>')   
          
      #Get Menu
      h_wnd_menu = GetMenuA.call(container.com)
      #puts h_wnd_menu
     
      menu_count = GetMenuItemCount.call(h_wnd_menu)
      ##puts menu_count
     
      top_menu = "".center(256)
      sub_name = "".center(256)
      sub_l_name = "".center(256)
     
      for i in 0..(menu_count-1) do
       
        GetMenuString.call(h_wnd_menu, i, top_menu, top_menu.length, 1024)
        top_menu_item = top_menu.rstrip
        ##puts top_menu_item.to_s
               
        replace_from = '&'
        replace_to = ''
        top_menu_item = top_menu_item.gsub(/#{replace_from}/, replace_to)
       
        if( /#{mi[0]}/.match(top_menu_item.to_s) )
          #boolean check
          ##puts "Found it #{mi[0]}"
          ##puts top_menu_item
          top_level_menu_item = true
         
        end

        h_view = GetSubMenu.call(h_wnd_menu, i)
        #       #puts h_view
       
        GetMenuString.call(h_view, i, sub_name, sub_name.length, 1024)
        #       #puts sub_name.strip
       
        menu_count1 = GetMenuItemCount.call(h_view)
        for j in 0..(menu_count1-1) do
          GetMenuString.call(h_view, j, sub_l_name, sub_l_name.length, 1024)
       
          sub_menu_item = sub_l_name.rstrip
          ##puts sub_menu_item.to_s
         
          ##puts sub_l_name.strip
          menu_item = GetMenuItemID.call(h_view, j)
          ##puts menu_item
          sub_menu_item = sub_menu_item.gsub(/#{replace_from}/, replace_to)
          ##puts sub_menu_item.to_s
         
          if( /#{mi[1]}/.match(sub_menu_item.to_s) )
            #boolean check
            ##puts sub_menu_item
            ##puts "Found it #{mi[1]}"
            sub_level_menu_item = true
         
          end

          if top_level_menu_item && sub_level_menu_item
            ##puts menu_item
            ##puts h_wnd
            
            #Use PostMessage so as not to wait for confirmation
            PostMessageA.call(@container.com, 273, menu_item, 0) 
            top_level_menu_item = false           
            sub_level_menu_item = false
           
            #puts "Found menu: #{mi[0]} > #{mi[1]}"
          end
         
          #Reset the holding variable to blank
          #open_file(sub_l_name.strip)
          sub_l_name = "".center(256)
        end

        #Reset the holding variable to blank
        sub_name = "".center(256)
        #open_file(sub_l_name.strip)
      end

    end
    
  end
  
  class Filemenu < FileMenuInput
    INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
  end
end

#Combo Box Class
module Wintir
  class Combolist
    
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    GetComboBoxInfo = Win32API.new('user32','GetComboBoxInfo','LP','L')
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    GetClientRect = Win32API.new('user32','GetClientRect','LP','I')    
    GetWindowRect = Win32API.new('user32','GetWindowRect','LP','I')
    
    #Messages
    CB_SELECTSTRING = 333
    CB_GETCOUNT = 326
    CB_GETDROPPEDSTATE = 343
    CB_GETLBTEXT = 328
    CB_GETLBTEXTLEN = 329 
    
    include Wintir::GuiTest    
    
    def initialize(container, caption, name, attached_text, zorder)
      find_combo(container)
      check_attached_text(self.cb_hwnd, attached_text)
      check_attached_text(container.com, attached_text)
           
      #puts caption
    end
  
    def check_attached_text(obj_hwnd, attached_text)
      #puts attached_text
      buf = "\0" * 16
      GetClientRect.call(obj_hwnd, buf)
      @Rect = Rect.new(buf)        
    end
    
    def select_selection(combo_selection)
      
    end
    attr_accessor :name, :attached_text, :zorder, :caption
    
    def find_combo(container)
      
      cb_hwnd = FindWindowEx.call(container.com,0,container.name.to_s,container.caption.to_s)
      @cb_hwnd = cb_hwnd

      #Getting the ComboInfo on hold
      #buf = "\0" * 255
      #GetComboBoxInfo.call(c_hwnd, buf)
      #@combo = ComboInfo.new(buf)
      #puts cb_hwnd
        
    end
    attr_accessor :cb_hwnd
  
    def get_combo_count
      cb_count = SendMessageA.call(self.cb_hwnd, 326, 0, 0)
      return cb_count
    end
    
    def select_string(string)
      #Return Position by integer
      cb_selectstring = SendMessageA.call(self.cb_hwnd, CB_SELECTSTRING, -1, string)
      return cb_selectstring
    end
    
    def get_state
      #Return 1=True
      cb_getdroppedstate = SendMessageA.call(self.cb_hwnd, CB_GETDROPPEDSTATE, 0, 0)
      return cb_getdroppedstate
    end
    
    #ToDO. Failing
    def get_cb_text(position)
      buf = "\0" * 16
      cb_getlbtext = SendMessageA.call(self.cb_hwnd, CB_GETLBTEXT, position, buf)
      a = buf.unpack("l")
      return cb_getlbtext
    end
    
    def get_cb_text_len(position)
      buf = "".center(255)
      cb_getlbtextlen = SendMessageA.call(self.cb_hwnd, CB_GETLBTEXTLEN, position, buf)
      return cb_getlbtextlen
    end
    
  end
  
  class Combo_List < Combolist
    INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
  end 
  
end

#Static Text Class
module Wintir
  class Static
    
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    GetClientRect = Win32API.new('user32','GetClientRect','LP','I')
    GetWindowRect = Win32API.new('user32','GetWindowRect','LP','I')
    
    include Wintir::GuiTest
    
    def initialize(container, caption, name, attached_text, zorder)
      @com = container.com
      find_static_text(container)
    end
    
    def find_static_text(container)
      st_hwnd = FindWindowEx.call(container.com,0,container.name.to_s,container.caption.to_s)
      get_location_and_size(st_hwnd)
      #puts st_hwnd 
    end
    
    def get_location_and_size(obj_hwnd)
      #GetWindowRect details
      buf = "\0" * 16
      GetWindowRect.call(obj_hwnd, buf)
      @WindowRect = Rect.new(buf)
      
      #GetClientRect details
      buf = "\0" * 16
      GetClientRect.call(obj_hwnd, buf)
      @ClientRect = Rect.new(buf)
    end
    
  end
  
  class Static_Text < Static
    INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
  end
end

module Wintir
  class TabControl

    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    
    TCM_GETITEMCOUNT = 4868
    TCM_GETCURSEL = 4875
    TCM_SETCURSEL = 4876
    
    
    
    def initialize(container, caption, name, attached_text, zorder)
      @com = container.com
      
      find_tab_control(container)
      #get_current_tab(container)
      #puts caption
    end
    
    #find the tab control described
    def find_tab_control(container)
      
      tc_hwnd = FindWindowEx.call(container.com,0,container.name.to_s,container.caption.to_s)
      @tc_hwnd = tc_hwnd
      
    end
    
    attr_accessor :tc_hwnd
    
    def get_current_tab
      cur_tab = SendMessageA.call(self.tc_hwnd, TCM_GETCURSEL, 0, 0)
      #puts cur_tab
      return cur_tab
    end

    def set_tab(index)
      SendMessageA.call(self.tc_hwnd, TCM_SETCURSEL, index, 0)
    end
    
    def get_tab_count
      tb_count = SendMessageA.call(self.tc_hwnd, TCM_GETITEMCOUNT, 0, 0)
      return tb_count
    end
    
    class Tab_Control < TabControl
      INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
    end
    
  end
end

#List Box Class
module Wintir
  class Listbox
    
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    GetListBoxInfo = Win32API.new('user32','GetListBoxInfo','LP', 'L')
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    
    def initialize(container, caption, name, attached_text, zorder)
      @com = container.com
      
      find_list(container)
      #puts caption
    end
  
    def select_selection(combo_selection)
      
    end
    attr_accessor :name, :attached_text, :zorder, :caption
    
    def find_list(container)
      
      lb_hwnd = FindWindowEx.call(container.com,0,container.name.to_s,container.caption.to_s)
      @lb_hwnd = lb_hwnd
      
      no_lb_items = GetListBoxInfo.call(lb_hwnd, container.com)
      @no_lb_items = no_lb_items
      #puts no_lb_items
      
    end
  
    def find_string_item(string)
      lp_Result = SendMessageA.call(self.lb_hwnd, 399, -1, string)
      #puts lp_Result
    end
    
    def select_list_box_value(value)
      SendMessageA.call(self.lb_hwnd, 390, value, 0)
    end
    attr_accessor :lb_hwnd, :no_lb_items
    
  end
  
  class List_Box < Listbox
    INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
  end 
  
end

#Input Elements
module Wintir
  
  class InputElement  
     
    FindWindowEx = Win32API.new('user32', 'FindWindowEx', ['P'] * 4, 'L')
    SendMessageAB  = Win32API.new('user32', 'SendMessage', ["L", "L", "P", "P"], "L")
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
    PostMessageA = Win32API.new('user32','PostMessageA','LIIL','I')
    GetWindowRect = Win32API.new('user32','GetWindowRect','LP','I')
    
    WM_SETTEXT  = 0x000C
     
    
    #For setting object color - temp
    #include Wintir::SetObjectColour
    
    
    def intValue  
      @value  
    end  
    def initialize(container, caption, name, attached_text, zorder)
      #set_container container
      
      if is_caption(caption) == true
        #puts "name is good"
      end
       
      if is_name(name) == true
        #puts "name is good"
      end
      
      if is_attached_text(attached_text) == true
        #puts "attached_text is good"
      end
      
      if is_zorder(zorder) == true
        #puts "zorder is good"
      end
     
      #set the value of the text box - Note: Might have to use PostMessage      
      def set(value)
        
        #temp location for setting background object color
        col = Wintir::SetObjectColour.new(self.obj_id)
        col.color_on(self.obj_id)
        
        SendMessageA.call(self.obj_id, WM_SETTEXT, 0, value)
      end
      
      def close
        SendMessageA.call(self.obj_id, 16, 0, 0)
      end
      
      def click
        #puts "click #{@obj_id}"
        PostMessageA.call(@obj_id, 245, 0, 0)
      end
      
      com = ObjectAssert.new
      com.object_exists(container)
      @obj_id =com.obj_id 
  
      #super(nil)
    end
   
    attr_accessor :obj_id
    
    def is_caption(caption)
      if caption != nil and caption != ""
        ##puts "A real name #{name}"
        return true
      end
      
    end
     
    def is_name(name)
      if name != nil and name != ""
        return true
      end
      
    end
    def is_attached_text(attached_text)
      if attached_text != nil and attached_text != "" 
        ##puts "Real text #{attached_text}"
        
        buf = "\0" * 16
        GetWindowRect.call(com, buf)
        @Rect = Rect.new(buf)        
       
        return true
      end
    end
    def is_zorder(zorder)
      if zorder != nil 
        ##puts "Zorder is #{zorder}"
        return true
      end
       
    end
     
  end
  
  class TextField < InputElement
    INPUT_TYPES = ["caption", "name", "attached_text", "zorder"]
  end
  
  class Button < InputElement
    INPUT_TYPES = ["caption", "button", "attached_text", "zorder"]
  end
  
end

#Container Class
module Wintir
  module Container
    
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')    
       
    #text_field (describe) - Describe Edit objects using
    #
    #:name, the real name of the object
    # Usage :name => "txtFirstname"
    # 
    #:attached_text, the text above or to the left of the field
    # Usage :attached_text => "Firstname"
    # 
    #zorder, the position of the edit field on the form, starting from top left -> bottom right
    # Useage :zorder => 0
    def text_field(describe = nil)
      @name = describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      TextField.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder] )
    end
    
    attr_accessor :name, :attached_text, :zorder, :caption
    
    def button(describe = nil)
      @name=describe[:name]
      @attached_text = describe[:attached_text]
      @zorder = describe[:zorder]
      @caption = describe[:caption]
      
      Button.new(self, describe[:caption], describe[:name], describe[:attached_text], describe[:zorder])
    end
    
    attr_accessor :menu_path
    
    def close
       SendMessageA.call(self.com, 16, 0, 0)
    end    
    
    def file_menu(describe = nil)
      @menu_path=describe      
      Filemenu.new(self, describe[:menu_path])
    end
    
    attr_accessor :dialog_name
    
    def dialog(describe=nil)
      @dialog_name = describe
      Dialog.new(self, describe[:dialog_name])
    end
    
    def combo_list(describe = nil)
      @combo=describe      
      Combolist.new(self, describe[:combo])
    end
    
    def static(describe = nil)
      @static = describe
      Static_Text.new(self, describe[:caption])
    end
  end  
end

module Wintir

  class Com
      
    CreateProcess = Win32API.new('kernel32','CreateProcess','PPPPILPPPP','I')
    WaitForInputIdle = Win32API.new('user32','WaitForInputIdle','II','I')
    GetDesktopWindow = Win32API.new('user32','GetDesktopWindow','V','L')
    GetWindow = Win32API.new('user32','GetWindow','LI','L')
    GetWindowThreadProcessId = Win32API.new('user32','GetWindowThreadProcessId', 'LP', 'L')
    GetParent = Win32API.new('user32','GetParent','L','L')
    GetForegroundWindow = Win32API.new('user32','GetForegroundWindow', 'V', 'L')
      
    include Wintir::Container
    include Wintir::GuiTest

    def pid
      pid = [0].pack('L')
      hwnd = GetForegroundWindow.call
      GetWindowThreadProcessId.call(hwnd, pid)
      pid = pid.unpack('L')[0]
    end
    

       
    def create_application_window(what)
      create_process(nil, what)
    end
       
    def create_process(lpApplicationName, lpCommandLine, lpCurrentDirectory=nil,
      dwMilliseconds=60000)
      lpStartupInfo = [68].pack("L") + "\0" * 64
      lpProcessInformation  = [0,0,0,0].pack('LLLL')
      CreateProcess.call(lpApplicationName, lpCommandLine, nil, nil, 1, 0, nil,  lpCurrentDirectory, lpStartupInfo, lpProcessInformation)
      hProcess = lpProcessInformation[8,4].unpack('L').first
      
      com = 0
      process_id_count = 0
      #Not a great plan but WaitForInputIdle is failing
      while com == 0 or process_id_count != 10
        com = gethwndfromprocessid(hProcess)
        #counter - so that this isn't endless
        process_id_count = process_id_count + 1
      end
      #puts com
      com = GetForegroundWindow.call
      
      ret = waitForInputIdle(hProcess, dwMilliseconds)
      ##puts ret
      #if dwMilliseconds != 0 and (ret = waitForInputIdle(hProcess, dwMilliseconds)) != 0
      #  raise "createProcess(#{lpCommandLine},#{lpCurrentDirectory},#{dwMilliseconds}):" +
      #    " waitForInputIdle returns #{ret}"
      #end
      @com = com
       
    end
    
    GW_CHILD = 5
    GW_HWNDNEXT = 2
    
    def gethwndfromprocessid(hProcess)
    
      hWnd = GetDesktopWindow.call()
      window_found = false
      
      hWndProcess = [0].pack('L')

      while not window_found and hWnd != 0
        #Get the Child Window
        tmp = hWnd
        hWnd = GetWindow.call(hWnd, GW_CHILD)
        if hWnd != 0 then
          dl = GetWindowThreadProcessId.call(hWnd, hWndProcess)
          hWndProcess = hWndProcess.unpack('L')[0]

          if hWndProcess == hProcess then 
            window_found = true
            #puts "window_found"
          end
          hWndProcess = [0].pack('L')
        else
          hWnd = tmp
          hWnd = GetWindow.call(hWnd, GW_HWNDNEXT)
          if hWnd != 0 then 
            dl = GetWindowThreadProcessId.call(hWnd, hWndProcess)
            hWndProcess = hWndProcess.unpack('L')[0]
            if hWndProcess == hProcess then 
              window_found = true
              #puts "window_found"
            end
            hWndProcess = [0].pack('L')
          else
            hWnd = tmp
            hWnd = GetParent.call(hWnd)
            if hWnd != 0 then 
              branch_found = false
              while not branch_found and not window_found and hWnd != 0
                        
                tmp = hWnd
                hWnd = GetWindow.call(hWnd, GW_HWNDNEXT)
                if hWnd != 0 then 
                  branch_found = true
                  dl = GetWindowThreadProcessId.call(hWnd, hWndProcess)
                  hWndProcess = hWndProcess.unpack('L')[0]
                  if hWndProcess == hProcess then 
                    window_found = true
                    #puts "window_found"
                                
                  end
                  hWndProcess = [0].pack('L')
                else
                  hWnd = tmp
                  hWnd = GetParent.call(hWnd)
                            
                end
              end
            end
          end
        end
      end
      
      @com = hWnd
      return hWnd
      
    end
    
    INFINITE = 0xffffffff   # Infinite timeout
    def waitForInputIdle(hProcess, dwMilliseconds=INFINITE)
      WaitForInputIdle.call(hProcess, dwMilliseconds)
    end
       
    attr_accessor :obj_class, :name, :com

    def initialize_options
      #puts "init opt"
    end

    def _attach_init describe
      @obj_class = describe[:obj_class]
      @name = describe[:name]
     
      attach_com_window @obj_class, @name
      initialize_options
      wait
         
    end

    def self.create describe

      @lpApplicationName = describe[:name]
      @lpCommandLinet = describe[:command_line]

      com = new describe
      com._new_window_init @lpApplicationName
      com
    end

    def self.attach describe
      #Attach the how, what variants
      com = new true
      com._attach_init(describe)
      com
    end

    def initialize describe
      #puts describe
      # _new_window_init describe[:name]
    end

    attr_accessor :name, :command_line

    def _new_window_init what
      create_process(nil, what)
    end

    def self._find(how, what)
      ieTemp = ""
      return ieTemp
    end 

    def wait(no_sleep=false)
      #puts "wait"
    end

    def log(what)
      #puts "log"
      @logger.debug(what) if @logger
    end 

    def attach_com_window how, what 
      log "Seeking Window with #{how}: #{what}"
      #puts "attach com window"
      comTemp = nil
      #begin
      #  Wintir::until_with_timeout do
            
      comTemp = assign_com(how, what)
      #  end
      #rescue TimeOutException
      #  raise NoMatchingWindowFoundException,
      #           "Unable to locate a window with #{how} of #{what}"
      #end
      @com = comTemp
      #return @com
    end
    private :attach_com_window 

  end
   
end


#ComboInfo Class - Needs further investigation
module Wintir
  
  class ComboInfo
  
      def initialize(buf)
        @cbSize,@rcItem,@stateButton,@hwndCombo,@hwndItem,@hwndList = buf.unpack("IPPIII")
        #puts @cbSize
      end
      attr_accessor :cbSize,:rcItem,:rcItem,:stateButton,:hwndCombo,:hwndItem,:hwndList

  end
  
end

module Wintir
  class SetObjectColour
    
    SendMessageA = Win32API.new('user32','SendMessageA','LIIP','I')
#   SetBkColor = Win32API.new('user32', 'SetBkColor', 'LI','L')
    GetWindowDC = Win32API.new('user32','GetWindowDC','L','L')
    SetForegroundWindow = Win32API.new('user32','SetForegroundWindow','L','I')
    GetDC = Win32API.new('user32','GetDC','L','L')
    
    
    EM_SETBKGNDCOLOR = 0x0443
    SET_COLOR_YELLOW = 0xDFFFA5
    
    def initialize(com)
      #ToDo check the object type for correct color change
      
      #puts com
    end
  
    #Turn the background of the object color on
    def color_on(com)
      #yellow
      
      color_on = true
      color_on = SendMessageA.call(com, EM_SETBKGNDCOLOR, 0, SET_COLOR_YELLOW)
      return color_on     
    end
  
    #Protect from user setting background objects color status
    #private :color_on
    
    #Turn the background of the color off
    def color_off
    end
    
    #Get the current color of the objects background
    def get_object_bk_color(com)
      
      #Setting the window to focus call to pixel/color
      SetForegroundWindow.call(com)
      
      #Get the DC
      hdc_source = GetDC.call(com)
      #puts hdc_source
    
    end
    
    #Protect from user setting background objects color status
    #private :color_off
    
  end
end