cadran_list.hpp

Go to the documentation of this file.

// cadran::List — the Cadran look for the list screens (the tabs' lines under
// their tops, every other screen) without rewriting them: the original
// tab is built as usual (its XML, its i18n strings, its actions), then its
// lines are restyled after the boards' settings lists. A section header
// becomes a kicker (kit::TEXT_KICKER, capitals, text2); each run of cells a
// card (surf, 1 px border, kit::RADIUS_CARD, a line between rows); a cell
// gets an icon in a soft square before its title, a chevron when it opens
// something, a switch for a BooleanCell; the notes go to kit::TEXT_NOTE. tiles() turns a few cells into
// the boards' tiles instead (a row of cards; the icon on top, or before an action's title
// over two soft lights in its own ink).
//
// The tab keeps every view it binds (they move, they are not rebuilt), and
// its own show / hide logic: a card or a tile row with all its lines hidden
// draws nothing and takes no room. The restyle adds no words of its own.
// Copyright (C) 2026 JigSawFr.  GPLv3-or-later (see LICENSE.GPL).
#pragma once
 
#include <string>
#include <utility>
#include <vector>
#include <aurore.hpp>
#include <aurore/cadran/view/cadran_icon.hpp>
 
namespace cadran
{
std::string upper(const std::string& text);
 
class Card : public aurore::Box
{
  public:
    Card();
    void setAccent(const std::string& key);
    void setFill(const std::string& key);
    void follow_rows();
    void draw(NVGcontext* vg, float x, float y, float width, float height,
        aurore::Style style, aurore::FrameContext* ctx) override;
 
  private:
    std::string fill = "cadran/surf", border = "cadran/line";
};
 
class Switch : public aurore::View
{
  public:
    explicit Switch(aurore::BooleanCell* cell);
    void draw(NVGcontext* vg, float x, float y, float width, float height,
        aurore::Style style, aurore::FrameContext* ctx) override;
 
  private:
    aurore::BooleanCell* cell;
};
 
class List
{
  public:
    explicit List(aurore::View* tab, bool sub_screen = false);
    List(aurore::View* screen, aurore::Box* column);
 
    aurore::Box* content() const { return this->box; }
 
    aurore::Box* tiles(const std::vector<std::pair<const char*, const char*>>& cells, bool status);
 
    void state(const char* id, const char* color_key);
 
    void tag(const char* id, const std::string& text, bool warn, const std::string& note = "");
 
    aurore::Box* head(const char* id) const;
 
    Card* wrap(const char* id);
 
    void apply(const std::vector<std::pair<const char*, const char*>>& icons);
 
    Card* card_of(const char* id) const;
 
    void sync();
 
    static void section(aurore::Header* header);
    static void row(aurore::DetailCell* cell, const char* icon = nullptr, bool alone = false);
    static void row_image(aurore::DetailCell* cell, const std::string& image);
    static void row_swatch(aurore::DetailCell* cell, const CadranSwatch::Colors& colors);
    static void recolor_icon(aurore::DetailCell* cell, const char* icon, const char* color_key,
        const char* square_key = nullptr);
    static aurore::Box* rows_in(aurore::Box* list);
 
  private:
    aurore::View* tab;
    aurore::Box* box = nullptr;
    std::vector<aurore::Header*> headers;
    std::vector<aurore::DetailCell*> readings; 
    std::vector<std::pair<aurore::DetailCell*, aurore::Box*>> heads; 
    std::vector<std::pair<aurore::DetailCell*, aurore::View*>> marks; 
    std::vector<std::pair<aurore::DetailCell*, aurore::Box*>> tags; 
};
} // namespace cadran