Example #1
0
    def restore(self):

        # By doing normal way with EnumWindows() and then IsWindowVisible
        # I got about five thousand top-level windows. It sucks.
        # So I just walk through desktop region and to enumerate windows

        minx = self.d.right - self.margin - self.size; maxx = minx + self.size
        miny = self.margin; maxy = self.margin + self.size

        #print minx,miny,maxx,maxy

        p = POINT()
        step = 1; currx = minx;
        prev_hwnd = None
        wnds = set()
        while (currx <= maxx):
            curry = miny;
            while (curry <= maxy):
                p.x = currx; p.y = curry;
#                print currx, curry
                curry = curry + step
                
                hwnd = self.WindowFromPoint(p)
                if (hwnd in wnds):
                    continue
                wnds.add(hwnd)
                self.InvalidateRect(hwnd, self.d, True)
                self.UpdateWindow(hwnd)
                #print p.x, p.y
            currx = currx + step
Example #2
0
def get_window_at(x, y):
    point = POINT()
    point.x, point.y = x, y
    hwnd = ctypes.windll.user32.WindowFromPoint(point)
    if not hwnd:
        return None
    else:
        return Window(hwnd)
Example #3
0
def get_window_at(x, y):
    point = POINT()
    point.x, point.y = x, y
    hwnd = ctypes.windll.user32.WindowFromPoint(point)
    if not hwnd:
        return None
    else:
        return Window(hwnd)
Example #4
0
 def get_child_window_at(self, x, y):
     point = POINT()
     point.x, point.y = x, y
     child_hwnd = ctypes.windll.user32.RealChildWindowFromPoint(
         self.__hwnd, point)
     if not child_hwnd:
         return None
     else:
         return Window(child_hwnd)
Example #5
0
def map_to_window(x, y):
    '''x and y are normalized coordinates.'''
    width = GetSystemMetrics(SM_CXSCREEN)
    height = GetSystemMetrics(SM_CYSCREEN)
    point = POINT(2)
    point.x = int(x * width)
    point.y = int(y * height)
    MapWindowPoints(0, hwnd, point, 1)
    return point.x, point.y
Example #6
0
 def get_child_window_at(self, x, y):
     point = POINT()
     point.x, point.y = x, y
     child_hwnd = ctypes.windll.user32.RealChildWindowFromPoint(
         self.__hwnd,
         point
     )
     if not child_hwnd:
         return None
     else:
         return Window(child_hwnd)
Example #7
0
 async def init_silent_mode(self):
     if self.silent_mode and not self.silent_init:
         point = POINT()
         point.x = 100
         point.y = 100
         ctypes.windll.user32.ClientToScreen(self.window_handle,
                                             ctypes.byref(point))
         self.silent_xpos = point.x
         self.silent_ypos = point.y
         await self.walker.mouse_handler.set_mouse_position(
             self.silent_xpos, self.silent_ypos, convert_from_client=False)
         self.silent_init = True
Example #8
0
 def on_getminmaxinfo(self, hwnd, msg, wparam, lparam):
     if (self.min_size or self.max_size) and lparam:
         info = ctypes.cast(lparam, ctypes.POINTER(MINMAXINFO)).contents
         style = GetWindowLongW(hwnd, win32con.GWL_STYLE)
         dw, dh = 0, 0
         if style & win32con.WS_BORDER:
             fw, fh = self.frame_width, self.frame_height
             dw = fw * 2
             dh = self.caption_height + fh * 2
             log(
                 "on_getminmaxinfo window=%#x min_size=%s, max_size=%s, frame=%sx%s",
                 hwnd, self.min_size, self.max_size, fw, fh)
         if self.min_size:
             minw, minh = self.min_size  #pylint: disable=unpacking-non-sequence
             minw += dw
             minh += dh
             if not HOOK_MINMAXINFO_OVERRIDE:
                 v = info.ptMinTrackSize
                 if v:
                     log("on_getminmaxinfo ptMinTrackSize=%ix%i", v.x, v.y)
                     if v.x > 0:
                         minw = max(minw, v.x)
                     if v.y > 0:
                         minh = max(minh, v.y)
             point = POINT(minw, minh)
             info.ptMinSize = point
             info.ptMinTrackSize = point
             log("on_getminmaxinfo actual min_size=%ix%i", minw, minh)
         if self.max_size:
             maxw, maxh = self.max_size  #pylint: disable=unpacking-non-sequence
             maxw += dw
             maxh += dh
             if not HOOK_MINMAXINFO_OVERRIDE:
                 for name, v in {
                         "ptMaxSize": info.ptMaxSize,
                         "ptMaxTrackSize": info.ptMaxTrackSize,
                 }.items():
                     if v:
                         log("on_getminmaxinfo %s=%ix%i", name, v.x, v.y)
                         if v.x > 0:
                             maxw = min(maxw, v.x)
                         if v.y > 0:
                             maxh = min(maxh, v.y)
             point = POINT(maxw, maxh)
             info.ptMaxSize = point
             info.ptMaxTrackSize = point
             log("on_getminmaxinfo actual max_size=%ix%i", maxw, maxh)
         return 0
     log("on_getminmaxinfo%s min_size=%s, max_size=%s",
         (hwnd, msg, wparam, lparam), self.min_size, self.max_size)
     return 0
	def test_collection(self):
		"""Tests whether a collection of several rectangle and point types convert to the expected L{RectLTRB}."""
		rect=RectLTRB(left=10, top=15, right=500, bottom=1000)
		self.assertEqual(RectLTRB.fromCollection(
			rect.topLeft,
			rect.bottomRight,
			rect.center,
			Point(15, 15),
			Point(20, 20),
			Point(50, 50),
			Point(400, 400),
			POINT(x=15, y=15),
			POINT(x=20, y=20),
			POINT(x=50, y=50),
			POINT(x=400, y=400),
			RectLTRB(left=450, top=450, right=490, bottom=990),
			RECT(450, 450, 490, 990)
		), rect)

		location=RectLTWH(left=10, top=15, width=500, height=1000)
		self.assertEqual(RectLTWH.fromCollection(
			location.topLeft,
			location.bottomRight,
			location.center,
			Point(15, 15),
			Point(20, 20),
			Point(50, 50),
			Point(400, 400),
			POINT(x=15, y=15),
			POINT(x=20, y=20),
			POINT(x=50, y=50),
			POINT(x=400, y=400),
			RectLTRB(left=450, top=450, right=505, bottom=1010),
			RECT(450, 450, 490, 990)
		), location)
Example #10
0
 def on_getminmaxinfo(self, hwnd, msg, wparam, lparam):
     info = ctypes.cast(lparam, ctypes.POINTER(MINMAXINFO)).contents
     el, et, er, eb = self._get_edge_sizes()
     if self._dialog_max_size:
         width = self._dialog_max_size[0] + el + er
         height = self._dialog_max_size[1] + et + eb
         point = POINT(width, height)
         info.ptMaxSize = point
         info.ptMaxTrackSize = point
     if self._dialog_min_size:
         width = self._dialog_min_size[0] + el + er
         height = self._dialog_min_size[1] + et + eb
         point = POINT(width, height)
         info.ptMinTrackSize = point
    def mainloop(self):
        cursor_pos = POINT()
        window_rect = RECT()
        self_handle = self.__root.winfo_id()
        self_rect = RECT()

        timer = self.__timer

        @timer.add_observer
        def get_window(event):
            GetCursorPos(byref(cursor_pos))
            handle = WindowFromPoint(cursor_pos)
            GetWindowRect(self_handle, byref(self_rect))
            if not (
                    cursor_pos.y >= self_rect.top and \
                    cursor_pos.x >= self_rect.left and \
                    cursor_pos.y <= self_rect.bottom and \
                    cursor_pos.x <= self_rect.right) and \
                    (handle != GetParent(self_handle)):
                self.__sel_window = handle
                GetWindowRect(handle, byref(window_rect))
                self.__root.geometry(
                    f'+{max(0, window_rect.left)}+{max(0, window_rect.top)}')

        timer.interval = 500
        timer.active = True
        self.__root.mainloop()
Example #12
0
 def get_window_from_point(cls, p=None, main=False):
     """Window From Screen Coordinates or current Mouse Position."""
     if p is None:
         p = POINT()
         if not ctypes.windll.user32.GetCursorPos(byref(p)):
             raise ctypes.WinError()
     elif not isinstance(p, POINT):
         p = POINT(*p)
     w = ctypes.windll.user32.WindowFromPoint(p)
     w = cls(w)
     if main:
         p = w
         while p:
             w = p
             p = w.parent
     return w
def AccessibleObjectFromPoint(x, y):
    "Return an accessible object and an index. See MSDN for details."
    pacc = POINTER(IAccessible)()
    var = VARIANT()
    oledll.oleacc.AccessibleObjectFromPoint(POINT(x, y), byref(pacc),
                                            byref(var))
    return pacc, var
def set_inline_position(hwnd, x, y, font_face, font_height):
    # borrowed from http://d.hatena.ne.jp/doloopwhile/20090627/1275176169
    hIMC = windll.imm32.ImmGetContext(hwnd)
    status = windll.imm32.ImmGetOpenStatus(hIMC)
    # if not status:
    # Enable IME temporary.
    # ctypes.windll.imm32.ImmSetOpenStatus(hIMC, 1)

    pt = POINT(x, y)
    cf = COMPOSITIONFORM()
    cf.dwStyle = 2  # CFS_POINT
    cf.ptCurrentPos = pt

    # Supporting Weasel IME
    # For more detail see also WeaselIME.cpp@WeaselIME::_SetCompositionWindow
    cf.rcArea.left = x
    cf.rcArea.top = y
    if x == 0:
        cf.rcArea.left = 1
    if y == 0:
        cf.rcArea.top = 1
    cf.rcArea.right = cf.rcArea.left
    cf.rcArea.bottom = cf.rcArea.top

    windll.imm32.ImmSetCompositionWindow(hIMC, byref(cf))

    lf = LOGFONT()
    lf.lfHeight = font_height
    lf.lfFaceName = font_face
    windll.imm32.ImmSetCompositionFontW(hIMC, byref(lf))

    if not status:
        ctypes.windll.imm32.ImmSetOpenStatus(hIMC, 0)
    windll.imm32.ImmReleaseContext(hwnd, hIMC)
Example #15
0
 def get_position(self):
     """get mouse position"""
     if not self.silent_mode:
         point = POINT()
         ctypes.windll.user32.GetCursorPos(ctypes.byref(point))
         return (point.x, point.y)
     else:
         return (self.silent_xpos, self.silent_ypos)
Example #16
0
def cache_pointer_offset(self, event):
    #this overrides the window._get_pointer method
    #so we can cache the GTK position offset for synthetic wheel events
    gtk_x, gtk_y = event.x_root, event.y_root
    pos = POINT()
    GetCursorPos(ctypes.byref(pos))
    x, y = pos.x, pos.y
    self.win32_pointer_offset = gtk_x - x, gtk_y - y
    return gtk_x, gtk_y
Example #17
0
def action_handler():
    print("mouse")
    global id4, proc, hwnd
    if proc is None:
        proc = subprocess.Popen(["python", "overlay.py"])
    mouse = POINT()
    user32.GetCursorPos(ctypes.byref(mouse))
    hwnd = user32.WindowFromPoint(mouse)
    id4 = hot.addHotkey(['mouse middle'], up, isThread=False, up=True)
Example #18
0
    def _get_pos_from_tuple(self, position: tuple):
        rect = self.window_rect

        # Adjust point to window client area
        point = POINT(rect.left + position[0], rect.top + position[1])
        ScreenToClient(self.hwnd, byref(point))

        pos = point.x | (point.y * 2**16)
        return pos
Example #19
0
def drag_end(btn='left'):
    pt = POINT()
    windll.user32.GetCursorPos(byref(pt))
    if btn == 'left':
        windll.user32.mouse_event(MOUSEEVENTF_LEFTUP, pt.x, pt.y, 0, 0)
    elif btn == 'right':
        windll.user32.mouse_event(MOUSEEVENTF_RIGHTUP, pt.x, pt.y, 0, 0)
    elif btn == 'middle':
        windll.user32.mouse_event(MOUSEEVENTF_MIDDLEUP, pt.x, pt.y, 0, 0)
Example #20
0
 def click_callback(button, pressed):
     menu = CreatePopupMenu()
     AppendMenu(menu, win32con.MF_STRING, 1024, u"Generate balloon")
     AppendMenu(menu, win32con.MF_STRING, 1025, u"Exit")
     pos = POINT()
     GetCursorPos(byref(pos))
     hwnd = tray.hwnd
     user32.SetForegroundWindow(hwnd)
     user32.TrackPopupMenu(menu, win32con.TPM_LEFTALIGN, pos.x, pos.y, 0, hwnd, None)
     PostMessageA(hwnd, win32con.WM_NULL, 0, 0)
Example #21
0
 def AccessibleObjectFromPoint(x, y):
     """Return an accessible object and an index. See MSDN for details.
 @param  x  int  global pos
 @param  y  int  global pos
 @return  dict, int
 """
     pacc = POINTER(IAccessible)()
     var = VARIANT()
     oledll.oleacc.AccessibleObjectFromPoint(POINT(x, y), byref(pacc),
                                             byref(var))
     return pacc, var
Example #22
0
    def now(normalize=DEFAULT_NORMALIZE):
        """Getting now coord of mouse pointer.

         The normalize is switch of to using mormarize coord.
        """
        point = POINT()
        lppoint = ctypes.pointer(point)
        GetCursorPos(lppoint)
        if normalize:
            point = Normalizer.point(point)
        return point.x, point.y
Example #23
0
    def client_area_rect(self):
        client_rect = RECT()
        win_rect = RECT()
        offset = POINT()

        _USER32.GetClientRect(self.__hwnd, byref(client_rect))
        _USER32.GetWindowRect(self.__hwnd, byref(win_rect))
        _USER32.ClientToScreen(self.__hwnd, byref(offset))

        x = offset.x - win_rect.left
        y = offset.y - win_rect.top
        w = client_rect.right
        h = client_rect.bottom
        return x, y, w, h
Example #24
0
    def get_cursor_position(self):
        """
        Get cursor position.

        :return: A tuple of (x, y).
        """
        # Create point structure
        point = POINT()

        # Get cursor position
        _GetCursorPos(byref(point))

        # Return position tuple
        return (point.x, point.y)
Example #25
0
    def wizsdk_client_coords_to_wizwalker(self, x: int, y: int) -> tuple:
        """
        Converts WizSDK client coords to wizwalker client coords
        """
        # make absolute
        wX, wY, *_ = self.get_rect()
        x += wX
        y += wY

        # convert to the client coords wizwalker uses
        point = POINT(int(x), int(y))
        if (ctypes.windll.user32.ScreenToClient(self.window_handle,
                                                ctypes.byref(point)) == 0):
            raise RuntimeError("Screen to client conversion failed")

        return (point.x, point.y)
Example #26
0
def up():
    global id4, proc, hwnd
    mouse = POINT()
    user32.GetCursorPos(ctypes.byref(mouse))

    hot.removeHotkey(id=id4)

    if proc is not None:
        proc.terminate()

    print("-" * 40)
    print_handles("GetForegroundWindow", user32.GetForegroundWindow())
    active_window = print_handles("WindowFromPoint", hwnd)
    print_handles("GetParent", user32.GetParent(active_window))
    ancestor = print_handles(
        "GetAncestor", user32.GetAncestor(active_window, 3))

    if ancestor:
        # GetAncestor is the most correct for our use-case, so prefer it.
        active_window = ancestor

    rect = RECT()
    user32.GetWindowRect(active_window, ctypes.byref(rect))
    grid = find_matching_grid(mouse.x, mouse.y)

    if grid:
        grid = to_rect(grid)
        if is_aero_enabled():
            arect = get_actual_rect(active_window)
            grid.left -= abs(arect.left - rect.left)
            grid.top -= abs(arect.top - rect.top)
            grid.right += abs(arect.right - rect.right)
            grid.bottom += abs(arect.bottom - rect.bottom)

        width = grid.right - grid.left
        height = grid.bottom - grid.top

        print("width: %d height: %d" % (width, height))

        HWND_NOTOPMOST = -2
        user32.SetWindowPos(active_window, HWND_NOTOPMOST,
                            grid.left, grid.top, width, height, 0)

        user32.SetForegroundWindow(active_window)

    proc = None
    hwnd = None
Example #27
0
 def on_getminmaxinfo(self, hwnd, msg, wparam, lparam):
     if self.max_size and lparam:
         info = ctypes.cast(lparam, ctypes.POINTER(MINMAXINFO)).contents
         width, height = self.max_size
         style = win32api.GetWindowLong(hwnd, win32con.GWL_STYLE)
         if style & win32con.WS_BORDER:
             fw, fh = self.frame_width, self.frame_height
         else:
             fw, fh = 0, 0
         w = width + fw*2
         h = height + self.caption_height + fh*2
         point  = POINT(w, h)
         info.ptMaxSize       = point
         info.ptMaxTrackSize  = point
         log("on_getminmaxinfo window=%#x max_size=%s, frame=%sx%s, minmaxinfo size=%sx%s", hwnd, self.max_size, fw, fh, w, h)
         return 0
     log("on_getminmaxinfo window=%#x max_size=%s", hwnd, self.max_size)
Example #28
0
	def kwargsFromSuper(cls,kwargs,relation=None):
		UIAElement=None
		windowHandle=kwargs.get('windowHandle')
		if isinstance(relation,tuple):
			UIAElement=UIAHandler.handler.clientObject.ElementFromPointBuildCache(POINT(relation[0],relation[1]),UIAHandler.handler.baseCacheRequest)
		elif relation=="focus":
			try:
				UIAElement=UIAHandler.handler.clientObject.getFocusedElementBuildCache(UIAHandler.handler.baseCacheRequest)
				# This object may be in a different window, so we need to recalculate the window handle.
				kwargs['windowHandle']=None
			except COMError:
				log.debugWarning("getFocusedElement failed", exc_info=True)
		else:
			UIAElement=UIAHandler.handler.clientObject.ElementFromHandleBuildCache(windowHandle,UIAHandler.handler.baseCacheRequest)
		if not UIAElement:
			return False
		kwargs['UIAElement']=UIAElement
		return True
Example #29
0
def show_popup_menu(hwnd):
    hide_popup_menu()
    menu = user32.CreatePopupMenu()
    user32.InsertMenuW(menu, 0, MF_BYPOSITION | MF_STRING, ID_PUBLIC,
                       u'Get Public Key')
    user32.InsertMenuW(menu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, None)
    user32.InsertMenuW(menu, 2, MF_BYPOSITION | MF_STRING, ID_EXIT, u'Exit')
    user32.SetMenuDefaultItem(menu, ID_PUBLIC, False)
    user32.SetFocus(hwnd)
    user32.SetForegroundWindow(hwnd)

    pt = POINT()
    user32.GetCursorPos(byref(pt))
    cmd = user32.TrackPopupMenu(menu,
                                TPM_LEFTALIGN | TPM_RETURNCMD | TPM_NONOTIFY,
                                pt.x, pt.y, 0, hwnd, None)
    user32.SendMessageA(hwnd, WM_COMMAND, cmd, 0)
    user32.DestroyMenu(menu)
def set_inline_position(hwnd, x, y, font_face, font_height):
    # borrowed from http://d.hatena.ne.jp/doloopwhile/20090627/1275176169
    hIMC = windll.imm32.ImmGetContext(hwnd)
    status = windll.imm32.ImmGetOpenStatus(hIMC)
    if not status:
        windll.imm32.ImmReleaseContext(hwnd, hIMC)
        return

    pt = POINT(x, y)
    cf = COMPOSITIONFORM()
    cf.dwStyle = 2  # CFS_POINT
    cf.ptCurrentPos = pt
    windll.imm32.ImmSetCompositionWindow(hIMC, byref(cf))

    lf = LOGFONT()
    lf.lfHeight = font_height
    lf.lfFaceName = font_face
    windll.imm32.ImmSetCompositionFontW(hIMC, byref(lf))

    windll.imm32.ImmReleaseContext(hwnd, hIMC)
Example #31
0
 def click_callback(button, pressed):
     CreatePopupMenu = user32.CreatePopupMenu
     CreatePopupMenu.restype = ctypes.wintypes.HMENU
     CreatePopupMenu.argtypes = []
     AppendMenu = user32.AppendMenuW
     AppendMenu.restype = ctypes.wintypes.BOOL
     AppendMenu.argtypes = [
         ctypes.wintypes.HMENU, ctypes.wintypes.UINT, ctypes.wintypes.UINT,
         ctypes.wintypes.LPCWSTR
     ]
     menu = CreatePopupMenu()
     AppendMenu(menu, win32con.MF_STRING, 1024, u"Generate balloon")
     AppendMenu(menu, win32con.MF_STRING, 1025, u"Exit")
     pos = POINT()
     GetCursorPos(byref(pos))
     hwnd = tray.hwnd
     user32.SetForegroundWindow(hwnd)
     user32.TrackPopupMenu(menu, win32con.TPM_LEFTALIGN, pos.x, pos.y, 0,
                           hwnd, None)
     PostMessageA(hwnd, win32con.WM_NULL, 0, 0)
Example #32
0
 def getCoordinate(self, whos):
     pyautogui.FAILSAFE = False
     try:
         QMessageBox.about(None, "提示!!!", "放到鼠标点击位置2秒钟")
         self.mainwind.hide()
         time.sleep(2)
         po = POINT()
         windll.user32.GetCursorPos(byref(po))
         if whos == 1:
             self.y1 = int(po.y)
             self.x1 = int(po.x)
             self.click.lineEdit_2.setText(
                 str(self.x1) + ":" + str(self.y1))
         elif whos == 2:
             self.y2 = int(po.y)
             self.x2 = int(po.x)
             self.click.lineEdit_6.setText(
                 str(self.x2) + ":" + str(self.y2))
     except KeyboardInterrupt as e:
         print('有异常请确定' + e)
     self.mainwind.show()
Example #33
0
 def __init__(self, gui):
     """
     :type gui:PyQt5.WindowGUI.WindowGUI
     """
     super().__init__()
     # gui.setWindowIcon(QIcon(self.resource_path(gui.icon_path)))
     # gui.icon_area.setPixmap(
     #     QPixmap(self.resource_path(gui.icon_path)).scaled(30, 30))
     self.mousePos_pointer = POINT()  # マウスカーソル座標の変更用
     self.pressedCtrl = False
     self.pressedShift = False
     # タイマー処理のインスタンス(別スレッド)
     self.timerThread = TimerThread()
     self.timerThread.start()
     self.timerThread.CtrlTimeoutSignal.connect(self.timeout_Ctrl)
     self.timerThread.ShiftTimeoutSignal.connect(self.timeout_Shift)
     # グローバルホットキーに反応 ===========================
     # 同じキーを押し続けると連続発動するので,
     # trigger_on release:Trueによって離すまで発動を止める
     keyboard.add_hotkey('ctrl',
                         lambda: self.onPressCtrl_global(gui),
                         trigger_on_release=True)
     keyboard.add_hotkey('shift',
                         lambda: self.onPressShift_global(gui),
                         trigger_on_release=True)
     keyboard.add_hotkey('ctrl+shift,ctrl+shift',
                         lambda: self.autoComplete_single(gui),
                         trigger_on_release=True)
     keyboard.add_hotkey('ctrl+space',
                         gui.switchMemorize,
                         trigger_on_release=True)
     keyboard.add_hotkey('shift+tab',
                         gui.rollBack_at_flag,
                         trigger_on_release=True)
     # このアプリのハンドルを取得 ===========================
     self.thisHandle = findwindows.find_window(title='Keasy',
                                               class_name='Qt5QWindowIcon')
     self.thisWindowWrapper = hwndwrapper.HwndWrapper(self.thisHandle)
Example #34
0
def makePOINT(point):
    pt = POINT()
    pt.x, pt.y = point
    return pt