module Legacy

  def run
    setup
    set_script_variables
    run_test
  rescue
    fatal_to_log("(#{__LINE__})  #{$!}")
    browser.close
    raise
  end

  #TODO replace with method_missing?
  #    place holder to prevent method not found error in scripts
  def set_script_variables
  end

  def setup
    #    if @os_sysname =~ /Windows.+Server\s+2003/
    ##  'Microsoft(R) Windows(R) Server 2003, Enterprise Edition'
    #      @vertical_hack_ie   = 110
    #      @vertical_hack_ff   = 138
    #      @horizontal_hack_ie = 5
    #      @horizontal_hack_ff = 4
    #    elsif @os_sysname =~ /Windows XP Professional/
    #  'Microsoft Windows XP Professional'
    @vertical_hack_ie        = 118
    @vertical_hack_ff        = 144
    @horizontal_hack_ie      = 5
    @horizontal_hack_ff      = 4
    #end

    @settings_display_ids    = Hash[
        "Currency"       => "row-currencyName",
        "Description"    => "row-description",
        "Tx Date"        => "row-fmtDate",
        "Total"          => "row-amount",
        "[currencyCode]" => "row-currencyCode",
        "Date in Millis" => "row-dateInMilliseconds",
    ]
    @column_data_display_ids = Hash[
        "Currency"       => "yui-dt0-th-currencyName",
        "Description"    => "yui-dt0-th-description",
        "Tx Date"        => "yui-dt0-th-fmtDate",
        "Total"          => "yui-dt0-th-fmtDate",
        "[currencyCode]" => "yui-dt0-th-currencyCode",
        "Date in Millis" => "yui-dt0-th-dateInMilliseconds",
    ]
    @settings_panel_index    = 0
    @x_tolerance             = 4
    @y_tolerance             = 4
  end

  def sleep_for(seconds, dbg = true, desc = '')
    msg = "Sleeping for #{seconds} seconds."
    msg << " #{desc}" if desc.length > 0
    msg << "\n#{get_debug_list}" if dbg
    info_to_log(msg)
    sleep(seconds)
  end

  def get_mdyy(t = Time.now)
    "#{t.month}/#{t.day}/#{t.year}"
  end

  def get_prefix(strg, offset)
    a_slice = strg.slice(0, offset)
    a_slice.downcase
  end

  def get_timestamp(format = 'long', offset = nil, offset_unit = :years)
    t = DateTime.now
    if offset
      t = t.advance(offset_unit => offset)
    end
    case format
      when 'dateonly'
        t.strftime("%m/%d/%Y")
      when 'condensed'
        t.strftime("%Y%m%d%H%M")
      when 'condensed_seconds'
        t.strftime("%Y%m%d%H%M%S")
      when 'long'
        t.strftime("%m/%d/%Y %I:%M %p")
      when 'mdyy'
        get_mdyy(t)
      when 'm/d/y'
        get_mdyy(t)
      else
        Time.now.strftime("%m/%d/%Y %H:%M:%S")
    end
  end

  def token_auth(browser, role, token, id = 'token_pass')
    set_textfield_by_id(browser, id, token)
    click_button_by_value(browser, 'Continue')
    if validate_text(browser, 'The requested page requires authentication\.\s*Please enter your Passcode below', nil, true)
      bail_out(browser, __LINE__, "Token authorization failed on '#{token}'")
    end
  end

  def calc_index(index, every = 1)
    (index / every) + (every - 1)
  end

=begin rdoc
tags: data, DOM, page
browser is any container element.  Best to use is the smallest that contains the desired data.
types defaults to all of: :text, :textarea, :select_list, :span, :hidden, :checkbox, and :radio
Set types to array of subset if fewer elements are desired.
returns a single hash:
---
:name:
  :span: {}
  :textarea: {}
  :radio: {}
  :checkbox: {}
  :hidden: {}
  :select_list: {}
  :text: {}
:index:
  :span: {}
  :textarea: {}
  :radio: {}
  :checkbox: {}
  :hidden: {}
  :select_list: {}
  :text: {}
:id:
  :span: {}
  :textarea: {}
  :radio: {}
  :checkbox: {}
  :hidden: {}
  :select_list: {}
  :text: {}

No positive validations are reported but failure is rescued and reported.
=end
  def capture_page_data(browser, types = [:text, :textarea, :select_list, :span, :hidden, :checkbox, :radio])
    start = Time.now
    debug_to_log("Begin #{__method__}")
    data         = Hash.new
    data[:id]    = Hash.new
    data[:name]  = Hash.new
    data[:index] = Hash.new
    types.each do |type|
      #debug_to_log("#{__method__}: #{type}. . .")
      data[:id][type], data[:name][type], data[:index][type] = parse_elements(browser, type)
    end
    data
  rescue
    failed_to_log("#{__method__}: '#{$!}'")
  ensure
    stop = Time.now
    passed_to_log("#{__method__.to_s.titleize} finished. (#{"%.5f" % (stop - start)} secs)")
    #debug_to_log("End #{__method__}")
  end

  def compare_page_data(before, after, how, desc = '')
    [:text, :textarea, :select_list, :span, :checkbox, :radio].each do |type|
      before[how][type].each_key do |what|
        msg = "#{desc} #{type} #{how}=#{what}: Expected '#{before[how][type][what]}'."
        if after[how][type][what] == before[how][type][what]
          passed_to_log(msg)
        else
          failed_to_log("#{msg} Found '#{after[how][type][what]}'")
        end
      end
    end
  rescue
    failed_to_log("Unable to compare before and after page data. '#{$!}'")
  end

=begin rdoc
tags: data, DOM
data is output of capture_page_data().
how is one of :id, :name, :index
what is the target value for how
type is one of :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
get_text is used for select_list to choose selected option value or text (default)
note that multiple selections will be captured as arrays so value and text.
Not tested with multiple selections (02aug2011)
=end
  def fetch_page_data(data, how, what, type, get_text = true)
    rslt = data[how][type][what]
    if type == :select_list
      value, text = rslt.split('::')
      if get_text
        rslt = text
      else
        rslt = value
      end
    end
    rslt
  end

  def capture_screen(browser, ts)
    browser.maximize
    browser.bring_to_front
    caller = get_caller
    caller.match(/:(\d+):/)
    lnbr       = $1
    path       = "#{@myRoot}/screenshot/"
    screenfile = "#{@myName}_#{@myRun.id}_#{lnbr.to_s}_#{ts.to_f.to_s}.scrsht.jpg"
    info_to_log("path:#{path} screenfile:#{screenfile}")
    screenSpec = '"' + path + screenfile + '"'
    screenSpec.gsub!('/', '\\')
    screen_capture(screenSpec)
    screenfile
  end

  def bail_out(browser, lnbr, msg)
    ts  = Time.new
    msg = "Bailing out at util line #{lnbr} #{ts} " + msg
    puts "#{msg}"
    fatal_to_log(msg, nil, 1, lnbr)
    debug_to_log(dump_caller(lnbr))
    if is_browser?(browser)
      if @browserAbbrev == 'IE'
        hwnd = browser.hwnd
        kill_browser(hwnd, lnbr, browser)
        raise(RuntimeError, msg, caller)
      elsif @browserAbbrev == 'FF'
        debug_to_log("#{browser.inspect}")
        debug_to_log("#{browser.to_s}")
        raise(RuntimeError, msg, caller)
      end
    end
    @status = 'bailout'
    raise(RuntimeError, msg, caller)
  end

  def parse_cookies(browser)
    cookies = Hash.new
    strg    = browser.document.cookie
    ary     = strg.split(';')
    ary.each do |c|
      key, value          = c.split('=')
      cookies[key.lstrip] = value
    end
    cookies
  end

=begin rdoc
tags: data, DOM
browser is any container element.  best to use is the smallest that contains the desired data.
type is one of these symbols: :text,:textarea,:select_list,:span,:hidden,:checkbox,:radio
returns three hashes: id[type][id] = value, name[type][id] = value, index[type][id] = value
a given element appears once in the set of hashes depending on how is is found:  id first
then name, then index.
select list value is in the form 'value::text'. parse with x.split('::')
No positive validations are reported but failure is rescued and reported.
=end
  def parse_elements(browser, type)
    id    = Hash.new
    name  = Hash.new
    index = Hash.new
    idx   = 0
    #debug_to_log("#{__method__}: #{type}")
    case type
      when :span
        collection = browser.spans
      when :select_list
        collection = browser.select_lists
      when :radio
        collection = browser.radios
      when :checkbox
        collection = browser.checkboxes
      else
        collection = browser.elements(:type, type.to_s)
    end
    #debug_to_log("#{__method__}: collection: #{collection.inspect}")
    collection.each do |e|
      case type
        when :span
          vlu = e.text
        when :select_list
          vlu = "#{e.value}::#{e.selected_options[0]}"
        when :radio
          vlu = e.set?
        when :checkbox
          vlu = e.set?
        else
          vlu = e.value
      end
      idx += 1
      if e.id.length > 0 and not e.id =~ /^__[A-Z]/
        id[e.id] = vlu
      elsif e.name.length > 0 and not e.name =~ /^__[A-Z]/
        name[e.name] = vlu
      else
        index[idx] = vlu if not type == :hidden
      end
    end
    [id, name, index]

  rescue
    failed_to_log("#{__method__}: '#{$!}'")
  end

  def verify_no_element_overlap(browser, above_element, above_how, above_what, below_element, below_how, below_what, side, desc = '')
    mark_testlevel("#{__method__.to_s.titleize}", 3)
    msg = "#{above_element.to_s.titleize} #{above_how}=>#{above_what} does not overlap "+
        "#{below_element.to_s.titleize} #{below_how}=>#{below_what} at the #{side}."
    msg << " #{desc}" if desc.length > 0
    above = browser.element(above_how, above_what)
    below = browser.element(below_how, below_what)
    if overlay?(above, below, side)
      failed_to_log(msg)
    else
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to verify that #{msg} '#{$!}'")
  end

  def verify_element_inside(inner_element, outer_element, desc = '')
    mark_testlevel("#{__method__.to_s.titleize}", 3)
    msg = "#{inner_element.class.to_s} (:id=#{inner_element.id}) is fully enclosed by #{outer_element.class.to_s} (:id=#{outer_element.id})."
    msg << " #{desc}" if desc.length > 0
    if overlay?(inner_element, outer_element, :inside)
      failed_to_log(msg)
    else
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to verify that #{msg} '#{$!}'")
  end

  def overlay?(inner, outer, side = :bottom)
    #mark_testlevel("#{__method__.to_s.titleize}", 3)
    inner_t, inner_b, inner_l, inner_r = inner.bounding_rectangle_offsets
    outer_t, outer_b, outer_l, outer_r = outer.bounding_rectangle_offsets
    #overlay = false
    case side
      when :bottom
        overlay = inner_b > outer_t
      when :top
        overlay = inner_t > outer_t
      when :left
        overlay = inner_l < outer_r
      when :right
        overlay = inner_r > outer_r
      when :inside
        overlay = !(inner_t > outer_t and
            inner_r < outer_r and
            inner_l > outer_l and
            inner_b < outer_b)
      else
        overlay = (inner_t > outer_b or
            inner_r > outer_l or
            inner_l < outer_r or
            inner_b < outer_t)
    end
    overlay
  rescue
    failed_to_log("Unable to determine overlay. '#{$!}'")
  end

  def pdf_to_text(file, noblank = true)
    spec = file.sub(/\.pdf$/, '')
    `pdftotext #{spec}.pdf`
    file = File.new("#{spec}.txt")
    text = []
    file.readlines.each do |l|
      l.chomp! if noblank
      if l.length > 0
        text << l
      end
    end
    file.close
    text
  end

  def kill_browser(hwnd, lnbr, browser = nil, doflag = false)
    # TODO Firefox
    logit = false
    if @browserAbbrev == 'FF'
      if is_browser?(browser) # and browser.url.length > 1
        logit = true
        here  = __LINE__
        url   = browser.url
        capture_screen(browser, Time.new.to_f) if @screenCaptureOn
        browser.close if url.length > 0
        @status = 'killbrowser'
        fatal_to_log("Kill browser called from line #{lnbr}")
      end
    elsif hwnd
      pid = Watir::IE::Process.process_id_from_hwnd(hwnd)
      if pid and pid > 0 and pid < 538976288
        if browser.exists?
          here  = __LINE__
          logit = true
          url   = browser.url
          capture_screen(browser, Time.new.to_f) if @screenCaptureOn
          browser.close
          sleep(2)
          if browser.exists?
            do_taskkill(FATAL, pid)
          end
          @status = 'killbrowser'
        end
      end
      if logit
        debug_to_log("#{@browserName} window hwnd #{hwnd} pid #{pid} #{url} (#{here})")
        fatal_to_log("Kill browser called from line #{lnbr}")
      end
    end
  end

  def do_taskkill(severity, pid)
    if pid and pid > 0 and pid < 538976288
      info_to_log("Executing taskkill for pid #{pid}")
      log_message(severity, %x[taskkill /t /f /pid #{pid}])
    end
  rescue
    error_to_log("#{$!}  (#{__LINE__})")
  end

  def check_for_other_browsers
    cnt1 = find_other_browsers
    cnt2 = Watir::Process.count 'iexplore.exe'
    debug_to_log("check_for_other_browsers: cnt1: #{cnt1} cnt2: #{cnt2}")
  rescue
    error_to_log("#{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}")
  end

  def check_for_and_clear_other_browsers
    if @targetBrowser.abbrev == 'IE'
      debug_to_log("#{__method__}:")
      cnt1 = find_other_browsers
      cnt2 = Watir::IE.process_count
      debug_to_log("#{__method__}: cnt1: #{cnt1} cnt2: #{cnt2}")
      begin
        Watir::IE.each do |ie|
          pid = Watir::IE::Process.process_id_from_hwnd(ie.hwnd)
          debug_to_log("#{__method__}: Killing browser process: hwnd #{ie.hwnd} pid #{pid} title '#{ie.title}' (#{__LINE__})")
          do_taskkill(INFO, pid)
          sleep_for(10)
        end
        #Watir::IE.close_all()
      rescue
        debug_to_log("#{__method__}: #{$!}  (#{__LINE__})")
      end
      sleep(3)
      cnt1 = find_other_browsers
      cnt2 = Watir::IE.process_count
      if cnt1 > 0 or cnt2 > 0
        debug_to_log("#{__method__}:cnt1: #{cnt1} cnt2: #{cnt2}")
        begin
          Watir::IE.each do |ie|
            pid = Watir::IE::Process.process_id_from_hwnd(ie.hwnd)
            debug_to_log("#{__method__}: Killing browser process: hwnd #{ie.hwnd} pid #{pid} title '#{ie.title}' (#{__LINE__})")
            do_taskkill(INFO, pid)
            sleep_for(10)
          end
          #Watir::IE.close_all()
        rescue
          debug_to_log("#{__method__}:#{$!}  (#{__LINE__})")
        end
      end
    end
  rescue
    error_to_log("#{__method__}: #{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}")
  end

  #def attach_browser(browser, how, what)
  #  debug_to_log("Attaching browser window :#{how}=>'#{what}' ")
  #  uri_decoded_pattern = URI.encode(what.to_s.gsub('(?-mix:', '').gsub(')', ''))
  #  case @browserAbbrev
  #  when 'IE'
  #    tmpbrowser         = Watir::IE.attach(how, what)
  #    browser.visible    = true
  #    tmpbrowser.visible = true
  #    tmpbrowser.speed   = :fast
  #    tmpbrowser
  #  when 'FF'
  #    tmpbrowser = FireWatir::Firefox.attach(how, /#{uri_decoded_pattern}/)
  #  when 'S'
  #    Watir::Safari.attach(how, what)
  #    tmpbrowser = browser
  #  when 'C'
  #    browser.window(how, /#{uri_decoded_pattern}/).use
  #    tmpbrowser = browser
  #  end
  #  debug_to_log("#{__method__}: tmpbrowser:#{tmpbrowser.inspect}")
  #  tmpbrowser
  #end
  #
  def attach_browser(browser, how, what, desc = '')
    debug_to_log("Attaching browser window :#{how}=>'#{what}' #{desc}")
    uri_decoded_pattern = URI.encode(what.to_s.gsub('(?-mix:', '').gsub(')', ''))
    case @browserAbbrev
      when 'IE'
        tmpbrowser      = Watir::IE.attach(how, what)
        browser.visible = true
        if tmpbrowser
          tmpbrowser.visible = true
          tmpbrowser.speed   = :fast
        else
          raise "Browser window :#{how}=>'#{what}' has at least one doc not in completed ready state."
        end
      when 'FF'
        #TODO: This may be dependent on Firefox version if webdriver doesn't support 3.6.17 and below
        browser.driver.switch_to.window(browser.driver.window_handles[0])
        browser.window(how, /#{uri_decoded_pattern}/).use
        tmpbrowser = browser
      when 'S'
        Watir::Safari.attach(how, what)
        tmpbrowser = browser
      when 'C'
        browser.window(how, /#{uri_decoded_pattern}/).use
        tmpbrowser = browser
    end
    debug_to_log("#{__method__}: tmpbrowser:#{tmpbrowser.inspect}")
    tmpbrowser
  end

  def attach_browser_by_url(browser, pattern, desc = '')
    attach_browser(browser, :url, pattern, desc)
  end

  alias attach_browser_with_url attach_browser_by_url

  def attach_popup(browser, how, what, desc = '')
    msg   = "Attach popup :#{how}=>'#{what}'. #{desc}"
    popup = attach_browser(browser, how, what, desc)
    sleep_for(1)
    debug_to_log("#{popup.inspect}")
    if is_browser?(popup)
      title = popup.title
      passed_to_log("#{msg} title='#{title}'")
      return popup
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable to attach popup :#{how}=>'#{what}'. #{desc} '#{$!}' (#{__LINE__})")
  end

  def attach_popup_by_title(browser, strg, desc = '')
    attach_popup(browser, :title, strg, desc)
  end

  def attach_popup_by_url(browser, pattern, desc = '')
    attach_popup(browser, :url, pattern, desc)
  end

  alias get_popup_with_url attach_popup_by_url
  alias attach_popup_with_url attach_popup_by_url
  alias attach_iepopup attach_popup_by_url

  def clear_checkbox(browser, how, what, value = nil, desc = '')
    msg = "Clear checkbox #{how}=>'#{what}'"
    msg << " ('#{value}')" if value
    msg << " #{desc}'" if desc.length > 0
    browser.checkbox(how, what).clear
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def clear_checkbox_by_name(browser, strg, value = nil, desc = '')
    clear_checkbox(browser, :name, strg, value, desc)
  end

  def clear_checkbox_by_id(browser, strg, value = nil, desc = '')
    clear_checkbox(browser, :id, strg, value, desc)
  end

  def find_other_browsers
    cnt = 0
    if @targetBrowser.abbrev == 'IE'
      Watir::IE.each do |ie|
        debug_to_log("#{ie.inspect}")
        ie.close()
        cnt = cnt + 1
      end
    end
    debug_to_log("Found #{cnt} IE browser(s).")
    return cnt
  rescue
    error_to_log("#{$!}  (#{__LINE__})\n#{Kernel.caller.to_yaml}", __LINE__)
    return 0
  end

  def get_trace(lnbr)
    callertrace = "\nCaller trace: (#{lnbr})\n"
    Kernel.caller.each_index do |x|
      callertrace << '    >> ' + Kernel.caller[x].to_s + "\n"
    end
    callertrace
  end

  alias dump_caller get_trace

  def translate_var_list(key)
    if @var[key] and @var[key].length > 0
      list = @var[key].dup
      unless list =~ /^\[.+\]$/
        list = "[#{list}]"
      end
      eval(list)
    end
  rescue
    failed_to_log("#{__method__}: '#{$!}'")
  end

  def get_variables(file, login = :role, dbg = true)
    debug_to_log("#{__method__}: file = #{file}")
    debug_to_log("#{__method__}: role = #{login}")

    @var                   = Hash.new
    workbook               = Excel.new(file)
    data_index             = find_sheet_with_name(workbook, 'Data')
    workbook.default_sheet = workbook.sheets[data_index]
    var_col                = 0

    2.upto(workbook.last_column) do |col|
      scriptName = workbook.cell(1, col)
      if scriptName == @myName
        var_col = col
        break
      end
    end

    2.upto(workbook.last_row) do |line|
      name       = workbook.cell(line, 'A')
      value      = workbook.cell(line, var_col).to_s.strip
      @var[name] = value
    end

    @var.keys.sort.each do |name|
      message_tolog("@var #{name}: '#{@var[name]}'")
    end if dbg

    @login       = Hash.new
    login_col    = 0
    role_col     = 0
    userid_col   = 0
    password_col = 0
    url_col      = 0
    name_col     = 0
    role_index   = find_sheet_with_name(workbook, 'Login')
    if role_index >= 0
      workbook.default_sheet = workbook.sheets[role_index]

      1.upto(workbook.last_column) do |col|
        a_cell = workbook.cell(1, col)
        case a_cell
          when @myName
            login_col = col
            break
          when 'role'
            role_col = col
          when 'userid'
            userid_col = col
          when 'password'
            password_col = col
          when 'url'
            url_col = col
          when 'name'
            name_col = col
        end
      end

      2.upto(workbook.last_row) do |line|
        role     = workbook.cell(line, role_col)
        userid   = workbook.cell(line, userid_col)
        password = workbook.cell(line, password_col)
        url      = workbook.cell(line, url_col)
        username = workbook.cell(line, name_col)
        enabled  = workbook.cell(line, login_col).to_s

        case login
          when :id
            key = userid
          when :role
            key = role
          else
            key = role
        end

        @login[key]             = Hash.new
        @login[key]['role']     = role
        @login[key]['userid']   = userid
        @login[key]['password'] = password
        @login[key]['url']      = url
        @login[key]['name']     = username
        @login[key]['enabled']  = enabled

      end

      @login.keys.sort.each do |key|
        message_tolog("@login (by #{login}): #{key}=>'#{@login[key].to_yaml}'")
      end if dbg
    end

  rescue
    fatal_to_log("#{__method__}: '#{$!}'")
  end

  def grab_window_list(strg)
    @ai.AutoItSetOption("WinTitleMatchMode", 2)
    list    = @ai.WinList(strg)
    stuff   = ''
    names   = list[0]
    handles = list[1]
    max     = names.length - 1
    rng     = Range.new(0, max)
    rng.each do |idx|
      window_handle = "[HANDLE:#{handles[idx]}]"
      full_text     = @ai.WinGetText(window_handle)
      stuff << "[#{handles[idx]}]=>#{names[idx]}=>'#{full_text}'\n"
    end
    debug_to_log("\n#{stuff}")
    @ai.AutoItSetOption("WinTitleMatchMode", 1)
    stuff
  end

  def debug_call_list(msg)
    call_array = get_call_array
    debug_to_log("#{msg}\n#{dump_array(call_array)}")
  end

  # TODO ugly, gotta lose the hardcoding...
  def decode_options(strg)
    idx      = 0
    @options = Hash.new
    strg.each_char do |c|
      idx = idx + 1
      case idx
        when 1
          @options['load'] = c.to_i
        when 2
          @options['screenshot'] = c.to_i
          if c.to_i > 0
            @screenCaptureOn = true
          end
        when 3
          @options['hiderun'] = c.to_i
        #      when 4
        #        @options['another'] = c.to_i
      end

    end
    #    puts @options.to_yaml
  end

  def click_popup_button(title, button, waitTime= 9, user_input=nil)
    #TODO: is winclicker still viable/available?
    wc = WinClicker.new
    if wc.clickWindowsButton(title, button, waitTime)
      passed_to_log("Window '#{title}' button '#{button}' found and clicked.")
      true
    else
      failed_to_log("Window '#{title}' button '#{button}' not found. (#{__LINE__})")
    end
    wc = nil
    # get a handle if one exists
    #    hwnd = $ie.enabled_popup(waitTime)
    #    if (hwnd)  # yes there is a popup
    #      w = WinClicker.new
    #      if ( user_input )
    #        w.setTextValueForFileNameField( hwnd, "#{user_input}" )
    #      end
    #      # I put this in to see the text being input it is not necessary to work
    #      sleep 3
    #      # "OK" or whatever the name on the button is
    #      w.clickWindowsButton_hwnd( hwnd, "#{button}" )
    #      #
    #      # this is just cleanup
    #      w=nil
    #    end
  end

  def get_select_list(browser, how, what, desc = '')
    list = browser.select_list(how, what)
    if validate(browser, @myName, __LINE__)
      passed_to_log("Select list #{how}='#{what}' found and returned.")
      return list
    end
  rescue
    failed_to_log("Unable to return select list #{how}='#{what}': '#{$!}' (#{__LINE__})")
  end

  def get_select_options(browser, how, what, dump = false)
    list = browser.select_list(how, what)
    dump_select_list_options(list) if dump
    list.options
  rescue
    failed_to_log("Unable to get select options for #{how}=>#{what}.  '#{$!}'")
  end

  def get_select_options_by_id(browser, strg, dump = false)
    get_select_options(browser, :id, strg, dump)
  end

  def get_select_options_by_name(browser, strg, dump = false)
    get_select_options(browser, :name, strg, dump)
  end

  def get_selected_options(browser, how, what)
    begin
      list = browser.select_list(how, what)
    rescue => e
      if not rescue_me(e, __method__, "browser.select_list(#{how}, '#{what}')", "#{browser.class}")
        raise e
      end
    end
    list.selected_options
  end

  def get_selected_options_by_id(browser, strg)
    get_selected_options(browser, :id, strg)
  end

  alias get_selected_option_by_id get_selected_options_by_id

  def get_selected_options_by_name(browser, strg)
    get_selected_options(browser, :name, strg)
  end

  alias get_selected_option_by_name get_selected_options_by_name

  def sec2hms(s)
    Time.at(s.to_i).gmtime.strftime('%H:%M:%S')
  end

  def select(browser, how, what, which, value, desc = '')
    msg  = "Select option #{which}='#{value}' from list #{how}=#{what}. #{desc}"
    list = browser.select_list(how, what)
    case which
      when :text
        list.select(value)
      when :value
        list.select_value(value)
      when :index
        all = list.getAllContents
        txt = all[value]
        list.select(txt)
      else
        na = "#{__method__} cannot support select by '#{which}'. (#{msg})"
        debug_to_log(na, __LINE__, true)
        raise na
    end
    passed_to_log(msg)
  rescue
    failed_to_log("#Unable to #{msg}': '#{$!}'")
  end

  def select_option_from_list(list, what, what_strg, desc = '')
    ok  = true
    msg = "#{__method__.to_s.titleize} "
    if list
      msg << "list id=#{list.id}: "
      case what
        when :text
          list.select(what_strg) #TODO: regex?
        when :value
          list.select_value(what_strg) #TODO: regex?
        when :index
          list.select(list.getAllContents[what_strg.to_i])
        else
          msg << "select by #{what} not supported. #{desc} (#{__LINE__})"
          failed_to_log(msg)
          ok = false
      end
      if ok
        msg << "#{what}='#{what_strg}' selected. #{desc}"
        passed_to_log(msg)
        true
      end
    else
      failed_to_log("#{__method__.to_s.titleize} list not found. #{desc} (#{__LINE__})")
    end
  rescue
    failed_to_log("#{__method__.to_s.titleize}: #{what}='#{what_strg}' could not be selected: '#{$!}'. #{desc} (#{__LINE__})")
  end

  def select_option_by_id_and_option_text(browser, strg, option, nofail=false, desc = '')
    msg = "Select list id=#{strg} option text='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    list = browser.select_list(:id, strg)
    list.select(option)
    #      browser.select_list(:id, strg).select(option)   #(browser.select_list(:id, strg).getAllContents[option])
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    if !nofail
      failed_to_log("#{msg} '#{$!}'")
    end
  end

  alias select_option_by_id select_option_by_id_and_option_text
  alias select_option_by_id_and_text select_option_by_id_and_option_text

  def select_option_by_name_and_option_text(browser, strg, option, desc = '')
    msg = "Select list name=#{strg} option text='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    begin
      list = browser.select_list(:name, strg)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:name,'#{strg}')", "#{browser.class}")
        raise e
      end
    end
    begin
      list.select(option)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select('#{option}')", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  alias select_option_by_name select_option_by_name_and_option_text

  def select_option_by_title_and_option_text(browser, strg, option, desc = '')
    msg = "Select list name=#{strg} option text='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    browser.select_list(:title, strg).select(option)
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def select_option_by_class_and_option_text(browser, strg, option, desc = '')
    msg = "Select list class=#{strg} option text='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    browser.select_list(:class, strg).select(option)
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def select_option_by_name_and_option_value(browser, strg, option, desc = '')
    msg = "Select list name=#{strg} option value='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    begin
      list = browser.select_list(:name, strg)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:name,'#{strg}')", "#{browser.class}")
        raise e
      end
    end
    begin
      list.select_value(option)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select_value('#{option}')", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def select_option_by_id_and_option_value(browser, strg, option, desc = '')
    msg = "Select list name=#{strg} option value='#{option}' selected."
    msg << " #{desc}" if desc.length > 0
    begin
      list = browser.select_list(:id, strg)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list(:text,'#{strg}')", "#{browser.class}")
        raise e
      end
    end
    sleep(0.5) unless @targetBrowser.abbrev == 'IE'
    begin
      list.select_value(option)
    rescue => e
      if not rescue_me(e, __method__, "#{__LINE__}: select_list#select_value('#{option}')", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def select_option_by_id_and_index(browser, strg, idx, desc = '')
    msg = "Select list id=#{strg} index='#{idx}' selected."
    msg << " #{desc}" if desc.length > 0
    list = browser.select_list(:id, strg)
    all  = list.getAllContents
    txt  = all[idx]
    browser.select_list(:id, strg).set(browser.select_list(:id, strg).getAllContents[idx])
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  # TODO add check that both list and option exist
  def select_option_by_name_and_index(browser, strg, idx)
    msg = "Select list name=#{strg} index='#{idx}' selected."
    msg << " #{desc}" if desc.length > 0
    browser.select_list(:name, strg).set(browser.select_list(:name, strg).getAllContents[idx])
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def select_option_by_xpath_and_index(browser, strg, idx)
    msg = "Select list xpath=#{strg} index='#{idx}' selected."
    msg << " #{desc}" if desc.length > 0
    browser.select_list(:xpath, strg).set(browser.select_list(:xpath, strg).getAllContents[idx])
    if validate(browser, nil, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def set(browser, element, how, what, value = nil, desc = '')
    msg = "Set #{element} #{how}=>'#{what}' "
    msg << "('#{value.to_s}')" if value
    msg << " '#{desc}' " if desc.length > 0
    case element
      when :radio
        browser.radio(how, what, value).set
      when :checkbox
        browser.checkbox(how, what, value).set
      else
        failed_to_log("#{__method__}: #{element} not supported")
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def set_checkbox(browser, how, what, desc = '')
    set(browser, :checkbox, how, what, nil, desc)
  end

  def set_checkbox_by_class(browser, strg, value = nil, desc = '')
    set(browser, :checkbox, :class, strg, value, desc)
  end

  def set_checkbox_by_id(browser, strg, value = nil, desc = '')
    set(browser, :checkbox, :id, strg, value, desc)
  end

  def set_checkbox_by_name(browser, strg, value = nil, desc = '')
    set(browser, :checkbox, :name, strg, value, desc)
  end

  def set_checkbox_by_title(browser, strg, value = nil, desc = '')
    set(browser, :checkbox, :title, strg, value, desc)
  end

  def set_checkbox_by_value(browser, strg, desc = '')
    set(browser, :checkbox, :value, strg, nil, desc)
  end

  def set_radio(browser, how, what, value = nil, desc = '')
    if how == :value
      set_radio_by_value(browser, what, desc)
    else
      set(browser, :radio, how, what, value, desc)
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def set_radio_two_attributes(browser, how1, what1, how2, what2, desc = '')
    msg = "Set radio #{how1}='#{what1}', #{how2}= #{what2}"
    msg << " '#{desc}' " if desc.length > 0
    browser.radio(how1 => what1, how2 => what2).set
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def set_radio_by_class(browser, strg, value = nil, desc = '')
    set(browser, :radio, :class, strg, value, desc)
  end

  def set_radio_by_id(browser, strg, value = nil, desc = '')
    set(browser, :radio, :id, strg, value, desc)
  end

  def set_radio_by_index(browser, index, desc = '')
    set(browser, :radio, :index, index, nil, desc)
  end

  def set_radio_by_name(browser, strg, value = nil, desc = '')
    set(browser, :radio, :name, strg, value, desc)
  end

  def set_radio_by_title(browser, strg, value = nil, desc = '')
    set(browser, :radio, :title, strg, value, desc)
  end

  def set_radio_no_wait_by_index(browser, index, desc = '')
    #TODO: Not supported by Watir 1.8.x
    msg    = "Radio :index=#{index} "
    radios = browser.radios
    debug_to_log("\n#{radios}")
    radio = radios[index]
    debug_to_log("\n#{radio}")
    radio.click_no_wait
    if validate(browser)
      msg << 'set ' + desc
      passed_to_log(msg)
      true
    end
  rescue
    msg << 'not found ' + desc
    failed_to_log("#{msg} (#{__LINE__})")
  end

  def set_radio_by_value(browser, strg, desc = '')
    msg = "Radio :value=>'#{strg}' "
    msg << " '#{desc}' " if desc.length > 0
    browser.radio(:value, strg).set
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def set_radio_by_name_and_index(browser, name, index, desc = '')
    set_radio_two_attributes(browser, :name, name, :index, index, desc)
  end

  def set_radio_by_name_and_text(browser, name, text, desc = '')
    set_radio_two_attributes(browser, :name, name, :text, text, desc)
  end

  def set_radio_by_value_and_index(browser, value, index, desc = '')
    set_radio_two_attributes(browser, :value, value, :index, index, desc)
  end

  def set_radio_by_name_and_value(browser, strg, value, desc = '')
    set(browser, :radio, :name, strg, value, desc)
  end

# No validation
  def clear(browser, element, how, what, value = nil, desc = '')
    msg = "Clear #{element} #{how}=>'#{what}' "
    msg << "('#{value.to_s}')" if value
    msg << " '#{desc}' " if desc.length > 0
    case element
      when :radio
        browser.radio(how, what, value).clear
      when :checkbox
        browser.checkbox(how, what, value).clear
      when :text_field
        browser.text_field(how, what).set('')
      else
        failed_to_log("#{__method__}: #{element} not supported")
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

  def clear_radio(browser, how, what, value = nil, desc = '')
    msg = "Clear radio #{how}=>'#{what.to_s}' "
    msg << "('#{value.to_s}')" if value
    msg << " '#{desc}' " if desc.length > 0
    radio = browser.radio(how, what, value)
    radio.clear
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("#{msg} '#{$!}'")
  end

# Set skip_value_check = true when string is altered by application and/or
# this method will be followed by validate_text
  def clear_textfield(browser, how, which, skip_value_check = false)
    if browser.text_field(how, which).exists?
      tf = browser.text_field(how, which)
      if validate(browser, @myName, __LINE__)
        tf.clear
        if validate(browser, @myName, __LINE__)
          if tf.value == ''
            passed_to_log("Textfield #{how}='#{which}' cleared.")
            true
          elsif skip_value_check
            passed_to_log("Textfield  #{how}='#{which}' cleared. (skip value check)")
            true
          else
            failed_to_log("Textfield  #{how}='#{which}' not cleared: Found:'#{tf.value}'. (#{__LINE__})")
          end
        end
      end
    else
      failed_to_log("Textfield id='#{id}' to clear. (#{__LINE__})")
    end
  rescue
    failed_to_log("Textfield id='#{id}' could not be cleared: '#{$!}'. (#{__LINE__})")
  end

  def close_window_by_title(browser, title, desc = '', text = '')
    msg = "Window '#{title}':"
    if @ai.WinWait(title, text, WAIT) > 0
      passed_to_log("#{msg} appeared. #{desc}")
      myHandle  = @ai.WinGetHandle(title, text)
      full_text = @ai.WinGetText(title)
      debug_to_log("#{msg} hwnd: #{myHandle.inspect}")
      debug_to_log("#{msg} title: '#{title}' text: '#{full_text}'")
      if @ai.WinClose(title, text) > 0
        passed_to_log("#{msg} closed successfully. #{desc}")
      else
        failed_to_log("#{msg} close failed. (#{__LINE__}) #{desc}")
      end
    else
      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__}) #{desc}")
    end
  rescue
    failed_to_log("#{msg}: Unable to close: '#{$!}'. (#{__LINE__}) #{desc}")
  end

  def set_file_field(browser, how, what, filespec, desc = '')
    msg = "Set file field #{how}=>#{what} to '#{filespec}."
    msg << " #{desc}" if desc.length > 0
    ff = browser.file_field(how, what)
    if ff
      ff.set filespec
      sleep_for(8)
      if validate(browser, @myName, __LINE__)
        passed_to_log(msg)
        true
      end
    else
      failed_to_log("#{msg} File field not found.")
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def set_file_field_by_name(browser, strg, path, desc = '')
    set_file_field(browser, :name, strg, path, desc)
  end

  def set_file_field_by_id(browser, strg, path, desc = '')
    set_file_field(browser, :id, strg, path, desc)
  end

  def set_text_field(browser, how, what, value, desc = '', skip_value_check = false)
    #TODO: fix this to handle Safari password field
    msg = "Set textfield #{how}='#{what}' to '#{value}'"
    msg << " #{desc}" if desc.length > 0
    msg << " (Skip value check)" if skip_value_check
    if browser.text_field(how, what).exists?
      tf = browser.text_field(how, what)
      debug_to_log("#{tf.inspect}")
      if validate(browser, @myName, __LINE__)
        tf.set(value)
        if validate(browser, @myName, __LINE__)
          if tf.value == value
            passed_to_log(msg)
            true
          elsif skip_value_check
            passed_to_log(msg)
            true
          else
            failed_to_log("#{msg}: Found:'#{tf.value}'.")
          end
        end
      end
    else
      failed_to_log("Textfield #{how}='#{what}' not found to set to '#{value}''")
    end
  rescue
    failed_to_log("Unable to '#{msg}': '#{$!}'")
  end

  alias set_textfield set_text_field

  def set_textfield_by_name(browser, name, value, desc = '', skip_value_check = false)
    if browser.text_field(:name, name).exists?
      tf = browser.text_field(:name, name)
      # Workaround because browser.text_field doesn't work for password fields in Safari
    elsif @browserAbbrev.eql?("S")
      tf = browser.password(:name, name)
    end
    if tf.exists?
      if validate(browser, @myName, __LINE__)
        tf.set(value)
        if validate(browser, @myName, __LINE__)
          if tf.value == value
            passed_to_log("Set textfield name='#{name}' to '#{value}' #{desc}")
            true
          elsif skip_value_check
            passed_to_log("Set textfield name='#{name}' to '#{value}' #{desc} (skip value check)")
            true
          else
            failed_to_log("Set textfield name='#{name}' to '#{value}': Found:'#{tf.value}'.  #{desc} (#{__LINE__})")
          end
        end
      end
    else
      failed_to_log("Textfield name='#{name}' not found to set to '#{value}'.  #{desc} (#{__LINE__})")
    end
  rescue
    failed_to_log("Textfield name='#{name}' could not be set to '#{value}': '#{$!}'. #{desc} (#{__LINE__})")
  end

# Set skip_value_check = true when string is altered by application and/or
# this method will be followed by validate_text
  def set_textfield_by_id(browser, id, value, desc = '', skip_value_check = false)
    set_text_field(browser, :id, id, value, desc, skip_value_check)
  end

  def set_textfield_by_title(browser, title, value, desc = '', skip_value_check = false)
    set_text_field(browser, :title, title, value, desc, skip_value_check)
  end

  def set_textfield_by_class(browser, strg, value, desc = '', skip_value_check = false)
    set_text_field(browser, :class, strg, value, desc, skip_value_check)
  end

  def set_text_field_and_validate(browser, how, what, value, desc = '', valid_value = nil)
    #NOTE: use when value and valid_value differ as with dollar reformatting
    if set_text_field(browser, how, what, value, desc, true)
      expected = valid_value ? valid_value : value
      validate_textfield_value(browser, how, what, expected)
    end
  rescue
    failed_to_log("Unable to '#{msg}': '#{$!}'")
  end

=begin rdoc
category: Logon
tags: logon, login, user, password, url
TODO: Needs to be more flexible about finding login id and password textfields
TODO: Parameterize url and remove references to environment
=end
  def login(browser, user, password)
    myURL  = @myAppEnv.url
    runenv = @myAppEnv.nodename
    message_tolog("URL: #{myURL}")
    message_tolog("Beginning login: User: #{user} Environment: #{runenv}")
    if validate(browser, @myName, __LINE__)
      browser.goto(myURL)
      if validate(browser, @myName)
        set_textfield_by_name(browser, 'loginId', user)
        set_textfield_by_name(browser, 'password', password)
        click_button_by_value(browser, 'Login')
        if validate(browser, @myName)
          passed_to_log("Login successful.")
        end
      else
        failed_to_log("Unable to login to application: '#{$!}'")
        #          screen_capture( "#{@myRoot}/screens/#{myName}_#{@runid}_#{__LINE__.to_s}_#{Time.new.to_f.to_s}.jpg")
      end
    end
  rescue
    failed_to_log("Unable to login to application: '#{$!}'")
  end

=begin rdoc
category: Logon
tags: logon, login, user, password, url, basic authorization
=end
  def basic_auth(browser, user, pswd, url, bypass_validate = false)
    mark_testlevel("Basic Authorization Login", 0)

    message_to_report ("Login:    #{user}")
    message_to_report ("URL:      #{url}")
    message_to_report ("Password: #{pswd}")

    @login_title = "Connect to"

    a = Thread.new {
      browser.goto(url)
    }

    sleep_for(2)
    message_to_log("#{@login_title}...")

    if (@ai.WinWait(@login_title, "", 90) > 0)
      win_title = @ai.WinGetTitle(@login_title)
      debug_to_log("Basic Auth Login window appeared: '#{win_title}'")
      @ai.WinActivate(@login_title)
      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:2]", '!u')
      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:2]", user, 1)
      @ai.ControlSend(@login_title, '', "[CLASS:Edit; INSTANCE:3]", pswd.gsub(/!/, '{!}'), 1)
      @ai.ControlClick(@login_title, "", '[CLASS:Button; INSTANCE:1]')
    else
      debug_to_log("Basic Auth Login window did not appear.")
    end
    a.join

    validate(browser, @myName) unless bypass_validate

    message_to_report("URL: [#{browser.url}] User: [#{user}]")

  end

  def logout(browser, where = @myName, lnbr = __LINE__)
    #TODO Firewatir 1.6.5 does not implement .exists for FireWatir::Firefox class
    debug_to_log("Logging out in #{where} at line #{lnbr}.", lnbr, true)
    debug_to_log("#{__method__}: browser: #{browser.inspect} (#{__LINE__})")

    if ['FF', 'S'].include?(@browserAbbrev) || browser.exists?
      case @browserAbbrev
        when 'FF'
          if is_browser?(browser)
            url   = browser.url
            title = browser.title
            debug_to_log("#{__method__}: Firefox browser url: [#{url}]")
            debug_to_log("#{__method__}: Firefox browser title: [#{title}]")
            debug_to_log("#{__method__}: Closing browser: #{where} (#{lnbr})")
            if url and url.length > 1
              browser.close
            else
              browser = FireWatir::Firefox.attach(:title, title)
              browser.close
            end

          end
        when 'IE'
          hwnd = browser.hwnd
          pid  = Watir::IE::Process.process_id_from_hwnd(hwnd)
          debug_to_log("#{__method__}: Closing browser: hwnd #{hwnd} pid #{pid} #{where} (#{lnbr}) (#{__LINE__})")
          browser.close
          if browser.exists? and pid > 0 and pid < 538976288 # value of uninitialized memory location
            debug_to_log("Retry close browser: hwnd #{hwnd} pid #{pid} #{where} #{lnbr} (#{__LINE__})")
            browser.close
          end
          if browser.exists? and pid > 0 and pid < 538976288 # value of uninitialized memory location
            kill_browser(browser.hwnd, __LINE__, browser, true)
          end
        when 'S'
          if is_browser?(browser)
            url   = browser.url
            title = browser.title
            debug_to_log("Safari browser url: [#{url}]")
            debug_to_log("Safari browser title: [#{title}]")
            debug_to_log("Closing browser: #{where} (#{lnbr})")
            close_modal_s # to close any leftover modal dialogs
            browser.close
          end
        when 'C'
          if is_browser?(browser)
            url   = browser.url
            title = browser.title
            debug_to_log("Chrome browser url: [#{url}]")
            debug_to_log("Chrome browser title: [#{title}]")
            debug_to_log("Closing browser: #{where} (#{lnbr})")
            if url and url.length > 1
              browser.close
              #else
              #browser = FireWatir::Firefox.attach(:title, title)
              #browser.close
            end

          end
        else
          raise "Unsupported browser: '#{@browserAbbrev}'"
      end
    end
    #  rescue => e
    #    if not e.is_a?(Vapir::WindowGoneException)
    #      raise e
    #    end
  end

  #close popup in new window
  def close_new_window_popup(popup)
    if is_browser?(popup)
      url = popup.url
      debug_to_log("Closing popup '#{url}' ")
      popup.close

    end
  end

  def close_panel_by_text(browser, panel, strg = 'Close')
    if validate(browser, @myName, __LINE__)
      if @browserAbbrev == 'IE'
        panel.link(:text, strg).click!
      elsif $USE_FIREWATIR
        begin
          panel.link(:text, strg).click
        rescue => e
          if not rescue_me(e, __method__, "link(:text,'#{strg}').click", "#{panel.class}")
            raise e
          end
        end
      else
        panel.link(:text, strg).click(:wait => false)
      end
      sleep_for(1)
      if validate(browser, @myName, __LINE__)
        passed_to_log("Panel '#{strg}' (by :text) closed.")
        true
      end
    else
      failed_to_log("Panel '#{strg}' (by :text) still open.")
    end
  rescue
    failed_to_log("Click on '#{strg}'(by :text) failed: '#{$!}' (#{__LINE__})")
  end

  #  def close_modal_ie(title="", button="OK", text='', side = 'primary', wait = WAIT)
  def close_popup(title, button = "OK", text = '', side = 'primary', wait = WAIT, desc = '', quiet = false)
    #TODO needs simplifying and debug code cleaned up
    title = translate_popup_title(title)
    msg   = "'#{title}'"
    msg << " with text '#{text}'" if text.length > 0
    msg << " (#{desc})" if desc.length > 0
    @ai.Opt("WinSearchChildren", 1) # Match any substring in the title
    if @ai.WinWait(title, text, wait) > 0
      myHandle  = @ai.WinGetHandle(title, text)
      full_text = @ai.WinGetText(title)
      #debug_to_report("Found popup handle:'#{myHandle}', title:'#{title}', text:'#{full_text}'")
      if myHandle.length > 0
        debug_to_log("hwnd: #{myHandle.inspect}")
        passed_to_log("#{msg} appeared.") unless quiet
        sleep_for(0.5)
        @ai.WinActivate(title, text)
        if @ai.WinActive(title, text) #  > 0   #Hack to prevent fail when windows session locked
          debug_to_log("#{msg} activated.")
          if @ai.ControlFocus(title, text, button) #  > 0
            controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
            if not controlHandle
              button        = "&#{button}"
              controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
            end
            debug_to_log("Handle for button '#{button}': [#{controlHandle}]")
            debug_to_log("#{msg} focus gained.")
            #              sleep_for(2)
            if @ai.ControlClick(title, text, button, side) # > 0
                                                           #            if @ai.ControlClick(title, text, "[Handle:#{controlHandle}]", side) > 0
                                                           #                debug_to_log("#{msg} #{side} click on 'Handle:#{controlHandle}'." )
              debug_to_log("#{msg} #{side} click on '#{button}' successful.")
              sleep_for(1)
              if @ai.WinExists(title, text) > 0
                debug_to_log("#{msg} close popup failed on click '#{button}'. Trying WinClose. (#{__LINE__})")
                @ai.WinClose(title, text)
                if @ai.WinExists(title, text) > 0
                  debug_to_log("#{msg} close popup failed with WinClose('#{title}','#{text}'). (#{__LINE__})")
                  @ai.WinKill(title, text)
                  if @ai.WinExists(title, text) > 0
                    debug_to_log("#{msg} close popup failed with WinKill('#{title}','#{text}'). (#{__LINE__})")
                  else
                    debug_to_log("#{msg} closed successfully with WinKill('#{title}','#{text}').")
                  end
                else
                  debug_to_log("#{msg} closed successfully with WinClose('#{title}','#{text}').")
                end
              else
                passed_to_log("#{msg} closed successfully.") unless quiet
              end
            else
              failed_to_log("#{msg} #{side} click on '#{button}' failed. (#{__LINE__})")
            end
          else
            failed_to_log("#{msg} Unable to gain focus on button (#{__LINE__})")
          end
        else
          failed_to_log("#{msg} Unable to activate (#{__LINE__})")
        end
      else
        failed_to_log("#{msg} did not appear after #{wait} seconds. (#{__LINE__})")
      end
    else
      failed_to_log("#{msg} did not appear after #{wait} seconds. (#{__LINE__})")
    end
  rescue
    failed_to_log("Close popup title=#{title} failed: '#{$!}' (#{__LINE__})")
  end

  alias close_popup_validate_text close_popup

  def close_popup_by_text(popup, strg = 'Close', desc = '')
    count = 0
    url   = popup.url
    if validate(popup, @myName, __LINE__)
      count = string_count_in_string(popup.text, strg)
      if count > 0
        #        @waiter.wait_until( browser.link(:text, strg).exists? ) if @waiter
        begin
          popup.link(:text, strg).click
        rescue => e
          if not rescue_me(e, __method__, "link(:text,'#{strg}')", "#{popup.class}")
            raise e
          end
        end
        passed_to_log("Popup #{url} closed by clicking link with text '#{strg}'. #{desc}")
        true
      else
        failed_to_log("Link :text=>'#{strg}' for popup #{url} not found. #{desc}")
      end
    end
  rescue
    failed_to_log("Close popup #{url} with click link :text+>'#{strg}' failed: '#{$!}' (#{__LINE__})")
    debug_to_log("#{strg} appears #{count} times in popup.text.")
    raise
  end

  #  #close a modal dialog
  def close_modal(browser, title="", button="OK", text='', side = 'primary', wait = WAIT)
    case @targetBrowser.abbrev
      when 'IE'
        close_modal_ie(browser, title, button, text, side, wait)
      when 'FF'
        close_modal_ff(browser, title, button, text, side)
      when 'S'
        close_modal_s
      when 'C', 'GC'
        close_modal_c(browser, title)
    end
  end

# TODO: Logging
  def close_modal_c(browser, title)
    browser.window(:url, title).close
  end

# TODO: Logging
  def close_modal_s
    # simply closes the frontmost Safari dialog
    Appscript.app("Safari").activate; Appscript.app("System Events").processes["Safari"].key_code(52)
  end

  def close_modal_ie(browser, title="", button="OK", text='', side = 'primary', wait = WAIT, desc = '', quiet = false)
    #TODO needs simplifying, incorporating text verification, and debug code cleaned up
    title = translate_popup_title(title)
    msg   = "Modal window (popup) '#{title}'"
    if @ai.WinWait(title, text, wait)
      myHandle = @ai.WinGetHandle(title, text)
      if myHandle.length > 0
        debug_to_log("hwnd: #{myHandle.inspect}")
        passed_to_log("#{msg} appeared.") unless quiet
        window_handle = "[HANDLE:#{myHandle}]"
        sleep_for(0.5)
        @ai.WinActivate(window_handle)
        if @ai.WinActive(window_handle)
          debug_to_log("#{msg} activated.")
          controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
          if not controlHandle.length > 0
            button        = "&#{button}"
            controlHandle = @ai.ControlGetHandle(title, '', "[CLASS:Button; TEXT:#{button}]")
          end
          debug_to_log("Handle for button '#{button}': [#{controlHandle}]")
          debug_to_log("#{msg} focus gained.")
          if @ai.ControlClick(title, '', "[CLASS:Button; TEXT:#{button}]")
            passed_to_log("#{msg} #{side} click on '[CLASS:Button; TEXT:#{button}]' successful.")
            sleep_for(0.5)
            if @ai.WinExists(window_handle)
              debug_to_log("#{msg} close popup failed on click '#{button}'. Trying WinClose. (#{__LINE__})")
              @ai.WinClose(title, text)
              if @ai.WinExists(window_handle)
                debug_to_log("#{msg} close popup failed with WinClose(#{window_handle}). (#{__LINE__})")
                @ai.WinKill(window_handle)
                if @ai.WinExists(window_handle)
                  debug_to_log("#{msg} close popup failed with WinKill(#{window_handle}). (#{__LINE__})")
                else
                  debug_to_log("#{msg} closed successfully with WinKill(#{window_handle}).")
                end
              else
                debug_to_log("#{msg} closed successfully with WinClose(#{window_handle}).")
              end
            else
              passed_to_log("#{msg} closed successfully.")
            end
          else
            failed_to_log("#{msg} #{side} click on '[CLASS:Button; TEXT:#{button}]' failed. (#{window_handle}) (#{__LINE__})")
          end
        else
          failed_to_log("#{msg} Unable to activate (#{window_handle}) (#{__LINE__})")
        end
      else
        failed_to_log("#{msg} did not appear after #{wait} seconds. (#{window_handle}) (#{__LINE__})")
      end
    else
      failed_to_log("#{msg} did not appear after #{wait} seconds.(#{window_handle}) (#{__LINE__})")
    end
  rescue
    failed_to_log("Close popup title=#{title} failed: '#{$!}' (#{__LINE__})")
  end

  #  private :close_modal_ie

  def close_modal_ff(browser, title="", button=nil, text="", side='')
    title = translate_popup_title(title)
    msg   = "Modal dialog (popup): title=#{title} button='#{button}' text='#{text}' side='#{side}':"
    modal = browser.modal_dialog(:timeout => WAIT)
    if modal.exists?
      modal_text = modal.text
      if text.length > 0
        if modal_text =~ /#{text}/
          passed_to_log("#{msg} appeared with match on '#{text}'.")
        else
          failed_to_log("#{msg} appeared but did not match '#{text}' ('#{modal_text}).")
        end
      else
        passed_to_log("#{msg} appeared.")
      end
      if button
        modal.click_button(button)
      else
        modal.close
      end
      if modal.exists?
        failed_to_log("#{msg} close failed. (#{__LINE__})")
      else
        passed_to_log("#{msg} closed successfully.")
      end
    else
      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
    end
  rescue
    failed_to_log("#{msg} Unable to validate modal popup: '#{$!}'. (#{__LINE__})")
  end

  def handle_popup(title, text = '', button= 'OK', side = 'primary', wait = WAIT, desc = '')
    title = translate_popup_title(title)
    msg   = "'#{title}'"
    if text.length > 0
      msg << " with text '#{text}'"
    end
    @ai.Opt("WinSearchChildren", 1) # match title from start, forcing default

    if button and button.length > 0
      if button =~ /ok|yes/i
        id = '1'
      else
        id = '2'
      end
    else
      id = ''
    end

    if @ai.WinWait(title, '', wait) > 0
      myHandle      = @ai.WinGetHandle(title, '')
      window_handle = "[HANDLE:#{myHandle}]"
      full_text     = @ai.WinGetText(window_handle)
      debug_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text:'#{full_text}'")

      controlHandle = @ai.ControlGetHandle(window_handle, '', "[CLASS:Button; TEXT:#{button}]")
      if not controlHandle
#        button        = "&#{button}"
        controlHandle = @ai.ControlGetHandle(window_handle, '', "[CLASS:Button; TEXT:&#{button}]")
      end

      if text.length > 0
        if full_text =~ /#{text}/
          passed_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text includes '#{text}'. #{desc}")
        else
          failed_to_log("Found popup handle:'#{myHandle}', title:'#{title}', text does not include '#{text}'. Closing it. #{desc}")
        end
      end

      @ai.WinActivate(window_handle, '')
      @ai.ControlClick(window_handle, '', id, side)
      if @ai.WinExists(title, '') > 0
        debug_to_log("#{msg} @ai.ControlClick on '#{button}' (ID:#{id}) with handle '#{window_handle}' failed to close window. Trying title.")
        @ai.ControlClick(title, '', id, side)
        if @ai.WinExists(title, '') > 0
          debug_to_report("#{msg} @ai.ControlClick on '#{button}' (ID:#{id}) with title '#{title}' failed to close window.  Forcing closed.")
          @ai.WinClose(title, '')
          if @ai.WinExists(title, '') > 0
            debug_to_report("#{msg} @ai.WinClose on title '#{title}' failed to close window.  Killing window.")
            @ai.WinKill(title, '')
            if @ai.WinExists(title, '') > 0
              failed_to_log("#{msg} @ai.WinKill on title '#{title}' failed to close window")
            else
              passed_to_log("Killed: popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
              true
            end
          else
            passed_to_log("Forced closed: popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
            true
          end
        else
          passed_to_log("Closed on '#{button}': popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
          true
        end
      else
        passed_to_log("Closed on '#{button}': popup handle:'#{myHandle}', title:'#{title}'. #{desc}")
        true
      end

    else
      failed_to_log("#{msg} did not appear after #{wait} seconds. #{desc} (#{__LINE__})")
    end
  rescue
    failed_to_log("Unable to handle popup #{msg}: '#{$!}' #{desc} (#{__LINE__})")

  end

# howLong is integer, whatFor is a browser object
=begin rdoc
tags: wait
howLong is the number of seconds, text is a string to be found, threshold is the number of seconds
after which a fail message is generated even though the text was detected within the howLong limit.
Use this in place of wait_until_by_text when the wait time needs to be longer than the test automation default.
=end
  def hold_for_text(browser, howLong, text, desc = '', threshold = 20, interval = 0.25)
    countdown = howLong
    while ((not browser.contains_text(text)) and countdown > 0)
      sleep(interval)
      countdown = countdown - interval
    end
    if countdown < howLong
      waittime = howLong - countdown
      passed_tolog("#{__method__}  '#{text}' found after #{waittime} second(s) #{desc}")
      if waittime > threshold
        failed_tolog("#{__method__}  '#{text}' took #{waittime} second(s). (threshold: #{threshold} seconds) #{desc}")
      end
      true
    else
      failed_tolog("#{__method__}  '#{text}' not found after #{howLong} second(s) #{desc}")
      false
    end
  rescue
    failed_tolog("Unable to #{__method__} '#{text}'. '#{$!}' #{desc}")
  end

  alias wait_for_text hold_for_text

  def hover(browser, element, wait = 2)
    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
    @ai.MoveMouse(xc1, yc1)
    sleep_for(1)
  end

  def get_save_file_path(root, filename)
    filespec = "#{root}/file/#{filename}"
    filespec.gsub!('/', '\\')
  end

  def save_file_orig(filepath, desc = '', wait = WAIT)
    #    title = translate_popup_title(title)
    @ai.WinWait("File Download", "", wait)
    @ai.ControlFocus("File Download", "", "&Save")
    sleep 1
    @ai.ControlClick("File Download", "", "&Save", "left")
    @ai.WinWait("Save As", "", wait)
    sleep 1
    @ai.ControlSend("Save As", "", "Edit1", filepath)
    @ai.ControlClick("Save As", "", "&Save", "left")
    sleep 1
    @ai.WinWait("Download complete", "", wait)
    @ai.ControlClick("Download complete", "", "Close")
  end

  #TODO This and save_file2 have to be combined somehow.
  def save_file1(filepath, title = "File Download", desc = '', wait = WAIT)
    title = translate_popup_title(title)
    @ai.WinWait(title, '', wait)
    @ai.WinActivate(title, '')
    sleep 1
    @ai.ControlFocus(title, "", "&Save")
    sleep 3
    @ai.ControlClick(title, "", "&Save", "primary")
    sleep 2
    @ai.ControlClick(title, "", "Save", "primary")

    @ai.WinWait("Save As", "", wait)
    sleep 1
    @ai.ControlSend("Save As", "", "Edit1", filepath)
    @ai.ControlFocus("Save As", "", "&Save")
    @ai.ControlClick("Save As", "", "&Save", "primary")
    @ai.ControlClick("Save As", "", "Save", "primary")

    @ai.WinWait("Download complete", "", wait)
    passed_to_log("Save file '#{filepath}' succeeded. #{desc}")
    @ai.ControlClick("Download complete", "", "Close")
  rescue
    failed_to_log("Save file failed: #{desc} '#{$!}'. (#{__LINE__})")
  end

  def save_file2(filepath, title = "File Download - Security Warning", desc = '', wait = WAIT)
    title = translate_popup_title(title)
    sleep(1)
    @ai.WinWait(title, '', wait)
    dl_hndl    = @ai.WinGetHandle(title, '')
    dl_sv_hndl = @ai.ControlGetHandle(title, '', "&Save")
    @ai.WinActivate(title, '')
    sleep 1
    @ai.ControlFocus(title, "", "&Save")
    sleep 1
    @ai.ControlFocus(title, "", "Save")
    sleep 1
    @ai.ControlClick(title, "", "&Save", "primary")
    sleep 1
    @ai.ControlClick(title, "", "Save", "primary")
    sleep 1
    w = WinClicker.new
    w.clickButtonWithHandle(dl_sv_hndl)
    sleep 1
    w.clickWindowsButton_hwnd(dl_hndl, "Save")
    sleep 1
    w.clickWindowsButton_hwnd(dl_hndl, "&Save")

    @ai.WinWait("Save As", "", wait)
    sleep 1
    @ai.ControlSend("Save As", "", "Edit1", filepath)
    @ai.ControlFocus("Save As", "", "&Save")
    @ai.ControlClick("Save As", "", "&Save", "primary")

    @ai.WinWait("Download complete", "", wait)
    passed_to_log("Save file '#{filepath}' succeeded. #{desc}")
    @ai.ControlClick("Download complete", "", "Close")
  rescue
    failed_to_log("Save file failed: #{desc} '#{$!}'. (#{__LINE__})")
  end

  #method for handling save dialog
  #use click_no_wait on the action that triggers the save dialog
  # TODO need version for Firefox
  # TODO need to handle first character underline, e.g. 'Cancel' and '&Cancel'
  def save_file(filepath, download_title = "File Download - Security Warning")
    download_title   = translate_popup_title(download_title)
    download_text    = ''
    download_control = "&Save"
    saveas_title     = 'Save As'
    saveas_text      = ''
    saveas_control   = "Edit1"
    dnld_cmplt_title = "Download Complete"
    dnld_cmplt_title = translate_popup_title(dnld_cmplt_title)
    dnld_cmplt_text  = ""
    #    save_title = ""
    side             = 'primary'
    msgdl            = "Window '#{download_title}':"
    msgsa            = "Window '#{saveas_title}':"
    msgdc            = "Window '#{dnld_cmplt_title}':"
    begin
      if @ai.WinWait(download_title, download_text, WAIT)
        @ai.WinActivate(download_title, download_text)
        if @ai.WinActive(download_title, download_text)
          dl_title = @ai.WinGetTitle(download_title, download_text)
          #          dl_hndl  = @ai.WinGetHandle(download_title, download_text)
          #          dl_text  = @ai.WinGetText(download_title, download_text)
          #          dl_sv_hndl = @ai.ControlGetHandle(dl_title, '', download_control)
          #          dl_op_hndl = @ai.ControlGetHandle(dl_title, '', '&Open')
          #          dl_cn_hndl = @ai.ControlGetHandle(dl_title, '', 'Cancel')
          debug_to_log("#{msgdl} activated. (#{__LINE__})")

          if @ai.ControlFocus(dl_title, download_text, download_control)
            debug_to_log("#{msgdl} focus gained. (#{__LINE__})")

            @ai.Send("S")
            #              @ai.ControlSend(dl_Stitle, download_text, download_control, "{ENTER}")
            sleep_for 1

            if @ai.ControlClick(dl_title, download_text, download_control, side)
              debug_to_log("#{msgdl} click succeeded on '#{download_control}'. (#{__LINE__})")

              if @ai.WinWait(saveas_title, saveas_text, WAIT)
                debug_to_log("#{msgsa} appeared. (#{__LINE__})")
                sleep_for 1
                if @ai.ControlSend(saveas_title, saveas_text, saveas_control, filepath)
                  debug_to_log("#{msgsa} controlsend of '#{saveas_control}' succeeded. (#{__LINE__})")

                  @ai.Send("S")
                  @ai.ControlSend(saveas_title, saveas_text, saveas_control, "{ENTER}")
                  sleep_for 1

                  if @ai.ControlClick(saveas_title, saveas_text, saveas_control, side)
                    passed_to_log("#{msgsa} click succeeded on '#{saveas_control}'. (#{__LINE__})")
                    if @ai.WinWait(dnld_cmplt_title, dnld_cmplt_text, WAIT)
                      debug_to_log("#{msgdc} appeared. (#{__LINE__})")
                      sleep_for 1
                      if @ai.ControlClick(dnld_cmplt_title, dnld_cmplt_text, "Close", side)
                        passed_to_log("Save file for #{filepath} succeeded.")
                      else
                        failed_to_log("#{msgdc} click failed on 'Close'. (#{__LINE__})")
                      end
                    else
                      failed_to_log("#{msgdc} did not appear after #{WAIT} seconds. (#{__LINE__})")
                    end
                  else
                    failed_to_log("#{msgsa} click failed on '#{saveas_control}'. (#{__LINE__})")
                  end
                else
                  failed_to_log("#{msgsa} controlsend of '#{saveas_control}' failed. (#{__LINE__})")
                end
              else
                failed_to_log("#{msgsa} did not appear after #{WAIT} seconds. (#{__LINE__})")
              end
            else
              failed_to_log("#{msgdl} click failed on '#{download_control}'. (#{__LINE__})")
            end
          else
            failed_to_log("#{msgdl} Unable to gain focus on control '#{dl_title}'. (#{__LINE__})")
          end
        else
          failed_to_log("#{msgdl} Unable to activate. (#{__LINE__})")
        end
      else
        failed_to_log("#{msgdl} did not appear after #{WAIT} seconds. (#{__LINE__})")
      end
    rescue
      failed_to_log("Save file failed: '#{$!}'. (#{__LINE__})")
    end
  end

  def close_log(scriptName, lnbr = '')
    cmplTS = Time.now.to_f.to_s
    puts ("#{scriptName} finished.  Closing log. #{lnbr.to_s}")
    passed_to_log("#{scriptName} run complete [#{cmplTS}]")
    @myLog.close()
    sleep(2)
  end

  protected :close_log

  #method for cancelling Print window
  # TODO need to handle 'Cancel' and '&Cancel' (first character underlined)
  def close_print(title = 'Print', text = '', button = '&Cancel', side = 'left')
    msg = "Popup: title=#{title} button='#{button}' text='#{text}' side='#{side}':"
    if @ai.WinWait(title, text, WAIT)
      passed_to_log("#{msg} found.")
      @ai.WinActivate(title)
      if @ai.WinActive(title, text)
        passed_to_log("#{msg} activated.")
        if @ai.ControlFocus(title, text, button)
          passed_to_log("#{msg} focus attained.")
          if @ai.ControlClick(title, text, button, side)
            passed_to_log("#{msg} closed successfully.")
          else
            failed_to_log("#{msg} click failed on button (#{__LINE__})")
          end
        else
          failed_to_log("#{msg} Unable to gain focus on button (#{__LINE__})")
        end
      else
        failed_to_log("#{msg} Unable to activate (#{__LINE__})")
      end
    else
      failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
    end
  rescue
    failed_to_log("Close #{msg}: '#{$!}'. (#{__LINE__})")
  end

  #method for handling file download dialog
  #use click_no_wait on the action that triggers the save dialog
  # TODO need version for Firefox
  # TODO need to handle 'Cancel' and '&Cancel' (first character underlined)
  # TODO replace call to close_modal_ie with actual file download
  def file_download(browser = nil)
    title  = 'File Download'
    title  = translate_popup_title(title)
    text   = ''
    button = 'Cancel'
    if @browserAbbrev == 'IE'
      close_popup(title, button, text)
    else

    end
  end

  #method for handling file upload dialog
  #use click_no_wait on the action that triggers the save dialog
  # TODO need version for Firefox
  def file_upload(filepath)
    title   = 'Choose File'
    title   = translate_popup_title(title)
    text    = ''
    button  = "&Open"
    control = "Edit1"
    side    = 'primary'
    msg     = "Window title=#{title} button='#{button}' text='#{text}' side='#{side}':"
    begin
      if @ai.WinWait(title, text, WAIT)
        passed_to_log("#{msg} found.")
        @ai.WinActivate(title, text)
        if @ai.WinActive(title, text)
          passed_to_log("#{msg} activated.")
          if @ai.ControlSend(title, text, control, filepath)
            passed_to_log("#{msg} #{control} command sent.")
            sleep_for 1
            if @ai.ControlClick(title, text, button, "primary")
              passed_to_log("#{msg} Upload of #{filepath} succeeded.")
            else
              failed_to_log("#{msg} Upload of #{filepath} failed. (#{__LINE__})")
            end
          else
            failed_to_log("#{msg} Unable to select #{filepath}. (#{__LINE__})")
          end
        else
          failed_to_log("#{msg} Unable to activate. (#{__LINE__})")
        end
      else
        failed_to_log("#{msg} did not appear after #{WAIT} seconds. (#{__LINE__})")
      end
    rescue
      failed_to_log("#{msg} Unable to upload: '#{$!}'. (#{__LINE__})")
    end

  end

  def find_popup(browser, how, what, desc = '')
    msg   = "Find popup :#{how}=>'#{what}'. #{desc}"
    popup = Watir::IE.find(how, what) # TODO: too browser specific
    sleep_for(1)
    debug_to_log("#{popup.inspect}")
    if is_browser?(popup)
#      title = popup.title
      passed_to_log(msg)
      return popup
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable to find popup :#{how}=>'#{what}'. #{desc} '#{$!}' (#{__LINE__})")
  end

  def find_sheet_with_name(workbook, sheet_name)
    sheets = workbook.sheets
    idx    = 0
    found  = false
    sheets.each do |s|
      if s == sheet_name
        found = true
        break
      end
      idx += 1
    end
    if found
      idx
    else
      -1
    end
  end

  # howLong is integer, whatFor is a browser object
  def wait_for_text(browser, howLong, text)
    countdown = howLong
    while ((not browser.contains_text(text)) and countdown > 0)
      sleep(1)
      countdown = countdown - 1
    end
    if countdown
      passed_tolog("wait_for_text '#{text}' found after #{howLong} second(s)")
    else
      failed_tolog("wait_for_text '#{text}' not foundafter #{howLong} second(s)")
    end
    countdown
  end

  def wait_for_element_to_reappear(browser, how, what, desc = '', timeout = 20)
    msg = "Element #{how}=#{what} exists. #{desc}"
    wait_while(browser, "While: #{msg}", timeout) { browser.element(how, what).exists? }
    wait_until(browser, "Until: #{msg}", timeout) { browser.element(how, what).exists? }
  end

  # howLong is integer, whatFor is a browser object
  def wait_for_exists(howLong, whatFor)
    wait_for(howLong, whatFor)
  end

  def wait_for(howLong, whatFor)
    countdown = howLong
    while ((not whatFor.exists?) and countdown > 0)
      sleep(1)
      puts whatFor.inspect+':'+countdown.to_s
      countdown = countdown - 1
    end
    if countdown
      puts 'found '+whatFor.inspect
      passed_tolog("wait_for (#{howLong} found "+whatFor.inspect)
    else
      puts 'Did not find '+whatFor.inspect
      failed_tolog("wait_for (#{howLong} did not find "+whatFor.inspect)
    end
    countdown
  end

  #Sample usage:
  #  if wait_for( 10, browser.link(:id, "wria-messagebox-yes") )
  #    browser.link(:id, "wria-messagebox-yes").click
  # . .
  #  else
  #    @myLog.error('['+__LINE__.to_s+'] '+role+' Validate Expected Confirm Delete messagebox')
  #  end

  def wait_the_hard_way(browser, how, what, wait = 6, intvl = 0.25)
    count = (wait / intvl).to_i + 1
    tally = 0
    ok    = (1 / intvl).to_i + 1
    debug_to_log("#{__method__}: wait: #{wait} secs; intvl: #{intvl} secs; count; #{count}; thresh: #{ok}")
    (1..count).each do |x|
      begin
        if browser.element(how, what).exists?
          tally += 1
          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} exists.")
        else
          tally = 0
          debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} does not exist.")
        end
      rescue
        tally = 0
        debug_to_log("#{x}: #{(x - 1) * intvl}: #{what} rescue: #{$!}")
      end
      if tally >= ok
        return true
      end
      sleep(intvl)
    end
  end

  def is_browser?(browser)
    myClass = browser.class.to_s
    case @targetBrowser.abbrev
      when 'IE'
        myClass =~ /Watir::/i # TODO: should this be /Watir::IE/i ?
      when 'FF'
        if @version.to_f < 4.0
          myClass =~ /FireWatir::/i
        else
          myClass =~ /Watir::Browser/i
        end
      when 'S'
        myClass =~ /Watir::Safari/i
      when 'C'
        myClass =~ /Watir::Browser/i
    end
  end

  alias is_browser is_browser?

  def nice_array(arr, space_to_underscore = false)
    new_arr = Array.new
    if space_to_underscore
      arr.each do |nty|
        new_arr << nty.gsub(/\s/, '_')
      end
    else
      new_arr = arr
    end
    "['#{new_arr.join("','")}']"
  end

  def open_browser(url = nil)
    debug_to_log("Opening browser: #{@targetBrowser.name}")
    debug_to_log("#{__method__}: [#{get_caller_line}] #{get_callers}")
    case @targetBrowser.abbrev
      when 'IE'
        @myBrowser = open_ie
        @myHwnd    = @myBrowser.hwnd
      #@waiter    = Watir::Waiter.new(WAIT)
      when 'FF'
        #version    = "11"
        #@myBrowser = open_ff_for_version(version)
        @myBrowser = open_ff_for_version
      when 'S'
        debug_to_log("Opening browser: #{@targetBrowser.name} legacy.rb:#{__LINE__}")
        aBrowser = Watir::Safari.new
        debug_to_log("Browser instantiated")
        @myBrowser = aBrowser
      #require 'shamisen/awetest_legacy/safari_waiter'
      #@waiter    = Watir::Waiter
      when 'C', 'GC'
        @myBrowser = open_chrome
      ##require 'shamisen/awetest_legacy/webdriver_waiter'
      #require 'shamisen/support/webdriver_ext/browser'
      #@waiter    = Watir::Waiter

      else
        raise "Unsupported browser: #{@targetBrowser.name}"
    end
    get_browser_version(@myBrowser)
    if url
      go_to_url(@myBrowser, url)
    end
    @myBrowser
  end

  def open_ie(process = true)
    check_for_and_clear_other_browsers
    Watir::Browser.default = 'ie'
    #if process && !IS_WIN_2008
    #  browser = Watir::IE.new_process
    #else
    browser                = Watir::IE.new
    #end
    browser
  end

  def open_ff_for_version(version = @targetVersion)
    if version.to_f < 4.0
      browser = open_ff
      #waiter  = Watir::Waiter.new(WAIT)
    else
      browser = Watir::Browser.new(:firefox)
      #require 'shamisen/awetest_legacy/webdriver_waiter'
      #waiter = Watir::Waiter
    end
    browser
  end

  def open_ff
    Watir::Browser.default = 'firefox'
    browser                = Watir::Browser.new
  end

  def open_chrome
    browser = Watir::Browser.new(:chrome)
  end

  #=begin
  # Get the browser to navigate to a given url.  If not supplied in the second argument,
  # defaults to value of FullScript.myURL, which is populated from ApplicationEnvironment.url.
  #=end
  def go_to_url(browser, url = nil, redirect = nil)
    if url
      @myURL = url
    end
    message_tolog("URL: #{@myURL}")
    browser.goto(@myURL)
    if validate(browser, @myName, __LINE__)
#      TODO .url method returns blank in Firewatir
      if redirect
        passed_to_log("Redirected to url '#{browser.url}'.")
        true
      elsif browser.url =~ /#{@myURL}/i # or @browserAbbrev == 'FF'
        passed_to_log("Navigated to url '#{@myURL}'.")
        true
      else
        failed_to_log("Navigated to url '#{browser.url}' but expected '#{@myURL}'.")
      end
    end
  rescue
    fatal_to_log("Unable to navigate to '#{@myURL}': '#{$!}'")
  end

  #def open_log
  #  start = Time.now.to_f.to_s
  #
  #  logTS = Time.at(@myRun.launched.to_f).strftime("%Y%m%d%H%M%S")
  #  xls = @myAppEnv.xls_name.gsub('.xls', '') + '_' if  @myAppEnv.xls_name.length > 0
  #  @logFileSpec = "#{@myRoot}/#{logdir}/#{@myName}_#{@targetBrowser.abbrev}_#{xls}#{logTS}.log"
  #  init_logger(@logFileSpec, @myName)
  #
  #                                                  #    message_tolog( self.inspect )
  #  message_to_log("#{@myName} launched at [#{@myRun.launched.to_f.to_s}][#{@myScript.id}][#{@myRun.id}][#{@myChild.id}]")
  #  debug_to_log("pid: #{$$}")
  #  message_to_log("#{@myName} begin at [#{start}]")
  #  message_to_log("#{@myName} environment [#{@myAppEnv.name}]")
  #  message_to_log("#{@myName} xls_name [#{@myAppEnv.xls_name}]") if  @myAppEnv.xls_name.length > 0
  #  message_to_log("#{@myName} rootDir [#{@myRoot}]")
  #  message_to_log("#{@myName} Target Browser [#{@targetBrowser.name}]")
  #  mark_testlevel(@myParent.name, @myParent.level) # Module
  #  mark_testlevel(@myChild.name, @myChild.level) # SubModule
  #
  #end

  def click(browser, element, how, what, desc = '')
    #debug_to_log("#{__method__}: #{element}, #{how}, #{what}")
    msg = "Click #{element} :#{how}=>'#{what}'"
    msg << ", '#{desc}'" if desc.length > 0
    msg1 = "#{element}(#{how}, '#{what}')"
    begin
      case element
        when :link
          browser.link(how, what).click
        when :button
          browser.button(how, what).click
        when :image
          browser.image(how, what).click
        when :radio
          case how
            when :index
              set_radio_by_index(browser, what, desc)
            else
              browser.radio(how, what).set
          end
        when :span
          browser.span(how, what).click
        when :div
          browser.div(how, what).click
        when :cell
          browser.cell(how, what).click
        else
          browser.element(how, what).click
      end
    rescue => e
      if not rescue_me(e, __method__, "browser(#{msg1}).click", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  def click_no_wait(browser, element, how, what, desc = '')
    debug_to_log("#{__method__}: #{element}, #{how}, #{what}")
    msg = "Click no wait #{element} :#{how}=>'#{what}'"
    msg << ", '#{desc}'" if desc.length > 0
    msg1 = "#{element}(#{how}, '#{what}'"
    begin
      case element
        when :link
          browser.link(how, what).click_no_wait
        when :button
          browser.button(how, what).click_no_wait
        when :image
          browser.image(how, what).click_no_wait
        when :radio
          case how
            when :index
              set_radio_no_wait_by_index(browser, what, desc)
            else
              browser.radio(how, what).click_no_wait
          end
        when :span
          browser.span(how, what).click_no_wait
        when :div
          browser.div(how, what).click_no_wait
        when :checkbox
          browser.checkbox(how, what).click_no_wait
        when :cell
          browser.cell(how, what).click_no_wait
        else
          browser.element(how, what).click_no_wait
      end
    rescue => e
      if not rescue_me(e, __method__, "browser(#{msg1}').click_no_wait", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to #{msg}  '#{$!}'")
    sleep_for(1)
  end

  def click_button_by_id(browser, strg, desc = '')
    click(browser, :button, :id, strg, desc)
  end

  def click_link_by_index(browser, strg, desc = '')
    click(browser, :link, :index, strg, desc)
  end

  def click_link_by_href(browser, strg, desc = '')
    click(browser, :link, :href, strg, desc)
  end

  alias click_href click_link_by_href

  def click_link_no_wait_by_href(browser, strg, desc = '')
    click_no_wait(browser, :link, :href, strg, desc)
  end

  alias click_href_no_wait click_link_no_wait_by_href

  def click_button_by_index(browser, index, desc = '')
    click(browser, :button, :index, index, desc)
  end

  def click_button_by_name(browser, strg, desc = '')
    click(browser, :button, :name, strg, desc)
  end

  def click_button_by_text(browser, strg, desc = '')
    click(browser, :button, :text, strg, desc)
  end

  def click_button_by_class(browser, strg, desc = '')
    click(browser, :button, :class, strg, desc)
  end

  def click_button_no_wait_by_id(browser, strg, desc = '')
    click_no_wait(browser, :button, :id, strg, desc)
  end

  alias click_button_by_id_no_wait click_button_no_wait_by_id

  def click_button_no_wait_by_name(browser, strg, desc = '')
    click_no_wait(browser, :button, :name, strg, desc)
  end

  def click_button_no_wait_by_class(browser, strg, desc = '')
    click_no_wait(browser, :button, :class, strg, desc)
  end

  alias click_button_by_class_no_wait click_button_no_wait_by_class

  def click_button_by_value(browser, strg, desc = '')
    click(browser, :button, :value, strg, desc)
  end

  def click_button_by_title(browser, strg, desc = '')
    click(browser, :button, :title, strg, desc)
  end

  def click_button_by_xpath_and_id(browser, strg, desc = '')
    msg = "Click button by xpath and id '#{strg}' #{desc}"
    if browser.button(:xpath, "//a[@id = '#{strg}']").click
      passed_to_log(msg)
      true
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable to click button by xpath and id '#{strg}' #{desc} '#{$!}' (#{__LINE__})")
  end

  alias click_button_by_xpath click_button_by_xpath_and_id

  def click_link_by_id(browser, strg, desc = '')
    click(browser, :link, :id, strg, desc)
  end

  alias click_id click_link_by_id

  def click_link_by_name(browser, strg, desc = '')
    click(browser, :link, :name, strg, desc)
  end

  alias click_name click_link_by_name

  def click_link_by_xpath_and_id(browser, strg, desc = '')
    msg = "Click link by xpath and id '#{strg}' #{desc}"
    if browser.link(:xpath, "//a[@id = '#{strg}']").click
      passed_to_log(msg)
      true
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable click on link by xpath and id '#{strg}' #{desc} '#{$!}' (#{__LINE__})")
  end

  alias click_link_by_xpath click_link_by_xpath_and_id

  def click_link_no_wait_by_id(browser, strg, desc = '')
    click_no_wait(browser, :link, :id, strg, desc)
  end

  alias click_no_wait_id click_link_no_wait_by_id
  alias click_no_wait_by_id click_link_no_wait_by_id
  alias click_id_no_wait click_link_no_wait_by_id
  alias click_no_wait_link_by_id click_link_no_wait_by_id

  def click_file_field_by_id(browser, strg, desc = '')
    click(browser, :file_field, :id, strg, desc)
  end

  def click_img_by_alt(browser, strg, desc = '')
    click(browser, :image, :alt, strg, desc)
  end

  def click_img_by_title(browser, strg, desc = '')
    click(browser, :image, :title, strg, desc)
  end

  def click_img_by_xpath_and_name(browser, strg, desc = '')
    msg = "Click image by xpath where name='#{strg}' #{desc}"
    if browser.link(:xpath, "//input[@name = '#{strg}']").click
      passed_to_log(msg)
      true
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable to click image by xpath where name='#{strg}' #{desc} '#{$!}'")
  end

  alias click_img_by_xpath click_img_by_xpath_and_name
  alias click_image_by_xpath click_img_by_xpath_and_name
  alias click_image_by_xpath_and_name click_img_by_xpath_and_name

  def click_img_no_wait_by_alt(browser, strg, desc = '')
    click_no_wait(browser, :image, :alt, strg, desc)
  end

  alias click_img_by_alt_no_wait click_img_no_wait_by_alt

  def click_img_by_src(browser, strg, desc = '')
    click(browser, :image, :src, strg, desc)
  end

  def click_img_by_src_and_index(browser, strg, index, desc = '')
    msg = "Click image by src='#{strg}' and index=#{index}"
    msg << " #{desc}" if desc.length > 0
    browser.image(:src => strg, :index => index).click
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def click_link_by_value(browser, strg, desc = '')
    click(browser, :link, :value, strg, desc)
  end

  def click_link_by_text(browser, strg, desc = '')
    click(browser, :link, :text, strg, desc)
  end

  alias click_link click_link_by_text
  alias click_text click_link_by_text
  alias click_js_button click_link_by_text

  def click_link_by_class(browser, strg, desc = '')
    click(browser, :link, :class, strg, desc)
  end

  alias click_class click_link_by_class

  def click_button_no_wait_by_text(browser, strg, desc = '')
    click_no_wait(browser, :button, :text, strg, desc)
  end

  def click_button_no_wait_by_value(browser, strg, desc = '')
    click_no_wait(browser, :button, :value, strg, desc)
  end

  def click_link_by_name_no_wait(browser, strg, desc = '')
    click_no_wait(browser, :link, :name, strg, desc)
  end

  alias click_no_wait_name click_link_by_name_no_wait
  alias click_name_no_wait click_link_by_name_no_wait

  def click_link_by_text_no_wait(browser, strg, desc = '')
    click_no_wait(browser, :link, :text, strg, desc)
  end

  alias click_no_wait_text click_link_by_text_no_wait
  alias click_text_no_wait click_link_by_text_no_wait

  def click_span_by_text(browser, strg, desc = '')
    if not desc and not strg.match(/Save|Open|Close|Submit|Cancel/)
      desc = 'to navigate to selection'
    end
    msg = "Click span containing text '#{strg}'."
    msg << " #{desc}" if desc.length > 0
    if validate(browser, @myName, __LINE__)
      passed_to_log("#{msg}")
    end
  rescue
    failed_to_log("Unable to #{msg}: '#{$!}'")
  end

# TODO no logging yet.  slow.
  def click_span_with_text(browser, trgt, desc = '')
    msg = "Find and click span containing text '#{trgt}'."
    msg << " #{desc}" if desc.length > 0
    spans = browser.spans
    x     = 0
    spans.each do |span|
      x += 1
      debug_to_log("Span #{x}: #{span.text}")
      aText = span.text
      if aText and aText.size > 0
        if aText =~ /#{trgt}/
          break
        end
      end
    end
    spans[x].click
  end

  def click_link_by_title(browser, strg, desc = '')
    click(browser, :link, :title, strg, desc)
  end

  alias click_title click_link_by_title

  def click_title_no_wait(browser, strg, desc = '')
    click_no_wait(browser, :link, :title, strg, desc)
  end

  def click_table_row_with_text_by_id(browser, ptrn, strg, column = nil)
    msg   = "id=#{ptrn} row with text='#{strg}"
    table = get_table_by_id(browser, /#{ptrn}/)
    if table
      index = get_index_of_row_with_text(table, strg, column)
      if index
        table[index].click
        if validate(browser, @myName, __LINE__)
          passed_to_log("Click #{msg} row index=#{index}.")
          index
        end
      else
        failed_to_log("Table #{msg} not found to click.")
      end
    else
      failed_to_log("Table id=#{ptrn} not found.")
    end
  rescue
    failed_to_log("Unable to click table #{msg}: '#{$!}' (#{__LINE__}) ")
  end

  def click_table_row_with_text_by_index(browser, idx, strg, column = nil)
    msg   = "index=#{idx} row with text='#{strg}"
    table = get_table_by_index(browser, idx)
    if table
      index = get_index_of_row_with_text(table, strg, column)
      if index
        table[index].click
        if validate(browser, @myName, __LINE__)
          passed_to_log("Click #{msg} row index=#{index}.")
          index
        end
      else
        failed_to_log("Table #{msg} not found to click.")
      end
    else
      failed_to_log("Table id=#{ptrn} not found.")
    end
  rescue
    failed_to_log("Unable to click table #{msg}: '#{$!}' (#{__LINE__}) ")
  end

  def double_click_table_row_with_text_by_id(browser, ptrn, strg, column = nil)
    msg   = "id=#{ptrn} row with text='#{strg}"
    table = get_table_by_id(browser, /#{ptrn}/)
    if table
      index = get_index_of_row_with_text(table, strg, column)
      if index
        table[index].fire_event('ondblclick')
        if validate(browser, @myName, __LINE__)
          passed_to_log("Double click #{msg} row index=#{index}.")
          index
        end
      else
        failed_to_log("Table #{msg} not found to double click.")
      end
    else
      failed_to_log("Table id=#{ptrn} not found.")
    end
  rescue
    failed_to_log("Unable to double click table #{msg}: '#{$!}' (#{__LINE__}) ")
  end

  def double_click_table_row_with_text_by_index(browser, idx, strg, column = nil)
    msg   = "index=#{idx} row with text='#{strg}"
    table = get_table_by_index(browser, idx)
    if table
      index = get_index_of_row_with_text(table, strg, column)
      if index
        row = table[index]
        table[index].fire_event('ondblclick')
        row.fire_event('ondblclick')
        if validate(browser, @myName, __LINE__)
          passed_to_log("Double click #{msg} row index=#{index}.")
          index
        end
      else
        failed_to_log("Table #{msg} not found to double click.")
      end
    else
      failed_to_log("Table id=#{ptrn} not found.")
    end
  rescue
    failed_to_log("Unable to double click table #{msg}: '#{$!}' (#{__LINE__}) ")
  end

  def flash_text(browser, strg, count, desc = '')
    msg = "Flash link text='#{strg}' #{count} times."
    msg << " #{desc}" if desc.length > 0
    strgCnt = string_count_in_string(browser.text, strg)
    if strgCnt > 0
      browser.link(:text, strg).flash(count)
      if validate(browser, @myName, __LINE__)
        passed_to_log(msg)
        true
      end
    else
      failed_to_log("#{msg} Link not found.")
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def flash_id(browser, strg, count)
    msg = "Flash link id='#{strg}' #{count} times."
    msg << " #{desc}" if desc.length > 0
    browser.link(:id, strg).flash(count)
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      true
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def flash(element, count = 4)
    element.flash(count)
    debug_to_log("'#{element.inspect}' flashed #{count} times.")
    true
  rescue
    debug_to_log("Flash '#{element.inspect}' failed: '#{$!}' (#{__LINE__})")
  end

  def upload_file(data_path)
    limit = 180 # .seconds
    Timeout::timeout(limit) {
      wait = 20
      @ai.WinWait("Choose File to Upload", "", wait)
      sleep 1
      @ai.ControlSend("Choose File to Upload", "", "Edit1", data_path)
      @ai.ControlClick("Choose File to Upload", "", "[CLASS:Button; INSTANCE:2]", "left")
      sleep 4
      #sleep 1
    }
    failed_to_log("Choose File to Upload not found after #{limit} '#{$!}'")
  rescue Timeout::Error
    failed_to_log("File Upload timeout after #{limit} '#{$!}'")
  end

  #TODO put rescue inside the do loop
  #parameters: browser and a list of column link text values
  #example: exercise_sorting(browser,['Division', 'Payee', 'Date'], 'Sortable columns on this page')

  def exercise_sorting(browser, columnList, desc = '')
    columnList.each do |column|
      click(browser, :link, :text, column, desc)
    end
  end

  alias validate_sorting exercise_sorting

  def focus_on_textfield_by_id(browser, strg, desc = '')
    msg = "Set focus on textfield name='#{strg}' "
    msg << " #{desc}" if desc.length > 0
    tf = browser.text_field(:id, strg)
    if validate(browser, @myName, __LINE__)
      tf.focus
      if validate(browser, @myName, __LINE__)
        passed_to_log(msg)
        true
      end
    end
  rescue
    failed_to_log("Unable to #{msg} '#{$!}'")
  end

  def open_popup_through_link_title(browser, title, pattern, name)
    click_title(browser, title)
    #TODO need some kind of wait for process here
    sleep_for 2
    attach_iepopup(browser, pattern, name)
  rescue
    failed_to_log("Unable to open popup '#{name}': '#{$!}' (#{__LINE__})")
  end

  def get_div(browser, how, what, desc = '', dbg = false)
    msg = "Get division #{how}=>#{what}."
    msg << " #{desc}" if desc.length > 0
    Watir::Wait.until { browser.div(how, what).exists? }
    div = browser.div(how, what)
    debug_to_log(div.inspect) if dbg
    if validate(browser, @myName, __LINE__)
      if div
        passed_to_log(msg)
        return div
      else
        failed_to_log(msg)
      end
    end
  rescue
    failed_to_log("Unable to '#{msg}' '#{$!}'")
  end

  def get_div_by_id(browser, strg, desc = '', dbg = false)
    get_div(browser, :id, strg, desc, dbg)
  end

  def get_div_by_class(browser, strg, desc = '', dbg = false)
    get_div(browser, :class, strg, desc, dbg)
  end

  def get_div_by_text(browser, strg, desc = '', dbg = false)
    get_div(browser, :text, strg, desc, dbg)
  end

  def get_form(browser, how, strg)
    begin
      #       Watir::Wait.until( browser.form(how, strg).exists? )  # fails in wait_until
    rescue => e
      if not rescue_me(e, __method__, "browser.form(#{how}, '#{strg}').exists?", "#{browser.class}")
        raise e
      end
    end
    myForm = browser.form(how, strg)
    if validate(browser, @myName, __LINE__)
      passed_to_log("Form #{how}='#{strg}' found and returned.")
      return myForm
    end
  rescue
    failed_to_log("Unable to return form #{how}='#{strg}': '#{$!}' (#{__LINE__})")
  end

  def get_form_by_id(browser, strg)
    get_form(browser, :id, strg)
  end

  def get_frame(browser, how, strg, desc = '')
    #    begin
    #      Watir::Wait.until(browser.frame(how, strg).exists?) # fails in wait_until
    #    rescue => e
    #      if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
    #        raise e
    #      end
    #    end
    begin
      frame = browser.frame(how, strg)
    rescue => e
      if not rescue_me(e, __method__, "browser.frame(#{how}, '#{strg}').exists?", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log("Frame #{how}='#{strg}' found and returned. #{desc}")
      return frame
    end
  rescue
    failed_to_log("Unable to return frame #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
  end

  def get_frame_by_id(browser, strg, desc = '')
    get_frame(browser, :id, strg, desc)
  end

  def get_frame_by_index(browser, index, desc = '')
    get_frame(browser, :index, index, desc)
  end

  def get_frame_by_name(browser, strg, desc = '')
    get_frame(browser, :name, strg, desc)
  end

  def get_span(browser, how, strg, desc = '')
    begin
      #TODO: use LegacyExtensions#wait_until
      Watir::Wait.until { browser.span(how, strg).exists? }
    rescue => e
      if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
        raise e
      end
    end
    begin
      span = browser.span(how, strg)
    rescue => e
      if not rescue_me(e, __method__, "browser.span(#{how}, '#{strg}').exists?", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log("Span #{how}='#{strg}' found and returned. #{desc}")
      return span
    end
  rescue
    failed_to_log("Unable to return span #{how}='#{strg}'. #{desc}: '#{$!}' (#{__LINE__})")
  end

  def get_span_by_id(browser, strg, desc = '')
    get_span(browser, :id, strg, desc)
  end

  def get_table(browser, how, what, desc = '')
    msg = "Return table :#{how}='#{what}'. #{desc}"
    tbl = browser.table(how, what)
    if validate(browser, @myName, __LINE__)
      passed_to_log(msg)
      tbl
    end
  rescue
    failed_to_log("#{msg}': '#{$!}'")
  end

  def get_table_by_id(browser, strg, desc = '')
    get_table(browser, :id, strg, desc)
  end

  def get_table_by_index(browser, idx)
    get_table(browser, :index, idx, desc)
  end

  def get_table_by_text(browser, strg)
    get_table(browser, :text, strg, desc)
  end

  def get_table_headers(table, header_index = 1)
    headers          = Hash.new
    headers['index'] = Hash.new
    headers['name']  = Hash.new
    count            = 1
    table[header_index].each do |cell|
      if cell.text.length > 0
        name                    = cell.text.gsub(/\s+/, ' ')
        headers['index'][count] = name
        headers['name'][name]   = count
      end
      count += 1
    end
    #debug_to_log("#{__method__}:****** headers:\n#{headers.to_yaml}")
    headers
  rescue
    failed_to_log("Unable to get content headers. '#{$!}'")
  end

  def get_textfield_value(browser, how, what, desc = '')
    msg = "Return value in textfield #{how}='#{what}'"
    msg << " #{desc}" if desc.length > 0
    tf = browser.text_field(how, what)
    if validate(browser, @myName, __LINE__)
      if tf
        debug_to_log("#{tf.inspect}")
        vlu = tf.value
        passed_to_log("#{msg} Value='#{vlu}'")
        vlu
      else
        failed_to_log("#{msg}")
      end
    end
  rescue
    failed_to_log("Unable to #{msg}: '#{$!}'")
  end

  def get_textfield_value_by_name(browser, strg, desc = '')
    get_textfield_value(browser, :name, strg, desc)
  end

  def get_textfield_value_by_id(browser, strg)
    get_textfield_value(browser, :id, strg)
  end

  def string_count_in_string(strg, substrg)
    count = strg.scan(substrg).length
    count
  end

  def translate_popup_title(title)
    new_title = title
    case @browserAbbrev
      when 'IE'
        if @browserVersion
          case @browserVersion
            when '8.0'
              case title
                when "Microsoft Internet Explorer"
                  new_title = "Message from webpage"
                when "The page at"
                  new_title = "Message from webpage"
              end
            when '7.0'
              case title
                when "Message from webpage"
                  new_title = "Microsoft Internet Explorer"
                when "The page at"
                  new_title = "Windows Internet Explorer"
              end
            when '6.0'
              case title
                when "Message from webpage"
                  new_title = "Microsoft Internet Explorer"
                when "The page at"
                  new_title = "Microsoft Internet Explorer"
              end
            else
              case title
                when "Microsoft Internet Explorer"
                  new_title = "Message from webpage"
                when "The page at"
                  new_title = "Message from webpage"
              end
          end
        else
          case title
            when "Microsoft Internet Explorer"
              new_title = "Message from webpage"
            when "The page at"
              new_title = "Message from webpage"
          end
        end
      when 'FF'
        case title
          when 'File Download'
            new_title = 'Opening'
          when "Microsoft Internet Explorer"
            new_title = 'The page at'
          when "Message from webpage"
            new_title = 'The page at'
        end
      when 'C'
        case title
          when 'File Download'
            new_title = 'Save As'
          when "Microsoft Internet Explorer"
            new_title = 'The page at'
          when "Message from webpage"
            new_title = 'The page at'
        end
    end
    new_title
  end

  #def translate_popup_title(title)
  #  new_title = title
  #  case @browserAbbrev
  #    when 'IE'
  #
  #
  #      case title
  #        when "Microsoft Internet Explorer"
  #          new_title = "Message from webpage"
  #        when "The page at"
  #          new_title = "Message from webpage"
  #      end
  #
  #
  #
  #
  #    when 'FF'
  #      case title
  #        when 'File Download'
  #          new_title = 'Opening'
  #        when "Microsoft Internet Explorer"
  #          new_title = 'The page at'
  #        when "Message from webpage"
  #          new_title = 'The page at'
  #      end
  #
  #    when 'C'
  #      case title
  #        when 'File Download'
  #          new_title = 'Save As'
  #        when "Microsoft Internet Explorer"
  #          new_title = 'The page at'
  #        when "Message from webpage"
  #          new_title = 'The page at'
  #      end
  #  end
  #  new_title
  #end

  def get_browser_version(browser)
    debug_to_log("starting get_browser_version")
    case @targetBrowser.abbrev
      when 'IE'
        @browserAbbrev  = 'IE'
        @browserName    = 'Internet Explorer'
        @browserAppInfo = browser.document.invoke('parentWindow').navigator.appVersion
        @browserAppInfo =~ /MSIE\s(.*?);/
        @browserVersion = $1
      when 'FF'
        #@browserAbbrev = 'FF'
        #@browserName   = 'Firefox'
        #js_stuff       = <<-end_js_stuff
        #var info = Components.classes["@mozilla.org/xre/app-info;1"]
        #.getService(Components.interfaces.nsIXULAppInfo);
        #[info, info.name, info.version];
        #end_js_stuff
        #js_stuff.gsub!("\n", " ")
        #info = browser.execute_script(js_stuff)
        #info, aName, @browserVersion = info.split(',')
        #debug_to_log("FF info: [#{info}]")
        #debug_to_log("FF name: [#{aName}]")
        #debug_to_log("FF vrsn: [#{@browserVersion}]")
        @browserAbbrev  = 'FF'
        @browserName    = 'Firefox'
        @browserVersion = '6.01' #TODO: get actual version from browser
        debug_to_log("Firefox, in get_browser_version (#{@browserVersion})")
      when 'S'
        @browserAbbrev  = 'S'
        @browserName    = 'Safari'
        @browserVersion = '5.0.4' #TODO: get actual version from browser itself
        debug_to_log("Safari, in get_browser_version (#{@browserVersion})")
      when 'C'
        @browserAbbrev  = 'C'
        @browserName    = 'Chrome'
        @browserVersion = '11.0' #TODO: get actual version from browser
        debug_to_log("Chrome, in get_browser_version (#{@browserVersion})")
    end
    # if [notify_queue, notify_class, notify_id].all?
    #  Resque::Job.create(notify_queue, notify_class, :id => notify_id, :browser_used => "#{@browserName} #{@browserVersion}")
    #end
  rescue
    debug_to_log("Unable to determine #{@browserAbbrev} browser version: '#{$!}' (#{__LINE__})")

    # TODO: can we get rid of this?
    # js for getting firefox version information
    #      function getAppID() {
    #        var id;
    #        if("@mozilla.org/xre/app-info;1" in Components.classes) {
    #          // running under Mozilla 1.8 or later
    #          id = Components.classes["@mozilla.org/xre/app-info;1"]
    #                         .getService(Components.interfaces.nsIXULAppInfo).ID;
    #        } else {
    #          try {
    #            id = Components.classes["@mozilla.org/preferences-service;1"]
    #                           .getService(Components.interfaces.nsIPrefBranch)
    #                           .getCharPref("app.id");
    #          } catch(e) {
    #            // very old version
    #            dump(e);
    #          }
    #        }
    #        return id;
    #      }
    #      alert(getAppID());
    # another snippet that shows getting attributes from object
    #      var info = Components.classes["@mozilla.org/xre/app-info;1"]
    #                 .getService(Components.interfaces.nsIXULAppInfo);
    #      // Get the name of the application running us
    #      info.name; // Returns "Firefox" for Firefox
    #      info.version; // Returns "2.0.0.1" for Firefox version 2.0.0.1
  ensure
    message_to_log("Browser: [#{@browserAbbrev} #{@browserVersion}]")
  end

  protected :get_browser_version

  def fire_event(browser, element, how, what, event, desc = '')
    msg  = "#{element.to_s.titlecase}: #{how}=>'#{what}' event:'#{event}'"
    msg1 = "#{element.to_s.titlecase}(#{how}, '#{what}')"
    begin
      case element
        when :link
          browser.link(how, what).fire_event(event)
        when :button
          browser.button(how, what).fire_event(event)
        when :image
          browser.image(how, what).fire_event(event)
        when :span
          browser.span(how, what).fire_event(event)
        when :div
          browser.div(how, what).fire_event(event)
        else
          browser.element(how, what).fire_event(event)
      end
    rescue => e
      if not rescue_me(e, __method__, "browser(#{msg1}).fire_event('#{event}')", "#{browser.class}")
        raise e
      end
    end
    if validate(browser, @myName, __LINE__)
      passed_to_log("Fire event: #{msg}. #{desc}")
      true
    end
  rescue
    failed_to_log("Unable to fire event: #{msg}. '#{$!}' #{desc}")
  end

  def fire_event_on_link_by_text(browser, strg, event = 'onclick', desc = '')
    fire_event(browser, :link, :text, strg, event, desc)
  end

  alias fire_event_text fire_event_on_link_by_text
  alias fire_event_by_text fire_event_on_link_by_text

  def fire_event_on_link_by_id(browser, strg, event = 'onclick', desc = '')
    fire_event(browser, :link, :id, strg, event, desc)
  end

  alias fire_event_id fire_event_on_link_by_id
  alias fire_event_by_id fire_event_on_link_by_id

  def fire_event_on_image_by_src(browser, strg, event = 'onclick', desc = '')
    fire_event(browser, :img, :src, strg, event, desc)
  end

  alias fire_event_src fire_event_on_image_by_src
  alias fire_event_image_by_src fire_event_on_image_by_src

  def wait_until_exists(browser, element, how, what, desc = '')
    msg = "Wait until (#{element} :#{how}=>#{what}) exists."
    msg << " #{desc}" if desc.length > 0
    start = Time.now.to_f
    # TODO: try Watir::Wait.until { browser.element(how, what).exists? } instead of this (cumbersome) case statement
    # TODO: above fails on frame
    begin
      case element
        when :link
          Watir::Wait.until { browser.link(how, what).exists? }
        when :button
          Watir::Wait.until { browser.button(how, what).exists? }
        when :radio
          Watir::Wait.until { browser.radio(how, what).exists? }
        when :checkbox
          Watir::Wait.until { browser.checkbox(how, what).exists? }
        when :div
          Watir::Wait.until { browser.div(how, what).exists? }
        when :select_list
          Watir::Wait.until { browser.select_list(how, what).exists? }
        when :text_field
          Watir::Wait.until { browser.text_field(how, what).exists? }
        when :frame
          Watir::Wait.until { browser.frame(how, what).exists? }
        when :form
          Watir::Wait.until { browser.form(how, what).exists? }
        when :cell
          Watir::Wait.until { browser.cell(how, what).exists? }
        when :image
          Watir::Wait.until { browser.image(how, what).exists? }
        else
          Watir::Wait.until { browser.element(how, what).exists? }
      end
    rescue => e
      if e.class.to_s =~ /TimeOutException/
        failed_to_log("#{msg}: '#{$!}'")
        return false
      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
        raise e
      end
    end
    stop = Time.now.to_f
    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
    #    sleep 1
    if validate(browser, @myName, __LINE__)
      passed_to_log("#{msg} (#{stop - start} seconds)")
      true
    end
  rescue
    failed_to_log("Unable to complete #{msg}: '#{$!}'")
  end

  #TODO: Would like to be able to see the block code in the log message instead of the identification
  def wait_while(browser, desc, timeout = 45, &block)
    msg   = "Wait while #{desc}:"
    start = Time.now.to_f
    begin
      #Watir::Wait.until(timeout) { block.call(nil) }
      if block.call(nil)
        Watir::Wait.while(timeout) { block.call(nil) }
      end
    rescue => e
      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
        failed_to_log("#{msg}: '#{$!}' ")
        return false
      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
        raise e
      end
    end
    stop = Time.now.to_f
    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
    #    sleep 1
    if validate(browser, @myName, __LINE__)
      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") #  {#{block.to_s}}")
      true
    end
  rescue
    failed_to_log("Unable to complete #{msg}. '#{$!}'")
  end

  alias wait_while_true wait_while

  #TODO: Would like to be able to see the block code in the log message instead of the identification
  def wait_until(browser, desc, timeout = 45, skip_pass = false, &block)
    msg   = "Wait until #{desc}"
    start = Time.now.to_f
    begin
      Watir::Wait.until(timeout) { block.call(nil) }
    rescue => e
      if e.class.to_s =~ /TimeOutException/ or e.message =~ /timed out/
        failed_to_log("#{msg} '#{$!}'")
        return false
      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
        raise e
      end
    end
    stop = Time.now.to_f
    #debug_to_log("#{__method__}: start:#{start} stop:#{stop} block: #{block.to_s}")
    #    sleep 1
    if validate(browser, @myName, __LINE__)
      passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless skip_pass #  {#{block.to_s}}")
      true
    end
  rescue
    failed_to_log("Unable to complete #{msg}  '#{$!}'")
  end

  alias wait_until_true wait_until

  def wait_until_by_radio_value(browser, strg, desc = '')
    wait_until_exists(browser, :radio, :value, strg, desc)
  end

  def wait_until_ready(browser, how, what, desc = '', timeout = 90, verbose = false)
    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
    msg << " #{desc}" if desc.length > 0
    proc_exists  = Proc.new { browser.element(how, what).exists? }
    proc_enabled = Proc.new { browser.element(how, what).enabled? }
    case how
      when :href
        proc_exists  = Proc.new { browser.link(how, what).exists? }
        proc_enabled = Proc.new { browser.link(how, what).enabled? }
    end
    if verbose
      if wait_until(browser, "#{msg} Element exists.", timeout) { proc_exists.call(nil) }
        if wait_until(browser, "#{msg} Element enabled.", timeout) { proc_enabled.call(nil) }
          passed_to_log(msg)
          true
        else
          failed_to_log(msg)
        end
      else
        failed_to_log(msg)
      end
    else
      start = Time.now.to_f
      if Watir::Wait.until(timeout) { proc_exists.call(nil) }
        if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
          stop = Time.now.to_f
          #debug_to_log("#{__method__}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
          passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)")
          true
        else
          failed_to_log(msg)
        end
      else
        failed_to_log(msg)
      end
    end
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  def wait_until_ready_quiet(browser, how, what, desc = '', timeout = 45, quiet = true)
    msg = "#{__method__.to_s.titleize}: element: #{how}='#{what}'"
    msg << " #{desc}" if desc.length > 0
    proc_exists  = Proc.new { browser.element(how, what).exists? }
    proc_enabled = Proc.new { browser.element(how, what).enabled? }
    case how
      when :href
        proc_exists  = Proc.new { browser.link(how, what).exists? }
        proc_enabled = Proc.new { browser.link(how, what).enabled? }
    end
    start = Time.now.to_f
    if Watir::Wait.until(timeout) { proc_exists.call(nil) }
      if Watir::Wait.until(timeout) { proc_enabled.call(nil) }
        stop = Time.now.to_f
        #debug_to_log("#{msg}: start:#{"%.5f" % start} stop:#{"%.5f" % stop}")
        passed_to_log("#{msg} (#{"%.5f" % (stop - start)} seconds)") unless quiet
        true
      else
        failed_to_log(msg)
      end
    else
      failed_to_log(msg)
    end
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  def wait_until_text(browser, strg, desc = '', timeout = 60)
    if not strg.class.to_s.match('String')
      raise "#{__method__} requires String for search target. #{strg.class} is not supported."
    end
    wait_until(browser, "'#{strg}' #{desc}", timeout) { browser.text.include? strg }
  end

  alias wait_until_by_text wait_until_text

  def wait_until_by_link_text(browser, strg, desc = '')
    wait_until_exists(browser, :link, :text, strg, desc)
  end

  def wait_until_enabled(browser, what, how, value, desc = '')
    start = Time.now.to_f
    begin
      case what
        when :link
          Watir::Wait.until { browser.link(how, value).enabled? }
        when :button
          Watir::Wait.until { browser.button(how, value).enabled? }
        when :radio
          Watir::Wait.until { browser.radio(how, value).enabled? }
        when :checkbox
          Watir::Wait.until { browser.checkbox(how, value).enabled? }
        when :div
          Watir::Wait.until { browser.div(how, value).enabled? }
        when :select_list
          Watir::Wait.until { browser.select_list(how, value).enabled? }
        when :text_field
          Watir::Wait.until { browser.text_field(how, value).enabled? }
        when :table
          Watir::Wait.until { browser.table(how, value).enabled? }
        else
          raise "#{__method__}: Element #{what} not supported."
      end
    rescue => e
      if e.class.to_s =~ /TimeOutException/
        failed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}' #{desc}")
        return false
      elsif not rescue_me(e, __method__, "#{block.to_s}", "#{browser.class}")
        raise e
      end
    end
    stop = Time.now.to_f
    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
    #    sleep 1
    if validate(browser, @myName, __LINE__)
      passed_to_log("Wait until (#{what} :#{how}=>#{value}) enabled. #{desc} (#{stop - start} seconds)")
      true
    end
  rescue
    failed_to_log("Unable to complete wait until (#{what} :#{how}=>#{value}) enabled. #{desc}: '#{$!}'")
  end

  def wait_until_visible(browser, element, how, what, desc = '')
    start = Time.now.to_f
    Watir::Wait.until(20) { browser.element(how, what).exists? }
    begin
      case element
        when :link
          Watir::Wait.until { browser.link(how, what).visible? }
        when :button
          Watir::Wait.until { browser.button(how, what).visible? }
        when :radio
          Watir::Wait.until { browser.radio(how, what).visible? }
        when :checkbox
          Watir::Wait.until { browser.checkbox(how, what).visible? }
        when :div
          Watir::Wait.until { browser.div(how, what).visible? }
        when :select_list
          Watir::Wait.until { browser.select_list(how, what).visible? }
        when :text_field
          Watir::Wait.until { browser.text_field(how, what).visible? }
        else
          Watir::Wait.until { browser.element(how, what).visible? }
#          raise "#{__method__}: Element #{what} not supported."
      end
    rescue => e
      if e.class.to_s =~ /TimeOutException/
        failed_to_log("Wait until (#{what} :#{how}=>#{what}) visible. #{desc}: '#{$!}' #{desc}")
        return false
      elsif not rescue_me(e, __method__, '', "#{browser.class}")
        raise e
      end
    end
    stop = Time.now.to_f
    #debug_to_log("#{__method__}: start:#{start} stop:#{stop}")
    #    sleep 1
    if validate(browser, @myName, __LINE__)
      passed_to_log("Wait until (#{element} :#{how}=>#{what}) visible. #{desc} (#{stop - start} seconds)")
      true
    end
  rescue
    failed_to_log("Unable to complete wait until (#{element} :#{how}=>#{what}) visible. #{desc}: '#{$!}'")
  end

  def rescue_me(e, me = nil, what = nil, where = nil, who = nil)
    #TODO: these are rescues from exceptions raised in Watir/Firewatir
    debug_to_log("#{__method__}: Enter")
    ok = false
    begin
      gaak    = who.inspect
      located = gaak =~ /located=true/i
    rescue
      debug_to_log("#{__method__}: gaak: '#{gaak}'")
    end
    msg = e.message
    debug_to_log("#{__method__}: msg = #{msg}")
    if  msg =~ /undefined method\s+.join.\s+for/i # firewatir to_s implementation error
      ok = true
    elsif msg =~ /undefined method\s+.match.\s+for.+WIN32OLERuntimeError/i # watir and firewatir
      ok = true
    elsif msg =~ /undefined method\s+.match.\s+for.+UnknownObjectException/i # watir
      ok = true
    elsif msg =~ /window\.getBrowser is not a function/i # firewatir
      ok = true
    elsif msg =~ /WIN32OLERuntimeError/i # watir
      ok = true
    elsif msg =~ /undefined method\s+.match.\s+for/i # watir
      ok = true
    elsif msg =~ /wrong number of arguments \(1 for 0\)/i
      ok = true
    elsif (msg =~ /unable to locate element/i)
      if located
        ok = true
      elsif where == 'Watir::Div'
        ok = true
      end
    elsif (msg =~ /HRESULT error code:0x80070005/)
      ok = true
                                                  #elsif msg =~ /missing\s+\;\s+before statement/
                                                  #  ok = true
    end
    if ok
      debug_to_log("#{__method__}: RESCUED: \n#{who.to_yaml}=> #{what} in #{me}()\n=> '#{$!}'")
      debug_to_log("#{__method__}: #{who.inspect}") if who
      debug_to_log("#{__method__}: #{where.inspect}")
      debug_to_log("#{__method__}: #{get_callers(6, true)}")
    else
      debug_to_log("#{__method__}: NO RESCUE: #{e.message}")
      debug_to_log("#{__method__}: NO RESCUE: \n#{get_callers(6, true)}")
    end
    debug_to_log("#{__method__}: Exit")
    ok
  end

  def close_popup_by_button_title(popup, strg, desc = '')
    click(popup, :link, :title, strg, desc)
  end

  def move_element_with_handle(browser, element, handle_id, dx, dy)
    #    msg = "Move element "
    #    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
    #    newx   = w1 + dx
    #    newy   = h1 + dy
    #    msg << " by [#{dx}, #{dy}] to expected [[#{newx}, #{newy}] "
    #    handle = get_resize_handle(element, handle_id)
    #    hw, hh, hx, hy, hxc, hyc, hxlr, hylr  = get_element_coordinates(browser, handle, true)

    #    drag_and_drop(hxc, hyc, dx, dy)

    #    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

    #    xerr = x2 - newx
    #    yerr = y2 - newy
    #    xdsp = (x1 - x2).abs
    #    ydsp = (y1 - y2).abs

    #    if x2 == newx and y2 == newy
    #      msg << "succeeded."
    #      passed_to_log(msg)
    #    else
    #      msg << "failed. "
    #      failed_to_log(msg)
    #      debug_to_log("x: actual #{x2}, error #{xerr}, displace #{xdsp}. y: actual #{y2}, error #{yerr}, displace #{ydsp}.")
    #    end

  end

  #TODO enhance to accept differing percentages in each direction
  def resize_element_with_handle(browser, element, target, dx, dy=nil)
    msg                                  = "Resize element "
    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
    if dy
      deltax = dx
      deltay = dy
      neww   = w1 + dx
      newh   = h1 + dy
      msg << " by [#{dx}, #{dy}] " #"" to expected dimension [#{neww}, #{newh}] "
    else
      deltax, deltay, neww, newh = adjust_dimensions_by_percent(w1, h1, dx, true)
      msg << "by #{dx} percent " #"" to expected dimension [#{neww}, #{newh}] "
    end
    handle = get_resize_handle_by_class(element, target) #, true)
    sleep_for(0.5)
    hw, hh, hx, hy, hxc, hyc, hxlr, hylr = get_element_coordinates(browser, handle, true)
    hxlr_diff                            = 0
    hylr_diff                            = 0

    # TODO These adjustments are adhoc and empirical. Need to be derived more rigorously
    if @browserAbbrev == 'IE'
      hxlr_diff = (xlr1 - hxlr)
      hylr_diff = (ylr1 - hylr)
      x_start   = hxlr - 2
      y_start   = hylr - 2
    else
      hxlr_diff = (xlr1 - hxlr) / 2 unless (xlr1 - hxlr) == 0
      hylr_diff = (ylr1 - hylr) / 2 unless (ylr1 - hylr) == 0
      x_start = hxlr
      y_start = hylr
    end

    newxlr = xlr1 + deltax
    newylr = ylr1 + deltay
    #    msg << ", lower right [#{newxlr}, #{newylr}] - "
    sleep_for(0.5)

    drag_and_drop(x_start, y_start, deltax, deltay)

    sleep_for(1.5)
    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

    werr   = w2 - neww
    herr   = h2 - newh

    # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
    xlrerr = xlr2 - newxlr + hxlr_diff
    ylrerr = ylr2 - newylr + hylr_diff

    xlrdsp = (xlr1 - xlr2).abs
    ylrdsp = (ylr1 - ylr2).abs

    debug_to_log("\n" +
                     "\t\t  hxlr_diff: #{hxlr_diff}\n" +
                     "\t\t  hylr_diff: #{hylr_diff}\n" +
                     "\t\t       werr: #{werr}\n" +
                     "\t\t       herr: #{herr}\n" +
                     "\t\t     xlrerr: #{xlrerr}\n" +
                     "\t\t     ylrerr: #{ylrerr}\n" +
                     "\t\t     xlrdsp: #{xlrdsp}\n" +
                     "\t\t     ylrdsp: #{ylrdsp}\n" +
                     "\t\t @min_width: #{@min_width}\n" +
                     "\t\t@min_height: #{@min_height}\n" +
                     "\t\t      x tol: #{@x_tolerance}\n" +
                     "\t\t      y tol: #{@y_tolerance}\n"
    )

    #TODO Add check that window _was_ resized.
    x_ok, x_msg = validate_move(w2, xlrerr, @x_tolerance, @min_width, xlr2)
    y_ok, y_msg = validate_move(h2, ylrerr, @y_tolerance, @min_height, ylr2)
    msg         = msg + "x: #{x_msg}, y: #{y_msg}"

    if x_ok and y_ok
      passed_to_log(msg)
    else
      failed_to_log(msg)
      debug_to_log("x - actual #{xlr2}, error #{xlrerr}, displace #{xlrdsp}, y - actual #{ylr2}, error #{ylrerr}, displace #{ylrdsp}.")
    end
    sleep_for(1)
  rescue
    failed_to_log("Unable to validate resize. #{$!} (#{__LINE__})")
    sleep_for(1)
  end

  def get_resize_handle_by_id(element, id, dbg=nil)
    handle = get_div_by_id(element, id, dbg)
    sleep_for(1)
    handle.flash(5)
    return handle
  end

  def get_resize_handle_by_class(element, strg, dbg=nil)
    handle = get_div_by_class(element, strg, dbg)
    sleep_for(0.5)
    handle.flash(5)
    return handle
  end

  def get_element_coordinates(browser, element, dbg=nil)
    bx, by, bw, bh = get_browser_coord(browser, dbg)
    if @browserAbbrev == 'IE'
      x_hack = @horizontal_hack_ie
      y_hack = @vertical_hack_ie
    elsif @browserAbbrev == 'FF'
      x_hack = @horizontal_hack_ff
      y_hack = @vertical_hack_ff
    end
    sleep_for(1)
    w, h   = element.dimensions.to_a
    xc, yc = element.client_offset.to_a
    #    xcc, ycc = element.client_center.to_a
    xcc    = xc + w/2
    ycc    = yc + h/2
    # screen offset:
    xs     = bx + x_hack + xc - 1
    ys     = by + y_hack + yc - 1
    # screen center:
    xsc    = xs + w/2
    ysc    = ys + h/2
    xslr   = xs + w
    yslr   = ys + h
    if dbg
      debug_to_log(
          "\n\t\tElement: #{element.inspect}"+
              "\n\t\tbrowser screen offset: x: #{bx} y: #{by}"+
              "\n\t\t           dimensions: x: #{w} y: #{h}"+
              "\n\t\t         client offset x: #{xc} y: #{yc}"+
              "\n\t\t         screen offset x: #{xs} y: #{ys}"+
              "\n\t\t         client center x: #{xcc} y: #{ycc}"+
              "\n\t\t         screen center x: #{xsc} y: #{ysc}"+
              "\n\t\t    screen lower right x: #{xslr} y: #{yslr}")
    end
    [w, h, xs, ys, xsc, ysc, xslr, yslr]
  end

  def get_element(browser, element, how, what, value = nil)
    target = nil
    what = Regexp.new(Regexp.escape(what)) unless how == :index or what.is_a?(Regexp)
    case element
      when :link
        target = browser.link(how, what)
      when :button
        target = browser.button(how, what)
      when :div
        target = browser.div(how, what)
      when :checkbox
        target = browser.checkbox(how, what, value)
      when :text_field, :textfield
        target = browser.text_field(how, what)
      when :image
        target = browser.image(how, what)
      when :file_field, :filefield
        target = browser.file_field(how, what)
      when :form
        target = browser.form(how, what)
      when :frame
        target = browser.frame(how, what)
      when :radio
        target = browser.radio(how, what, value)
      when :span
        target = browser.span(how, what)
      when :table
        target = browser.table(how, what)
      when :li
        target = browser.li(how, what)
      when :select_list, :selectlist
        target = browser.select_list(how, what)
      when :hidden
        target = browser.hidden(how, what)
      when :area
        target = browser.area(how, what)
    end
    if target.exists?
      target
    else
      nil
    end
  rescue => e
    if not rescue_me(e, __method__, "browser.#{element}(#{how}, '#{what}')", "#{browser.class}", target)
      raise e
    end
  end

  def get_element_text(browser, element, how, what, desc = '')
    msg = "Return text in #{element} #{how}='#{what}'"
    msg << " #{desc}" if desc.length > 0
    text = browser.element(how, what).text
    if validate(browser, @myName, __LINE__)
      passed_to_log("#{msg} text='#{text}'")
      text
    end
  rescue
    failed_to_log("Unable to #{msg}: '#{$!}'")
  end

  def adjust_dimensions_by_percent(w, h, p, returnnew=nil)
    p      += 100
    nw     = (w * (p/100.0)).to_i
    nh     = (h * (p/100.0)).to_i
    deltaw = nw - w
    deltah = nh - h
    if returnnew
      [deltaw, deltah, nw, nh]
    else
      [deltaw, deltah]
    end
  end

  def get_browser_coord(browser=nil, dbg=nil)
    browser = @myBrowser if not browser
    title = browser.title
    x     = @ai.WinGetPosX(title)
    y     = @ai.WinGetPosY(title)
    w     = @ai.WinGetPosWidth(title)
    h     = @ai.WinGetPosHeight(title)
    if dbg
      debug_to_log("\n\t\tBrowser #{browser.inspect}\n"+
                       "\t\tdimensions:   x: #{w} y: #{h}"+
                       "\t\tscreen offset x: #{x} y: #{y}")
    end
    [x, y, w, h]
  end

  def get_index_for_column_head(panel, table_index, strg)
    rgx = Regexp.new(strg)
    panel.tables[table_index].each do |row|
      if row.text =~ rgx
        index = 1
        row.each do |cell|
          if cell.text =~ rgx
            return index
          end
          index += 1
        end
      end
    end
  end

  def get_index_of_last_row(table, pad = 2, every = 1)
    index = calc_index(table.row_count, every)
    index = index.to_s.rjust(pad, '0')
    #debug_to_log("#{__method__}: index='#{index}' row_count=#{table.row_count} pad=#{pad} every=#{every}")
    index
  end

  alias get_index_for_last_row get_index_of_last_row

  def get_index_of_last_row_with_text(table, strg, column_index = nil)
    debug_to_log("#{__method__}: #{get_callers(5)}")
    msg = "Find last row in table :id=#{table.id} with text '#{strg}'"
    msg << " in column #{column_index}" if column_index
    dbg = "#{__method__}: #{table.id} text by row "
    dbg << "in column #{column_index}" if column_index
    index    = 0
    found    = false
    at_index = 0
    #row_count = table.row_count
    table.rows.each do |row|
      cell_count = get_cell_count(row)
      index      += 1
      text       = ''
      if column_index
        col_idx = column_index.to_i
        if cell_count >= col_idx
          text = row[col_idx].text
        end
      else
        text = row.text
      end
      dbg << "\n#{index}. [#{text}]"
      if text =~ /#{strg}/
        found    = true
        at_index = index
      end
    end
    debug_to_log(dbg)
    if found
      passed_to_log("#{msg} at index #{index}.")
      at_index
    else
      failed_to_log("#{msg}")
      nil
    end
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  alias get_index_for_last_row_with_text get_index_of_last_row_with_text

  def get_index_of_row_with_text(table, strg, column_index = nil, fail_if_found = false)
    debug_to_log("#{__method__}: #{get_callers(5)}")
    if fail_if_found
      msg = 'No '
    else
      msg = 'Find '
    end
    msg << "row in table :id=#{table.id} with text '#{strg}'"
    msg << " in column #{column_index}" if column_index
    dbg = "#{__method__}: #{table.id} text by row "
    dbg << "in column #{column_index}" if column_index
    index = 0
    found = false
    table.rows.each do |row|
      cell_count = row.cells.length
      index      += 1
      text       = ''
      if column_index
        col_idx = column_index.to_i
        if cell_count >= col_idx
          text = row[col_idx].text
        end
      else
        text = row.text
      end
      dbg << "\n#{index}. [#{text}]"
      if text =~ /#{strg}/
        found = true
        break
      end
    end
    debug_to_log(dbg)
    if found
      if fail_if_found
        failed_to_log("#{msg} at index #{index}.")
      else
        passed_to_log("#{msg} at index #{index}.")
      end
      index
    else
      if fail_if_found
        passed_to_log("#{msg}")
      else
        failed_to_log("#{msg}")
      end
      nil
    end
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  def get_index_of_row_with_textfield_value(table, strg, how, what, column_index = nil)
    msg = "Find row in table :id=#{table.id} with value '#{strg}' in text_field #{how}=>'#{what} "
    msg << " in column #{column_index}" if column_index
    index = 0
    found = false
    table.rows.each do |row|
      cell_count = get_cell_count(row)
      index      += 1
      text       = ''
      if column_index
        col_idx = column_index.to_i
        if cell_count >= col_idx
          if  row[col_idx].text_field(how, what).exists?
            value = row[col_idx].text_field(how, what).value
          end
        end
      else
        if  row.text_field(how, what).exists?
          value = row.text_field(how, what).value
          sleep(0.25)
        end
      end
      if value and value =~ /#{strg}/
        found = true
        break
      end
    end
    if found
      passed_to_log("#{msg} at index #{index}.")
    else
      failed_to_log("#{msg}")
    end
    index
  rescue
    failed_to_log("Unable to #{msg}. '#{$!}'")
  end

  def get_index_for_table_containing_text(browser, strg, ordinal = 1)
    msg   = "Get index for table containing text '#{strg}'"
    index = 0
    found = 0
    browser.tables.each do |t|
      index += 1
      if t.text =~ /#{strg}/
        found += 1
        if ordinal > 0 and found == ordinal
          break
        end
      end
    end
    if found
      passed_to_log("#{msg}: #{index}")
      index
    else
      passed_to_log("#{msg}.")
      nil
    end
  rescue
    failed_to_log("Unable to find index of table containing text '#{strg}' '#{$!}' ")
  end

  def get_table_containing_text(browser, strg, ordinal = 1)
    msg   = "Get table #{ordinal} containing text '#{strg}'"
    index = get_index_for_table_containing_text(browser, strg, ordinal)
    if index
      passed_to_log(msg)
      browser.tables[index]
    else
      failed_to_log(msg)
      nil
    end
  rescue
    failed_to_log("Unable to find index of table containing text '#{strg}' '#{$!}' ")
  end

  def get_cell_text_from_row_with_string(nc_element, table_index, column_index, strg)
    rgx  = Regexp.new(strg)
    text = ''
    debug_to_log("strg:'#{strg}', rgx:'#{rgx}', table_index:'#{table_index}', column_index:'#{column_index}'")
    nc_element.tables[table_index].each do |row|
      cell_count = get_cell_count(row)
      if cell_count >= column_index
        #TODO this assumes column 1 is a number column
        #        debug_to_log("row:'#{row.cells}'")
        cell_1 = row[1].text
        if cell_1 =~ /\d+/
          row_text = row.text
          if row_text =~ rgx
            text = row[column_index].text
            break
          end
        end
      end
    end
    text
  end

  def count_rows_with_string(container, table_index, strg)
    hit = 0
    container.tables[table_index].each do |row|
      if get_cell_count(row) >= 1
        #        debug_to_log("#{__method__}: #{row.text}")
        #TODO this assumes column 1 is a number column
        if row[1].text =~ /\d+/
          if row.text =~ /#{strg}/i
            hit += 1
            debug_to_log("#{__method__}: #{row.text}")
          end
        end
      end
    end
    debug_to_log("#{__method__}: hit row count: #{hit}")
    hit
  end

  def fetch_array_for_table_column(nc_element, table_index, column_index)
    ary = []
    nc_element.tables[table_index].each do |row|
      if get_cell_count(row) >= column_index
        #TODO this assumes column 1 is a number column
        if row[1].text =~ /\d+/
          ary << row[column_index].text
        end
      end
    end
    return ary f
  end

  def fetch_hash_for_table_column(table, column_index, start_row = 2)
    hash      = Hash.new
    row_count = 0
    table.each do |row|
      row_count += 1
      if get_cell_count(row) >= column_index
        if row_count >= start_row
          hash[row_count] = row[column_index].text
        end
      end
    end
    hash
  end

  def get_row_cells_text_as_array(row)
    ary = []
    row.each do |cell|
      ary << cell.text
    end
    ary
  end

  def count_data_rows(container, data_index, column_index)
    cnt   = 0
    #  get_objects(container, :tables, true)
    table = container.tables[data_index]
    dump_table_and_rows(table)
    if table
      table.rows.each do |row|
        if get_cell_count(row) >= column_index
          #TODO this assumes column 1 is a number column
          if row[column_index].text =~ /\d+/
            cnt += 1
          end
        end
      end
    end
    sleep_for(2)
    cnt
  end

  def drag_and_drop(x1, y1, dx, dy, speed=nil)
    speed = 10 if not speed
    x2 = x1 + dx
    y2 = y1 + dy
    debug_to_log("drag_and_drop: start: [#{x1}, #{y1}] end: [#{x2}, #{y2}]")

    @ai.MouseMove(x1, y1, speed)
    @ai.MouseClick("primary", x1, y1)
    sleep_for(0.5)
    @ai.MouseClick("primary", x1, y1)
    sleep_for(0.5)
    @ai.MouseClickDrag("primary", x1, y1, x2, y2, speed)
  end

  def drag_and_drop_element(browser, element, dx, dy, speed = nil)
    speed = 10 if not speed
    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
    msg                                  = "Move #{element} by [#{dx}, #{dy}] from center[#{xc1}, #{yc1}] "
    newxc                                = xc1 + dx
    newyc                                = yc1 + dy
    msg << "to center[[#{newxc}, #{newyc}]"
    sleep_for(0.5)

    drag_and_drop(xc1, yc1, dx, dy)

    sleep_for(1)
    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

    # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
    xcerr                                = xc2 - xc1
    ycerr                                = yc2 - yc1

    debug_to_log("\n" +
                     "\t\t   xc1: #{xc1}\n" +
                     "\t\t   yc1: #{yc1}\n" +
                     "\t\t   xc2: #{xc2}\n" +
                     "\t\t   yc2: #{yc2}\n" +
                     "\t\t xcerr: #{xlrerr}\n" +
                     "\t\t ycerr: #{ylrerr}\n" +
                     "\t\t x tol: #{@x_tolerance}\n" +
                     "\t\t y tol: #{@y_tolerance}\n"
    )

    #TODO Add check that window _was_ resized.
    x_ok, x_msg = validate_drag_drop(xcerr, @x_tolerance, newxc, xc2)
    y_ok, y_msg = validate_drag_drop(ycerr, @y_tolerance, newyc, yc2)
    msg         = msg + "x: #{x_msg}, y: #{y_msg}"

    if x_ok and y_ok
      passed_to_log(msg)
    else
      failed_to_log(msg)
    end
    sleep_for(1)
  rescue
    failed_to_log("Unable to validate drag and drop. #{$!} (#{__LINE__})")
    sleep_for(1)
  end

  def get_objects(browser, which, dbg=false)
    cnt = 0
    case which
      when :links
        list = browser.links
        sleep(1)
      when :tables
        list = browser.tables
      when :divs
        list = browser.divs
      when :buttons
        list = browser.buttons
      when :checkboxes
        list = browser.checkboxes
      when :radios
        list = browser.radios
      when :selectlists
        list = browser.selectlists
      when :textfields
        list = browser.textfields
      when :lis
        list = browser.lis
      else
        debug_to_log("Unrecognized dom object '#{which}'")
    end
    if dbg
      list.each do |obj|
        cnt += 1
        debug_to_log("\n============== #{which}:\nindex:     #{cnt}\n#{obj}\n#{obj.to_yaml}")
      end
    end
    list
  end

  def get_ole(element)
    ole = element.ole_object
    if ole
      passed_to_log("Found ole_object for #{element}.")
      ole
    else
      failed_to_log("Did not find ole_object for #{element}.")
    end
  rescue
    failed_to_log("Unable to find ole_object for #{element}.  #{$!}")
  end

  def find_all_links_with_exact_href(browser, href)
    links = browser.links
    hash  = Hash.new
    idx   = 0
    links.each do |l|
      idx     += 1
      an_href = href
      my_href = l.href
      if my_href == an_href
        hash[idx] = l
        debug_to_log("#{__method__}:#{idx}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
      end
    end
    hash
  end

  def find_link_with_exact_href(browser, href)
    links = browser.links
    link  = nil
    index = 0
    links.each do |l|
      index   += 1
      an_href = href
      my_href = l.href
      if my_href == an_href
        link = l
#        debug_to_log("#{__method__}:#{__LINE__}\n********\n#{l.to_s}\n\n#{l.to_yaml}")
        break
      end
    end
    link
  end

  def find_index_for_object(browser, obj, how, ord, strg)
    obj_sym = (obj.to_s.pluralize).to_sym
    how_str = how.to_s
    ptrn    = /#{how}:\s+#{strg}/i
    list    = get_objects(browser, obj_sym, true)
    cnt     = 0
    idx     = 0
    list.each do |nty|
      s = nty.to_s
      #      a    = nty.to_a
      if s =~ ptrn
        cnt += 1
        if cnt == ord
          break
        end
      end
      idx += 1
    end
    idx
  end

  def right_click(element)
    x = element.left_edge_absolute + 2
    y = element.top_edge_absolute + 2
    @ai.MouseClick("secondary", x, y)
  end

  def left_click(element)
    x = element.left_edge_absolute + 2
    y = element.top_edge_absolute + 2
    @ai.MouseClick("primary", x, y)
  end

  def get_cell_count(row)
    #    if @browserAbbrev == 'IE' or $use_firewatir
    row.cells.length
    #    else
    #      row.cell_count
    #    end
  end

  def screen_offset(element, browser=nil)
    bx, by, bw, bh = get_browser_coord(browser)
    ex             = element.left_edge
    ey             = element.top_edge
    [bx + ex, by + ey]
  end

  def screen_center(element, browser=nil)
    bx, by, bw, bh = get_browser_coord(browser)
    w, h           = element.dimensions.to_a
    cx             = bx + w/2
    cy             = by + h/2
    [cx, cy]
  end

  def screen_lower_right(element, browser=nil)
    bx, by, bw, bh = get_browser_coord(browser)
    w, h           = element.dimensions.to_a
    [bx + w, by + h]
  end

  #TODO unlikely to work...
  def find_me(where, how, what)
    me = where.element(how, what)
    puts me.inspect
  rescue
    error_to_log("#{where.inspect} doesn't seem to respond to element() #{$!}")
  end

  def click_me(element)
    element.click
  rescue
    error_to_log("#{element.inspect} doesn't seem to respond to click() #{$!}")
  end

  def filter_bailout_from_rescue(err, msg)
    if msg =~ /bailing out/i
      raise err
    else
      error_to_log(msg)
    end
  end

  def get_caller_line
    last_caller = get_callers[0]
    line        = last_caller.split(':', 3)[1]
    line
  end

  def get_call_list(depth = 9, dbg = false)
    myList    = []
    call_list = Kernel.caller
    puts call_list if dbg
    call_list.each_index do |x|
      myCaller = call_list[x].to_s
      break if x > depth or myCaller =~ /:in .run.$/
      myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
      myList << "[#{$1.gsub(/eval/, @myName)}] "
    end
    myList
  end

  alias get_callers get_call_list

  def get_call_list_new(depth = 9, dbg = false)
    myList    = []
    call_list = Kernel.caller
    puts call_list if dbg
    call_list.each_index do |x|
      myCaller = call_list[x].to_s
      break if x > depth or myCaller =~ /:in .run.$/
      if myCaller.include? @myName
        myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
        myList << "[#{$1.gsub(/eval/, @myName)}] "
        break
      end
    end
    if @projName
      call_list.each_index do |x|
        myCaller = call_list[x].to_s
        break if x > depth or myCaller =~ /:in .run.$/
        if myCaller.include? @projName
          myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
          myList << "[#{$1.gsub(/eval/, @projName)}] "
          break
        end
      end
    end
    myList
  end

  def get_call_array(depth = 9)
    arr       = []
    call_list = Kernel.caller
    call_list.each_index do |x|
      myCaller = call_list[x].to_s
      break if x > depth or myCaller =~ /:in .run.$/
      myCaller =~ /([\(\)\w_\_\-\.]+\:\d+\:?.*?)$/
      arr << $1.gsub(/eval/, @myName)
    end
    arr
  end

  def get_debug_list(dbg = false)
    calls = get_call_array(10)
    puts "#{calls.to_yaml}" if dbg
    arr = []
    calls.each_index do |ix|
      if ix > 1 # skip this method and the logging method
        arr << calls[ix]
      end
    end
    puts "#{arr.to_yaml}" if dbg
    if arr.length > 0
      list = 'TRACE:'
      arr.reverse.each { |l| list << "=>#{l}" }
      " [[#{list}]]"
    else
      nil
    end
  end

  def dump_all_tables(browser, to_report = false)
    tables  = browser.tables
    msg     = ''
    tbl_cnt = 0
    tables.each do |tbl|
      tbl_cnt += 1
      row_cnt = 0
      msg <<"\n=================\ntable: #{tbl_cnt}\n=================\n#{tbl}\ntext:\n#{tbl.text}"
      tbl.rows.each do |row|
        row_cnt  += 1
        cell_cnt = 0
        msg <<"\n=================\ntable: #{tbl_cnt} row: #{row_cnt}\n#{row.inspect}\n#{row}\ntext:'#{row.text}'"
        row.each do |cell|
          cell_cnt += 1
          msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
        end
      end
    end
    if to_report
      debug_to_report(msg)
    else
      debug_to_log(msg)
    end
  end

  def dump_table_and_rows(table, to_report = false)
    msg = "\n=================\ntable\n=================\nn#{table}\n#{table.to_yaml}\nrows:"
    cnt = 0
    table.rows.each do |r|
      cnt += 1
      msg << "\n#{cnt}: #{r.text}"
    end
    msg << "\n=================\n================="
    if to_report
      debug_to_report(msg)
    else
      debug_to_log(msg)
    end
  end

  def dump_table_rows_and_cells(tbl)
    msg     = ''
    row_cnt = 0
    msg <<"\n=================\ntable: #{tbl.inspect}\n=================\n#{tbl}\ntext:\n#{tbl.text}"
    tbl.rows.each do |row|
      row_cnt  += 1
      cell_cnt = 0
      msg <<"\n=================\nrow: #{row_cnt}\n#{row.inspect}\n#{row}\ntext:'#{row.text}'"
      row.each do |cell|
        cell_cnt += 1
        msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
      end
    end
    debug_to_log(msg)
  end

  alias dump_table_rows dump_table_rows_and_cells

  def dump_array(arr, space_to_underscore = false)
    dump = "  #{arr.inspect}\n"
    arr.each_index do |x|
      value = arr[x].to_s
      value.gsub!(/\s/, '_') if space_to_underscore
      dump << " #{x.to_s.rjust(5)}>> '#{arr[x].to_s}'\n"
    end
    dump
  end

  def dump_ole_methods(ole)
    rtrn = ''
    ole.ole_methods.each do |m|
      prms = ''
      m.params.each do |p|
        prms << "#{p}, "
      end
      rtrn << "#{m.name}(#{prms.chop.chop})\n"
    end
    rtrn
  end

  def dump_ole_get_methods(ole)
    rtrn = ''
    ole.ole_get_methods.each do |m|
      prms = ''
      m.params.each do |p|
        prms << "#{p}, "
      end
      rtrn << "#{m.name}(#{prms.chop.chop})\n"
    end
    rtrn
  end

  def dump_ole_help(ole)
    rtrn = ''
    ole.ole_obj_help.each do |m|
      prms = ''
      m.params.each do |p|
        prms << "#{p}, "
      end
      rtrn << "#{m.name}(#{prms.chop.chop})\n"
    end
    rtrn
  end

  def dump_row_cells(row)
    msg      = ''
    cell_cnt = 0
    msg <<"\n=================\nrow: #{row.inspect}\n#{row}\ntext:'#{row.text}'"
    row.each do |cell|
      cell_cnt += 1
      msg <<"\n==== cell: #{cell_cnt}\n#{cell.inspect}\n#{row}\ntext: '#{cell.text}'"
    end
    debug_to_log(msg)
  end

  def dump_select_list_options(element)
    msg     = "#{element.inspect}"
    options = element.options
    cnt     = 1
    options.each do |o|
      msg << "\n\t#{cnt}:\t'#{o}"
      cnt += 1
    end
    debug_to_log(msg)
  end

end