def _ui_bell(*msg: str) -> None:
window = active_window()
if not window:
return
view = window.active_view()
if not view:
return
if msg:
status_message(*msg)
if get_option(view, 'belloff') == 'all':
return
color_scheme = get_setting(view, 'bell_color_scheme')
if color_scheme in ('dark', 'light'):
color_scheme = 'Packages/NeoVintageous/res/Bell-%s.hidden-color-scheme' % color_scheme
duration = int(0.3 * 1000)
times = 4
delay = 55
style = get_setting(view, 'bell')
settings = view.settings()
if style == 'view':
settings.set('color_scheme', color_scheme)
def remove_bell() -> None:
settings.erase('color_scheme')
set_timeout(remove_bell, duration)
elif style == 'views':
views = []
for group in range(window.num_groups()):
view = window.active_view_in_group(group)
if view:
view.settings().set('color_scheme', color_scheme)
views.append(view)
def remove_bell() -> None:
for view in views:
view.settings().erase('color_scheme')
set_timeout(remove_bell, duration)
elif style == 'blink':
# Ensure we leave the setting as we found it.
times = times if (times % 2) == 0 else times + 1
def do_blink() -> None:
nonlocal times
if times > 0:
settings.set('highlight_line', not settings.get('highlight_line'))
times -= 1
set_timeout(do_blink, delay)
do_blink()
def _seq_to_command(view, seq: str, mode: str):
# Return the command definition mapped for seq and mode.
#
# Args:
# view (View):
# seq (str): The command sequence.
# mode (str): Forces the use of this mode instead of the global state's.
#
# Returns:
# ViCommandDefBase:
# ViMissingCommandDef: If not found.
if mode in plugin.mappings:
plugin_command = plugin.mappings[mode].get(seq)
if plugin_command:
plugin_name = plugin_command.__class__.__module__[24:]
is_plugin_enabled = get_setting(view, 'enable_%s' % plugin_name)
if is_plugin_enabled:
return plugin_command
if mode in keys.mappings:
command = keys.mappings[mode].get(seq)
if command:
return command
return ViMissingCommandDef()
def _get_search_flags(view, search: str) -> int:
flags = LITERAL
if search and get_setting(view, 'sneak_use_ic_scs') == 1:
if get_option(view,
'ignorecase') and not is_smartcase_pattern(view, search):
flags |= IGNORECASE
return flags
def _get(self, view):
try:
value = _session[self._name]
except KeyError:
# DEPRECATED This is for backwards compatability only. All options
# should be set by the .neovintageousrc configuration file.
# See https://github.com/NeoVintageous/NeoVintageous/issues/404.
value = get_setting(view, self._name, self._default)
return value
def window_quit_view(window, **kwargs) -> None:
# Need to get the setting before quiting the the view because if closing the
# last view there may not be a view to get the setting from.
exit_when_quiting_last_window = get_setting(
window.active_view(), 'exit_when_quiting_last_window')
_close_view(window, **kwargs)
if len(window.views()) == 0 and exit_when_quiting_last_window:
window.run_command('close')
def _get(view, name: str = _UNNAMED):
name = str(name)
assert len(name) == 1, "Register names must be 1 char long."
if name == _CURRENT_FILE_NAME:
try:
file_name = view.file_name()
if not file_name:
return
return [file_name]
except AttributeError:
return
if name in _CLIPBOARD:
return [get_clipboard()]
if ((name not in (_UNNAMED, _SMALL_DELETE)) and (name in _SPECIAL)):
return
# Special case lumped among these --user always wants the sys clipboard
if ((name == _UNNAMED)
and (get_setting(view, 'use_sys_clipboard') is True)):
return [get_clipboard()]
# If the expression register holds a value and we're requesting the unnamed
# register, return the expression register and clear it aftwerwards.
if name == _UNNAMED and _data.get(_EXPRESSION, ''):
value = _data[_EXPRESSION]
_data[_EXPRESSION] = None
return value
if name.isdigit():
if name == _LAST_YANK:
return _data[name]
return _get_numbered_register(name)
try:
return _data[name.lower()]
except KeyError:
pass
def on_query_context(self, view, key, operator, operand, match_all):
# Called when determining to trigger a key binding with the given context key.
#
# If the plugin knows how to respond to the context, it should return
# either True of False. If the context is unknown, it should return
# None.
#
# Args:
# view (View):
# key (str):
# operator (int):
# operand (bool):
# match_all (bool):
#
# Returns:
# bool: If the context is known.
# None: If the context is unknown.
if key == 'nv_handle_key':
handle_keys = get_setting(view, 'handle_keys')
if handle_keys:
try:
# Check if the key (no mode prefix; all modes) should be handled.
return bool(handle_keys[operand])
except KeyError:
# Check if the key should be handled only for a specific mode.
# The format is "{mode}_{key}" e.g. "n_<C-w>", "v_<C-w>"
# meaning NORMAL, VISUAL respectively. No prefix implies all
# modes. See mode_to_char() for a list of valid mode prefixes.
cur_mode_char = mode_to_char(get_mode(view))
if cur_mode_char:
try:
return bool(handle_keys['%s_%s' %
(cur_mode_char, operand)])
except KeyError:
pass
# By default all keys are handled.
return True
try:
return _query_contexts[key](view, operator, operand, match_all)
except KeyError:
pass
def open(view) -> None:
term = get_setting(view, 'terminal', 'cmd.exe')
if term:
subprocess.Popen([term, '/k'], cwd=os.getcwd())
def init_state(view) -> None:
# Initialise view state.
#
# Runs every time a view is activated, loaded, etc.
# Don't initialise if we get a console, widget, panel, or any other view
# where Vim modes are not relevant. Some related initialised settings that
# may cause unexpected behaviours if they exist are erased "cleaned" too.
if not is_view(view):
try:
# TODO "cleaning" views that are not initialised shouldn't be necessary?
clean_view(view)
except Exception:
_log.debug(
'could not clean an object: console, widget, panel, etc.')
finally:
return
if not get_reset_during_init(view):
# Probably exiting from an input panel, like when using '/'. Don't reset
# the global state, as it may contain data needed to complete the
# command that's being built.
set_reset_during_init(view, True)
return
mode = get_mode(view)
# Does user want to reset mode (to normal mode) when initialising state?
if mode not in (NORMAL, UNKNOWN) and not get_setting(
view, 'reset_mode_when_switching_tabs'):
return
# Fix malformed selection: if we have no selections, add one.
if len(view.sel()) == 0:
view.sel().add(0)
if get_setting(view, 'default_mode') == 'insert':
if mode in (NORMAL, UNKNOWN):
enter_insert_mode(view, mode)
elif mode in (VISUAL, VISUAL_LINE, VISUAL_BLOCK):
# Visual modes are not reset (to normal mode), because actions like
# pressing the super key or opening a command-palette/overlay will cause
# the active view to lose focus and when focus is received again it
# triggers the on_activated() event, this in turn initialises the view'
# state, which would reset the visual mode to normal mode, therefore,
# for example, any command run from the command palette that expects to
# operate on a visual selection wouldn't work because the visual
# selection is reset to normal mode before the command has time to run.
# See https://github.com/NeoVintageous/NeoVintageous/issues/547
pass
elif mode in (INSERT, REPLACE):
# NOTE that the mode is not passed as an argument because it causes the
# cursor to move back one point from it's current position, for example
# when pressing i<Esc>i<Esc>i<Esc> the cursor moves one point each time,
# which is expected, but not expected when initialising state. But not
# passing the mode may also be causing some other hidden bugs too.
view.window().run_command('_enter_normal_mode', {'from_init': True})
elif mode != VISUAL and view.has_non_empty_selection_region():
# Try to fixup a malformed visual state. For example, apparently this
# can happen when a search is performed via a search panel and "Find
# All" is pressed. In that case, multiple selections may need fixing.
view.window().run_command('_enter_visual_mode', {'mode': mode})
else:
# This may be run when we're coming from cmdline mode.
mode = VISUAL if view.has_non_empty_selection_region() else mode
view.window().run_command('_enter_normal_mode', {
'mode': mode,
'from_init': True
})
reset_command_data(view)
def open(view) -> None:
term = get_setting(view, 'terminal', os.environ.get('TERM'))
if term:
subprocess.Popen([term, '-e', 'bash'], cwd=os.getcwd())
def init_state(view):
# type: (...) -> None
# Initialise view state.
#
# Runs at startup and every time a view gets activated, loaded, etc.
#
# Args:
# :view (sublime.View):
if not is_view(view):
# Abort if we got a console, widget, panel...
try:
# XXX: All this seems to be necessary here.
if not is_ignored_but_command_mode(view):
view.settings().set('command_mode', False)
view.settings().set('inverse_caret_state', False)
view.settings().erase('vintage')
except Exception:
# TODO [review] Exception handling
_log.debug(
'error initialising irregular view i.e. console, widget, panel, etc.'
)
finally:
return
state = State(view)
if not get_reset_during_init(view):
# Probably exiting from an input panel, like when using '/'. Don't
# reset the global state, as it may contain data needed to complete
# the command that's being built.
set_reset_during_init(view, True)
return
mode = state.mode
# Non-standard user setting.
reset = get_setting(view, 'reset_mode_when_switching_tabs')
# XXX: If the view was already in normal mode, we still need to run the
# init code. I believe this is due to Sublime Text (intentionally) not
# serializing the inverted caret state and the command_mode setting when
# first loading a file.
# If the mode is unknown, it might be a new file. Let normal mode setup
# continue.
if not reset and (mode not in (NORMAL, UNKNOWN)):
return
# If we have no selections, add one.
if len(view.sel()) == 0:
view.sel().add(0)
if get_setting(view, 'default_mode') == 'insert':
if mode in (NORMAL, UNKNOWN):
enter_insert_mode(view, mode)
elif mode in (VISUAL, VISUAL_LINE):
# This was commented out to fix the issue of visual selections being
# lost because some keys, like the super key, cause Sublime to lose
# focus, and when focus comes back it triggers the on_activated() event,
# which then initializes state, which then causes visual mode to enter
# normal mode. Note that there may be regressions as a side effect.
# See nv/events.py#NeoVintageousEvents::on_activated().
# See https://github.com/NeoVintageous/NeoVintageous/issues/547
# view.window().run_command('_enter_normal_mode', {'from_init': True})
_log.debug('initializing %s state', mode)
elif mode in (INSERT, REPLACE):
# TODO: Don't we need to pass a mode here?
view.window().run_command('_enter_normal_mode', {'from_init': True})
elif view.has_non_empty_selection_region() and mode != VISUAL:
# Runs, for example, when we've performed a search via ST3 search panel
# and we've pressed 'Find All'. In this case, we want to ensure a
# consistent state for multiple selections.
# TODO We could end up with multiple selections in other ways that bypass init_state.
state.mode = VISUAL
else:
# This may be run when we're coming from cmdline mode.
mode = VISUAL if view.has_non_empty_selection_region() else mode
state.enter_normal_mode()
view.window().run_command('_enter_normal_mode', {
'mode': mode,
'from_init': True
})
state.reset_command_data()
def _maybe_set_sys_clipboard(view, name: str, values: list) -> None:
if (name in _CLIPBOARD or get_setting(view, 'use_sys_clipboard') is True):
value = '\n'.join(values)
set_clipboard(value)
update_clipboard_history(value)