def _get_ctrl(criteria_):
"Get the control based on the various criteria"
# make a copy of the criteria
criteria = [crit.copy() for crit in criteria_]
# find the dialog
dialog = controls.WrapHandle(findwindows.find_window(**criteria[0]))
ctrl = None
# if there is only criteria for a dialog then return it
if len(criteria) > 1:
# so there was criteria for a control, add the extra criteria
# that are required for child controls
ctrl_criteria = criteria[1]
ctrl_criteria["top_level_only"] = False
ctrl_criteria["parent"] = dialog.handle
# resolve the control and return it
ctrl = controls.WrapHandle(findwindows.find_window(**ctrl_criteria))
if ctrl:
return (dialog, ctrl)
else:
return (dialog, )
def windows_(self, **kwargs):
"""Return list of wrapped windows of the top level windows of
the application
"""
if not self.process:
raise AppNotConnected("Please use start_ or connect_ before "
"trying anything else")
if 'visible_only' not in kwargs:
kwargs['visible_only'] = False
if 'enabled_only' not in kwargs:
kwargs['enabled_only'] = False
kwargs['process'] = self.process
windows = findwindows.find_windows(**kwargs)
return [controls.WrapHandle(win) for win in windows]
def _resolve_from_appdata(criteria_, app, timeout=None, retry_interval=None):
"Should not be used at the moment!"
if timeout is None:
timeout = Timings.window_find_timeout
if retry_interval is None:
retry_interval = Timings.window_find_retry
global cur_item
# get the stored item corresponding to this request
matched_control = app.GetMatchHistoryItem(cur_item)
cur_item += 1
# remove parameters from the original search that changes each time
criteria = [crit.copy() for crit in criteria_]
# Remove any attributes from the current search that are
# completely language dependent
for unloc_attrib in ['title_re', 'title', 'best_match']:
for c in criteria:
if c.has_key(unloc_attrib):
del c[unloc_attrib]
#found_criteria = item[0]
#for c in found_criteria:
# if c.has_key('process'):
# del c['process']
#
# They should match - so if they don't print it out.
#if found_criteria != search_criteria:
# print "\t\t", matched[cur_index - 3][0]
# print "\t" ,matched[cur_index - 2][0]
# print search_criteria
# print "---"
# print found_criteria
# raise RuntimeError("Mismatch")
# so let's use the ID from the matched control...
#print item[1]
# we need to try and get a good match for the dialog
# this could be done by matching
# - number/positoin of controls
# - class
# anything else?
dialog_criterion = criteria[0]
#print list(matched_control)
dialog_criterion['class_name'] = matched_control[1]['Class']
# find all the windows in the process
process_hwnds = findwindows.find_windows(**dialog_criterion)
dialog = None
ctrl = None
if len(process_hwnds) >= 1:
similar_child_count = [
h for h in process_hwnds if matched_control[1]['ControlCount'] -
2 <= len(handleprops.children(h))
and matched_control[1]['ControlCount'] +
2 >= len(handleprops.children(h))
]
if len(similar_child_count) == 0:
#print "None Similar child count!!???"
#print matched_control[1]['ControlCount'], \
# len(handleprops.children(h))
pass
else:
process_hwnds = similar_child_count
for h in process_hwnds:
#print controls.WrapHandle(h).GetProperties()
#print "======", h, h, h
dialog = controls.WrapHandle(h)
# if a control was specified also
if len(criteria_) > 1:
# find it in the original data
#print item[2]
# remove those criteria which are langauge specific
ctrl_criterion = criteria[1]
#def has_same_id(other_ctrl):
# print "==="*20
# print "testing", item[2]['ControlID'],
# print "against", other_ctrl
# return item[2]['ControlID'] == \
# handleprops.controlid(other_ctrl)
ctrl_criterion['class_name'] = matched_control[2]['Class']
ctrl_criterion['parent'] = dialog.handle
ctrl_criterion['top_level_only'] = False
#ctrl_criterion['predicate_func'] = has_same_id
#print "CTRLCTRJL", ctrl_criterion
ctrl_hwnds = findwindows.find_windows(**ctrl_criterion)
if len(ctrl_hwnds) > 1:
same_ids = \
[hwnd for hwnd in ctrl_hwnds
if handleprops.controlid(hwnd) == \
matched_control[2]['ControlID']]
if len(same_ids) >= 1:
ctrl_hwnds = same_ids
try:
ctrl = controls.WrapHandle(ctrl_hwnds[0])
except IndexError:
print "-+-+=_" * 20
print found_criteria
raise
break
# it is possible that the dialog will not be found - so we
# should raise an error
if dialog is None:
raise findwindows.WindowNotFoundError()
if len(criteria_) == 2 and ctrl is None:
raise findwindows.WindowNotFoundError()
if ctrl:
return dialog, ctrl
else:
return (dialog, )
def find_windows(class_name = None,
class_name_re = None,
parent = None,
process = None,
title = None,
title_re = None,
top_level_only = True,
visible_only = True,
enabled_only = False,
best_match = None,
handle = None,
ctrl_index = None,
predicate_func = None,
active_only = False,
control_id = None,
):
"""Find windows based on criteria passed in
Possible values are:
* **class_name** Windows with this window class
* **class_name_re** Windows whose class match this regular expression
* **parent** Windows that are children of this
* **process** Windows running in this process
* **title** Windows with this Text
* **title_re** Windows whose Text match this regular expression
* **top_level_only** Top level windows only (default=True)
* **visible_only** Visible windows only (default=True)
* **enabled_only** Enabled windows only (default=True)
* **best_match** Windows with a title similar to this
* **handle** The handle of the window to return
* **ctrl_index** The index of the child window to return
* **active_only** Active windows only (default=False)
* **control_id** Windows with this control id
"""
# allow a handle to be passed in
# if it is present - just return it
if handle is not None:
return [handle, ]
if top_level_only:
# find the top level windows
windows = enum_windows()
# if we have been given a parent
if parent:
windows = [win for win in windows
if handleprops.parent(win) == parent]
# looking for child windows
else:
# if not given a parent look for all children of the desktop
if not parent:
parent = win32functions.GetDesktopWindow()
# look for all children of that parent
windows = enum_child_windows(parent)
# if the ctrl_index has been specified then just return
# that control
if ctrl_index is not None:
return [windows[ctrl_index]]
if control_id is not None and windows:
windows = [win for win in windows if
handleprops.controlid(win) == control_id]
if active_only:
gui_info = win32structures.GUITHREADINFO()
gui_info.cbSize = ctypes.sizeof(gui_info)
# get all the active windows (not just the specified process)
ret = win32functions.GetGUIThreadInfo(0, ctypes.byref(gui_info))
if not ret:
raise ctypes.WinError()
if gui_info.hwndActive in windows:
windows = [gui_info.hwndActive]
else:
windows = []
if class_name is not None and windows:
windows = [win for win in windows
if class_name == handleprops.classname(win)]
if class_name_re is not None and windows:
class_name_regex = re.compile(class_name_re)
windows = [win for win in windows
if class_name_regex.match(handleprops.classname(win))]
if process is not None and windows:
windows = [win for win in windows
if handleprops.processid(win) == process]
if title is not None and windows:
windows = [win for win in windows
if title == handleprops.text(win)]
elif title_re is not None and windows:
title_regex = re.compile(title_re)
windows = [win for win in windows
if title_regex.match(handleprops.text(win))]
if visible_only and windows:
windows = [win for win in windows if handleprops.isvisible(win)]
if enabled_only and windows:
windows = [win for win in windows if handleprops.isenabled(win)]
if best_match is not None and windows:
wrapped_wins = []
for win in windows:
try:
wrapped_wins.append(controls.WrapHandle(win))
except controls.InvalidWindowHandle:
# skip invalid handles - they have dissapeared
# since the list of windows was retrieved
pass
windows = findbestmatch.find_best_control_matches(
best_match, wrapped_wins)
# convert window back to handle
windows = [win.handle for win in windows]
if predicate_func is not None and windows:
windows = [win for win in windows if predicate_func(win)]
return windows