kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

window.cc (12120B)


      1 #include "window.hh"
      2 
      3 #include "assert.hh"
      4 #include "buffer.hh"
      5 #include "buffer_utils.hh"
      6 #include "context.hh"
      7 #include "client.hh"
      8 #include "highlighter.hh"
      9 #include "hook_manager.hh"
     10 #include "input_handler.hh"
     11 #include "face_registry.hh"
     12 #include "option_manager.hh"
     13 #include "debug.hh"
     14 #include "option.hh"
     15 #include "option_types.hh"
     16 #include "profile.hh"
     17 
     18 #include <algorithm>
     19 
     20 namespace Kakoune
     21 {
     22 
     23 // Implementation in highlighters.cc
     24 void setup_builtin_highlighters(HighlighterGroup& group);
     25 
     26 Window::Window(Buffer& buffer)
     27     : Scope(buffer),
     28       m_buffer(&buffer),
     29       m_builtin_highlighters{highlighters()}
     30 {
     31     run_hook_in_own_context(Hook::WinCreate, buffer.name());
     32 
     33     options().register_watcher(*this);
     34 
     35     setup_builtin_highlighters(m_builtin_highlighters.group());
     36 
     37     // gather as on_option_changed can mutate the option managers
     38     for (auto& option : options().flatten_options()
     39                       | transform([](auto& ptr) { return ptr.get(); })
     40                       | gather<Vector<const Option*>>())
     41         on_option_changed(*option);
     42 }
     43 
     44 Window::~Window()
     45 {
     46     options().unregister_watcher(*this);
     47 }
     48 
     49 void Window::set_client(Client* client)
     50 {
     51     m_client = client;
     52 }
     53 
     54 void Window::scroll(LineCount offset)
     55 {
     56     m_position.line = std::max(0_line, m_position.line + offset);
     57 }
     58 
     59 void Window::display_line_at(LineCount buffer_line, LineCount display_line)
     60 {
     61     if (display_line >= 0 or display_line < m_dimensions.line)
     62         m_position.line = std::max(0_line, buffer_line - display_line);
     63 }
     64 
     65 void Window::center_line(LineCount buffer_line)
     66 {
     67     display_line_at(buffer_line, m_dimensions.line/2_line);
     68 }
     69 
     70 void Window::scroll(ColumnCount offset)
     71 {
     72     m_position.column = std::max(0_col, m_position.column + offset);
     73 }
     74 
     75 void Window::display_column_at(ColumnCount buffer_column, ColumnCount display_column)
     76 {
     77     if (display_column >= 0 or display_column < m_dimensions.column)
     78         m_position.column = std::max(0_col, buffer_column - display_column);
     79 }
     80 
     81 void Window::center_column(ColumnCount buffer_column)
     82 {
     83     display_column_at(buffer_column, m_dimensions.column/2_col);
     84 }
     85 
     86 static uint32_t compute_faces_hash(const FaceRegistry& faces)
     87 {
     88     uint32_t hash = 0;
     89     for (auto&& face : faces.flatten_faces() | transform(&FaceRegistry::FaceMap::Item::value))
     90         hash = combine_hash(hash, face.base.empty() ? hash_value(face.face) : hash_value(face.base));
     91     return hash;
     92 }
     93 
     94 Window::Setup Window::build_setup(const Context& context) const
     95 {
     96     return {m_position, m_dimensions,
     97             context.buffer().timestamp(),
     98             compute_faces_hash(context.faces(false)),
     99             context.selections().main_index(),
    100             context.selections() | gather<Vector<BasicSelection, MemoryDomain::Display>>()};
    101 }
    102 
    103 bool Window::needs_redraw(const Context& context) const
    104 {
    105     auto& selections = context.selections();
    106     return m_position != m_last_setup.position or
    107         m_dimensions != m_last_setup.dimensions or
    108         context.buffer().timestamp() != m_last_setup.timestamp or
    109         selections.main_index() != m_last_setup.main_selection or
    110         selections.size() != m_last_setup.selections.size() or
    111         compute_faces_hash(context.faces(false)) != m_last_setup.faces_hash or
    112         not std::equal(selections.begin(), selections.end(),
    113                        m_last_setup.selections.begin(), m_last_setup.selections.end());
    114 }
    115 
    116 const DisplayBuffer& Window::update_display_buffer(const Context& context)
    117 {
    118     ProfileScope profile{context.options()["debug"].get<DebugFlags>(), [&](std::chrono::microseconds duration) {
    119         write_to_debug_buffer(format("window display update for '{}' took {} us",
    120                                      buffer().display_name(), (size_t)duration.count()));
    121     }, not (buffer().flags() & Buffer::Flags::Debug)};
    122 
    123     if (m_display_buffer.timestamp() != -1)
    124     {
    125         for (auto&& change : buffer().changes_since(m_display_buffer.timestamp()))
    126         {
    127             if (change.type == Buffer::Change::Insert and change.begin.line < m_position.line)
    128                 m_position.line += change.end.line - change.begin.line;
    129             if (change.type == Buffer::Change::Erase and change.begin.line < m_position.line)
    130                 m_position.line = std::max(m_position.line - (change.end.line - change.begin.line), change.begin.line);
    131         }
    132     }
    133 
    134     DisplayLineList& lines = m_display_buffer.lines();
    135     m_display_buffer.set_timestamp(buffer().timestamp());
    136     lines.clear();
    137 
    138     if (m_dimensions.line == 0 or m_dimensions.column == 0)
    139         return m_display_buffer;
    140 
    141     kak_assert(&buffer() == &context.buffer());
    142     DisplaySetup setup = compute_display_setup(context);
    143 
    144     if (setup.line_count != m_last_display_setup.line_count or
    145         setup.widget_columns != m_last_display_setup.widget_columns)
    146     {
    147         // Technically the window has not resized, but most things that hook WinResize probably want to be notfied anyway
    148         m_resize_hook_pending = true;
    149     }
    150 
    151     for (LineCount line = 0; line < setup.line_count; ++line)
    152     {
    153         LineCount buffer_line = setup.first_line + line;
    154         if (buffer_line >= buffer().line_count())
    155             break;
    156         lines.emplace_back(AtomList{{buffer(), {buffer_line, {buffer_line, buffer()[buffer_line].length()}}}});
    157     }
    158 
    159     m_display_buffer.compute_range();
    160     const BufferRange range{{0,0}, buffer().end_coord()};
    161     for (auto pass : {HighlightPass::Replace, HighlightPass::Wrap, HighlightPass::Move})
    162         m_builtin_highlighters.highlight({context, setup, pass, {}}, m_display_buffer, range);
    163 
    164     if (context.ensure_cursor_visible)
    165     {
    166         auto cursor_pos = display_coord(context.selections().main().cursor());
    167         kak_assert(cursor_pos);
    168 
    169         if (auto line_overflow = cursor_pos->line - m_dimensions.line + setup.scroll_offset.line + 1; line_overflow > 0)
    170         {
    171             lines.erase(lines.begin(), lines.begin() + (size_t)line_overflow);
    172             setup.first_line = lines.begin()->range().begin.line;
    173         }
    174 
    175         auto max_first_column = cursor_pos->column - (setup.widget_columns + setup.scroll_offset.column);
    176         setup.first_column = std::max(0_col, std::min(setup.first_column, max_first_column));
    177 
    178         auto min_first_column = cursor_pos->column - (m_dimensions.column - setup.scroll_offset.column) + 1;
    179         setup.first_column = std::max(setup.first_column, min_first_column);
    180     }
    181 
    182     for (auto& line : m_display_buffer.lines())
    183         line.trim_from(setup.widget_columns, setup.first_column, m_dimensions.column);
    184     if (m_display_buffer.lines().size() > m_dimensions.line)
    185         m_display_buffer.lines().resize((size_t)m_dimensions.line);
    186 
    187     m_builtin_highlighters.highlight({context, setup, HighlightPass::Colorize, {}}, m_display_buffer, range);
    188 
    189     m_display_buffer.optimize();
    190 
    191     set_position({setup.first_line, setup.first_column});
    192     m_last_setup = build_setup(context);
    193     m_last_display_setup = setup;
    194 
    195     return m_display_buffer;
    196 }
    197 
    198 void Window::set_position(DisplayCoord position)
    199 {
    200     m_position.line = clamp(position.line, 0_line, buffer().line_count()-1);
    201     m_position.column = std::max(0_col, position.column);
    202 }
    203 
    204 void Window::set_dimensions(DisplayCoord dimensions)
    205 {
    206     if (m_dimensions != dimensions)
    207     {
    208         m_dimensions = dimensions;
    209         m_resize_hook_pending = true;
    210     }
    211 }
    212 
    213 void Window::run_resize_hook_ifn()
    214 {
    215     if (m_resize_hook_pending)
    216     {
    217         m_resize_hook_pending = false;
    218         run_hook_in_own_context(Hook::WinResize,
    219                                 format("{}.{}", m_dimensions.line, m_dimensions.column));
    220     }
    221 }
    222 
    223 static void check_display_setup(const DisplaySetup& setup, const Window& window)
    224 {
    225     kak_assert(setup.first_line >= 0 and setup.first_line < window.buffer().line_count());
    226     kak_assert(setup.first_column >= 0);
    227     kak_assert(setup.line_count >= 0);
    228 }
    229 
    230 DisplaySetup Window::compute_display_setup(const Context& context) const
    231 {
    232     DisplayCoord offset = options()["scrolloff"].get<DisplayCoord>();
    233     offset.line = std::min(offset.line, (m_dimensions.line + 1) / 2);
    234     offset.column = std::min(offset.column, (m_dimensions.column + 1) / 2);
    235     const auto& cursor = context.selections().main().cursor();
    236     DisplaySetup setup{m_position.line, m_dimensions.line, m_position.column, 0_col, offset};
    237     if (context.ensure_cursor_visible and
    238         cursor.line - offset.line < setup.first_line)
    239         setup.first_line = clamp(cursor.line - offset.line, 0_line, buffer().line_count()-1);
    240 
    241     for (auto pass : {HighlightPass::Move, HighlightPass::Wrap, HighlightPass::Replace})
    242         m_builtin_highlighters.compute_display_setup({context, setup, pass, {}}, setup);
    243 
    244     if (context.ensure_cursor_visible and
    245         cursor.line + offset.line >= setup.first_line + setup.line_count)
    246         setup.first_line = std::min(cursor.line + offset.line - setup.line_count + 1, buffer().line_count()-1);
    247 
    248     setup.first_line = std::min(setup.first_line, buffer().line_count()-1);
    249     check_display_setup(setup, *this);
    250 
    251     return setup;
    252 }
    253 
    254 namespace
    255 {
    256 ColumnCount find_display_column(const DisplayLine& line, const Buffer& buffer,
    257                                 BufferCoord coord)
    258 {
    259     ColumnCount column = 0;
    260     for (auto& atom : line)
    261     {
    262         if (atom.has_buffer_range() and
    263             coord >= atom.begin() and coord < atom.end())
    264         {
    265             if (atom.type() == DisplayAtom::Range)
    266                 column += utf8::column_distance(get_iterator(buffer, atom.begin()),
    267                                                 get_iterator(buffer, coord));
    268             return column;
    269         }
    270         column += atom.length();
    271     }
    272     return column;
    273 }
    274 
    275 BufferCoord find_buffer_coord(const DisplayLine& line, const Buffer& buffer,
    276                               ColumnCount column)
    277 {
    278     const auto& range = line.range();
    279     for (auto& atom : line)
    280     {
    281         ColumnCount len = atom.length();
    282         if (atom.has_buffer_range() and column < len)
    283         {
    284             if (atom.type() == DisplayAtom::Range)
    285                 return buffer.clamp(
    286                     utf8::advance(get_iterator(buffer, atom.begin()),
    287                                   get_iterator(buffer, range.end),
    288                                   std::max(0_col, column)).coord());
    289              return buffer.clamp(atom.begin());
    290         }
    291         column -= len;
    292     }
    293     return range.end == BufferCoord{0,0} ?
    294         range.end : buffer.prev(range.end);
    295 }
    296 }
    297 
    298 Optional<DisplayCoord> Window::display_coord(BufferCoord coord) const
    299 {
    300     if (m_display_buffer.timestamp() != buffer().timestamp())
    301         return {};
    302 
    303     LineCount l = 0;
    304     for (auto& line : m_display_buffer.lines())
    305     {
    306         auto& range = line.range();
    307         if (range.begin <= coord and coord < range.end)
    308             return DisplayCoord{l, find_display_column(line, buffer(), coord)};
    309         ++l;
    310     }
    311     return {};
    312 }
    313 
    314 Optional<BufferCoord> Window::buffer_coord(DisplayCoord coord) const
    315 {
    316     if (m_display_buffer.timestamp() != buffer().timestamp() or
    317         m_display_buffer.lines().empty())
    318         return {};
    319     if (coord < 0_line)
    320         return {};
    321     if ((size_t)coord.line >= m_display_buffer.lines().size())
    322         return {};
    323 
    324     return find_buffer_coord(m_display_buffer.lines()[(int)coord.line],
    325                              buffer(), coord.column);
    326 }
    327 
    328 void Window::clear_display_buffer()
    329 {
    330     m_display_buffer = DisplayBuffer{};
    331 }
    332 
    333 void Window::on_option_changed(const Option& option)
    334 {
    335     run_hook_in_own_context(Hook::WinSetOption, format("{}={}", option.name(), option.get_desc_string()));
    336 }
    337 
    338 
    339 void Window::run_hook_in_own_context(Hook hook, StringView param, String client_name)
    340 {
    341     if (m_buffer->flags() & Buffer::Flags::NoHooks)
    342         return;
    343 
    344     InputHandler hook_handler{{ *m_buffer, Selection{} },
    345                               Context::Flags::Draft,
    346                               std::move(client_name)};
    347     hook_handler.context().set_window(*this);
    348     if (m_client)
    349         hook_handler.context().set_client(*m_client);
    350 
    351     hooks().run_hook(hook, param, hook_handler.context());
    352 }
    353 }