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 }