mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-12-29 14:14:45 +03:00
ad59fb7cf0
Rather than adding/removing a breakpoint indicator, and then telling the debugger about it and hoping it works, let the debugger tell us if it succeeded and then use that to update the indicator. This prevents the user from adding breakpoints to invalid locations while the debugger is running. It also avoids a couple of scary VERIFY()s. We still allow creating breakpoints in invalid locations while the debugger is *not* running.
836 lines
28 KiB
C++
836 lines
28 KiB
C++
/*
|
|
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2018-2022, the SerenityOS developers.
|
|
* Copyright (c) 2023-2024, Sam Atkins <atkinssj@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "Editor.h"
|
|
#include "Debugger/Debugger.h"
|
|
#include "EditorWrapper.h"
|
|
#include "HackStudio.h"
|
|
#include <AK/ByteBuffer.h>
|
|
#include <AK/Debug.h>
|
|
#include <AK/JsonParser.h>
|
|
#include <AK/LexicalPath.h>
|
|
#include <LibCMake/CMakeCache/SyntaxHighlighter.h>
|
|
#include <LibCMake/SyntaxHighlighter.h>
|
|
#include <LibConfig/Client.h>
|
|
#include <LibCore/DirIterator.h>
|
|
#include <LibCore/Timer.h>
|
|
#include <LibCpp/SemanticSyntaxHighlighter.h>
|
|
#include <LibCpp/SyntaxHighlighter.h>
|
|
#include <LibFileSystem/FileSystem.h>
|
|
#include <LibGUI/Action.h>
|
|
#include <LibGUI/Application.h>
|
|
#include <LibGUI/GML/AutocompleteProvider.h>
|
|
#include <LibGUI/GML/SyntaxHighlighter.h>
|
|
#include <LibGUI/GitCommitSyntaxHighlighter.h>
|
|
#include <LibGUI/INISyntaxHighlighter.h>
|
|
#include <LibGUI/Label.h>
|
|
#include <LibGUI/MessageBox.h>
|
|
#include <LibGUI/Painter.h>
|
|
#include <LibGUI/Scrollbar.h>
|
|
#include <LibGUI/Window.h>
|
|
#include <LibJS/SyntaxHighlighter.h>
|
|
#include <LibMarkdown/Document.h>
|
|
#include <LibMarkdown/SyntaxHighlighter.h>
|
|
#include <LibSQL/AST/SyntaxHighlighter.h>
|
|
#include <LibSyntax/Language.h>
|
|
#include <LibWeb/CSS/SyntaxHighlighter/SyntaxHighlighter.h>
|
|
#include <LibWeb/DOM/Text.h>
|
|
#include <LibWeb/HTML/HTMLHeadElement.h>
|
|
#include <LibWeb/HTML/SyntaxHighlighter/SyntaxHighlighter.h>
|
|
#include <LibWebView/OutOfProcessWebView.h>
|
|
#include <Shell/SyntaxHighlighter.h>
|
|
#include <fcntl.h>
|
|
|
|
namespace HackStudio {
|
|
|
|
enum class TooltipRole {
|
|
Documentation,
|
|
ParametersHint,
|
|
};
|
|
|
|
static RefPtr<GUI::Window> s_tooltip_window;
|
|
static RefPtr<WebView::OutOfProcessWebView> s_tooltip_page_view;
|
|
static Optional<TooltipRole> m_tooltip_role;
|
|
|
|
ErrorOr<NonnullRefPtr<Editor>> Editor::try_create()
|
|
{
|
|
NonnullRefPtr<Editor> editor = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Editor()));
|
|
TRY(initialize_tooltip_window());
|
|
return editor;
|
|
}
|
|
|
|
Editor::Editor()
|
|
{
|
|
create_tokens_info_timer();
|
|
|
|
set_document(CodeDocument::create());
|
|
m_move_execution_to_line_action = GUI::Action::create("Set Execution Point to Cursor Line", [this](auto&) {
|
|
VERIFY(is_program_running());
|
|
auto success = Debugger::the().set_execution_position(currently_open_file(), cursor().line());
|
|
if (success) {
|
|
set_execution_position(cursor().line());
|
|
} else {
|
|
GUI::MessageBox::show(window(), "Failed to set execution position"sv, "Error"sv, GUI::MessageBox::Type::Error);
|
|
}
|
|
});
|
|
|
|
set_debug_mode(false);
|
|
|
|
add_custom_context_menu_action(*m_move_execution_to_line_action);
|
|
|
|
set_gutter_visible(true);
|
|
on_gutter_click = [&](auto line, auto) {
|
|
add_breakpoint(line).release_value_but_fixme_should_propagate_errors();
|
|
};
|
|
|
|
m_git_diff_indicator_id = register_gutter_indicator(
|
|
[&](auto& painter, Gfx::IntRect rect, size_t line) {
|
|
auto diff_type = code_document().line_difference(line);
|
|
switch (diff_type) {
|
|
case CodeDocument::DiffType::AddedLine:
|
|
painter.draw_text(rect, "+"sv, font(), Gfx::TextAlignment::Center);
|
|
break;
|
|
case CodeDocument::DiffType::ModifiedLine:
|
|
painter.draw_text(rect, "!"sv, font(), Gfx::TextAlignment::Center);
|
|
break;
|
|
case CodeDocument::DiffType::DeletedLinesBefore:
|
|
painter.draw_text(rect, "-"sv, font(), Gfx::TextAlignment::Center);
|
|
break;
|
|
case CodeDocument::DiffType::None:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
}).release_value_but_fixme_should_propagate_errors();
|
|
|
|
m_breakpoint_indicator_id = register_gutter_indicator(
|
|
[&](auto& painter, Gfx::IntRect rect, size_t) {
|
|
auto const& icon = breakpoint_icon_bitmap();
|
|
painter.draw_scaled_bitmap(rect, icon, icon.rect());
|
|
},
|
|
[&](size_t line_index, auto) {
|
|
remove_breakpoint(line_index);
|
|
}).release_value_but_fixme_should_propagate_errors();
|
|
|
|
m_execution_indicator_id = register_gutter_indicator(
|
|
[&](auto& painter, Gfx::IntRect rect, size_t) {
|
|
auto const& icon = current_position_icon_bitmap();
|
|
painter.draw_scaled_bitmap(rect, icon, icon.rect());
|
|
}).release_value_but_fixme_should_propagate_errors();
|
|
|
|
if (Config::read_string("HackStudio"sv, "Global"sv, "DocumentationSearchPaths"sv).is_empty()) {
|
|
Config::write_string("HackStudio"sv, "Global"sv, "DocumentationSearchPaths"sv, "[\"/usr/share/man/man2\", \"/usr/share/man/man3\"]"sv);
|
|
}
|
|
}
|
|
|
|
ErrorOr<void> Editor::initialize_tooltip_window()
|
|
{
|
|
if (s_tooltip_window.is_null()) {
|
|
s_tooltip_window = GUI::Window::construct();
|
|
s_tooltip_window->set_window_type(GUI::WindowType::Tooltip);
|
|
}
|
|
if (s_tooltip_page_view.is_null()) {
|
|
s_tooltip_page_view = s_tooltip_window->set_main_widget<WebView::OutOfProcessWebView>();
|
|
}
|
|
return {};
|
|
}
|
|
|
|
EditorWrapper& Editor::wrapper()
|
|
{
|
|
return static_cast<EditorWrapper&>(*parent());
|
|
}
|
|
EditorWrapper const& Editor::wrapper() const
|
|
{
|
|
return static_cast<EditorWrapper const&>(*parent());
|
|
}
|
|
|
|
void Editor::paint_event(GUI::PaintEvent& event)
|
|
{
|
|
GUI::TextEditor::paint_event(event);
|
|
|
|
GUI::Painter painter(*this);
|
|
if (is_focused()) {
|
|
painter.add_clip_rect(event.rect());
|
|
|
|
auto rect = frame_inner_rect();
|
|
if (vertical_scrollbar().is_visible())
|
|
rect.set_width(rect.width() - vertical_scrollbar().width());
|
|
if (horizontal_scrollbar().is_visible())
|
|
rect.set_height(rect.height() - horizontal_scrollbar().height());
|
|
painter.draw_rect(rect, palette().selection());
|
|
}
|
|
}
|
|
|
|
static HashMap<ByteString, ByteString>& man_paths()
|
|
{
|
|
static HashMap<ByteString, ByteString> paths;
|
|
if (paths.is_empty()) {
|
|
auto json = Config::read_string("HackStudio"sv, "Global"sv, "DocumentationSearchPaths"sv);
|
|
AK::JsonParser parser(json);
|
|
|
|
auto value_or_error = parser.parse();
|
|
if (value_or_error.is_error())
|
|
return paths;
|
|
|
|
auto value = value_or_error.release_value();
|
|
if (!value.is_array())
|
|
return paths;
|
|
|
|
for (auto& json_value : value.as_array().values()) {
|
|
if (!json_value.is_string())
|
|
continue;
|
|
|
|
Core::DirIterator it(json_value.as_string(), Core::DirIterator::Flags::SkipDots);
|
|
while (it.has_next()) {
|
|
auto path = it.next_full_path();
|
|
auto title = LexicalPath::title(path);
|
|
paths.set(title, path);
|
|
}
|
|
}
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
void Editor::show_documentation_tooltip_if_available(ByteString const& hovered_token, Gfx::IntPoint screen_location)
|
|
{
|
|
auto it = man_paths().find(hovered_token);
|
|
if (it == man_paths().end()) {
|
|
dbgln_if(EDITOR_DEBUG, "no man path for {}", hovered_token);
|
|
if (m_tooltip_role == TooltipRole::Documentation) {
|
|
s_tooltip_window->hide();
|
|
m_tooltip_role.clear();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (s_tooltip_window->is_visible() && m_tooltip_role == TooltipRole::Documentation && hovered_token == m_last_parsed_token) {
|
|
return;
|
|
}
|
|
|
|
dbgln_if(EDITOR_DEBUG, "opening {}", it->value);
|
|
auto file_or_error = Core::File::open(it->value, Core::File::OpenMode::Read);
|
|
if (file_or_error.is_error()) {
|
|
dbgln("Failed to open {}, {}", it->value, file_or_error.error());
|
|
return;
|
|
}
|
|
|
|
auto buffer_or_error = file_or_error.release_value()->read_until_eof();
|
|
if (buffer_or_error.is_error()) {
|
|
dbgln("Couldn't read file: {}", buffer_or_error.error());
|
|
return;
|
|
}
|
|
|
|
auto man_document = Markdown::Document::parse(buffer_or_error.release_value());
|
|
if (!man_document) {
|
|
dbgln("failed to parse markdown");
|
|
return;
|
|
}
|
|
|
|
s_tooltip_page_view->load_html(man_document->render_to_html("<style>body { background-color: #dac7b5; }</style>"sv));
|
|
|
|
s_tooltip_window->set_rect(0, 0, 500, 400);
|
|
s_tooltip_window->move_to(screen_location.translated(4, 4));
|
|
m_tooltip_role = TooltipRole::Documentation;
|
|
s_tooltip_window->show();
|
|
|
|
m_last_parsed_token = hovered_token;
|
|
}
|
|
|
|
void Editor::mousemove_event(GUI::MouseEvent& event)
|
|
{
|
|
GUI::TextEditor::mousemove_event(event);
|
|
|
|
if (document().spans().is_empty())
|
|
return;
|
|
|
|
auto text_position = text_position_at(event.position());
|
|
if (!text_position.is_valid() && m_tooltip_role == TooltipRole::Documentation) {
|
|
s_tooltip_window->hide();
|
|
m_tooltip_role.clear();
|
|
return;
|
|
}
|
|
|
|
auto highlighter = wrapper().editor().syntax_highlighter();
|
|
if (!highlighter)
|
|
return;
|
|
|
|
bool hide_tooltip = (m_tooltip_role == TooltipRole::Documentation);
|
|
bool is_over_clickable = false;
|
|
|
|
if (m_hovering_editor && event.position().x() > fixed_elements_width())
|
|
set_override_cursor(m_hovering_clickable && event.ctrl() ? Gfx::StandardCursor::Hand : Gfx::StandardCursor::IBeam);
|
|
|
|
for (auto& span : document().spans()) {
|
|
bool is_clickable = (highlighter->is_navigatable(span.data) || highlighter->is_identifier(span.data));
|
|
if (span.range.contains(m_previous_text_position) && !span.range.contains(text_position)) {
|
|
if (is_clickable && span.attributes.underline_style.has_value()) {
|
|
span.attributes.underline_style.clear();
|
|
wrapper().editor().update();
|
|
}
|
|
}
|
|
|
|
if (span.range.contains(text_position)) {
|
|
auto hovered_span_text = document().text_in_range(span.range);
|
|
dbgln_if(EDITOR_DEBUG, "Hovering: {} \"{}\"", span.range, hovered_span_text);
|
|
|
|
if (is_clickable) {
|
|
is_over_clickable = true;
|
|
bool was_underlined = span.attributes.underline_style.has_value();
|
|
bool now_underlined = event.modifiers() & Mod_Ctrl;
|
|
span.attributes.underline_style.clear();
|
|
if (now_underlined)
|
|
span.attributes.underline_style = Gfx::TextAttributes::UnderlineStyle::Solid;
|
|
if (now_underlined != was_underlined) {
|
|
wrapper().editor().update();
|
|
}
|
|
}
|
|
|
|
if (highlighter->is_identifier(span.data)) {
|
|
show_documentation_tooltip_if_available(hovered_span_text, event.position().translated(screen_relative_rect().location()));
|
|
hide_tooltip = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_previous_text_position = text_position;
|
|
if (hide_tooltip) {
|
|
s_tooltip_window->hide();
|
|
m_tooltip_role.clear();
|
|
}
|
|
|
|
m_hovering_clickable = (is_over_clickable) && (event.modifiers() & Mod_Ctrl);
|
|
}
|
|
|
|
void Editor::mousedown_event(GUI::MouseEvent& event)
|
|
{
|
|
if (m_tooltip_role == TooltipRole::ParametersHint) {
|
|
s_tooltip_window->hide();
|
|
m_tooltip_role.clear();
|
|
}
|
|
|
|
auto highlighter = wrapper().editor().syntax_highlighter();
|
|
if (!highlighter) {
|
|
GUI::TextEditor::mousedown_event(event);
|
|
return;
|
|
}
|
|
|
|
auto text_position = text_position_at(event.position());
|
|
|
|
if (!(event.modifiers() & Mod_Ctrl)) {
|
|
GUI::TextEditor::mousedown_event(event);
|
|
return;
|
|
}
|
|
|
|
if (!text_position.is_valid()) {
|
|
GUI::TextEditor::mousedown_event(event);
|
|
return;
|
|
}
|
|
|
|
if (auto* span = document().span_at(text_position)) {
|
|
if (highlighter->is_navigatable(span->data)) {
|
|
on_navigatable_link_click(*span);
|
|
return;
|
|
}
|
|
if (highlighter->is_identifier(span->data)) {
|
|
on_identifier_click(*span);
|
|
return;
|
|
}
|
|
}
|
|
|
|
GUI::TextEditor::mousedown_event(event);
|
|
}
|
|
|
|
void Editor::drag_enter_event(GUI::DragEvent& event)
|
|
{
|
|
auto const& mime_types = event.mime_types();
|
|
if (mime_types.contains_slow("text/uri-list"sv))
|
|
event.accept();
|
|
}
|
|
|
|
void Editor::drop_event(GUI::DropEvent& event)
|
|
{
|
|
event.accept();
|
|
|
|
if (event.mime_data().has_urls()) {
|
|
auto urls = event.mime_data().urls();
|
|
if (urls.is_empty())
|
|
return;
|
|
window()->move_to_front();
|
|
if (urls.size() > 1) {
|
|
GUI::MessageBox::show(window(), "HackStudio can only open one file at a time!"sv, "One at a time please!"sv, GUI::MessageBox::Type::Error);
|
|
return;
|
|
}
|
|
set_current_editor_wrapper(static_cast<EditorWrapper*>(parent()));
|
|
open_file(urls.first().serialize_path());
|
|
}
|
|
}
|
|
|
|
void Editor::enter_event(Core::Event& event)
|
|
{
|
|
m_hovering_editor = true;
|
|
GUI::TextEditor::enter_event(event);
|
|
}
|
|
|
|
void Editor::leave_event(Core::Event& event)
|
|
{
|
|
m_hovering_editor = false;
|
|
GUI::TextEditor::leave_event(event);
|
|
}
|
|
|
|
static HashMap<ByteString, ByteString>& include_paths()
|
|
{
|
|
static HashMap<ByteString, ByteString> paths;
|
|
|
|
auto add_directory = [](ByteString base, Optional<ByteString> recursive, auto handle_directory) -> void {
|
|
Core::DirIterator it(recursive.value_or(base), Core::DirIterator::Flags::SkipDots);
|
|
while (it.has_next()) {
|
|
auto path = it.next_full_path();
|
|
if (!FileSystem::is_directory(path)) {
|
|
auto key = path.substring(base.length() + 1, path.length() - base.length() - 1);
|
|
dbgln_if(EDITOR_DEBUG, "Adding header \"{}\" in path \"{}\"", key, path);
|
|
paths.set(key, path);
|
|
} else {
|
|
handle_directory(base, path, handle_directory);
|
|
}
|
|
}
|
|
};
|
|
|
|
if (paths.is_empty()) {
|
|
add_directory(".", {}, add_directory);
|
|
add_directory("/usr/local/include", {}, add_directory);
|
|
add_directory("/usr/local/include/c++/9.2.0", {}, add_directory);
|
|
add_directory("/usr/include", {}, add_directory);
|
|
}
|
|
|
|
return paths;
|
|
}
|
|
|
|
void Editor::navigate_to_include_if_available(ByteString path)
|
|
{
|
|
auto it = include_paths().find(path);
|
|
if (it == include_paths().end()) {
|
|
dbgln_if(EDITOR_DEBUG, "no header {} found.", path);
|
|
return;
|
|
}
|
|
|
|
on_open(it->value);
|
|
}
|
|
|
|
void Editor::set_execution_position(size_t line_number)
|
|
{
|
|
if (execution_position().has_value())
|
|
remove_gutter_indicator(m_execution_indicator_id, execution_position().value());
|
|
add_gutter_indicator(m_execution_indicator_id, line_number);
|
|
code_document().set_execution_position(line_number);
|
|
scroll_position_into_view({ line_number, 0 });
|
|
}
|
|
|
|
void Editor::clear_execution_position()
|
|
{
|
|
if (!execution_position().has_value()) {
|
|
return;
|
|
}
|
|
size_t previous_position = execution_position().value();
|
|
code_document().clear_execution_position();
|
|
remove_gutter_indicator(m_execution_indicator_id, previous_position);
|
|
}
|
|
|
|
Gfx::Bitmap const& Editor::breakpoint_icon_bitmap()
|
|
{
|
|
static auto bitmap = Gfx::Bitmap::load_from_file("/res/icons/16x16/breakpoint.png"sv).release_value_but_fixme_should_propagate_errors();
|
|
return *bitmap;
|
|
}
|
|
|
|
Gfx::Bitmap const& Editor::current_position_icon_bitmap()
|
|
{
|
|
static auto bitmap = Gfx::Bitmap::load_from_file("/res/icons/16x16/go-forward.png"sv).release_value_but_fixme_should_propagate_errors();
|
|
return *bitmap;
|
|
}
|
|
|
|
CodeDocument const& Editor::code_document() const
|
|
{
|
|
return verify_cast<CodeDocument const>(document());
|
|
}
|
|
|
|
CodeDocument& Editor::code_document()
|
|
{
|
|
return const_cast<CodeDocument&>(static_cast<Editor const&>(*this).code_document());
|
|
}
|
|
|
|
void Editor::set_document(GUI::TextDocument& doc)
|
|
{
|
|
if (has_document() && &document() == &doc)
|
|
return;
|
|
|
|
VERIFY(is<CodeDocument>(doc));
|
|
GUI::TextEditor::set_document(doc);
|
|
|
|
auto& code_document = static_cast<CodeDocument&>(doc);
|
|
|
|
set_language_client_for(code_document);
|
|
set_syntax_highlighter_for(code_document);
|
|
|
|
if (m_language_client) {
|
|
set_autocomplete_provider(make<LanguageServerAidedAutocompleteProvider>(*m_language_client));
|
|
// NOTE:
|
|
// When a file is opened for the first time in HackStudio, its content is already synced with the filesystem.
|
|
// Otherwise, if the file has already been opened before in some Editor instance, it should exist in the LanguageServer's
|
|
// FileDB, and the LanguageServer should already have its up-to-date content.
|
|
// So it's OK to just pass an fd here (rather than the TextDocument's content).
|
|
auto maybe_fd = Core::System::open(code_document.file_path(), O_RDONLY | O_NOCTTY);
|
|
if (maybe_fd.is_error()) {
|
|
warnln("Failed to open `{}`: {}", code_document.file_path(), maybe_fd.release_error());
|
|
return;
|
|
}
|
|
auto fd = maybe_fd.release_value();
|
|
m_language_client->open_file(code_document.file_path(), fd);
|
|
close(fd);
|
|
} else {
|
|
set_autocomplete_provider_for(code_document);
|
|
}
|
|
}
|
|
|
|
Optional<Editor::AutoCompleteRequestData> Editor::get_autocomplete_request_data()
|
|
{
|
|
if (!wrapper().editor().m_language_client)
|
|
return {};
|
|
|
|
return Editor::AutoCompleteRequestData { cursor() };
|
|
}
|
|
|
|
void Editor::LanguageServerAidedAutocompleteProvider::provide_completions(Function<void(Vector<CodeComprehension::AutocompleteResultEntry>)> callback)
|
|
{
|
|
auto& editor = static_cast<Editor&>(*m_editor).wrapper().editor();
|
|
auto data = editor.get_autocomplete_request_data();
|
|
if (!data.has_value())
|
|
callback({});
|
|
|
|
m_language_client.on_autocomplete_suggestions = [callback = move(callback)](auto suggestions) {
|
|
callback(suggestions);
|
|
};
|
|
|
|
m_language_client.request_autocomplete(
|
|
editor.code_document().file_path(),
|
|
data.value().position.line(),
|
|
data.value().position.column());
|
|
}
|
|
|
|
void Editor::after_execute(GUI::TextDocumentUndoCommand const& command)
|
|
{
|
|
if (!m_language_client)
|
|
return;
|
|
|
|
if (is<GUI::InsertTextCommand>(command)) {
|
|
auto const& insert_command = static_cast<GUI::InsertTextCommand const&>(command);
|
|
m_language_client->insert_text(
|
|
code_document().file_path(),
|
|
insert_command.text(),
|
|
insert_command.range().start().line(),
|
|
insert_command.range().start().column());
|
|
return;
|
|
}
|
|
|
|
if (is<GUI::RemoveTextCommand>(command)) {
|
|
auto const& remove_command = static_cast<GUI::RemoveTextCommand const&>(command);
|
|
m_language_client->remove_text(
|
|
code_document().file_path(),
|
|
remove_command.range().start().line(),
|
|
remove_command.range().start().column(),
|
|
remove_command.range().end().line(),
|
|
remove_command.range().end().column());
|
|
return;
|
|
}
|
|
|
|
flush_file_content_to_langauge_server();
|
|
}
|
|
|
|
void Editor::undo()
|
|
{
|
|
TextEditor::undo();
|
|
flush_file_content_to_langauge_server();
|
|
}
|
|
|
|
void Editor::redo()
|
|
{
|
|
TextEditor::redo();
|
|
flush_file_content_to_langauge_server();
|
|
}
|
|
|
|
void Editor::flush_file_content_to_langauge_server()
|
|
{
|
|
if (!m_language_client)
|
|
return;
|
|
|
|
m_language_client->set_file_content(
|
|
code_document().file_path(),
|
|
document().text());
|
|
}
|
|
|
|
void Editor::on_navigatable_link_click(const GUI::TextDocumentSpan& span)
|
|
{
|
|
auto span_text = document().text_in_range(span.range);
|
|
auto header_path = span_text.substring(1, span_text.length() - 2);
|
|
dbgln_if(EDITOR_DEBUG, "Ctrl+click: {} \"{}\"", span.range, header_path);
|
|
navigate_to_include_if_available(header_path);
|
|
}
|
|
|
|
void Editor::on_identifier_click(const GUI::TextDocumentSpan& span)
|
|
{
|
|
if (!m_language_client)
|
|
return;
|
|
|
|
m_language_client->on_declaration_found = [](ByteString const& file, size_t line, size_t column) {
|
|
HackStudio::open_file(file, line, column);
|
|
};
|
|
m_language_client->search_declaration(code_document().file_path(), span.range.start().line(), span.range.start().column());
|
|
}
|
|
|
|
void Editor::set_syntax_highlighter_for(CodeDocument const& document)
|
|
{
|
|
if (!document.language().has_value()) {
|
|
set_syntax_highlighter({});
|
|
force_rehighlight();
|
|
return;
|
|
}
|
|
|
|
switch (document.language().value()) {
|
|
case Syntax::Language::Cpp:
|
|
if (m_use_semantic_syntax_highlighting) {
|
|
set_syntax_highlighter(make<Cpp::SemanticSyntaxHighlighter>());
|
|
on_token_info_timer_tick();
|
|
m_tokens_info_timer->restart();
|
|
} else {
|
|
set_syntax_highlighter(make<Cpp::SyntaxHighlighter>());
|
|
}
|
|
break;
|
|
case Syntax::Language::CMake:
|
|
set_syntax_highlighter(make<CMake::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::CMakeCache:
|
|
set_syntax_highlighter(make<CMake::Cache::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::CSS:
|
|
set_syntax_highlighter(make<Web::CSS::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::GitCommit:
|
|
set_syntax_highlighter(make<GUI::GitCommitSyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::GML:
|
|
set_syntax_highlighter(make<GUI::GML::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::HTML:
|
|
set_syntax_highlighter(make<Web::HTML::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::INI:
|
|
set_syntax_highlighter(make<GUI::IniSyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::JavaScript:
|
|
set_syntax_highlighter(make<JS::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::Markdown:
|
|
set_syntax_highlighter(make<Markdown::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::Shell:
|
|
set_syntax_highlighter(make<Shell::SyntaxHighlighter>());
|
|
break;
|
|
case Syntax::Language::SQL:
|
|
set_syntax_highlighter(make<SQL::AST::SyntaxHighlighter>());
|
|
break;
|
|
default:
|
|
set_syntax_highlighter({});
|
|
}
|
|
|
|
force_rehighlight();
|
|
}
|
|
|
|
void Editor::set_autocomplete_provider_for(CodeDocument const& document)
|
|
{
|
|
if (document.language() == Syntax::Language::GML) {
|
|
set_autocomplete_provider(make<GUI::GML::AutocompleteProvider>());
|
|
} else {
|
|
set_autocomplete_provider({});
|
|
}
|
|
}
|
|
|
|
void Editor::set_language_client_for(CodeDocument const& document)
|
|
{
|
|
if (m_language_client && m_language_client->language() == document.language())
|
|
return;
|
|
|
|
if (document.language() == Syntax::Language::Cpp)
|
|
m_language_client = get_language_client<LanguageClients::Cpp::ConnectionToServer>(project().root_path());
|
|
|
|
if (document.language() == Syntax::Language::Shell)
|
|
m_language_client = get_language_client<LanguageClients::Shell::ConnectionToServer>(project().root_path());
|
|
|
|
if (m_language_client) {
|
|
m_language_client->on_tokens_info_result = [this](Vector<CodeComprehension::TokenInfo> const& tokens_info) {
|
|
on_tokens_info_result(tokens_info);
|
|
};
|
|
}
|
|
}
|
|
|
|
void Editor::keydown_event(GUI::KeyEvent& event)
|
|
{
|
|
TextEditor::keydown_event(event);
|
|
|
|
if (m_tooltip_role == TooltipRole::ParametersHint) {
|
|
s_tooltip_window->hide();
|
|
m_tooltip_role.clear();
|
|
}
|
|
|
|
if (!event.shift() && !event.alt() && event.ctrl() && event.key() == KeyCode::Key_P) {
|
|
handle_function_parameters_hint_request();
|
|
}
|
|
|
|
m_tokens_info_timer->restart();
|
|
}
|
|
|
|
void Editor::handle_function_parameters_hint_request()
|
|
{
|
|
if (!m_language_client)
|
|
return;
|
|
|
|
m_language_client->on_function_parameters_hint_result = [this](Vector<ByteString> const& params, size_t argument_index) {
|
|
dbgln("on_function_parameters_hint_result");
|
|
|
|
StringBuilder html;
|
|
for (size_t i = 0; i < params.size(); ++i) {
|
|
if (i == argument_index)
|
|
html.append("<b>"sv);
|
|
|
|
html.appendff("{}", params[i]);
|
|
|
|
if (i == argument_index)
|
|
html.append("</b>"sv);
|
|
|
|
if (i < params.size() - 1)
|
|
html.append(", "sv);
|
|
}
|
|
html.append("<style>body { background-color: #dac7b5; }</style>"sv);
|
|
|
|
s_tooltip_page_view->load_html(html.to_byte_string());
|
|
|
|
auto cursor_rect = current_editor().cursor_content_rect().location().translated(screen_relative_rect().location());
|
|
|
|
Gfx::Rect content(cursor_rect.x(), cursor_rect.y(), s_tooltip_page_view->children_clip_rect().width(), s_tooltip_page_view->children_clip_rect().height());
|
|
|
|
m_tooltip_role = TooltipRole::ParametersHint;
|
|
s_tooltip_window->set_rect(0, 0, 280, 35);
|
|
s_tooltip_window->move_to(cursor_rect.x(), cursor_rect.y() - s_tooltip_window->height() - vertical_scrollbar().value());
|
|
s_tooltip_window->show();
|
|
};
|
|
|
|
m_language_client->get_parameters_hint(
|
|
code_document().file_path(),
|
|
cursor().line(),
|
|
cursor().column());
|
|
}
|
|
|
|
void Editor::set_debug_mode(bool enabled)
|
|
{
|
|
m_move_execution_to_line_action->set_enabled(enabled);
|
|
}
|
|
|
|
void Editor::on_token_info_timer_tick()
|
|
{
|
|
if (!semantic_syntax_highlighting_is_enabled())
|
|
return;
|
|
if (!m_language_client || !m_language_client->is_active_client())
|
|
return;
|
|
|
|
m_language_client->get_tokens_info(code_document().file_path());
|
|
}
|
|
|
|
void Editor::on_tokens_info_result(Vector<CodeComprehension::TokenInfo> const& tokens_info)
|
|
{
|
|
auto highlighter = syntax_highlighter();
|
|
if (highlighter && highlighter->is_cpp_semantic_highlighter()) {
|
|
auto& semantic_cpp_highlighter = verify_cast<Cpp::SemanticSyntaxHighlighter>(*highlighter);
|
|
semantic_cpp_highlighter.update_tokens_info(tokens_info);
|
|
force_rehighlight();
|
|
}
|
|
}
|
|
|
|
void Editor::create_tokens_info_timer()
|
|
{
|
|
static constexpr size_t token_info_timer_interval_ms = 1000;
|
|
m_tokens_info_timer = Core::Timer::create_repeating((int)token_info_timer_interval_ms, [this] {
|
|
on_token_info_timer_tick();
|
|
m_tokens_info_timer->stop();
|
|
}).release_value_but_fixme_should_propagate_errors();
|
|
m_tokens_info_timer->start();
|
|
}
|
|
|
|
void Editor::set_semantic_syntax_highlighting(bool value)
|
|
{
|
|
m_use_semantic_syntax_highlighting = value;
|
|
set_syntax_highlighter_for(code_document());
|
|
}
|
|
|
|
ErrorOr<void> Editor::add_breakpoint(size_t line_number)
|
|
{
|
|
if (!breakpoint_lines().contains_slow(line_number)) {
|
|
if (Debugger::the().change_breakpoint(wrapper().filename_title(), line_number, BreakpointChange::Added)) {
|
|
add_gutter_indicator(m_breakpoint_indicator_id, line_number);
|
|
TRY(breakpoint_lines().try_append(line_number));
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
void Editor::remove_breakpoint(size_t line_number)
|
|
{
|
|
if (Debugger::the().change_breakpoint(wrapper().filename_title(), line_number, BreakpointChange::Removed)) {
|
|
remove_gutter_indicator(m_breakpoint_indicator_id, line_number);
|
|
breakpoint_lines().remove_first_matching([&](size_t line) { return line == line_number; });
|
|
}
|
|
}
|
|
|
|
ErrorOr<void> Editor::update_git_diff_indicators()
|
|
{
|
|
clear_gutter_indicators(m_git_diff_indicator_id);
|
|
|
|
if (!wrapper().git_repo())
|
|
return {};
|
|
|
|
Vector<CodeDocument::DiffType> line_differences;
|
|
TRY(line_differences.try_ensure_capacity(document().line_count()));
|
|
for (auto i = 0u; i < document().line_count(); ++i)
|
|
line_differences.unchecked_append(CodeDocument::DiffType::None);
|
|
|
|
for (auto const& hunk : wrapper().hunks()) {
|
|
auto start_line = hunk.location.new_range.start_line;
|
|
// Account for 1 indexed hunk location
|
|
if (start_line != 0)
|
|
start_line--;
|
|
auto finish_line = start_line + hunk.location.new_range.number_of_lines;
|
|
|
|
auto additions = hunk.location.new_range.number_of_lines;
|
|
auto deletions = hunk.location.old_range.number_of_lines;
|
|
|
|
for (size_t line_offset = 0; line_offset < additions; line_offset++) {
|
|
auto line = start_line + line_offset;
|
|
auto difference = (line_offset < deletions) ? CodeDocument::DiffType::ModifiedLine : CodeDocument::DiffType::AddedLine;
|
|
line_differences[line] = difference;
|
|
add_gutter_indicator(m_git_diff_indicator_id, line);
|
|
}
|
|
if (additions < deletions) {
|
|
auto deletions_line = min(finish_line, line_count() - 1);
|
|
line_differences[deletions_line] = CodeDocument::DiffType::DeletedLinesBefore;
|
|
add_gutter_indicator(m_git_diff_indicator_id, deletions_line);
|
|
}
|
|
}
|
|
code_document().set_line_differences({}, move(line_differences));
|
|
update();
|
|
|
|
return {};
|
|
}
|
|
|
|
}
|