cutter/src/widgets/GraphView.cpp

566 lines
15 KiB
C++
Raw Normal View History

#include "GraphView.h"
#include "GraphGridLayout.h"
#include <vector>
#include <QPainter>
#include <QMouseEvent>
#include <QKeyEvent>
#include <QPropertyAnimation>
2019-04-07 10:53:42 +00:00
#ifndef QT_NO_OPENGL
#include <QOpenGLContext>
#include <QOpenGLWidget>
#include <QOpenGLPaintDevice>
#include <QOpenGLExtraFunctions>
#endif
GraphView::GraphView(QWidget *parent)
: QAbstractScrollArea(parent)
, graphLayoutSystem(new GraphGridLayout())
2019-04-07 10:53:42 +00:00
, useGL(false)
#ifndef QT_NO_OPENGL
, cacheTexture(0)
, cacheFBO(0)
#endif
{
2019-04-07 10:53:42 +00:00
#ifndef QT_NO_OPENGL
if (useGL) {
glWidget = new QOpenGLWidget(this);
setViewport(glWidget);
} else {
glWidget = nullptr;
}
#endif
}
GraphView::~GraphView()
{
// TODO: Cleanups
}
// Callbacks
2018-03-21 20:32:32 +00:00
void GraphView::drawBlock(QPainter &p, GraphView::GraphBlock &block)
{
Q_UNUSED(p);
Q_UNUSED(block);
qWarning() << "Draw block not overriden!";
}
void GraphView::blockClicked(GraphView::GraphBlock &block, QMouseEvent *event, QPoint pos)
{
Q_UNUSED(block);
Q_UNUSED(event);
Q_UNUSED(pos);
qWarning() << "Block clicked not overridden!";
}
2017-12-14 21:07:48 +00:00
void GraphView::blockDoubleClicked(GraphView::GraphBlock &block, QMouseEvent *event, QPoint pos)
{
Q_UNUSED(block);
Q_UNUSED(event);
Q_UNUSED(pos);
qWarning() << "Block double clicked not overridden!";
}
void GraphView::blockHelpEvent(GraphView::GraphBlock &block, QHelpEvent *event, QPoint pos)
{
Q_UNUSED(block);
Q_UNUSED(event);
Q_UNUSED(pos);
}
bool GraphView::helpEvent(QHelpEvent *event)
{
int x = event->pos().x() + offset.x();
int y = event->pos().y() - offset.y();
2018-03-21 20:32:32 +00:00
for (auto &blockIt : blocks) {
GraphBlock &block = blockIt.second;
2018-03-21 20:32:32 +00:00
if ((block.x <= x) && (block.y <= y) &&
(x <= block.x + block.width) & (y <= block.y + block.height)) {
QPoint pos = QPoint(x - block.x, y - block.y);
blockHelpEvent(block, event, pos);
return true;
}
}
return false;
}
void GraphView::blockTransitionedTo(GraphView::GraphBlock *to)
{
Q_UNUSED(to);
qWarning() << "blockTransitionedTo not overridden!";
}
2018-03-21 20:32:32 +00:00
GraphView::EdgeConfiguration GraphView::edgeConfiguration(GraphView::GraphBlock &from,
GraphView::GraphBlock *to)
{
Q_UNUSED(from);
Q_UNUSED(to);
qWarning() << "Edge configuration not overridden!";
EdgeConfiguration ec;
return ec;
}
bool GraphView::event(QEvent *event)
{
2018-03-21 20:32:32 +00:00
if (event->type() == QEvent::ToolTip) {
if (helpEvent(static_cast<QHelpEvent *>(event))) {
return true;
}
}
return QAbstractScrollArea::event(event);
}
// This calculates the full graph starting at block entry.
void GraphView::computeGraph(ut64 entry)
{
graphLayoutSystem->CalculateLayout(blocks, entry, width, height);
2017-12-14 21:07:48 +00:00
ready = true;
2017-12-14 21:07:48 +00:00
viewport()->update();
}
QPolygonF GraphView::recalculatePolygon(QPolygonF polygon)
{
QPolygonF ret;
for (int i = 0; i < polygon.size(); i++) {
ret << QPointF(polygon[i].x() - offset.x(), polygon[i].y() - offset.y());
}
return ret;
}
void GraphView::beginMouseDrag(QMouseEvent *event)
{
scroll_base_x = event->x();
scroll_base_y = event->y();
scroll_mode = true;
setCursor(Qt::ClosedHandCursor);
viewport()->grabMouse();
}
void GraphView::setViewOffset(QPoint offset)
{
this->offset = offset;
emit viewOffsetChanged(offset);
}
void GraphView::setViewScale(qreal scale)
{
this->current_scale = scale;
emit viewScaleChanged(scale);
}
QSize GraphView::getCacheSize()
{
return
#ifndef QT_NO_OPENGL
useGL ? cacheSize :
#endif
pixmap.size();
}
qreal GraphView::getCacheDevicePixelRatioF()
{
return
#ifndef QT_NO_OPENGL
useGL ? 1.0 :
#endif
pixmap.devicePixelRatioF();
}
QSize GraphView::getRequiredCacheSize()
{
return
#ifndef QT_NO_OPENGL
useGL ? viewport()->size() :
#endif
viewport()->size() * devicePixelRatioF();
}
qreal GraphView::getRequiredCacheDevicePixelRatioF()
{
return
#ifndef QT_NO_OPENGL
useGL ? 1.0f :
#endif
devicePixelRatioF();
}
2019-04-07 10:53:42 +00:00
void GraphView::paintEvent(QPaintEvent *)
{
2019-04-07 10:53:42 +00:00
#ifndef QT_NO_OPENGL
if (useGL) {
glWidget->makeCurrent();
}
#endif
if (!qFuzzyCompare(getCacheDevicePixelRatioF(), getRequiredCacheDevicePixelRatioF())
|| getCacheSize() != getRequiredCacheSize()) {
setCacheDirty();
}
bool cacheWasDirty = cacheDirty;
if(cacheDirty) {
2019-04-07 10:53:42 +00:00
paintGraphCache();
cacheDirty = false;
2019-04-07 10:53:42 +00:00
}
if (useGL) {
#ifndef QT_NO_OPENGL
auto gl = glWidget->context()->extraFunctions();
gl->glBindFramebuffer(GL_READ_FRAMEBUFFER, cacheFBO);
gl->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, glWidget->defaultFramebufferObject());
gl->glBlitFramebuffer(0, 0, cacheSize.width(), cacheSize.height(),
2019-04-07 10:53:42 +00:00
0, 0, viewport()->width(), viewport()->height(),
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glWidget->doneCurrent();
#endif
} else {
QRectF target(0.0, 0.0, viewport()->width(), viewport()->height());
QRectF source(0.0, 0.0, pixmap.width(), pixmap.height());
2019-04-07 10:53:42 +00:00
QPainter p(viewport());
p.drawPixmap(target, pixmap, source);
}
}
void GraphView::paintGraphCache()
{
#ifndef QT_NO_OPENGL
QOpenGLPaintDevice *paintDevice = nullptr;
#endif
QPainter p;
if (useGL) {
#ifndef QT_NO_OPENGL
auto gl = QOpenGLContext::currentContext()->functions();
bool resizeTex = false;
if (!cacheTexture) {
gl->glGenTextures(1, &cacheTexture);
gl->glBindTexture(GL_TEXTURE_2D, cacheTexture);
gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
resizeTex = true;
} else if(cacheSize != viewport()->size()) {
gl->glBindTexture(GL_TEXTURE_2D, cacheTexture);
resizeTex = true;
}
if (resizeTex) {
cacheSize = viewport()->size();
gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport()->width(), viewport()->height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
gl->glGenFramebuffers(1, &cacheFBO);
gl->glBindFramebuffer(GL_FRAMEBUFFER, cacheFBO);
gl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, cacheTexture, 0);
} else {
gl->glBindFramebuffer(GL_FRAMEBUFFER, cacheFBO);
}
gl->glViewport(0, 0, viewport()->width(), viewport()->height());
gl->glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
gl->glClear(GL_COLOR_BUFFER_BIT);
2019-04-07 10:53:42 +00:00
paintDevice = new QOpenGLPaintDevice(viewport()->size());
p.begin(paintDevice);
#endif
} else {
auto dpr = devicePixelRatioF();
pixmap = QPixmap(getRequiredCacheSize());
2019-04-07 10:53:42 +00:00
pixmap.setDevicePixelRatio(dpr);
p.begin(&pixmap);
p.setRenderHint(QPainter::Antialiasing);
}
int render_width = viewport()->width();
int render_height = viewport()->height();
2017-12-14 21:07:48 +00:00
p.setBrush(backgroundColor);
p.drawRect(viewport()->rect());
p.setBrush(Qt::black);
p.scale(current_scale, current_scale);
2018-03-21 20:32:32 +00:00
for (auto &blockIt : blocks) {
GraphBlock &block = blockIt.second;
qreal blockX = block.x * current_scale;
qreal blockY = block.y * current_scale;
qreal blockWidth = block.width * current_scale;
qreal blockHeight = block.height * current_scale;
// Check if block is visible by checking if block intersects with view area
if (offset.x() * current_scale < blockX + blockWidth
&& blockX < offset.x() * current_scale + render_width
&& offset.y() * current_scale < blockY + blockHeight
&& blockY < offset.y() * current_scale + render_height) {
drawBlock(p, block);
}
p.setBrush(Qt::gray);
// Always draw edges
// TODO: Only draw edges if they are actually visible ...
// Draw edges
2018-03-21 20:32:32 +00:00
for (GraphEdge &edge : block.edges) {
if (edge.polyline.empty()) {
continue;
}
QPolygonF polyline = recalculatePolygon(edge.polyline);
EdgeConfiguration ec = edgeConfiguration(block, &blocks[edge.target]);
QPen pen(ec.color);
pen.setWidth(pen.width() / ec.width_scale);
p.setPen(pen);
p.setBrush(ec.color);
p.drawPolyline(polyline);
pen.setStyle(Qt::SolidLine);
p.setPen(pen);
if (!polyline.empty()) {
if (ec.start_arrow) {
auto firstPt = edge.polyline.first();
QPolygonF arrowStart;
arrowStart << QPointF(firstPt.x() - 3, firstPt.y() + 6);
arrowStart << QPointF(firstPt.x() + 3, firstPt.y() + 6);
arrowStart << QPointF(firstPt);
p.drawConvexPolygon(recalculatePolygon(arrowStart));
}
if (ec.end_arrow) {
auto lastPt = edge.polyline.last();
QPolygonF arrowEnd;
arrowEnd << QPointF(lastPt.x() - 3, lastPt.y() - 6);
arrowEnd << QPointF(lastPt.x() + 3, lastPt.y() - 6);
arrowEnd << QPointF(lastPt);
p.drawConvexPolygon(recalculatePolygon(arrowEnd));
}
}
}
}
2019-04-07 10:53:42 +00:00
p.end();
#ifndef QT_NO_OPENGL
delete paintDevice;
#endif
}
void GraphView::center()
{
centerX(false);
centerY(false);
emit viewOffsetChanged(offset);
}
void GraphView::centerX(bool emitSignal)
{
offset.rx() = -((viewport()->width() - width * current_scale) / 2);
offset.rx() /= current_scale;
if (emitSignal) {
emit viewOffsetChanged(offset);
}
}
void GraphView::centerY(bool emitSignal)
{
offset.ry() = -((viewport()->height() - height * current_scale) / 2);
offset.ry() /= current_scale;
if (emitSignal) {
emit viewOffsetChanged(offset);
}
}
void GraphView::showBlock(GraphBlock &block)
{
showBlock(&block);
}
void GraphView::showBlock(GraphBlock *block)
{
if (width * current_scale <= viewport()->width()) {
centerX(false);
} else {
int render_width = viewport()->width() / current_scale;
offset.rx() = block->x - ((render_width - block->width) / 2);
}
if (height * current_scale <= viewport()->height()) {
centerY(false);
} else {
offset.ry() = block->y - 30;
}
emit viewOffsetChanged(offset);
blockTransitionedTo(block);
2017-12-14 21:07:48 +00:00
viewport()->update();
}
void GraphView::addBlock(GraphView::GraphBlock block)
{
2017-12-14 21:07:48 +00:00
blocks[block.entry] = block;
}
void GraphView::setEntry(ut64 e)
{
2017-12-14 21:07:48 +00:00
entry = e;
}
bool GraphView::checkPointClicked(QPointF &point, int x, int y, bool above_y)
{
int half_target_size = 5;
2018-03-21 20:32:32 +00:00
if ((point.x() - half_target_size < x) &&
(point.y() - (above_y ? (2 * half_target_size) : 0) < y) &&
(x < point.x() + half_target_size) &&
2018-03-21 20:32:32 +00:00
(y < point.y() + (above_y ? 0 : (3 * half_target_size)))) {
return true;
}
return false;
}
// Mouse events
void GraphView::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::MiddleButton) {
beginMouseDrag(event);
return;
}
int x = event->pos().x() / current_scale + offset.x();
int y = event->pos().y() / current_scale + offset.y();
// Check if a block was clicked
2018-03-21 20:32:32 +00:00
for (auto &blockIt : blocks) {
GraphBlock &block = blockIt.second;
2018-03-21 20:32:32 +00:00
if ((block.x <= x) && (block.y <= y) &&
(x <= block.x + block.width) & (y <= block.y + block.height)) {
QPoint pos = QPoint(x - block.x, y - block.y);
blockClicked(block, event, pos);
// Don't do anything else here! blockClicked might seek and
// all our data is invalid then.
return;
}
}
// Check if a line beginning/end was clicked
2018-03-21 20:32:32 +00:00
for (auto &blockIt : blocks) {
GraphBlock &block = blockIt.second;
2018-03-21 20:32:32 +00:00
for (GraphEdge &edge : block.edges) {
if (edge.polyline.length() < 2) {
continue;
}
QPointF start = edge.polyline.first();
QPointF end = edge.polyline.last();
2018-03-21 20:32:32 +00:00
if (checkPointClicked(start, x, y)) {
showBlock(blocks[edge.target]);
// TODO: Callback to child
return;
break;
}
2018-03-21 20:32:32 +00:00
if (checkPointClicked(end, x, y, true)) {
showBlock(block);
// TODO: Callback to child
return;
break;
}
}
}
// No block was clicked
2018-03-21 20:32:32 +00:00
if (event->button() == Qt::LeftButton) {
//Left click outside any block, enter scrolling mode
beginMouseDrag(event);
}
}
2018-03-21 20:32:32 +00:00
void GraphView::mouseMoveEvent(QMouseEvent *event)
{
2018-03-21 20:32:32 +00:00
if (scroll_mode) {
offset.rx() += (scroll_base_x - event->x()) / current_scale;
offset.ry() += (scroll_base_y - event->y()) / current_scale;
emit viewOffsetChanged(offset);
2017-12-14 21:07:48 +00:00
scroll_base_x = event->x();
scroll_base_y = event->y();
viewport()->update();
2017-12-14 21:07:48 +00:00
}
}
void GraphView::mouseDoubleClickEvent(QMouseEvent *event)
{
int x = event->pos().x() / current_scale + offset.x();
int y = event->pos().y() / current_scale + offset.y();
2017-12-14 21:07:48 +00:00
// Check if a block was clicked
2018-03-21 20:32:32 +00:00
for (auto &blockIt : blocks) {
2017-12-14 21:07:48 +00:00
GraphBlock &block = blockIt.second;
2018-03-21 20:32:32 +00:00
if ((block.x <= x) && (block.y <= y) &&
(x <= block.x + block.width) & (y <= block.y + block.height)) {
2017-12-14 21:07:48 +00:00
QPoint pos = QPoint(x - block.x, y - block.y);
blockDoubleClicked(block, event, pos);
return;
}
}
}
void GraphView::keyPressEvent(QKeyEvent* event)
{
const int delta = static_cast<int>(30.0 / current_scale);
int dx = 0, dy = 0;
switch (event->key()) {
case Qt::Key_Up:
dy = -delta;
break;
case Qt::Key_Down:
dy = delta;
break;
case Qt::Key_Left:
dx = -delta;
break;
case Qt::Key_Right:
dx = delta;
break;
default:
QAbstractScrollArea::keyPressEvent(event);
return;
}
offset.rx() += dx;
offset.ry() += dy;
emit viewOffsetChanged(offset);
viewport()->update();
event->accept();
}
2018-03-21 20:32:32 +00:00
void GraphView::mouseReleaseEvent(QMouseEvent *event)
{
// TODO
// if(event->button() == Qt::ForwardButton)
// gotoNextSlot();
// else if(event->button() == Qt::BackButton)
// gotoPreviousSlot();
if (scroll_mode && (event->buttons() & (Qt::LeftButton | Qt::MiddleButton)) == 0) {
2017-12-14 21:07:48 +00:00
scroll_mode = false;
setCursor(Qt::ArrowCursor);
viewport()->releaseMouse();
}
}
void GraphView::wheelEvent(QWheelEvent *event)
{
if (scroll_mode) {
// With some mice it's easy to hit sideway scroll button while holding middle mouse.
// That would result in unwanted scrolling while panning.
return;
}
QPoint delta = -event->angleDelta();
delta /= current_scale;
offset += delta;
emit viewOffsetChanged(offset);
viewport()->update();
event->accept();
}