The following is an updated version of the plugin outlined above; I’m posting this as a second post so that for the sake of posterity and comparison it’s possible to see what is different between the two.
The changes in this version over the above are:
- You can enable or disable the plugin in specific windows; this is the only way to be able to drag and drop a file since the plugin can’t detect
- Using
File > Open or the command to reopen a previously closed file will now be exempt and will open the file directly without moving it
- The plugin attempts to bring the new window to the front; depending on the platform in question this may or may not have an effect
- Better handling for files that are stored in symlinked locations; in some cases the
on_load will get the resolved filename and in some cases the link filename; the plugin will now work both ways.
To use the toggle, execute the toggle_project_specific_files command, which you can bind to a key or add to the command palette by creating a sublime-commands file with the following content:
[
{ "caption": "Toggle Project Specific File Loads",
"command": "toggle_project_specific_files"
}
]
The default state of the plugin is set by the constant at the top of the file, and when toggled the setting will be persisted, even across restarts of Sublime (so long as the window exists).
When the toggle happens, the status bar in the window will tell you what the current state now is.
import sublime
import sublime_plugin
from os.path import isabs, isfile, normpath, realpath, dirname, join
# Related reading:
# https://forum.sublimetext.com/t/forbid-st-from-opening-non-project-files-in-the-projects-window/68989
# The name of the window specific setting that determines if the functionality
# of this plugin is enabled or not, and an indication of whether the plugin
# functionality is enabled by default or not.
IS_ENABLED = '_project_specific_files'
ENABLED_DEFAULT = True
def get_target_window(file_name):
"""
Iterates through all of the windows that currently exist and create a dict
that associates each unique open folder with the window or windows that
carry that path.
Windows for which there is no folders open are associated with the empty
path name ''.
Returns back a list of the windows that this file should exist in based on
the path name of the file; this will return None if there are no windows
that are appropriate, such as if the file doesn't associate with a project
and there are no non-project windows open.
"""
result = {}
def get_list(folder):
"""
Look up the list of windows in the result set that associates with the
provided path; if there is not one, add a new empty list for that path.
"""
items = result.get(folder, [])
result[folder] = items
return items
# Iterate over all windows, filling up the result list with all of the
# unique folders that are open across all windows, and associate each path
# with the window or windows that have that folder open in the side bar.
for window in sublime.windows():
# Get the project data and project filename for the window. Windows
# with no folders will have empty project data, and windows with no
# project file will have an empty file name.
project_data = window.project_data() or {}
project_path = dirname(window.project_file_name() or '')
# Get the list of folders out of the window; if there are no folders,
# then associate this window with the empty path.
folders = project_data.get('folders', [])
if not folders:
get_list('').append(window)
# For each folder that's open, get the full absolute path. If the path
# is relative, it will be relaive to the project file, so adjust as
# needed. Each folder will associate with this window.
for folder in folders:
path = folder.get('path', '')
if not isabs(path):
path = normpath(join(project_path, path))
get_list(path).append(window)
# When opening files from the command line via subl (and maybe at
# other times too) the file path that Sublime delivers in on_load
# has symlinks resolved; so, add that path here.
resolved = realpath(path)
if path != resolved:
get_list(resolved).append(window)
# Get the list of folders that we found, and sort it based on length, with
# the longest paths first. This ensures that if any sub folders of a path
# are present along with the parent path, that we can find the subpath
# first since that is more specific.
file_path = dirname(file_name)
for path in sorted(result.keys(), key=lambda p: len(p), reverse=True):
# If the filename starts with this path, use the first window we found
# that has this path.
if file_path.startswith(path):
return result[path][0]
# There are no windows currently open that have a path that matches the
# provided file, and there are also no windows open that just have no path,
# so return None to indicate that.
return None
class ToggleProjectSpecificFilesCommand(sublime_plugin.WindowCommand):
"""
Toggle the enabled status of the plugin in the current window between on
and off; when off, the event listener below does nothing.
"""
def run(self):
enabled = not self.window.settings().get(IS_ENABLED, ENABLED_DEFAULT)
self.window.settings().set(IS_ENABLED, enabled)
status = 'enabled' if enabled else 'disabled'
self.window.status_message(f'Project specific file loads are {status}')
class ProjectFileEventListener(sublime_plugin.EventListener):
"""
Listen to events that allow us to detect when a file that has been opened
does not belong in the current window, and move it to the window in which
it does belong, if any.
"""
skip_next_load = False
def on_window_command(self, window, command, args):
"""
Listen for window commands that are trying to open explicit files; if
those are seen, set the flag that will tell the on_load listener that
it should not try to move the file because the open was intentional.
"""
if command in ('reopen_last_file', 'open_file', 'prompt_open_file'):
# prompt_open_file can be cancelled, which will leave the flag set
# and could cause an externally opened file to not be moved; the
# only good way around that is to have some timeout on setting the
# flag that forces it to be unset or similar. This doesn't do that
# currently because this is a rare situation.
self.skip_next_load = True
def on_load(self, view):
"""
Listen for a file being opened; we check the path of the file to see
which window it should be associated with, and shift it to the correct
window if not.
"""
# Determine if the plugin functionality is enabled in the window the
# file was opened in, and wether or not this file is flagged with the
# temporary setting that says that this view was loaded as a result of
# a previous tab move.
enabled = view.window().settings().get(IS_ENABLED, ENABLED_DEFAULT)
is_moved = view.settings().get('_moved_file', False)
# If the plugin isn't enabled, the file has already been moved, or we
# have the flag set saying that we should skip the next load, then
# reset the flag, erase the setting, and do nothing.
if not enabled or is_moved or self.skip_next_load:
self.skip_next_load = False
view.settings().erase('_moved_file')
return
# Determine what window this file should be contained in based on the
# path that it has.
target_window = get_target_window(view.file_name())
# If the target window ends up None, then the path of this file does
# not associate with any existing window and there are no windows that
# don't have a folder open, so we need to make a new one.
if target_window is None:
sublime.run_command('new_window')
target_window = sublime.active_window()
# If the window the file is in and the target window are not the same,
# then we have to move the file to the appropriate window, which we do
# by opening the file in the new window and closing the version in this
# window. When we move the file, we flag it with a setting to let the
# next call to on_load() know that it doesn't need to do anything.
if view.window() != target_window:
new_view = target_window.open_file(view.file_name())
new_view.settings().set('_moved_file', True)
# If the file that we're moving doesn't exist on disk, then someone
# just tried to open a nonexistant file to create it; in that case
# mark the buffer as scratch before we close it.
if not isfile(view.file_name()):
view.set_scratch(True)
view.close()
# Bring the target window to the front.
target_window.bring_to_front()
). So, your deep involvement is greatly appreciated!! Thanks!!
I thought its maximum is to display images of few types, but not the live video actually 
So cool
It’s so early in my timezone, uhhh.