def _set_parsers(self, command): # type: (ViCommandDefBase) -> None if command.accept_input: if command.input_parser.type == INPUT_VIA_PANEL: if self.non_interactive: return run_window_command(command.input_parser.command)
def eval(self): # type: () -> None # Run data as a command if possible. if not self.runnable(): return if self.action and self.motion: action_cmd = self.action.translate(self) motion_cmd = self.motion.translate(self) _log.debug('changing to INTERNAL_NORMAL...') self.mode = INTERNAL_NORMAL # TODO Make motions and actions require a 'mode' param. if 'mode' in action_cmd['action_args']: _log.debug('action has a mode, changing to INTERNAL_NORMAL...') action_cmd['action_args']['mode'] = INTERNAL_NORMAL if 'mode' in motion_cmd['motion_args']: _log.debug('motion has a mode, changing to INTERNAL_NORMAL...') motion_cmd['motion_args']['mode'] = INTERNAL_NORMAL args = action_cmd['action_args'] args['count'] = 1 # Let the action run the motion within its edit object so that we # don't need to worry about grouping edits to the buffer. args['motion'] = motion_cmd if self.glue_until_normal_mode and not self.processing_notation: # Tell Sublime Text that it should group all the next edits # until we enter normal mode again. run_window_command('mark_undo_groups_for_gluing') self.add_macro_step(action_cmd['action'], args) run_window_command(action_cmd['action'], args) if not self.non_interactive: if self.action.repeatable: _log.debug('action is repeatable, setting repeat data...') self.repeat_data = ('vi', str(self.sequence), self.mode, None) self.reset_command_data() return if self.motion: motion_cmd = self.motion.translate(self) self.add_macro_step(motion_cmd['motion'], motion_cmd['motion_args']) # All motions are subclasses of ViTextCommandBase, so it's safe to # run the command via the current view. run_view_command(self.view, motion_cmd['motion'], motion_cmd['motion_args']) if self.action: action_cmd = self.action.translate(self) if self.mode == NORMAL: _log.debug('is NORMAL, changing to INTERNAL_NORMAL...') self.mode = INTERNAL_NORMAL if 'mode' in action_cmd['action_args']: _log.debug( 'action has a mode, changing to INTERNAL_NORMAL...') action_cmd['action_args']['mode'] = INTERNAL_NORMAL elif self.mode in (VISUAL, VISUAL_LINE, VISUAL_BLOCK): _log.debug('is VISUAL, saving selection...') self.view.add_regions('visual_sel', list(self.view.sel())) self.view.settings().set('_nv_visual_sel_mode', self.mode) # Some commands, like 'i' or 'a', open a series of edits that need # to be grouped together unless we are gluing a larger sequence # through _nv_process_notation. For example, aFOOBAR<Esc> should be # grouped atomically, but not inside a sequence like # iXXX<Esc>llaYYY<Esc>, where we want to group the whole sequence # instead. if self.glue_until_normal_mode and not self.processing_notation: # Tell Sublime Text that it should group all the next edits # until we enter normal mode again. run_window_command('mark_undo_groups_for_gluing') seq = self.sequence visual_repeat_data = self.get_visual_repeat_data() action = self.action self.add_macro_step(action_cmd['action'], action_cmd['action_args']) run_window_command(action_cmd['action'], action_cmd['action_args']) if not (self.processing_notation and self.glue_until_normal_mode): if action.repeatable: _log.debug('action is repeatable, setting repeat data...') self.repeat_data = ('vi', seq, self.mode, visual_repeat_data) if self.mode == INTERNAL_NORMAL: _log.debug('is INTERNAL_NORMAL, changing to NORMAL...') self.enter_normal_mode() self.reset_command_data()
def evaluate_state(view) -> None: _log.debug('evaluating...') if not is_runnable(view): _log.debug('not runnable!') return action = get_action(view) motion = get_motion(view) if action and motion: # Evaluate action with motion: runs the action with the motion as an # argument. The motion's mode is set to INTERNAL_NORMAL and is run # by the action internally to make the selection it operates on. For # example the motion commands can be used after an operator command, # to have the command operate on the text that was moved over. action_cmd = action.translate(view) motion_cmd = motion.translate(view) _log.debug('action: %s', action_cmd) _log.debug('motion: %s', motion_cmd) set_mode(view, INTERNAL_NORMAL) if 'mode' in action_cmd['action_args']: action_cmd['action_args']['mode'] = INTERNAL_NORMAL if 'mode' in motion_cmd['motion_args']: motion_cmd['motion_args']['mode'] = INTERNAL_NORMAL args = action_cmd['action_args'] args['count'] = 1 # Let the action run the motion within its edit object so that we # don't need to worry about grouping edits to the buffer. args['motion'] = motion_cmd if get_glue_until_normal_mode( view) and not is_processing_notation(view): run_window_command('mark_undo_groups_for_gluing') add_macro_step(view, action_cmd['action'], args) run_window_command(action_cmd['action'], args) if is_interactive(view) and get_action(view).repeatable: set_repeat_data( view, ('vi', str(get_sequence(view)), get_mode(view), None)) reset_command_data(view) return # Nothing more to do. if motion: # Evaluate motion: Run it. motion_cmd = motion.translate(view) _log.debug('motion: %s', motion_cmd) add_macro_step(view, motion_cmd['motion'], motion_cmd['motion_args']) run_motion(view, motion_cmd) if action: # Evaluate action. Run it. action_cmd = action.translate(view) _log.debug('action: %s', action_cmd) if get_mode(view) == NORMAL: set_mode(view, INTERNAL_NORMAL) if 'mode' in action_cmd['action_args']: action_cmd['action_args']['mode'] = INTERNAL_NORMAL elif is_visual_mode(get_mode(view)): # Special-case exclusion: saving the previous selection would # overwrite the previous selection needed e.g. gv in a VISUAL # mode needs to expand or contract to previous selection. if action_cmd['action'] != '_vi_gv': save_previous_selection(view, get_mode(view)) # Some commands, like 'i' or 'a', open a series of edits that need # to be grouped together unless we are gluing a larger sequence # through _nv_process_notation. For example, aFOOBAR<Esc> should be # grouped atomically, but not inside a sequence like # iXXX<Esc>llaYYY<Esc>, where we want to group the whole sequence # instead. if get_glue_until_normal_mode( view) and not is_processing_notation(view): run_window_command('mark_undo_groups_for_gluing') sequence = get_sequence(view) visual_repeat_data = get_visual_repeat_data(view, get_mode(view)) action = get_action(view) add_macro_step(view, action_cmd['action'], action_cmd['action_args']) run_action(active_window(), action_cmd) if not (is_processing_notation(view) and get_glue_until_normal_mode(view)) and action.repeatable: set_repeat_data( view, ('vi', sequence, get_mode(view), visual_repeat_data)) if get_mode(view) == INTERNAL_NORMAL: set_mode(view, NORMAL) reset_command_data(view)
def run_command(self): run_window_command(self._command)
def run_command(self) -> None: run_window_command(self._command)
def eval(self): # type: () -> None if not self.runnable(): return if self.action and self.motion: action_cmd = self.action.translate(self) _log.debug('action_cmd = %s', action_cmd) motion_cmd = self.motion.translate(self) _log.debug('motion_cmd = %s', motion_cmd) _log.debug('changing to INTERNAL_NORMAL...') self.mode = INTERNAL_NORMAL if 'mode' in action_cmd['action_args']: action_cmd['action_args']['mode'] = INTERNAL_NORMAL if 'mode' in motion_cmd['motion_args']: motion_cmd['motion_args']['mode'] = INTERNAL_NORMAL args = action_cmd['action_args'] args['count'] = 1 # Let the action run the motion within its edit object so that we # don't need to worry about grouping edits to the buffer. args['motion'] = motion_cmd if self.glue_until_normal_mode and not self.processing_notation: # Tell Sublime Text that it should group all the next edits # until we enter normal mode again. run_window_command('mark_undo_groups_for_gluing') macros.add_step(self, action_cmd['action'], args) run_window_command(action_cmd['action'], args) if not self.non_interactive: if self.action.repeatable: _log.debug('action is repeatable, setting repeat data...') set_repeat_data( self.view, ('vi', str(self.sequence), self.mode, None)) self.reset_command_data() return if self.motion: motion_cmd = self.motion.translate(self) macros.add_step(self, motion_cmd['motion'], motion_cmd['motion_args']) # All motions are subclasses of ViTextCommandBase, so it's safe to # run the command via the current view. run_motion(self.view, motion_cmd) if self.action: action_cmd = self.action.translate(self) if self.mode == NORMAL: _log.debug('is NORMAL, changing to INTERNAL_NORMAL...') self.mode = INTERNAL_NORMAL if 'mode' in action_cmd['action_args']: _log.debug( 'action has a mode, changing to INTERNAL_NORMAL...') action_cmd['action_args']['mode'] = INTERNAL_NORMAL elif is_visual_mode(self.mode): # Special-case exclusion: saving the previous selection would # overwrite the previous selection needed e.g. gv in a VISUAL # mode needs to expand or contract to previous selection. if action_cmd['action'] != '_vi_gv': _log.debug('is VISUAL, saving selection...') save_previous_selection(self.view, self.mode) # Some commands, like 'i' or 'a', open a series of edits that need # to be grouped together unless we are gluing a larger sequence # through _nv_process_notation. For example, aFOOBAR<Esc> should be # grouped atomically, but not inside a sequence like # iXXX<Esc>llaYYY<Esc>, where we want to group the whole sequence # instead. if self.glue_until_normal_mode and not self.processing_notation: # Tell Sublime Text that it should group all the next edits # until we enter normal mode again. run_window_command('mark_undo_groups_for_gluing') seq = self.sequence visual_repeat_data = self.get_visual_repeat_data() action = self.action macros.add_step(self, action_cmd['action'], action_cmd['action_args']) run_action(active_window(), action_cmd) if not (self.processing_notation and self.glue_until_normal_mode): if action.repeatable: _log.debug('action is repeatable, setting repeat data...') set_repeat_data(self.view, ('vi', seq, self.mode, visual_repeat_data)) if self.mode == INTERNAL_NORMAL: _log.debug('is INTERNAL_NORMAL, changing to NORMAL...') self.enter_normal_mode() self.reset_command_data()
def run_command(self): # type: () -> None run_window_command(self._command)