aboutsummaryrefslogtreecommitdiffstats
path: root/gui
diff options
context:
space:
mode:
Diffstat (limited to 'gui')
-rw-r--r--gui/designwidget.cc67
-rw-r--r--gui/designwidget.h6
-rw-r--r--gui/fpgaviewwidget.cc16
-rw-r--r--gui/fpgaviewwidget.h2
-rw-r--r--gui/quadtree.h3
-rw-r--r--gui/treemodel.cc446
-rw-r--r--gui/treemodel.h383
7 files changed, 618 insertions, 305 deletions
diff --git a/gui/designwidget.cc b/gui/designwidget.cc
index e8c05ef9..34e358ae 100644
--- a/gui/designwidget.cc
+++ b/gui/designwidget.cc
@@ -34,7 +34,7 @@ DesignWidget::DesignWidget(QWidget *parent) : QWidget(parent), ctx(nullptr), sel
{
// Add tree view
treeView = new QTreeView();
- treeModel = new ContextTreeModel();
+ treeModel = new TreeModel::Model();
treeView->setModel(treeModel);
treeView->setContextMenuPolicy(Qt::CustomContextMenu);
treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
@@ -215,7 +215,11 @@ void DesignWidget::newContext(Context *ctx)
highlightSelected.clear();
this->ctx = ctx;
- treeModel->loadData(ctx);
+ {
+ std::lock_guard<std::mutex> lock_ui(ctx->ui_mutex);
+ std::lock_guard<std::mutex> lock(ctx->mutex);
+ treeModel->loadContext(ctx);
+ }
updateTree();
}
@@ -223,9 +227,9 @@ void DesignWidget::updateTree()
{
clearProperties();
- QMap<ContextTreeItem *, int>::iterator i = highlightSelected.begin();
+ QMap<TreeModel::Item *, int>::iterator i = highlightSelected.begin();
while (i != highlightSelected.end()) {
- QMap<ContextTreeItem *, int>::iterator prev = i;
+ QMap<TreeModel::Item *, int>::iterator prev = i;
++i;
if (prev.key()->type() == ElementType::NET && ctx->nets.find(prev.key()->id()) == ctx->nets.end()) {
highlightSelected.erase(prev);
@@ -235,7 +239,11 @@ void DesignWidget::updateTree()
}
}
- treeModel->updateData(ctx);
+ {
+ std::lock_guard<std::mutex> lock_ui(ctx->ui_mutex);
+ std::lock_guard<std::mutex> lock(ctx->mutex);
+ treeModel->updateCellsNets(ctx);
+ }
}
QtProperty *DesignWidget::addTopLevelProperty(const QString &id)
{
@@ -309,24 +317,33 @@ QtProperty *DesignWidget::addSubGroup(QtProperty *topItem, const QString &name)
void DesignWidget::onClickedBel(BelId bel, bool keep)
{
- ContextTreeItem *item = treeModel->nodeForIdType(ElementType::BEL, ctx->getBelName(bel).c_str(ctx));
- selectionModel->setCurrentIndex(treeModel->indexFromNode(item),
+ auto item = treeModel->nodeForIdType(ElementType::BEL, ctx->getBelName(bel));
+ if (!item)
+ return;
+
+ selectionModel->setCurrentIndex(treeModel->indexFromNode(*item),
keep ? QItemSelectionModel::Select : QItemSelectionModel::ClearAndSelect);
Q_EMIT selected(getDecals(ElementType::BEL, ctx->getBelName(bel)), keep);
}
void DesignWidget::onClickedWire(WireId wire, bool keep)
{
- ContextTreeItem *item = treeModel->nodeForIdType(ElementType::WIRE, ctx->getWireName(wire).c_str(ctx));
- selectionModel->setCurrentIndex(treeModel->indexFromNode(item),
+ auto item = treeModel->nodeForIdType(ElementType::WIRE, ctx->getWireName(wire));
+ if (!item)
+ return;
+
+ selectionModel->setCurrentIndex(treeModel->indexFromNode(*item),
keep ? QItemSelectionModel::Select : QItemSelectionModel::ClearAndSelect);
Q_EMIT selected(getDecals(ElementType::WIRE, ctx->getWireName(wire)), keep);
}
void DesignWidget::onClickedPip(PipId pip, bool keep)
{
- ContextTreeItem *item = treeModel->nodeForIdType(ElementType::PIP, ctx->getPipName(pip).c_str(ctx));
- selectionModel->setCurrentIndex(treeModel->indexFromNode(item),
+ auto item = treeModel->nodeForIdType(ElementType::PIP, ctx->getPipName(pip));
+ if (!item)
+ return;
+
+ selectionModel->setCurrentIndex(treeModel->indexFromNode(*item),
keep ? QItemSelectionModel::Select : QItemSelectionModel::ClearAndSelect);
Q_EMIT selected(getDecals(ElementType::PIP, ctx->getPipName(pip)), keep);
}
@@ -339,7 +356,7 @@ void DesignWidget::onSelectionChanged(const QItemSelection &, const QItemSelecti
if (selectionModel->selectedIndexes().size() > 1) {
std::vector<DecalXY> decals;
for (auto index : selectionModel->selectedIndexes()) {
- ContextTreeItem *item = treeModel->nodeFromIndex(index);
+ TreeModel::Item *item = treeModel->nodeFromIndex(index);
std::vector<DecalXY> d = getDecals(item->type(), item->id());
std::move(d.begin(), d.end(), std::back_inserter(decals));
}
@@ -349,7 +366,7 @@ void DesignWidget::onSelectionChanged(const QItemSelection &, const QItemSelecti
QModelIndex index = selectionModel->selectedIndexes().at(0);
if (!index.isValid())
return;
- ContextTreeItem *clickItem = treeModel->nodeFromIndex(index);
+ TreeModel::Item *clickItem = treeModel->nodeFromIndex(index);
ElementType type = clickItem->type();
if (type == ElementType::NONE)
@@ -597,7 +614,7 @@ std::vector<DecalXY> DesignWidget::getDecals(ElementType type, IdString value)
return decals;
}
-void DesignWidget::updateHighlightGroup(QList<ContextTreeItem *> items, int group)
+void DesignWidget::updateHighlightGroup(QList<TreeModel::Item *> items, int group)
{
const bool shouldClear = items.size() == 1;
for (auto item : items) {
@@ -622,7 +639,7 @@ void DesignWidget::updateHighlightGroup(QList<ContextTreeItem *> items, int grou
void DesignWidget::prepareMenuProperty(const QPoint &pos)
{
QTreeWidget *tree = propertyEditor->treeWidget();
- QList<ContextTreeItem *> items;
+ QList<TreeModel::Item *> items;
for (auto itemContextMenu : tree->selectedItems()) {
QtBrowserItem *browserItem = propertyEditor->itemToBrowserItem(itemContextMenu);
if (!browserItem)
@@ -632,11 +649,14 @@ void DesignWidget::prepareMenuProperty(const QPoint &pos)
if (type == ElementType::NONE)
continue;
IdString value = ctx->id(selectedProperty->valueText().toStdString());
- items.append(treeModel->nodeForIdType(type, value.c_str(ctx)));
+ auto node = treeModel->nodeForIdType(type, value);
+ if (!node)
+ continue;
+ items.append(*node);
}
int selectedIndex = -1;
if (items.size() == 1) {
- ContextTreeItem *item = items.at(0);
+ TreeModel::Item *item = items.at(0);
if (highlightSelected.contains(item))
selectedIndex = highlightSelected[item];
}
@@ -677,13 +697,13 @@ void DesignWidget::prepareMenuTree(const QPoint &pos)
if (selectionModel->selectedIndexes().size() == 0)
return;
- QList<ContextTreeItem *> items;
+ QList<TreeModel::Item *> items;
for (auto index : selectionModel->selectedIndexes()) {
- ContextTreeItem *item = treeModel->nodeFromIndex(index);
+ TreeModel::Item *item = treeModel->nodeFromIndex(index);
items.append(item);
}
if (items.size() == 1) {
- ContextTreeItem *item = items.at(0);
+ TreeModel::Item *item = items.at(0);
if (highlightSelected.contains(item))
selectedIndex = highlightSelected[item];
}
@@ -709,9 +729,9 @@ void DesignWidget::onItemDoubleClicked(QTreeWidgetItem *item, int column)
{
QtProperty *selectedProperty = propertyEditor->itemToBrowserItem(item)->property();
ElementType type = getElementTypeByName(selectedProperty->propertyId());
- ContextTreeItem *it = treeModel->nodeForIdType(type, selectedProperty->valueText());
+ auto it = treeModel->nodeForIdType(type, ctx->id(selectedProperty->valueText().toStdString()));
if (it)
- selectionModel->setCurrentIndex(treeModel->indexFromNode(it), QItemSelectionModel::ClearAndSelect);
+ selectionModel->setCurrentIndex(treeModel->indexFromNode(*it), QItemSelectionModel::ClearAndSelect);
}
void DesignWidget::onDoubleClicked(const QModelIndex &index) { Q_EMIT zoomSelected(); }
@@ -723,6 +743,9 @@ void DesignWidget::onSearchInserted()
if (currentIndex >= currentSearchIndexes.size())
currentIndex = 0;
} else {
+ std::lock_guard<std::mutex> lock_ui(ctx->ui_mutex);
+ std::lock_guard<std::mutex> lock(ctx->mutex);
+
currentSearch = searchEdit->text();
currentSearchIndexes = treeModel->search(searchEdit->text());
currentIndex = 0;
diff --git a/gui/designwidget.h b/gui/designwidget.h
index 535fd0c3..628586f4 100644
--- a/gui/designwidget.h
+++ b/gui/designwidget.h
@@ -51,7 +51,7 @@ class DesignWidget : public QWidget
void updateButtons();
void addToHistory(QModelIndex item);
std::vector<DecalXY> getDecals(ElementType type, IdString value);
- void updateHighlightGroup(QList<ContextTreeItem *> item, int group);
+ void updateHighlightGroup(QList<TreeModel::Item *> item, int group);
Q_SIGNALS:
void info(std::string text);
void selected(std::vector<DecalXY> decal, bool keep);
@@ -77,7 +77,7 @@ class DesignWidget : public QWidget
QTreeView *treeView;
QItemSelectionModel *selectionModel;
- ContextTreeModel *treeModel;
+ TreeModel::Model *treeModel;
QLineEdit *searchEdit;
QtVariantPropertyManager *variantManager;
QtVariantPropertyManager *readOnlyManager;
@@ -99,7 +99,7 @@ class DesignWidget : public QWidget
QAction *actionClear;
QColor highlightColors[8];
- QMap<ContextTreeItem *, int> highlightSelected;
+ QMap<TreeModel::Item *, int> highlightSelected;
QString currentSearch;
QList<QModelIndex> currentSearchIndexes;
diff --git a/gui/fpgaviewwidget.cc b/gui/fpgaviewwidget.cc
index ed25a187..66739b28 100644
--- a/gui/fpgaviewwidget.cc
+++ b/gui/fpgaviewwidget.cc
@@ -323,14 +323,18 @@ void FPGAViewWidget::paintGL()
flags = rendererData_->flags;
}
- {
- QMutexLocker locker(&rendererArgsLock_);
- rendererArgs_->flags.clear();
- }
-
// Check flags passed through pipeline.
if (flags.zoomOutbound) {
- zoomOutbound();
+ // If we're doing init zoomOutbound, make sure we're actually drawing
+ // something already.
+ if (rendererData_->gfxByStyle[GraphicElement::STYLE_FRAME].vertices.size() != 0) {
+ zoomOutbound();
+ flags.zoomOutbound = false;
+ {
+ QMutexLocker lock(&rendererArgsLock_);
+ rendererArgs_->flags.zoomOutbound = false;
+ }
+ }
}
}
diff --git a/gui/fpgaviewwidget.h b/gui/fpgaviewwidget.h
index c35821d9..a40a0153 100644
--- a/gui/fpgaviewwidget.h
+++ b/gui/fpgaviewwidget.h
@@ -251,8 +251,6 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions
zoomOutbound = other.zoomOutbound;
return *this;
}
-
- void clear() { zoomOutbound = false; }
};
struct RendererArgs
diff --git a/gui/quadtree.h b/gui/quadtree.h
index b3ebf81c..a6c38a85 100644
--- a/gui/quadtree.h
+++ b/gui/quadtree.h
@@ -50,7 +50,6 @@ template <typename CoordinateT, typename ElementT> class QuadTreeNode
{
}
-
BoundingBox() : x0_(pinf), y0_(pinf), x1_(ninf), y1_(ninf) {}
BoundingBox(const BoundingBox &other) : x0_(other.x0_), y0_(other.y0_), x1_(other.x1_), y1_(other.y1_) {}
@@ -83,7 +82,7 @@ template <typename CoordinateT, typename ElementT> class QuadTreeNode
CoordinateT y0() const { return y0_; }
CoordinateT x1() const { return x1_; }
CoordinateT y1() const { return y1_; }
-
+
void setX0(CoordinateT v) { x0_ = v; }
void setY0(CoordinateT v) { y0_ = v; }
void setX1(CoordinateT v) { x1_ = v; }
diff --git a/gui/treemodel.cc b/gui/treemodel.cc
index d42dc401..900d5101 100644
--- a/gui/treemodel.cc
+++ b/gui/treemodel.cc
@@ -2,6 +2,7 @@
* nextpnr -- Next Generation Place and Route
*
* Copyright (C) 2018 Miodrag Milanovic <miodrag@symbioticeda.com>
+ * Copyright (C) 2018 Serge Bazanski <q3k@symbioticeda.com>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -18,265 +19,249 @@
*/
#include "treemodel.h"
+#include "log.h"
NEXTPNR_NAMESPACE_BEGIN
-static bool contextTreeItemLessThan(const ContextTreeItem *v1, const ContextTreeItem *v2)
- {
- return v1->name() < v2->name();
- }
+namespace TreeModel {
-ContextTreeItem::ContextTreeItem() { parentNode = nullptr; }
-
-ContextTreeItem::ContextTreeItem(QString name)
- : parentNode(nullptr), itemId(IdString()), itemType(ElementType::NONE), itemName(name)
+// converts 'aa123bb432' -> ['aa', '123', 'bb', '432']
+std::vector<QString> IdStringList::alphaNumSplit(const QString &str)
{
-}
+ std::vector<QString> res;
+ QString current_part;
+
+ bool number = true;
+ for (const auto c : str) {
+ if (current_part.size() == 0 && res.size() == 0) {
+ current_part.push_back(c);
+ number = c.isNumber();
+ continue;
+ }
-ContextTreeItem::ContextTreeItem(IdString id, ElementType type, QString name)
- : parentNode(nullptr), itemId(id), itemType(type), itemName(name)
-{
-}
+ if (number != c.isNumber()) {
+ number = c.isNumber();
+ res.push_back(current_part);
+ current_part.clear();
+ }
-ContextTreeItem::~ContextTreeItem()
-{
- if (parentNode)
- parentNode->children.removeOne(this);
- qDeleteAll(children);
+ current_part.push_back(c);
+ }
+
+ res.push_back(current_part);
+
+ return res;
}
-void ContextTreeItem::addChild(ContextTreeItem *item)
+
+void IdStringList::updateElements(Context *ctx, std::vector<IdString> elements)
{
- item->parentNode = this;
- children.append(item);
+ bool changed = false;
+
+ // For any elements that are not yet in managed_, created them.
+ std::unordered_set<IdString> element_set;
+ for (auto elem : elements) {
+ element_set.insert(elem);
+ auto existing = managed_.find(elem);
+ if (existing == managed_.end()) {
+ auto item = new IdStringItem(ctx, elem, this, child_type_);
+ managed_.emplace(elem, std::unique_ptr<IdStringItem>(item));
+ changed = true;
+ }
+ }
+
+ // For any elements that are in managed_ but not in new, delete them.
+ for (auto &pair : managed_) {
+ if (element_set.count(pair.first) != 0) {
+ continue;
+ }
+ managed_.erase(pair.first);
+ changed = true;
+ }
+
+ // Return early if there are no changes.
+ if (!changed)
+ return;
+
+ // Rebuild children list.
+ children_.clear();
+ for (auto &pair : managed_) {
+ if (element_set.count(pair.first) != 0) {
+ children_.push_back(pair.second.get());
+ }
+ }
+
+ // Sort new children
+ qSort(children_.begin(), children_.end(), [&](const Item *a, const Item *b) {
+ auto parts_a = alphaNumSplit(a->name());
+ auto parts_b = alphaNumSplit(b->name());
+
+ // Short-circuit for different part count.
+ if (parts_a.size() != parts_b.size()) {
+ return parts_a.size() < parts_b.size();
+ }
+
+ for (size_t i = 0; i < parts_a.size(); i++) {
+ auto &part_a = parts_a.at(i);
+ auto &part_b = parts_b.at(i);
+
+ bool a_is_number, b_is_number;
+ int a_number = part_a.toInt(&a_is_number);
+ int b_number = part_b.toInt(&b_is_number);
+
+ // If both parts are numbers, compare numerically.
+ // If they're equal, continue to next part.
+ if (a_is_number && b_is_number) {
+ if (a_number != b_number) {
+ return a_number < b_number;
+ } else {
+ continue;
+ }
+ }
+
+ // For different alpha/nonalpha types, make numeric parts appear
+ // first.
+ if (a_is_number != b_is_number) {
+ return a_is_number;
+ }
+
+ // If both parts are numbers, compare lexically.
+ // If they're equal, continue to next part.
+ if (part_a == part_b) {
+ continue;
+ }
+ return part_a < part_b;
+ }
+
+ // Same string.
+ return true;
+ });
}
-void ContextTreeItem::sort()
+void IdStringList::search(QList<Item *> &results, QString text, int limit)
{
- for (auto item : children)
- if (item->count()>1) item->sort();
- qSort(children.begin(), children.end(), contextTreeItemLessThan);
+ for (const auto &child : children_) {
+ if (limit != -1 && results.size() > limit)
+ return;
+
+ if (child->name().contains(text))
+ results.push_back(child);
+ }
}
-ContextTreeModel::ContextTreeModel(QObject *parent) : QAbstractItemModel(parent) { root = new ContextTreeItem(); }
+Model::Model(QObject *parent) : QAbstractItemModel(parent), root_(new Item("Elements", nullptr)) {}
-ContextTreeModel::~ContextTreeModel() { delete root; }
+Model::~Model() {}
-void ContextTreeModel::loadData(Context *ctx)
+void Model::loadContext(Context *ctx)
{
if (!ctx)
return;
+ ctx_ = ctx;
beginResetModel();
- delete root;
- root = new ContextTreeItem();
-
- for (int i = 0; i < 6; i++)
- nameToItem[i].clear();
-
- IdString none;
-
- ContextTreeItem *bels_root = new ContextTreeItem("Bels");
- root->addChild(bels_root);
- QMap<QString, ContextTreeItem *> bel_items;
-
- // Add bels to tree
- for (auto bel : ctx->getBels()) {
- IdString id = ctx->getBelName(bel);
- QStringList items = QString(id.c_str(ctx)).split("/");
- QString name;
- ContextTreeItem *parent = bels_root;
- for (int i = 0; i < items.size(); i++) {
- if (!name.isEmpty())
- name += "/";
- name += items.at(i);
- if (!bel_items.contains(name)) {
- if (i == items.size() - 1) {
- ContextTreeItem *item = new ContextTreeItem(id, ElementType::BEL, items.at(i));
- parent->addChild(item);
- nameToItem[0].insert(name, item);
- } else {
- ContextTreeItem *item = new ContextTreeItem(none, ElementType::NONE, items.at(i));
- parent->addChild(item);
- bel_items.insert(name, item);
- }
- }
- parent = bel_items[name];
+ // Currently we lack an API to get a proper hierarchy of bels/pip/wires
+ // cross-arch. So we only do this for ICE40 by querying the ChipDB
+ // directly.
+ // TODO(q3k): once AnyId and the tree API land in Arch, move this over.
+#ifdef ARCH_ICE40
+ {
+ std::map<std::pair<int, int>, std::vector<BelId>> belMap;
+ for (auto bel : ctx->getBels()) {
+ auto loc = ctx->getBelLocation(bel);
+ belMap[std::pair<int, int>(loc.x, loc.y)].push_back(bel);
}
- }
- bels_root->sort();
-
- ContextTreeItem *wire_root = new ContextTreeItem("Wires");
- root->addChild(wire_root);
- QMap<QString, ContextTreeItem *> wire_items;
-
- // Add wires to tree
- for (auto wire : ctx->getWires()) {
- auto id = ctx->getWireName(wire);
- QStringList items = QString(id.c_str(ctx)).split("/");
- QString name;
- ContextTreeItem *parent = wire_root;
- for (int i = 0; i < items.size(); i++) {
- if (!name.isEmpty())
- name += "/";
- name += items.at(i);
- if (!wire_items.contains(name)) {
- if (i == items.size() - 1) {
- ContextTreeItem *item = new ContextTreeItem(id, ElementType::WIRE, items.at(i));
- parent->addChild(item);
- nameToItem[1].insert(name, item);
- } else {
- ContextTreeItem *item = new ContextTreeItem(none, ElementType::NONE, items.at(i));
- parent->addChild(item);
- wire_items.insert(name, item);
- }
- }
- parent = wire_items[name];
+ auto belGetter = [](Context *ctx, BelId id) { return ctx->getBelName(id); };
+ bel_root_ = std::unique_ptr<BelXYRoot>(
+ new BelXYRoot(ctx, "Bels", root_.get(), belMap, belGetter, ElementType::BEL));
+
+ std::map<std::pair<int, int>, std::vector<WireId>> wireMap;
+ for (int i = 0; i < ctx->chip_info->num_wires; i++) {
+ const auto wire = &ctx->chip_info->wire_data[i];
+ WireId wireid;
+ wireid.index = i;
+ wireMap[std::pair<int, int>(wire->x, wire->y)].push_back(wireid);
}
- }
- wire_root->sort();
-
- ContextTreeItem *pip_root = new ContextTreeItem("Pips");
- root->addChild(pip_root);
- QMap<QString, ContextTreeItem *> pip_items;
-
- // Add pips to tree
-#ifndef ARCH_ECP5
- for (auto pip : ctx->getPips()) {
- auto id = ctx->getPipName(pip);
- QStringList items = QString(id.c_str(ctx)).split("/");
- QString name;
- ContextTreeItem *parent = pip_root;
- for (int i = 0; i < items.size(); i++) {
- if (!name.isEmpty())
- name += "/";
- name += items.at(i);
- if (!pip_items.contains(name)) {
- if (i == items.size() - 1) {
- ContextTreeItem *item = new ContextTreeItem(id, ElementType::PIP, items.at(i));
- parent->addChild(item);
- nameToItem[2].insert(name, item);
- } else {
- ContextTreeItem *item = new ContextTreeItem(none, ElementType::NONE, items.at(i));
- parent->addChild(item);
- pip_items.insert(name, item);
- }
- }
- parent = pip_items[name];
+ auto wireGetter = [](Context *ctx, WireId id) { return ctx->getWireName(id); };
+ wire_root_ = std::unique_ptr<WireXYRoot>(
+ new WireXYRoot(ctx, "Wires", root_.get(), wireMap, wireGetter, ElementType::WIRE));
+
+ std::map<std::pair<int, int>, std::vector<PipId>> pipMap;
+ for (int i = 0; i < ctx->chip_info->num_pips; i++) {
+ const auto pip = &ctx->chip_info->pip_data[i];
+ PipId pipid;
+ pipid.index = i;
+ pipMap[std::pair<int, int>(pip->x, pip->y)].push_back(pipid);
}
+ auto pipGetter = [](Context *ctx, PipId id) { return ctx->getPipName(id); };
+ pip_root_ = std::unique_ptr<PipXYRoot>(
+ new PipXYRoot(ctx, "Pips", root_.get(), pipMap, pipGetter, ElementType::PIP));
}
#endif
- pip_root->sort();
- nets_root = new ContextTreeItem("Nets");
- root->addChild(nets_root);
-
- cells_root = new ContextTreeItem("Cells");
- root->addChild(cells_root);
+ cell_root_ = std::unique_ptr<IdStringList>(new IdStringList(QString("Cells"), root_.get(), ElementType::CELL));
+ net_root_ = std::unique_ptr<IdStringList>(new IdStringList(QString("Nets"), root_.get(), ElementType::NET));
endResetModel();
+
+ updateCellsNets(ctx);
}
-void ContextTreeModel::updateData(Context *ctx)
+void Model::updateCellsNets(Context *ctx)
{
if (!ctx)
return;
beginResetModel();
- //QModelIndex nets_index = indexFromNode(nets_root);
- // Remove nets not existing any more
- QMap<QString, ContextTreeItem *>::iterator i = nameToItem[3].begin();
- while (i != nameToItem[3].end()) {
- QMap<QString, ContextTreeItem *>::iterator prev = i;
- ++i;
- if (ctx->nets.find(ctx->id(prev.key().toStdString())) == ctx->nets.end()) {
- //int pos = prev.value()->parent()->indexOf(prev.value());
- //beginRemoveRows(nets_index, pos, pos);
- delete prev.value();
- nameToItem[3].erase(prev);
- //endRemoveRows();
- }
- }
- // Add nets to tree
- for (auto &item : ctx->nets) {
- auto id = item.first;
- QString name = QString(id.c_str(ctx));
- if (!nameToItem[3].contains(name)) {
- //beginInsertRows(nets_index, nets_root->count() + 1, nets_root->count() + 1);
- ContextTreeItem *newItem = new ContextTreeItem(id, ElementType::NET, name);
- nets_root->addChild(newItem);
- nameToItem[3].insert(name, newItem);
- //endInsertRows();
- }
+ std::vector<IdString> cells;
+ for (auto &pair : ctx->cells) {
+ cells.push_back(pair.first);
}
+ cell_root_->updateElements(ctx, cells);
- nets_root->sort();
-
- //QModelIndex cell_index = indexFromNode(cells_root);
- // Remove cells not existing any more
- i = nameToItem[4].begin();
- while (i != nameToItem[4].end()) {
- QMap<QString, ContextTreeItem *>::iterator prev = i;
- ++i;
- if (ctx->cells.find(ctx->id(prev.key().toStdString())) == ctx->cells.end()) {
- //int pos = prev.value()->parent()->indexOf(prev.value());
- //beginRemoveRows(cell_index, pos, pos);
- delete prev.value();
- nameToItem[4].erase(prev);
- //endRemoveRows();
- }
+ std::vector<IdString> nets;
+ for (auto &pair : ctx->nets) {
+ nets.push_back(pair.first);
}
- // Add cells to tree
- for (auto &item : ctx->cells) {
- auto id = item.first;
- QString name = QString(id.c_str(ctx));
- if (!nameToItem[4].contains(name)) {
- //beginInsertRows(cell_index, cells_root->count() + 1, cells_root->count() + 1);
- ContextTreeItem *newItem = new ContextTreeItem(id, ElementType::CELL, name);
- cells_root->addChild(newItem);
- nameToItem[4].insert(name, newItem);
- //endInsertRows();
- }
- }
-
- cells_root->sort();
+ net_root_->updateElements(ctx, nets);
endResetModel();
}
-int ContextTreeModel::rowCount(const QModelIndex &parent) const { return nodeFromIndex(parent)->count(); }
+int Model::rowCount(const QModelIndex &parent) const { return nodeFromIndex(parent)->count(); }
-int ContextTreeModel::columnCount(const QModelIndex &parent) const { return 1; }
+int Model::columnCount(const QModelIndex &parent) const { return 1; }
-QModelIndex ContextTreeModel::index(int row, int column, const QModelIndex &parent) const
+QModelIndex Model::index(int row, int column, const QModelIndex &parent) const
{
- ContextTreeItem *node = nodeFromIndex(parent);
+ Item *node = nodeFromIndex(parent);
if (row >= node->count())
return QModelIndex();
- return createIndex(row, column, node->at(row));
+
+ return createIndex(row, column, node->child(row));
}
-QModelIndex ContextTreeModel::parent(const QModelIndex &child) const
+QModelIndex Model::parent(const QModelIndex &child) const
{
- ContextTreeItem *parent = nodeFromIndex(child)->parent();
- if (parent == root)
+ Item *parent = nodeFromIndex(child)->parent();
+ if (parent == root_.get())
return QModelIndex();
- ContextTreeItem *node = parent->parent();
+ Item *node = parent->parent();
return createIndex(node->indexOf(parent), 0, parent);
}
-QVariant ContextTreeModel::data(const QModelIndex &index, int role) const
+QVariant Model::data(const QModelIndex &index, int role) const
{
if (index.column() != 0)
return QVariant();
if (role != Qt::DisplayRole)
return QVariant();
- ContextTreeItem *node = nodeFromIndex(index);
+ Item *node = nodeFromIndex(index);
return node->name();
}
-QVariant ContextTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant Model::headerData(int section, Qt::Orientation orientation, int role) const
{
Q_UNUSED(section);
if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
@@ -285,62 +270,49 @@ QVariant ContextTreeModel::headerData(int section, Qt::Orientation orientation,
return QVariant();
}
-ContextTreeItem *ContextTreeModel::nodeFromIndex(const QModelIndex &idx) const
+Item *Model::nodeFromIndex(const QModelIndex &idx) const
{
if (idx.isValid())
- return (ContextTreeItem *)idx.internalPointer();
- return root;
+ return (Item *)idx.internalPointer();
+ return root_.get();
}
-static int getElementIndex(ElementType type)
+Qt::ItemFlags Model::flags(const QModelIndex &index) const
{
- if (type == ElementType::BEL)
- return 0;
- if (type == ElementType::WIRE)
- return 1;
- if (type == ElementType::PIP)
- return 2;
- if (type == ElementType::NET)
- return 3;
- if (type == ElementType::CELL)
- return 4;
- return -1;
+ Item *node = nodeFromIndex(index);
+ return Qt::ItemIsEnabled | (node->type() != ElementType::NONE ? Qt::ItemIsSelectable : Qt::NoItemFlags);
}
-ContextTreeItem *ContextTreeModel::nodeForIdType(const ElementType type, const QString name) const
+void Model::fetchMore(const QModelIndex &parent)
{
- int index = getElementIndex(type);
- if (type != ElementType::NONE && nameToItem[index].contains(name))
- return nameToItem[index].value(name);
- return nullptr;
-}
+ if (ctx_ == nullptr)
+ return;
-QModelIndex ContextTreeModel::indexFromNode(ContextTreeItem *node)
-{
- ContextTreeItem *parent = node->parent();
- if (parent == root)
- return QModelIndex();
- return createIndex(parent->indexOf(node), 0, node);
-}
+ std::lock_guard<std::mutex> lock_ui(ctx_->ui_mutex);
+ std::lock_guard<std::mutex> lock(ctx_->mutex);
-Qt::ItemFlags ContextTreeModel::flags(const QModelIndex &index) const
-{
- ContextTreeItem *node = nodeFromIndex(index);
- return Qt::ItemIsEnabled | (node->type() != ElementType::NONE ? Qt::ItemIsSelectable : Qt::NoItemFlags);
+ nodeFromIndex(parent)->fetchMore();
}
-QList<QModelIndex> ContextTreeModel::search(QString text)
+bool Model::canFetchMore(const QModelIndex &parent) const { return nodeFromIndex(parent)->canFetchMore(); }
+
+QList<QModelIndex> Model::search(QString text)
{
- QList<QModelIndex> list;
- for (int i = 0; i < 6; i++) {
- for (auto key : nameToItem[i].keys()) {
- if (key.contains(text, Qt::CaseInsensitive)) {
- list.append(indexFromNode(nameToItem[i].value(key)));
- if (list.count() > 500)
- break; // limit to 500 results
- }
- }
+ const int limit = 500;
+ QList<Item *> list;
+ cell_root_->search(list, text, limit);
+ net_root_->search(list, text, limit);
+ bel_root_->search(list, text, limit);
+ wire_root_->search(list, text, limit);
+ pip_root_->search(list, text, limit);
+
+ QList<QModelIndex> res;
+ for (auto i : list) {
+ res.push_back(indexFromNode(i));
}
- return list;
+ return res;
}
+
+}; // namespace TreeModel
+
NEXTPNR_NAMESPACE_END
diff --git a/gui/treemodel.h b/gui/treemodel.h
index c14efa90..4c3f64c3 100644
--- a/gui/treemodel.h
+++ b/gui/treemodel.h
@@ -2,6 +2,7 @@
* nextpnr -- Next Generation Place and Route
*
* Copyright (C) 2018 Miodrag Milanovic <miodrag@symbioticeda.com>
+ * Copyright (C) 2018 Serge Bazanski <q3k@symbioticeda.com>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -21,6 +22,8 @@
#define TREEMODEL_H
#include <QAbstractItemModel>
+#include <boost/optional.hpp>
+
#include "nextpnr.h"
NEXTPNR_NAMESPACE_BEGIN
@@ -36,43 +39,350 @@ enum class ElementType
GROUP
};
-class ContextTreeItem
+namespace TreeModel {
+
+// Item is a leaf or non-leaf item in the TreeModel hierarchy. It does not
+// manage any memory.
+// It has a list of children, and when created it registers itself as a child
+// of its parent.
+// It has some PNR-specific members, like type (if any), idstring (if ay).
+// They should be overwritten by deriving classes to make them relate to an
+// object somewhere in the arch universe.
+// It also has provisions for lazy loading of data, via the canFetchMore and
+// fetchMore methods.
+class Item
+{
+ protected:
+ // Human-friendly name of this item.
+ QString name_;
+ // Parent or nullptr if root.
+ Item *parent_;
+ // Children that are loaded into memory.
+ QList<Item *> children_;
+
+ void addChild(Item *child) { children_.append(child); }
+
+ public:
+ Item(QString name, Item *parent) : name_(name), parent_(parent)
+ {
+ // Register in parent if exists.
+ if (parent_ != nullptr) {
+ parent_->addChild(this);
+ }
+ };
+
+ // Number of children.
+ int count() const { return children_.count(); }
+
+ // Name getter.
+ QString name() const { return name_; }
+
+ // Child getter.
+ Item *child(int index) { return children_.at(index); }
+
+ // Parent getter.
+ const Item *parent() const { return parent_; }
+ Item *parent() { return parent_; }
+
+ // indexOf gets index of child in children array.
+ int indexOf(const Item *child) const
+ {
+ // Dropping the const for indexOf to work.
+ return children_.indexOf((Item *)child, 0);
+ }
+ int indexOf(Item *child) { return children_.indexOf(child, 0); }
+
+ // Arch id and type that correspond to this element.
+ virtual IdString id() const { return IdString(); }
+ virtual ElementType type() const { return ElementType::NONE; }
+
+ // Lazy loading methods.
+ virtual bool canFetchMore() const { return false; }
+ virtual void fetchMore() {}
+
+ ~Item() {}
+};
+
+// IdString is an Item that corresponds to a real element in Arch.
+class IdStringItem : public Item
+{
+ private:
+ IdString id_;
+ ElementType type_;
+
+ public:
+ IdStringItem(Context *ctx, IdString str, Item *parent, ElementType type)
+ : Item(QString(str.c_str(ctx)), parent), id_(str), type_(type)
+ {
+ }
+
+ virtual IdString id() const override { return id_; }
+
+ virtual ElementType type() const override { return type_; }
+};
+
+// IdString list is a static list of IdStrings which can be set/updates from
+// a vector of IdStrings. It will render each IdStrings as a child, with the
+// list sorted in a smart way.
+class IdStringList : public Item
+{
+ private:
+ // Children that we manage the memory for, stored for quick lookup from
+ // IdString to child.
+ std::unordered_map<IdString, std::unique_ptr<IdStringItem>> managed_;
+ // Type of children that the list creates.
+ ElementType child_type_;
+
+ public:
+ // Create an IdStringList at given partent that will contain elements of
+ // the given type.
+ IdStringList(QString name, Item *parent, ElementType type) : Item(name, parent), child_type_(type) {}
+
+ // Split a name into alpha/non-alpha parts, which is then used for sorting
+ // of children.
+ static std::vector<QString> alphaNumSplit(const QString &str);
+
+ // getById finds a child for the given IdString.
+ IdStringItem *getById(IdString id) const { return managed_.at(id).get(); }
+
+ // (Re-)create children from a list of IdStrings.
+ void updateElements(Context *ctx, std::vector<IdString> elements);
+
+ // Find children that contain the given text.
+ void search(QList<Item *> &results, QString text, int limit);
+};
+
+// ElementList is a dynamic list of ElementT (BelId,WireId,...) that are
+// automatically generated based on an overall map of elements.
+// ElementList is emitted from ElementXYRoot, and contains the actual
+// Bels/Wires/Pips underneath it.
+template <typename ElementT> class ElementList : public Item
+{
+ public:
+ // A map from tile (X,Y) to list of ElementTs in that tile.
+ using ElementMap = std::map<std::pair<int, int>, std::vector<ElementT>>;
+ // A method that converts an ElementT to an IdString.
+ using ElementGetter = std::function<IdString(Context *, ElementT)>;
+
+ private:
+ Context *ctx_;
+ // ElementMap given to use by our constructor.
+ const ElementMap *map_;
+ // The X, Y that this list handles.
+ int x_, y_;
+ ElementGetter getter_;
+ // Children that we manage the memory for, stored for quick lookup from
+ // IdString to child.
+ std::unordered_map<IdString, std::unique_ptr<Item>> managed_;
+ // Type of children that he list creates.
+ ElementType child_type_;
+
+ // Gets elements that this list should create from the map. This pointer is
+ // short-lived (as it will change when the map mutates.
+ const std::vector<ElementT> *elements() const { return &map_->at(std::make_pair(x_, y_)); }
+
+ public:
+ ElementList(Context *ctx, QString name, Item *parent, ElementMap *map, int x, int y, ElementGetter getter,
+ ElementType type)
+ : Item(name, parent), ctx_(ctx), map_(map), x_(x), y_(y), getter_(getter), child_type_(type)
+ {
+ }
+
+ // Lazy loading of elements.
+
+ virtual bool canFetchMore() const override { return (size_t)children_.size() < elements()->size(); }
+
+ void fetchMore(int count)
+ {
+ size_t start = children_.size();
+ size_t end = std::min(start + count, elements()->size());
+ for (size_t i = start; i < end; i++) {
+ auto idstring = getter_(ctx_, elements()->at(i));
+ QString name(idstring.c_str(ctx_));
+
+ // Remove X.../Y.../ prefix
+ QString prefix = QString("X%1/Y%2/").arg(x_).arg(y_);
+ if (name.startsWith(prefix))
+ name.remove(0, prefix.size());
+
+ auto item = new IdStringItem(ctx_, idstring, this, child_type_);
+ managed_[idstring] = std::move(std::unique_ptr<Item>(item));
+ }
+ }
+
+ virtual void fetchMore() override { fetchMore(100); }
+
+ // getById finds a child for the given IdString.
+ boost::optional<Item *> getById(IdString id)
+ {
+ // Search requires us to load all our elements...
+ while (canFetchMore())
+ fetchMore();
+
+ auto res = managed_.find(id);
+ if (res != managed_.end()) {
+ return res->second.get();
+ }
+ return boost::none;
+ }
+
+ // Find children that contain the given text.
+ void search(QList<Item *> &results, QString text, int limit)
+ {
+ // Last chance to bail out from loading entire tree into memory.
+ if (limit != -1 && results.size() > limit)
+ return;
+
+ // Search requires us to load all our elements...
+ while (canFetchMore())
+ fetchMore();
+
+ for (const auto &child : children_) {
+ if (limit != -1 && results.size() > limit)
+ return;
+ if (child->name().contains(text))
+ results.push_back(child);
+ }
+ }
+};
+
+// ElementXYRoot is the root of an ElementT multi-level lazy loading list.
+// It can take any of {BelId,WireId,PipId} and create a tree that
+// hierarchizes them by X and Y tile positions, when given a map from X,Y to
+// list of ElementTs in that tile.
+template <typename ElementT> class ElementXYRoot : public Item
{
public:
- ContextTreeItem();
- ContextTreeItem(QString name);
- ContextTreeItem(IdString id, ElementType type, QString name);
- ~ContextTreeItem();
-
- void addChild(ContextTreeItem *item);
- int indexOf(ContextTreeItem *n) const { return children.indexOf(n); }
- ContextTreeItem *at(int idx) const { return children.at(idx); }
- int count() const { return children.count(); }
- ContextTreeItem *parent() const { return parentNode; }
- IdString id() const { return itemId; }
- ElementType type() const { return itemType; }
- QString name() const { return itemName; }
- void sort();
+ // A map from tile (X,Y) to list of ElementTs in that tile.
+ using ElementMap = std::map<std::pair<int, int>, std::vector<ElementT>>;
+ // A method that converts an ElementT to an IdString.
+ using ElementGetter = std::function<IdString(Context *, ElementT)>;
+
private:
- ContextTreeItem *parentNode;
- QList<ContextTreeItem *> children;
- IdString itemId;
- ElementType itemType;
- QString itemName;
+ Context *ctx_;
+ // X-index children that we manage the memory for.
+ std::vector<std::unique_ptr<Item>> managed_labels_;
+ // Y-index children (ElementLists) that we manage the memory for.
+ std::vector<std::unique_ptr<ElementList<ElementT>>> managed_lists_;
+ // Source of truth for elements to display.
+ ElementMap map_;
+ ElementGetter getter_;
+ // Type of children that he list creates in X->Y->...
+ ElementType child_type_;
+
+ public:
+ ElementXYRoot(Context *ctx, QString name, Item *parent, ElementMap map, ElementGetter getter, ElementType type)
+ : Item(name, parent), ctx_(ctx), map_(map), getter_(getter), child_type_(type)
+ {
+ // Create all X and Y label Items/ElementLists.
+
+ // Y coordinates at which an element exists for a given X - taken out
+ // of loop to limit heap allocation/deallocation.
+ std::vector<int> y_present;
+
+ for (int i = 0; i < ctx->getGridDimX(); i++) {
+ y_present.clear();
+ // First find all the elements in all Y coordinates in this X.
+ for (int j = 0; j < ctx->getGridDimY(); j++) {
+ if (map_.count(std::make_pair(i, j)) == 0)
+ continue;
+ y_present.push_back(j);
+ }
+ // No elements in any X coordinate? Do not add X tree item.
+ if (y_present.size() == 0)
+ continue;
+
+ // Create X list Item.
+ auto item = new Item(QString("X%1").arg(i), this);
+ managed_labels_.push_back(std::move(std::unique_ptr<Item>(item)));
+
+ for (auto j : y_present) {
+ // Create Y list ElementList.
+ auto item2 =
+ new ElementList<ElementT>(ctx_, QString("Y%1").arg(j), item, &map_, i, j, getter_, child_type_);
+ // Pre-populate list with one element, other Qt will never ask for more.
+ item2->fetchMore(1);
+ managed_lists_.push_back(std::move(std::unique_ptr<ElementList<ElementT>>(item2)));
+ }
+ }
+ }
+
+ // getById finds a child for the given IdString.
+ boost::optional<Item *> getById(IdString id)
+ {
+ // For now, scan linearly all ElementLists.
+ // TODO(q3k) fix this once we have tree API from arch
+ for (auto &l : managed_lists_) {
+ auto res = l->getById(id);
+ if (res) {
+ return res;
+ }
+ }
+ return boost::none;
+ }
+
+ // Find children that contain the given text.
+ void search(QList<Item *> &results, QString text, int limit)
+ {
+ for (auto &l : managed_lists_) {
+ if (limit != -1 && results.size() > limit)
+ return;
+ l->search(results, text, limit);
+ }
+ }
};
-class ContextTreeModel : public QAbstractItemModel
+class Model : public QAbstractItemModel
{
+ private:
+ Context *ctx_ = nullptr;
+
public:
- ContextTreeModel(QObject *parent = nullptr);
- ~ContextTreeModel();
-
- void loadData(Context *ctx);
- void updateData(Context *ctx);
- ContextTreeItem *nodeFromIndex(const QModelIndex &idx) const;
- QModelIndex indexFromNode(ContextTreeItem *node);
- ContextTreeItem *nodeForIdType(const ElementType type, const QString name) const;
+ using BelXYRoot = ElementXYRoot<BelId>;
+ using WireXYRoot = ElementXYRoot<WireId>;
+ using PipXYRoot = ElementXYRoot<PipId>;
+
+ Model(QObject *parent = nullptr);
+ ~Model();
+
+ void loadContext(Context *ctx);
+ void updateCellsNets(Context *ctx);
+ Item *nodeFromIndex(const QModelIndex &idx) const;
+ QModelIndex indexFromNode(Item *node)
+ {
+ const Item *parent = node->parent();
+ if (parent == nullptr)
+ return QModelIndex();
+
+ return createIndex(parent->indexOf(node), 0, node);
+ }
+
QList<QModelIndex> search(QString text);
+
+ boost::optional<Item *> nodeForIdType(ElementType type, IdString id) const
+ {
+ switch (type) {
+ case ElementType::BEL:
+ if (bel_root_ == nullptr)
+ return boost::none;
+ return bel_root_->getById(id);
+ case ElementType::WIRE:
+ if (wire_root_ == nullptr)
+ return boost::none;
+ return wire_root_->getById(id);
+ case ElementType::PIP:
+ if (pip_root_ == nullptr)
+ return boost::none;
+ return pip_root_->getById(id);
+ case ElementType::CELL:
+ return cell_root_->getById(id);
+ case ElementType::NET:
+ return net_root_->getById(id);
+ default:
+ return boost::none;
+ }
+ }
+
// Override QAbstractItemModel methods
int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
int columnCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
@@ -81,14 +391,21 @@ class ContextTreeModel : public QAbstractItemModel
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const Q_DECL_OVERRIDE;
QVariant headerData(int section, Qt::Orientation orientation, int role) const Q_DECL_OVERRIDE;
Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE;
+ void fetchMore(const QModelIndex &parent) Q_DECL_OVERRIDE;
+ bool canFetchMore(const QModelIndex &parent) const Q_DECL_OVERRIDE;
private:
- ContextTreeItem *root;
- QMap<QString, ContextTreeItem *> nameToItem[6];
- ContextTreeItem *nets_root;
- ContextTreeItem *cells_root;
+ // Tree elements that we manage the memory for.
+ std::unique_ptr<Item> root_;
+ std::unique_ptr<BelXYRoot> bel_root_;
+ std::unique_ptr<WireXYRoot> wire_root_;
+ std::unique_ptr<PipXYRoot> pip_root_;
+ std::unique_ptr<IdStringList> cell_root_;
+ std::unique_ptr<IdStringList> net_root_;
};
+}; // namespace TreeModel
+
NEXTPNR_NAMESPACE_END
#endif // TREEMODEL_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-05 05:13:58 +0000