# GUI Application automation and testing library # Copyright (C) 2006-2018 Mark Mc Mahon and Contributors # https://github.com/pywinauto/pywinauto/graphs/contributors # http://pywinauto.readthedocs.io/en/latest/credits.html # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # * Neither the name of pywinauto nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ Classes that wrap the Windows Common controls .. implicitly document some private classes .. autoclass:: _toolbar_button :members: :show-inheritance: .. autoclass:: _treeview_element :members: :show-inheritance: .. autoclass:: _listview_item :members: :show-inheritance: """ from __future__ import print_function import time import ctypes from ctypes import wintypes import warnings import locale import six from .. import win32functions from .. import win32defines from .. import win32structures from .. import findbestmatch from ..remote_memory_block import RemoteMemoryBlock from . import hwndwrapper from ..timings import Timings from ..timings import wait_until from ..timings import TimeoutError from ..handleprops import is64bitprocess from ..sysinfo import is_x64_Python from .. import deprecated # Todo: I should return iterators from things like items() and texts() # to save building full lists all the time class _listview_item(object): """Wrapper around ListView items""" #---------------------------------------------------------------- def __init__(self, lv_ctrl, item_index, subitem_index=0): """Initialize the item""" self.listview_ctrl = lv_ctrl # ensure the item_index is an integer or # convert it to one self.item_index = self._as_item_index(item_index) self.subitem_index = subitem_index #self._as_parameter_ = self.item_index #----------------------------------------------------------- def _as_item_index(self, item): """Ensure that item is an item index If a string is passed in then it will be searched for in the list of item titles. """ index = item if isinstance(item, six.string_types): index = int((self.listview_ctrl.texts().index(item) - 1) / self.listview_ctrl.column_count()) return index #----------------------------------------------------------- def __eq__(self, other): """Return True if the parent control and the indexes are the same as the other.""" if isinstance(other, _listview_item): return self.listview_ctrl == other.listview_ctrl and \ self.item_index == other.item_index and \ self.subitem_index == other.subitem_index else: return False #----------------------------------------------------------- def __ne__(self, other): """Return True if not matched the parent control or an index.""" return not self == other #---------------------------------------------------------------- def _readitem(self): """Read the list view item""" # set up a memory block in the remote application remote_mem = RemoteMemoryBlock(self.listview_ctrl) # set up the item structure to get the text item = self.listview_ctrl.LVITEM() item.mask = \ win32defines.LVIF_TEXT | \ win32defines.LVIF_IMAGE | \ win32defines.LVIF_INDENT | \ win32defines.LVIF_STATE item.iItem = self.item_index item.iSubItem = self.subitem_index item.stateMask = wintypes.UINT(-1) item.cchTextMax = 2000 item.pszText = remote_mem.Address() + \ ctypes.sizeof(item) + 1 # Write the local LVITEM structure to the remote memory block remote_mem.Write(item) # Fill in the requested item retval = self.listview_ctrl.send_message( self.listview_ctrl.LVM_GETITEM, 0, # MSDN: wParam for LVM_GETITEM must be zero remote_mem) text = '' # if it succeeded if retval: remote_mem.Read(item) # Read the remote text string char_data = self.listview_ctrl.create_buffer(2000) remote_mem.Read(char_data, item.pszText) text = self.listview_ctrl.text_decode(char_data.value) else: raise RuntimeError( "We should never get to this part of ListView.get_item(), retval = " + str(retval) + ', GetLastError() = ' + str(ctypes.GetLastError()) + ', item_index = ' + str(self.item_index) + ', subitem_index = ' + str(self.subitem_index)) del remote_mem return item, text #---------------------------------------------------------------- def __getitem__(self, key): """Return property name""" warnings.warn('ListView item properties "text", "state", "image" and "indent" are deprecated! ' + 'Use methods text(), state(), image() and indent().', DeprecationWarning) item, text = self._readitem() if key == 'text': return text if key == 'state': return item.state if key == 'image': return item.iImage if key == 'indent': return item.iIndent raise KeyError('Incorrect property: "' + str(key) + '", can be "text", "state", "image" or "indent".') #---------------------------------------------------------------- def text(self): """Return the text of the item""" return self._readitem()[1] # Non PEP-8 alias Text = deprecated(text) #---------------------------------------------------------------- def item(self): """Return the item itself (LVITEM instance)""" return self._readitem()[0] # Non PEP-8 alias Item = deprecated(item) #---------------------------------------------------------------- def item_data(self): """Return the item data (dictionary)""" item_data = {} item, text = self._readitem() # and add it to the titles item_data['text'] = text item_data['state'] = item.state item_data['image'] = item.iImage item_data['indent'] = item.iIndent return item_data # Non PEP-8 alias ItemData = deprecated(item_data) #---------------------------------------------------------------- def state(self): """Return the state of the item""" return self.item().state # Non PEP-8 alias State = deprecated(state) #---------------------------------------------------------------- def image(self): """Return the image index of the item""" return self.item().iImage # Non PEP-8 alias Image = deprecated(image) #---------------------------------------------------------------- def indent(self): """Return the indent of the item""" return self.item().iIndent # Non PEP-8 alias Indent = deprecated(indent) #---------------------------------------------------------------- def rectangle(self, area="all"): """Return the rectangle of the item. Possible ``area`` values: * ``"all"`` Returns the bounding rectangle of the entire item, including the icon and label. * ``"icon"`` Returns the bounding rectangle of the icon or small icon. * ``"text"`` Returns the bounding rectangle of the item text. * ``"select"`` Returns the union of the "icon" and "text" rectangles, but excludes columns in report view. """ # set up a memory block in the remote application remote_mem = RemoteMemoryBlock(self.listview_ctrl) rect = win32structures.RECT() # If listview_ctrl has LVS_REPORT we can get access to subitems rectangles is_table = self.listview_ctrl.has_style(win32defines.LVS_REPORT) if area.lower() == "all" or not area: rect.left = win32defines.LVIR_BOUNDS elif area.lower() == "icon": rect.left = win32defines.LVIR_ICON elif area.lower() == "text": rect.left = win32defines.LVIR_LABEL elif area.lower() == "select": rect.left = win32defines.LVIR_BOUNDS if is_table else win32defines.LVIR_SELECTBOUNDS else: raise ValueError('Incorrect rectangle area of the list view item: "' + str(area) + '"') if is_table: # The one-based index of the subitem. rect.top = self.subitem_index # Write the local RECT structure to the remote memory block remote_mem.Write(rect) # Depends on subitems rectangles availability message = win32defines.LVM_GETSUBITEMRECT if is_table else win32defines.LVM_GETITEMRECT # Fill in the requested item retval = self.listview_ctrl.send_message( message, self.item_index, remote_mem) # If it's not succeeded if not retval: del remote_mem raise RuntimeError("Did not succeed in getting rectangle") rect = remote_mem.Read(rect) del remote_mem return rect # Non PEP-8 alias Rectangle = deprecated(rectangle) #---------------------------------------------------------------- def click(self, button="left", double=False, where="text", pressed=""): """Click on the list view item where can be any one of "all", "icon", "text", "select", "check" defaults to "text" """ self.ensure_visible() if where.lower() != "check": point_to_click = self.rectangle(area=where.lower()).mid_point() self.listview_ctrl.click( button, coords=(point_to_click.x, point_to_click.y), double=double, pressed=pressed) else: # Click on checkbox point_to_click = self.rectangle(area="icon").mid_point() point_to_click.y = self.rectangle(area="icon").bottom - 3 # Check ListView display mode # (to be able to process 'Full Row Details' mode separately remote_mem = RemoteMemoryBlock(self.listview_ctrl) hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click # Actually, there is no need to set hittest.iItem, because # send_message followed by remote_mem.Read always refreshes it #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) # Hittest flag checkbox_found = False if hittest.flags == win32defines.LVHT_ONITEMICON: # Large Icons, Small Icons, List, Details while not checkbox_found and point_to_click.x > 0: point_to_click.x -= 1 hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if hittest.flags == win32defines.LVHT_ONITEMSTATEICON: checkbox_found = True break elif hittest.flags == win32defines.LVHT_ONITEM: # Full Row Details warnings.warn("Full Row Details 'check' area is detected in experimental mode. Use carefully!") point_to_click.x = self.rectangle(area="icon").left - 8 # Check if point_to_click is still on item hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if hittest.flags == win32defines.LVHT_ONITEM: checkbox_found = True else: raise RuntimeError("Unexpected hit test flags value " + str(hittest.flags) + " trying to find checkbox") # Click on the found checkbox if checkbox_found: self.listview_ctrl.click( button, coords=(point_to_click.x, point_to_click.y), double=double, pressed=pressed) else: raise RuntimeError("Area ('check') not found for this list view item") return self # Non PEP-8 alias Click = deprecated(click) #---------------------------------------------------------------- def click_input(self, button="left", double=False, wheel_dist=0, where="text", pressed=""): """Click on the list view item where can be any one of "all", "icon", "text", "select", "check" defaults to "text" """ self.ensure_visible() if where.lower() != "check": point_to_click = self.rectangle(area=where.lower()).mid_point() self.listview_ctrl.click_input( button, coords=(point_to_click.x, point_to_click.y), double=double, wheel_dist=wheel_dist, pressed=pressed) else: # Click on checkbox point_to_click = self.rectangle(area="icon").mid_point() point_to_click.y = self.rectangle(area="icon").bottom - 3 # Check ListView display mode # (to be able to process 'Full Row Details' mode separately remote_mem = RemoteMemoryBlock(self.listview_ctrl) hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click # Actually, there is no need to set hittest.iItem, because # send_message followed by remote_mem.Read always refreshes it #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) # Hittest flag checkbox_found = False if hittest.flags == win32defines.LVHT_ONITEMICON: # Large Icons, Small Icons, List, Details while not checkbox_found and point_to_click.x > 0: point_to_click.x -= 1 hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if hittest.flags == win32defines.LVHT_ONITEMSTATEICON: checkbox_found = True break elif hittest.flags == win32defines.LVHT_ONITEM: # Full Row Details warnings.warn("Full Row Details 'check' area is detected in experimental mode. Use carefully!") point_to_click.x = self.rectangle(area="icon").left - 8 # Check if point_to_click is still on item hittest = win32structures.LVHITTESTINFO() hittest.pt = point_to_click #hittest.iItem = self.item_index hittest.iSubItem = self.subitem_index remote_mem.Write(hittest) self.listview_ctrl.send_message(win32defines.LVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if hittest.flags == win32defines.LVHT_ONITEM: checkbox_found = True else: raise RuntimeError("Unexpected hit test flags value " + str(hittest.flags) + " trying to find checkbox") # Click on the found checkbox if checkbox_found: self.listview_ctrl.click_input( button, coords=(point_to_click.x, point_to_click.y), double=double, wheel_dist=wheel_dist, pressed=pressed) else: raise RuntimeError("Area ('check') not found for this list view item") return self # Non PEP-8 alias ClickInput = deprecated(click_input) #---------------------------------------------------------------- def ensure_visible(self): """Make sure that the ListView item is visible""" if self.state() & win32defines.LVS_NOSCROLL: return None # scroll is disabled ret = self.listview_ctrl.send_message( win32defines.LVM_ENSUREVISIBLE, self.item_index, win32defines.FALSE) if ret != win32defines.TRUE: raise RuntimeError('Fail to make the list view item visible ' + '(item_index = ' + str(self.item_index) + ')') return self # Non PEP-8 alias EnsureVisible = deprecated(ensure_visible) #----------------------------------------------------------- def uncheck(self): """Uncheck the ListView item""" def index_to_state_image_mask(i): return i << 12 self.listview_ctrl.verify_actionable() lvitem = self.listview_ctrl.LVITEM() lvitem.mask = wintypes.UINT(win32defines.LVIF_STATE) lvitem.state = wintypes.UINT(index_to_state_image_mask(1)) # wintypes.UINT(0x1000) lvitem.stateMask = wintypes.UINT(win32defines.LVIS_STATEIMAGEMASK) remote_mem = RemoteMemoryBlock(self.listview_ctrl) remote_mem.Write(lvitem) retval = self.listview_ctrl.send_message( win32defines.LVM_SETITEMSTATE, self.item_index, remote_mem) if retval != win32defines.TRUE: raise ctypes.WinError() del remote_mem return self # Non PEP-8 alias UnCheck = deprecated(uncheck, deprecated_name='UnCheck') #----------------------------------------------------------- def check(self): """Check the ListView item""" def index_to_state_image_mask(i): return i << 12 self.listview_ctrl.verify_actionable() lvitem = self.listview_ctrl.LVITEM() lvitem.mask = wintypes.UINT(win32defines.LVIF_STATE) lvitem.state = wintypes.UINT(index_to_state_image_mask(2)) # wintypes.UINT(0x2000) lvitem.stateMask = wintypes.UINT(win32defines.LVIS_STATEIMAGEMASK) remote_mem = RemoteMemoryBlock(self.listview_ctrl) remote_mem.Write(lvitem) retval = self.listview_ctrl.send_message( win32defines.LVM_SETITEMSTATE, self.item_index, remote_mem) if retval != win32defines.TRUE: raise ctypes.WinError() del remote_mem return self # Non PEP-8 alias Check = deprecated(check) #----------------------------------------------------------- def is_checked(self): """Return whether the ListView item is checked or not""" state = self.listview_ctrl.send_message( win32defines.LVM_GETITEMSTATE, self.item_index, win32defines.LVIS_STATEIMAGEMASK) return state & 0x2000 == 0x2000 # Non PEP-8 alias IsChecked = deprecated(is_checked) #----------------------------------------------------------- def is_selected(self): """Return True if the item is selected""" return win32defines.LVIS_SELECTED == self.listview_ctrl.send_message( win32defines.LVM_GETITEMSTATE, self.item_index, win32defines.LVIS_SELECTED) # Non PEP-8 alias IsSelected = deprecated(is_selected) #----------------------------------------------------------- def is_focused(self): """Return True if the item has the focus""" return win32defines.LVIS_FOCUSED == self.listview_ctrl.send_message( win32defines.LVM_GETITEMSTATE, self.item_index, win32defines.LVIS_FOCUSED) # Non PEP-8 alias IsFocused = deprecated(is_focused) #----------------------------------------------------------- def _modify_selection(self, to_select): """Change the selection of the item to_select should be True to select the item and false to deselect the item """ self.listview_ctrl.verify_actionable() if self.item_index >= self.listview_ctrl.item_count(): raise IndexError("There are only %d items in the list view not %d" % (self.listview_ctrl.item_count(), self.item_index + 1)) # first we need to change the state of the item lvitem = self.listview_ctrl.LVITEM() lvitem.mask = wintypes.UINT(win32defines.LVIF_STATE) if to_select: lvitem.state = wintypes.UINT(win32defines.LVIS_FOCUSED | win32defines.LVIS_SELECTED) lvitem.stateMask = wintypes.UINT(win32defines.LVIS_FOCUSED | win32defines.LVIS_SELECTED) remote_mem = RemoteMemoryBlock(self.listview_ctrl) remote_mem.Write(lvitem, size=ctypes.sizeof(lvitem)) retval = self.listview_ctrl.send_message( win32defines.LVM_SETITEMSTATE, self.item_index, remote_mem) if retval != win32defines.TRUE: raise ctypes.WinError() # ('retval = ' + str(retval)) del remote_mem # now we need to notify the parent that the state has changed nmlv = win32structures.NMLISTVIEW() nmlv.hdr.hwndFrom = self.listview_ctrl.handle nmlv.hdr.idFrom = self.listview_ctrl.control_id() nmlv.hdr.code = win32defines.LVN_ITEMCHANGING nmlv.iItem = self.item_index #nmlv.iSubItem = 0 nmlv.uNewState = win32defines.LVIS_SELECTED #nmlv.uOldState = 0 nmlv.uChanged = win32defines.LVIS_SELECTED nmlv.ptAction = win32structures.POINT() new_remote_mem = RemoteMemoryBlock(self.listview_ctrl, size=ctypes.sizeof(nmlv)) new_remote_mem.Write(nmlv, size=ctypes.sizeof(nmlv)) retval = self.listview_ctrl.parent().send_message( win32defines.WM_NOTIFY, self.listview_ctrl.control_id(), new_remote_mem) #if retval != win32defines.TRUE: # print('retval = ' + str(retval)) # raise ctypes.WinError() del new_remote_mem win32functions.WaitGuiThreadIdle(self.listview_ctrl.handle) time.sleep(Timings.after_listviewselect_wait) #----------------------------------------------------------- def select(self): """Mark the item as selected The ListView control must be enabled and visible before an Item can be selected otherwise an exception is raised """ self._modify_selection(True) return self # Non PEP-8 alias Select = deprecated(select) #----------------------------------------------------------- def deselect(self): """Mark the item as not selected The ListView control must be enabled and visible before an Item can be selected otherwise an exception is raised """ self._modify_selection(False) return self # Non PEP-8 alias Deselect = deprecated(deselect) #----------------------------------------------------------- def inplace_control(self, friendly_class_name=""): """Return the editor HwndWrapper of the item Possible ``friendly_class_name`` values: * ``""`` Return the first appeared in-place control * ``"friendlyclassname"`` Returns editor with particular friendlyclassname """ # If currently editing in this item or some other self.listview_ctrl.type_keys("{ENTER}") # Get a list of visible controls parent_dlg = self.listview_ctrl.top_level_parent() list_before_click = [w.handle for w in parent_dlg.element_info.descendants() if w.visible] # After a click on the visible list an editable element should appear self.click_input(double=True) def get_list_after_click(): return [w.handle for w in parent_dlg.element_info.descendants() if w.visible] try: def check_func(): return len(get_list_after_click()) > len(list_before_click) wait_until(Timings.listviewitemcontrol_timeout, 0.05, check_func) except TimeoutError: raise TimeoutError(("In-place-edit control for item ({0},{1}) not visible, possible it not editable, " + "try to set slower timings").format(self.item_index, self.subitem_index)); possible_inplace_ctrls = set(get_list_after_click()) - set(list_before_click) for handle in possible_inplace_ctrls: hwnd_friendly_class = hwndwrapper.HwndWrapper(handle).friendlyclassname if (friendly_class_name == "" or hwnd_friendly_class == friendly_class_name): return hwndwrapper.HwndWrapper(handle) names_list = [hwndwrapper.HwndWrapper(handle).friendlyclassname for handle in possible_inplace_ctrls] raise RuntimeError('In-place-edit control "{2}" for item ({0},{1}) not found in list {3}'.format( self.item_index, self.subitem_index, friendly_class_name, names_list)); #==================================================================== class ListViewWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows ListView common control This class derives from HwndWrapper - so has all the methods o that class also **see** hwndwrapper.HwndWrapper_ .. _hwndwrapper.HwndWrapper: class-pywinauto.controls.hwndwrapper.HwndWrapper.html """ friendlyclassname = "ListView" windowclasses = [ "SysListView32", r"WindowsForms\d*\.SysListView32\..*", "TSysListView", "ListView.*WndClass", ] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(ListViewWrapper, self).__init__(hwnd) if self.is_unicode(): self.create_buffer = ctypes.create_unicode_buffer if is64bitprocess(self.process_id()) or not is_x64_Python(): self.LVCOLUMN = win32structures.LVCOLUMNW self.LVITEM = win32structures.LVITEMW else: self.LVCOLUMN = win32structures.LVCOLUMNW32 self.LVITEM = win32structures.LVITEMW32 self.LVM_GETITEM = win32defines.LVM_GETITEMW self.LVM_GETCOLUMN = win32defines.LVM_GETCOLUMNW self.text_decode = lambda v: v else: self.create_buffer = ctypes.create_string_buffer if is64bitprocess(self.process_id()) or not is_x64_Python(): self.LVCOLUMN = win32structures.LVCOLUMNW self.LVITEM = win32structures.LVITEMW else: self.LVCOLUMN = win32structures.LVCOLUMNW32 self.LVITEM = win32structures.LVITEMW32 self.LVM_GETCOLUMN = win32defines.LVM_GETCOLUMNA self.LVM_GETITEM = win32defines.LVM_GETITEMA self.text_decode = lambda v: v.decode(locale.getpreferredencoding()) @property def writable_props(self): """Extend default properties list.""" props = super(ListViewWrapper, self).writable_props props.extend(['column_count', 'item_count', 'columns', 'items', ]) return props #----------------------------------------------------------- def column_count(self): """Return the number of columns""" if self.get_header_control() is not None: return self.get_header_control().item_count() return 0 # Non PEP-8 alias ColumnCount = deprecated(column_count) #----------------------------------------------------------- def item_count(self): """The number of items in the ListView""" return self.send_message(win32defines.LVM_GETITEMCOUNT) # Non PEP-8 alias ItemCount = deprecated(item_count) #----------------------------------------------------------- def get_header_control(self): """Returns the Header control associated with the ListView""" try: return hwndwrapper.HwndWrapper( self.send_message(win32defines.LVM_GETHEADER)) except hwndwrapper.InvalidWindowHandle: return None # Non PEP-8 alias GetHeaderControl = deprecated(get_header_control) #----------------------------------------------------------- def get_column(self, col_index): """Get the information for a column of the ListView""" col_props = {} col = self.LVCOLUMN() col.mask = \ win32defines.LVCF_FMT | \ win32defines.LVCF_IMAGE | \ win32defines.LVCF_ORDER | \ win32defines.LVCF_SUBITEM | \ win32defines.LVCF_TEXT | \ win32defines.LVCF_WIDTH remote_mem = RemoteMemoryBlock(self) col.cchTextMax = 2000 col.pszText = remote_mem.Address() + ctypes.sizeof(col) + 1 # put the information in the memory that the # other process can read/write remote_mem.Write(col) # ask the other process to update the information retval = self.send_message( self.LVM_GETCOLUMN, col_index, remote_mem) col = remote_mem.Read(col) # if that succeeded then there was a column if retval: col = remote_mem.Read(col) text = self.create_buffer(2000) remote_mem.Read(text, col.pszText) col_props['order'] = col.iOrder col_props['text'] = self.text_decode(text.value) col_props['format'] = col.fmt col_props['width'] = col.cx col_props['image'] = col.iImage col_props['subitem'] = col.iSubItem del remote_mem return col_props # Non PEP-8 alias GetColumn = deprecated(get_column) #----------------------------------------------------------- def columns(self): """Get the information on the columns of the ListView""" cols = [] for i in range(0, self.column_count()): cols.append(self.get_column(i)) return cols # Non PEP-8 alias Columns = deprecated(columns) #----------------------------------------------------------- def column_widths(self): """Return a list of all the column widths""" return [col['width'] for col in self.columns()] # Non PEP-8 alias ColumnWidths = deprecated(column_widths) #----------------------------------------------------------- def get_item_rect(self, item_index): """Return the bounding rectangle of the list view item""" warnings.warn("Use get_item(item).rectangle() instead", DeprecationWarning) return self.get_item(item_index).rectangle() # Non PEP-8 alias GetItemRect = deprecated(get_item_rect) #----------------------------------------------------------- def get_item(self, item_index, subitem_index=0): """Return the item of the list view" * **item_index** Can be either an index of the item or a string with the text of the item you want returned. * **subitem_index** A zero based index of the item you want returned. Defaults to 0. """ return _listview_item(self, item_index, subitem_index) item = get_item # this is an alias to be consistent with other content elements # Non PEP-8 alias Item = deprecated(item) # Non PEP-8 alias GetItem = deprecated(get_item) #----------------------------------------------------------- def items(self): """Get all the items in the list view""" colcount = self.column_count() if not colcount: colcount = 1 items = [] # now get the item values... # for each of the rows for item_index in range(0, self.item_count()): # and each of the columns for that row for subitem_index in range(0, colcount): # get the item #yield self.get_item(item_index, subitem_index) # return iterator items.append(self.get_item(item_index, subitem_index)) return items # Non PEP-8 alias Items = deprecated(items) #----------------------------------------------------------- def texts(self): """Get the texts for the ListView control""" texts = [self.window_text()] texts.extend([item.text() for item in self.items()]) return texts #----------------------------------------------------------- def uncheck(self, item): """Uncheck the ListView item""" warnings.warn("Use get_item(item).uncheck() instead", DeprecationWarning) return self.get_item(item).uncheck() # Non PEP-8 alias UnCheck = deprecated(uncheck, deprecated_name='UnCheck') #----------------------------------------------------------- def check(self, item): """Check the ListView item""" warnings.warn("Use get_item(item).check() instead", DeprecationWarning) return self.get_item(item).check() # Non PEP-8 alias Check = deprecated(check) #----------------------------------------------------------- def is_checked(self, item): """Return whether the ListView item is checked or not""" warnings.warn("Use get_item(item).is_checked() instead", DeprecationWarning) return self.get_item(item).is_checked() # Non PEP-8 alias IsChecked = deprecated(is_checked) #----------------------------------------------------------- def is_selected(self, item): """Return True if the item is selected""" warnings.warn("Use get_item(item).is_selected() instead", DeprecationWarning) return self.get_item(item).is_selected() # Non PEP-8 alias IsSelected = deprecated(is_selected) #----------------------------------------------------------- def is_focused(self, item): """Return True if the item has the focus""" warnings.warn("Use get_item(item).is_focused() instead", DeprecationWarning) return self.get_item(item).is_focused() # Non PEP-8 alias IsFocused = deprecated(is_focused) #----------------------------------------------------------- def select(self, item): """Mark the item as selected The ListView control must be enabled and visible before an Item can be selected otherwise an exception is raised """ warnings.warn("Use get_item(item).select() instead", DeprecationWarning) return self.get_item(item).select() # Non PEP-8 alias Select = deprecated(select) #----------------------------------------------------------- def deselect(self, item): """Mark the item as not selected The ListView control must be enabled and visible before an Item can be selected otherwise an exception is raised """ warnings.warn("Use get_item(item).deselect() instead", DeprecationWarning) return self.get_item(item).deselect() # Naming is not clear - so create an alias. #UnSelect = deselect # Non PEP-8 alias Deselect = deprecated(deselect) #----------------------------------------------------------- def get_selected_count(self): """Return the number of selected items""" return self.send_message(win32defines.LVM_GETSELECTEDCOUNT) # Non PEP-8 alias GetSelectedCount = deprecated(get_selected_count) #==================================================================== class _treeview_element(object): """Wrapper around TreeView items""" #---------------------------------------------------------------- def __init__(self, elem, tv_handle): """Initialize the item""" self.tree_ctrl = tv_handle self.elem = elem self._as_parameter_ = self.elem #---------------------------------------------------------------- def text(self): """Return the text of the item""" return self._readitem()[1] # Non PEP-8 alias Text = deprecated(text) #---------------------------------------------------------------- def item(self): """Return the item itself""" return self._readitem()[0] # Non PEP-8 alias Item = deprecated(item) #---------------------------------------------------------------- def state(self): """Return the state of the item""" return self.item().state # Non PEP-8 alias State = deprecated(state) #----------------------------------------------------------- def is_checked(self): """Return whether the TreeView item is checked or not""" state = self.tree_ctrl.send_message( win32defines.TVM_GETITEMSTATE, self.elem, win32defines.TVIS_STATEIMAGEMASK) return state & 0x2000 == 0x2000 # Non PEP-8 alias IsChecked = deprecated(is_checked) #---------------------------------------------------------------- def client_rect(self, text_area_rect=True): """Return a rectangle of a text area of the item If **text_area_rect** is set to False then it will return a rectangle for the whole item (usually left is equal to 0). Defaults to True - which returns just the rectangle of the text of the item """ remote_mem = RemoteMemoryBlock(self.tree_ctrl) # this is a bit weird # we have to write the element handle # but we read the rectangle afterwards! remote_mem.Write(win32structures.LPARAM(self.elem)) ret = self.tree_ctrl.send_message( win32defines.TVM_GETITEMRECT, text_area_rect, remote_mem) # the item is not visible if not ret: rect = None else: # OK - it's visible so read it rect = win32structures.RECT() remote_mem.Read(rect) del remote_mem return rect # Non PEP-8 alias ClientRect = deprecated(client_rect) #---------------------------------------------------------------- def click(self, button="left", double=False, where="text", pressed=""): """Click on the treeview item where can be any one of "text", "icon", "button", "check" defaults to "text" """ self.ensure_visible() # find the text rectangle for the item, point_to_click = self.client_rect().mid_point() if where.lower() != "text": remote_mem = RemoteMemoryBlock(self.tree_ctrl) point_to_click.x = self.client_rect().left found = False while not found and point_to_click.x >= 0: hittest = win32structures.TVHITTESTINFO() hittest.pt = point_to_click hittest.hItem = self.elem remote_mem.Write(hittest) self.tree_ctrl.send_message(win32defines.TVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if where.lower() == 'button' and \ hittest.flags == win32defines.TVHT_ONITEMBUTTON: found = True break if where.lower() == 'icon' and \ hittest.flags == win32defines.TVHT_ONITEMICON: found = True break if where.lower() == 'check' and \ hittest.flags == win32defines.TVHT_ONITEMSTATEICON: found = True break point_to_click.x -= 1 if not found: raise RuntimeError("Area ('{}') not found for this tree view item".format(where)) self.tree_ctrl.click( button, coords=(point_to_click.x, point_to_click.y), double=double, pressed=pressed) return self # XXX: somehow it works for 64-bit explorer.exe on Win8.1, # but it doesn't work for 32-bit ControlSpyV6.exe #absolute = True) # TODO: if we use click instead of clickInput - then we need to tell the # treeview to update itself #self.tree_ctrl. # Non PEP-8 alias Click = deprecated(click) #---------------------------------------------------------------- def click_input(self, button="left", double=False, wheel_dist=0, where="text", pressed=""): """Click on the treeview item where can be any one of "text", "icon", "button", "check" defaults to "text" """ self.ensure_visible() # find the text rectangle for the item, point_to_click = self.client_rect().mid_point() if where.lower() != "text": remote_mem = RemoteMemoryBlock(self.tree_ctrl) point_to_click.x = self.client_rect().left found = False while not found and point_to_click.x >= 0: hittest = win32structures.TVHITTESTINFO() hittest.pt = point_to_click hittest.hItem = self.elem remote_mem.Write(hittest) self.tree_ctrl.send_message(win32defines.TVM_HITTEST, 0, remote_mem) remote_mem.Read(hittest) if where.lower() == 'button' and \ hittest.flags == win32defines.TVHT_ONITEMBUTTON: found = True break if where.lower() == 'icon' and \ hittest.flags == win32defines.TVHT_ONITEMICON: found = True break if where.lower() == 'check' and \ hittest.flags == win32defines.TVHT_ONITEMSTATEICON: found = True break point_to_click.x -= 1 if not found: raise RuntimeError("Area ('%s') not found for this tree view item" % where) self.tree_ctrl.click_input( button, coords=(point_to_click.x, point_to_click.y), double=double, wheel_dist=wheel_dist, pressed=pressed) return self # Non PEP-8 alias ClickInput = deprecated(click_input) #---------------------------------------------------------------- def start_dragging(self, button='left', pressed=''): """Start dragging the item""" #self.ensure_visible() # find the text rectangle for the item rect = self.client_rect() point_to_click = rect.mid_point() #self.tree_ctrl.set_focus() self.tree_ctrl.press_mouse_input( button, coords=(point_to_click.x, point_to_click.y), pressed=pressed, absolute=False) for i in range(5): self.tree_ctrl.move_mouse_input( coords=(rect.left + i, rect.top), pressed=pressed, absolute=False) return self # Non PEP-8 alias StartDragging = deprecated(start_dragging) #---------------------------------------------------------------- def drop(self, button='left', pressed=''): """Drop at the item""" #self.ensure_visible() # find the text rectangle for the item point_to_click = self.client_rect().mid_point() self.tree_ctrl.move_mouse_input( coords=(point_to_click.x, point_to_click.y), pressed=pressed, absolute=False) time.sleep(Timings.drag_n_drop_move_mouse_wait) self.tree_ctrl.release_mouse_input( button, coords=(point_to_click.x, point_to_click.y), pressed=pressed, absolute=False) time.sleep(Timings.after_drag_n_drop_wait) return self # Non PEP-8 alias Drop = deprecated(drop) #---------------------------------------------------------------- def collapse(self): """Collapse the children of this tree view item""" self.tree_ctrl.send_message( win32defines.TVM_EXPAND, win32defines.TVE_COLLAPSE, self.elem) return self # Non PEP-8 alias Collapse = deprecated(collapse) #---------------------------------------------------------------- def expand(self): """Expand the children of this tree view item""" self.tree_ctrl.send_message( win32defines.TVM_EXPAND, win32defines.TVE_EXPAND, self.elem) return self # Non PEP-8 alias Expand = deprecated(expand) #---------------------------------------------------------------- def children(self): """Return the direct children of this control""" if self.item().cChildren not in (0, 1): print("##### not dealing with that TVN_GETDISPINFO stuff yet") # No children #if self.__item.cChildren == 0: # pass children_elements = [] if self.item().cChildren == 1: # Get the first child of this element child_elem = self.tree_ctrl.send_message( win32defines.TVM_GETNEXTITEM, win32defines.TVGN_CHILD, self.elem) if child_elem: children_elements.append(_treeview_element(child_elem, self.tree_ctrl)) # now get all the next children while True: next_child = children_elements[-1].next_item() if next_child is not None: children_elements.append(next_child) else: break else: return [] #raise ctypes.WinError() return children_elements # Non PEP-8 alias Children = deprecated(children) #---------------------------------------------------------------- def next_item(self): """Return the next item""" # get the next element next_elem = self.tree_ctrl.send_message( win32defines.TVM_GETNEXTITEM, win32defines.TVGN_NEXT, self.elem) if next_elem: return _treeview_element(next_elem, self.tree_ctrl) return None # don't raise - as it just meant that there was no # next #else: # raise ctypes.WinError() # Non PEP-8 alias Next = deprecated(next_item, deprecated_name='Next') #---------------------------------------------------------------- def sub_elements(self): """Return the list of children of this control""" sub_elems = [] for child in self.children(): sub_elems.append(child) sub_elems.extend(child.sub_elements()) return sub_elems # Non PEP-8 alias SubElements = deprecated(sub_elements) #---------------------------------------------------------------- def get_child(self, child_spec, exact=False): """Return the child item of this item Accepts either a string or an index. If a string is passed then it returns the child item with the best match for the string. """ #print child_spec if isinstance(child_spec, six.string_types): texts = [c.text() for c in self.children()] if exact: if child_spec in texts: index = texts.index(child_spec) else: raise IndexError('There is no child equal to "' + str(child_spec) + '" in ' + str(texts)) else: indices = range(0, len(texts)) index = findbestmatch.find_best_match( child_spec, texts, indices, limit_ratio=.6) #if len(matching) > 1 : # raise RuntimeError( # "There are multiple children that match that spec '%s'"% # child_spec) else: index = child_spec return self.children()[index] # Non PEP-8 alias GetChild = deprecated(get_child) #---------------------------------------------------------------- def ensure_visible(self): """Make sure that the TreeView item is visible""" self.tree_ctrl.send_message( win32defines.TVM_ENSUREVISIBLE, win32defines.TVGN_CARET, self.elem) win32functions.WaitGuiThreadIdle(self.tree_ctrl.handle) return self # Non PEP-8 alias EnsureVisible = deprecated(ensure_visible) #---------------------------------------------------------------- def select(self): """Select the TreeView item""" # http://stackoverflow.com/questions/14111333/treeview-set-default-select-item-and-highlight-blue-this-item # non-focused TreeView can ignore TVM_SELECTITEM self.tree_ctrl.set_focus() retval = self.tree_ctrl.send_message( win32defines.TVM_SELECTITEM, # message win32defines.TVGN_CARET, # how to select self.elem) # item to select if retval != win32defines.TRUE: raise ctypes.WinError() return self # Non PEP-8 alias Select = deprecated(select) #---------------------------------------------------------------- def is_selected(self): """Indicate that the TreeView item is selected or not""" return win32defines.TVIS_SELECTED == (win32defines.TVIS_SELECTED & self.state()) # Non PEP-8 alias IsSelected = deprecated(is_selected) #---------------------------------------------------------------- def is_expanded(self): """Indicate that the TreeView item is selected or not""" return win32defines.TVIS_EXPANDED == (win32defines.TVIS_EXPANDED & self.state()) # Non PEP-8 alias IsExpanded = deprecated(is_expanded) #---------------------------------------------------------------- def _readitem(self): """Read the treeview item""" remote_mem = RemoteMemoryBlock(self.tree_ctrl) if is64bitprocess(self.tree_ctrl.process_id()) or not is_x64_Python(): item = win32structures.TVITEMW() else: item = win32structures.TVITEMW32() item.mask = win32defines.TVIF_TEXT | \ win32defines.TVIF_HANDLE | \ win32defines.TVIF_CHILDREN | \ win32defines.TVIF_STATE # set the address for the text item.pszText = remote_mem.Address() + ctypes.sizeof(item) + 16 item.cchTextMax = 2000 item.hItem = self.elem item.stateMask = wintypes.UINT(-1) # Write the local TVITEM structure to the remote memory block remote_mem.Write(item) # read the entry retval = self.tree_ctrl.send_message( win32defines.TVM_GETITEMW, 0, remote_mem) text = '' if retval: remote_mem.Read(item) #self.__item = item # Read the remote text string char_data = ctypes.create_unicode_buffer(2000) remote_mem.Read(char_data, item.pszText) text = char_data.value else: # seems that this may not always be correct raise ctypes.WinError() return item, text #==================================================================== class TreeViewWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows TreeView common control""" friendlyclassname = "TreeView" windowclasses = [ "SysTreeView32", r"WindowsForms\d*\.SysTreeView32\..*", "TTreeView", "TreeList.TreeListCtrl"] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(TreeViewWrapper, self).__init__(hwnd) @property def writable_props(self): """Extend default properties list.""" props = super(TreeViewWrapper, self).writable_props props.extend(['item_count']) return props #---------------------------------------------------------------- def item_count(self): """Return the count of the items in the treeview""" return self.send_message(win32defines.TVM_GETCOUNT) # Non PEP-8 alias ItemCount = deprecated(item_count) #---------------------------------------------------------------- def texts(self): """Return all the text for the tree view""" texts = [self.window_text(), ] if self.item_count(): texts.append(self.tree_root().text()) elements = self.tree_root().sub_elements() texts.extend([elem.text() for elem in elements]) return texts #---------------------------------------------------------------- def tree_root(self): """Return the root element of the tree view""" # get the root item: root_elem = self.send_message( win32defines.TVM_GETNEXTITEM, win32defines.TVGN_ROOT) # Sometimes there is no root element if not root_elem: return None return _treeview_element(root_elem, self) # Non PEP-8 alias Root = deprecated(tree_root, deprecated_name='Root') #---------------------------------------------------------------- def roots(self): """Get root items of the control""" roots = [] cur_elem = self.tree_root() while cur_elem: roots.append(cur_elem) cur_elem = cur_elem.next_item() return roots # Non PEP-8 alias Roots = deprecated(roots) #---------------------------------------------------------------- def get_properties(self): """Get the properties for the control as a dictionary""" props = super(TreeViewWrapper, self).get_properties() props['item_count'] = self.item_count() return props #---------------------------------------------------------------- def get_item(self, path, exact=False): r"""Read the TreeView item * **path** the path to the item to return. This can be one of the following: * A string separated by \\ characters. The first character must be \\. This string is split on the \\ characters and each of these is used to find the specific child at each level. The \\ represents the root item - so you don't need to specify the root itself. * A list/tuple of strings - The first item should be the root element. * A list/tuple of integers - The first item the index which root to select. """ # work is just based on integers for now if not self.item_count(): return None # Ensure the path is absolute if isinstance(path, six.string_types): if not path.startswith("\\"): raise RuntimeError( "Only absolute paths allowed - " "please start the path with \\") path = path.split("\\")[1:] current_elem = None # find the correct root elem if isinstance(path[0], int): current_elem = self.roots()[path[0]] else: roots = self.roots() texts = [r.text() for r in roots] #not used var: indices = range(0, len(texts)) if exact: if path[0] in texts: current_elem = roots[texts.index(path[0])] else: raise IndexError("There is no root element equal to '{0}'".format(path[0])) else: try: current_elem = findbestmatch.find_best_match( path[0], texts, roots, limit_ratio=.6) except IndexError: raise IndexError("There is no root element similar to '{0}'".format(path[0])) # get the correct lowest level item # current_elem.get_child # for i in range(0, path[0]): # current_elem = current_elem.next_item() # # if current_elem is None: # raise IndexError("Root Item '%s' does not have %d sibling(s)"% # (self.tree_root().window_text(), i + 1)) # # remove the first (empty) item and the root element as we have # dealt with it (string or integer) path = path[1:] # now for each of the lower levels # just index into it's children for child_spec in path: # ensure that the item is expanded (as this is sometimes required # for loading the tree view branches current_elem.expand() try: current_elem = current_elem.get_child(child_spec, exact) except IndexError: if isinstance(child_spec, six.string_types): raise IndexError("Item '%s' does not have a child '%s'" % (current_elem.text(), child_spec)) else: raise IndexError("Item '%s' does not have %d children" % (current_elem.text(), child_spec + 1)) # self.send_message_timeout( # win32defines.TVM_EXPAND, # win32defines.TVE_EXPAND, # current_elem) return current_elem item = get_item # this is an alias to be consistent with other content elements # Non PEP-8 alias Item = deprecated(item) # Non PEP-8 alias GetItem = deprecated(get_item) #---------------------------------------------------------------- def select(self, path): """Select the treeview item""" # http://stackoverflow.com/questions/14111333/treeview-set-default-select-item-and-highlight-blue-this-item # non-focused TreeView can ignore TVM_SELECTITEM self.set_focus() elem = self.get_item(path) retval = self.send_message( win32defines.TVM_SELECTITEM, # message win32defines.TVGN_CARET, # how to select elem.elem) # item to select if retval != win32defines.TRUE: raise ctypes.WinError() #win32functions.WaitGuiThreadIdle(self.handle) #time.sleep(Timings.after_treeviewselect_wait) # Non PEP-8 alias Select = deprecated(select) #----------------------------------------------------------- def is_selected(self, path): """Return True if the item is selected""" return win32defines.TVIS_SELECTED == (win32defines.TVIS_SELECTED & self.get_item(path).state()) # Non PEP-8 alias IsSelected = deprecated(is_selected) #---------------------------------------------------------------- def ensure_visible(self, path): """Make sure that the TreeView item is visible""" elem = self.get_item(path) return elem.ensure_visible() # Non PEP-8 alias EnsureVisible = deprecated(ensure_visible) #---------------------------------------------------------------- def print_items(self): """Print all items with line indents""" self.text = self.window_text() + "\n" def print_one_level(item, ident): """Get texts for the item and its children""" self.text += " " * ident + item.text() + "\n" for child in item.children(): print_one_level(child, ident + 1) for root in self.roots(): print_one_level(root, 0) return self.text # Non PEP-8 alias PrintItems = deprecated(print_items) # #----------------------------------------------------------- # def uncheck(self, path): # """Uncheck the ListView item""" # self.verify_actionable() # # elem = self.get_item(path) # ## lvitem = win32structures.LVITEMW() ## ## lvitem.mask = win32defines.LVIF_STATE ## lvitem.state = 0x1000 ## lvitem.stateMask = win32defines.LVIS_STATEIMAGEMASK ## ## remote_mem = RemoteMemoryBlock(self) ## remote_mem.Write(lvitem) ## ## self.send_message( ## win32defines.LVM_SETITEMSTATE, item, remote_mem) ## ## del remote_mem # # # #----------------------------------------------------------- # def check(self, path): # """Check the ListView item""" # self.verify_actionable() # # elem = self.get_item(path) # # #lvitem = win32structures.LVITEMW() # # lvitem.mask = win32defines.LVIF_STATE # lvitem.state = 0x2000 # lvitem.stateMask = win32defines.LVIS_STATEIMAGEMASK # # remote_mem = RemoteMemoryBlock(self) # remote_mem.Write(lvitem) # # self.send_message( # win32defines.LVM_SETITEMSTATE, item, remote_mem) # # del remote_mem # # #----------------------------------------------------------- # def is_checked(self, path): # """Return whether the ListView item is checked or not""" # elem = self.get_item(path) # # elem.state # # state = self.send_message( # win32defines.LVM_GETITEMSTATE, # item, # win32defines.LVIS_STATEIMAGEMASK) # # return state & 0x2000 #==================================================================== class HeaderWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows ListView Header common control""" friendlyclassname = "Header" windowclasses = ["SysHeader32", "msvb_lib_header"] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(HeaderWrapper, self).__init__(hwnd) #---------------------------------------------------------------- def item_count(self): """Return the number of columns in this header""" # get the number of items in the header... return self.send_message(win32defines.HDM_GETITEMCOUNT) # Non PEP-8 alias ItemCount = deprecated(item_count) #---------------------------------------------------------------- def get_column_rectangle(self, column_index): """Return the rectangle for the column specified by column_index""" remote_mem = RemoteMemoryBlock(self) # get the column rect rect = win32structures.RECT() remote_mem.Write(rect) retval = self.send_message( win32defines.HDM_GETITEMRECT, column_index, remote_mem) if retval: rect = remote_mem.Read(rect) else: raise ctypes.WinError() del remote_mem return rect # Non PEP-8 alias GetColumnRectangle = deprecated(get_column_rectangle) #---------------------------------------------------------------- def client_rects(self): """Return all the client rectangles for the header control""" rects = [self.client_rect(), ] for col_index in range(0, self.item_count()): rects.append(self.get_column_rectangle(col_index)) return rects #---------------------------------------------------------------- def get_column_text(self, column_index): """Return the text for the column specified by column_index""" remote_mem = RemoteMemoryBlock(self) item = win32structures.HDITEMW() item.mask = win32defines.HDI_FORMAT | \ win32defines.HDI_WIDTH | \ win32defines.HDI_TEXT # | HDI_ORDER item.cchTextMax = 2000 # set up the pointer to the text # it should be at the item.pszText = remote_mem.Address() + ctypes.sizeof(item) + 1 # put the information in the memory that the # other process can read/write remote_mem.Write(item) # ask the other process to update the information retval = self.send_message( win32defines.HDM_GETITEMW, column_index, remote_mem) if retval: item = remote_mem.Read(item) # Read the remote text string char_data = ctypes.create_unicode_buffer(2000) remote_mem.Read(char_data, item.pszText) return char_data.value return None # Non PEP-8 alias GetColumnText = deprecated(get_column_text) #---------------------------------------------------------------- def texts(self): """Return the texts of the Header control""" texts = [self.window_text(), ] for i in range(0, self.item_count()): texts.append(self.get_column_text(i)) return texts # #---------------------------------------------------------------- # def _fill_header_info(self): # """Get the information from the header control""" # remote_mem = RemoteMemoryBlock(self) # # for col_index in range(0, self.Count()): # # item = win32structures.HDITEMW() # item.mask = win32defines.HDI_FORMAT | \ # win32defines.HDI_WIDTH | \ # win32defines.HDI_TEXT #| HDI_ORDER # item.cchTextMax = 2000 # # # set up the pointer to the text # # it should be at the # item.pszText = remote_mem.Address() + ctypes.sizeof(item) + 1 # # # put the information in the memory that the # # other process can read/write # remote_mem.Write(item) # # # ask the other process to update the information # retval = self.send_message( # win32defines.HDM_GETITEMW, # col_index, # remote_mem) # # if retval: # item = remote_mem.Read(item) # # # Read the remote text string # charData = ctypes.create_unicode_buffer(2000) # remote_mem.Read(charData, item.pszText) # self._extra_texts.append(charData.value) #==================================================================== class StatusBarWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Status Bar common control""" friendlyclassname = "StatusBar" windowclasses = [ "msctls_statusbar32", ".*StatusBar", r"WindowsForms\d*\.msctls_statusbar32\..*"] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(StatusBarWrapper, self).__init__(hwnd) @property def writable_props(self): """Extend default properties list.""" props = super(StatusBarWrapper, self).writable_props props.extend(['border_widths', 'part_count', 'part_right_edges', ]) return props #---------------------------------------------------------------- def border_widths(self): """Return the border widths of the StatusBar A dictionary of the 3 available widths is returned: Horizontal - the horizontal width Vertical - The width above and below the status bar parts Inter - The width between parts of the status bar """ remote_mem = RemoteMemoryBlock(self) # get the borders for each of the areas there can be a border. borders = (ctypes.c_int * 3)() remote_mem.Write(borders) self.send_message( win32defines.SB_GETBORDERS, 0, remote_mem ) borders = remote_mem.Read(borders) borders_widths = {} borders_widths['Horizontal'] = borders[0] borders_widths['Vertical'] = borders[1] borders_widths['Inter'] = borders[2] del remote_mem return borders_widths # Non PEP-8 alias BorderWidths = deprecated(border_widths) #---------------------------------------------------------------- def part_count(self): """Return the number of parts""" # get the number of parts for this status bar return self.send_message( win32defines.SB_GETPARTS, 0, 0) # Non PEP-8 alias PartCount = deprecated(part_count) #---------------------------------------------------------------- def part_right_edges(self): """Return the widths of the parts""" remote_mem = RemoteMemoryBlock(self) # get the number of parts for this status bar parts = (ctypes.c_int * self.part_count())() remote_mem.Write(parts) self.send_message( win32defines.SB_GETPARTS, self.part_count(), remote_mem ) parts = remote_mem.Read(parts) del remote_mem return [int(part) for part in parts] # Non PEP-8 alias PartRightEdges = deprecated(part_right_edges) #---------------------------------------------------------------- def get_part_rect(self, part_index): """Return the rectangle of the part specified by part_index""" if part_index >= self.part_count(): raise IndexError( "Only {0} parts available you asked for part {1} (zero based)".format( self.part_count(), part_index)) remote_mem = RemoteMemoryBlock(self) # get the rectangle for this item rect = win32structures.RECT() remote_mem.Write(rect) self.send_message( win32defines.SB_GETRECT, part_index, remote_mem) rect = remote_mem.Read(rect) del remote_mem return rect # Non PEP-8 alias GetPartRect = deprecated(get_part_rect) #---------------------------------------------------------------- def client_rects(self): """Return the client rectangles for the control""" rects = [self.client_rect()] for i in range(self.part_count()): rects.append(self.get_part_rect(i)) return rects #---------------------------------------------------------------- def get_part_text(self, part_index): """Return the text of the part specified by part_index""" if part_index >= self.part_count(): raise IndexError( "Only {0} parts available you asked for part {1} (zero based)".format( self.part_count(), part_index)) remote_mem = RemoteMemoryBlock(self) textlen = self.send_message( win32defines.SB_GETTEXTLENGTHW, part_index, 0 ) #draw_operation = win32functions.HiWord(textlen) textlen = win32functions.LoWord(textlen) # get the text for this item text = ctypes.create_unicode_buffer(textlen + ctypes.sizeof(ctypes.c_wchar)) remote_mem.Write(text) self.send_message( win32defines.SB_GETTEXTW, part_index, remote_mem ) text = remote_mem.Read(text) del remote_mem return text.value # Non PEP-8 alias GetPartText = deprecated(get_part_text) #---------------------------------------------------------------- def texts(self): """Return the texts for the control""" texts = [self.window_text()] for i in range(self.part_count()): texts.append(self.get_part_text(i)) return texts #==================================================================== class TabControlWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Tab common control""" friendlyclassname = "TabControl" windowclasses = [ "SysTabControl32", r"WindowsForms\d*\.SysTabControl32\..*"] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(TabControlWrapper, self).__init__(hwnd) #self.writable_props.append("TabStates") @property def writable_props(self): """Extend default properties list.""" props = super(TabControlWrapper, self).writable_props props.extend(['tab_count']) return props #---------------------------------------------------------------- def row_count(self): """Return the number of rows of tabs""" return self.send_message(win32defines.TCM_GETROWCOUNT) # Non PEP-8 alias RowCount = deprecated(row_count) #---------------------------------------------------------------- def get_selected_tab(self): """Return the index of the selected tab""" return self.send_message(win32defines.TCM_GETCURSEL) # Non PEP-8 alias GetSelectedTab = deprecated(get_selected_tab) #---------------------------------------------------------------- def tab_count(self): """Return the number of tabs""" return self.send_message(win32defines.TCM_GETITEMCOUNT) # Non PEP-8 alias TabCount = deprecated(tab_count) #---------------------------------------------------------------- def get_tab_rect(self, tab_index): """Return the rectangle to the tab specified by tab_index""" if tab_index >= self.tab_count(): raise IndexError( "Only {0} tabs available you asked for tab {1} (zero based)".format( self.tab_count(), tab_index)) remote_mem = RemoteMemoryBlock(self) rect = win32structures.RECT() remote_mem.Write(rect) self.send_message( win32defines.TCM_GETITEMRECT, tab_index, remote_mem) remote_mem.Read(rect) del remote_mem return rect # Non PEP-8 alias GetTabRect = deprecated(get_tab_rect) # #---------------------------------------------------------------- # def get_tab_state(self, tab_index): # """Return the state of the tab""" # if tab_index >= self.tab_count(): # raise IndexError( # "Only %d tabs available you asked for tab %d (zero based)" % ( # self.tab_count(), # tab_index)) # # remote_mem = RemoteMemoryBlock(self) # # item = win32structures.TCITEMW() # item.mask = win32defines.TCIF_STATE # remote_mem.Write(item) # # ret = self.send_message( # win32defines.TCM_GETITEMW, tab_index, remote_mem) # # remote_mem.Read(item) # del remote_mem # # if not ret: # raise ctypes.WinError() # # return item.dwState # # Non PEP-8 alias # GetTabState = deprecated(get_tab_state) #---------------------------------------------------------------- def get_tab_text(self, tab_index): """Return the text of the tab""" if tab_index >= self.tab_count(): raise IndexError( "Only {0} tabs available you asked for tab {1} (zero based)".format( self.tab_count(), tab_index)) remote_mem = RemoteMemoryBlock(self) item = win32structures.TCITEMW() item.mask = win32defines.TCIF_TEXT item.cchTextMax = 1999 item.pszText = remote_mem.Address() + ctypes.sizeof(item) remote_mem.Write(item) self.send_message( win32defines.TCM_GETITEMW, tab_index, remote_mem) remote_mem.Read(item) # Read the text that has been written text = ctypes.create_unicode_buffer(2000) text = remote_mem.Read(text, remote_mem.Address() + ctypes.sizeof(item)) return text.value # Non PEP-8 alias GetTabText = deprecated(get_tab_text) #---------------------------------------------------------------- def get_properties(self): """Return the properties of the TabControl as a Dictionary""" props = super(TabControlWrapper, self).get_properties() props['tab_count'] = self.tab_count() return props # #---------------------------------------------------------------- # def tab_states(self): # """Return the tab state for all the tabs""" # states = [] # for i in range(0, self.tab_count()): # states.append(self.GetTabState(i)) # return states # # Non PEP-8 alias # TabStates = deprecated(tab_states) #---------------------------------------------------------------- def client_rects(self): """Return the client rectangles for the Tab Control""" rects = [self.client_rect()] for tab_index in range(0, self.tab_count()): rects.append(self.get_tab_rect(tab_index)) return rects #---------------------------------------------------------------- def texts(self): """Return the texts of the Tab Control""" texts = [self.window_text()] for i in range(0, self.tab_count()): texts.append(self.get_tab_text(i)) return texts #---------------------------------------------------------------- def select(self, tab): """Select the specified tab on the tab control""" self.verify_actionable() logging_tab = tab # if it's a string then find the index of # the tab with that text if isinstance(tab, six.string_types): # find the string in the tab control best_text = findbestmatch.find_best_match( tab, self.texts(), self.texts()) tab = self.texts().index(best_text) - 1 if tab >= self.tab_count(): raise IndexError( "Only {0} tabs available you asked for tab {1} (zero based)".format( self.tab_count(), tab)) if self.has_style(win32defines.TCS_BUTTONS): # workaround for TCS_BUTTONS case self.click(coords=self.get_tab_rect(tab)) # TCM_SETCURFOCUS changes focus, but doesn't select the tab # TCM_SETCURSEL selects the tab, but tab content is not re-drawn # (TODO: need to find a solution without WM_CLICK) #self.Notify(win32defines.TCN_SELCHANGING) #self.send_message(win32defines.TCM_SETCURSEL, tab) #self.Notify(win32defines.TCN_SELCHANGE) else: self.send_message(win32defines.TCM_SETCURFOCUS, tab) win32functions.WaitGuiThreadIdle(self.handle) time.sleep(Timings.after_tabselect_wait) self.actions.log('Selected tab "' + str(logging_tab) + '"') return self # Non PEP-8 alias Select = deprecated(select) #==================================================================== class _toolbar_button(object): """Wrapper around Toolbar button (TBBUTTONINFO) items""" #---------------------------------------------------------------- def __init__(self, index_, tb_handle): """Initialize the item""" self.toolbar_ctrl = tb_handle self.index = index_ self.info = self.toolbar_ctrl.get_button(self.index) #---------------------------------------------------------------- def rectangle(self): """Get the rectangle of a button on the toolbar""" remote_mem = RemoteMemoryBlock(self.toolbar_ctrl) rect = win32structures.RECT() remote_mem.Write(rect) self.toolbar_ctrl.send_message(win32defines.TB_GETRECT, self.info.idCommand, remote_mem) rect = remote_mem.Read(rect) if rect == win32structures.RECT(0, 0, 0, 0): self.toolbar_ctrl.send_message(win32defines.TB_GETITEMRECT, self.index, remote_mem) rect = remote_mem.Read(rect) del remote_mem return rect # Non PEP-8 alias Rectangle = deprecated(rectangle) # #---------------------------------------------------------------- # def press(self, press = True): # """Find where the button is and click it""" # if press: # press_flag = win32functions.MakeLong(0, 1) # else: # press_flag = 0 # # ret = self.toolbar_ctrl.send_message_timeout( # win32defines.TB_PRESSBUTTON, # self.info.idCommand, # press_flag) # # # Notify the parent that we are finished selecting # #self.toolbar_ctrl.notify_parent(win32defines.TBN_TOOLBARCHANGE) # # win32functions.WaitGuiThreadIdle(self.toolbar_ctrl.handle) # time.sleep(Timings.after_toobarpressbutton_wait) # # Non PEP-8 alias # Press = deprecated(press) # # #---------------------------------------------------------------- # def press(self): # """Find where the button is and click it""" # self.Press(press = False) # # Non PEP-8 alias # Press = deprecated(press) # # #---------------------------------------------------------------- # def check(self, check = True): # """Find where the button is and click it""" # if check: # check_flag = win32functions.MakeLong(0, 1) # else: # check_flag = 0 # # ret = self.toolbar_ctrl.send_message_timeout( # win32defines.TB_CHECKBUTTON, # self.info.idCommand, # check_flag) # # # Notify the parent that we are finished selecting # #self.toolbar_ctrl.notify_parent(win32defines.TBN_TOOLBARCHANGE) # # win32functions.WaitGuiThreadIdle(self.toolbar_ctrl.handle) # time.sleep(Timings.after_toobarpressbutton_wait) # # #---------------------------------------------------------------- # def uncheck(self): # self.check(check = False) #---------------------------------------------------------------- def text(self): """Return the text of the button""" return self.info.text # Non PEP-8 alias Text = deprecated(text) #---------------------------------------------------------------- def style(self): """Return the style of the button""" return self.toolbar_ctrl.send_message( win32defines.TB_GETSTYLE, self.info.idCommand) # Non PEP-8 alias Style = deprecated(style) #---------------------------------------------------------------- def has_style(self, style): """Return True if the button has the specified style""" return self.style() & style == style # Non PEP-8 alias HasStyle = deprecated(has_style) #---------------------------------------------------------------- def state(self): """Return the state of the button""" return self.toolbar_ctrl.send_message( win32defines.TB_GETSTATE, self.info.idCommand) # Non PEP-8 alias State = deprecated(state) #---------------------------------------------------------------- def is_checkable(self): """Return if the button can be checked""" return self.has_style(win32defines.TBSTYLE_CHECK) # Non PEP-8 alias IsCheckable = deprecated(is_checkable) #---------------------------------------------------------------- def is_pressable(self): """Return if the button can be pressed""" return self.has_style(win32defines.TBSTYLE_BUTTON) # Non PEP-8 alias IsPressable = deprecated(is_pressable) #---------------------------------------------------------------- def is_checked(self): """Return if the button is in the checked state""" return self.state() & win32defines.TBSTATE_CHECKED == win32defines.TBSTATE_CHECKED # Non PEP-8 alias IsChecked = deprecated(is_checked) #---------------------------------------------------------------- def is_pressed(self): """Return if the button is in the pressed state""" return self.state() & win32defines.TBSTATE_PRESSED == win32defines.TBSTATE_PRESSED # Non PEP-8 alias IsPressed = deprecated(is_pressed) #---------------------------------------------------------------- def is_enabled(self): """Return if the button is in the pressed state""" # make sure it has an ID if not self.info.idCommand: return False return self.state() & win32defines.TBSTATE_ENABLED == win32defines.TBSTATE_ENABLED # Non PEP-8 alias IsEnabled = deprecated(is_enabled) #---------------------------------------------------------------- def click(self, button="left", pressed=""): """Click on the Toolbar button""" self.toolbar_ctrl.click(button=button, coords=self.rectangle(), pressed=pressed) time.sleep(Timings.after_toobarpressbutton_wait) # Non PEP-8 alias Click = deprecated(click) #---------------------------------------------------------------- def click_input(self, button="left", double=False, wheel_dist=0, pressed=""): """Click on the Toolbar button""" self.toolbar_ctrl.click_input(button=button, coords=self.rectangle().mid_point(), double=double, wheel_dist=wheel_dist, pressed=pressed) time.sleep(Timings.after_toobarpressbutton_wait) # Non PEP-8 alias ClickInput = deprecated(click_input) #==================================================================== class ToolbarWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Toolbar common control""" friendlyclassname = "Toolbar" windowclasses = [ "ToolbarWindow32", "TToolBar", r"WindowsForms\d*\.ToolbarWindow32\..*", "Afx:ToolBar:.*"] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(ToolbarWrapper, self).__init__(hwnd) @property def writable_props(self): """Extend default properties list.""" props = super(ToolbarWrapper, self).writable_props props.extend(['button_count']) return props #---------------------------------------------------------------- def button_count(self): """Return the number of buttons on the ToolBar""" return self.send_message(win32defines.TB_BUTTONCOUNT) # Non PEP-8 alias ButtonCount = deprecated(button_count) #---------------------------------------------------------------- def button(self, button_identifier, exact=True, by_tooltip=False): """Return the button at index button_index""" if isinstance(button_identifier, six.string_types): texts = self.texts()[1:] self.actions.log('Toolbar buttons: ' + str(texts)) # one of these will be returned for the matching text indices = [i for i in range(0, len(texts))] if by_tooltip: texts = self.tip_texts() self.actions.log('Toolbar tooltips: ' + str(texts)) if exact: try: button_index = texts.index(button_identifier) except ValueError: raise findbestmatch.MatchError(items=texts, tofind=button_identifier) else: # find which index best matches that text button_index = findbestmatch.find_best_match(button_identifier, texts, indices) else: button_index = button_identifier return _toolbar_button(button_index, self) # Non PEP-8 alias Button = deprecated(button) #---------------------------------------------------------------- def get_button_struct(self, button_index): """Return TBBUTTON structure on the Toolbar button""" if button_index >= self.button_count(): raise IndexError( "0 to {0} are acceptaple for button_index".format(self.button_count())) remote_mem = RemoteMemoryBlock(self) if is64bitprocess(self.process_id()) or not is_x64_Python(): button = win32structures.TBBUTTON() else: button = win32structures.TBBUTTON32() remote_mem.Write(button) ret = self.send_message( win32defines.TB_GETBUTTON, button_index, remote_mem) if not ret: del remote_mem raise RuntimeError( "get_button failed for button index {0}".format(button_index)) remote_mem.Read(button) del remote_mem return button # Non PEP-8 alias GetButtonStruct = deprecated(get_button_struct) #---------------------------------------------------------------- def get_button(self, button_index): """Return information on the Toolbar button""" button = self.get_button_struct(button_index) if is64bitprocess(self.process_id()) or not is_x64_Python(): button_info = win32structures.TBBUTTONINFOW() else: button_info = win32structures.TBBUTTONINFOW32() button_info.cbSize = ctypes.sizeof(button_info) button_info.dwMask = \ win32defines.TBIF_COMMAND | \ win32defines.TBIF_SIZE | \ win32defines.TBIF_STYLE | \ win32defines.TBIF_IMAGE | \ win32defines.TBIF_LPARAM | \ win32defines.TBIF_STATE | \ win32defines.TBIF_TEXT #win32defines.TBIF_IMAGELABEL | \ button_info.cchText = 2000 remote_mem = RemoteMemoryBlock(self) # set the text address to after the structures button_info.pszText = remote_mem.Address() + \ ctypes.sizeof(button_info) # fill the button_info structure remote_mem.Write(button_info) ret = self.send_message( win32defines.TB_GETBUTTONINFOW, button.idCommand, remote_mem) remote_mem.Read(button_info) if ret == -1: del remote_mem raise RuntimeError('GetButtonInfo failed for button with command' + ' id {0}'.format(button.idCommand)) # read the text button_info.text = ctypes.create_unicode_buffer(1999) remote_mem.Read(button_info.text, remote_mem.Address() + ctypes.sizeof(button_info)) button_info.text = button_info.text.value del remote_mem return button_info # Non PEP-8 alias GetButton = deprecated(get_button) #---------------------------------------------------------------- def texts(self): """Return the texts of the Toolbar""" texts = [self.window_text()] for i in range(0, self.button_count()): btn_text = self.get_button(i).text lines = btn_text.split('\n') if lines: texts.append(lines[0]) else: texts.append(btn_text) return texts #---------------------------------------------------------------- def tip_texts(self): """Return the tip texts of the Toolbar (without window text)""" texts = [] for i in range(0, self.button_count()): # it works for MFC btn_tooltip_index = self.get_button_struct(i).iString # usually iString == -1 for separator # other cases if any if not (-1 <= btn_tooltip_index < self.get_tool_tips_control().tool_count()): btn_tooltip_index = i btn_text = self.get_tool_tips_control().get_tip_text(btn_tooltip_index + 1) texts.append(btn_text) return texts # Non PEP-8 alias TipTexts = deprecated(tip_texts) #---------------------------------------------------------------- def get_button_rect(self, button_index): """Get the rectangle of a button on the toolbar""" return self.button(button_index).rectangle() # Non PEP-8 alias GetButtonRect = deprecated(get_button_rect) #---------------------------------------------------------------- def get_tool_tips_control(self): """Return the tooltip control associated with this control""" return ToolTipsWrapper(self.send_message(win32defines.TB_GETTOOLTIPS)) # Non PEP-8 alias GetToolTipsControl = deprecated(get_tool_tips_control) # def right_click(self, button_index, **kwargs): # """Right click for Toolbar buttons""" # # win32functions.SetCapture(self) # # button = self.get_button(button_index) # #print button.text # # rect = self.get_button_rect(button_index) # # x = (rect.left + rect.right) /2 # y = (rect.top + rect.bottom) /2 # # #print x, y # # # self.move_mouse_input(coords = (x, y)) # self.send_message( # win32defines.WM_MOUSEACTIVATE, # self.parent().parent().parent(), # win32functions.MakeLong( # win32defines.WM_RBUTTONDOWN, # win32defines.HTCLIENT) # ) # # self.press_mouse(pressed = "right", button = "right", coords = (x, y)) # # remote_mem = RemoteMemoryBlock(self) # # # now we need to notify the parent that the state has changed # nmlv = win32structures.NMMOUSE() # nmlv.hdr.hwndFrom = self.handle # nmlv.hdr.idFrom = self.control_id() # nmlv.hdr.code = win32defines.NM_RCLICK # # # nmlv.dwItemSpec = button.idCommand # #nmlv.dwItemData # # nmlv.pt = win32structures.POINT() # # remote_mem.Write(nmlv) # # self.send_message( # win32defines.WM_NOTIFY, # self.control_id(), # remote_mem) # # del remote_mem # # # self.release_mouse(button = "right", coords = (x, y)) # # win32functions.ReleaseCapture() # # Non PEP-8 alias # Right_Click = deprecated(right_click) #---------------------------------------------------------------- def press_button(self, button_identifier, exact=True): """Find where the button is and click it""" msg = 'Clicking "' + self.window_text() + '" toolbar button "' + str(button_identifier) + '"' self.actions.logSectionStart(msg) self.actions.log(msg) button = self.button(button_identifier, exact=exact) # transliterated from # http://source.winehq.org/source/dlls/comctl32/toolbar.c # if the button is enabled if button.is_enabled(): button.click_input() else: raise RuntimeError('Toolbar button "' + str(button_identifier) + '" is disabled! Cannot click it.') self.actions.logSectionEnd() # Non PEP-8 alias PressButton = deprecated(press_button) #---------------------------------------------------------------- def check_button(self, button_identifier, make_checked, exact=True): """Find where the button is and click it if it's unchecked and vice versa""" self.actions.logSectionStart('Checking "' + self.window_text() + '" toolbar button "' + str(button_identifier) + '"') button = self.button(button_identifier, exact=exact) if make_checked: self.actions.log('Pressing down toolbar button "' + str(button_identifier) + '"') else: self.actions.log('Pressing up toolbar button "' + str(button_identifier) + '"') # TODO: add waiting for a button state if not button.is_enabled(): self.actions.log('Toolbar button is not enabled!') raise RuntimeError("Toolbar button is not enabled!") if button.is_checked() != make_checked: button.click_input() # wait while button has changed check state #i = 0 #while button.is_checked() != make_checked: # time.sleep(0.5) # i += 1 # if i > 10: # raise RuntimeError("Cannot wait button check state!") self.actions.logSectionEnd() # Non PEP-8 alias CheckButton = deprecated(check_button) #---------------------------------------------------------------- def menu_bar_click_input(self, path, app): """Select menu bar items by path (experimental!) The path is specified by a list of items separated by '->' each Item can be the zero based index of the item to return prefaced by # e.g. #1. Example: "#1 -> #0", "#1->#0->#0" """ warnings.warn("menu_bar_click_input method is experimental. Use carefully!") self.actions.logSectionStart('Clicking "{0}" menu bar path "{1}"'.format(self.window_text(), path)) if isinstance(path, list): parts = path else: parts = path.split("->") indices = [] for part in parts: if isinstance(part, int): indices.append(part) else: item_string = part.strip().lstrip('#') try: index = int(item_string) except Exception: raise TypeError('Path must contain integers only!') indices.append(index) # circle import doesn't work with current package structure # so use the app instance as a method param #app = Application().Connect(handle=self.handle) current_toolbar = self current_toolbar.set_focus() # to make sure it can be clicked immediately for i, index in enumerate(indices): windows_before = app.windows(visible_only=True) current_toolbar.button(index).click_input() if i < len(indices) - 1: wait_until(5, 0.1, lambda: len(app.windows(visible_only=True)) > len(windows_before)) windows_after = app.windows(visible_only=True) new_window = set(windows_after) - set(windows_before) current_toolbar = list(new_window)[0].children()[0] self.actions.logSectionEnd() # Non PEP-8 alias MenuBarClickInput = deprecated(menu_bar_click_input) # #---------------------------------------------------------------- # def _fill_toolbar_info(self): # """Get the information from the toolbar""" # buttonCount = self.send_message(win32defines.TB_BUTTONCOUNT) # self._extra_props['button_count'] = buttonCount # # remote_mem = RemoteMemoryBlock(self) # # for i in range(0, buttonCount): # # button = win32structures.TBBUTTON() # # remote_mem.Write(button) # # self.send_message( # win32defines.TB_GETBUTTON, i, remote_mem) # # remote_mem.Read(button) # # buttonInfo = win32structures.TBBUTTONINFOW() # buttonInfo.cbSize = ctypes.sizeof(buttonInfo) # buttonInfo.dwMask = win32defines.TBIF_TEXT | \ # win32defines.TBIF_COMMAND | \ # win32defines.TBIF_SIZE | \ # win32defines.TBIF_COMMAND | \ # win32defines.TBIF_STYLE | \ # win32defines.TBIF_STATE # # buttonInfo.cchText = 2000 # # # set the text address to after the structures # buttonInfo.pszText = remote_mem.Address() + \ # ctypes.sizeof(buttonInfo) # # # fill the buttonInfo structure # remote_mem.Write(buttonInfo) # self.send_message( # win32defines.TB_GETBUTTONINFOW, # button.idCommand, # remote_mem) # remote_mem.Read(buttonInfo) # # # read the text # text = ctypes.create_unicode_buffer(1999) # remote_mem.Read(text, remote_mem.Address() + \ # ctypes.sizeof(buttonInfo)) # # extendedStyle = self.send_message(win32defines.TB_GETEXTENDEDSTYLE) # # self._extra_props.setdefault('Buttons', []).append( # dict( # iBitMap = button.iBitmap, # idCommand = button.idCommand, # fsState = button.fsState, # fsStyle = button.fsStyle, # cx = buttonInfo.cx, # exstyle = extendedStyle # ) # ) # # if button.fsStyle & TBSTYLE_DROPDOWN == TBSTYLE_DROPDOWN and \ # # (extendedStyle & TBSTYLE_EX_DRAWDDARROWS) != \ # # TBSTYLE_EX_DRAWDDARROWS: # # props['Buttons'][-1]["DROPDOWNMENU"] = 1 # # # # self.send_message(WM_COMMAND, button.idCommand) # # # # print "Pressing", text.value # # handle.send_message(TB_PRESSBUTTON, button.idCommand, 1) # # handle.send_message(TB_PRESSBUTTON, button.idCommand, 0) # # self._extra_texts.append(text.value) # # # RB_GETBANDBORDERS class BandWrapper(win32structures.REBARBANDINFOW): """Simple wrapper around REBARBANDINFOW to allow setting new attributes""" pass #==================================================================== class ReBarWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows ReBar common control""" friendlyclassname = "ReBar" windowclasses = ["ReBarWindow32", ] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(ReBarWrapper, self).__init__(hwnd) @property def writable_props(self): """Extend default properties list.""" props = super(ReBarWrapper, self).writable_props props.extend(['band_count']) return props #---------------------------------------------------------------- def band_count(self): """Return the number of bands in the control""" return self.send_message(win32defines.RB_GETBANDCOUNT) # Non PEP-8 alias BandCount = deprecated(band_count) #---------------------------------------------------------------- def get_band(self, band_index): """Get a band of the ReBar control""" if band_index >= self.band_count(): raise IndexError(('band_index {0} greater then number of' + ' available bands: {1}').format(band_index, self.band_count())) remote_mem = RemoteMemoryBlock(self) band_info = BandWrapper() band_info.cbSize = ctypes.sizeof(band_info) band_info.fMask = \ win32defines.RBBIM_CHILD | \ win32defines.RBBIM_CHILDSIZE | \ win32defines.RBBIM_COLORS | \ win32defines.RBBIM_HEADERSIZE | \ win32defines.RBBIM_ID | \ win32defines.RBBIM_IDEALSIZE | \ win32defines.RBBIM_SIZE | \ win32defines.RBBIM_STYLE | \ win32defines.RBBIM_TEXT # set the pointer for the text band_info.lpText = win32structures.LPWSTR( remote_mem.Address() + ctypes.sizeof(band_info)) band_info.cch = 2000 # write the structure remote_mem.Write(band_info) # Fill the structure self.send_message( win32defines.RB_GETBANDINFOW, band_index, remote_mem) # read it back remote_mem.Read(band_info) # read the text band_info.text = ctypes.create_unicode_buffer(2000) remote_mem.Read(band_info.text, remote_mem.Address() + ctypes.sizeof(band_info)) band_info.text = band_info.text.value del remote_mem return band_info # Non PEP-8 alias GetBand = deprecated(get_band) #---------------------------------------------------------------- def get_tool_tips_control(self): """Return the tooltip control associated with this control""" tips_handle = self.send_message(win32defines.RB_GETTOOLTIPS) if tips_handle: return ToolTipsWrapper(tips_handle) # Non PEP-8 alias GetToolTipsControl = deprecated(get_tool_tips_control) #---------------------------------------------------------------- def texts(self): """Return the texts of the Rebar""" texts = [self.window_text()] for i in range(0, self.band_count()): band = self.get_band(i) lines = band.text.split('\n') if lines: texts.append(lines[0]) else: texts.append(band.text) return texts #==================================================================== class ToolTip(object): """Class that Wraps a single tip from a ToolTip control""" def __init__(self, ctrl, tip_index): """Read the required information""" self.ctrl = ctrl self.index = tip_index remote_mem = RemoteMemoryBlock(self.ctrl) tipinfo = win32structures.TOOLINFOW() tipinfo.cbSize = ctypes.sizeof(tipinfo) #tipinfo.uId = self.index tipinfo.lpszText = remote_mem.Address() + \ ctypes.sizeof(tipinfo) + 1 remote_mem.Write(tipinfo) self.ctrl.send_message( win32defines.TTM_ENUMTOOLSW, self.index, remote_mem) remote_mem.Read(tipinfo) self.info = tipinfo # now get the text self.info.lpszText = remote_mem.Address() + \ ctypes.sizeof(self.info) + 1 remote_mem.Write(self.info) self.ctrl.send_message( win32defines.TTM_GETTEXTW, 160, remote_mem) # There is no way to determine the required buffer size. # However, tool text, as returned at the lpszText member of the TOOLINFO structure, # has a maximum length of 80 TCHARs, including the terminating NULL. # If the text exceeds this length, it is truncated. # https://msdn.microsoft.com/en-us/library/windows/desktop/bb760375(v=vs.85).aspx text = ctypes.create_unicode_buffer(80) remote_mem.Read(text, self.info.lpszText) self.text = text.value del remote_mem #==================================================================== class ToolTipsWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows ToolTips common control (not fully implemented)""" # mask this class as it is not ready for prime time yet! friendlyclassname = "ToolTips" windowclasses = ["tooltips_class32", ".*ToolTip", "#32774", "MS_WINNOTE", "VBBubble", ] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialize the instance""" super(ToolTipsWrapper, self).__init__(hwnd) #---------------------------------------------------------------- def get_tip(self, tip_index): """Return the particular tooltip""" if tip_index >= self.tool_count(): raise IndexError(('tip_index {0} is greater than number of' + ' available tips: {1}').format(tip_index, self.tool_count())) return ToolTip(self, tip_index) # Non PEP-8 alias GetTip = deprecated(get_tip) #---------------------------------------------------------------- def tool_count(self): """Return the number of tooltips""" return self.send_message(win32defines.TTM_GETTOOLCOUNT) # Non PEP-8 alias ToolCount = deprecated(tool_count) #---------------------------------------------------------------- def get_tip_text(self, tip_index): """Return the text of the tooltip""" return ToolTip(self, tip_index).text # Non PEP-8 alias GetTipText = deprecated(get_tip_text) #---------------------------------------------------------------- def texts(self): """Return the text of all the tooltips""" texts = [self.window_text(), ] for tip_index in range(0, self.tool_count()): texts.append(self.get_tip_text(tip_index)) return texts #==================================================================== class UpDownWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows UpDown common control""" friendlyclassname = "UpDown" windowclasses = ["msctls_updown32", "msctls_updown", ] #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(UpDownWrapper, self).__init__(hwnd) #---------------------------------------------------------------- def get_value(self): """Get the current value of the UpDown control""" pos = self.send_message( win32defines.UDM_GETPOS, win32structures.LPARAM(0), win32structures.WPARAM(0), ) return win32functions.LoWord(pos) # Non PEP-8 alias GetValue = deprecated(get_value) #---------------------------------------------------------------- def get_base(self): """Get the base the UpDown control (either 10 or 16)""" return self.send_message(win32defines.UDM_GETBASE) # Non PEP-8 alias GetBase = deprecated(get_base) #---------------------------------------------------------------- def set_base(self, base_value): """Get the base the UpDown control (either 10 or 16)""" return self.send_message(win32defines.UDM_SETBASE, base_value) # Non PEP-8 alias SetBase = deprecated(set_base) #---------------------------------------------------------------- def get_range(self): """Return the lower, upper range of the up down control""" updown_range = self.send_message(win32defines.UDM_GETRANGE) updown_range = ( win32functions.HiWord(updown_range), win32functions.LoWord(updown_range) ) return updown_range # Non PEP-8 alias GetRange = deprecated(get_range) #---------------------------------------------------------------- def get_buddy_control(self): """Get the buddy control of the updown control""" #from wraphandle import WrapHandle #from HwndWrapper import WrapHandle buddy_handle = self.send_message(win32defines.UDM_GETBUDDY) return hwndwrapper.HwndWrapper(buddy_handle) # Non PEP-8 alias GetBuddyControl = deprecated(get_buddy_control) #---------------------------------------------------------------- def set_value(self, new_pos): """Set the value of the of the UpDown control to some integer value""" for _ in range(3): result = win32structures.DWORD_PTR(0) win32functions.SendMessageTimeout(self, win32defines.UDM_SETPOS, 0, win32functions.MakeLong(0, new_pos), win32defines.SMTO_NORMAL, int(Timings.after_updownchange_wait * 1000), ctypes.byref(result)) win32functions.WaitGuiThreadIdle(self.handle) time.sleep(Timings.after_updownchange_wait) if self.get_value() == new_pos: break # make one more attempt elsewhere # Non PEP-8 alias SetValue = deprecated(set_value) #---------------------------------------------------------------- def increment(self): """Increment the number in the UpDown control by one""" # hmmm - VM_SCROLL and UDN_DELTAPOS don't seem to be working for me :-( # I will fake it for now either use click, or get_value() + 1 rect = self.client_rect() self.click_input(coords=(rect.left + 5, rect.top + 5)) #self.set_value(self.get_value() + 1) #win32functions.WaitGuiThreadIdle(self.handle) #time.sleep(Timings.after_updownchange_wait) # Non PEP-8 alias Increment = deprecated(increment) #---------------------------------------------------------------- def decrement(self): """Decrement the number in the UpDown control by one""" rect = self.client_rect() self.click_input(coords=(rect.left + 5, rect.bottom - 5)) #self.set_value(self.get_value() - 1) #win32functions.WaitGuiThreadIdle(self.handle) #time.sleep(Timings.after_updownchange_wait) # Non PEP-8 alias Decrement = deprecated(decrement) #==================================================================== class TrackbarWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Trackbar common control """ friendlyclassname = "Trackbar" windowclasses = ["msctls_trackbar", ] def get_range_min(self): """Get min available trackbar value""" return self.send_message(win32defines.TBM_GETRANGEMIN) def get_range_max(self): """Get max available trackbar value""" return self.send_message(win32defines.TBM_GETRANGEMAX) def get_position(self): """Get trackbar position""" return self.send_message(win32defines.TBM_GETPOS) def get_num_ticks(self): """Get trackbar num ticks""" return self.send_message(win32defines.TBM_GETNUMTICS) def get_channel_rect(self): """Get position of the bounding rectangle for a Trackbar""" remote_mem = RemoteMemoryBlock(self) system_rect = win32structures.RECT() remote_mem.Write(system_rect) self.send_message(win32defines.TBM_GETCHANNELRECT, 0, remote_mem) remote_mem.Read(system_rect) del remote_mem return system_rect def get_line_size(self): """Get the number of logical positions the trackbar's slider""" return self.send_message(win32defines.TBM_GETLINESIZE) def get_tooltips_control(self): """Get trackbar tooltip""" return ToolTipsWrapper(self.send_message(win32defines.TBM_GETTOOLTIPS)) def get_page_size(self): """Get the number of logical positions for the trackbar's slider""" return self.send_message(win32defines.TBM_GETPAGESIZE) def set_range_max(self, range_max): """Set max available trackbar value""" if range_max < self.get_range_min(): raise ValueError('Cannot set range max less than range min') self.send_message(win32defines.TBM_SETRANGEMAX, True, range_max) def set_range_min(self, range_min): """Set min available trackbar value""" if range_min > self.get_range_max(): raise ValueError('Cannot set range min more than range max') self.send_message(win32defines.TBM_SETRANGEMIN, True, range_min) def set_position(self, pos): """Set trackbar position""" if not (self.get_range_min() <= pos <= self.get_range_max()): raise ValueError('Cannot set position out of range') self.send_message(win32defines.TBM_SETPOS, True, pos) def set_line_size(self, line_size): """Set trackbar line size""" self.send_message(win32defines.TBM_SETLINESIZE, 0, line_size) def set_page_size(self, page_size): """Set trackbar page size""" self.send_message(win32defines.TBM_SETPAGESIZE, 0, page_size) def set_sel(self, sel_start, sel_end): """Set start and end of selection""" if not self.has_style(win32defines.TBS_ENABLESELRANGE): raise RuntimeError('Range selection is not supported for this trackbar') sel_start_val = win32functions.LoWord(sel_start) sel_end_val = win32functions.HiWord(sel_end) sel_val = win32functions.MakeLong(sel_start_val, sel_end_val) self.send_message(win32defines.TBM_SETSAL, 0, sel_val) def get_sel_start(self): """Get start of selection""" if not self.has_style(win32defines.TBS_ENABLESELRANGE): raise RuntimeError('Range selection is not supported for this trackbar') return self.send_message(win32defines.TBM_GETSELSTART) def get_sel_end(self): """Get end of selection""" if not self.has_style(win32defines.TBS_ENABLESELRANGE): raise RuntimeError('Range selection is not supported for this trackbar') return self.send_message(win32defines.TBM_GETSELEND) #==================================================================== class AnimationWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Animation common control""" friendlyclassname = "Animation" windowclasses = ["SysAnimate32", ] #==================================================================== class ComboBoxExWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows ComboBoxEx common control""" friendlyclassname = "ComboBoxEx" windowclasses = ["ComboBoxEx32", ] has_title = False #==================================================================== class DateTimePickerWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows DateTimePicker common control""" friendlyclassname = "DateTimePicker" windowclasses = ["SysDateTimePick32", r"WindowsForms\d*\.SysDateTimePick32\..*", ] has_title = False #---------------------------------------------------------------- def get_time(self): """Get the currently selected time""" remote_mem = RemoteMemoryBlock(self) system_time = win32structures.SYSTEMTIME() remote_mem.Write(system_time) res = self.send_message(win32defines.DTM_GETSYSTEMTIME, 0, remote_mem) remote_mem.Read(system_time) del remote_mem if res != win32defines.GDT_VALID: raise RuntimeError('Failed to get time from Date Time Picker (result = ' + str(res) + ')') #year = system_time.wYear #month = system_time.wMonth #day_of_week = system_time.wDayOfWeek #day = system_time.wDay #hour = system_time.wHour #minute = system_time.wMinute #second = system_time.wSecond #milliseconds = system_time.wMilliseconds #return (year, month, day_of_week, day, hour, minute, second, milliseconds) return system_time # Non PEP-8 alias GetTime = deprecated(get_time) #---------------------------------------------------------------- def set_time(self, year=0, month=0, day_of_week=0, day=0, hour=0, minute=0, second=0, milliseconds=0): """Set the currently selected time""" remote_mem = RemoteMemoryBlock(self) system_time = win32structures.SYSTEMTIME() system_time.wYear = year system_time.wMonth = month system_time.wDayOfWeek = day_of_week system_time.wDay = day system_time.wHour = hour system_time.wMinute = minute system_time.wSecond = second system_time.wMilliseconds = milliseconds remote_mem.Write(system_time) res = self.send_message(win32defines.DTM_SETSYSTEMTIME, win32defines.GDT_VALID, remote_mem) del remote_mem if res == 0: raise RuntimeError('Failed to set time in Date Time Picker') # Non PEP-8 alias SetTime = deprecated(set_time) #==================================================================== class HotkeyWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Hotkey common control""" friendlyclassname = "Hotkey" windowclasses = ["msctls_hotkey32", ] has_title = False #==================================================================== class IPAddressWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows IPAddress common control""" friendlyclassname = "IPAddress" windowclasses = ["SysIPAddress32", ] has_title = False #==================================================================== class CalendarWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Calendar common control""" friendlyclassname = "Calendar" windowclasses = ["SysMonthCal32", ] has_title = False place_in_calendar = { 'background': win32defines.MCSC_BACKGROUND, 'month_background': win32defines.MCSC_MONTHBK, 'text': win32defines.MCSC_TEXT, 'title_background': win32defines.MCSC_TITLEBK, 'title_text': win32defines.MCSC_TITLETEXT, 'trailing_text': win32defines.MCSC_TRAILINGTEXT } #---------------------------------------------------------------- def __init__(self, hwnd): """Initialise the instance""" super(CalendarWrapper, self).__init__(hwnd) #---------------------------------------------------------------- def get_current_date(self): """Get the currently selected date""" remote_mem = RemoteMemoryBlock(self) system_date = win32structures.SYSTEMTIME() remote_mem.Write(system_date) res = self.send_message(win32defines.MCM_GETCURSEL , 0, remote_mem) remote_mem.Read(system_date) del remote_mem if res == 0: raise RuntimeError('Failed to get the currently selected date in Calendar') return system_date #---------------------------------------------------------------- def set_current_date(self, year, month, day_of_week, day): """Set the currently selected date""" remote_mem = RemoteMemoryBlock(self) system_time = win32structures.SYSTEMTIME() system_time.wYear = year system_time.wMonth = month system_time.wDayOfWeek = day_of_week system_time.wDay = day system_time.wHour = 0 system_time.wMinute = 0 system_time.wSecond = 0 system_time.wMilliseconds = 0 remote_mem.Write(system_time) res = self.send_message(win32defines.MCM_SETCURSEL, win32defines.GDT_VALID, remote_mem) del remote_mem if res == 0: raise RuntimeError('Failed to set the currently selected date in Calendar') #---------------------------------------------------------------- def get_border(self): """Get the calendar border""" return self.send_message(win32defines.MCM_GETCALENDARBORDER, 0, 0) #---------------------------------------------------------------- def set_border(self, border): """Set the calendar border""" self.send_message(win32defines.MCM_SETCALENDARBORDER, True, border) #---------------------------------------------------------------- def count(self): """Get the calendars count""" return self.send_message(win32defines.MCM_GETCALENDARCOUNT, 0, 0) #---------------------------------------------------------------- def get_view(self): """Get the calendar view""" return self.send_message(win32defines.MCM_GETCURRENTVIEW, 0, 0) #---------------------------------------------------------------- def set_view(self, viewType): """Set the calendar view""" res = self.send_message(win32defines.MCM_SETCURRENTVIEW, 0, viewType) if res == 0: raise RuntimeError('Failed to set view in Calendar') #---------------------------------------------------------------- def set_day_states(self, month_states): """Sets the day states for all months that are currently visible""" remote_mem = RemoteMemoryBlock(self) day_states = (wintypes.DWORD * len(month_states))(*month_states) remote_mem.Write(day_states) res = self.send_message(win32defines.MCM_SETDAYSTATE, len(day_states), remote_mem) del remote_mem if res == 0: raise RuntimeError('Failed to set the day states in Calendar') return res #---------------------------------------------------------------- def calc_min_rectangle(self, left, top, right, bottom): """Calculates the minimum size that a rectangle needs to be to fit that number of calendars""" remote_mem = RemoteMemoryBlock(self) minimized_rect = win32structures.RECT() minimized_rect.left = left minimized_rect.top = top minimized_rect.right = right minimized_rect.bottom = bottom remote_mem.Write(minimized_rect) self.send_message(win32defines.MCM_SIZERECTTOMIN, 0, remote_mem) remote_mem.Read(minimized_rect) del remote_mem return minimized_rect #---------------------------------------------------------------- def hit_test(self, x, y): """Determines which portion of a month calendar control is at a given point on the screen""" remote_mem = RemoteMemoryBlock(self) hit_test_info = win32structures.MCHITTESTINFO() point = win32structures.POINT() point.x = x point.y = y hit_test_info.pt = point hit_test_info.cbSize = ctypes.sizeof(hit_test_info) remote_mem.Write(hit_test_info) res = self.send_message(win32defines.MCM_HITTEST, 0, remote_mem) del remote_mem return res # ---------------------------------------------------------------- def set_id(self, ID): """ Set the calendar type. Receive only one parameter, which takes variants below: 'gregorian', 'gregorian_us', 'japan', 'taiwan', 'korea', 'hijri', 'thai', 'hebrew', 'gregorian_me_french', 'gregorian_arabic', 'gregorian_english_xlit', 'gregorian_french_xlit', 'umalqura' """ dict_types = { 'gregorian': win32defines.CAL_GREGORIAN, 'gregorian_us': win32defines.CAL_GREGORIAN_US, 'japan': win32defines.CAL_JAPAN, 'taiwan': win32defines.CAL_TAIWAN, 'korea': win32defines.CAL_KOREA, 'hijri': win32defines.CAL_HIJRI, 'thai': win32defines.CAL_THAI, 'hebrew': win32defines.CAL_HEBREW, 'gregorian_me_french': win32defines.CAL_GREGORIAN_ME_FRENCH, 'gregorian_arabic': win32defines.CAL_GREGORIAN_ARABIC, 'gregorian_english_xlit': win32defines.CAL_GREGORIAN_XLIT_ENGLISH, 'gregorian_french_xlit': win32defines.CAL_GREGORIAN_XLIT_FRENCH, 'umalqura': win32defines.CAL_UMALQURA } if ID in dict_types: self.send_message(win32defines.MCM_SETCALID, dict_types[ID], 0) else: raise ValueError('Incorrect calendar ID (use one of {0})'.format(dict_types.keys())) # ---------------------------------------------------------------- def get_id(self): """Get type of calendar""" return self.send_message(win32defines.MCM_GETCALID, 0, 0) # ---------------------------------------------------------------- def set_color(self, place_of_color, red, green, blue): """ Set some color in some place of calendar which you specify. Receive four parameters: - The first parameter may take few variants below: 'background', 'month_background', 'text', 'title_background', 'title_text', 'trailing_text' ; - All other parameters should be integer from 0 to 255. """ if not (0 <= red <= 255): raise RuntimeError('Incorrect range of red color, must be from 0 to 255') if not (0 <= green <= 255): raise RuntimeError('Incorrect range of green color, must be from 0 to 255') if not (0 <= blue <= 255): raise RuntimeError('Incorrect range of blue color, must be from 0 to 255') color = (red << 16) | (green << 8) | blue if place_of_color in self.place_in_calendar: result = self.send_message(win32defines.MCM_SETCOLOR, self.place_in_calendar[place_of_color], color) else: raise ValueError('Incorrect calendar place ID (use one of {0})'.format(self.place_in_calendar.keys())) if result == -1: raise RuntimeError('Incorrect color') return result # ---------------------------------------------------------------- #TODO create method get_color in future ''' def get_color(self, place_of_color): """ Return color of place in calendar, which you specify. Receive only one parameter, which takes variants below: 'background', 'month_background', 'text', 'title_background', 'title_text', 'trailing_text' """ if place_of_color in self.place_in_calendar: return self.send_message(win32defines.MCM_GETCOLOR, self.place_in_calendar[place_of_color], 0) else: raise ValueError('Incorrect calendar place ID (use one of {0})'.format(self.place_in_calendar.keys())) ''' def set_today(self, year, month, day): """Set today date""" remote_mem = RemoteMemoryBlock(self) system_time = win32structures.SYSTEMTIME() system_time.wYear = year system_time.wMonth = month system_time.wDay = day system_time.wHour = 0 system_time.wMinute = 0 system_time.wSecond = 0 system_time.wMilliseconds = 0 remote_mem.Write(system_time) res = self.send_message(win32defines.MCM_SETTODAY, 0, remote_mem) del remote_mem if res == 0: raise RuntimeError('Failed to set today date in Calendar') # ---------------------------------------------------------------- def get_today(self): """Get today date""" remote_mem = RemoteMemoryBlock(self) system_date = win32structures.SYSTEMTIME() remote_mem.Write(system_date) res = self.send_message(win32defines.MCM_GETTODAY, 0, remote_mem) remote_mem.Read(system_date) del remote_mem if res == 0: raise RuntimeError('Failed to get today date in Calendar') return system_date # ---------------------------------------------------------------- def set_first_weekday(self, dayNum): """Set first day of the week""" self.send_message(win32defines.MCM_SETFIRSTDAYOFWEEK, 0, dayNum) # ---------------------------------------------------------------- def get_first_weekday(self): """Get is not in current locale and if so first day of the week""" res = self.send_message(win32defines.MCM_GETFIRSTDAYOFWEEK, 0, 0) return (win32functions.HiWord(res), win32functions.LoWord(res)) # ---------------------------------------------------------------- def get_month_delta(self): """Retrieves the scroll rate for a month calendar control""" return self.send_message(win32defines.MCM_GETMONTHDELTA, 0, 0) # ---------------------------------------------------------------- def set_month_delta(self, delta): """Sets the scroll rate for a month calendar control.""" if (delta < 0): raise ValueError("Month delta must be greater than 0") self.send_message(win32defines.MCM_SETMONTHDELTA, delta, 0) # ---------------------------------------------------------------- def get_month_range(self, scope_of_range): """Retrieves date information that represents the high and low limits of a month calendar control's display.""" if scope_of_range not in [win32defines.GMR_DAYSTATE, win32defines.GMR_VISIBLE]: raise ValueError("scope_of_range value must be one of the following: GMR_DAYSTATE or GMR_VISIBLE") remote_mem = RemoteMemoryBlock(self) system_date_arr = (win32structures.SYSTEMTIME * 2)() system_date_arr[0] = win32structures.SYSTEMTIME() system_date_arr[1] = win32structures.SYSTEMTIME() remote_mem.Write(system_date_arr) res = self.send_message(win32defines.MCM_GETMONTHRANGE, scope_of_range, remote_mem) remote_mem.Read(system_date_arr) del remote_mem return (res, system_date_arr) #==================================================================== class PagerWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Pager common control""" friendlyclassname = "Pager" windowclasses = ["SysPager", ] #---------------------------------------------------------------- def get_position(self): """Return the current position of the pager""" self._ensure_enough_privileges('PGM_GETPOS') return self.send_message(win32defines.PGM_GETPOS) # Non PEP-8 alias GetPosition = deprecated(get_position) #---------------------------------------------------------------- def set_position(self, pos): """Set the current position of the pager""" self._ensure_enough_privileges('PGM_SETPOS') return self.send_message(win32defines.PGM_SETPOS, pos) # Non PEP-8 alias SetPosition = deprecated(set_position) #==================================================================== class ProgressWrapper(hwndwrapper.HwndWrapper): """Class that wraps Windows Progress common control""" friendlyclassname = "Progress" windowclasses = ["msctls_progress", "msctls_progress32", ] has_title = False #---------------------------------------------------------------- def get_position(self): """Return the current position of the progress bar""" self._ensure_enough_privileges('PBM_GETPOS') return self.send_message(win32defines.PBM_GETPOS) # Non PEP-8 alias GetPosition = deprecated(get_position) #---------------------------------------------------------------- def set_position(self, pos): """Set the current position of the progress bar""" self._ensure_enough_privileges('PBM_SETPOS') return self.send_message(win32defines.PBM_SETPOS, pos) # Non PEP-8 alias SetPosition = deprecated(set_position) #---------------------------------------------------------------- def get_state(self): """Get the state of the progress bar State will be one of the following constants: * PBST_NORMAL * PBST_ERROR * PBST_PAUSED """ self._ensure_enough_privileges('PBM_GETSTATE') return self.send_message(win32defines.PBM_GETSTATE) # Non PEP-8 alias GetState = deprecated(get_state) #---------------------------------------------------------------- def get_step(self): """Get the step size of the progress bar""" self._ensure_enough_privileges('PBM_GETSTEP') return self.send_message(win32defines.PBM_GETSTEP) # Non PEP-8 alias GetStep = deprecated(get_step) #---------------------------------------------------------------- def step_it(self): """Move the progress bar one step size forward""" self._ensure_enough_privileges('PBM_STEPIT') return self.send_message(win32defines.PBM_STEPIT) # Non PEP-8 alias StepIt = deprecated(step_it) # ## ###hwndwrapper._HwndWrappers["ComboBoxEx32"] = ComboBoxEx ## ###==================================================================== ##class ComboBoxEx(Controls_Standard.ComboBox): ## #---------------------------------------------------------------- ## def __init__(self, hwndOrXML): # Window.__init__(self, hwndOrXML) ## # if isinstance(hwndOrXML, (int, long)): ## comboCntrl = send_message( ## hwndOrXML, ## CBEM_GETCOMBOCONTROL, ## 0, ## 0) ## ## print "--"*20, comboCntrl ## Controls_Standard.ComboBox.__init__(self, comboCntrl) ## print self.dropped_rect ## ## ## ## droppedRect = win32structures.RECT() ## ## send_message( ## self, ## CB_GETDROPPEDCONTROLRECT, ## 0, ## ctypes.byref(droppedRect)) ## ## props['dropped_rect'] = droppedRect # # # # # # # # find out how many text items are in the combobox # numItems = send_message( # self, # CB_GETCOUNT, # 0, # 0) # # print "*"*20, numItems ## remote_mem = RemoteMemoryBlock(self) ## ## ## # get the text for each item in the combobox ## while True: ## item = COMBOBOXEXITEMW() ## ## item.mask = CBEIF_TEXT ## item.cchTextMax = 4000 ## item.pszText = remote_mem.Address() + ctypes.sizeof(item) + 1 ## ## remote_mem.Write(item) ## ## retval = send_message ( ## self, ## CBEM_GETITEMW, ## 0, ## remote_mem ## ) ## ## if retval: ## item = remote_mem.Read(item) ## ## # Read the remote text string ## charData = ctypes.create_unicode_buffer(4000) ## remote_mem.Read(charData, item.pszText) ## self.Titles.append(charData.value) ## else: ## break ## # # else: # # # get the dropped Rect form # droppedRect = XMLToRect(hwndOrXML.find("DROPPEDRECT")) # props['dropped_rect'] = droppedRect