SchemaGraphicSegmentedArrow.cpp

Go to the documentation of this file.

#include <QPainter>
#include <QPen>
#include <QToolTip>
#include "dbe/SchemaGraphicSegmentedArrow.hpp"
#include "dbe/SchemaKernelWrapper.hpp"
#include "dbe/SchemaStyle.hpp"

#include "oks/class.hpp"

#include <cmath>
 
namespace dbse {
 
SchemaGraphicSegmentedArrow::SchemaGraphicSegmentedArrow(SchemaGraphicObject* start_item,
                                                         SchemaGraphicObject* end_item,
                                                         int connection_count,
                                                         bool is_inheritance,
                                                         bool is_composite,
                                                         QString arrow_name,
                                                         QString arrow_cardinality,
                                                         QGraphicsItem* parent)
  : QGraphicsPathItem(parent)
  , m_start_item(start_item)
  , m_end_item(end_item)
  , m_connection_count(connection_count)
  , m_inheritance(is_inheritance)
  , m_composite(is_composite)
  , m_name(arrow_name)
  , m_cardinality(arrow_cardinality)
  , LastDegree(0)
  , LastRotation(0)
{
  if (!is_inheritance) {
    setAcceptHoverEvents(true);
  }
  // setPen(QPen(Qt::black,2,Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin));
  setFlag(ItemIsSelectable, true);
  m_arrow_size = 20;
}
 
SchemaGraphicSegmentedArrow::~SchemaGraphicSegmentedArrow() {}
 
void
dbse::SchemaGraphicSegmentedArrow::hoverEnterEvent(QGraphicsSceneHoverEvent* he)
{
  if (!m_name.isEmpty()) {
    auto info = m_start_item->GetClass();
 
    auto rel = info->find_relationship(m_name.toStdString());
 
    QToolTip::showText(he->screenPos(), QString::fromStdString(rel->get_description()));
  }
  he->ignore();
}
void
dbse::SchemaGraphicSegmentedArrow::hoverLeaveEvent(QGraphicsSceneHoverEvent* he)
{
  QToolTip::hideText();
  he->ignore();
}
 
QRectF
SchemaGraphicSegmentedArrow::boundingRect() const
{
  if (m_start_item->collidesWithItem(m_end_item)) {
    return QRectF();
  }
 
  qreal extra = (pen().width() + 20) / 2.0 + 10;
  auto br =
    QRectF(p1(), QSizeF(p2().x() - p1().x(), p2().y() - p1().y())).normalized().adjusted(-extra, -extra, extra, extra);
  br = br.united(m_rel_label_br);
  br = br.united(m_rel_cardinality_br);
  return br;
}
 
QPainterPath
SchemaGraphicSegmentedArrow::shape() const
{
  QPainterPath path = QGraphicsPathItem::shape();
  path.addRect(m_rel_label_br);
  path.addRect(m_rel_cardinality_br);
  path.addPolygon(m_marker);
  // path.addText ( p2() + QPoint ( 10, 10 ), QFont ( "Helvetica [Cronyx]", 10 ),
  //  m_cardinality );
  // path.addText ( p1() + QPoint ( -10, -10 ), QFont ( "Helvetica [Cronyx]", 10 ),
  //  m_cardinality );
  return path;
}
 
void
SchemaGraphicSegmentedArrow::UpdatePosition()
{
  if (m_start_item->collidesWithItem(m_end_item)) {
    // this->setPath(QPainterPath());
    // m_marker = QPolygonF();
    return;
  }
 
  std::vector<QLineF> norms = {
    { 0., 0., 0., 1. },  // up
    { 0., 0., 1., 0. },  // right
    { 0., 0., 0, -1. },  // down
    { 0., 0., -1., 0. }, // left
  };
 
  qreal xoffset;
  qreal yoffset;
  const qreal xfactor = 23.0;
  const qreal yfactor = 17.0;
  if (m_start_item->boundingRect().x() < m_end_item->boundingRect().x()) {
    xoffset = m_connection_count * xfactor;
  } else {
    xoffset = m_connection_count * -xfactor;
  }
 
  if (m_start_item->boundingRect().y() > m_end_item->boundingRect().y()) {
    yoffset = m_connection_count * yfactor;
  } else {
    yoffset = m_connection_count * -yfactor;
  }
 
  QPointF start_offset(xoffset, yoffset);
  QPointF end_offset(0, 0);
 
  QLineF center_line(m_start_item->mapToScene(m_start_item->boundingRect().center() + start_offset),
                     m_end_item->mapToScene(m_end_item->boundingRect().center() + end_offset));
  QPolygonF start_polygon = QPolygonF(m_start_item->boundingRect());
  QPolygonF end_polygon = QPolygonF(m_end_item->boundingRect());
  QPointF intersect_point_start, intersect_point_end;
  QLineF intersect_norm_start, intersect_norm_end;
 
  // Iterate on the sides starting from top-left
  QPointF p1 = end_polygon.first() + m_end_item->pos(), p2;
  for (int i = 1; i < end_polygon.count(); ++i) {
 
    p2 = end_polygon.at(i) + m_end_item->pos();
    QLineF item_side = QLineF(p1, p2);
    QLineF::IntersectType intersect_type = item_side.intersects(center_line, &intersect_point_end);
 
    if (intersect_type == QLineF::BoundedIntersection) {
      intersect_norm_end = norms[i - 1];
      break;
    }
 
    p1 = p2;
  }
 
  p1 = start_polygon.first() + m_start_item->pos();
  QPointF start_sp;
  for (int i = 1; i < start_polygon.count(); ++i) {
    p2 = start_polygon.at(i) + m_start_item->pos();
    QLineF item_side = QLineF(p1, p2);
    QLineF::IntersectType intersect_type = item_side.intersects(center_line, &intersect_point_start);
    if (intersect_type == QLineF::BoundedIntersection) {
      switch (i) {
        case 1:
          start_sp = QPointF{ m_start_item->pos().x() + (m_start_item->boundingRect().width() / 2) + xoffset,
                              intersect_point_start.y() };
          break;
        case 3:
          start_sp = QPointF{ m_start_item->pos().x() + (m_start_item->boundingRect().width() / 2) - xoffset,
                              intersect_point_start.y() };
          break;
 
        case 2:
        case 4:
          start_sp = { intersect_point_start.x(),
                       m_start_item->pos().y() + m_start_item->boundingRect().height() / 2 + yoffset };
          break;
      }
      intersect_norm_start = norms[i - 1];
      break;
    }
 
    p1 = p2;
  }
 
  QLineF direct_line(start_sp, intersect_point_end);
  auto font = QFont(SchemaStyle::get_font("line"));
  auto label_br = QRectF(QFontMetrics(font).boundingRect(m_name));
  // Center rectangle on origin
  label_br.translate(-label_br.width() / 2, label_br.height() / 2);
 
  auto cardinality_br = QRectF(QFontMetrics(font).boundingRect(m_cardinality));
  // Center rectangle on origin
  cardinality_br.translate(-cardinality_br.width() / 2, cardinality_br.height() / 2);
 
  qreal label_x_padding = 2;
  qreal label_y_padding = -2;
  qreal card_x_padding = 2;
  qreal card_y_padding = -2;
 
  QPainterPath path(intersect_point_start);
 
  if ((intersect_norm_start.dx() == 0) && (intersect_norm_end.dx() == 0)) {
    // Three segments, starting and ending vertically
    QPointF wp1 = QPointF(direct_line.x1(), direct_line.center().y() + yoffset);
    QPointF wp2 = QPointF(direct_line.x2(), direct_line.center().y() + yoffset);
    path.moveTo(direct_line.x1(), direct_line.y1());
    path.lineTo(wp1);
    path.lineTo(wp2);
 
    // Place the label
    label_br.translate(wp2 + QPointF((direct_line.dx() < 0 ? 1 : -1) * (label_x_padding + label_br.width() / 2),
                                     (direct_line.dy() > 0 ? 1 : -1) * (label_br.height() + label_y_padding)));
    // Place cardinality
    cardinality_br.translate(intersect_point_start +
                             QPointF((direct_line.dx() < 0 ? 1 : -1) * (card_x_padding + cardinality_br.width() / 2),
                                     (direct_line.dy() > 0 ? 1 : -1) * (cardinality_br.height() + card_y_padding)));
 
  } else if ((intersect_norm_start.dy() == 0) && (intersect_norm_end.dy() == 0)) {
    // Three segments, starting and ending horizontally
    QPointF wp1 = QPointF(direct_line.center().x() - xoffset, direct_line.y1());
    QPointF wp2 = QPointF(direct_line.center().x() - xoffset, direct_line.y2());
 
    path.moveTo(direct_line.x1(), direct_line.y1());
    path.lineTo(wp1);
    path.lineTo(wp2);
 
    // Place the label
    label_br.translate(wp2 + QPointF((direct_line.dx() > 0 ? 1 : -1) * (label_x_padding + label_br.width() / 2),
                                     (direct_line.dy() < 0 ? 1 : -1) * (label_br.height() + label_y_padding)));
    cardinality_br.translate(intersect_point_start +
                             QPointF((direct_line.dx() > 0 ? 1 : -1) * (card_x_padding + cardinality_br.width() / 2),
                                     (direct_line.dy() < 0 ? 1 : -1) * (cardinality_br.height() + card_y_padding)));
 
  } else if (intersect_norm_start.dx() == 0) {
    // Two segments, starting vertically, ending horizontally
    QPointF wp1 = QPointF(direct_line.x1(), direct_line.y2());
 
    path.moveTo(direct_line.x1(), direct_line.y1());
    path.lineTo(wp1);
 
    label_br.translate(wp1 + QPointF((direct_line.dx() > 0 ? 1 : -1) * (label_x_padding + label_br.width() / 2),
                                     (direct_line.dy() < 0 ? 1 : -1) * (label_br.height() + label_y_padding)));
    cardinality_br.translate(intersect_point_start +
                             QPointF((direct_line.dx() < 0 ? 1 : -1) * (card_x_padding + cardinality_br.width() / 2),
                                     (direct_line.dy() > 0 ? 1 : -1) * (cardinality_br.height() + card_y_padding)));
 
  } else if (intersect_norm_start.dy() == 0) {
    // Two segments, starting horizontally, ending vertically
    QPointF wp1 = QPointF(direct_line.x2(), direct_line.y1());
    path.moveTo(direct_line.x1(), direct_line.y1());
 
    path.lineTo(wp1);
 
    label_br.translate(wp1 + QPointF((direct_line.dx() > 0 ? 1 : -1) * (label_x_padding + label_br.width() / 2),
                                     (direct_line.dy() < 0 ? 1 : -1) * (label_br.height() + label_y_padding)));
    cardinality_br.translate(intersect_point_start +
                             QPointF((direct_line.dx() < 0 ? 1 : -1) * (card_x_padding + cardinality_br.width() / 2),
                                     (direct_line.dy() > 0 ? 1 : -1) * (cardinality_br.height() + card_y_padding)));
  }
 
  path.lineTo(intersect_point_end);
  setPath(path);
 
  m_rel_label_br = label_br;
  m_rel_cardinality_br = cardinality_br;
 
  // Why does a function called UpdatePosition add decorations to a line??
  // =====================================================================
  if (m_inheritance) {
    m_marker = this->make_arrow_head(-intersect_norm_end.angle() / 180 * M_PI).translated(this->p2());
  } else {
    m_marker = this->make_rhombus(-intersect_norm_start.angle() / 180 * M_PI).translated(this->p1());
  }
}
 
SchemaGraphicObject*
SchemaGraphicSegmentedArrow::GetStartItem() const
{
  return m_start_item;
}
 
SchemaGraphicObject*
SchemaGraphicSegmentedArrow::GetEndItem() const
{
  return m_end_item;
}
 
bool
SchemaGraphicSegmentedArrow::GetInheritanceMode()
{
  return m_inheritance;
}
 
void
SchemaGraphicSegmentedArrow::RemoveArrow()
{
  if (m_inheritance) {
  } else {
  }
}
 
QPolygonF
SchemaGraphicSegmentedArrow::make_arrow_head(qreal rotation) const
{
 
  float opening_angle = atan2(1, 0.5);
  qreal size = m_arrow_size;
  QPointF a1 = QPointF(sin(rotation + opening_angle) * size, cos(rotation + opening_angle) * size);
  QPointF a2 = QPointF(sin(rotation + M_PI - opening_angle) * size, cos(rotation + M_PI - opening_angle) * size);
 
  QPolygonF arrow;
  arrow << QPointF(0, 0) << a1 << a2;
  return arrow;
}
 
QPolygonF
SchemaGraphicSegmentedArrow::make_rhombus(qreal rotation) const
{
 
  float opening_angle = M_PI / 3;
  qreal size = 0.6 * m_arrow_size;
 
  QPointF a1 = QPointF(sin(rotation + opening_angle) * size, cos(rotation + opening_angle) * size);
  QPointF a2 = QPointF(sin(rotation + M_PI - opening_angle) * size, cos(rotation + M_PI - opening_angle) * size);
 
  QPointF m = QPointF((a1.x() + a2.x()) / 2, (a1.y() + a2.y()) / 2);
  QPointF a3 = QPointF(2 * m.x(), 2 * m.y());
 
  QPolygonF rhombus;
  rhombus << QPointF(0, 0) << a1 << a3 << a2;
  return rhombus;
}
 
void
SchemaGraphicSegmentedArrow::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
{
  Q_UNUSED(option)
  Q_UNUSED(widget)
 
  if (m_start_item->collidesWithItem(m_end_item)) {
    return;
  }
 
  const QPen line_pen = QPen(SchemaStyle::get_color("foreground", "line"), 1);
  const QPen arrow_pen = QPen(SchemaStyle::get_color("foreground", "line"), 1);
 
  painter->setFont(QFont(SchemaStyle::get_font("line")));
  painter->setPen(line_pen);
  painter->setBrush({});
  painter->setRenderHint(QPainter::Antialiasing);
 
  painter->drawPath(this->path());
 
  painter->setPen(arrow_pen);
  if (!m_inheritance) {
    painter->drawText(m_rel_label_br, Qt::AlignTop | Qt::AlignLeft, QString(m_name));
    painter->drawText(m_rel_cardinality_br, Qt::AlignTop | Qt::AlignLeft, QString(m_cardinality));
  }
 
  if (m_inheritance) {
    painter->setBrush(Qt::white);
  } else if (m_composite) {
    painter->setBrush(SchemaStyle::get_color("foreground", "line"));
 
  } else {
    painter->setBrush(Qt::white);
  }
  painter->drawPolygon(m_marker);
}
 
} // namespace dbse