Beispiel #1
0
from talon.voice import Context, ContextGroup, talon
from talon import app


def set_enabled(enable):
    if enable:
        talon.enable()
        app.icon_color(0, 0.7, 0, 1)
    else:
        talon.disable()
        app.icon_color(1, 0, 0, 1)
    lib.menu_check(b'!Enable Speech Recognition', enable)


def on_menu(item):
    if item == '!Enable Speech Recognition':
        set_enabled(not talon.enabled)


app.register('menu', on_menu)
set_enabled(talon.enabled)

sleep_group = ContextGroup('sleepy')
sleepy = Context('sleepy', group=sleep_group)

sleepy.keymap({
    'talon sleep': lambda m: set_enabled(False),
    'talon wake': lambda m: set_enabled(True),
})
sleep_group.load()
Beispiel #2
0
from talon import actions, app


def on_ready():
    actions.speech.disable()
    actions.speech.set_microphone('Yeti Stereo Microphone Analog Stereo')


app.register('launch', on_ready)
    global cached_path

    # on windows, we get events from the clock
    # and such, so this check is important
    if not window.app.exe or window != ui.active_window():
        return

    path = actions.user.file_manager_current_path()

    if not "user.file_manager" in registry.tags:
        actions.user.file_manager_hide_pickers()
        clear_lists()
    elif path:
        if cached_path != path:
            update_lists()
    elif cached_path:
        clear_lists()
        actions.user.file_manager_hide_pickers()

    cached_path = path


def register_events():
    ui.register("win_title", win_event_handler)
    ui.register("win_focus", win_event_handler)


# prevent scary errors in the log by waiting for talon to be fully loaded
# before registering the events
app.register("launch", register_events)
Beispiel #4
0
        global show_enabled_contexts_only
        global selected_context

        if gui_context_help.showing:
            if selected_context == None:
                refresh_context_command_map(show_enabled_contexts_only)
            else:
                update_active_contexts_cache(registry.active_contexts())

    def help_hide():
        """Hides the help"""
        reset()

        # print("help_hide - alphabet gui_alphabet: {}".format(gui_alphabet.showing))
        # print(
        #     "help_hide - gui_context_help showing: {}".format(gui_context_help.showing)
        # )

        gui_alphabet.hide()
        gui_context_help.hide()
        refresh_context_command_map()
        register_events(False)
        actions.mode.disable("user.help")


def commands_updated(_):
    update_title()


app.register("ready", refresh_context_command_map)
Beispiel #5
0
            self.prev_mouse_pos = pos
            for widget in self.widgets:
                if widget.enabled:
                    widget.mouse_move(self.prev_mouse_pos)


def create_hud():
    global hud
    preferences = HeadUpDisplayUserPreferences()

    from user.talon_hud.knausj_bindings import KnausjStatePoller
    poller = KnausjStatePoller()
    hud = HeadUpDisplay(hud_content, preferences, poller)


app.register('ready', create_hud)


@mod.action_class
class Actions:
    def enable_hud():
        """Enables the HUD"""
        global hud
        hud.enable()

    def disable_hud():
        """Disables the HUD"""
        global hud
        hud.disable()

    def add_hud_log(type: str, message: str):
Beispiel #6
0
        if file_extension and file_extension in extension_lang_map:
            result = extension_lang_map[file_extension]

        print("code.language: " + result)
        return result


# create a mode for each defined language
for __, lang in extension_lang_map.items():
    mod.mode(lang)

# Create a mode for the automated language detection. This is active when no lang is forced.
mod.mode("auto_lang")

# Auto lang is enabled by default
app.register("ready", lambda: actions.user.code_clear_language_mode())


@mod.action_class
class Actions:
    def code_set_language_mode(language: str):
        """Sets the active language mode, and disables extension matching"""
        actions.user.code_clear_language_mode()
        actions.mode.disable("user.auto_lang")
        actions.mode.enable("user.{}".format(language))
        app.notify("Enabled {} mode".format(language))
        # forced_language = True
        # app.notify("Enabled {} mode".format(language))

    def code_clear_language_mode():
        """Clears the active language mode, and re-enables code.language: extension matching"""
Beispiel #7
0
    global cached_path

    # on windows, we get events from the clock
    # and such, so this check is important
    if not window.app.exe or window != ui.active_window():
        return

    path = actions.user.file_manager_current_path()

    if not "user.file_manager" in registry.tags:
        actions.user.file_manager_hide_pickers()
        clear_lists()
    elif path:
        if cached_path != path:
            update_lists()
    elif cached_path:
        clear_lists()
        actions.user.file_manager_hide_pickers()

    cached_path = path


def register_events():
    ui.register("win_title", win_event_handler)
    ui.register("win_focus", win_event_handler)


# prevent scary errors in the log by waiting for talon to be fully loaded
# before registering the events
app.register("ready", register_events)
Beispiel #8
0
        global show_enabled_contexts_only
        global selected_context

        if gui_context_help.showing:
            if selected_context == None:
                refresh_context_command_map(show_enabled_contexts_only)
            else:
                update_active_contexts_cache(registry.active_contexts())

    def help_hide():
        """Hides the help"""
        reset()

        # print("help_hide - alphabet gui_alphabet: {}".format(gui_alphabet.showing))
        # print(
        #     "help_hide - gui_context_help showing: {}".format(gui_context_help.showing)
        # )

        gui_alphabet.hide()
        gui_context_help.hide()
        refresh_context_command_map()
        register_events(False)
        actions.mode.disable("user.help")


def commands_updated(_):
    update_title()


app.register("launch", refresh_context_command_map)
Beispiel #9
0
        if gui_enabled:
            actions.self.command_history_disable()
        else:
            actions.self.command_history_enable()

    def command_history_enable():
        """Shows the command_history"""
        global gui_enabled
        gui_enabled = True
        reset_gui_timer()

    def command_history_disable():
        """Hides the command_history"""
        global gui_enabled
        gui_enabled = False
        gui.hide()

    def command_history_clear():
        """Clear the command_history"""
        global history, history_lock
        with history_lock:
            history = []

    def command_history_set_size(n: int):
        """Set number of items displayed in the command history."""
        context.settings["user.command_history_items"] = n


# Enable command history by default.
app.register("launch", lambda: actions.self.command_history_enable())
Beispiel #10
0
        # print("narrow many", repr(digit))
        # print(str(digit_list))
        for d in digit_list:
            GridActions.grid_narrow(int(d))

    def grid_narrow(digit: Union[int, str]):
        """Choose a field of the grid and narrow the selection down"""
        # print("narrow one", repr(digit))
        mg.narrow(int(digit))

    def grid_go_back():
        """Sets the grid state back to what it was before the last command"""
        mg.go_back()

    def grid_close():
        """Close the active grid"""
        if len(ctx.tags) > 0 or mg.active:
            ctx.tags = []
            mg.reset()(None)
            mg.stop()


def check_shimmer_setting_at_startup():
    if shimmer_effect_enabled.get():
        mg.start()
        mg.reset()
        mg.stop()


app.register("launch", check_shimmer_setting_at_startup)
Beispiel #11
0
from talon import actions, app


def set_microphone():
    actions.speech.set_microphone('Audient iD14')


app.register('launch', set_microphone)
        # Text formatters
        actions.user.hud_add_documentation(
            "Text formatting",
            "gives a list with examples of commands that can change text with a different format.",
            documentation_dir + "/text_formatters.txt")

        # Talon draft usage
        actions.user.hud_add_documentation(
            "Talon draft window",
            "shows all the available commands used for the draft window, which can be used to dictate and edit text outside of the current program.",
            documentation_dir + "/talon_draft_usage.txt")

        # Browser documentation
        actions.user.hud_add_documentation(
            "Browser usage",
            "shows the commands and explanations related to web browser usage",
            documentation_dir + "/browser_usage_documentation.txt")

        # Basic browser usage
        actions.user.hud_add_walkthrough(
            "Basic browser usage",
            documentation_dir + "/basic_browser_usage_walkthrough.json")

        # Media usage
        actions.user.hud_add_walkthrough(
            "Music and video controls",
            documentation_dir + "/music_and_video_walkthrough.json")


app.register("ready", talon_hud_ready)
Beispiel #13
0
        if tags is not None:
            for tag in tags:
                new_tags.append(tag)

        modes = []
        scopemodes = scope.get("mode")
        if scopemodes is not None:
            for mode in scopemodes:
                modes.append(mode)

        text = "<*app: " + scope.get("app")["name"] + "/> " + scope.get(
            "win")["title"] + "/>\n<*Tags:/>\n" + "\n".join(
                sorted(new_tags)) + "\n<*Modes:/> " + " - ".join(sorted(modes))
        return text


def append_poller():
    actions.user.hud_add_poller("scope", ScopePoller())


app.register("ready", append_poller)

mod = Module()


@mod.action_class
class Actions:
    def hud_toolkit_scope():
        """Start debugging the Talon scope in the Talon HUD"""
        actions.user.hud_activate_poller("scope")
Beispiel #14
0

def register_language_poller():
    actions.user.hud_add_poller("programming_toggle",
                                ProgrammingLanguagePoller())
    default_option = actions.user.hud_create_button(
        "Add code language", add_statusbar_programming_icon, "text_navigation")
    activated_option = actions.user.hud_create_button(
        "Remove code language", remove_statusbar_programming_icon,
        "text_navigation")
    status_option = actions.user.hud_create_status_option(
        "programming_toggle", default_option, activated_option)
    actions.user.hud_publish_status_option("programming_option", status_option)


app.register("ready", register_language_poller)


def load_languages(languages_file):
    languages = {}
    languages_header = "Language,Extension,Icon"
    if not os.path.exists(languages_file):
        language_defaults = [
            "bash,.sh,programming_bash", "c,,programming_c",
            "cplusplus,.cpp,programming_cplusplus",
            "csharp,.cs,programming_cplusplus",
            "objectivec,,programming_objectivec",
            "haskel,.hs,programming_haskel", "swift,,programming_swift",
            "rust,.rs,programming_rust", "r,.r,programming_r",
            "php,.php,programming_php", "ruby,.rb,programming_ruby",
            "python,.py,programming_python", "lua,.lua,programming_lua",
Beispiel #15
0
                            voice_commands_remaining.remove(said_word)
                    
                    if len(step.voice_commands) > 0 and len(voice_commands_remaining) == 0 and not "skip step" in step.voice_commands and not "continue" in step.voice_commands:
                        cron.cancel(self.next_step_job)
                        self.next_step_job = cron.after("1500ms", self.next_step)
    
hud_walkthrough = WalkthroughPoller()
hud_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

def load_walkthrough():
    global hud_walkthrough
    actions.user.hud_add_walkthrough("Head up display", hud_directory + "/docs/hud_walkthrough.json")
    actions.user.hud_add_poller("walkthrough_step", hud_walkthrough)
    hud_walkthrough.load_state()

app.register("ready", load_walkthrough)

@mod.action_class
class Actions:

    def hud_add_walkthrough(title: str, filename: str):
        """Add a walk through through a file"""
        global hud_walkthrough 
        hud_walkthrough.add_walkthrough_file(title, filename)
        
    def hud_add_lazy_walkthrough(title: str, get_walkthrough: Callable[[], list[HudWalkThroughStep]]):
        """Add a walk through through a file"""
        global hud_walkthrough 
        hud_walkthrough.add_lazy_walkthrough(title, get_walkthrough)

    def hud_create_walkthrough_step(content: str, context_hint: str = "", tags: list[str] = None, modes: list[str] = None, app: str = "", restore_callback: Callable[[Any, Any], None] = None):
Beispiel #16
0
                    winreg.SetValueEx(Registrykey, value_name, 0,
                                      winreg.REG_EXPAND_SZ, hidden_cursor)

            winreg.CloseKey(Registrykey)

            ctypes.windll.user32.SystemParametersInfoA(win32con.SPI_SETCURSORS,
                                                       0, None, 0)

        except WindowsError:
            print("Unable to show_cursor({})".format(str(show)))
    else:
        ctrl.cursor_visible(show)


if setting_mouse_enable_on_startup.get() >= 1:
    app.register("ready", mouse_wake)


def on_pop(active):
    if setting_mouse_enable_pop_stops_scroll.get() >= 1 and (gaze_job
                                                             or scroll_job):
        stop_scroll()
    elif (not eye_zoom_mouse.zoom_mouse.enabled
          and eye_mouse.mouse.attached_tracker is not None):
        print("Triggering non-zoom click")
        if setting_mouse_enable_pop_click.get() >= 1:
            ctrl.mouse_click(button=0, hold=16000)


def mouse_scroll(amount):
    def scroll():
Beispiel #17
0
                            if len(name) > 6 and len(word) < 3:
                                continue

                            launch[word] = path

        ctx.lists["user.launch"] = launch


def ui_event(event, arg):
    if event in ("app_launch", "app_close"):
        update_lists()


# Currently update_launch_list only does anything on mac, so we should make sure
# to initialize user launch to avoid getting "List not found: user.launch"
# errors on other platforms.
ctx.lists["user.launch"] = {}


# Talon starts faster if you don't use the `talon.ui` module during launch
def on_ready():
    update_overrides(None, None)
    fs.watch(overrides_directory, update_overrides)
    update_launch_list()
    ui.register("", ui_event)


# NOTE: please update this from "launch" to "ready" in Talon v0.1.5
app.register("launch", on_ready)
# app.register("ready", on_ready)
Beispiel #18
0
                widget.disable()
                widget.show_animations = show_animations
            self.widget_manager.widgets = []
        self.widget_manager = None


preferences = HeadUpDisplayUserPreferences("", CURRENT_TALON_HUD_VERSION)
hud = HeadUpDisplay(preferences)


def hud_start():
    global hud
    actions.user.hud_internal_register("HeadUpDisplay", hud)


app.register('ready', hud_start)


@mod.action_class
class Actions:
    def hud_enable():
        """Enables the HUD"""
        global hud
        hud.enable(True)

    def hud_disable():
        """Disables the HUD"""
        global hud
        hud.disable(True)

    def hud_persist_preferences():
        "microphone_list",
        PartialMicrophonePoller("microphone_list", microphone_poller))

    # Add the toggles to the status bar
    default_option = actions.user.hud_create_button(
        "Add microphone", add_statusbar_one_click_toggle, "microphone_on")
    activated_option = actions.user.hud_create_button(
        "Remove microphone", remove_statusbar_one_click_toggle,
        "microphone_on")
    status_option = actions.user.hud_create_status_option(
        "microphone_toggle", default_option, activated_option)
    actions.user.hud_publish_status_option("microphone_toggle_option",
                                           status_option)


app.register("ready", register_microphone_pollers)

mod = Module()


@mod.action_class
class Actions:
    def show_microphone_options():
        """Show the microphone options in a choice panel"""
        show_microphone_selection()

    def hud_add_single_click_mic_toggle():
        """Add a single click toggle on the status bar"""
        add_statusbar_one_click_toggle()

    def hud_remove_single_click_mic_toggle():
Beispiel #20
0
            lib.nvgBeginPath(vg)
            lib.nvgMoveTo(vg, x + ob, wavemid - waveheight / 2 + 5)
            lib.nvgLineTo(vg, x + ot, wavemid + waveheight / 2 - 5)
            lib.nvgStroke(vg)


font = None
timeline = AudioTimeline()


def on_noise(noise):
    with timeline.lock:
        timeline.events.append([len(timeline.history), noise])


def on_overlay(vg, width, height):
    global font
    if font is None:
        font = lib.nvgCreateFont(
            vg, 'courier'.encode('utf8'),
            '/Library/Fonts/Courier New Bold.ttf'.encode('utf8'))
    lib.nvgFontFaceId(vg, font)
    lib.nvgFontSize(vg, 18)

    timeline.draw(vg, 0, height * 4 / 5, width, height / 5)


noise.register('noise', on_noise)
record.register('record', timeline.append)
app.register('overlay', on_overlay)
Beispiel #21
0
        if gui.showing:
            gui.hide()
        else:
            gui.show()

    def microphone_select(index: int):
        """Selects a micropohone"""
        # print(str(index) + " " + str(len(microphone_device_list)))
        if 1 <= index and index <= len(microphone_device_list):
            microphone = microphone_device_list[index - 1].name
            for item in manager.menu.items:
                # print(item.name + " " + microphone)
                if microphone in item.name:
                    # manager.menu_click(item)
                    actions.speech.set_microphone(item.name)
                    app.notify("Activating {}".format(item.name))

                    break

            gui.hide()


ctx.register("devices_changed", devices_changed)


def on_launch():
    update_microphone_list()


app.register("launch", on_launch)
Beispiel #22
0
    def format_time_ms(self, time_ms: float, threshold: float = 0.0) -> str:
        content = ""
        if time_ms <= threshold:
            return content

        if time_ms >= 7500:
            if time_ms >= 20000:
                content += "<!!"
            else:
                content += "<!"
        content += "{:.1f}".format(time_ms / 1000) + "s"
        if time_ms >= 7500:
            content += "/>"
        return content


def register_poller():
    actions.user.hud_add_poller("speech", SpeechPoller())


app.register("ready", register_poller)

mod = Module()


@mod.action_class
class Action:
    def hud_toolkit_speech():
        """Start displaying the phrase debugging tools"""
        actions.user.hud_activate_poller("speech")
Beispiel #23
0
def on_ready():
    ctx.lists["self.things_tag"] = actions.user.create_spoken_forms_from_map(
        {tag.title: tag.uuid for tag in tags}
    )
    ctx.lists[
        "self.things_tag_with_shortcut"
    ] = actions.user.create_spoken_forms_from_map(
        {tag.title: tag.uuid for tag in tags if tag.shortcut is not None}
    )
    ctx.lists["self.things_project"] = actions.user.create_spoken_forms_from_map(
        {project.title: project.uuid for project in projects}
    )


# NOTE: please update this from "launch" to "ready" in Talon v0.1.5
app.register("ready", on_ready)


@mod.action_class
class Actions:
    def tag_todo(things_tags: str):
        """Tag todo with a list of tags"""
        tag_list = [tag_map[tag_uuid] for tag_uuid in things_tags.split(",")]
        tags_with_shortcuts = [tag for tag in tag_list if tag.shortcut is not None]
        tags_without_shortcuts = [tag for tag in tag_list if tag.shortcut is None]

        for tag in tags_with_shortcuts:
            actions.key(f"ctrl-{tag.shortcut}")

        for tag in tags_without_shortcuts:
            actions.key(f"cmd-shift-t")
Beispiel #24
0
                               {"topic_types": copy.copy(self.topic_types)},
                               "dump")

    def destroy(self):
        pass


hud_content = HeadUpDisplayContent()


def on_ready():
    global hud_content
    actions.user.hud_internal_register("HeadUpDisplayContent", hud_content)


app.register('ready', on_ready)


@mod.action_class
class Actions:
    def hud_add_log(type: str, message: str):
        """Adds a log to the HUD"""
        global hud_content
        hud_content.append_to_log_messages(type, message)

    def hud_edit_log(prefix_split: str,
                     throttle_remaining: int = 0,
                     discard_remaining: int = 0,
                     type: str = "command"):
        """Edits a log message to be split up into multiple with optional discarding of the remainder"""
        global hud_content