def keepAlive(self):
if self.kbHook is None:
return
msg = win32gui.GetMessage(None, 0, 0)
while msg and self.kbHook is not None:
win32gui.TranslateMessage(byref(msg))
win32gui.DispatchMessage(byref(msg))
msg = win32gui.GetMessage(None, 0, 0)
def wait_for_hotkeys():
def handle_windows(nCode, wParam, lParam):
isKeyDown = False
isKeyUp = False
if wParam == win32con.WM_KEYDOWN or wParam == win32con.WM_SYSKEYDOWN:
isKeyDown = True
if wParam == win32con.WM_KEYUP or wParam == win32con.WM_SYSKEYUP:
isKeyUp = True
shouldContinue = True
if isKeyDown or isKeyUp:
shouldContinue = not handle_python(isKeyDown, lParam[0], lParam[1])
if shouldContinue:
return windll.user32.CallNextHookEx(windowsHook, nCode, wParam, lParam)
return 1
HANDLER = CFUNCTYPE(c_uint, c_uint, c_uint, POINTER(c_uint))
handlerPtr = HANDLER(handle_windows)
setWindowsHookExA = windll.user32.SetWindowsHookExA
setWindowsHookExA.argtypes = (wintypes.DWORD, HANDLER, wintypes.HINSTANCE, wintypes.DWORD)
windowsHook = setWindowsHookExA(win32con.WH_KEYBOARD_LL, handlerPtr, windll.kernel32.GetModuleHandleW(None), 0)
atexit.register(windll.user32.UnhookWindowsHookEx, windowsHook)
while not pylewm.commands.stopped:
msg = win32gui.GetMessage(None, 0, 0)
win32gui.TranslateMessage(byref(msg))
win32gui.DispatchMessage(byref(msg))
def start(self):
while self._running:
b, msg = win32gui.GetMessage(0, 0, 0)
if not msg:
break
win32gui.TranslateMessage(msg)
win32gui.DispatchMessage(msg)
def listen():
"""
Calls `handlers` for each keyboard event received. This is a blocking call.
"""
# Adapted from http://www.hackerthreads.org/Topic-42395
from ctypes import windll, CFUNCTYPE, POINTER, c_int, c_void_p, byref
import win32con, win32api, win32gui, atexit
event_types = {
win32con.WM_KEYDOWN: 'key down',
win32con.WM_KEYUP: 'key up',
0x104: 'key down', # WM_SYSKEYDOWN, used for Alt key.
0x105: 'key up', # WM_SYSKEYUP, used for Alt key.
}
def low_level_handler(nCode, wParam, lParam):
"""
Processes a low level Windows keyboard event.
"""
event = KeyboardEvent(event_types[wParam], lParam[0], lParam[1],
lParam[2] == 32, lParam[3])
for handler in handlers:
handler(event)
# Be a good neighbor and call the next hook.
return windll.user32.CallNextHookEx(hook_id, nCode, wParam, lParam)
def low_level_mouse_handler(nCode, wParam, lParam):
event = MouseEvent(MSG_TEXT.get(wParam, str(wParam)), lParam[0],
lParam[1], lParam[2] == 32, lParam[3])
if wParam == win32con.WM_LBUTTONDOWN:
print('Click here')
for handler in handlers:
handler(event)
# Be a good neighbor and call the next hook.
return windll.user32.CallNextHookEx(mouse_hook_id, nCode, wParam,
lParam)
# Our low level handler signature.
CMPFUNC = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_void_p))
# Convert the Python handler into C pointer.
pointer = CMPFUNC(low_level_handler)
mouse_pointer = CMPFUNC(low_level_mouse_handler)
# Hook both key up and key down events for common keys (non-system).
hook_id = windll.user32.SetWindowsHookExW(win32con.WH_KEYBOARD_LL, pointer,
None, 0)
mouse_hook_id = windll.user32.SetWindowsHookExW(win32con.WH_MOUSE_LL,
mouse_pointer, None, 0)
# Register to remove the hook when the interpreter exits. Unfortunately a
# try/finally block doesn't seem to work here.
atexit.register(windll.user32.UnhookWindowsHookEx, hook_id)
while True:
msg = win32gui.GetMessage(None, 0, 0)
win32gui.TranslateMessage(byref(msg))
win32gui.DispatchMessage(byref(msg))
def dispatchMessage(winid): import win32api,win32gui,win32con status, msg = win32gui.PeekMessage(winid,0,0,win32con.PM_NOREMOVE) if not msg[0] == 0: b,msg = win32gui.GetMessage(winid,0,0) if msg: win32gui.TranslateMessage(msg) win32gui.DispatchMessage(msg)
def windowmessage(self):
"""
Returns the message from hWindow's queue
Returns None on error
"""
try:
return win32gui.GetMessage(self.hWindow, 0, 0)
except win32gui.error:
logging.exception("Error while grabbing the window message")
return None
def monitor_thread(cb, wc):
hwnd = win32gui.CreateWindow(wc.lpszClassName, "TimeChangeWindow",
win32con.WS_OVERLAPPED, 0, 0,
win32con.CW_USEDEFAULT,
win32con.CW_USEDEFAULT, 0, 0, wc.hInstance,
None)
acc_err = 0
while True:
mt, tt = time.monotonic(), time.time()
win32gui.GetMessage(hwnd, win32con.WM_TIMECHANGE,
win32con.WM_TIMECHANGE)
mtt, ttt = time.monotonic(), time.time()
x = abs((ttt - tt) - (mtt - mt))
acc_err += x
if acc_err > 0.1:
acc_err = 0
cb()
def mainloop(self):
while True:
code, msg = win32gui.GetMessage(0, 0, 0)
if not code:
break
if code < 0:
error = win32api.GetLastError()
raise RuntimeError(error)
#######################################
### Trio specific part of main loop ###
#######################################
hwnd, msgid, lparam, wparam, time, point = msg
if hwnd == win32con.NULL and msgid == TRIO_MSG:
do_trio()
continue
###############################
### Trio specific part ends ###
###############################
win32gui.TranslateMessage(msg)
win32gui.DispatchMessage(msg)
def _run_window(self):
# Create hidden window
log.debug('_run_window start')
wc = win32gui.WNDCLASS()
wc.lpszClassName = 'devicenotify'
wc.style = win32con.CS_GLOBALCLASS | win32con.CS_VREDRAW | win32con.CS_HREDRAW
wc.hbrBackground = win32con.COLOR_WINDOW + 1
wc.lpfnWndProc = self.window_callback
class_atom = win32gui.RegisterClass(wc)
if not class_atom:
log.error('window class not created')
return
self._hwnd = win32gui.CreateWindow(wc.lpszClassName, 'devicenotify',
win32con.WS_CAPTION, 100, 100, 900,
900, 0, 0, 0, None)
if not self._hwnd:
log.error('window not created')
return
# Watch for all USB device notifications
devfilt = win32gui_struct.PackDEV_BROADCAST_DEVICEINTERFACE(
GUID_DEVINTERFACE_USB_DEVICE)
self._event = win32gui.RegisterDeviceNotification(
self._hwnd, devfilt, win32con.DEVICE_NOTIFY_WINDOW_HANDLE)
while 1:
b, msg = win32gui.GetMessage(None, 0, 0)
log.debug('win32_device_notify message')
if not b or not msg:
break
win32gui.TranslateMessage(msg)
win32gui.DispatchMessage(msg)
win32gui.UnregisterDeviceNotification(self._event)
win32gui.UnregisterClass(wc.lpszClassName, None)
self._hwnd = None
log.debug('_run_window done')
def start(self, asynchronous=True):
if asynchronous:
print('async hook')
import threading
threading.Thread(target=self.start, kwargs={
'asynchronous': False
}).start()
return
print('starting hook')
import win32con
keyboard_event_types = {
win32con.WM_KEYDOWN: 'key down',
win32con.WM_KEYUP: 'key up',
0x104: 'key down', # WM_SYSKEYDOWN, used for Alt key.
0x105: 'key up', # WM_SYSKEYUP, used for Alt key.
}
mouse_event_types = {
win32con.WM_RBUTTONDOWN: 'RMB down',
win32con.WM_RBUTTONUP: 'RMB up',
win32con.WM_MOUSEMOVE: 'mouse move'
}
def low_level_keyboard_handler(nCode, wParam, lParam):
event = (nCode,
self.KeyboardEvent(keyboard_event_types[wParam],
lParam[0], lParam[1], lParam[2] == 32,
lParam[3]))
# Be a good neighbor and call the next hook.
if self.keyboard_callback(event):
return ctypes.windll.user32.CallNextHookEx(
self.hook_id_keyboard, nCode, wParam, lParam)
else:
print("#")
return 1
def low_level_mouse_handler(nCode, wParam, lParam):
event = (nCode, mouse_event_types.get(wParam, 'unknown'))
if self.mouse_callback(event):
# Be a good neighbor and call the next hook.
return ctypes.windll.user32.CallNextHookEx(
self.hook_id_mouse, nCode, wParam, lParam)
else:
return 1
import ctypes
CMPFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int,
ctypes.POINTER(ctypes.c_void_p))
# Convert the Python handler into C pointer.
pointer_keyboard = CMPFUNC(low_level_keyboard_handler)
pointer_mouse = CMPFUNC(low_level_mouse_handler)
import win32api
# Hook both key up and key down events for common keys (non-system).
self.hook_id_keyboard = ctypes.windll.user32.SetWindowsHookExA(
win32con.WH_KEYBOARD_LL, pointer_keyboard,
win32api.GetModuleHandle(None), 0)
self.hook_id_mouse = ctypes.windll.user32.SetWindowsHookExA(
win32con.WH_MOUSE_LL, pointer_mouse,
win32api.GetModuleHandle(None), 0)
# Register to remove the hook when the interpreter exits. Unfortunately a
# try/finally block doesn't seem to work here.
import atexit
atexit.register(ctypes.windll.user32.UnhookWindowsHookEx,
self.hook_id_keyboard)
atexit.register(ctypes.windll.user32.UnhookWindowsHookEx,
self.hook_id_mouse)
while True:
import win32gui
#peek_result, msg = win32gui.PeekMessage(None, 0, 0, 1)
result, msg = win32gui.GetMessage(None, 0, 0)
print('got msg:', msg)
win32gui.TranslateMessage(msg)
#print('translated')
win32gui.DispatchMessage(msg)
#print('sent')
#sleep(0.5)
pass
import win32api, win32con, win32gui, time
hn = win32gui.FindWindow(
None, '192.168.23.121 - SecureCRT') #查找到桌面上10.20.1.33 - SecureCRT的窗口
win32gui.ShowWindow(hn, win32con.SW_SHOWNORMAL) #正常显示这个窗口
time.sleep(1)
hWndChildList = []
win32gui.EnumChildWindows(hn, lambda hWnd, param: param.append(hWnd),
hWndChildList)
print hWndChildList
for x in hWndChildList:
print str(x) + ':' + win32gui.GetWindowText(
x) + '-' + win32gui.GetClassName(x)
hn2 = win32gui.FindWindowEx(hn, None, 'MDIClient',
None) #用spy++查找#32770的窗口，因为我发现它下面有‘edit’控件。
hn2 = 263886
print hn2
#hn2=win32gui.FindWindowEx(hn,None,'Edit',None) #查找到edit控件
time.sleep(1)
win32gui.SetForegroundWindow(hn2) #选中edit控件
time.sleep(1)
win32gui.PostMessage(hn2, win32con.WM_KEYDOWN, win32con.VK_RETURN, 0)
win32gui.PostMessage(hn2, win32con.WM_KEYUP, win32con.VK_RETURN, 0)
win32gui.SendMessage(hn2, win32con.WM_SETTEXT, None,
'show card') #向这个窗口输入setup指令（‘setup’是linux上的一个shell命令）
time.sleep(1)
win32gui.PostMessage(hn2, win32con.WM_KEYDOWN, win32con.VK_RETURN, 0)
win32gui.PostMessage(hn2, win32con.WM_KEYUP, win32con.VK_RETURN, 0)
win32gui.GetMessage(263886, win32con.WM_SETTEXT, 1)
def init_keyboard_listener(self):
from ctypes import CFUNCTYPE, c_int, POINTER, Structure
from ctypes.wintypes import DWORD, WPARAM, LPARAM
class WindowsKeyEvent(AdHocStruct):
pass
class KBDLLHOOKSTRUCT(Structure):
_fields_ = [
("vk_code", DWORD),
("scan_code", DWORD),
("flags", DWORD),
("time", c_int),
]
DOWN = [win32con.WM_KEYDOWN, win32con.WM_SYSKEYDOWN]
#UP = [win32con.WM_KEYUP, win32con.WM_SYSKEYUP]
ALL_KEY_EVENTS = {
win32con.WM_KEYDOWN: "KEYDOWN",
win32con.WM_SYSKEYDOWN: "SYSKEYDOWN",
win32con.WM_KEYUP: "KEYUP",
win32con.WM_SYSKEYUP: "SYSKEYUP",
}
def low_level_keyboard_handler(nCode, wParam, lParam):
try:
scan_code = lParam.contents.scan_code
focused = self.client._focused
keyname = {
win32con.VK_LWIN: "Super_L",
win32con.VK_RWIN: "Super_R",
}.get(scan_code)
keycode = 0
modifiers = []
kh = self.client.keyboard_helper
if focused and keyname and kh and kh.keyboard and wParam in ALL_KEY_EVENTS:
modifier_keycodes = kh.keyboard.modifier_keycodes
modifier_keys = kh.keyboard.modifier_keys
#find the keycode: (try the exact key we hit first)
for x in (keyname, "Super_L", "Super_R"):
keycodes = modifier_keycodes.get(x, [])
for k in keycodes:
#only interested in numeric keycodes:
try:
keycode = int(k)
break
except:
pass
if keycode > 0:
break
for vk, modkeynames in {
win32con.VK_NUMLOCK: ["Num_Lock"],
win32con.VK_CAPITAL: ["Caps_Lock"],
win32con.VK_CONTROL: ["Control_L", "Control_R"],
win32con.VK_SHIFT: ["Shift_L", "Shift_R"],
}.items():
if win32api.GetKeyState(vk):
for modkeyname in modkeynames:
mod = modifier_keys.get(modkeyname)
if mod:
modifiers.append(mod)
break
#keylog.info("keyboard helper=%s, modifier keycodes=%s", kh, modifier_keycodes)
keylog(
"scan_code=%s, event=%s, keyname=%s, keycode=%s, modifiers=%s, focused=%s",
scan_code, ALL_KEY_EVENTS.get(wParam), keyname,
keycode, modifiers, focused)
if keycode > 0:
key_event = WindowsKeyEvent()
key_event.keyname = keyname
key_event.pressed = wParam in DOWN
key_event.modifiers = modifiers
key_event.keyval = scan_code
key_event.keycode = keycode
key_event.string = ""
key_event.group = 0
keylog("detected windows key, sending %s", key_event)
self.client.keyboard_helper.send_key_action(
focused, key_event)
#swallow this event:
return 1
except Exception as e:
keylog.error("Error: low level keyboard hook failed")
keylog.error(" %s", e)
return windll.user32.CallNextHookEx(keyboard_hook_id, nCode,
wParam, lParam)
# Our low level handler signature.
CMPFUNC = CFUNCTYPE(c_int, WPARAM, LPARAM, POINTER(KBDLLHOOKSTRUCT))
# Convert the Python handler into C pointer.
pointer = CMPFUNC(low_level_keyboard_handler)
# Hook both key up and key down events for common keys (non-system).
keyboard_hook_id = windll.user32.SetWindowsHookExA(
win32con.WH_KEYBOARD_LL, pointer, win32api.GetModuleHandle(None),
0)
# Register to remove the hook when the interpreter exits:
keylog("init_keyboard_listener() hook_id=%#x", keyboard_hook_id)
while True:
msg = win32gui.GetMessage(None, 0, 0)
keylog("init_keyboard_listener: GetMessage()=%s", msg)
win32gui.TranslateMessage(byref(msg))
win32gui.DispatchMessage(byref(msg))
def start(self, asynchronous=True):
if asynchronous:
print('async hook')
t = threading.Thread(target=self.start,
kwargs={'asynchronous': False})
self.running = True
t.start()
return t
print('starting hook')
keyboard_event_types = {
win32con.WM_KEYDOWN: 'key down',
win32con.WM_KEYUP: 'key up',
0x104: 'key down', # WM_SYSKEYDOWN, used for Alt key.
0x105: 'key up', # WM_SYSKEYUP, used for Alt key.
}
# WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_MOUSEHWHEEL, WM_RBUTTONDOWN, or WM_RBUTTONUP.
mouse_event_types = {
win32con.WM_RBUTTONDOWN: 'RMB down',
win32con.WM_RBUTTONUP: 'RMB up',
win32con.WM_LBUTTONDOWN: 'LMB down',
win32con.WM_LBUTTONUP: 'LMB up',
0x0207: 'MMB down',
0x0208: 'MMB up',
win32con.WM_MOUSEWHEEL: 'Wheel',
0x020E: 'Horizontal Wheel', # win32con.WM_MOUSEHWHEEL
win32con.WM_MOUSEMOVE: 'mouse move'
}
def low_level_keyboard_handler(nCode, wParam, lParam):
event = (nCode,
self.KeyboardEvent(
event_type=keyboard_event_types[wParam],
key_code=lParam[0] & 0xFFFFFFFF,
scan_code=lParam[1] & 0xFFFFFFFF,
alt_pressed=lParam[2] == 32,
time=lParam[3]
& 0xFFFFFFFF if lParam[3] is not None else 0,
extra_info=lParam[4])) # unsigned int 64 for 32bit
# Be a good neighbor and call the next hook.
if self.keyboard_callback(event):
return ctypes.windll.user32.CallNextHookEx(
self.hook_id_keyboard, nCode, wParam, lParam)
else:
print("#")
return 1
def low_level_mouse_handler(nCode, wParam, lParam):
event = (nCode,
self.MouseEvent(event_type=mouse_event_types.get(
wParam, f'unknown ({hex(wParam)})'),
point=lParam[0],
wheel_direction=lParam[1],
injection=lParam[2],
time=lParam[3]))
if self.mouse_callback(event):
# Be a good neighbor and call the next hook.
return ctypes.windll.user32.CallNextHookEx(
self.hook_id_mouse, nCode, wParam, lParam)
else:
return 1
CMPFUNC = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int,
ctypes.POINTER(ctypes.c_void_p))
# Convert the Python handler into C pointer.
pointer_keyboard = CMPFUNC(low_level_keyboard_handler)
pointer_mouse = CMPFUNC(low_level_mouse_handler)
# Hook both key up and key down events for common keys (non-system).
try:
wh_keyboard_lo_level = win32con.WH_KEYBOARD_LL
wh_mouse_low_level = win32con.WH_MOUSE_LL
p_keyoard = pointer_keyboard
p_mouse = pointer_mouse
module_handle = win32api.GetModuleHandle(None)
module_handle = 0
self.hook_id_keyboard = ctypes.windll.user32.SetWindowsHookExA(
wh_keyboard_lo_level, p_keyoard, module_handle, 0)
self.hook_id_mouse = ctypes.windll.user32.SetWindowsHookExA(
wh_mouse_low_level, p_mouse, module_handle, 0)
except Exception as ex:
print(ex)
# Register to remove the hook when the interpreter exits.
# Unfortunately a
# try/finally block doesn't seem to work here.
atexit.register(ctypes.windll.user32.UnhookWindowsHookEx,
self.hook_id_keyboard)
atexit.register(ctypes.windll.user32.UnhookWindowsHookEx,
self.hook_id_mouse)
while self.running:
#peek_result, msg = win32gui.PeekMessage(None, 0, 0, 1)
result, msg = win32gui.GetMessage(None, 0, 0)
print('got msg:', msg, result)
win32gui.TranslateMessage(msg)
#print('translated')
win32gui.DispatchMessage(msg)
#print('sent')
#sleep(0.5)
pass
def listen():
def low_level_handler(nCode, wParam, lParam):
global c_word
global shift
global other
Key = lParam[0] & 0xffff
if Key == 160 or Key == 161 or Key == 16:
shift = True if wParam == WM_KEYDOWN else False
if Key == 91 or Key == 92 or \
Key == 162 or Key == 163 or \
Key == 163 or Key == 164 or Key == 18:
other = True if wParam == WM_KEYDOWN else False
if wParam == WM_KEYDOWN:
if(34 <= Key <= 40 or
44 <= Key <= 46 or
Key == 145 or Key == 19 or
Key == 13 or Key == 32) \
and not self:
print("c_word Cleared!")
c_word.clear()
if Key == 8 and not self:
if len(c_word) > 0:
del c_word[-1]
print(
"removed 1 item from c_word,\nnow lenght is {}".format(
len(c_word)))
else:
print("c_word is empty.")
if(65 <= Key <= 90 or
48 <= Key <= 57 or
186 <= Key <= 192 or
219 <= Key <= 222) \
and not other and not self:
kst = create_string_buffer(256)
if not shift:
print(ToUn(Key, 0, kst, lcs.GetCurrentLocale()))
c_word.append(YuKey(Key, False))
else:
kst[16] = 0xff
print(ToUn(Key, 0, kst, lcs.GetCurrentLocale()))
c_word.append(YuKey(Key, True))
return windll.user32.CallNextHookEx(hook_id, nCode, wParam, lParam)
CMPFUNC = CFUNCTYPE(c_int, c_int, c_int, POINTER(c_void_p))
pointer = CMPFUNC(low_level_handler)
hook_id = windll.user32.SetWindowsHookExA(WH_KEYBOARD_LL, pointer,
w3a.GetModuleHandle(None), 0)
def low_level_mouse_handler(nCode, wParam, lParam):
if wParam == WM_LBUTTONUP or wParam == WM_RBUTTONUP:
print('c_word Cleared!')
c_word.clear()
return windll.user32.CallNextHookEx(hook2_id, nCode, wParam, lParam)
pointer2 = CMPFUNC(low_level_mouse_handler)
hook2_id = windll.user32.SetWindowsHookExA(WH_MOUSE_LL, pointer2,
w3a.GetModuleHandle(None), 0)
atexit.register(windll.user32.UnhookWindowsHookEx, hook_id)
while True:
try:
msg = w3g.GetMessage(None, 0, 0)
w3g.TranslateMessage(brf(msg))
w3g.DispatchMessage(brf(msg))
except TypeError:
HKHandle(msg[1][2])
def WinMain(self):
hInstance = win32api.GetModuleHandle()
wndClass = win32gui.WNDCLASS()
wndClass.hInstance = hInstance
wndClass.lpszClassName = self.szClassName
wndClass.lpfnWndProc = self.WndProc
wndClass.style = win32con.CS_DBLCLKS
wndClass.hIcon = win32gui.LoadIcon(0, win32con.IDI_APPLICATION)
wndClass.hCursor = win32gui.LoadCursor(0, win32con.IDC_ARROW)
wndClass.cbWndExtra = 0
wndClass.hbrBackground = win32gui.GetStockObject(win32con.BLACK_BRUSH)
tWnd = win32gui.FindWindow(0, self.TargetName)
if tWnd == 0:
exit(1) # 시작시 타켓윈도우 없으면 종료
# while tWnd == 0:
# tWnd = win32gui.FindWindow(0, self.TargetName) # 타겟윈도우 찾을때까지 반복
tRect = win32gui.GetWindowRect(tWnd)
wWidth = tRect[2] - tRect[0]
wHeight = tRect[3] - tRect[1]
if not tWnd:
wWidth = 400
wHeight = 350
wndClassAtom = None
try:
wndClassAtom = win32gui.RegisterClass(wndClass)
except Exception as e:
print(e)
raise e
self.hWnd = win32gui.CreateWindowEx(
win32con.WS_EX_TOPMOST | win32con.WS_EX_TRANSPARENT, wndClassAtom,
"Overlay", win32con.WS_POPUP, 100, 90, wWidth, wHeight, 0, 0,
hInstance, None)
#hWnd
# Show & update the window
win32gui.ShowWindow(self.hWnd, win32con.SW_SHOW)
win32gui.UpdateWindow(self.hWnd)
win32gui.SetWindowLong(
self.hWnd, win32con.GWL_EXSTYLE,
win32gui.GetWindowLong(self.hWnd, win32con.GWL_EXSTYLE)
^ win32con.WS_EX_LAYERED)
win32gui.SetLayeredWindowAttributes(self.hWnd, win32api.RGB(0, 0, 0),
0, win32con.LWA_COLORKEY)
# win32ui.CreateThread(SetWindow, hWnd)
t = threading.Thread(target=self.SetWindow, args=(self.hWnd, ))
t.daemon = True
t.start()
#msg pump
msg = win32gui.GetMessage(self.hWnd, 0, 0)
msg = msg[1]
while msg[1]:
win32gui.TranslateMessage(msg)
win32gui.DispatchMessage(msg)
msg = win32gui.GetMessage(self.hWnd, 0, 0)
msg = msg[1]
if self.flag == True:
exit(0)
