mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-09-21 02:08:12 +03:00
9b13a3905b
With this patch, you can now assign the same GTextDocument to multiple GTextEditor widgets via GTextEditor::set_document(). The editors have independent cursors and selection, but all changes are shared, and immediately propagate to all editors. This is very unoptimized and will do lots of unnecessary invalidation, especially line re-wrapping and repainting over and over again.
1458 lines
49 KiB
C++
1458 lines
49 KiB
C++
#include <AK/StringBuilder.h>
|
|
#include <Kernel/KeyCode.h>
|
|
#include <LibGUI/GAction.h>
|
|
#include <LibGUI/GClipboard.h>
|
|
#include <LibGUI/GFontDatabase.h>
|
|
#include <LibGUI/GMenu.h>
|
|
#include <LibGUI/GPainter.h>
|
|
#include <LibGUI/GScrollBar.h>
|
|
#include <LibGUI/GTextEditor.h>
|
|
#include <LibGUI/GWindow.h>
|
|
#include <ctype.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
//#define DEBUG_GTEXTEDITOR
|
|
|
|
GTextEditor::GTextEditor(Type type, GWidget* parent)
|
|
: GScrollableWidget(parent)
|
|
, m_type(type)
|
|
{
|
|
set_document(GTextDocument::create());
|
|
set_frame_shape(FrameShape::Container);
|
|
set_frame_shadow(FrameShadow::Sunken);
|
|
set_frame_thickness(2);
|
|
set_scrollbars_enabled(is_multi_line());
|
|
set_font(GFontDatabase::the().get_by_name("Csilla Thin"));
|
|
// FIXME: Recompute vertical scrollbar step size on font change.
|
|
vertical_scrollbar().set_step(line_height());
|
|
m_cursor = { 0, 0 };
|
|
create_actions();
|
|
}
|
|
|
|
GTextEditor::~GTextEditor()
|
|
{
|
|
if (m_document)
|
|
m_document->unregister_client(*this);
|
|
}
|
|
|
|
void GTextEditor::create_actions()
|
|
{
|
|
m_undo_action = GCommonActions::make_undo_action([&](auto&) {
|
|
// FIXME: Undo
|
|
});
|
|
m_redo_action = GCommonActions::make_redo_action([&](auto&) {
|
|
// FIXME: Undo
|
|
});
|
|
m_cut_action = GCommonActions::make_cut_action([&](auto&) { cut(); }, this);
|
|
m_copy_action = GCommonActions::make_copy_action([&](auto&) { copy(); }, this);
|
|
m_paste_action = GCommonActions::make_paste_action([&](auto&) { paste(); }, this);
|
|
m_delete_action = GCommonActions::make_delete_action([&](auto&) { do_delete(); }, this);
|
|
}
|
|
|
|
void GTextEditor::set_text(const StringView& text)
|
|
{
|
|
if (is_single_line() && text.length() == line(0).length() && !memcmp(text.characters_without_null_termination(), line(0).characters(), text.length()))
|
|
return;
|
|
|
|
m_selection.clear();
|
|
|
|
document().set_text(text);
|
|
|
|
update_content_size();
|
|
recompute_all_visual_lines();
|
|
if (is_single_line())
|
|
set_cursor(0, line(0).length());
|
|
else
|
|
set_cursor(0, 0);
|
|
did_update_selection();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::update_content_size()
|
|
{
|
|
int content_width = 0;
|
|
int content_height = 0;
|
|
for (auto& line : m_line_visual_data) {
|
|
content_width = max(line.visual_rect.width(), content_width);
|
|
content_height += line.visual_rect.height();
|
|
}
|
|
content_width += m_horizontal_content_padding * 2;
|
|
if (is_right_text_alignment(m_text_alignment))
|
|
content_width = max(frame_inner_rect().width(), content_width);
|
|
|
|
set_content_size({ content_width, content_height });
|
|
set_size_occupied_by_fixed_elements({ ruler_width(), 0 });
|
|
}
|
|
|
|
GTextPosition GTextEditor::text_position_at(const Point& a_position) const
|
|
{
|
|
auto position = a_position;
|
|
position.move_by(horizontal_scrollbar().value(), vertical_scrollbar().value());
|
|
position.move_by(-(m_horizontal_content_padding + ruler_width()), 0);
|
|
position.move_by(-frame_thickness(), -frame_thickness());
|
|
|
|
int line_index = -1;
|
|
|
|
if (is_line_wrapping_enabled()) {
|
|
for (int i = 0; i < lines().size(); ++i) {
|
|
auto& rect = m_line_visual_data[i].visual_rect;
|
|
if (position.y() >= rect.top() && position.y() <= rect.bottom()) {
|
|
line_index = i;
|
|
break;
|
|
}
|
|
if (position.y() > rect.bottom())
|
|
line_index = lines().size() - 1;
|
|
}
|
|
} else {
|
|
line_index = position.y() / line_height();
|
|
}
|
|
|
|
line_index = max(0, min(line_index, line_count() - 1));
|
|
|
|
int column_index;
|
|
switch (m_text_alignment) {
|
|
case TextAlignment::CenterLeft:
|
|
column_index = (position.x() + glyph_width() / 2) / glyph_width();
|
|
if (is_line_wrapping_enabled()) {
|
|
for_each_visual_line(line_index, [&](const Rect& rect, const StringView&, int start_of_line) {
|
|
if (rect.contains_vertically(position.y())) {
|
|
column_index += start_of_line;
|
|
return IterationDecision::Break;
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
break;
|
|
case TextAlignment::CenterRight:
|
|
// FIXME: Support right-aligned line wrapping, I guess.
|
|
ASSERT(!is_line_wrapping_enabled());
|
|
column_index = (position.x() - content_x_for_position({ line_index, 0 }) + glyph_width() / 2) / glyph_width();
|
|
break;
|
|
default:
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
|
|
column_index = max(0, min(column_index, lines()[line_index].length()));
|
|
return { line_index, column_index };
|
|
}
|
|
|
|
void GTextEditor::doubleclick_event(GMouseEvent& event)
|
|
{
|
|
if (event.button() != GMouseButton::Left)
|
|
return;
|
|
|
|
m_triple_click_timer.start();
|
|
m_in_drag_select = false;
|
|
|
|
auto start = text_position_at(event.position());
|
|
auto end = start;
|
|
auto& line = lines()[start.line()];
|
|
|
|
if (!document().has_spans()) {
|
|
while (start.column() > 0) {
|
|
if (isspace(line.characters()[start.column() - 1]))
|
|
break;
|
|
start.set_column(start.column() - 1);
|
|
}
|
|
|
|
while (end.column() < line.length()) {
|
|
if (isspace(line.characters()[end.column()]))
|
|
break;
|
|
end.set_column(end.column() + 1);
|
|
}
|
|
} else {
|
|
for (auto& span : document().spans()) {
|
|
if (!span.range.contains(start))
|
|
continue;
|
|
start = span.range.start();
|
|
end = span.range.end();
|
|
end.set_column(end.column() + 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_selection.set(start, end);
|
|
set_cursor(end);
|
|
update();
|
|
did_update_selection();
|
|
}
|
|
|
|
void GTextEditor::mousedown_event(GMouseEvent& event)
|
|
{
|
|
if (event.button() != GMouseButton::Left) {
|
|
return;
|
|
}
|
|
|
|
if (m_triple_click_timer.is_valid() && m_triple_click_timer.elapsed() < 250) {
|
|
m_triple_click_timer = CElapsedTimer();
|
|
|
|
GTextPosition start;
|
|
GTextPosition end;
|
|
|
|
if (is_multi_line()) {
|
|
// select *current* line
|
|
start = GTextPosition(m_cursor.line(), 0);
|
|
end = GTextPosition(m_cursor.line(), lines()[m_cursor.line()].length());
|
|
} else {
|
|
// select *whole* line
|
|
start = GTextPosition(0, 0);
|
|
end = GTextPosition(line_count() - 1, lines()[line_count() - 1].length());
|
|
}
|
|
|
|
m_selection.set(start, end);
|
|
set_cursor(end);
|
|
return;
|
|
}
|
|
|
|
if (event.modifiers() & Mod_Shift) {
|
|
if (!has_selection())
|
|
m_selection.set(m_cursor, {});
|
|
} else {
|
|
m_selection.clear();
|
|
}
|
|
|
|
m_in_drag_select = true;
|
|
|
|
set_cursor(text_position_at(event.position()));
|
|
|
|
if (!(event.modifiers() & Mod_Shift)) {
|
|
if (!has_selection())
|
|
m_selection.set(m_cursor, {});
|
|
}
|
|
|
|
if (m_selection.start().is_valid() && m_selection.start() != m_cursor)
|
|
m_selection.set_end(m_cursor);
|
|
|
|
// FIXME: Only update the relevant rects.
|
|
update();
|
|
did_update_selection();
|
|
}
|
|
|
|
void GTextEditor::mouseup_event(GMouseEvent& event)
|
|
{
|
|
if (event.button() == GMouseButton::Left) {
|
|
if (m_in_drag_select) {
|
|
m_in_drag_select = false;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void GTextEditor::mousemove_event(GMouseEvent& event)
|
|
{
|
|
if (m_in_drag_select) {
|
|
set_cursor(text_position_at(event.position()));
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
update();
|
|
return;
|
|
}
|
|
}
|
|
|
|
int GTextEditor::ruler_width() const
|
|
{
|
|
if (!m_ruler_visible)
|
|
return 0;
|
|
// FIXME: Resize based on needed space.
|
|
return 5 * font().glyph_width('x') + 4;
|
|
}
|
|
|
|
Rect GTextEditor::ruler_content_rect(int line_index) const
|
|
{
|
|
if (!m_ruler_visible)
|
|
return {};
|
|
return {
|
|
0 - ruler_width() + horizontal_scrollbar().value(),
|
|
line_content_rect(line_index).y(),
|
|
ruler_width(),
|
|
line_content_rect(line_index).height()
|
|
};
|
|
}
|
|
|
|
Rect GTextEditor::ruler_rect_in_inner_coordinates() const
|
|
{
|
|
return { 0, 0, ruler_width(), height() - height_occupied_by_horizontal_scrollbar() };
|
|
}
|
|
|
|
Rect GTextEditor::visible_text_rect_in_inner_coordinates() const
|
|
{
|
|
return {
|
|
m_horizontal_content_padding + (m_ruler_visible ? (ruler_rect_in_inner_coordinates().right() + 1) : 0),
|
|
0,
|
|
frame_inner_rect().width() - (m_horizontal_content_padding * 2) - width_occupied_by_vertical_scrollbar() - ruler_width(),
|
|
frame_inner_rect().height() - height_occupied_by_horizontal_scrollbar()
|
|
};
|
|
}
|
|
|
|
void GTextEditor::paint_event(GPaintEvent& event)
|
|
{
|
|
GFrame::paint_event(event);
|
|
|
|
GPainter painter(*this);
|
|
painter.add_clip_rect(widget_inner_rect());
|
|
painter.add_clip_rect(event.rect());
|
|
painter.fill_rect(event.rect(), Color::White);
|
|
|
|
painter.translate(frame_thickness(), frame_thickness());
|
|
|
|
auto ruler_rect = ruler_rect_in_inner_coordinates();
|
|
|
|
if (m_ruler_visible) {
|
|
painter.fill_rect(ruler_rect, Color::WarmGray);
|
|
painter.draw_line(ruler_rect.top_right(), ruler_rect.bottom_right(), Color::DarkGray);
|
|
}
|
|
|
|
painter.translate(-horizontal_scrollbar().value(), -vertical_scrollbar().value());
|
|
if (m_ruler_visible)
|
|
painter.translate(ruler_width(), 0);
|
|
|
|
int first_visible_line = text_position_at(event.rect().top_left()).line();
|
|
int last_visible_line = text_position_at(event.rect().bottom_right()).line();
|
|
|
|
auto selection = normalized_selection();
|
|
bool has_selection = selection.is_valid();
|
|
|
|
if (m_ruler_visible) {
|
|
for (int i = first_visible_line; i <= last_visible_line; ++i) {
|
|
bool is_current_line = i == m_cursor.line();
|
|
auto ruler_line_rect = ruler_content_rect(i);
|
|
painter.draw_text(
|
|
ruler_line_rect.shrunken(2, 0).translated(0, m_line_spacing / 2),
|
|
String::number(i + 1),
|
|
is_current_line ? Font::default_bold_font() : font(),
|
|
TextAlignment::TopRight,
|
|
is_current_line ? Color::DarkGray : Color::MidGray);
|
|
}
|
|
}
|
|
|
|
Rect text_clip_rect {
|
|
(m_ruler_visible ? (ruler_rect_in_inner_coordinates().right() + frame_thickness() + 1) : frame_thickness()),
|
|
frame_thickness(),
|
|
width() - width_occupied_by_vertical_scrollbar() - ruler_width(),
|
|
height() - height_occupied_by_horizontal_scrollbar()
|
|
};
|
|
painter.add_clip_rect(text_clip_rect);
|
|
|
|
for (int line_index = first_visible_line; line_index <= last_visible_line; ++line_index) {
|
|
auto& line = lines()[line_index];
|
|
|
|
bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line();
|
|
int first_visual_line_with_selection = -1;
|
|
int last_visual_line_with_selection = -1;
|
|
if (physical_line_has_selection) {
|
|
if (selection.start().line() < line_index)
|
|
first_visual_line_with_selection = 0;
|
|
else
|
|
first_visual_line_with_selection = visual_line_containing(line_index, selection.start().column());
|
|
|
|
if (selection.end().line() > line_index)
|
|
last_visual_line_with_selection = m_line_visual_data[line_index].visual_line_breaks.size();
|
|
else
|
|
last_visual_line_with_selection = visual_line_containing(line_index, selection.end().column());
|
|
}
|
|
|
|
int selection_start_column_within_line = selection.start().line() == line_index ? selection.start().column() : 0;
|
|
int selection_end_column_within_line = selection.end().line() == line_index ? selection.end().column() : line.length();
|
|
|
|
int visual_line_index = 0;
|
|
for_each_visual_line(line_index, [&](const Rect& visual_line_rect, const StringView& visual_line_text, int start_of_visual_line) {
|
|
if (is_multi_line() && line_index == m_cursor.line())
|
|
painter.fill_rect(visual_line_rect, Color(230, 230, 230));
|
|
#ifdef DEBUG_GTEXTEDITOR
|
|
painter.draw_rect(visual_line_rect, Color::Cyan);
|
|
#endif
|
|
if (!document().has_spans()) {
|
|
// Fast-path for plain text
|
|
painter.draw_text(visual_line_rect, visual_line_text, m_text_alignment, Color::Black);
|
|
} else {
|
|
int advance = font().glyph_width(' ') + font().glyph_spacing();
|
|
Rect character_rect = { visual_line_rect.location(), { font().glyph_width(' '), line_height() } };
|
|
for (int i = 0; i < visual_line_text.length(); ++i) {
|
|
const Font* font = &this->font();
|
|
Color color;
|
|
GTextPosition physical_position(line_index, start_of_visual_line + i);
|
|
// FIXME: This is *horribly* inefficient.
|
|
for (auto& span : document().spans()) {
|
|
if (!span.range.contains(physical_position))
|
|
continue;
|
|
color = span.color;
|
|
if (span.font)
|
|
font = span.font;
|
|
break;
|
|
}
|
|
painter.draw_text(character_rect, visual_line_text.substring_view(i, 1), *font, m_text_alignment, color);
|
|
character_rect.move_by(advance, 0);
|
|
}
|
|
}
|
|
bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line();
|
|
if (physical_line_has_selection) {
|
|
|
|
bool current_visual_line_has_selection = (line_index != selection.start().line() && line_index != selection.end().line())
|
|
|| (visual_line_index >= first_visual_line_with_selection && visual_line_index <= last_visual_line_with_selection);
|
|
if (current_visual_line_has_selection) {
|
|
bool selection_begins_on_current_visual_line = visual_line_index == first_visual_line_with_selection;
|
|
bool selection_ends_on_current_visual_line = visual_line_index == last_visual_line_with_selection;
|
|
|
|
int selection_left = selection_begins_on_current_visual_line
|
|
? content_x_for_position({ line_index, selection_start_column_within_line })
|
|
: m_horizontal_content_padding;
|
|
|
|
int selection_right = selection_ends_on_current_visual_line
|
|
? content_x_for_position({ line_index, selection_end_column_within_line })
|
|
: visual_line_rect.right() + 1;
|
|
|
|
Rect selection_rect {
|
|
selection_left,
|
|
visual_line_rect.y(),
|
|
selection_right - selection_left,
|
|
visual_line_rect.height()
|
|
};
|
|
|
|
painter.fill_rect(selection_rect, Color::from_rgb(0x955233));
|
|
|
|
int start_of_selection_within_visual_line = max(0, selection_start_column_within_line - start_of_visual_line);
|
|
int end_of_selection_within_visual_line = selection_end_column_within_line - start_of_visual_line;
|
|
|
|
StringView visual_selected_text {
|
|
visual_line_text.characters_without_null_termination() + start_of_selection_within_visual_line,
|
|
end_of_selection_within_visual_line - start_of_selection_within_visual_line
|
|
};
|
|
|
|
painter.draw_text(selection_rect, visual_selected_text, TextAlignment::CenterLeft, Color::White);
|
|
}
|
|
}
|
|
++visual_line_index;
|
|
return IterationDecision::Continue;
|
|
});
|
|
}
|
|
|
|
if (is_focused() && m_cursor_state)
|
|
painter.fill_rect(cursor_content_rect(), Color::Red);
|
|
}
|
|
|
|
void GTextEditor::toggle_selection_if_needed_for_event(const GKeyEvent& event)
|
|
{
|
|
if (event.shift() && !m_selection.is_valid()) {
|
|
m_selection.set(m_cursor, {});
|
|
did_update_selection();
|
|
update();
|
|
return;
|
|
}
|
|
if (!event.shift() && m_selection.is_valid()) {
|
|
m_selection.clear();
|
|
did_update_selection();
|
|
update();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void GTextEditor::select_all()
|
|
{
|
|
GTextPosition start_of_document { 0, 0 };
|
|
GTextPosition end_of_document { line_count() - 1, lines()[line_count() - 1].length() };
|
|
m_selection.set(start_of_document, end_of_document);
|
|
did_update_selection();
|
|
set_cursor(end_of_document);
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::keydown_event(GKeyEvent& event)
|
|
{
|
|
if (is_single_line() && event.key() == KeyCode::Key_Tab)
|
|
return GWidget::keydown_event(event);
|
|
|
|
if (is_single_line() && event.key() == KeyCode::Key_Return) {
|
|
if (on_return_pressed)
|
|
on_return_pressed();
|
|
return;
|
|
}
|
|
|
|
if (event.key() == KeyCode::Key_Escape) {
|
|
if (on_escape_pressed)
|
|
on_escape_pressed();
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_Up) {
|
|
if (m_cursor.line() > 0) {
|
|
int new_line = m_cursor.line() - 1;
|
|
int new_column = min(m_cursor.column(), lines()[new_line].length());
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_Down) {
|
|
if (m_cursor.line() < (lines().size() - 1)) {
|
|
int new_line = m_cursor.line() + 1;
|
|
int new_column = min(m_cursor.column(), lines()[new_line].length());
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_PageUp) {
|
|
if (m_cursor.line() > 0) {
|
|
int new_line = max(0, m_cursor.line() - visible_content_rect().height() / line_height());
|
|
int new_column = min(m_cursor.column(), lines()[new_line].length());
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_PageDown) {
|
|
if (m_cursor.line() < (lines().size() - 1)) {
|
|
int new_line = min(line_count() - 1, m_cursor.line() + visible_content_rect().height() / line_height());
|
|
int new_column = min(m_cursor.column(), lines()[new_line].length());
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_Left) {
|
|
if (m_cursor.column() > 0) {
|
|
int new_column = m_cursor.column() - 1;
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(m_cursor.line(), new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
} else if (m_cursor.line() > 0) {
|
|
int new_line = m_cursor.line() - 1;
|
|
int new_column = lines()[new_line].length();
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (event.key() == KeyCode::Key_Right) {
|
|
int new_line = m_cursor.line();
|
|
int new_column = m_cursor.column();
|
|
if (m_cursor.column() < current_line().length()) {
|
|
new_line = m_cursor.line();
|
|
new_column = m_cursor.column() + 1;
|
|
} else if (m_cursor.line() != line_count() - 1) {
|
|
new_line = m_cursor.line() + 1;
|
|
new_column = 0;
|
|
}
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(new_line, new_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
return;
|
|
}
|
|
if (!event.ctrl() && event.key() == KeyCode::Key_Home) {
|
|
int first_nonspace_column = current_line().first_non_whitespace_column();
|
|
toggle_selection_if_needed_for_event(event);
|
|
if (m_cursor.column() == first_nonspace_column)
|
|
set_cursor(m_cursor.line(), 0);
|
|
else
|
|
set_cursor(m_cursor.line(), first_nonspace_column);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
return;
|
|
}
|
|
if (!event.ctrl() && event.key() == KeyCode::Key_End) {
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(m_cursor.line(), current_line().length());
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
return;
|
|
}
|
|
if (event.ctrl() && event.key() == KeyCode::Key_Home) {
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(0, 0);
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
return;
|
|
}
|
|
if (event.ctrl() && event.key() == KeyCode::Key_End) {
|
|
toggle_selection_if_needed_for_event(event);
|
|
set_cursor(line_count() - 1, lines()[line_count() - 1].length());
|
|
if (event.shift() && m_selection.start().is_valid()) {
|
|
m_selection.set_end(m_cursor);
|
|
did_update_selection();
|
|
}
|
|
return;
|
|
}
|
|
if (event.modifiers() == Mod_Ctrl && event.key() == KeyCode::Key_A) {
|
|
select_all();
|
|
return;
|
|
}
|
|
|
|
if (event.key() == KeyCode::Key_Backspace) {
|
|
if (is_readonly())
|
|
return;
|
|
if (has_selection()) {
|
|
delete_selection();
|
|
did_update_selection();
|
|
return;
|
|
}
|
|
if (m_cursor.column() > 0) {
|
|
int erase_count = 1;
|
|
if (current_line().first_non_whitespace_column() >= m_cursor.column()) {
|
|
int new_column;
|
|
if (m_cursor.column() % m_soft_tab_width == 0)
|
|
new_column = m_cursor.column() - m_soft_tab_width;
|
|
else
|
|
new_column = (m_cursor.column() / m_soft_tab_width) * m_soft_tab_width;
|
|
erase_count = m_cursor.column() - new_column;
|
|
}
|
|
|
|
// Backspace within line
|
|
for (int i = 0; i < erase_count; ++i) {
|
|
current_line().remove(document(), m_cursor.column() - 1 - i);
|
|
}
|
|
update_content_size();
|
|
set_cursor(m_cursor.line(), m_cursor.column() - erase_count);
|
|
did_change();
|
|
return;
|
|
}
|
|
if (m_cursor.column() == 0 && m_cursor.line() != 0) {
|
|
// Backspace at column 0; merge with previous line
|
|
auto& previous_line = lines()[m_cursor.line() - 1];
|
|
int previous_length = previous_line.length();
|
|
previous_line.append(document(), current_line().characters(), current_line().length());
|
|
document().remove_line(m_cursor.line());
|
|
update_content_size();
|
|
update();
|
|
set_cursor(m_cursor.line() - 1, previous_length);
|
|
did_change();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (event.modifiers() == Mod_Shift && event.key() == KeyCode::Key_Delete) {
|
|
if (is_readonly())
|
|
return;
|
|
delete_current_line();
|
|
return;
|
|
}
|
|
|
|
if (event.key() == KeyCode::Key_Delete) {
|
|
if (is_readonly())
|
|
return;
|
|
do_delete();
|
|
return;
|
|
}
|
|
|
|
if (!is_readonly() && !event.ctrl() && !event.alt() && !event.text().is_empty())
|
|
insert_at_cursor_or_replace_selection(event.text());
|
|
}
|
|
|
|
void GTextEditor::delete_current_line()
|
|
{
|
|
if (has_selection())
|
|
return delete_selection();
|
|
|
|
document().remove_line(m_cursor.line());
|
|
if (lines().is_empty())
|
|
document().append_line(make<GTextDocumentLine>(document()));
|
|
|
|
update_content_size();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::do_delete()
|
|
{
|
|
if (is_readonly())
|
|
return;
|
|
|
|
if (has_selection())
|
|
return delete_selection();
|
|
|
|
if (m_cursor.column() < current_line().length()) {
|
|
// Delete within line
|
|
current_line().remove(document(), m_cursor.column());
|
|
did_change();
|
|
update_cursor();
|
|
return;
|
|
}
|
|
if (m_cursor.column() == current_line().length() && m_cursor.line() != line_count() - 1) {
|
|
// Delete at end of line; merge with next line
|
|
auto& next_line = lines()[m_cursor.line() + 1];
|
|
int previous_length = current_line().length();
|
|
current_line().append(document(), next_line.characters(), next_line.length());
|
|
document().remove_line(m_cursor.line() + 1);
|
|
update();
|
|
did_change();
|
|
set_cursor(m_cursor.line(), previous_length);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void GTextEditor::insert_at_cursor(const StringView& text)
|
|
{
|
|
// FIXME: This should obviously not be implemented this way.
|
|
for (int i = 0; i < text.length(); ++i) {
|
|
insert_at_cursor(text[i]);
|
|
}
|
|
}
|
|
|
|
void GTextEditor::insert_at_cursor(char ch)
|
|
{
|
|
bool at_head = m_cursor.column() == 0;
|
|
bool at_tail = m_cursor.column() == current_line().length();
|
|
if (ch == '\n') {
|
|
if (at_tail || at_head) {
|
|
String new_line_contents;
|
|
if (m_automatic_indentation_enabled && at_tail) {
|
|
int leading_spaces = 0;
|
|
auto& old_line = lines()[m_cursor.line()];
|
|
for (int i = 0; i < old_line.length(); ++i) {
|
|
if (old_line.characters()[i] == ' ')
|
|
++leading_spaces;
|
|
else
|
|
break;
|
|
}
|
|
if (leading_spaces)
|
|
new_line_contents = String::repeated(' ', leading_spaces);
|
|
}
|
|
document().insert_line(m_cursor.line() + (at_tail ? 1 : 0), make<GTextDocumentLine>(document(), new_line_contents));
|
|
update();
|
|
did_change();
|
|
set_cursor(m_cursor.line() + 1, lines()[m_cursor.line() + 1].length());
|
|
return;
|
|
}
|
|
auto new_line = make<GTextDocumentLine>(document());
|
|
new_line->append(document(), current_line().characters() + m_cursor.column(), current_line().length() - m_cursor.column());
|
|
current_line().truncate(document(), m_cursor.column());
|
|
document().insert_line(m_cursor.line() + 1, move(new_line));
|
|
update();
|
|
did_change();
|
|
set_cursor(m_cursor.line() + 1, 0);
|
|
return;
|
|
}
|
|
if (ch == '\t') {
|
|
int next_soft_tab_stop = ((m_cursor.column() + m_soft_tab_width) / m_soft_tab_width) * m_soft_tab_width;
|
|
int spaces_to_insert = next_soft_tab_stop - m_cursor.column();
|
|
for (int i = 0; i < spaces_to_insert; ++i) {
|
|
current_line().insert(document(), m_cursor.column(), ' ');
|
|
}
|
|
did_change();
|
|
set_cursor(m_cursor.line(), next_soft_tab_stop);
|
|
return;
|
|
}
|
|
current_line().insert(document(), m_cursor.column(), ch);
|
|
did_change();
|
|
set_cursor(m_cursor.line(), m_cursor.column() + 1);
|
|
}
|
|
|
|
int GTextEditor::content_x_for_position(const GTextPosition& position) const
|
|
{
|
|
auto& line = lines()[position.line()];
|
|
int x_offset = -1;
|
|
switch (m_text_alignment) {
|
|
case TextAlignment::CenterLeft:
|
|
for_each_visual_line(position.line(), [&](const Rect&, const StringView& view, int start_of_visual_line) {
|
|
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
|
|
x_offset = (position.column() - start_of_visual_line) * glyph_width();
|
|
return IterationDecision::Break;
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
return m_horizontal_content_padding + x_offset;
|
|
case TextAlignment::CenterRight:
|
|
// FIXME
|
|
ASSERT(!is_line_wrapping_enabled());
|
|
return content_width() - m_horizontal_content_padding - (line.length() * glyph_width()) + (position.column() * glyph_width());
|
|
default:
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
}
|
|
|
|
Rect GTextEditor::content_rect_for_position(const GTextPosition& position) const
|
|
{
|
|
if (!position.is_valid())
|
|
return {};
|
|
ASSERT(!lines().is_empty());
|
|
ASSERT(position.column() <= (current_line().length() + 1));
|
|
|
|
int x = content_x_for_position(position);
|
|
|
|
if (is_single_line()) {
|
|
Rect rect { x, 0, 1, font().glyph_height() + 2 };
|
|
rect.center_vertically_within({ {}, frame_inner_rect().size() });
|
|
return rect;
|
|
}
|
|
|
|
Rect rect;
|
|
for_each_visual_line(position.line(), [&](const Rect& visual_line_rect, const StringView& view, int start_of_visual_line) {
|
|
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
|
|
// NOTE: We have to subtract the horizontal padding here since it's part of the visual line rect
|
|
// *and* included in what we get from content_x_for_position().
|
|
rect = {
|
|
visual_line_rect.x() + x - (m_horizontal_content_padding),
|
|
visual_line_rect.y(),
|
|
1,
|
|
line_height()
|
|
};
|
|
return IterationDecision::Break;
|
|
}
|
|
return IterationDecision::Continue;
|
|
});
|
|
return rect;
|
|
}
|
|
|
|
Rect GTextEditor::cursor_content_rect() const
|
|
{
|
|
return content_rect_for_position(m_cursor);
|
|
}
|
|
|
|
Rect GTextEditor::line_widget_rect(int line_index) const
|
|
{
|
|
auto rect = line_content_rect(line_index);
|
|
rect.set_x(frame_thickness());
|
|
rect.set_width(frame_inner_rect().width());
|
|
rect.move_by(0, -(vertical_scrollbar().value()));
|
|
rect.move_by(0, frame_thickness());
|
|
rect.intersect(frame_inner_rect());
|
|
return rect;
|
|
}
|
|
|
|
void GTextEditor::scroll_position_into_view(const GTextPosition& position)
|
|
{
|
|
auto rect = content_rect_for_position(position);
|
|
if (position.column() == 0)
|
|
rect.set_x(content_x_for_position({ position.line(), 0 }) - 2);
|
|
else if (position.column() == lines()[position.line()].length())
|
|
rect.set_x(content_x_for_position({ position.line(), lines()[position.line()].length() }) + 2);
|
|
scroll_into_view(rect, true, true);
|
|
}
|
|
|
|
void GTextEditor::scroll_cursor_into_view()
|
|
{
|
|
scroll_position_into_view(m_cursor);
|
|
}
|
|
|
|
Rect GTextEditor::line_content_rect(int line_index) const
|
|
{
|
|
auto& line = lines()[line_index];
|
|
if (is_single_line()) {
|
|
Rect line_rect = { content_x_for_position({ line_index, 0 }), 0, line.length() * glyph_width(), font().glyph_height() + 2 };
|
|
line_rect.center_vertically_within({ {}, frame_inner_rect().size() });
|
|
return line_rect;
|
|
}
|
|
if (is_line_wrapping_enabled())
|
|
return m_line_visual_data[line_index].visual_rect;
|
|
return {
|
|
content_x_for_position({ line_index, 0 }),
|
|
line_index * line_height(),
|
|
line.length() * glyph_width(),
|
|
line_height()
|
|
};
|
|
}
|
|
|
|
void GTextEditor::update_cursor()
|
|
{
|
|
update(line_widget_rect(m_cursor.line()));
|
|
}
|
|
|
|
void GTextEditor::set_cursor(int line, int column)
|
|
{
|
|
set_cursor({ line, column });
|
|
}
|
|
|
|
void GTextEditor::set_cursor(const GTextPosition& a_position)
|
|
{
|
|
ASSERT(!lines().is_empty());
|
|
|
|
GTextPosition position = a_position;
|
|
|
|
if (position.line() >= lines().size())
|
|
position.set_line(lines().size() - 1);
|
|
|
|
if (position.column() > lines()[position.line()].length())
|
|
position.set_column(lines()[position.line()].length());
|
|
|
|
if (m_cursor != position) {
|
|
// NOTE: If the old cursor is no longer valid, repaint everything just in case.
|
|
auto old_cursor_line_rect = m_cursor.line() < lines().size()
|
|
? line_widget_rect(m_cursor.line())
|
|
: rect();
|
|
m_cursor = position;
|
|
m_cursor_state = true;
|
|
scroll_cursor_into_view();
|
|
update(old_cursor_line_rect);
|
|
update_cursor();
|
|
}
|
|
if (on_cursor_change)
|
|
on_cursor_change();
|
|
}
|
|
|
|
void GTextEditor::focusin_event(CEvent&)
|
|
{
|
|
update_cursor();
|
|
start_timer(500);
|
|
}
|
|
|
|
void GTextEditor::focusout_event(CEvent&)
|
|
{
|
|
stop_timer();
|
|
}
|
|
|
|
void GTextEditor::timer_event(CTimerEvent&)
|
|
{
|
|
m_cursor_state = !m_cursor_state;
|
|
if (is_focused())
|
|
update_cursor();
|
|
}
|
|
|
|
bool GTextEditor::write_to_file(const StringView& path)
|
|
{
|
|
int fd = open_with_path_length(path.characters_without_null_termination(), path.length(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
if (fd < 0) {
|
|
perror("open");
|
|
return false;
|
|
}
|
|
|
|
// Compute the final file size and ftruncate() to make writing fast.
|
|
// FIXME: Remove this once the kernel is smart enough to do this instead.
|
|
off_t file_size = 0;
|
|
for (int i = 0; i < lines().size(); ++i)
|
|
file_size += lines()[i].length();
|
|
file_size += lines().size() - 1;
|
|
|
|
int rc = ftruncate(fd, file_size);
|
|
if (rc < 0) {
|
|
perror("ftruncate");
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < lines().size(); ++i) {
|
|
auto& line = lines()[i];
|
|
if (line.length()) {
|
|
ssize_t nwritten = write(fd, line.characters(), line.length());
|
|
if (nwritten < 0) {
|
|
perror("write");
|
|
close(fd);
|
|
return false;
|
|
}
|
|
}
|
|
if (i != lines().size() - 1) {
|
|
char ch = '\n';
|
|
ssize_t nwritten = write(fd, &ch, 1);
|
|
if (nwritten != 1) {
|
|
perror("write");
|
|
close(fd);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
close(fd);
|
|
return true;
|
|
}
|
|
|
|
String GTextEditor::text() const
|
|
{
|
|
StringBuilder builder;
|
|
for (int i = 0; i < line_count(); ++i) {
|
|
auto& line = lines()[i];
|
|
builder.append(line.characters(), line.length());
|
|
if (i != line_count() - 1)
|
|
builder.append('\n');
|
|
}
|
|
return builder.to_string();
|
|
}
|
|
|
|
void GTextEditor::clear()
|
|
{
|
|
document().remove_all_lines();
|
|
document().append_line(make<GTextDocumentLine>(document()));
|
|
m_selection.clear();
|
|
did_update_selection();
|
|
set_cursor(0, 0);
|
|
update();
|
|
}
|
|
|
|
String GTextEditor::selected_text() const
|
|
{
|
|
if (!has_selection())
|
|
return {};
|
|
|
|
auto selection = normalized_selection();
|
|
StringBuilder builder;
|
|
for (int i = selection.start().line(); i <= selection.end().line(); ++i) {
|
|
auto& line = lines()[i];
|
|
int selection_start_column_on_line = selection.start().line() == i ? selection.start().column() : 0;
|
|
int selection_end_column_on_line = selection.end().line() == i ? selection.end().column() : line.length();
|
|
builder.append(line.characters() + selection_start_column_on_line, selection_end_column_on_line - selection_start_column_on_line);
|
|
if (i != selection.end().line())
|
|
builder.append('\n');
|
|
}
|
|
|
|
return builder.to_string();
|
|
}
|
|
|
|
void GTextEditor::delete_selection()
|
|
{
|
|
if (!has_selection())
|
|
return;
|
|
|
|
auto selection = normalized_selection();
|
|
|
|
// First delete all the lines in between the first and last one.
|
|
for (int i = selection.start().line() + 1; i < selection.end().line();) {
|
|
document().remove_line(i);
|
|
selection.end().set_line(selection.end().line() - 1);
|
|
}
|
|
|
|
if (selection.start().line() == selection.end().line()) {
|
|
// Delete within same line.
|
|
auto& line = lines()[selection.start().line()];
|
|
bool whole_line_is_selected = selection.start().column() == 0 && selection.end().column() == line.length();
|
|
if (whole_line_is_selected) {
|
|
line.clear(document());
|
|
} else {
|
|
auto before_selection = String(line.characters(), line.length()).substring(0, selection.start().column());
|
|
auto after_selection = String(line.characters(), line.length()).substring(selection.end().column(), line.length() - selection.end().column());
|
|
StringBuilder builder(before_selection.length() + after_selection.length());
|
|
builder.append(before_selection);
|
|
builder.append(after_selection);
|
|
line.set_text(document(), builder.to_string());
|
|
}
|
|
} else {
|
|
// Delete across a newline, merging lines.
|
|
ASSERT(selection.start().line() == selection.end().line() - 1);
|
|
auto& first_line = lines()[selection.start().line()];
|
|
auto& second_line = lines()[selection.end().line()];
|
|
auto before_selection = String(first_line.characters(), first_line.length()).substring(0, selection.start().column());
|
|
auto after_selection = String(second_line.characters(), second_line.length()).substring(selection.end().column(), second_line.length() - selection.end().column());
|
|
StringBuilder builder(before_selection.length() + after_selection.length());
|
|
builder.append(before_selection);
|
|
builder.append(after_selection);
|
|
first_line.set_text(document(), builder.to_string());
|
|
document().remove_line(selection.end().line());
|
|
}
|
|
|
|
if (lines().is_empty()) {
|
|
document().append_line(make<GTextDocumentLine>(document()));
|
|
}
|
|
|
|
m_selection.clear();
|
|
did_update_selection();
|
|
did_change();
|
|
set_cursor(selection.start());
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::insert_at_cursor_or_replace_selection(const StringView& text)
|
|
{
|
|
ASSERT(!is_readonly());
|
|
if (has_selection())
|
|
delete_selection();
|
|
insert_at_cursor(text);
|
|
}
|
|
|
|
void GTextEditor::cut()
|
|
{
|
|
if (is_readonly())
|
|
return;
|
|
auto selected_text = this->selected_text();
|
|
printf("Cut: \"%s\"\n", selected_text.characters());
|
|
GClipboard::the().set_data(selected_text);
|
|
delete_selection();
|
|
}
|
|
|
|
void GTextEditor::copy()
|
|
{
|
|
auto selected_text = this->selected_text();
|
|
printf("Copy: \"%s\"\n", selected_text.characters());
|
|
GClipboard::the().set_data(selected_text);
|
|
}
|
|
|
|
void GTextEditor::paste()
|
|
{
|
|
if (is_readonly())
|
|
return;
|
|
auto paste_text = GClipboard::the().data();
|
|
printf("Paste: \"%s\"\n", paste_text.characters());
|
|
insert_at_cursor_or_replace_selection(paste_text);
|
|
}
|
|
|
|
void GTextEditor::enter_event(CEvent&)
|
|
{
|
|
ASSERT(window());
|
|
window()->set_override_cursor(GStandardCursor::IBeam);
|
|
}
|
|
|
|
void GTextEditor::leave_event(CEvent&)
|
|
{
|
|
ASSERT(window());
|
|
window()->set_override_cursor(GStandardCursor::None);
|
|
}
|
|
|
|
void GTextEditor::did_change()
|
|
{
|
|
ASSERT(!is_readonly());
|
|
update_content_size();
|
|
recompute_all_visual_lines();
|
|
if (!m_have_pending_change_notification) {
|
|
m_have_pending_change_notification = true;
|
|
deferred_invoke([this](auto&) {
|
|
if (on_change)
|
|
on_change();
|
|
m_have_pending_change_notification = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
void GTextEditor::set_readonly(bool readonly)
|
|
{
|
|
if (m_readonly == readonly)
|
|
return;
|
|
m_readonly = readonly;
|
|
m_cut_action->set_enabled(!is_readonly() && has_selection());
|
|
m_delete_action->set_enabled(!is_readonly());
|
|
m_paste_action->set_enabled(!is_readonly());
|
|
}
|
|
|
|
void GTextEditor::did_update_selection()
|
|
{
|
|
m_cut_action->set_enabled(!is_readonly() && has_selection());
|
|
m_copy_action->set_enabled(has_selection());
|
|
if (on_selection_change)
|
|
on_selection_change();
|
|
if (is_line_wrapping_enabled()) {
|
|
// FIXME: Try to repaint less.
|
|
update();
|
|
}
|
|
}
|
|
|
|
void GTextEditor::context_menu_event(GContextMenuEvent& event)
|
|
{
|
|
if (!m_context_menu) {
|
|
m_context_menu = make<GMenu>();
|
|
m_context_menu->add_action(undo_action());
|
|
m_context_menu->add_action(redo_action());
|
|
m_context_menu->add_separator();
|
|
m_context_menu->add_action(cut_action());
|
|
m_context_menu->add_action(copy_action());
|
|
m_context_menu->add_action(paste_action());
|
|
m_context_menu->add_action(delete_action());
|
|
if (!m_custom_context_menu_actions.is_empty()) {
|
|
m_context_menu->add_separator();
|
|
for (auto& action : m_custom_context_menu_actions) {
|
|
m_context_menu->add_action(action);
|
|
}
|
|
}
|
|
}
|
|
m_context_menu->popup(event.screen_position());
|
|
}
|
|
|
|
void GTextEditor::set_text_alignment(TextAlignment alignment)
|
|
{
|
|
if (m_text_alignment == alignment)
|
|
return;
|
|
m_text_alignment = alignment;
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::resize_event(GResizeEvent& event)
|
|
{
|
|
GScrollableWidget::resize_event(event);
|
|
update_content_size();
|
|
recompute_all_visual_lines();
|
|
}
|
|
|
|
GTextPosition GTextEditor::next_position_after(const GTextPosition& position, ShouldWrapAtEndOfDocument should_wrap)
|
|
{
|
|
auto& line = lines()[position.line()];
|
|
if (position.column() == line.length()) {
|
|
if (position.line() == line_count() - 1) {
|
|
if (should_wrap == ShouldWrapAtEndOfDocument::Yes)
|
|
return { 0, 0 };
|
|
return {};
|
|
}
|
|
return { position.line() + 1, 0 };
|
|
}
|
|
return { position.line(), position.column() + 1 };
|
|
}
|
|
|
|
GTextPosition GTextEditor::prev_position_before(const GTextPosition& position, ShouldWrapAtStartOfDocument should_wrap)
|
|
{
|
|
if (position.column() == 0) {
|
|
if (position.line() == 0) {
|
|
if (should_wrap == ShouldWrapAtStartOfDocument::Yes) {
|
|
auto& last_line = lines()[line_count() - 1];
|
|
return { line_count() - 1, last_line.length() };
|
|
}
|
|
return {};
|
|
}
|
|
auto& prev_line = lines()[position.line() - 1];
|
|
return { position.line() - 1, prev_line.length() };
|
|
}
|
|
return { position.line(), position.column() - 1 };
|
|
}
|
|
|
|
GTextRange GTextEditor::find_next(const StringView& needle, const GTextPosition& start)
|
|
{
|
|
if (needle.is_empty())
|
|
return {};
|
|
|
|
GTextPosition position = start.is_valid() ? start : GTextPosition(0, 0);
|
|
GTextPosition original_position = position;
|
|
|
|
GTextPosition start_of_potential_match;
|
|
int needle_index = 0;
|
|
|
|
do {
|
|
auto ch = character_at(position);
|
|
if (ch == needle[needle_index]) {
|
|
if (needle_index == 0)
|
|
start_of_potential_match = position;
|
|
++needle_index;
|
|
if (needle_index >= needle.length())
|
|
return { start_of_potential_match, next_position_after(position) };
|
|
} else {
|
|
if (needle_index > 0)
|
|
position = start_of_potential_match;
|
|
needle_index = 0;
|
|
}
|
|
position = next_position_after(position);
|
|
} while (position.is_valid() && position != original_position);
|
|
|
|
return {};
|
|
}
|
|
|
|
GTextRange GTextEditor::find_prev(const StringView& needle, const GTextPosition& start)
|
|
{
|
|
if (needle.is_empty())
|
|
return {};
|
|
|
|
GTextPosition position = start.is_valid() ? start : GTextPosition(0, 0);
|
|
position = prev_position_before(position);
|
|
GTextPosition original_position = position;
|
|
|
|
GTextPosition end_of_potential_match;
|
|
int needle_index = needle.length() - 1;
|
|
|
|
do {
|
|
auto ch = character_at(position);
|
|
if (ch == needle[needle_index]) {
|
|
if (needle_index == needle.length() - 1)
|
|
end_of_potential_match = position;
|
|
--needle_index;
|
|
if (needle_index < 0)
|
|
return { position, next_position_after(end_of_potential_match) };
|
|
} else {
|
|
if (needle_index < needle.length() - 1)
|
|
position = end_of_potential_match;
|
|
needle_index = needle.length() - 1;
|
|
}
|
|
position = prev_position_before(position);
|
|
} while (position.is_valid() && position != original_position);
|
|
|
|
return {};
|
|
}
|
|
|
|
void GTextEditor::set_selection(const GTextRange& selection)
|
|
{
|
|
if (m_selection == selection)
|
|
return;
|
|
m_selection = selection;
|
|
set_cursor(m_selection.end());
|
|
scroll_position_into_view(normalized_selection().start());
|
|
update();
|
|
}
|
|
|
|
char GTextEditor::character_at(const GTextPosition& position) const
|
|
{
|
|
ASSERT(position.line() < line_count());
|
|
auto& line = lines()[position.line()];
|
|
if (position.column() == line.length())
|
|
return '\n';
|
|
return line.characters()[position.column()];
|
|
}
|
|
|
|
void GTextEditor::recompute_all_visual_lines()
|
|
{
|
|
int y_offset = 0;
|
|
for (int line_index = 0; line_index < line_count(); ++line_index) {
|
|
recompute_visual_lines(line_index);
|
|
m_line_visual_data[line_index].visual_rect.set_y(y_offset);
|
|
y_offset += m_line_visual_data[line_index].visual_rect.height();
|
|
}
|
|
|
|
update_content_size();
|
|
}
|
|
|
|
int GTextEditor::visual_line_containing(int line_index, int column) const
|
|
{
|
|
int visual_line_index = 0;
|
|
for_each_visual_line(line_index, [&](const Rect&, const StringView& view, int start_of_visual_line) {
|
|
if (column >= start_of_visual_line && ((column - start_of_visual_line) < view.length()))
|
|
return IterationDecision::Break;
|
|
++visual_line_index;
|
|
return IterationDecision::Continue;
|
|
});
|
|
return visual_line_index;
|
|
}
|
|
|
|
void GTextEditor::recompute_visual_lines(int line_index)
|
|
{
|
|
auto& line = document().line(line_index);
|
|
auto& visual_data = m_line_visual_data[line_index];
|
|
|
|
visual_data.visual_line_breaks.clear_with_capacity();
|
|
|
|
int available_width = visible_text_rect_in_inner_coordinates().width();
|
|
|
|
if (is_line_wrapping_enabled()) {
|
|
int line_width_so_far = 0;
|
|
|
|
for (int i = 0; i < line.length(); ++i) {
|
|
auto ch = line.characters()[i];
|
|
auto glyph_width = font().glyph_width(ch);
|
|
if ((line_width_so_far + glyph_width) > available_width) {
|
|
visual_data.visual_line_breaks.append(i);
|
|
line_width_so_far = glyph_width;
|
|
continue;
|
|
}
|
|
line_width_so_far += glyph_width;
|
|
}
|
|
}
|
|
|
|
visual_data.visual_line_breaks.append(line.length());
|
|
|
|
if (is_line_wrapping_enabled())
|
|
visual_data.visual_rect = { m_horizontal_content_padding, 0, available_width, visual_data.visual_line_breaks.size() * line_height() };
|
|
else
|
|
visual_data.visual_rect = { m_horizontal_content_padding, 0, font().width(line.view()), line_height() };
|
|
}
|
|
|
|
template<typename Callback>
|
|
void GTextEditor::for_each_visual_line(int line_index, Callback callback) const
|
|
{
|
|
auto editor_visible_text_rect = visible_text_rect_in_inner_coordinates();
|
|
int start_of_line = 0;
|
|
int visual_line_index = 0;
|
|
|
|
auto& line = document().line(line_index);
|
|
auto& visual_data = m_line_visual_data[line_index];
|
|
|
|
for (auto visual_line_break : visual_data.visual_line_breaks) {
|
|
auto visual_line_view = StringView(line.characters() + start_of_line, visual_line_break - start_of_line);
|
|
Rect visual_line_rect {
|
|
visual_data.visual_rect.x(),
|
|
visual_data.visual_rect.y() + (visual_line_index * line_height()),
|
|
font().width(visual_line_view),
|
|
line_height()
|
|
};
|
|
if (is_right_text_alignment(text_alignment()))
|
|
visual_line_rect.set_right_without_resize(editor_visible_text_rect.right());
|
|
if (!is_multi_line())
|
|
visual_line_rect.center_vertically_within(editor_visible_text_rect);
|
|
if (callback(visual_line_rect, visual_line_view, start_of_line) == IterationDecision::Break)
|
|
break;
|
|
start_of_line = visual_line_break;
|
|
++visual_line_index;
|
|
}
|
|
}
|
|
|
|
void GTextEditor::set_line_wrapping_enabled(bool enabled)
|
|
{
|
|
if (m_line_wrapping_enabled == enabled)
|
|
return;
|
|
|
|
m_line_wrapping_enabled = enabled;
|
|
horizontal_scrollbar().set_visible(!m_line_wrapping_enabled);
|
|
update_content_size();
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::add_custom_context_menu_action(GAction& action)
|
|
{
|
|
m_custom_context_menu_actions.append(action);
|
|
}
|
|
|
|
void GTextEditor::did_change_font()
|
|
{
|
|
vertical_scrollbar().set_step(line_height());
|
|
GWidget::did_change_font();
|
|
}
|
|
|
|
void GTextEditor::document_did_append_line()
|
|
{
|
|
m_line_visual_data.append(make<LineVisualData>());
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::document_did_remove_line(int line_index)
|
|
{
|
|
m_line_visual_data.remove(line_index);
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::document_did_remove_all_lines()
|
|
{
|
|
m_line_visual_data.clear();
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::document_did_insert_line(int line_index)
|
|
{
|
|
m_line_visual_data.insert(line_index, make<LineVisualData>());
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::document_did_change()
|
|
{
|
|
recompute_all_visual_lines();
|
|
update();
|
|
}
|
|
|
|
void GTextEditor::set_document(GTextDocument& document)
|
|
{
|
|
if (m_document.ptr() == &document)
|
|
return;
|
|
if (m_document)
|
|
m_document->unregister_client(*this);
|
|
m_document = document;
|
|
m_line_visual_data.clear();
|
|
for (int i = 0; i < m_document->line_count(); ++i) {
|
|
m_line_visual_data.append(make<LineVisualData>());
|
|
}
|
|
m_cursor = { 0, 0 };
|
|
recompute_all_visual_lines();
|
|
update();
|
|
m_document->register_client(*this);
|
|
}
|