예제 #1
0
    def _start(self, sources: typing.List[typing.Any],
               context: UserContext) -> None:
        from denite.ui.map import do_map

        self._vim.command('silent! autocmd! denite')

        if re.search(r'\[Command Line\]$', self._vim.current.buffer.name):
            # Ignore command line window.
            return

        resume = self._initialized and context['resume']
        if resume:
            # Skip the initialization

            update = ('immediately', 'immediately_1', 'cursor_pos',
                      'prev_winid', 'start_filter', 'quick_move')
            for key in update:
                self._context[key] = context[key]

            self._check_move_option()
            if self._check_do_option():
                return

            self._init_buffer()
            if context['refresh']:
                self.redraw()
            self._move_to_pos(self._cursor)
        else:
            if self._context != context:
                self._context.clear()
                self._context.update(context)
            self._context['sources'] = sources
            self._context['is_redraw'] = False
            self._is_multi = len(sources) > 1

            if not sources:
                # Ignore empty sources.
                error(self._vim, 'Empty sources')
                return

            self._init_denite()
            self._gather_candidates()
            self._update_candidates()

            self._init_cursor()
            self._check_move_option()
            if self._check_do_option():
                return

            self._init_buffer()

        self._update_displayed_texts()
        self._update_buffer()
        self._move_to_pos(self._cursor)

        if self._context['quick_move'] and do_map(self, 'quick_move', []):
            return

        if self._context['start_filter']:
            do_map(self, 'open_filter_buffer', [])
예제 #2
0
 def do_map(self, args):
     bufnr = args[0]
     bufvars = self._vim.buffers[bufnr].vars
     try:
         ui = self.get_ui(bufvars['denite']['buffer_name'])
         ui._cursor = self._vim.call('line', '.')
         return do_map(ui, args[1], args[2])
     except Exception:
         import traceback
         import denite.util
         for line in traceback.format_exc().splitlines():
             denite.util.error(self._vim, line)
         denite.util.error(self._vim, 'Please execute :messages command.')
예제 #3
0
    def do_map(self, args: Args) -> typing.Any:
        from denite.ui.map import do_map
        bufnr = args[0]
        if not self._vim.call('bufexists', bufnr):
            return
        bufvars = self._vim.buffers[bufnr].vars
        if 'denite' not in bufvars:
            return

        try:
            buffer_name = bufvars['denite']['buffer_name']
            ui = self.get_ui(buffer_name)
            ui._cursor = self._vim.call('line', '.')
            ui._context['next_actions'] = []

            ret = do_map(ui, args[1], args[2])

            if args[1] == 'quit' and buffer_name[-1] == '@':
                # Temporary buffer quit
                # Resume the previous buffer
                self.resume(buffer_name[:-1])

            if ui._context['next_actions']:
                actions = ui._context['next_actions']
                ui._context['next_actions'] = []

                # Do actions
                for action in actions:
                    ui = self.get_ui(action['buffer_name'])
                    self.resume(action['buffer_name'])

                    ui.do_action(
                        action['name'], '', True, action['targets']
                    )

            return ret
        except Exception:
            import traceback
            import denite.util
            for line in traceback.format_exc().splitlines():
                denite.util.error(self._vim, line)
            denite.util.error(self._vim,
                              'Please execute :messages command.')
예제 #4
0
    def do_map(self, args: Args) -> typing.Any:
        from denite.ui.map import do_map
        bufnr = args[0]
        if not self._vim.call('bufexists', bufnr):
            return
        bufvars = self._vim.buffers[bufnr].vars
        if 'denite' not in bufvars:
            return

        try:
            ui = self.get_ui(bufvars['denite']['buffer_name'])
            ui._cursor = self._vim.call('line', '.')
            return do_map(ui, args[1], args[2])
        except Exception:
            import traceback
            import denite.util
            for line in traceback.format_exc().splitlines():
                denite.util.error(self._vim, line)
            denite.util.error(self._vim, 'Please execute :messages command.')