Merge pull request #846 from cgudrian/tables

Changelog: New Features/Editor: Add support for simple tables in schematics and boards

Author: carrotIndustries

meson.build

@@ -197,6 +197,7 @@ src_common = files(
     'src/common/polygon.cpp',
     'src/common/shape.cpp',
     'src/common/text.cpp',
+    'src/common/table.cpp',
     'src/frame/frame.cpp',
     'src/logger/logger.cpp',
     'src/package/package_rules.cpp',
@@ -512,6 +513,7 @@ src_imp = files(
     'src/dialogs/edit_plane_window.cpp',
     'src/dialogs/edit_shape.cpp',
     'src/dialogs/edit_stackup.cpp',
+    'src/dialogs/edit_table_window.cpp',
     'src/dialogs/edit_text_window.cpp',
     'src/dialogs/edit_via.cpp',
     'src/dialogs/enter_datum_angle_window.cpp',

scripts/app_versions.yml

@@ -22,6 +22,7 @@ versions:
     20: add via definitions
     21: add user layers
     22: add height restrictions
+    23: add tables
   schematic:
     1: add custom values on symbols
     2: add hierarchy
@@ -32,6 +33,7 @@ versions:
     7: keep nets on unconnected labels
     8: add BOM export customisation
     9: add bus ripper label position
+    10: add tables
   package:
     1: package-defined solder mask & paste parameters override board parameters
     2: add heights

src/board/board.cpp

@@ -43,7 +43,7 @@ const LutEnumStr<Board::OutputFormat> Board::output_format_lut = {
         {"odb", Board::OutputFormat::ODB},
 };
 
-static const unsigned int app_version = 22;
+static const unsigned int app_version = 23;
 
 unsigned int Board::get_app_version()
 {
@@ -157,6 +157,13 @@ Board::Board(const UUID &uu, const json &j, Block &iblock, IPool &pool, const st
                 load_and_log(texts, ObjectType::TEXT, std::forward_as_tuple(u, it.value()), Logger::Domain::BOARD);
         }
     }
+    if (j.count("tables")) {
+        const json &o = j["tables"];
+        for (auto it = o.cbegin(); it != o.cend(); ++it) {
+            auto u = UUID(it.key());
+            load_and_log(tables, ObjectType::TABLE, std::forward_as_tuple(u, it.value()), Logger::Domain::BOARD);
+        }
+    }
     if (j.count("lines")) {
         const json &o = j["lines"];
         for (auto it = o.cbegin(); it != o.cend(); ++it) {
@@ -377,16 +384,16 @@ const std::map<int, Layer> &Board::get_layers() const
 
 Board::Board(const Board &brd, CopyMode copy_mode)
     : layers(brd.layers), uuid(brd.uuid), block(brd.block), name(brd.name), polygons(brd.polygons), holes(brd.holes),
-      junctions(brd.junctions), tracks(brd.tracks), texts(brd.texts), lines(brd.lines), arcs(brd.arcs),
-      planes(brd.planes), keepouts(brd.keepouts), dimensions(brd.dimensions), connection_lines(brd.connection_lines),
-      included_boards(brd.included_boards), board_panels(brd.board_panels), pictures(brd.pictures), decals(brd.decals),
-      net_ties(brd.net_ties), height_restrictions(brd.height_restrictions), warnings(brd.warnings),
-      output_format(brd.output_format), rules(brd.rules), gerber_output_settings(brd.gerber_output_settings),
-      odb_output_settings(brd.odb_output_settings), grid_settings(brd.grid_settings), airwires(brd.airwires),
-      stackup(brd.stackup), colors(brd.colors), pdf_export_settings(brd.pdf_export_settings),
-      step_export_settings(brd.step_export_settings), pnp_export_settings(brd.pnp_export_settings),
-      version(brd.version), board_directory(brd.board_directory), n_inner_layers(brd.n_inner_layers),
-      user_layers(brd.user_layers)
+      junctions(brd.junctions), tracks(brd.tracks), texts(brd.texts), tables(brd.tables), lines(brd.lines),
+      arcs(brd.arcs), planes(brd.planes), keepouts(brd.keepouts), dimensions(brd.dimensions),
+      connection_lines(brd.connection_lines), included_boards(brd.included_boards), board_panels(brd.board_panels),
+      pictures(brd.pictures), decals(brd.decals), net_ties(brd.net_ties), height_restrictions(brd.height_restrictions),
+      warnings(brd.warnings), output_format(brd.output_format), rules(brd.rules),
+      gerber_output_settings(brd.gerber_output_settings), odb_output_settings(brd.odb_output_settings),
+      grid_settings(brd.grid_settings), airwires(brd.airwires), stackup(brd.stackup), colors(brd.colors),
+      pdf_export_settings(brd.pdf_export_settings), step_export_settings(brd.step_export_settings),
+      pnp_export_settings(brd.pnp_export_settings), version(brd.version), board_directory(brd.board_directory),
+      n_inner_layers(brd.n_inner_layers), user_layers(brd.user_layers)
 {
     if (copy_mode == CopyMode::DEEP) {
         packages = brd.packages;
@@ -1310,6 +1317,10 @@ json Board::serialize() const
     for (const auto &it : texts) {
         j["texts"][(std::string)it.first] = it.second.serialize();
     }
+    j["tables"] = json::object();
+    for (const auto &it : tables) {
+        j["tables"][(std::string)it.first] = it.second.serialize();
+    }
     j["lines"] = json::object();
     for (const auto &it : lines) {
         j["lines"][(std::string)it.first] = it.second.serialize();

src/board/board.hpp

@@ -31,6 +31,7 @@
 #include "common/grid_settings.hpp"
 #include "board_net_tie.hpp"
 #include "height_restriction.hpp"
+#include "common/table.hpp"
 
 namespace horizon {
 using json = nlohmann::json;
@@ -104,6 +105,7 @@ class Board : public ObjectProvider, public LayerProvider {
     std::map<UUID, Track> tracks;
     std::map<UUID, Via> vias;
     std::map<UUID, Text> texts;
+    std::map<UUID, Table> tables;
     std::map<UUID, Line> lines;
     std::map<UUID, Arc> arcs;
     std::map<UUID, Plane> planes;

src/canvas/canvas.hpp

@@ -128,6 +128,7 @@ class Canvas {
     void render(const class PowerSymbol &sym);
     void render(const class BusRipper &ripper);
     void render(const class Text &text, bool interactive = true, ColorP co = ColorP::FROM_LAYER);
+    void render(const class Table &table, bool interactive = true, ColorP co = ColorP::FROM_LAYER);
     void render(const class Padstack &padstack, bool interactive = true);
     void render(const class Polygon &polygon, bool interactive = true, ColorP co = ColorP::FROM_LAYER);
     void render(const class Shape &shape, bool interactive = true);

src/canvas/grid.cpp

@@ -70,7 +70,7 @@ void Grid::render()
 
     Coordf sp = spacing;
     Coordf sp_px = sp * ca.scale;
-    unsigned int newmul = 1;
+    uint64_t newmul = 1;
     while (sp_px.x < 20 || sp_px.y < 20) {
         newmul *= 2;
         sp = spacing * newmul;

src/canvas/render.cpp

@@ -5,6 +5,7 @@
 #include "common/hole.hpp"
 #include "common/polygon.hpp"
 #include "common/text.hpp"
+#include "common/table.hpp"
 #include "layer_display.hpp"
 #include "package/pad.hpp"
 #include "poly2tri/poly2tri.h"
@@ -800,6 +801,84 @@ void Canvas::render(const Text &text, bool interactive, ColorP co)
     }
 }
 
+void Canvas::render(const Table &table, bool interactive, ColorP co)
+{
+    const bool rev = layer_provider.get_layers().at(table.layer).reverse;
+
+    transform_save();
+    transform.accumulate(table.placement);
+
+    object_ref_push(ObjectType::TABLE, table.uuid);
+
+    auto &layout = table.get_layout();
+
+    img_auto_line = img_mode;
+
+    uint64_t line_width = table.get_line_width();
+    float total_width = rev ? -layout.total_width : layout.total_width;
+    float total_height = -layout.total_height;
+
+    // draw outer border
+    {
+        draw_line({0, 0}, {total_width, 0}, co, table.layer, true, line_width);
+        draw_line({total_width, 0}, {total_width, total_height}, co, table.layer, true, line_width);
+        draw_line({total_width, total_height}, {0, total_height}, co, table.layer, true, line_width);
+        draw_line({0, total_height}, {0, 0}, co, table.layer, true, line_width);
+    }
+
+    // draw horizontal grid lines
+    {
+        float y = -layout.row_heights[0];
+        for (size_t r = 1; r < table.get_n_rows(); r++) {
+            draw_line({0, y}, {total_width, y}, co, table.layer, true, line_width);
+            y -= layout.row_heights[r];
+        }
+    }
+
+    // draw vertical grid lines
+    {
+        float x = rev ? -layout.col_widths[0] : layout.col_widths[0];
+        for (size_t c = 1; c < table.get_n_columns(); c++) {
+            draw_line({x, 0}, {x, total_height}, co, table.layer, true, line_width);
+            if (rev)
+                x -= layout.col_widths[c];
+            else
+                x += layout.col_widths[c];
+        }
+    }
+
+    img_auto_line = false;
+
+    // draw cell contents
+    {
+        TextRenderer::Options opts;
+        opts.width = line_width;
+        opts.font = table.get_font();
+        opts.allow_upside_down = true;
+        opts.flip = rev;
+
+        auto &cells = table.get_cells();
+        for (size_t idx = 0; idx < cells.size(); idx++) {
+            auto textpos = layout.text_positions[idx];
+            if (rev)
+                textpos.x *= -1;
+            auto pos = transform.transform(textpos);
+            auto size = static_cast<float>(table.get_text_size());
+            int angle = rev ? -transform.get_angle() : transform.get_angle();
+            draw_text(pos, size, cells[idx], angle, TextOrigin::BASELINE, co, table.layer, opts);
+        }
+    }
+
+    object_ref_pop();
+
+    if (interactive) {
+        selectables.append(table.uuid, ObjectType::TABLE, {0, 0}, {0, 0}, {total_width, total_height}, 0, table.layer);
+        targets.emplace_back(table.uuid, ObjectType::TABLE, transform.transform(Coordi(0, 0)), 0, table.layer);
+    }
+
+    transform_restore();
+}
+
 template <typename T> static std::string join(const T &v, const std::string &delim)
 {
     std::ostringstream s;
@@ -1214,6 +1293,9 @@ void Canvas::render(const Sheet &sheet)
         if (!it.second.from_smash)
             render(it.second);
     }
+    for (const auto &it : sheet.tables) {
+        render(it.second);
+    }
     for (const auto &it : sheet.net_labels) {
         render(it.second);
     }
@@ -1684,6 +1766,9 @@ void Canvas::render(const Board &brd, bool interactive, PanelMode mode, OutlineM
     for (const auto &it : brd.texts) {
         render(it.second, interactive);
     }
+    for (const auto &it : brd.tables) {
+        render(it.second, interactive);
+    }
     for (const auto &it : brd.tracks) {
         render(it.second, interactive);
     }

src/common/common.hpp

@@ -71,6 +71,7 @@ enum class ObjectType {
     SCHEMATIC_NET_TIE,
     BOARD_NET_TIE,
     HEIGHT_RESTRICTION,
+    TABLE,
 };
 enum class PatchType { OTHER, TRACK, PAD, PAD_TH, VIA, PLANE, HOLE_PTH, HOLE_NPTH, BOARD_EDGE, TEXT, NET_TIE, N_TYPES };
 

src/common/object_descr.cpp

@@ -406,5 +406,31 @@ const std::map<ObjectType, ObjectDescription> object_descriptions = {
                   {ObjectProperty::ID::HEIGHT, {ObjectProperty::Type::LENGTH, "Height", 0}},
 
           }}},
+        {ObjectType::TABLE,
+         {"Table",
+          "Tables",
+          {
+                  {ObjectProperty::ID::LAYER, {ObjectProperty::Type::LAYER, "Layer", 0}},
+                  {ObjectProperty::ID::POSITION_X, {ObjectProperty::Type::DIM, "Position X", 1}},
+                  {ObjectProperty::ID::POSITION_Y, {ObjectProperty::Type::DIM, "Position Y", 2}},
+                  {ObjectProperty::ID::ANGLE, {ObjectProperty::Type::ANGLE, "Angle", 3}},
+                  {ObjectProperty::ID::FONT,
+                   {ObjectProperty::Type::ENUM,
+                    "Font",
+                    9,
+                    {
+                            {static_cast<int>(TextData::Font::SIMPLEX), "Simplex"},
+                            {static_cast<int>(TextData::Font::DUPLEX), "Duplex"},
+                            {static_cast<int>(TextData::Font::TRIPLEX), "Triplex"},
+                            {static_cast<int>(TextData::Font::TRIPLEX_ITALIC), "Triplex Italic"},
+                            {static_cast<int>(TextData::Font::COMPLEX), "Complex"},
+                            {static_cast<int>(TextData::Font::COMPLEX_ITALIC), "Complex Italic"},
+                            {static_cast<int>(TextData::Font::SCRIPT_SIMPLEX), "Script Simplex"},
+                            {static_cast<int>(TextData::Font::SCRIPT_COMPLEX), "Script Complex"},
+                    }}},
+                  {ObjectProperty::ID::SIZE, {ObjectProperty::Type::LENGTH, "Text Size", 5}},
+                  {ObjectProperty::ID::WIDTH, {ObjectProperty::Type::LENGTH, "Line Width", 6}},
+                  {ObjectProperty::ID::PADDING, {ObjectProperty::Type::LENGTH, "Cell Padding", 7}},
+          }}},
 };
 } // namespace horizon

src/common/object_descr.hpp

@@ -89,6 +89,7 @@ class ObjectProperty {
         SPAN,
         VIA_DEFINITION,
         TEXT_POSITION,
+        PADDING,
     };
     ObjectProperty(Type t, const std::string &l, int o = 0, const std::vector<std::pair<int, std::string>> &its = {})
         : type(t), label(l), enum_items(its), order(o)