639 lines
17 KiB
C++
639 lines
17 KiB
C++
#include "blockbusitem.h"
|
|
|
|
|
|
BlockBusItem::BlockBusItem(bool temp): QGraphicsObject(), PropertyStorage() {
|
|
temp_ = temp;
|
|
_init();
|
|
if (!temp) setData(1005, "connection");
|
|
else hide();
|
|
}
|
|
|
|
|
|
BlockBusItem::BlockBusItem(const BlockBusItem & other): QGraphicsObject(), PropertyStorage() {
|
|
temp_ = false;
|
|
_init();
|
|
setData(1005, "connection");
|
|
setPen(other.pen());
|
|
setBrush(other.brush());
|
|
setBusType(other.busType());
|
|
max_ep = other.max_ep;
|
|
pol = other.pol;
|
|
segments = other.segments;
|
|
updateGeometry();
|
|
}
|
|
|
|
|
|
void BlockBusItem::_init() {
|
|
setBusType(-1);
|
|
setAcceptHoverEvents(true);
|
|
ph.setColor(Qt::blue); ph.setJoinStyle(Qt::MiterJoin);
|
|
bh.setColor(Qt::blue); bh.setStyle(Qt::SolidPattern);
|
|
pu = pa = pr = ph; bu = ba = br = bh;
|
|
grid_step = 10.;
|
|
pu.setWidth(1);
|
|
pu.setColor(Qt::black); bu.setColor(Qt::black);
|
|
pa.setColor(Qt::darkGreen); ba.setColor(Qt::darkGreen);
|
|
pr.setColor(Qt::darkRed); br.setColor(Qt::darkRed);
|
|
pn.setColor(Qt::gray); pn.setStyle(Qt::DashLine);
|
|
if (temp_) {
|
|
pu.setStyle(Qt::DashLine);
|
|
pu.setColor(Qt::darkGray);
|
|
bu.setColor(Qt::darkGray);
|
|
}
|
|
setPen(pu); setBrush(bu);
|
|
max_ep = 0;
|
|
selPoint = selSegment = state_ = -1;
|
|
pen_width = 2.;
|
|
moved = deleted = mark_in = mark_out = new_segment = mm_cancel = lm_point = false;
|
|
}
|
|
|
|
|
|
void BlockBusItem::reconnect() {
|
|
if (temp_) return;
|
|
if (!scene()) return;
|
|
if (scene()->views().isEmpty()) return;
|
|
QMetaObject::invokeMethod(scene()->views().back(), "reconnectAll");
|
|
}
|
|
|
|
|
|
bool BlockBusItem::sceneEvent(QEvent * e) {
|
|
if (temp_) return QGraphicsObject::sceneEvent(e);
|
|
switch (e->type()) {
|
|
case QEvent::GraphicsSceneHoverEnter: hoverEnterEvent((QGraphicsSceneHoverEvent * )e); break;
|
|
case QEvent::GraphicsSceneHoverMove: hoverMoveEvent((QGraphicsSceneHoverEvent * )e); break;
|
|
case QEvent::GraphicsSceneHoverLeave: hoverLeaveEvent((QGraphicsSceneHoverEvent * )e); break;
|
|
case QEvent::GraphicsSceneMousePress: mousePressEvent((QGraphicsSceneMouseEvent * )e); break;
|
|
case QEvent::GraphicsSceneMouseMove: mouseMoveEvent((QGraphicsSceneMouseEvent * )e); break;
|
|
case QEvent::GraphicsSceneMouseRelease: mouseReleaseEvent((QGraphicsSceneMouseEvent * )e); break;
|
|
default: break;
|
|
}
|
|
return QGraphicsObject::sceneEvent(e);
|
|
}
|
|
|
|
|
|
int BlockBusItem::addPoint(const QPointF & point, bool update) {
|
|
int ei = pol.indexOf(point);
|
|
if (ei >= 0) return ei;
|
|
if (selSegment < 0 || selSegment >= pol.size() - 1) return -1;
|
|
pol << quantize(nearestPointOnLine(pol[segments[selSegment].first], pol[segments[selSegment].second], point), grid_step);
|
|
selPoint = pol.size() - 1;
|
|
segments << QPair<int, int>(selPoint, segments[selSegment].second);
|
|
segments[selSegment].second = selPoint;
|
|
selSegment = -1;
|
|
updateGeometry();
|
|
if (scene() != 0 && update) scene()->update();
|
|
return pol.size() - 1;
|
|
}
|
|
|
|
|
|
int BlockBusItem::segmentPointPair(int point) const {
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
if (segments[i].first == point) return segments[i].second;
|
|
if (segments[i].second == point) return segments[i].first;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
void BlockBusItem::removePoint(int index) {
|
|
if (index < 0 || index > pol.size() - 1) return;
|
|
int sc = 0, fs = -1, ss = -1;
|
|
for (int i = 0; i < segments.size(); ++i)
|
|
if (segments[i].first == index ||
|
|
segments[i].second == index) {
|
|
sc++;
|
|
if (fs < 0) fs = i;
|
|
else ss = i;
|
|
}
|
|
int ei(0);
|
|
switch (sc) {
|
|
case 1:
|
|
segments.removeAt(fs);
|
|
break;
|
|
case 2:
|
|
if (segments[ss].first == index) ei = segments[ss].second;
|
|
else ei = segments[ss].first;
|
|
if (segments[fs].first == index) segments[fs].first = ei;
|
|
else segments[fs].second = ei;
|
|
segments.removeAt(ss);
|
|
break;
|
|
default: return;
|
|
}
|
|
pol.remove(index);
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
if (segments[i].first >= index)
|
|
segments[i].first--;
|
|
if (segments[i].second >= index)
|
|
segments[i].second--;
|
|
}
|
|
selPoint = -1;
|
|
checkDelete();
|
|
updateGeometry();
|
|
if (scene() != 0) scene()->update();
|
|
}
|
|
|
|
|
|
void BlockBusItem::removeSegment(int index) {
|
|
if (index < 0 || index > segments.size() - 1) return;
|
|
int pif = segments[index].first, pis = segments[index].second;
|
|
if (pif > pis) qSwap<int>(pif, pis);
|
|
int scf = 0, scs = 0;
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
if (segments[i].first == pif ||
|
|
segments[i].second == pif)
|
|
scf++;
|
|
if (segments[i].first == pis ||
|
|
segments[i].second == pis)
|
|
scs++;
|
|
}
|
|
if (scs <= 2) removePoint(pis);
|
|
if (scf <= 2) removePoint(pif);
|
|
if (scs <= 2 || scf <= 2) selSegment = -1;
|
|
if (scene() != 0) scene()->update();
|
|
|
|
}
|
|
|
|
|
|
void BlockBusItem::appendPoint(const QPointF & p) {
|
|
pol << p;
|
|
if (pol.size() > 1)
|
|
segments << QPair<int, int>(pol.size() - 2, pol.size() - 1);
|
|
updateGeometry();
|
|
}
|
|
|
|
|
|
void BlockBusItem::clear() {
|
|
pol.clear();
|
|
segments.clear();
|
|
updateGeometry();
|
|
}
|
|
|
|
|
|
void BlockBusItem::markAsInput() {
|
|
mark_in = true;
|
|
mark_out = false;
|
|
}
|
|
|
|
|
|
void BlockBusItem::markAsOutput() {
|
|
mark_in = false;
|
|
mark_out = true;
|
|
}
|
|
|
|
|
|
void BlockBusItem::unmark() {
|
|
mark_in = mark_out = false;
|
|
}
|
|
|
|
|
|
void BlockBusItem::simplify() {
|
|
int pcnt = pol.size();
|
|
for (int i = 0; i < pol.size() - 1; ++i) {
|
|
if (pol[i] == pol[i + 1])
|
|
pol.remove(i--);
|
|
}
|
|
if (pol.size() < 3) return;
|
|
//PIMathVectorT2d cl, pl;
|
|
for (int i = 0; i < pol.size() - 2; ++i) {
|
|
//pl = Q2PIVector2(pol[i]) - Q2PIVector2(pol[i + 1]);
|
|
//cl = Q2PIVector2(pol[i + 1]) - Q2PIVector2(pol[i + 2]);
|
|
//if (pl.turnTo<3, double>() || cl.turnTo<3, double>())
|
|
// pol.remove(i-- + 1);
|
|
}
|
|
if (pcnt == pol.size()) return;
|
|
//GBFrom->emitAddToHistory(History::ConnectionSimplify, "");
|
|
updateGeometry();
|
|
if (scene() != 0) scene()->update();
|
|
}
|
|
|
|
|
|
void BlockBusItem::adjustLine() {
|
|
}
|
|
|
|
|
|
int BlockBusItem::endpointCount() const {
|
|
return endpoints().size();
|
|
}
|
|
|
|
|
|
|
|
QList<BlockItem * > BlockBusItem::connectedBlocks() const {
|
|
QList<BlockItemPin * > pins = connections_.values();
|
|
QSet<BlockItem * > ret;
|
|
foreach (BlockItemPin * p, pins)
|
|
ret << p->parent();
|
|
return ret.toList();
|
|
}
|
|
|
|
|
|
QList<BlockItemPin * > BlockBusItem::connectedPins() const {
|
|
return connections_.values();
|
|
}
|
|
|
|
|
|
void BlockBusItem::setBusState(bool state) {
|
|
int s = state ? 1 : 0;
|
|
if (state_ == s) return;
|
|
state_ = s;
|
|
update();
|
|
}
|
|
|
|
|
|
void BlockBusItem::clearBusState() {
|
|
if (state_ == -1) return;
|
|
state_ = -1;
|
|
update();
|
|
}
|
|
|
|
|
|
QByteArray BlockBusItem::save() const {
|
|
ChunkStream cs;
|
|
cs << cs.chunk(1, busType()) << cs.chunk(2, busName()) << cs.chunk(3, width()) << cs.chunk(4, pen())
|
|
<< cs.chunk(5, brush()) << cs.chunk(6, pol) << cs.chunk(7, segments) << cs.chunk(8, props);
|
|
return cs.data();
|
|
}
|
|
|
|
|
|
void BlockBusItem::load(const QByteArray & data) {
|
|
clear();
|
|
if (data.isEmpty()) return;
|
|
ChunkStream cs(data);
|
|
while (!cs.atEnd()) {
|
|
switch (cs.read()) {
|
|
case 1: setBusType(cs.getData<int>()); break;
|
|
case 2: setBusName(cs.getData<QString>()); break;
|
|
case 3: setWidth(cs.getData<double>()); break;
|
|
case 4: setPen(cs.getData<QPen>()); break;
|
|
case 5: setBrush(cs.getData<QBrush>()); break;
|
|
case 6: pol = cs.getData<QPolygonF>(); break;
|
|
case 7: segments = cs.getData<QList<QPair<int, int> > >(); break;
|
|
case 8: props = cs.getData<QList<BlockItem::Property> >(); break;
|
|
}
|
|
}
|
|
updateGeometry();
|
|
}
|
|
|
|
|
|
BlockBusItem * BlockBusItem::copy() const {
|
|
return new BlockBusItem(*this);
|
|
}
|
|
|
|
|
|
void BlockBusItem::updateGeometry() {
|
|
ends = endpoints();
|
|
ends_ind.clear();
|
|
for (int e = 0; e < ends.size(); ++e) {
|
|
int ce = ends[e];
|
|
for (int s = 0; s < segments.size(); ++s) {
|
|
if (segments[s].first == ce) {
|
|
ends_ind << QPair<int, int>(segments[s].first, segments[s].second);
|
|
break;
|
|
}
|
|
if (segments[s].second == ce) {
|
|
ends_ind << QPair<int, int>(segments[s].second, segments[s].first);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
reconnect();
|
|
prepareGeometryChange();
|
|
}
|
|
|
|
|
|
void BlockBusItem::checkDelete() {
|
|
if (pol.size() < 2 || segments.size() < 1) deleteLater();
|
|
}
|
|
|
|
|
|
void BlockBusItem::emitAction(BlockItemBase::Action a) {
|
|
QMetaObject::invokeMethod(scene()->views().back(), "actionEvent", Q_ARG(BlockItemBase::Action, a), Q_ARG(QList<QGraphicsItem*>, QList<QGraphicsItem*>() << this));
|
|
QMetaObject::invokeMethod(scene()->views().back(), "connectionsChanged");
|
|
}
|
|
|
|
|
|
QVector<int> BlockBusItem::endpoints() const {
|
|
QVector<int> counts(pol.size(), 0), ret;
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
counts[segments[i].first]++;
|
|
counts[segments[i].second]++;
|
|
}
|
|
for (int i = 0; i < counts.size(); ++i) {
|
|
if (counts[i] == 1)
|
|
ret << i;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
int BlockBusItem::pointSegments(int point) const {
|
|
int ret = 0;
|
|
for (int i = 0; i < segments.size(); ++i)
|
|
if (segments[i].first == point ||
|
|
segments[i].second == point)
|
|
ret++;
|
|
return ret;
|
|
}
|
|
|
|
|
|
void BlockBusItem::testPoint(QPointF pos, int * sel_point, int * sel_segment) {
|
|
for (int i = 0; i < pol.size(); ++i) {
|
|
if ((pol[i] - pos).manhattanLength() <= 10.) { // Point
|
|
*sel_point = i;
|
|
*sel_segment = -1;
|
|
return;
|
|
}
|
|
}
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
if (distPointToLine(pol[segments[i].first], pol[segments[i].second], pos) <= 7.) { // Segment
|
|
*sel_point = -1;
|
|
*sel_segment = i;
|
|
return;
|
|
}
|
|
}
|
|
*sel_point = -1;
|
|
*sel_segment = -1;
|
|
}
|
|
|
|
|
|
void BlockBusItem::hoverEnterEvent(QGraphicsSceneHoverEvent * e) {
|
|
tt = bus_name + (bus_name.isEmpty() ? "" : "\n\n") + tr("Add point: Ctrl + LeftClick\nRemove point\\segment: Ctrl + RightClick\nNew branch: Shift + LeftClick\nRemove connection: Shift + RightClick");
|
|
}
|
|
|
|
|
|
void BlockBusItem::hoverMoveEvent(QGraphicsSceneHoverEvent * e) {
|
|
if (temp_) return;
|
|
QPointF sp = e->scenePos();
|
|
testPoint(sp, &selPoint, &selSegment);
|
|
if (selPoint >= 0 || selSegment >= 0) {
|
|
setToolTip(tt);
|
|
update();
|
|
return;
|
|
}
|
|
setToolTip(QString());
|
|
QList<QGraphicsItem * > il = scene()->items(sp, Qt::ContainsItemBoundingRect, Qt::DescendingOrder), bil;
|
|
bil << this;
|
|
for (int i = 0; i < il.size(); ++i) {
|
|
QGraphicsItem * b = il[i];
|
|
if (b->data(1005) == "connection" && b != this) {
|
|
int tp = -1, ts = -1;
|
|
((BlockBusItem*)b)->testPoint(sp, &tp, &ts);
|
|
if (tp >= 0 || ts >= 0) {
|
|
foreach (QGraphicsItem * b2, bil)
|
|
b2->stackBefore(b);
|
|
break;
|
|
}
|
|
bil << b;
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
|
|
void BlockBusItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * e) {
|
|
if (temp_) return;
|
|
selPoint = selSegment = -1;
|
|
setPen(pu); setBrush(bu);
|
|
setToolTip(QString());
|
|
update();
|
|
QGraphicsObject::hoverLeaveEvent(e);
|
|
}
|
|
|
|
|
|
void BlockBusItem::mousePressEvent(QGraphicsSceneMouseEvent * e) {
|
|
if (temp_) return;
|
|
lp = quantize(e->scenePos(), grid_step);
|
|
if (new_segment) {
|
|
QMetaObject::invokeMethod(scene()->views().back(), "newBranchCancel");
|
|
}
|
|
new_segment = false;
|
|
if ((selPoint < 0 || selPoint > pol.size() - 1) && (selSegment < 0)) {
|
|
QGraphicsObject::mousePressEvent(e);
|
|
return;
|
|
}
|
|
int btncnt = 0;
|
|
if (e->buttons().testFlag(Qt::LeftButton)) btncnt++;
|
|
if (e->buttons().testFlag(Qt::RightButton)) btncnt++;
|
|
if (e->buttons().testFlag(Qt::MidButton)) btncnt++;
|
|
if (btncnt > 0) mm_mods = e->modifiers();
|
|
//qDebug() << "press" << e;
|
|
if (btncnt >= 2 && e->button() == Qt::RightButton) {
|
|
mm_cancel = true;
|
|
moved = false;
|
|
QPointF lp = qp - press_pos;
|
|
//qDebug() << lp;
|
|
if (selPoint >= 0 && selPoint <= pol.size() - 1)
|
|
pol[selPoint] += lp;
|
|
if (selSegment >= 0 && selSegment <= segments.size() - 1) {
|
|
pol[segments[selSegment].first] += lp;
|
|
pol[segments[selSegment].second] += lp;
|
|
}
|
|
moved = true;
|
|
prepareGeometryChange();
|
|
return;
|
|
}
|
|
if (e->modifiers().testFlag(Qt::ShiftModifier)) {
|
|
if (e->buttons().testFlag(Qt::LeftButton)) {
|
|
if (selSegment >= 0)
|
|
press_pos = quantize(nearestPointOnLine(pol[segments[selSegment].first], pol[segments[selSegment].second], e->scenePos()), grid_step);
|
|
else {
|
|
if (selPoint >= 0)
|
|
press_pos = pol[selPoint];
|
|
else
|
|
return;
|
|
}
|
|
if (max_ep >= 2) {
|
|
if (endpointCount() >= max_ep)
|
|
if (pointSegments(selPoint) >= 2 || selSegment >= 0)
|
|
return;
|
|
}
|
|
QMetaObject::invokeMethod(scene()->views().back(), "newBranch", Q_ARG(BlockBusItem * , this));
|
|
new_segment = true;
|
|
return;
|
|
}
|
|
if (e->buttons().testFlag(Qt::RightButton)) {
|
|
deleteLater();
|
|
}
|
|
}
|
|
if (e->modifiers().testFlag(Qt::ControlModifier)) {
|
|
if (e->buttons().testFlag(Qt::RightButton)) {
|
|
if (selPoint >= 0 && selPoint <= pol.size() - 1) {
|
|
removePoint(selPoint);
|
|
emitAction(BlockItemBase::BusPointRemove);
|
|
return;
|
|
}
|
|
if (selSegment >= 0 && selSegment <= segments.size() - 1) {
|
|
removeSegment(selSegment);
|
|
emitAction(BlockItemBase::BusSegmentRemove);
|
|
return;
|
|
}
|
|
}
|
|
if (e->buttons().testFlag(Qt::LeftButton) && selSegment >= 0) {
|
|
if (addPoint(e->scenePos()) >= 0)
|
|
emitAction(BlockItemBase::BusPointAdd);
|
|
return;
|
|
}
|
|
}
|
|
if (e->modifiers().testFlag(Qt::ShiftModifier)) {
|
|
if (e->buttons().testFlag(Qt::RightButton)) {
|
|
if (deleted) return;
|
|
deleted = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void BlockBusItem::mouseMoveEvent(QGraphicsSceneMouseEvent * e) {
|
|
if (temp_ || mm_cancel) return;
|
|
if (((selPoint < 0 || selPoint > pol.size() - 1) && (selSegment < 0)) && !new_segment) {
|
|
QGraphicsObject::mouseMoveEvent(e);
|
|
return;
|
|
}
|
|
qp = quantize(e->scenePos(), grid_step);
|
|
lp = qp - lp;
|
|
if (e->buttons().testFlag(Qt::LeftButton) && mm_mods.testFlag(Qt::ShiftModifier) && new_segment) {
|
|
QMetaObject::invokeMethod(scene()->views().back(), "newBranchTrace", Q_ARG(BlockBusItem * , this), Q_ARG(QPointF, e->scenePos()));
|
|
return;
|
|
}
|
|
if (new_segment) {
|
|
new_end = qp;
|
|
prepareGeometryChange();
|
|
} else {
|
|
if (e->buttons().testFlag(Qt::LeftButton)) {
|
|
lm_point = selPoint >= 0;
|
|
if (selPoint >= 0 && selPoint <= pol.size() - 1)
|
|
pol[selPoint] += lp;
|
|
if (selSegment >= 0 && selSegment <= segments.size() - 1) {
|
|
pol[segments[selSegment].first] += lp;
|
|
pol[segments[selSegment].second] += lp;
|
|
}
|
|
moved = true;
|
|
prepareGeometryChange();
|
|
}
|
|
}
|
|
lp = qp;
|
|
}
|
|
|
|
|
|
void BlockBusItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * e) {
|
|
mm_mods = 0;
|
|
int btncnt = 0;
|
|
if (e->buttons().testFlag(Qt::LeftButton)) btncnt++;
|
|
if (e->buttons().testFlag(Qt::RightButton)) btncnt++;
|
|
if (e->buttons().testFlag(Qt::MidButton)) btncnt++;
|
|
if (btncnt == 0) mm_cancel = false;
|
|
if (new_segment) {
|
|
QMetaObject::invokeMethod(scene()->views().back(), "newBranchAccept", Q_ARG(BlockBusItem * , this));
|
|
updateGeometry();
|
|
selPoint = selSegment = -1;
|
|
}
|
|
if (moved) {
|
|
reconnect();
|
|
emitAction(lm_point ? BlockItemBase::BusPointMove : BlockItemBase::BusSegmentMove);
|
|
}
|
|
moved = new_segment = false;
|
|
QGraphicsObject::mouseReleaseEvent(e);
|
|
}
|
|
|
|
|
|
void BlockBusItem::paint(QPainter * p, const QStyleOptionGraphicsItem * o, QWidget * w) {
|
|
ph.setWidthF(pen_width + 1.);
|
|
pu.setWidthF(pen_width);
|
|
pa.setWidthF(pen_width);
|
|
pr.setWidthF(pen_width);
|
|
pn.setWidthF(pen_width);
|
|
if (pol.size() < 2) return;
|
|
if (selPoint >= 0 || selSegment >= 0) {
|
|
p->setPen(pa);
|
|
p->setBrush(ba);
|
|
} else {
|
|
p->setPen(pu);
|
|
p->setBrush(bu);
|
|
}
|
|
//if (mark_in) {p->setPen(pa); p->setBrush(ba);}
|
|
//if (mark_out) {p->setPen(pr); p->setBrush(br);}
|
|
if (im_bus.isNull()) {
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
p->drawLine(pol[segments[i].first], pol[segments[i].second]);
|
|
}
|
|
} else {
|
|
QBrush br;
|
|
br.setTextureImage(im_bus);
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
QPointF sp(pol[segments[i].first]), ep(pol[segments[i].second]);
|
|
QTransform tf;
|
|
tf.translate(sp.x(), sp.y());
|
|
tf.rotate(-QLineF(sp, ep).angle());
|
|
tf.translate(0., -im_bus.height() / 2.);
|
|
/*
|
|
br.setTransform(tf);
|
|
p->setPen(QPen(br, im_bus.height(), Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
|
|
p->drawLine(sp, ep);
|
|
*/
|
|
p->save();
|
|
p->setTransform(tf, true);
|
|
p->setPen(Qt::NoPen);
|
|
p->setBrush(br);
|
|
//p->drawLine(QPointF(0., 0.), QPointF(QLineF(sp, ep).length(), 0.));
|
|
p->drawRect(QRectF(0., 0., QLineF(sp, ep).length(), im_bus.height()));
|
|
p->restore();
|
|
}
|
|
}
|
|
if (!im_end.isNull()) {
|
|
for (int i = 0; i < ends_ind.size(); ++i) {
|
|
QPointF sp = pol[ends_ind[i].first], ep = pol[ends_ind[i].second];
|
|
QTransform tf;
|
|
tf.translate(sp.x(), sp.y());
|
|
tf.rotate(-QLineF(sp, ep).angle());
|
|
tf.translate(-pen_width, -im_end.height() / 2.);
|
|
p->save();
|
|
p->setTransform(tf, true);
|
|
p->drawImage(0, 0, im_end);
|
|
p->restore();
|
|
}
|
|
}
|
|
if (state_ >= 0) {
|
|
if (state_ == 0) {
|
|
pr.setWidthF(pen_width + 1.);
|
|
p->setPen(pr);
|
|
} else if (state_ == 1) {
|
|
pa.setWidthF(pen_width + 1.);
|
|
p->setPen(pa);
|
|
}
|
|
p->setOpacity(0.5);
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
p->drawLine(pol[segments[i].first], pol[segments[i].second]);
|
|
}
|
|
p->setOpacity(1.);
|
|
}
|
|
if (!im_bus.isNull() && (selPoint >= 0 || selSegment >= 0)) {
|
|
p->setPen(pa);
|
|
p->setBrush(ba);
|
|
for (int i = 0; i < segments.size(); ++i) {
|
|
p->drawLine(pol[segments[i].first], pol[segments[i].second]);
|
|
}
|
|
}
|
|
//if (mark_in) {p->setPen(pa); p->setBrush(ba);}
|
|
//if (mark_out) {p->setPen(pr); p->setBrush(br);}
|
|
if (selPoint >= 0) {
|
|
p->save();
|
|
p->setPen(ph);
|
|
p->setBrush(bh);
|
|
p->translate(pol[selPoint]);
|
|
p->drawEllipse(QPointF(0, 0), 3, 3);
|
|
p->restore();
|
|
}
|
|
if (selSegment >= 0) {
|
|
p->save();
|
|
p->setPen(ph);
|
|
p->drawLine(pol[segments[selSegment].first], pol[segments[selSegment].second]);
|
|
p->restore();
|
|
}
|
|
}
|
|
|
|
|
|
QRectF BlockBusItem::boundingRect() const {
|
|
QPolygonF p(pol);
|
|
p << new_end;
|
|
return enlargedRect(p.boundingRect(), 0, 0, 10.f);
|
|
}
|