Python sublime.Window方法代码示例

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def for_window(window: sublime.Window, create: bool = False) -> 'Optional[Debugger]':
		global instances
		id = window.id()
		instance = Debugger.instances.get(id)

		if not instance and create:
			if Debugger.creating.get(id):
				raise core.Error("We shouldn't be creating another debugger instance for this window...")

			Debugger.creating[id] = True
			try:
				instance = Debugger(window)
				Debugger.instances[id] = instance

			except dap.Error as e:
				core.log_exception()

			Debugger.creating[id] = False

		if instance and create:
			instance.show()

		return instance 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def _sessions_for_view_and_window(view: sublime.View, window: Optional[sublime.Window],
                                  point: Optional[int] = None) -> Iterable[Session]:
    if not window:
        debug("no window for view", view.file_name())
        return []

    file_path = view.file_name()
    if not file_path:
        # debug("no session for unsaved file")
        return []

    manager = windows.lookup(window)
    scope_configs = manager._configs.scope_configs(view, point)
    sessions = (manager.get_session(config.name, file_path) for config in scope_configs)
    ready_sessions = (session for session in sessions if session and session.state == ClientStates.READY)
    return ready_sessions 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def get_window_env(window: sublime.Window, config: ClientConfig) -> Tuple[List[str], Dict[str, str]]:

    # Create a dictionary of Sublime Text variables
    variables = window.extract_variables()

    # Expand language server command line environment variables
    expanded_args = list(
        sublime.expand_variables(os.path.expanduser(arg), variables)
        for arg in config.binary_args
    )

    # Override OS environment variables
    env = os.environ.copy()
    for var, value in config.env.items():
        # Expand both ST and OS environment variables
        env[var] = os.path.expandvars(sublime.expand_variables(value, variables))

    return expanded_args, env 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def start_window_config(window: sublime.Window,
                        workspace_folders: List[WorkspaceFolder],
                        config: ClientConfig,
                        on_pre_initialize: Callable[[Session], None],
                        on_post_initialize: Callable[[Session], None],
                        on_post_exit: Callable[[str], None],
                        on_stderr_log: Optional[Callable[[str], None]]) -> Optional[Session]:
    args, env = get_window_env(window, config)
    config.binary_args = args
    return create_session(config=config,
                          workspace_folders=workspace_folders,
                          env=env,
                          settings=settings,
                          on_pre_initialize=on_pre_initialize,
                          on_post_initialize=on_post_initialize,
                          on_post_exit=lambda config_name: on_session_ended(window, config_name, on_post_exit),
                          on_stderr_log=on_stderr_log) 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def load_inline_diff_views(self, window, non_cached_files, cached_files):
        # type: (sublime.Window, List[str], List[str]) -> None
        for fpath in non_cached_files:
            syntax = util.file.guess_syntax_for_file(window, fpath)
            settings = {
                "file_path": fpath,
                "repo_path": self.repo_path,
                "syntax": syntax
            }
            window.run_command("gs_inline_diff", {
                "settings": settings,
                "cached": False
            })

        for fpath in cached_files:
            syntax = util.file.guess_syntax_for_file(window, fpath)
            settings = {
                "file_path": fpath,
                "repo_path": self.repo_path,
                "syntax": syntax
            }
            window.run_command("gs_inline_diff", {
                "settings": settings,
                "cached": True
            }) 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def __init__(self, window, panel_name, file_regex=None,
                 line_regex=None, path=None, read_only=True,
                 auto_show=True):
        if not isinstance(window, Window):
            raise ValueError("window parameter is invalid")
        if not isinstance(panel_name, basestring):
            raise ValueError("panel_name must be a string")

        self.window = window
        self.panel_name = panel_name
        self.view = window.get_output_panel(panel_name)
        self.view.set_read_only(read_only)
        self.settings = ViewSettings(self.view)

        self.set_path(path, file_regex, line_regex)

        self.auto_show = auto_show 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def __init__(self, param):
        # no super() call! this would get the references confused
        if isinstance(param, sublime.Window):
            self.window = param
            self._window_command = True  # probably called from build system
            self.typ = WindowCommand
        elif isinstance(param, sublime.View):
            self.view   = param
            self._window_command = False
            self.typ = TextCommand
        else:
            raise TypeError("Something really bad happened and you are responsible")

        self._update_members() 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def create_window_commands(window_id):
    window = sublime.Window(window_id)
    cmds = []
    for class_ in window_command_classes:
        cmds.append(class_(window))
    return cmds 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def on_window_command(window_id, name, args):
    window = sublime.Window(window_id)
    for callback in all_callbacks['on_window_command']:
        try:
            res = callback.on_window_command(window, name, args)
            if isinstance(res, tuple):
                return res
            elif res:
                return (res, None)
        except:
            traceback.print_exc()

    return ("", None) 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def on_post_window_command(window_id, name, args):
    window = sublime.Window(window_id)
    for callback in all_callbacks['on_post_window_command']:
        try:
            callback.on_post_window_command(window, name, args)
        except:
            traceback.print_exc() 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def open(window_or_view: Union[sublime.View, sublime.Window]):
	if isinstance(window_or_view, sublime.View):
		view = window_or_view 
		window = view.window()
	else:
		window = window_or_view
		view = window.active_view()

	if get_setting(view, 'open_at_startup', False) and (not window.id() in was_opened_at_startup) and Debugger.should_auto_open_in_window(window):
		was_opened_at_startup.add(window.id())
		Debugger.for_window(window, create=True) 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def on_load_project(window: sublime.Window):
	if debugger := Debugger.get(window):
		debugger.project.reload() 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def on_pre_close_window(window: sublime.Window):
	if debugger := Debugger.get(window):
		debugger.dispose() 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def __init__(self, window: sublime.Window, on_output, args):
		global debugger_exec_for_id
		global id
		id += 1
		debugger_exec_for_id[id] = self

		self.future = core.create_future()
		self.on_output_callback = on_output

		window.run_command("debugger_exec", {
			"id": id,
			"args": args,
		})

		async def kill_if_canceled():
			try:
				await self.future
			except core.CancelledError as e:
				core.log_info("Cancel task")
				window.run_command("debugger_exec", {
					"id": id,
					"args": {
						"kill": True
					},
				})
				raise e
		core.run(kill_if_canceled()) 

# 需要导入模块: import sublime [as 别名]
# 或者: from sublime import Window [as 别名]
def open_settings(window: sublime.Window):
	window.run_command('edit_settings', {
		'base_file': '${packages}/Debugger/debugger.sublime-settings'
	})