Hey there, I see this solution for ST3
http://sublimetexttips.com/execute-a-command-every-time-sublime-launches/
but is there a simple method of executing commands on startup? for ST2…
Surely there is a file that runs commands etc. on startup…
Thanks!
A
That should work for Sublime Text 2 too as long as it supports plugin_loaded function.
That solution is you basically making a basic plugin - you would be able to add as many commands as you’d like to that function - they are executed when the plugin is loaded ( which is after Sublime Text has launched during the load phase for plugins where it may be someone slow to use ).
What commands are you looking to run on startup?
It wouldn’t be difficult to modify that plugin to use the settings system… Load the settings object, then if ( setting.get( ‘console’, False ): run command to open console…
and so on… so you could have it configured and enable /. disable the options as it starts up. It would require reading a bit of the api to find the commands you’re looking for, for Sublime Text 2… But when done it would be a small simple solution and would work for you.
Alas the plugin_loaded function is not mentioned…
http://www.sublimetext.com/docs/2/api_reference.html
Tks…
The purpose of plugin_loaded() in Sublime Text 3 is to tell plugin code when the API is available, because in ST3 the plugin host is hosted in a separate process and it takes time to get everything spun up and talking to the core. As such there are only a few API calls that you can make prior to plugin_loaded() being called.
On the flip side, Sublime Text 2 doesn’t have a separate plugin host, and it doesn’t contain this particular endpoint.
Both versions load plugin files right away and execute any top level code in the plugin while the plugin is being loaded, which is why in ST3 you need to guard any API calls from being called too early.
Despite the lack of a plugin_loaded() module endpoint, I have some anecdotal evidence that calling some API methods (such as sublime.active_window() too soon in ST2 does indeed return None and not a valid window. I’ve never done anything in ST2 that needed top level code, so I don’t know if there is an accepted “best practices” for something like this, but a potential solution is this:
import sublime, sublime_plugin
import sys
def plugin_loaded():
# If there is no active window yet, call ourselves again a bit to
# give the API time to settle.
window = sublime.active_window()
if window is None:
return sublime.set_timeout(lambda: plugin_loaded(), 100)
window.run_command("show_panel", {"panel": "console", "toggle": True})
# on ST2, simulate a call to plugin_loaded()
if sys.version_info < (3,):
plugin_loaded()
If loaded in ST3, plugin_loaded() will be called automatically and the guard code will do nothing, and the console will open at startup. On ST2 an initial call to plugin_loaded() is made by the top level code (by detecting that the python version is 2) and the code in plugin_loaded() may trigger the guard code and call itself again until things are ready.
As I mentioned above, I don’t know if this is the expected behaviour here, as I only have the one version of ST2 to test with. Probably this would go a little pear shaped if you’re on a Mac because it’s possible for Sublime to be running with no windows at all. On the other hand ST2 on a Mac is no longer supported, so that may be less of an issue. 
Thanks a lot for the comprehensive reply.
Really appreciate it and will apply to my install, fresh enough to Python.
Thanks.
A
This is running first time when I start Sublime, but not when I open subsequential windows. Any chance that code can be changed, so it will run every time new Sublime window is open.
The code outlined above ensures that, whenever the plugin is loaded, the active window (the one with the focus) has its console toggled. That would happen either at startup OR when the plugin loads (but the latter would only happen if it was part of a packge that was ignored and then unignored, or if you manually re-save the file).
If you wanted to ensure that all windows have the console open when the plugin loads, and not just the active one, the last part of the plugin_loaded() should be this instead (not that you asked, but just for the sake of completeness):
for w in sublime.windows():
w.run_command("show_panel", {"panel": "console", "toggle": True})
Assuming you still want ST2 compatability (I sure hope not) you would still need the other parts of that version to verify that it’s safe to make the call.
To have this trigger when a new window is created after this, you would want something like the following (presented here as a single plugin but if you’re combining, just add the class to the plugin and you’re good to go):
import sublime
import sublime_plugin
class OpenConsoleInNewWindowListener(sublime_plugin.EventListener):
"""
In builds of Sublime Text >= 4050, listen for the on_new_window event to
know when a new window is created, and toggle the panel in it.
"""
def on_new_window(self, window):
window.run_command("show_panel", {"panel": "console", "toggle": True})
Note however that this requires Sublime Text 4; the related event here does not exist in builds prior to this one. You can work around this in ST3 (and maybe ST2 but it has been years since I’ve used its API so I’m not 100% certain the below would work for it).
In ST3 where this event does not exist, you need to resort to trying to catch the command that causes a new window to be created; you can do that by adding this method to the listener above after on_new_window:
def on_post_window_command(self, window, command, args):
"""
Prior to build 4050, the on_new_window event does not exist; we can
bodge it in by listening for the command that creates a new window and
manually triggering the event.
on_post_window_command triggers after the command happens, at which
point the newly created window is the active one.
"""
if command == "new_window" and int(sublime.version() < 4050):
self.on_new_window(sublime.active_window())
What this does is listen for the command that creates a new window to be issued and, once it is finished executing, if the version of Sublime is prior to the version that supports the event natively, it will just invoke it with the new window.
This is not 100% foolproof; it has been a while, but as I recall there are ways to create a new window that don’t go through the command system and thus cannot catch this (hence part of the reason the event was added). The only one that comes to mind is running Sublime on MacOS, where clicking rhe dock icon while Sublime is running causes (I beleive) a new window to appear.
Since that is an outside party telling the core to create the window, the command doesn’t trigger, and the plugin would not work.
If THAT matters, then you would need to get into something like constantly polling the available window list to see if there is a new one now that was not there a few ms prior, but that is kind of invasive, resource intensive, and probably better solved by using a more recent build of Sublime (or manually using the keyboard shortcut to create the new window)…
Thanks for the response. I can see that its way to complicated for the thing that I would like to do.
I’m using portable Sublime on Windows. Since you can run different Sublime instances; copy-paste Sublime folder and rename it. I have customized one Sublime, with Terminus, to replace Windows CMD in my workflow. Every time you start that Sublime or open a new window, you need to start Terminus. It’s not a big deal xD.
As always thank you very much xD
