giga

Terminal text editor
git clone git://git.dimitrijedobrota.com/giga.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit05c2e1a48294b7c9b53b9829dafd1127299abad8
parent0dc45513c84776586408c8170e18c29defe65036
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateSun, 2 Mar 2025 11:39:58 +0100

Decouple editor from line number, add status line

Diffstat:
MCMakeLists.txt|+-
Msource/main.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------------------

2 files changed, 192 insertions(+), 66 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake)

project(
giga
VERSION 0.1.5
VERSION 0.1.6
DESCRIPTION "Terminal text editor"
HOMEPAGE_URL "https://git.dimitrijedobrota.com/giga.git"
LANGUAGES CXX

diff --git a/source/main.cpp b/source/main.cpp

@@ -43,56 +43,139 @@ private:

std::vector<std::string> m_lines;
};
class Editor : public display::Window
class PanelWindow : public display::Window
{
public:
Editor(display::plc_t aplc, File file)
: Window(aplc, {1, 1})
, m_file(std::move(file))
struct state_t
{
File file;
display::pos_t line;
display::pos_t cursor;
};
PanelWindow(display::plc_t aplc, display::pad_t pad, state_t& state)
: Window(aplc, pad)
, m_state(state)
{
}
protected:
const auto& file() const { return m_state.file; }
auto& file() { return m_state.file; }
const auto& cursor() const { return m_state.cursor; }
auto& cursor() { return m_state.cursor; }
const auto& line() const { return m_state.line; }
auto& line() { return m_state.line; }
void cursor_clamp_width(display::xpos_t& xpos) const
{
using display::clamp_high, display::xpos_t;
const auto& sel = file()[(line().y + cursor().y).value()];
const auto size = sub_lim(xpos_t(sel.size()), line().x, xpos_t(0));
if (size == 0) {
xpos = xpos_t(0);
} else {
xpos = clamp_high(xpos, size - 1);
}
}
private:
state_t& m_state; // NOLINT
};
class LineNum : public PanelWindow
{
public:
explicit LineNum(display::plc_t aplc, PanelWindow::state_t& state)
: PanelWindow(aplc, display::pad_t(0, 0, 1, 0), state)
{
}
void render() const override
{
line_reset();
std::size_t pos = line().y.value();
for (std::size_t i = 0; i < hgt(); i++, pos++) {
if (pos < file().size()) {
line_right(std::to_string(pos));
} else {
line_right("~");
}
}
}
};
class LineInfo : public PanelWindow
{
public:
explicit LineInfo(display::plc_t aplc, PanelWindow::state_t& state)
: PanelWindow(aplc, display::pad_t(0, 0), state)
{
}
void render() const override
{
auto crs = cursor();
cursor_clamp_width(crs.x);
line_reset();
line_right(std::to_string(crs.x.value()) + ","
+ std::to_string((line().y + crs.y).value()));
}
private:
};
const auto linenum_width = get_linenum_width();
const std::size_t available_width = wth().value() - linenum_width - 1;
class Editor : public PanelWindow
{
public:
Editor(display::plc_t aplc, PanelWindow::state_t& state)
: PanelWindow(aplc, {0, 0}, state)
{
}
auto cursor = m_cursor;
auto line = m_line;
void render() const override
{
line_reset();
cursor_clamp_width(cursor.x);
auto crs = cursor();
auto lin = line();
cursor_clamp_width(crs.x);
const auto hwidth = (wth() / 2).value();
const auto overshoot = crs.x / hwidth;
const auto overshoot = cursor.x / (available_width / 2);
if (overshoot > 1) {
line.x += (overshoot - 1) * (available_width / 2);
cursor.x -= (overshoot - 1) * (available_width / 2);
lin.x += (overshoot - 1) * hwidth;
crs.x -= (overshoot - 1) * hwidth;
}
for (std::size_t i = 0; i < hgt(); i++, line.y++) {
if (line.y >= m_file.size()) {
for (std::size_t i = 0; i < hgt(); i++, lin.y++) {
if (lin.y >= file().size()) {
break;
}
if (i == cursor.y) {
if (i == crs.y) {
std::cout << alec::background_v<alec::Color::BLACK>;
}
line_left(
get_linenum(line.y.value(), linenum_width) + " "
+ m_file.substr(line.y.value(), line.x.value(), available_width));
line_left(file().substr(lin.y.value(), lin.x.value(), wth().value()));
if (i == cursor.y) {
if (i == crs.y) {
std::cout << alec::background_v<alec::Color::DEFAULT>;
}
}
Window::render();
Window::render_border();
std::cout << alec::cursor_show_v;
set_cursor(cursor + display::pos_t(linenum_width + 2, 1));
set_cursor(crs);
std::cout << std::flush;
}

@@ -100,103 +183,146 @@ public:

{
using display::event;
auto& crs = cursor();
auto& lin = line();
if (evnt.type() != event::Type::KEY) {
return;
}
if (evnt.key() == 'j') {
if (m_cursor.y + 1 < hgt().value()) {
m_cursor.y++;
} else if (m_line.y + hgt() < m_file.size()) {
m_line.y++;
if (crs.y + 1 < hgt().value()) {
crs.y++;
} else if (lin.y + hgt() < file().size()) {
lin.y++;
}
evnt.type() = event::Type::NONE;
render();
return;
}
if (evnt.key() == 'k') {
if (m_cursor.y > 0) {
m_cursor.y--;
} else if (m_line.y > 0) {
m_line.y--;
if (crs.y > 0) {
crs.y--;
} else if (lin.y > 0) {
lin.y--;
}
evnt.type() = event::Type::NONE;
render();
return;
}
if (evnt.key() == 'l') {
using display::xpos_t;
cursor_clamp_width(m_cursor.x);
cursor_clamp_width(crs.x);
const auto& line = m_file[(m_line.y + m_cursor.y).value()];
const auto size = sub_lim(xpos_t(line.size()), m_line.x, xpos_t(0));
const auto& sel = file()[(lin.y + crs.y).value()];
const auto size = sub_lim(xpos_t(sel.size()), lin.x, xpos_t(0));
if (m_cursor.x.value() + 1 < size) {
m_cursor.x++;
if (crs.x.value() + 1 < size) {
crs.x++;
}
evnt.type() = event::Type::NONE;
render();
return;
}
if (evnt.key() == 'h') {
using display::xpos_t;
cursor_clamp_width(m_cursor.x);
cursor_clamp_width(crs.x);
if (m_cursor.x > 0) {
m_cursor.x--;
if (crs.x > 0) {
crs.x--;
}
evnt.type() = event::Type::NONE;
render();
return;
}
}
};
private:
static std::string get_linenum(std::size_t line, std::uint8_t width)
class Panel : public display::Element
{
public:
explicit Panel(display::plc_t aplc, File file)
: Element(aplc)
, m_state(std::move(file), {0, 0}, {0, 0})
, m_num(place_num(), m_state)
, m_info(place_info(), m_state)
, m_editor(place_editor(), m_state)
{
const auto line_str = std::to_string(line);
return std::string(width - line_str.size(), ' ') + line_str;
}
std::uint8_t get_linenum_width() const
void resize(display::plc_t aplc) override
{
auto number = m_file.size();
std::uint8_t digits = 0;
Element::resize(aplc);
do {
digits++;
} while ((number /= 10) > 0);
return digits;
m_num.resize(place_num());
m_info.resize(place_info());
m_editor.resize(place_editor());
}
void cursor_clamp_width(display::xpos_t& xpos) const
void render() const override
{
using display::clamp_high, display::xpos_t;
m_num.render();
m_info.render();
m_editor.render();
}
const auto& line = m_file[(m_line.y + m_cursor.y).value()];
const auto size = sub_lim(xpos_t(line.size()), m_line.x, xpos_t(0));
void input(display::event& evnt) override
{
m_editor.input(evnt);
if (size == 0) {
xpos = xpos_t(0);
} else {
xpos = clamp_high(xpos, size - 1);
if (evnt.type() == display::event::Type::NONE) {
render();
}
}
File m_file;
void clear() const override
{
m_num.clear();
m_editor.clear();
m_info.clear();
}
private:
display::plc_t place_num() const
{
return {display::pos_t(0, 0),
display::dim_t(get_linenuwidth(), (ahgt() - 1).value())};
}
display::plc_t place_info() const
{
return {display::pos_t(0U, (ahgt() - 1).value()),
display::dim_t(awth(), display::hgt_t(1))};
}
display::plc_t place_editor() const
{
return {display::pos_t(get_linenuwidth(), 0U),
display::dim_t(awth() - get_linenuwidth(), ahgt() - 1)};
}
std::uint16_t get_linenuwidth() const
{
auto number = m_state.file.size();
std::uint16_t digits = 1;
do {
digits++;
} while ((number /= 10) > 0);
return digits;
}
PanelWindow::state_t m_state;
display::pos_t m_line = {0, 0};
display::pos_t m_cursor = {0, 0};
LineNum m_num;
LineInfo m_info;
Editor m_editor;
};
int main(const int argc, const char* argv[])

@@ -209,7 +335,7 @@ int main(const int argc, const char* argv[])

}
auto& inst = display::Display::display();
inst.layout().set_child<Editor>(File(args[1]));
inst.layout().set_child<Panel>(File(args[1]));
inst.render();
while (true) {