Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++
19.2 KB
Raw Blame
#include "Presentation/Views/ERDiagram/ERDiagramView.h"
#include "Presentation/Views/ERDiagram/ERDiagramExporter.h"

#include <cmath>

#include <QAction>
#include <QFileDialog>
#include <QFont>
#include <QGraphicsEllipseItem>
#include <QGraphicsLineItem>
#include <QGraphicsPathItem>
#include <QGraphicsRectItem>
#include <QGraphicsScene>
#include <QGraphicsTextItem>
#include <QImage>
#include <QMenu>
#include <QMessageBox>
#include <QPainter>
#include <QPainterPath>
#include <QPushButton>
#include <QResizeEvent>
#include <QStandardPaths>
#include <QStyleOptionGraphicsItem>
#include <QVBoxLayout>
#include <QWheelEvent>

#include "Core/Errors/GridexError.h"
#include "Core/Models/Schema/SchemaSnapshot.h"
#include "Core/Protocols/Database/IDatabaseAdapter.h"

namespace gridex {

namespace {

// Card geometry constants (matches macOS ERDiagramCanvas proportions)
constexpr qreal kCardWidth      = 220.0;
constexpr qreal kHeaderHeight   = 32.0;
constexpr qreal kRowHeight      = 22.0;
constexpr qreal kCornerRadius   = 8.0;
constexpr qreal kGridCols       = 4.0;    // columns in grid layout
constexpr qreal kHGap           = 80.0;
constexpr qreal kVGap           = 60.0;
constexpr qreal kPadding        = 60.0;

inline qreal cardHeight(int columnCount) {
    return kHeaderHeight + columnCount * kRowHeight + 4.0;
}

// Abbreviate SQL type to short display form.
QString abbreviateType(const std::string& type) {
    const QString t = QString::fromStdString(type).toLower();
    if (t.startsWith(QStringLiteral("character varying")) ||
        t.startsWith(QStringLiteral("varchar"))) {
        const int p1 = t.indexOf(QLatin1Char('('));
        const int p2 = t.indexOf(QLatin1Char(')'));
        if (p1 != -1 && p2 > p1)
            return QStringLiteral("varchar") + t.mid(p1, p2 - p1 + 1);
        return QStringLiteral("varchar");
    }
    if (t.startsWith(QStringLiteral("timestamp")))  return QStringLiteral("timestamp");
    if (t.startsWith(QStringLiteral("double")))     return QStringLiteral("double");
    if (t == QStringLiteral("integer"))             return QStringLiteral("int");
    if (t == QStringLiteral("boolean"))             return QStringLiteral("bool");
    if (t == QStringLiteral("bigint"))              return QStringLiteral("bigint");
    if (t == QStringLiteral("smallint"))            return QStringLiteral("smallint");
    if (t == QStringLiteral("text"))                return QStringLiteral("text");
    if (t == QStringLiteral("uuid"))                return QStringLiteral("uuid");
    if (t == QStringLiteral("jsonb"))               return QStringLiteral("jsonb");
    if (t == QStringLiteral("json"))                return QStringLiteral("json");
    return QString::fromStdString(type).left(14);
}

// Build a table card QGraphicsItem group (returns the root rect item).
// The item is added to the scene inside this function; position is (0,0) —
// caller translates via QGraphicsItem::setPos.
QGraphicsRectItem* buildTableCard(QGraphicsScene* scene,
                                  const TableDescription& td) {
    const int   cols  = static_cast<int>(td.columns.size());
    const qreal cw    = kCardWidth;
    const qreal ch    = cardHeight(cols);

    // --- outer card rect (movable) ---
    auto* card = new QGraphicsRectItem(0, 0, cw, ch);
    card->setFlag(QGraphicsItem::ItemIsMovable, true);
    card->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
    card->setZValue(1.0);

    QPen borderPen(QColor(0x55, 0x55, 0x55, 180));
    borderPen.setWidthF(1.0);
    card->setPen(borderPen);
    card->setBrush(QBrush(QColor(0x2a, 0x2a, 0x2a)));

    // Drop shadow via a slightly-offset duplicate behind the card.
    auto* shadow = new QGraphicsRectItem(2, 3, cw, ch, card);
    shadow->setPen(Qt::NoPen);
    shadow->setBrush(QColor(0, 0, 0, 60));
    shadow->setZValue(-0.1);

    // --- header background ---
    auto* header = new QGraphicsRectItem(0, 0, cw, kHeaderHeight, card);
    header->setPen(Qt::NoPen);
    header->setBrush(QColor(0x1a, 0x6a, 0xc8, 50));  // accent blue tint

    // Header separator line
    auto* hSep = new QGraphicsLineItem(0, kHeaderHeight, cw, kHeaderHeight, card);
    hSep->setPen(QPen(QColor(0x55, 0x55, 0x55, 120), 0.5));

    // --- table name ---
    auto* nameItem = new QGraphicsTextItem(card);
    nameItem->setPos(10, 6);
    QFont nameFont;
    nameFont.setPointSize(9);
    nameFont.setBold(true);
    nameItem->setFont(nameFont);
    nameItem->setDefaultTextColor(QColor(0xec, 0xec, 0xec));
    nameItem->setPlainText(QString::fromStdString(td.name));
    nameItem->setTextWidth(cw - 20);

    // Column count badge (top-right of header)
    const QString countText = QString::number(cols);
    auto* countItem = new QGraphicsTextItem(card);
    QFont countFont;
    countFont.setPointSize(7);
    countItem->setFont(countFont);
    countItem->setDefaultTextColor(QColor(0x88, 0x88, 0x88));
    countItem->setPlainText(countText);
    const qreal cw2 = countItem->boundingRect().width();
    countItem->setPos(cw - cw2 - 8, 9);

    // --- column rows ---
    for (int i = 0; i < cols; ++i) {
        const auto& col  = td.columns[static_cast<std::size_t>(i)];
        const qreal rowY = kHeaderHeight + 2 + i * kRowHeight;

        // Alternating row background
        if (i % 2 == 1) {
            auto* rowBg = new QGraphicsRectItem(0, rowY, cw, kRowHeight, card);
            rowBg->setPen(Qt::NoPen);
            rowBg->setBrush(QColor(0xff, 0xff, 0xff, 6));
        }

        // PK / FK badge
        if (col.isPrimaryKey) {
            auto* badge = new QGraphicsTextItem(card);
            QFont bf; bf.setPointSize(7); bf.setBold(true);
            badge->setFont(bf);
            badge->setDefaultTextColor(QColor(0xd4, 0xa0, 0x17));  // gold
            badge->setPlainText(QStringLiteral("PK"));
            badge->setPos(8, rowY + 3);
        } else {
            // Check if this column is a FK column
            bool isFk = false;
            for (const auto& fk : td.foreignKeys) {
                for (const auto& fcol : fk.columns) {
                    if (fcol == col.name) { isFk = true; break; }
                }
                if (isFk) break;
            }
            if (isFk) {
                auto* badge = new QGraphicsTextItem(card);
                QFont bf; bf.setPointSize(7); bf.setBold(true);
                badge->setFont(bf);
                badge->setDefaultTextColor(QColor(0x5b, 0x9b, 0xd5));  // blue
                badge->setPlainText(QStringLiteral("FK"));
                badge->setPos(8, rowY + 3);
            }
        }

        // Column name
        auto* colName = new QGraphicsTextItem(card);
        QFont cf; cf.setPointSize(9);
        if (col.isPrimaryKey) cf.setBold(true);
        colName->setFont(cf);
        colName->setDefaultTextColor(QColor(0xd8, 0xd8, 0xd8));
        colName->setPlainText(QString::fromStdString(col.name));
        colName->setTextWidth(kCardWidth - 70);
        colName->setPos(28, rowY + 2);

        // Data type (right-aligned)
        auto* typeItem = new QGraphicsTextItem(card);
        QFont tf; tf.setPointSize(8); tf.setFamily(QStringLiteral("monospace"));
        typeItem->setFont(tf);
        typeItem->setDefaultTextColor(QColor(0x77, 0x99, 0x77));
        const QString shortType = abbreviateType(col.dataType);
        typeItem->setPlainText(shortType);
        const qreal tw = typeItem->boundingRect().width();
        typeItem->setPos(cw - tw - 6, rowY + 3);
    }

    scene->addItem(card);
    return card;
}

// Dynamic FK edge that recalculates its path every paint based on current
// positions of the source and target card items. Follows nodes when dragged.
class FKEdgeItem : public QGraphicsItem {
public:
    FKEdgeItem(QGraphicsRectItem* srcCard, int srcRowIdx,
               QGraphicsRectItem* tgtCard, int tgtRowIdx)
        : srcCard_(srcCard), tgtCard_(tgtCard),
          srcRowIdx_(srcRowIdx), tgtRowIdx_(tgtRowIdx) {
        setZValue(0.0);
    }

    QRectF boundingRect() const override {
        const auto s = srcPoint();
        const auto t = tgtPoint();
        return QRectF(std::min(s.x(), t.x()) - 20,
                      std::min(s.y(), t.y()) - 20,
                      std::abs(t.x() - s.x()) + 40,
                      std::abs(t.y() - s.y()) + 40);
    }

    void paint(QPainter* painter, const QStyleOptionGraphicsItem*, QWidget*) override {
        const auto src = srcPoint();
        const auto tgt = tgtPoint();
        const qreal midX = (src.x() + tgt.x()) / 2.0;

        QPainterPath path;
        path.moveTo(src);
        path.cubicTo(QPointF(midX, src.y()), QPointF(midX, tgt.y()), tgt);

        QPen p(QColor(0x5b, 0x9b, 0xd5, 160));
        p.setWidthF(1.5);
        painter->setPen(p);
        painter->setBrush(Qt::NoBrush);
        painter->drawPath(path);

        // Arrowhead
        const double angle = std::atan2(tgt.y() - src.y(), tgt.x() - src.x());
        const double aLen = 8.0, aAng = M_PI / 6.0;
        QPolygonF arrow;
        arrow << tgt
              << QPointF(tgt.x() - aLen * std::cos(angle - aAng),
                         tgt.y() - aLen * std::sin(angle - aAng))
              << QPointF(tgt.x() - aLen * std::cos(angle + aAng),
                         tgt.y() - aLen * std::sin(angle + aAng));
        painter->setPen(Qt::NoPen);
        painter->setBrush(QColor(0x5b, 0x9b, 0xd5, 160));
        painter->drawPolygon(arrow);
    }

private:
    QPointF srcPoint() const {
        const auto pos = srcCard_->pos();
        const bool leftOfTarget = pos.x() < tgtCard_->pos().x();
        const qreal y = pos.y() + kHeaderHeight + (srcRowIdx_ + 0.5) * kRowHeight;
        return QPointF(leftOfTarget ? pos.x() + kCardWidth : pos.x(), y);
    }
    QPointF tgtPoint() const {
        const auto pos = tgtCard_->pos();
        const bool leftOfSource = pos.x() < srcCard_->pos().x();
        const qreal y = pos.y() + kHeaderHeight + (tgtRowIdx_ + 0.5) * kRowHeight;
        return QPointF(leftOfSource ? pos.x() + kCardWidth : pos.x(), y);
    }

    QGraphicsRectItem* srcCard_;
    QGraphicsRectItem* tgtCard_;
    int srcRowIdx_;
    int tgtRowIdx_;
};

}  // namespace

// ---------------------------------------------------------------------------

ERDiagramView::ERDiagramView(QWidget* parent)
    : QGraphicsView(parent) {
    scene_ = new QGraphicsScene(this);
    setScene(scene_);

    setRenderHint(QPainter::Antialiasing);
    // Update the scene whenever items move so FKEdgeItem repaints.
    setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
    setDragMode(QGraphicsView::ScrollHandDrag);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    setResizeAnchor(QGraphicsView::AnchorUnderMouse);
    setBackgroundBrush(QColor(0x18, 0x18, 0x18));
    setFrameShape(QFrame::NoFrame);

    // Hide the dropdown arrow only — colors come from the global style.qss.
    const QString hideMenuArrow =
        QStringLiteral("QPushButton::menu-indicator { image: none; width: 0; }");

    // Fit-all button (top-right corner)
    fitBtn_ = new QPushButton(QStringLiteral("⤢ Fit"), this);
    fitBtn_->setFixedSize(60, 26);
    fitBtn_->setToolTip(tr("Fit all tables in view"));
    connect(fitBtn_, &QPushButton::clicked, this, &ERDiagramView::fitAll);
    fitBtn_->raise();

    // Export button with dropdown menu (placed left of Fit).
    exportMenu_ = new QMenu(this);
    auto* exportPngAct = exportMenu_->addAction(tr("Export as PNG..."));
    connect(exportPngAct, &QAction::triggered, this, &ERDiagramView::exportAsPng);
    auto* exportSvgAct = exportMenu_->addAction(tr("Export as SVG..."));
    connect(exportSvgAct, &QAction::triggered, this, &ERDiagramView::exportAsSvg);
    auto* exportPdfAct = exportMenu_->addAction(tr("Export as PDF..."));
    connect(exportPdfAct, &QAction::triggered, this, &ERDiagramView::exportAsPdf);
    exportMenu_->addSeparator();
    auto* exportDbmlAct = exportMenu_->addAction(tr("Export as DBML..."));
    connect(exportDbmlAct, &QAction::triggered, this, &ERDiagramView::exportAsDbml);
    auto* exportMermaidAct = exportMenu_->addAction(tr("Export as Mermaid (.md)..."));
    connect(exportMermaidAct, &QAction::triggered, this, &ERDiagramView::exportAsMermaid);

    exportBtn_ = new QPushButton(QStringLiteral("⇩ Export ▾"), this);
    exportBtn_->setFixedSize(84, 26);
    exportBtn_->setToolTip(tr("Export ER diagram"));
    exportBtn_->setStyleSheet(hideMenuArrow);
    exportBtn_->setMenu(exportMenu_);
    exportBtn_->raise();

    // Initial placement. resizeEvent repositions on every resize.
    fitBtn_->move(width() - fitBtn_->width() - 12, 8);
    exportBtn_->move(width() - fitBtn_->width() - exportBtn_->width() - 20, 8);
}

void ERDiagramView::resizeEvent(QResizeEvent* event) {
    QGraphicsView::resizeEvent(event);
    fitBtn_->move(width() - fitBtn_->width() - 12, 8);
    exportBtn_->move(width() - fitBtn_->width() - exportBtn_->width() - 20, 8);
}

void ERDiagramView::wheelEvent(QWheelEvent* event) {
    const qreal factor = (event->angleDelta().y() > 0) ? 1.15 : (1.0 / 1.15);
    scale(factor, factor);
    event->accept();
}

void ERDiagramView::fitAll() {
    if (scene_->items().isEmpty()) return;
    fitInView(scene_->itemsBoundingRect().adjusted(-40, -40, 40, 40),
              Qt::KeepAspectRatio);
}

void ERDiagramView::clear() {
    scene_->clear();
    nodePositions_.clear();
    nodeColumnCounts_.clear();
    tables_.clear();
}

void ERDiagramView::exportAsPng() {
    if (scene_->items().isEmpty()) {
        QMessageBox::information(this, tr("Export ER Diagram"),
                                 tr("No diagram to export."));
        return;
    }

    const QString defaultDir =
        QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
    const QString defaultPath = defaultDir + QStringLiteral("/er-diagram.png");

    const QString path = QFileDialog::getSaveFileName(
        this, tr("Export ER Diagram as PNG"), defaultPath,
        tr("PNG Image (*.png)"));
    if (path.isEmpty()) return;

    // Render full scene bounding rect (not viewport) so offscreen tables
    // are included. 2x scale keeps text sharp on high-DPI displays.
    const QRectF source = scene_->itemsBoundingRect().adjusted(-40, -40, 40, 40);
    constexpr qreal scaleFactor = 2.0;
    const QSize imageSize(
        static_cast<int>(std::ceil(source.width()  * scaleFactor)),
        static_cast<int>(std::ceil(source.height() * scaleFactor)));

    QImage image(imageSize, QImage::Format_ARGB32_Premultiplied);
    image.fill(backgroundBrush().color());

    QPainter painter(&image);
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setRenderHint(QPainter::TextAntialiasing);
    painter.setRenderHint(QPainter::SmoothPixmapTransform);
    scene_->render(&painter, QRectF(QPointF(0, 0), imageSize), source);
    painter.end();

    const QString outPath = path.endsWith(QStringLiteral(".png"), Qt::CaseInsensitive)
        ? path
        : path + QStringLiteral(".png");

    if (!image.save(outPath, "PNG")) {
        QMessageBox::warning(this, tr("Export ER Diagram"),
                             tr("Failed to write PNG to:\n%1").arg(outPath));
    }
}

void ERDiagramView::exportAsSvg() {
    ERDiagramExporter::exportAsSvg(scene_, this);
}

void ERDiagramView::exportAsPdf() {
    ERDiagramExporter::exportAsPdf(scene_, this);
}

void ERDiagramView::exportAsDbml() {
    ERDiagramExporter::exportAsDbml(tables_, this);
}

void ERDiagramView::exportAsMermaid() {
    ERDiagramExporter::exportAsMermaid(tables_, this);
}

void ERDiagramView::loadSchema(IDatabaseAdapter* adapter,
                               const std::optional<std::string>& schema) {
    clear();
    if (!adapter) return;

    std::vector<TableDescription> tables;
    try {
        const auto tableInfos = adapter->listTables(schema);
        for (const auto& info : tableInfos) {
            if (info.type != TableKind::Table) continue;
            try {
                tables.push_back(adapter->describeTable(info.name, schema));
            } catch (...) {
                // Skip tables that fail to describe
            }
        }
    } catch (const GridexError&) {
        return;
    }

    buildScene(tables);
}

void ERDiagramView::buildScene(const std::vector<TableDescription>& tables) {
    if (tables.empty()) return;
    tables_ = tables;

    // Build layout nodes
    std::vector<TableNode> nodes;
    nodes.reserve(tables.size());
    for (const auto& td : tables) {
        TableNode n;
        n.name    = td.name;
        n.columns = td.columns;
        nodes.push_back(std::move(n));
    }
    layoutGrid(nodes);

    // Place table cards in scene and record card pointers.
    std::unordered_map<std::string, QGraphicsRectItem*> cardMap;
    for (std::size_t i = 0; i < tables.size(); ++i) {
        const auto& td   = tables[i];
        const auto& node = nodes[i];

        auto* card = buildTableCard(scene_, td);
        card->setPos(node.x, node.y);
        // ItemSendsGeometryChanges already set in buildTableCard.
        // Trigger scene update when card moves so edges repaint.
        card->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);

        cardMap[td.name]            = card;
        nodePositions_[td.name]     = QPointF(node.x, node.y);
        nodeColumnCounts_[td.name]  = static_cast<int>(td.columns.size());
    }

    // Draw FK edges as dynamic FKEdgeItem (follows nodes on drag).
    for (const auto& td : tables) {
        auto srcCardIt = cardMap.find(td.name);
        if (srcCardIt == cardMap.end()) continue;

        for (const auto& fk : td.foreignKeys) {
            auto tgtCardIt = cardMap.find(fk.referencedTable);
            if (tgtCardIt == cardMap.end()) continue;

            // Find FK column row index in source table.
            int srcRowIdx = 0;
            for (std::size_t c = 0; c < td.columns.size(); ++c) {
                if (!fk.columns.empty() && td.columns[c].name == fk.columns[0]) {
                    srcRowIdx = static_cast<int>(c);
                    break;
                }
            }

            auto* edge = new FKEdgeItem(srcCardIt->second, srcRowIdx,
                                        tgtCardIt->second, /*tgtRowIdx*/ 0);
            scene_->addItem(edge);
        }
    }

    fitAll();
}

void ERDiagramView::layoutGrid(std::vector<TableNode>& nodes) {
    const int cols = static_cast<int>(kGridCols);
    for (std::size_t i = 0; i < nodes.size(); ++i) {
        const int row = static_cast<int>(i) / cols;
        const int col = static_cast<int>(i) % cols;

        // Compute max height of this row to stack cleanly
        qreal rowH = 0;
        const int rowStart = row * cols;
        const int rowEnd   = std::min(rowStart + cols, static_cast<int>(nodes.size()));
        for (int j = rowStart; j < rowEnd; ++j) {
            rowH = std::max(rowH,
                cardHeight(static_cast<int>(nodes[static_cast<std::size_t>(j)].columns.size())));
        }

        // X: sum of all card widths + gaps up to this column
        nodes[i].x = kPadding + col * (kCardWidth + kHGap);

        // Y: sum of max-heights of previous rows + gaps
        qreal y = kPadding;
        for (int r = 0; r < row; ++r) {
            const int rs = r * cols;
            const int re = std::min(rs + cols, static_cast<int>(nodes.size()));
            qreal maxH = 0;
            for (int j = rs; j < re; ++j) {
                maxH = std::max(maxH,
                    cardHeight(static_cast<int>(nodes[static_cast<std::size_t>(j)].columns.size())));
            }
            y += maxH + kVGap;
        }
        nodes[i].y = y;
    }
}

}  // namespace gridex