示例#1
0
    def __iter__(self):
        """Initialises the message loop and yields all messages until
        :meth:`stop` is called.

        :raises AssertionError: if :meth:`start` has not been called
        """
        assert self._threadid is not None

        try:
            # Pump messages until WM_STOP
            while True:
                msg = wintypes.MSG()
                lpmsg = ctypes.byref(msg)
                r = self._GetMessage(lpmsg, None, 0, 0)
                if r <= 0 or msg.message == self.WM_STOP:
                    break
                else:
                    yield msg

        finally:
            self._threadid = None
            self.thread = None
示例#2
0
    def _mainloop(self):
        """The body of the main loop thread.

        This method retrieves all events from *Windows* and makes sure to
        dispatch clicks.
        """
        # Pump messages
        try:
            msg = wintypes.MSG()
            lpmsg = ctypes.byref(msg)
            while True:
                r = win32.GetMessage(lpmsg, None, 0, 0)
                if not r:
                    break
                elif r == -1:
                    break
                else:
                    win32.TranslateMessage(lpmsg)
                    win32.DispatchMessage(lpmsg)

        except:
            self._log.error('An error occurred in the main loop',
                            exc_info=True)

        finally:
            try:
                self._hide()
                del self._HWND_TO_ICON[self._hwnd]
            except:
                # Ignore
                pass

            win32.DestroyWindow(self._hwnd)
            win32.DestroyWindow(self._menu_hwnd)
            if self._menu_handle:
                hmenu, callbacks = self._menu_handle
                win32.DestroyMenu(hmenu)
            self._unregister_class(self._atom)
示例#3
0
def listenForPaste(funcPress, funcRelease):
    '''Registers the Ctrl + V hotkey and monitors it untill the thread receives
    a WM_QUIT message from the main thread.

    This is the entry point of the monitoring system for the Ctrl + V combination.

    It registers the hotkey and sends the current thread's ID to the main thread,
    so we can send a QUIT message from the main to this one when we want to exit.

    On exit we are checking whether we have a database connection stored on the
    thread and if we do, we close it.

    Args:
        funcPress: A callable to be executed when the hotkey is pressed for more than .15 seconds
        funcRelease: A callable to be executed when the hotkey is released after being triggered
    '''
    _registerHotkey()

    t = QThread.currentThread()
    t.threadId = threading.currentThread().ident

    try:
        msg = wintypes.MSG()
        while u32.GetMessageA(ctypes.byref(msg), None, 0, 0) != 0:
            if msg.message == win32con.WM_HOTKEY:
                _hold(funcPress, funcRelease)
                continue
            if msg.message == win32con.WM_QUIT:
                break
            u32.TranslateMessage(ctypes.byref(msg))
            u32.DispatchMessageA(ctypes.byref(msg))
    finally:
        u32.UnregisterHotKey(None, 1)
        logging.info("Unregistered the Ctrl + V hotkey")

        if hasattr(t, "dbConnection"):
            getattr(t, "dbConnection").close()
            logging.info("Closed dbConnection in paste thread")
示例#4
0
    def hook(self, keyboard=True, mouse=False):
        """Hook mouse and/or keyboard events"""
        self.mouse_is_hook = mouse
        self.keyboard_is_hook = keyboard

        # check that we are going to hook into at least one device
        if not self.mouse_is_hook and not self.keyboard_is_hook:
            raise Exception("You must hook into either the keyboard and/or mouse events")

        if self.keyboard_is_hook:
            def keyboard_low_level_handler(code, event_code, kb_data_ptr):
                """Used to catch keyboard events and deal with the event"""
                key_code = 0xFFFFFFFF & kb_data_ptr[0]  # key code
                current_key = ID_TO_KEY.get(key_code) # check the type of event (see ID_TO_KEY for a list)
                if current_key is None:
                    event = None # We can check this later.
                    if self.warn_unrecognised:
                        warn('Unrecognised key ID %d.' % key_code)
                else:
                    event_type = event_types[0xFFFFFFFF & event_code]

                    if event_type == 'key down':  # add key to those down to list
                        if current_key not in self.pressed_keys:
                            self.pressed_keys.append(current_key)

                    if event_type == 'key up':  # remove when no longer pressed
                        try:
                            self.pressed_keys.remove(current_key)
                        except ValueError:
                            pass # current_key is not in the list.

                    # wrap the keyboard information grabbed into a container class
                    event = KeyboardEvent(current_key, event_type, self.pressed_keys, key_code)

                # Call the event handler to deal with keys in the list
                try:
                    if event:
                        self.handler(event)
                except Exception as e:
                    warn('While handling {}, self.handler produced a traceback:\n{}'.format(event, format_exc()))
                finally:
                    # TODO: fix return here to use non-blocking call
                    return CallNextHookEx(self.keyboard_id, code, event_code, kb_data_ptr)

            keyboard_pointer = _callback_pointer(keyboard_low_level_handler)

            self.keyboard_id = SetWindowsHookExA(WH_KEYBOARD_LL, keyboard_pointer,
                                                 GetModuleHandleA(None),
                                                 0)

        if self.mouse_is_hook:
            def mouse_low_level_handler(code, event_code, kb_data_ptr):
                """Used to catch and deal with mouse events"""
                current_key = MOUSE_ID_TO_KEY.get(event_code)  # check the type of event (see MOUSE_ID_TO_KEY for a list)
                if current_key is None:
                    event = None # We can check this later.
                    if self.warn_unrecognised:
                        warn('Unrecognised mouse ID %d.' % event_code)
                else:
                    if current_key != 'Move':  # if we aren't moving, then we deal with a mouse click
                        event_type = MOUSE_ID_TO_EVENT_TYPE[event_code]
                        # the first two members of kb_data_ptr hold the mouse position, x and y
                        event = MouseEvent(current_key, event_type, kb_data_ptr[0], kb_data_ptr[1])

                try:
                    if event:
                        self.handler(event)
                except Exception as e:
                    warn('While handling {}, self.handler produced a traceback:\n{}'.format(event, format_exc()))
                finally:
                   # TODO: fix return here to use non-blocking call
                    return CallNextHookEx(self.mouse_id, code, event_code, kb_data_ptr)

            mouse_pointer = _callback_pointer(mouse_low_level_handler)
            self.mouse_id = SetWindowsHookExA(WH_MOUSE_LL, mouse_pointer,
                                              GetModuleHandleA(None), 0)

        atexit.register(UnhookWindowsHookEx, self.keyboard_id)
        atexit.register(UnhookWindowsHookEx, self.mouse_id)

        message = wintypes.MSG()
        while self.mouse_is_hook or self.keyboard_is_hook:
            msg = GetMessageW(byref(message), 0, 0, 0)
            if msg in [0, -1]:
                self.unhook_keyboard()
                self.unhook_mouse()
                break # Exit the loop.

            else:
                TranslateMessage(byref(message))
                DispatchMessageW(byref(message))
示例#5
0
    def hook(self, keyboard=True, mouse=False):
        """Hook mouse and/or keyboard events"""
        self.mouse_is_hook = mouse
        self.keyboard_is_hook = keyboard

        # check that we are going to hook into at least one device
        if not self.mouse_is_hook and not self.keyboard_is_hook:
            raise Exception("You must hook into either the keyboard and/or mouse events")

        if self.keyboard_is_hook:
            def keyboard_low_level_handler(code, event_code, kb_data_ptr):
                """Used to catch keyboard events and deal with the event"""
                try:
                    key_code = 0xFFFFFFFF & kb_data_ptr[0]  # key code
                    current_key = ID_TO_KEY[key_code]
                    event_type = event_types[0xFFFFFFFF & event_code]

                    if event_type == 'key down':  # add key to those down to list
                        self.pressed_keys.append(current_key)

                    if event_type == 'key up':  # remove when no longer pressed
                        self.pressed_keys.remove(current_key)

                    # wrap the keyboard information grabbed into a container class
                    event = KeyboardEvent(current_key, event_type, self.pressed_keys, key_code)

                    # if we have an event handler, call it to deal with keys in the list
                    if self.handler:
                        self.handler(event)

                finally:
                    # TODO: fix return here to use non-blocking call
                    return CallNextHookEx(self.keyboard_id, code, event_code, kb_data_ptr)

            keyboard_pointer = _callback_pointer(keyboard_low_level_handler)

            self.keyboard_id = SetWindowsHookExA(WH_KEYBOARD_LL, keyboard_pointer,
                                                 GetModuleHandleA(None),
                                                 0)

        if self.mouse_is_hook:
            def mouse_low_level_handler(code, event_code, kb_data_ptr):
                """Used to catch and deal with mouse events"""
                try:
                    current_key = MOUSE_ID_TO_KEY[
                        event_code]  # check the type of event (see MOUSE_ID_TO_KEY for a list)
                    if current_key != 'Move':  # if we aren't moving, then we deal with a mouse click
                        event_type = MOUSE_ID_TO_EVENT_TYPE[event_code]
                        # the first two members of kb_data_ptr hold the mouse position, x and y
                        event = MouseEvent(current_key, event_type, kb_data_ptr[0], kb_data_ptr[1])

                        if self.handler:
                            self.handler(event)

                finally:
                    # TODO: fix return here to use non-blocking call
                    return CallNextHookEx(self.mouse_id, code, event_code, kb_data_ptr)

            mouse_pointer = _callback_pointer(mouse_low_level_handler)
            self.mouse_id = SetWindowsHookExA(WH_MOUSE_LL, mouse_pointer,
                                              GetModuleHandleA(None), 0)

        atexit.register(UnhookWindowsHookEx, self.keyboard_id)
        atexit.register(UnhookWindowsHookEx, self.mouse_id)

        message = wintypes.MSG()
        while self.mouse_is_hook or self.keyboard_is_hook:
            msg = GetMessageW(byref(message), 0, 0, 0)
            if msg == -1:
                self.unhook_keyboard()
                self.unhook_mouse()
                exit(0)

            elif msg == 0:  # GetMessage return 0 only if WM_QUIT
                exit(0)
            else:
                TranslateMessage(byref(message))
                DispatchMessageW(byref(message))
示例#6
0
                                      mll_hook.m_struct.pt.y)

        # wparam contains the windows message id
        # if middle mouse button is pressed close the program
        if wParam == win32con.WM_MBUTTONUP:
            PostQuitMessage(0)

    return CallNextHookEx(mll_hook.hook, nCode, wParam, lParam)


if __name__ == '__main__':
    print "Press the middle mouse button to exit "
    try:
        mll_hook.hook = SetWindowsHookEx(win32con.WH_MOUSE_LL,
                                         LowLevelMouseProc, GetModuleHandle(0),
                                         0)
    except Exception, err:
        print err
    print "got this far..."
    # set up a message queue, you can use any valid message loop tkinter, pygtk and wxpythons message loops all work
    #win32gui.PumpMessages()

    msg = wintypes.MSG()
    while ctypes.windll.user32.GetMessageA(ctypes.byref(msg), None, 0, 0) != 0:
        print "got message..."
        ctypes.windll.user32.TranslateMessage(ctypes.byref(msg))
        ctypes.windll.user32.DispatchMessageA(ctypes.byref(msg))
    print "done?"
    # unhook the mouse hook
    UnhookWindowsHookEx(mll_hook.hook)
示例#7
0
def listen(connection_to_mom):
    if connection_to_mom.readable:
        byref = ctypes.byref
        user32 = ctypes.windll.user32
        keys = connection_to_mom.recv()
        #dictionary with all possible keys i could find and map to keys on my keyboard (haven't tested all of them though)
        #this is purely so we can translate human readable keys to the correct Win32Con mapping
        #there are still Win32con keys available that I haven't used, as I couldn't find those keys on my keyboard, or wasn't sure what the heck it is.
        keymap = {
            "enter": win32con.VK_RETURN,
            "up": win32con.VK_UP,
            "down": win32con.VK_DOWN,
            "left": win32con.VK_LEFT,
            "right": win32con.VK_RIGHT,
            "backspace": win32con.VK_BACK,
            "delete": win32con.VK_DELETE,
            "end": win32con.VK_END,
            "home": win32con.VK_HOME,
            "tab": win32con.VK_TAB,
            "f1": win32con.VK_F1,
            "f2": win32con.VK_F2,
            "f3": win32con.VK_F3,
            "f4": win32con.VK_F4,
            "f5": win32con.VK_F5,
            "f6": win32con.VK_F6,
            "f7": win32con.VK_F7,
            "f8": win32con.VK_F8,
            "f9": win32con.VK_F9,
            "f10": win32con.VK_F10,
            "f11": win32con.VK_F11,
            "f12": win32con.VK_F11,
            "f13": win32con.VK_F13,
            "f14": win32con.VK_F14,
            "f15": win32con.VK_F15,
            "f16": win32con.VK_F16,
            "f17": win32con.VK_F17,
            "f18": win32con.VK_F18,
            "f19": win32con.VK_F19,
            "f20": win32con.VK_F20,
            "f21": win32con.VK_F21,
            "f22": win32con.VK_F22,
            "f23": win32con.VK_F23,
            "f24": win32con.VK_F24,
            "pageup": win32con.VK_PRIOR,
            "pagedown": win32con.VK_NEXT,
            "escape": win32con.VK_ESCAPE,
            "left mouse": win32con.VK_LBUTTON,
            "right mouse": win32con.VK_RBUTTON,
            "control break": win32con.VK_CANCEL,
            "middle mouse": win32con.VK_MBUTTON,
            "clear": win32con.VK_CLEAR,
            "shift": win32con.VK_SHIFT,
            "ctrl": win32con.VK_CONTROL,
            "menu": win32con.VK_MENU,
            "pause": win32con.VK_PAUSE,
            "caps": win32con.VK_CAPITAL,
            "space": win32con.VK_SPACE,
            "end": win32con.VK_END,
            "home": win32con.VK_HOME,
            "print screen": win32con.VK_SNAPSHOT,
            "insert": win32con.VK_INSERT,
            "delete": win32con.VK_DELETE,
            "windows": win32con.MOD_WIN,
            "left windows": win32con.VK_LWIN,
            "right windows": win32con.VK_RWIN,
            "num0": win32con.VK_NUMPAD0,
            "num1": win32con.VK_NUMPAD1,
            "num2": win32con.VK_NUMPAD2,
            "num3": win32con.VK_NUMPAD3,
            "num4": win32con.VK_NUMPAD4,
            "num5": win32con.VK_NUMPAD5,
            "num6": win32con.VK_NUMPAD6,
            "num7": win32con.VK_NUMPAD7,
            "num8": win32con.VK_NUMPAD8,
            "num9": win32con.VK_NUMPAD9,
            "*": win32con.VK_MULTIPLY,
            "+": win32con.VK_ADD,
            "-": win32con.VK_SUBTRACT,
            "": win32con.VK_DECIMAL,
            "/": win32con.VK_DIVIDE,
            "numlock": win32con.VK_NUMLOCK,
            "scroll lock": win32con.VK_SCROLL,
            "left shift": win32con.VK_LSHIFT,
            "right shift": win32con.VK_RSHIFT,
            "left ctrl": win32con.VK_LCONTROL,
            "right ctrl": win32con.VK_RCONTROL,
            "left menu": win32con.VK_LMENU,
            "right menu": win32con.VK_RMENU,
            "mouse wheel": win32con.MOUSEEVENTF_WHEEL,
            "media mute": win32con.VK_VOLUME_MUTE,
            "media vol down": win32con.VK_VOLUME_DOWN,
            "media vol up": win32con.VK_VOLUME_UP,
            "media next": win32con.VK_MEDIA_NEXT_TRACK,
            "media prev": win32con.VK_MEDIA_PREV_TRACK,
            "media play": win32con.VK_MEDIA_PLAY_PAUSE,
            "prev page": win32con.VK_BROWSER_BACK,
            "next page": win32con.VK_BROWSER_FORWARD,
            #dunno what these are, if someone can clarify, I'll maybe add them :),
            "": win32con.VK_SEPARATOR,
            "": win32con.VK_KANA,
            "": win32con.VK_HANGEUL,
            "": win32con.VK_HANGUL,
            "": win32con.VK_JUNJA,
            "": win32con.VK_FINAL,
            "": win32con.VK_HANJA,
            "": win32con.VK_KANJI,
            "": win32con.VK_CONVERT,
            "": win32con.VK_NONCONVERT,
            "": win32con.VK_ACCEPT,
            "": win32con.VK_MODECHANGE,
            "": win32con.VK_PRIOR,
            "": win32con.VK_NEXT,
            "": win32con.VK_SELECT,
            "": win32con.VK_PRINT,
            "": win32con.VK_EXECUTE,
            "": win32con.VK_HELP,
            "": win32con.VK_APPS,
            "": win32con.VK_PROCESSKEY,
            "": win32con.VK_ATTN,
            "": win32con.VK_CRSEL,
            "": win32con.VK_EXSEL,
            "": win32con.VK_EREOF,
            "": win32con.VK_PLAY,
            "": win32con.VK_ZOOM,
            "": win32con.VK_NONAME,
            "": win32con.VK_PA1,
            "": win32con.VK_OEM_CLEAR,
            # multi-media related
            "": win32con.MOUSEEVENTF_XDOWN,
            "": win32con.MOUSEEVENTF_XUP,
            "": win32con.VK_XBUTTON1,
            "": win32con.VK_XBUTTON2,
        }

        #if the user is using custom keys, we have to convert them, as we want to give users an easy option to set their keys,
        #so they don't need to now the win32con.VKF2 codes and such
        i = 1
        HOTKEYS = {}
        for key_combo in keys:
            HOTKEYS[i] = ()
            for key in key_combo:
                HOTKEYS[i] = HOTKEYS[i] + (keymap[key], )
            i += 1

    def handle_win_f2():
        #sending to parent process that the action, given 1 here, kind of randomly (ID's are better than names)
        connection_to_mom.send({"action": 1})

    def handle_win_f3():
        #sending to parent process that the action 2 should be run.
        connection_to_mom.send({"action": 2})

    def handle_win_f4():
        #sending to parent process that the action 2 should be run.
        connection_to_mom.send({"action": 3})

    HOTKEY_ACTIONS = {1: handle_win_f2, 2: handle_win_f3, 3: handle_win_f4}

    #
    # RegisterHotKey takes:
    #  Window handle for WM_HOTKEY messages (None = this thread)
    #  arbitrary id unique within the thread
    #  modifiers (MOD_SHIFT, MOD_ALT, MOD_CONTROL, MOD_WIN)
    #  VK code (either ord ('x') or one of win32con.VK_*)
    #
    for id, (vk, modifiers) in HOTKEYS.items():
        #print ("Registering id", id, "for key", vk)
        if not user32.RegisterHotKey(None, id, modifiers, vk):
            print("Unable to register id", id)

    #
    # Home-grown Windows message loop: does
    #  just enough to handle the WM_HOTKEY
    #  messages and pass everything else along.
    #
    try:
        msg = wintypes.MSG()
        while user32.GetMessageA(byref(msg), None, 0, 0) != 0:
            if msg.message == win32con.WM_HOTKEY:
                action_to_take = HOTKEY_ACTIONS.get(msg.wParam)
                if action_to_take:
                    action_to_take()
            user32.TranslateMessage(byref(msg))
            user32.DispatchMessageA(byref(msg))
    finally:
        for id in HOTKEYS.keys():
            user32.UnregisterHotKey(None, id)
示例#8
0
def get_message():  # get pending messages
    msg = wintypes.MSG()
    return user32.PeekMessageA(ctypes.pointer(msg), None, 0, 0, PM_REMOVE)
示例#9
0
def wait_messages():  # enter message loop
    msg = wintypes.MSG()
    while user32.GetMessageA(ctypes.pointer(msg), None, 0, 0):
        pass
示例#10
0
 def WaitForMSG(self):
     msg = wintypes.MSG()
     self.GetMessage(msg, 0, 0, 0)
示例#11
0
    def run(self):

        heartbeat = HeartBeat(self._ppid, self._send_quit)
        heartbeat.start()

        import atexit
        import signal

        class KBDLLHOOKSTRUCT(ctypes.Structure):
            _fields_ = [
                ("vkCode", wintypes.DWORD),
                ("scanCode", wintypes.DWORD),
                ("flags", wintypes.DWORD),
                ("time", wintypes.DWORD),
                ("dwExtraInfo", ctypes.c_void_p),
            ]

        KeyboardProc = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int,
                                        wintypes.WPARAM,
                                        ctypes.POINTER(KBDLLHOOKSTRUCT))

        # Ignore KeyboardInterrupt when attached to a console...
        signal.signal(signal.SIGINT, signal.SIG_IGN)

        self._tid = windll.kernel32.GetCurrentThreadId()
        self._queue.put(self._tid)

        down_keys = set()
        passthrough_down_keys = set()

        def on_key(pressed, event):
            if (event.flags & 0x10):
                # Ignore simulated events (e.g. from KeyboardEmulation).
                return False
            if event.vkCode in self.PASSTHROUGH_KEYS:
                if pressed:
                    passthrough_down_keys.add(event.vkCode)
                else:
                    passthrough_down_keys.discard(event.vkCode)
            key = SCANCODE_TO_KEY.get(event.scanCode)
            if key is None:
                # Unhandled, ignore and don't suppress.
                return False
            suppressed = bool(self._suppressed_keys_bitmask[event.scanCode //
                                                            64]
                              & (1 << (event.scanCode % 64)))
            if pressed:
                if passthrough_down_keys:
                    # Modifier(s) pressed, ignore.
                    return False
                down_keys.add(key)
            else:
                down_keys.discard(key)
            self._queue.put((key, pressed))
            return suppressed

        hook_id = None

        def low_level_handler(code, wparam, lparam):
            if code >= 0:
                pressed = wparam in (0x100, 0x104)
                if on_key(pressed, lparam[0]):
                    # Suppressed...
                    return 1
            return windll.user32.CallNextHookEx(hook_id, code, wparam, lparam)

        pointer = KeyboardProc(low_level_handler)
        hook_id = windll.user32.SetWindowsHookExA(
            0x00D, pointer, windll.kernel32.GetModuleHandleW(None), 0)
        atexit.register(windll.user32.UnhookWindowsHookEx, hook_id)
        msg = wintypes.MSG()
        while windll.user32.GetMessageW(ctypes.byref(msg), 0, 0, 0):
            windll.user32.TranslateMessage(ctypes.byref(msg))
            windll.user32.DispatchMessageW(ctypes.byref(msg))

        heartbeat.stop()
示例#12
0
    def low_level_callback(code, rparam, lparam):
        try:
            key_code = 0xFFFFFFFF & lparam[0]  # key code
            handler(key_code, rparam)
        finally:
            return CallNextHookEx(handle[0], code, rparam, lparam)

    callback_pointer = CFUNCTYPE(c_int, c_int, wintypes.HINSTANCE,
                                 POINTER(c_void_p))(low_level_callback)
    handle[0] = SetWindowsHookExA(WH_KEYBOARD_LL, callback_pointer,
                                  GetModuleHandleA(None), 0)
    atexit.register(UnhookWindowsHookEx, handle[0])

    # Message pumper
    message = wintypes.MSG()
    while True:
        msg = GetMessageW(byref(message), 0, 0, 0)
        if msg == -1:
            UnhookWindowsHookEx(handle[0])
            sys.exit(0)

        elif msg == 0:  # GetMessage return 0 only if WM_QUIT
            sys.exit(0)
        else:
            TranslateMessage(byref(message))
            DispatchMessageW(byref(message))
    try:
        sys.stdin.read()
        pass
    finally:
 def run(self):
     global vparams, params, speaking
     global tid, dll, handle
     tid = windll.kernel32.GetCurrentThreadId()
     msg = wintypes.MSG()
     user32.PeekMessageA(byref(msg), None, 0x400, 0x400, 0)
     (dll, handle) = eciNew()
     dll.eciRegisterCallback(handle, callback, None)
     dll.eciSetOutputBuffer(handle, samples, pointer(buffer))
     dll.eciSetParam(handle, 1, 1)
     self.dictionaryHandle = dll.eciNewDict(handle)
     dll.eciSetDict(handle, self.dictionaryHandle)
     #0 = main dictionary
     if os.path.exists(os.path.join(os.path.dirname(eciPath),
                                    "enumain.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 0,
             os.path.join(os.path.dirname(eciPath),
                          "enumain.dic").encode('mbcs'))
     elif os.path.exists(os.path.join(os.path.dirname(eciPath),
                                      "main.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 0,
             os.path.join(os.path.dirname(eciPath),
                          "main.dic").encode('mbcs'))
     if os.path.exists(os.path.join(os.path.dirname(eciPath),
                                    "enuroot.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 1,
             os.path.join(os.path.dirname(eciPath),
                          "enuroot.dic").encode('mbcs'))
     elif os.path.exists(os.path.join(os.path.dirname(eciPath),
                                      "root.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 1,
             os.path.join(os.path.dirname(eciPath),
                          "root.dic").encode('mbcs'))
     if os.path.exists(os.path.join(os.path.dirname(eciPath),
                                    "enuabbr.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 2,
             os.path.join(os.path.dirname(eciPath),
                          "enuabbr.dic").encode('mbcs'))
     elif os.path.exists(os.path.join(os.path.dirname(eciPath),
                                      "abbr.dic")):
         dll.eciLoadDict(
             handle, self.dictionaryHandle, 2,
             os.path.join(os.path.dirname(eciPath),
                          "abbr.dic").encode('mbcs'))
     params[9] = dll.eciGetParam(handle, 9)
     started.set()
     while True:
         user32.GetMessageA(byref(msg), 0, 0, 0)
         user32.TranslateMessage(byref(msg))
         if msg.message == WM_PROCESS:
             internal_process_queue()
         elif msg.message == WM_SILENCE:
             speaking = False
             gb.seek(0)
             gb.truncate(0)
             dll.eciStop(handle)
             try:
                 while True:
                     bgQueue.get_nowait()
             except:
                 pass
             player.stop()
         elif msg.message == WM_PARAM:
             dll.eciSetParam(handle, msg.lParam, msg.wParam)
             params[msg.lParam] = msg.wParam
             param_event.set()
         elif msg.message == WM_VPARAM:
             setVParamImpl(param=msg.wParam, val=msg.lParam)
             param_event.set()
         elif msg.message == WM_COPYVOICE:
             dll.eciCopyVoice(handle, msg.wParam, 0)
             for i in (rate, pitch, vlm, fluctuation, hsz, rgh, bth):
                 vparams[i] = dll.eciGetVoiceParam(handle, 0, i)
             param_event.set()
         elif msg.message == WM_KILL:
             dll.eciDelete(handle)
             stopped.set()
             break
         else:
             user32.DispatchMessageA(byref(msg))
示例#14
0
def wait_for_msg():
    msg = wintypes.MSG()
    GetMessage(msg, 0, 0, 0)
示例#15
0
#!/usr/bin/env python3
__version__ = '0.67-beta'
__author__ = 'BladeMight'
import win32gui as w3g, win32api as w3a, ctypes, atexit
import win32clipboard as w3cl
from KInputs import *
from win32con import *
from collections import namedtuple
from ctypes import wintypes, windll, CFUNCTYPE, POINTER, c_int, c_void_p
from time import sleep
import Locales as lcs
from ToUn import *
# Hotkeys & functions related to it
brf = ctypes.byref
u32 = ctypes.windll.user32
m = wintypes.MSG()


def HKHandle(ID):
    global self
    print("HK with id = {} fired.".format(ID))
    if ID == 0:
        '''Converts selection'''
        # Below needed for AllList to return correct next locale id.
        w3a.PostMessage(w3g.GetForegroundWindow(), 0x50,
                        lcs.GetNotCurrentLocale())
        ConvertSelection()
        print(self)
    if ID == 1 and not self:
        '''Converts typed last word'''
        ConvertLast(c_word)