aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--qtmips_gui/mainwindow.cpp1
-rw-r--r--qtmips_gui/memorydock.cpp37
-rw-r--r--qtmips_gui/memorydock.h17
-rw-r--r--qtmips_gui/memoryview.cpp162
-rw-r--r--qtmips_gui/memoryview.h51
-rw-r--r--qtmips_gui/programdock.cpp106
-rw-r--r--qtmips_gui/programdock.h31
-rw-r--r--qtmips_gui/statictable.cpp125
-rw-r--r--qtmips_gui/statictable.h27
9 files changed, 432 insertions, 125 deletions
diff --git a/qtmips_gui/mainwindow.cpp b/qtmips_gui/mainwindow.cpp
index c064509..0f5d11a 100644
--- a/qtmips_gui/mainwindow.cpp
+++ b/qtmips_gui/mainwindow.cpp
@@ -104,6 +104,7 @@ void MainWindow::create_core(const machine::MachineConfig &config) {
// Setup docks
registers->setup(machine);
program->setup(machine);
+ memory->setup(machine);
// Set status to ready
machine_status(machine::QtMipsMachine::ST_READY);
}
diff --git a/qtmips_gui/memorydock.cpp b/qtmips_gui/memorydock.cpp
index 8998b32..d0bad9c 100644
--- a/qtmips_gui/memorydock.cpp
+++ b/qtmips_gui/memorydock.cpp
@@ -1,22 +1,35 @@
#include "memorydock.h"
+DataView::DataView(QWidget *parent) : MemoryView(parent) { }
+
+QList<QWidget*> DataView::row_widget(std::uint32_t address, QWidget *parent) {
+ QList<QWidget*> widgs;
+ QLabel *l;
+
+ l = new QLabel(QString("0x%1").arg(address, 8, 16, QChar('0')), parent);
+ l->setTextInteractionFlags(Qt::TextSelectableByMouse);
+ widgs.append(l);
+
+ l = new QLabel(parent);
+ l->setTextInteractionFlags(Qt::TextSelectableByMouse);
+ if (memory != nullptr) {
+ l->setText(QString("0x%1").arg(memory->read_word(address), 8, 16, QChar('0')));
+ }
+ else
+ l->setText(" "); // Just fill it in with some plain text so we don't have just addresses there
+ widgs.append(l);
+
+ return widgs;
+}
+
MemoryDock::MemoryDock(QWidget *parent) : QDockWidget(parent) {
- memory_view = new MemoryView(this);
- setWidget(memory_view);
+ view = new DataView(this);
+ setWidget(view);
setObjectName("Memory");
setWindowTitle("Memory");
}
-MemoryDock::~MemoryDock() {
- delete memory_view;
-}
-
void MemoryDock::setup(machine::QtMipsMachine *machine) {
- if (machine == nullptr)
- // TODO reset memory view
- return;
-
- // TODO setup memory view
-
+ view->setup(machine);
}
diff --git a/qtmips_gui/memorydock.h b/qtmips_gui/memorydock.h
index 533451e..612f986 100644
--- a/qtmips_gui/memorydock.h
+++ b/qtmips_gui/memorydock.h
@@ -2,19 +2,32 @@
#define MEMORYDOCK_H
#include <QDockWidget>
+#include <QLabel>
+#include <QComboBox>
#include "qtmipsmachine.h"
#include "memoryview.h"
+class DataView : public MemoryView {
+ Q_OBJECT
+public:
+ DataView(QWidget *parent);
+
+protected:
+ QList<QWidget*> row_widget(std::uint32_t address, QWidget *parent);
+
+private:
+ QComboBox *cb_size;
+};
+
class MemoryDock : public QDockWidget {
Q_OBJECT
public:
MemoryDock(QWidget *parent);
- ~MemoryDock();
void setup(machine::QtMipsMachine *machine);
private:
- MemoryView *memory_view;
+ DataView *view;
};
#endif // MEMORYDOCK_H
diff --git a/qtmips_gui/memoryview.cpp b/qtmips_gui/memoryview.cpp
index bd5d6d8..c391169 100644
--- a/qtmips_gui/memoryview.cpp
+++ b/qtmips_gui/memoryview.cpp
@@ -1,47 +1,167 @@
#include "memoryview.h"
+///////////////////////////
+// Minimal reserved range in pixels of scroll area (otherwise 10% of height are used)
+#define MIN_OFF 10
+///////////////////////////
+
+#include <iostream>
+using namespace std;
+
MemoryView::MemoryView(QWidget *parent) : QWidget(parent) {
+ memory = nullptr;
+ addr_0 = 0;
+
layout = new QVBoxLayout(this);
- frame = new QFrame(this);
- frame->setFrameShadow(QFrame::Sunken);
- frame->setFrameShape(QFrame::StyledPanel);
- frame->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- // TODO
- layout->addWidget(frame);
+ memf= new Frame(this);
+ layout->addWidget(memf);
- go_edit = new QLineEdit(this);
+
+ ctl_widg = new QWidget(this);
+ layout->addWidget(ctl_widg);
+
+ ctl_layout = new QHBoxLayout(ctl_widg);
+ go_edit = new QLineEdit(ctl_widg);
go_edit->setText("0x00000000");
go_edit->setInputMask("\\0\\xHHHHHHHH");
- layout->addWidget(go_edit);
+ ctl_layout->addWidget(go_edit);
connect(go_edit, SIGNAL(editingFinished()), this, SLOT(go_edit_finish()));
-
+ up = new QToolButton(ctl_widg);
+ up->setArrowType(Qt::UpArrow);
+ ctl_layout->addWidget(up);
+ down = new QToolButton(ctl_widg);
+ down->setArrowType(Qt::DownArrow);
+ ctl_layout->addWidget(down);
}
-MemoryView::~MemoryView() {
- delete go_edit;
- delete frame;
- delete layout;
+void MemoryView::setup(machine::QtMipsMachine *machine) {
+ memory = (machine == nullptr) ? nullptr : machine->memory();
+ reload_content();
}
-void MemoryView::set_center(std::uint32_t address) {
- center_addr = address;
+void MemoryView::set_focus(std::uint32_t address) {
+ // TODO center
// TODO update view
}
-std::uint32_t MemoryView::center() {
- return center_addr;
+std::uint32_t MemoryView::focus() {
+ // TODO
+ return 0;
+}
+
+void MemoryView::reload_content() {
+ int count = memf->widg->count();
+ memf->widg->clearRows();
+ update_content(count, 0);
+}
+
+void MemoryView::update_content(int count, int shift) {
+ if (abs(shift) >= memf->widg->count()) {
+ // This shifts more than we have so just reload whole content
+ memf->widg->clearRows();
+ addr_0 += 4*shift;
+ for (int i = 0; i <= count; i++)
+ memf->widg->addRow(row_widget(addr_0 + 4*i, memf->widg));
+ return;
+ }
+
+ int diff = count - memf->widg->count();
+ int d_b = shift;
+ int d_e = diff - shift;
+ cout << "count:" << memf->widg->count() << " tocount:" << count << " d_b:" << d_b << " d_e:" << d_e << endl;
+
+ if (d_b > 0)
+ for (int i = 0; i < d_b; i++) {
+ addr_0 -= 4;
+ memf->widg->insertRow(row_widget(addr_0, memf->widg), 0);
+ }
+ else
+ for (int i = 0; i > d_b; i--) {
+ addr_0 += 4;
+ memf->widg->removeRow(0);
+ }
+ if (d_e > 0)
+ for (int i = 0; i < d_e; i++)
+ memf->widg->addRow(row_widget(addr_0 + 4*memf->widg->count(), memf->widg));
+ else
+ for (int i = 0; i > d_e; i--)
+ memf->widg->removeRow(memf->widg->count() - 1);
}
-void MemoryView::resizeEvent(QResizeEvent *event) {
- QWidget::resizeEvent(event);
+void MemoryView::go_edit_finish() {
// TODO
}
-void MemoryView::wheelEvent(QWheelEvent *event) {
+MemoryView::Frame::Frame(MemoryView *parent) : QAbstractScrollArea(parent) {
+ mv = parent;
+ content_y = -3*MIN_OFF/2; // When this is initialized the width is 0 so this uses just min to inialize it
+
+ widg = new StaticTable(this);
+ setViewport(widg);
+
+ setFrameShadow(QFrame::Sunken);
+ setFrameShape(QFrame::StyledPanel);
+ setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ setContentsMargins(0, 0, 0, 0);
+}
+
+void MemoryView::Frame::focus(unsigned i) {
// TODO
}
-void MemoryView::go_edit_finish() {
+unsigned MemoryView::Frame::focussed() {
// TODO
+ return 0;
+}
+
+// This verifies that we are not scrolled too far away down or up and that we have enought height
+// We make 10% of height as buffer zone with fixed minimum in pixels
+void MemoryView::Frame::check_update() {
+ int hpart = qMax(height()/10, MIN_OFF);
+ int req_height = height() + 2*hpart;
+
+ while (!((content_y <= -hpart) && (content_y >= -2*hpart)) || (widg->height() < req_height)) {
+ cout << "widg.h:" << widg->height() << " req_h:" << req_height << endl;
+ cout << "content_y:" << content_y << " hpart:" << hpart << endl;
+ int row_h = widg->row_size();
+ cout << "row_h:" << row_h << " columns:" << widg->columns() << endl;
+ // Calculate how many we need and how much we need to move and update content accordingly
+ int count = (req_height / row_h) + 1;
+ int shift = (content_y + hpart + hpart/2)/row_h;
+ mv->update_content(count * widg->columns(), shift * widg->columns());
+ cout << "count:" << count << endl;
+ // Move and resize widget
+ content_y -= shift * row_h;
+ widg->setGeometry(0, content_y, width(), widg->heightForWidth(width()));
+ }
+}
+
+void MemoryView::Frame::resizeEvent(QResizeEvent *e) {
+ QAbstractScrollArea::resizeEvent(e);
+ widg->setGeometry(0, content_y, e->size().width(), widg->heightForWidth(e->size().width()));
+ check_update();
+}
+
+void MemoryView::Frame::wheelEvent(QWheelEvent *e) {
+ QPoint pix = e->pixelDelta();
+ QPoint ang = e->angleDelta();
+
+ if (!pix.isNull())
+ content_y += e->pixelDelta().ry();
+ // TODO angle scroll
+
+ // TODO smooth scroll
+ viewport()->move(0, content_y);
+ viewport()->repaint(0, content_y, width(), height());
+
+ check_update();
+}
+
+bool MemoryView::Frame::viewportEvent(QEvent *e) {
+ bool p = QAbstractScrollArea::viewportEvent(e);
+ // Pass paint event to viewport widget
+ if (e->type() == QEvent::Paint)
+ p = false;
+ return p;
}
diff --git a/qtmips_gui/memoryview.h b/qtmips_gui/memoryview.h
index e1049e8..be2c8a2 100644
--- a/qtmips_gui/memoryview.h
+++ b/qtmips_gui/memoryview.h
@@ -2,35 +2,68 @@
#define MEMORYVIEW_H
#include <QWidget>
-#include <QFrame>
+#include <QAbstractScrollArea>
#include <QBoxLayout>
+#include <QGridLayout>
#include <QLineEdit>
+#include <QToolButton>
+#include <QList>
+#include <QVector>
#include <cstdint>
+#include <QResizeEvent>
+#include "qtmipsmachine.h"
+#include "statictable.h"
class MemoryView : public QWidget {
+ Q_OBJECT
public:
MemoryView(QWidget *parent = nullptr);
- ~MemoryView();
- void set_center(std::uint32_t address);
- std::uint32_t center();
+ virtual void setup(machine::QtMipsMachine*);
+
+ void set_focus(std::uint32_t address);
+ std::uint32_t focus();
protected:
- //virtual QWidget *row_widget(std::uint32_t address) = 0;
+ const machine::Memory *memory;
- void resizeEvent(QResizeEvent *event);
- void wheelEvent(QWheelEvent *event);
+ virtual QList<QWidget*> row_widget(std::uint32_t address, QWidget *parent) = 0;
QVBoxLayout *layout;
+ void reload_content(); // reload displayed data
+ void update_content(int count, int shift); // update content to match given count and shift
+
private slots:
void go_edit_finish();
private:
- std::uint32_t center_addr;
+ unsigned count;
+ std::uint32_t addr_0; // First address in view
+
+ class Frame : public QAbstractScrollArea {
+ public:
+ Frame(MemoryView *parent);
+
+ StaticTable *widg;
+ void focus(unsigned i); // Focus on given item in widget
+ unsigned focussed(); // What item is in focus
+ void check_update(); // Update widget size and content if needed
+
+ protected:
+ MemoryView *mv;
+ int content_y;
+
+ bool viewportEvent(QEvent*);
+ void resizeEvent(QResizeEvent*);
+ void wheelEvent(QWheelEvent *event);
+ };
+ Frame *memf;
- QFrame *frame;
+ QWidget *ctl_widg;
+ QHBoxLayout *ctl_layout;
QLineEdit *go_edit;
+ QToolButton *up, *down;
};
#endif // MEMORYVIEW_H
diff --git a/qtmips_gui/programdock.cpp b/qtmips_gui/programdock.cpp
index c885083..9178dce 100644
--- a/qtmips_gui/programdock.cpp
+++ b/qtmips_gui/programdock.cpp
@@ -1,26 +1,21 @@
#include "programdock.h"
#include "qtmipsexception.h"
-ProgramDock::ProgramDock(QWidget *parent) : QDockWidget(parent) {
- widg = new QWidget(this);
- widg_layout = new QBoxLayout(QBoxLayout::TopToBottom, widg);
- widg_layout->setSizeConstraint(QLayout::SetMinAndMaxSize);
-
- memory_view = new MemoryView(widg);
- widg_layout->addWidget(memory_view);
+ProgramView::ProgramView(QWidget *parent) : MemoryView(parent) {
+ set_center(0x80020000); // Initialize center address to program start
- ctlbox_single = new QComboBox(widg);
- ctlbox_single->addItems({
+ cb_single = new QComboBox(this);
+ cb_single->addItems({
"Don't follow",
"Follow executing instruction"
});
- ctlbox_single->setCurrentIndex(1);
- ctlbox_single->hide();
- widg_layout->addWidget(ctlbox_single);
- connect(ctlbox_single, SIGNAL(currentIndexChanged(int)), this, SLOT(ctlbox_single_changed(int)));
+ cb_single->setCurrentIndex(1);
+ cb_single->hide();
+ layout->addWidget(cb_single);
+ connect(cb_single, SIGNAL(currentIndexChanged(int)), this, SLOT(cb_single_changed(int)));
- ctlbox_pipelined = new QComboBox(widg);
- ctlbox_pipelined->addItems({
+ cb_pipelined = new QComboBox(this);
+ cb_pipelined->addItems({
"Don't follow",
"Follow Instruction fetch stage",
"Follow Instruction decode stage",
@@ -28,51 +23,68 @@ ProgramDock::ProgramDock(QWidget *parent) : QDockWidget(parent) {
"Follow Memory access stage",
"Follow Registers write back stage",
});
- ctlbox_pipelined->hide();
- ctlbox_pipelined->setCurrentIndex(1);
- widg_layout->addWidget(ctlbox_pipelined);
- connect(ctlbox_pipelined, SIGNAL(currentIndexChanged(int)), this, SLOT(ctlbox_pipelined_changed(int)));
-
- setWidget(widg);
- setObjectName("Program");
- setWindowTitle("Program");
-}
-
-ProgramDock::~ProgramDock() {
- delete memory_view;
- delete ctlbox_single;
- delete ctlbox_pipelined;
- delete widg_layout;
- delete widg;
+ cb_pipelined->hide();
+ cb_pipelined->setCurrentIndex(1);
+ layout->addWidget(cb_pipelined);
+ connect(cb_pipelined, SIGNAL(currentIndexChanged(int)), this, SLOT(cb_pipelined_changed(int)));
}
-void ProgramDock::setup(machine::QtMipsMachine *machine) {
- if (machine == nullptr) {
- // TODO zero memory viewer
+void ProgramView::setup(machine::QtMipsMachine *machine) {
+ MemoryView::setup(machine);
+ if (machine == nullptr)
return;
- }
-
- // TODO pass to viewer
bool pipelined = machine->config().pipelined();
- ctlbox_single->setVisible(!pipelined);
- ctlbox_pipelined->setVisible(pipelined);
+ cb_single->setVisible(!pipelined);
+ cb_pipelined->setVisible(pipelined);
// Sync selection somewhat
if (pipelined) {
- if (ctlbox_single->currentIndex() == 0)
- ctlbox_pipelined->setCurrentIndex(0);
- else if (ctlbox_pipelined->currentIndex() == 0)
- ctlbox_pipelined->setCurrentIndex(1);
+ if (cb_single->currentIndex() == 0)
+ cb_pipelined->setCurrentIndex(0);
+ else if (cb_pipelined->currentIndex() == 0)
+ cb_pipelined->setCurrentIndex(1);
} else
- ctlbox_single->setCurrentIndex(ctlbox_pipelined->currentIndex() == 0 ? 0 : 1);
+ cb_single->setCurrentIndex(cb_pipelined->currentIndex() == 0 ? 0 : 1);
+}
+
+QList<QWidget*> ProgramView::row_widget(std::uint32_t address, QWidget *parent) {
+ QList<QWidget*> widgs;
+ QLabel *l;
+
+ l = new QLabel(" ", parent);
+ widgs.append(l);
- // TODO also update current setting of memory viewer
+ l = new QLabel(QString("0x%1").arg(address, 8, 16, QChar('0')), parent);
+ l->setTextInteractionFlags(Qt::TextSelectableByMouse);
+ widgs.append(l);
+
+ l = new QLabel(parent);
+ l->setTextInteractionFlags(Qt::TextSelectableByMouse);
+ if (memory != nullptr)
+ l->setText(machine::Instruction(memory->read_word(address)).to_str());
+ else
+ l->setText(" "); // Just fill it in with some plain text so we don't have just addresses there
+ widgs.append(l);
+
+ return widgs;
}
-void ProgramDock::ctlbox_single_changed(int index) {
+void ProgramView::cb_single_changed(int index) {
// TODO set memory view
}
-void ProgramDock::ctlbox_pipelined_changed(int index) {
+void ProgramView::cb_pipelined_changed(int index) {
// TODO set memory view
}
+
+ProgramDock::ProgramDock(QWidget *parent) : QDockWidget(parent) {
+ view = new ProgramView(this);
+ setWidget(view);
+
+ setObjectName("Program");
+ setWindowTitle("Program");
+}
+
+void ProgramDock::setup(machine::QtMipsMachine *machine) {
+ view->setup(machine);
+}
diff --git a/qtmips_gui/programdock.h b/qtmips_gui/programdock.h
index 4605a7b..9ed0896 100644
--- a/qtmips_gui/programdock.h
+++ b/qtmips_gui/programdock.h
@@ -9,25 +9,34 @@
#include "qtmipsmachine.h"
#include "memoryview.h"
-class ProgramDock : public QDockWidget {
+class ProgramView : public MemoryView {
Q_OBJECT
public:
- ProgramDock(QWidget *parent);
- ~ProgramDock();
+ ProgramView(QWidget *parent);
- void setup(machine::QtMipsMachine *machine);
+ void setup(machine::QtMipsMachine*);
+
+protected:
+ QList<QWidget*> row_widget(std::uint32_t address, QWidget *parent);
private slots:
- void ctlbox_single_changed(int index);
- void ctlbox_pipelined_changed(int index);
+ void cb_single_changed(int index);
+ void cb_pipelined_changed(int index);
private:
- QWidget *widg;
- QBoxLayout *widg_layout;
+ QComboBox *cb_single;
+ QComboBox *cb_pipelined;
+};
- MemoryView *memory_view;
- QComboBox *ctlbox_single;
- QComboBox *ctlbox_pipelined;
+class ProgramDock : public QDockWidget {
+ Q_OBJECT
+public:
+ ProgramDock(QWidget *parent);
+
+ void setup(machine::QtMipsMachine *machine);
+
+private:
+ ProgramView *view;
};
#endif // PROGRAMDOCK_H
diff --git a/qtmips_gui/statictable.cpp b/qtmips_gui/statictable.cpp
index 8686847..fe8a820 100644
--- a/qtmips_gui/statictable.cpp
+++ b/qtmips_gui/statictable.cpp
@@ -3,6 +3,7 @@
#include <qtmipsexception.h>
#include <iostream>
+#include <QLabel>
using namespace std;
StaticTableLayout::StaticTableLayout(QWidget *parent, int margin, int horizontal_big_spacing, int horizontal_small_spacing, int vertical_spacing) : QLayout(parent) {
@@ -29,21 +30,28 @@ bool StaticTableLayout::hasHeightForWidth() const {
}
int StaticTableLayout::heightForWidth(int w) const {
- // TODO cache value
- return layout_height(w);
+ if (cch_heightForWidth.w != w || cch_heightForWidth.count != items.count())
+ cch_heightForWidth.width = layout_height(w);
+ cch_heightForWidth.w = w;
+ cch_heightForWidth.count = items.count();
+ return cch_heightForWidth.width;
}
QSize StaticTableLayout::minimumSize() const {
- QSize s;
+ if (cch_minSize.count == items.size())
+ return cch_minSize.size;
+ cch_minSize.count = items.size();
+
+ cch_minSize.size = QSize();
for (int i = 0; i < items.size(); i++) {
QSize ss;
for (int y = 0; y < items[i].size(); y++) {
- ss = s.expandedTo(items[i][y]->minimumSize() + QSize(shspace, 0));
+ ss = cch_minSize.size.expandedTo(items[i][y]->minimumSize() + QSize(shspace, 0));
}
- s = s.expandedTo(ss - QSize(shspace, 0));
+ cch_minSize.size = cch_minSize.size.expandedTo(ss - QSize(shspace, 0));
}
- s += QSize(2*margin(), 2*margin());
- return s;
+ cch_minSize.size += QSize(2*margin(), 2*margin());
+ return cch_minSize.size;
}
void StaticTableLayout::setGeometry(const QRect &rect) {
@@ -72,13 +80,28 @@ int StaticTableLayout::count() const {
}
void StaticTableLayout::addRow(QList<QWidget*> w) {
- QVector<QLayoutItem*> v;
- for (int i = 0; i < w.size(); i++) {
- addChildWidget(w[i]);
- v.append(new QWidgetItem(w[i]));
+ items.append(list2vec(w));
+}
+
+void StaticTableLayout::insertRow(QList<QWidget*> w, int i) {
+ items.insert(i, list2vec(w));
+}
+
+void StaticTableLayout::removeRow(int i) {
+ for (int y = 0; y < items[i].size(); y++) {
+ delete items[i][y]->widget();
+ delete items[i][y];
}
+ items.remove(i);
+}
- items.append(v);
+void StaticTableLayout::clearRows() {
+ for (int i = 0; i < items.size(); i++)
+ for (int y = 0; y < items[i].size(); y++) {
+ delete items[i][y]->widget();
+ delete items[i][y];
+ }
+ items.clear();
}
void StaticTableLayout::itemRect(QRect &rect, QVector<int> &separators, int i) {
@@ -100,7 +123,6 @@ void StaticTableLayout::itemRect(QRect &rect, QVector<int> &separators, int i) {
x -= bhspace/2;
int y = top + (row * (row_height + vspace));
-
int width = 0;
for (int t = 0; t < row_widths[col].size(); t++) {
width += row_widths[col][t] + shspace;
@@ -117,14 +139,32 @@ int StaticTableLayout::columns() {
return row_widths.size();
}
+int StaticTableLayout::real_row_height() {
+ return row_height + vspace;
+}
+
int StaticTableLayout::layout_count_approx(const QRect &rect) const {
if (items.size() <= 0)
return 1;
+ // Note: for some reason (probably optimalisation) when qlabel is not visible it reports 0 size. So we have to found at least one that is visible
+ int vis = 0;
+ while (items[vis].size() <= 0 || !items[vis][0]->widget()->isVisible()) {
+ vis++;
+ if (vis >= items.size())
+ return 1; // If non is visible then just say that it has to be single column
+ }
+
int w = 0;
- for (int i = 0; i < items[0].size(); i++)
- w += items[0][i]->sizeHint().width() + shspace;
+ for (int i = 0; i < items[vis].size(); i++)
+ w += items[vis][i]->sizeHint().width() + shspace;
w -= shspace; // subtract lastest spacing
int width = rect.right() / w; // Note: this always rounds down so this always founds maximal possible count
+
+ cout << "ST: widht:" << rect.right() << " row_w" << w << " so count:" << width << " we have:" << items.count() << " In 0:" << items[vis].count() << " contains:";
+ for (int i = 0; i < items[0].size(); i++)
+ cout << ((QLabel*)items[0][i]->widget())->text().toStdString() << " ";
+ cout << endl;
+
return width <= 0 ? 1 : width; // We have to fit at least one column
}
@@ -164,22 +204,24 @@ void StaticTableLayout::layout_parms(QRect &rect, int &row_h, QList<QList<int>>
// Firt let's do orientation count only on first line
count = layout_count_approx(rect);
- if (layout_size(row_h, row_w, count) > rect.right()) {
+ while (layout_size(row_h, row_w, count) > rect.right() && count > 1) {
// Not using orientation count go down if we can't fit (if we can then just be happy with what we have)
- do {
- if (count <= 1)
- // TODO meaby warning?
- break; // We can't fit it but ignore that.
- count--;
- } while (layout_size(row_h, row_w, count) <= rect.width());
+ count--;
}
}
void StaticTableLayout::do_layout(const QRect &rect) {
+ if (cch_do_layout.size == rect.size() && cch_do_layout.count == items.size())
+ // No effective change so don't do layout
+ return;
+ cch_do_layout.size = rect.size();
+ cch_do_layout.count = items.size();
+
int row_h;
QList<QList<int>> row_w;
int count;
+ cout << "Doing layout" << endl;
QRect reff(rect);
layout_parms(reff, row_h, row_w, count);
@@ -202,6 +244,7 @@ void StaticTableLayout::do_layout(const QRect &rect) {
}
int StaticTableLayout::layout_height(int width) const {
+ cout << "Quering height" << endl;
QRect reff(0, 0, width, 0);
int row_h;
QList<QList<int>> row_w;
@@ -211,15 +254,51 @@ int StaticTableLayout::layout_height(int width) const {
return (row_h + vspace) * (items.size() / count);
}
+QVector<QLayoutItem*> StaticTableLayout::list2vec(QList<QWidget*> w) {
+ QVector<QLayoutItem*> v;
+ for (int i = 0; i < w.size(); i++) {
+ addChildWidget(w[i]);
+ v.append(new QWidgetItem(w[i]));
+ }
+ return v;
+}
+
StaticTable::StaticTable(QWidget *parent) : QWidget(parent), layout(this) {
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
}
+int StaticTable::count() {
+ return layout.count();
+}
+
void StaticTable::addRow(QList<QWidget*> w) {
layout.addRow(w);
}
+void StaticTable::insertRow(QList<QWidget*> w, int i) {
+ layout.insertRow(w, i);
+}
+
+void StaticTable::removeRow(int i) {
+ layout.removeRow(i);
+}
+
+void StaticTable::clearRows() {
+ layout.clearRows();
+}
+
+int StaticTable::columns() {
+ return qMax(layout.columns(), 1);
+}
+
+int StaticTable::row_size() {
+ return layout.real_row_height();
+}
+
void StaticTable::paintEvent(QPaintEvent*) {
+ if (layout.columns() <= 0) // Don't paint unless we have at least one column
+ return;
+
QPainter p(this);
p.setPen(QPen(QColor(200, 200, 200)));
@@ -232,7 +311,7 @@ void StaticTable::paintEvent(QPaintEvent*) {
if ((col % 2) == (row % 2))
p.setBrush(QBrush(QColor(255, 255, 255)));
else
- p.setBrush(QBrush(QColor(230, 230, 230)));
+ p.setBrush(QBrush(QColor(235, 235, 235)));
layout.itemRect(rect, separators, i);
diff --git a/qtmips_gui/statictable.h b/qtmips_gui/statictable.h
index 8248aa3..9249430 100644
--- a/qtmips_gui/statictable.h
+++ b/qtmips_gui/statictable.h
@@ -31,9 +31,13 @@ public:
int count() const override; // This returns number of item blocks
void addRow(QList<QWidget*>); // This adds row of widgets
+ void insertRow(QList<QWidget*>, int i); // Insert row to given position while shifting all other up
+ void removeRow(int i); // Remove row
+ void clearRows(); // Clear all rows from table
void itemRect(QRect &rect, QVector<int> &separators, int i); // This returns single item rectable (if expad_margin and it's on edge also count in margin)
int columns();
+ int real_row_height();
protected:
int shspace, bhspace, vspace;
@@ -47,13 +51,36 @@ protected:
void layout_parms(QRect &rect, int &row_h, QList<QList<int>> &row_w, int &count) const;
void do_layout(const QRect &rect);
int layout_height(int width) const;
+
+ QVector<QLayoutItem*> list2vec(QList<QWidget*>);
+
+ struct {
+ QSize size;
+ int count;
+ } cch_do_layout;
+ mutable struct {
+ int w, count;
+ int width;
+ } cch_heightForWidth;
+ mutable struct {
+ int count;
+ QSize size;
+ } cch_minSize;
+
};
class StaticTable : public QWidget {
public:
StaticTable(QWidget *parent = nullptr);
+ int count();
void addRow(QList<QWidget*>);
+ void insertRow(QList<QWidget*>, int i);
+ void removeRow(int i);
+ void clearRows();
+
+ int columns();
+ int row_size(); // return real row size (height) including spacing
protected:
void paintEvent(QPaintEvent*);