Python win32api.GetKeyState() Examples

def ctrl_click(x :int, y :int) -> None:
        """Clicks at pixel x, y while simulating the CTRL button to be down."""
        x += Window.x
        y += Window.y
        lParam = win32api.MAKELONG(x, y)
        while (win32api.GetKeyState(wcon.VK_CONTROL) < 0 or
               win32api.GetKeyState(wcon.VK_SHIFT) < 0 or
               win32api.GetKeyState(wcon.VK_MENU) < 0):
            time.sleep(0.005)

        win32gui.PostMessage(Window.id, wcon.WM_KEYDOWN, wcon.VK_CONTROL, 0)
        win32gui.PostMessage(Window.id, wcon.WM_LBUTTONDOWN,
                             wcon.MK_LBUTTON, lParam)
        win32gui.PostMessage(Window.id, wcon.WM_LBUTTONUP,
                             wcon.MK_LBUTTON, lParam)
        win32gui.PostMessage(Window.id, wcon.WM_KEYUP, wcon.VK_CONTROL, 0)
        time.sleep(userset.MEDIUM_SLEEP) 

def click_drag(x :int, y :int, x2 :int, y2 :int) -> None:
        """Click at pixel xy."""
        x += Window.x
        y += Window.y
        x2 += Window.x
        y2 += Window.y
        lParam = win32api.MAKELONG(x, y)
        lParam2 = win32api.MAKELONG(x2, y2)
        # MOUSEMOVE event is required for game to register clicks correctly
        win32gui.PostMessage(Window.id, wcon.WM_MOUSEMOVE, 0, lParam)
        while (win32api.GetKeyState(wcon.VK_CONTROL) < 0 or
               win32api.GetKeyState(wcon.VK_SHIFT) < 0 or
               win32api.GetKeyState(wcon.VK_MENU) < 0):
            time.sleep(0.005)
        win32gui.PostMessage(Window.id, wcon.WM_LBUTTONDOWN,
                             wcon.MK_LBUTTON, lParam)
        time.sleep(userset.LONG_SLEEP * 2)
        win32gui.PostMessage(Window.id, wcon.WM_MOUSEMOVE, 0, lParam2)
        time.sleep(userset.SHORT_SLEEP)
        win32gui.PostMessage(Window.id, wcon.WM_LBUTTONUP,
                             wcon.MK_LBUTTON, lParam2)
        time.sleep(userset.MEDIUM_SLEEP) 

def OnKeyDown(self, msg):
		key = msg[2]
		if win32api.GetKeyState(win32con.VK_CONTROL) & 0x8000:
			modList = MODIFYING_VK_KEYS_CTRL
		elif win32api.GetKeyState(win32con.VK_MENU) & 0x8000:
			modList = MODIFYING_VK_KEYS_ALT
		else:
			modList = MODIFYING_VK_KEYS

		if key in modList:
			# Return 1 if we can make the file editable.(or it already is!)
			return self.GetDocument().CheckMakeDocumentWritable()
		return 1 # Pass it on OK

#	def OnKey(self, key):
#		return self.GetDocument().CheckMakeDocumentWritable() 

def set_foreground(self):
        # Bring this window into the foreground if it isn't already the
        # current foreground window.
        if self.handle != win32gui.GetForegroundWindow():
            if self.is_minimized:
                self.restore()

            # Press a key so Windows allows us to use SetForegroundWindow()
            # (received last input event). See Microsoft's documentation on
            # SetForegroundWindow() for why this works.
            # Only do this if neither the left or right control keys are
            # held down.
            if win32api.GetKeyState(win32con.VK_CONTROL) == 0:
                Key("control:down,control:up").execute()

            # Set the foreground window.
            self._set_foreground() 

def is_lmb_pressed():
    return win32api.GetKeyState(LMB) < 0 

def click(x :int, y :int, button :str ="left", fast :bool =False) -> None:
        """Click at pixel xy."""
        x += Window.x
        y += Window.y
        lParam = win32api.MAKELONG(x, y)
        # MOUSEMOVE event is required for game to register clicks correctly
        win32gui.PostMessage(Window.id, wcon.WM_MOUSEMOVE, 0, lParam)
        while (win32api.GetKeyState(wcon.VK_CONTROL) < 0 or
               win32api.GetKeyState(wcon.VK_SHIFT) < 0 or
               win32api.GetKeyState(wcon.VK_MENU) < 0):
            time.sleep(0.005)
        if button == "left":
            win32gui.PostMessage(Window.id, wcon.WM_LBUTTONDOWN,
                                 wcon.MK_LBUTTON, lParam)
            win32gui.PostMessage(Window.id, wcon.WM_LBUTTONUP,
                                 wcon.MK_LBUTTON, lParam)
        else:
            win32gui.PostMessage(Window.id, wcon.WM_RBUTTONDOWN,
                                 wcon.MK_RBUTTON, lParam)
            win32gui.PostMessage(Window.id, wcon.WM_RBUTTONUP,
                                 wcon.MK_RBUTTON, lParam)
        # Sleep lower than 0.1 might cause issues when clicking in succession
        if fast:
            time.sleep(userset.FAST_SLEEP)
        else:
            time.sleep(userset.MEDIUM_SLEEP) 

def send_string(string :str) -> None:
        """Send one or multiple characters to the Window."""
        # Ensure it's a string by converting it to a string
        if isinstance(string, float):
            string = int(string)
        for c in str(string):
            # Make sure no key modifier is pressed
            while (win32api.GetKeyState(wcon.VK_CONTROL) < 0 or
                   win32api.GetKeyState(wcon.VK_SHIFT)   < 0 or
                   win32api.GetKeyState(wcon.VK_MENU)    < 0):
                time.sleep(0.005)
            
            vkc = win32api.VkKeyScan(c)  # Get virtual key code for character c
            # Only one keyup or keydown event needs to be sent
            win32gui.PostMessage(Window.id, wcon.WM_KEYDOWN, vkc, 0) 

def fire_key_event(self, msg):
		key = msg[2]
		keyState = 0
		if win32api.GetKeyState(win32con.VK_CONTROL) & 0x8000:
			keyState = keyState | win32con.RIGHT_CTRL_PRESSED | win32con.LEFT_CTRL_PRESSED
		if win32api.GetKeyState(win32con.VK_SHIFT) & 0x8000:
			keyState = keyState | win32con.SHIFT_PRESSED
		if win32api.GetKeyState(win32con.VK_MENU) & 0x8000:
			keyState = keyState | win32con.LEFT_ALT_PRESSED | win32con.RIGHT_ALT_PRESSED
		keyinfo = key, keyState
		# Special hacks for the dead-char key on non-US keyboards.
		# (XXX - which do not work :-(
		event = self.keymap.get( keyinfo )
		if event is None:
##			if key == 220: # Dead key
##				return 1
##			# Translate the raw scancode into an Ascii character.
##			print "translating", key, "(with state)", keyState,
##			key = win32ui.TranslateVirtualKey(key)
##			print "Got back key", `key`,
####			if key is None:
####				return 1 # Dead-key - don't handle at all!!!
##			if key:
##				# Then back to a "normalized" scan-code.
##				key = keycodes.get_scan_code(key[0])
##				keyinfo = key, keyState
##				event = self.keymap.get( keyinfo )
##			if event is None:
				return 1
		return self.fire(event, None) 

def OnFileRun( self, id, code ):
		" Called when a FileRun message is received. "
		import scriptutils
		showDlg = win32api.GetKeyState(win32con.VK_SHIFT) >= 0
		scriptutils.RunScript(None, None, showDlg) 

def OnKeyTab(self, key):
		if not self.GetDocument().CheckMakeDocumentWritable(): return 0
		start, end = self._obj_.GetSel()
		if start==end:	# normal TAB key
			self.Indent()
			return 0 # we handled this.

		# Otherwise it is a block indent/dedent.
		if start>end:
			start, end = end, start	# swap them.
		startLine = self._obj_.LineFromChar(start)
		endLine = self._obj_.LineFromChar(end)

		self.BlockDent(win32api.GetKeyState(win32con.VK_SHIFT)>=0, startLine, endLine)
		return 0 

def get_mouse_click():
    """Check if one of the three main mouse buttons is being clicked.
    Returns:
        True/False if any clicks have been detected or not.
    """
    buttons = (win32con.VK_LBUTTON, win32con.VK_MBUTTON, win32con.VK_RBUTTON)
    return tuple(win32api.GetKeyState(button) < 0 for button in buttons) 

def get_key_press(key):
    """Check if a key is being pressed.
    Needs changing for something that detects keypresses in applications.
    Returns:
        True/False if the selected key has been pressed or not.
    """
    return win32api.GetKeyState(key) < 0