giga

Terminal text editor
git clone git://git.dimitrijedobrota.com/giga.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commitf2306d0260bb7fa599d03898e94f879e8d9e7a7d
parent05c2e1a48294b7c9b53b9829dafd1127299abad8
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateMon, 3 Mar 2025 18:47:45 +0100

Dynamic Layout with splitting and navigation

Diffstat:
MCMakeLists.txt|++++---
Asource/layout_dynamic.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Asource/layout_dynamic.hpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Dsource/lib.cpp|
Msource/main.cpp|++++-

5 files changed, 364 insertions(+), 4 deletions(-)

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

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

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

@@ -20,7 +20,7 @@ find_package(alec 0.1.13 CONFIG REQUIRED)

add_library(
giga_lib OBJECT
source/lib.cpp
source/layout_dynamic.cpp
)
target_include_directories(

@@ -30,6 +30,7 @@ target_include_directories(

)
target_compile_features(giga_lib PUBLIC cxx_std_20)
target_link_libraries(giga_lib PUBLIC display::display)
# ---- Declare executable ----

@@ -40,7 +41,7 @@ set_property(TARGET giga_exe PROPERTY OUTPUT_NAME giga)

target_compile_features(giga_exe PRIVATE cxx_std_20)
target_link_libraries(giga_exe PRIVATE giga_lib display::display)
target_link_libraries(giga_exe PRIVATE giga_lib)
# ---- Install rules ----

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

@@ -0,0 +1,234 @@

#include <stdexcept>
#include "layout_dynamic.hpp"
namespace display
{
void LayoutDynamic::input(event& evnt)
{
if (evnt.type() == event::Type::KEY) {
if (evnt.key() == 'e') {
m_sel = m_sel->split_horizontal();
m_sel->set_child();
render();
evnt.type() = event::Type::NONE;
return;
}
if (evnt.key() == 'r') {
m_sel = m_sel->split_vertical();
m_sel->set_child();
render();
evnt.type() = event::Type::NONE;
return;
}
if (evnt.key() == 'w') {
m_sel = m_sel->up();
render();
evnt.type() = event::Type::NONE;
return;
}
if (evnt.key() == 'a') {
m_sel = m_sel->left();
render();
evnt.type() = event::Type::NONE;
return;
}
if (evnt.key() == 's') {
m_sel = m_sel->down();
render();
evnt.type() = event::Type::NONE;
return;
}
if (evnt.key() == 'd') {
m_sel = m_sel->right();
render();
evnt.type() = event::Type::NONE;
return;
}
}
m_sel->input(evnt);
}
void LayoutDynamic::Panel::render() const // NOLINT
{
if (m_type == Type::Single) {
Layout::render();
return;
}
for (const auto& panel : m_splits) {
panel->render();
}
}
void LayoutDynamic::Panel::resize(plc_t aplc) // NOLINT
{
Layout::resize(aplc);
switch (m_type) {
case Type::Single:
// Already done
break;
case Type::Horizontal: {
resize_begining_horizontal();
m_splits.back()->resize(place_last_horizontal(m_splits.size()));
break;
}
case Type::Vertical: {
resize_begining_vertical();
m_splits.back()->resize(place_last_vertical(m_splits.size()));
break;
}
}
}
LayoutDynamic::Panel* LayoutDynamic::Panel::split_horizontal() // NOLINT
{
if (m_parent != nullptr && m_parent->m_type == Type::Horizontal) {
return m_parent->split_horizontal();
}
if (m_type == Type::Vertical) {
throw std::runtime_error("Can't to horizontal split");
}
if (m_type == Type::Single) {
m_type = Type::Horizontal;
const auto plc = plc_t(apos(), {awth() / 2, ahgt()});
m_splits.emplace_back(std::make_unique<Panel>(this, plc, release_child()));
}
m_splits.emplace_back(std::make_unique<Panel>(
this, place_last_horizontal(m_splits.size() + 1)));
resize_begining_horizontal();
m_sel = m_splits.size() - 1;
return m_splits.back().get();
}
LayoutDynamic::Panel* LayoutDynamic::Panel::split_vertical() // NOLINT
{
if (m_parent != nullptr && m_parent->m_type == Type::Vertical) {
return m_parent->split_vertical();
}
if (m_type == Type::Horizontal) {
throw std::runtime_error("Can't to vertical split");
}
if (m_type == Type::Single) {
m_type = Type::Vertical;
const auto plc = plc_t(apos(), {awth(), ahgt() / 2});
m_splits.emplace_back(std::make_unique<Panel>(this, plc, release_child()));
}
m_splits.emplace_back(
std::make_unique<Panel>(this, place_last_vertical(m_splits.size() + 1)));
resize_begining_vertical();
m_sel = m_splits.size() - 1;
return m_splits.back().get();
}
plc_t LayoutDynamic::Panel::place_last_horizontal(std::size_t size) const
{
const auto unit = (awth() / size) * (size - 1);
const auto xpos = axpos() + unit;
const auto wth = awth() - unit;
return {{xpos, aypos()}, {wth, ahgt()}};
}
void LayoutDynamic::Panel::resize_begining_horizontal() // NOLINT
{
const auto unit = awth() / m_splits.size();
const auto dim = dim_t(unit, ahgt());
auto pos = apos();
for (std::size_t i = 0; i + 1 < m_splits.size(); i++) {
m_splits[i]->resize({pos, dim});
pos.x += unit.value();
}
}
plc_t LayoutDynamic::Panel::place_last_vertical(std::size_t size) const
{
const auto unit = (ahgt() / size) * (size - 1);
const auto ypos = aypos() + unit;
const auto hgt = ahgt() - unit;
return {{axpos(), ypos}, {awth(), hgt}};
}
void LayoutDynamic::Panel::resize_begining_vertical() // NOLINT
{
const auto unit = ahgt() / m_splits.size();
const auto dim = dim_t(awth(), unit);
auto pos = apos();
for (std::size_t i = 0; i + 1 < m_splits.size(); i++) {
m_splits[i]->resize({pos, dim});
pos.y += unit.value();
}
}
LayoutDynamic::Panel* LayoutDynamic::Panel::updown(Action action) // NOLINT
{
if (action != Action::Prop) {
if (m_type == Type::Vertical) {
if (action == Action::Inc && m_sel + 1 < m_splits.size()) {
return m_splits[++m_sel]->updown(Action::Prop);
}
if (action == Action::Dec && m_sel > 0) {
return m_splits[--m_sel]->updown(Action::Prop);
}
}
if (m_parent != nullptr) {
return m_parent->updown(action);
}
}
if (m_type == Type::Single) {
return this;
}
return m_splits[m_sel]->updown(Action::Prop);
}
LayoutDynamic::Panel* LayoutDynamic::Panel::leftright(Action action) // NOLINT
{
if (action != Action::Prop) {
if (m_type == Type::Horizontal) {
if (action == Action::Inc && m_sel + 1 < m_splits.size()) {
return m_splits[++m_sel]->leftright(Action::Prop);
}
if (action == Action::Dec && m_sel > 0) {
return m_splits[--m_sel]->leftright(Action::Prop);
}
}
if (m_parent != nullptr) {
return m_parent->leftright(action);
}
}
if (m_type == Type::Single) {
return this;
}
return m_splits[m_sel]->leftright(Action::Prop);
}
} // namespace display

diff --git a/source/layout_dynamic.hpp b/source/layout_dynamic.hpp

@@ -0,0 +1,122 @@

#pragma once
#include <memory>
#include <vector>
#include "display/element.hpp"
#include "display/layout.hpp"
#include "display/window.hpp"
namespace display
{
class WindowTest : public Window
{
public:
explicit WindowTest(plc_t aplc)
: Window(aplc, {1, 1})
{
}
void render() const override { Window::render_border(); }
};
class LayoutDynamic : public Element
{
public:
explicit LayoutDynamic(plc_t aplc)
: Element(aplc)
, m_layout(aplc)
{
}
void render() const override
{
Element::clear();
m_layout.render();
std::cout << alec::foreground_v<alec::Color::RED>;
m_sel->render_border();
std::cout << alec::foreground_v<alec::Color::DEFAULT>;
std::cout << std::flush;
}
void resize(plc_t aplc) override
{
Element::resize(aplc);
m_layout.resize(aplc);
}
void input(event& evnt) override;
private:
class Panel : public Layout<WindowTest>
{
public:
explicit Panel(plc_t aplc)
: Layout(aplc)
, m_parent(nullptr)
{
set_child();
}
explicit Panel(Panel* parent, plc_t aplc)
: Layout(aplc)
, m_parent(parent)
{
}
Panel(Panel* parent, plc_t aplc, Layout<WindowTest>::ptr_t&& payload)
: Layout(aplc, std::move(payload))
, m_parent(parent)
{
}
void render() const override;
void resize(plc_t aplc) override;
Panel* split_horizontal();
Panel* split_vertical();
Panel* up() { return updown(Action::Dec); }
Panel* left() { return leftright(Action::Dec); }
Panel* down() { return updown(Action::Inc); }
Panel* right() { return leftright(Action::Inc); }
private:
using panel_ptr = std::unique_ptr<Panel>;
enum class Type : std::uint8_t
{
Single,
Horizontal,
Vertical,
};
enum Action : std::uint8_t
{
Inc,
Dec,
Prop,
};
plc_t place_last_horizontal(std::size_t size) const;
plc_t place_last_vertical(std::size_t size) const;
void resize_begining_horizontal();
void resize_begining_vertical();
Panel* leftright(Action action);
Panel* updown(Action action);
Panel* m_parent;
Type m_type = Type::Single;
std::size_t m_sel = 0;
std::vector<panel_ptr> m_splits;
};
Panel m_layout;
Panel* m_sel = &m_layout;
};
} // namespace display

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

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

@@ -8,6 +8,8 @@

#include <display/utility.hpp>
#include <display/window.hpp>
#include "layout_dynamic.hpp"
class File
{
public:

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

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