2022-08-12 07:32:35 +00:00
|
|
|
#include "graphicsscene.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
#include <QGraphicsSceneMouseEvent>
|
|
|
|
#include <QGraphicsRectItem>
|
|
|
|
#include <QGraphicsEllipseItem>
|
|
|
|
#include <QGraphicsProxyWidget>
|
|
|
|
#include <QScrollBar>
|
|
|
|
#include <QPen>
|
|
|
|
#include <QBrush>
|
2022-08-12 08:03:33 +00:00
|
|
|
#include <QGraphicsView>
|
2022-08-12 07:32:35 +00:00
|
|
|
#include <typeinfo>
|
2022-08-12 08:58:05 +00:00
|
|
|
#include <math.h>
|
2023-08-15 01:33:29 +00:00
|
|
|
#include "assert.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
GraphicsTextEdit::GraphicsTextEdit(QWidget* parent)
|
|
|
|
: QTextEdit(parent)
|
|
|
|
{
|
2022-08-12 08:03:33 +00:00
|
|
|
viewport()->setWindowFlags(Qt::FramelessWindowHint);
|
2022-08-12 07:32:35 +00:00
|
|
|
//viewport()->setAttribute(Qt::WA_TranslucentBackground);
|
2022-05-03 10:25:52 +00:00
|
|
|
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
|
|
|
|
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
|
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
setContextMenuPolicy(Qt::ContextMenuPolicy::NoContextMenu);
|
2022-05-03 10:25:52 +00:00
|
|
|
connect(this, SIGNAL(textChanged()), this, SLOT(on_textChanged()));
|
2022-08-12 07:32:35 +00:00
|
|
|
|
|
|
|
setStyleSheet("QTextEdit{background-color: transparent; border: 3px solid red;}");
|
|
|
|
//setWindowOpacity(0.3);
|
|
|
|
//setMouseTracking(true);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GraphicsTextEdit::~GraphicsTextEdit()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
void GraphicsTextEdit::setDefeaultColor(const QColor& color)
|
|
|
|
{
|
|
|
|
m_defeaultColor = color;
|
|
|
|
setTextColor(m_defeaultColor);
|
|
|
|
}
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
#define BORDER_WIDTH 20
|
|
|
|
void GraphicsTextEdit::on_textChanged()
|
|
|
|
{
|
|
|
|
QFontMetrics fm(font());
|
|
|
|
|
|
|
|
QSize currentSize = this->size();
|
|
|
|
QStringList lineText = document()->toPlainText().split("\n", QString::SkipEmptyParts);
|
|
|
|
|
|
|
|
int idealWidth = 0;
|
|
|
|
for (const QString& str : lineText)
|
|
|
|
{
|
|
|
|
int width = fm.width(str);
|
|
|
|
if (width > idealWidth)
|
|
|
|
idealWidth = width;
|
|
|
|
}
|
|
|
|
int idelHeight = document()->lineCount() * fm.lineSpacing();
|
|
|
|
|
|
|
|
if (width() < idealWidth + BORDER_WIDTH)
|
|
|
|
currentSize.setWidth(idealWidth + BORDER_WIDTH);
|
|
|
|
if (height() < idelHeight + BORDER_WIDTH * 2)
|
|
|
|
currentSize.setHeight(idelHeight + BORDER_WIDTH * 2);
|
|
|
|
|
|
|
|
if (currentSize != this->size())
|
|
|
|
resize(currentSize);
|
2022-08-12 07:32:35 +00:00
|
|
|
|
|
|
|
if (toPlainText().isEmpty())
|
|
|
|
setTextColor(m_defeaultColor);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GraphicsScene::GraphicsScene(QObject* parent)
|
|
|
|
: QGraphicsScene(parent)
|
|
|
|
, m_status(Normal)
|
|
|
|
, m_activeItem(nullptr)
|
|
|
|
, m_pen(QColor(255, 0, 0, 255))
|
|
|
|
, m_brush(QColor(255, 255, 255, 255))
|
|
|
|
, m_font(tr("SongTi"))
|
2022-08-13 09:49:36 +00:00
|
|
|
, m_edit(nullptr)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
m_ItemList.clear();
|
|
|
|
m_curItemIndex = -1;
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GraphicsScene::~GraphicsScene()
|
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
for (int i = 0; i < (int)m_ItemList.size(); ++i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
}
|
|
|
|
m_ItemList.clear();
|
|
|
|
m_curItemIndex = -1;
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::setColor(const QColor& color)
|
|
|
|
{
|
|
|
|
m_pen.setColor(color);
|
|
|
|
m_brush.setColor(color);
|
2022-08-12 07:32:35 +00:00
|
|
|
if (m_edit != nullptr)
|
|
|
|
m_edit->setDefeaultColor(color);
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::setTextSize(int size)
|
|
|
|
{
|
|
|
|
m_font.setPointSize(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::setLineWidth(int width)
|
|
|
|
{
|
|
|
|
m_pen.setWidth(width);
|
|
|
|
}
|
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
void GraphicsScene::setItemFlag(int flag)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
flush();
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
switch (flag)
|
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
case Mask:
|
|
|
|
m_status = CreateMask;
|
|
|
|
break;
|
2022-05-03 10:25:52 +00:00
|
|
|
case Rect:
|
|
|
|
m_status = CreateRect;
|
|
|
|
break;
|
|
|
|
case Ellipse:
|
|
|
|
m_status = CreateEllipse;
|
|
|
|
break;
|
|
|
|
case Line:
|
|
|
|
m_status = CreateLine;
|
|
|
|
break;
|
|
|
|
case Text:
|
|
|
|
m_status = CreateText;
|
|
|
|
break;
|
|
|
|
case Arrow:
|
|
|
|
m_status = CreateArrow;
|
|
|
|
break;
|
|
|
|
case Pen:
|
|
|
|
m_status = CreatePen;
|
|
|
|
break;
|
|
|
|
default:
|
2022-08-12 07:32:35 +00:00
|
|
|
m_status = Normal;
|
2022-05-03 10:25:52 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
bool GraphicsScene::isCanUndo()
|
|
|
|
{
|
|
|
|
if (m_ItemList.empty() || -1 == m_curItemIndex)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::undo()
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
flush();
|
2022-12-05 10:08:46 +00:00
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
if (!isCanUndo())
|
2022-05-03 10:25:52 +00:00
|
|
|
return;
|
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
--m_curItemIndex;
|
|
|
|
updateShow();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GraphicsScene::isCanRedo()
|
|
|
|
{
|
|
|
|
if (m_ItemList.empty() || (int)m_ItemList.size() - 1 == m_curItemIndex)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::redo()
|
|
|
|
{
|
|
|
|
flush();
|
|
|
|
|
|
|
|
if (!isCanRedo())
|
|
|
|
return;
|
|
|
|
|
|
|
|
++m_curItemIndex;
|
|
|
|
updateShow();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::clear()
|
|
|
|
{
|
|
|
|
flush();
|
|
|
|
|
|
|
|
if (m_ItemList.empty())
|
|
|
|
return;
|
|
|
|
if (-1 == m_curItemIndex)
|
|
|
|
return;
|
|
|
|
if (NULL == m_ItemList[m_curItemIndex])
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (int i = (int)m_ItemList.size() - 1; i > m_curItemIndex; --i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
m_ItemList.erase(m_ItemList.begin() + i);
|
|
|
|
}
|
|
|
|
m_ItemList.push_back(NULL);
|
|
|
|
++m_curItemIndex;
|
|
|
|
updateShow();
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define PI acos(-1)
|
|
|
|
|
|
|
|
QPointF rotate(const QPointF& center, const QPointF& p, float angle)
|
|
|
|
{
|
|
|
|
float angle_ = angle;
|
|
|
|
float x = (p.x() - center.x()) * cos(angle_) - (p.y() - center.y()) * sin(angle_) + center.x();
|
|
|
|
float y = (p.y() - center.y()) * cos(angle_) + (p.x() - center.x()) * sin(angle_) + center.y();
|
|
|
|
|
|
|
|
return QPointF(x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
float lineLength(const QPointF& p1, const QPointF& p2)
|
|
|
|
{
|
|
|
|
return sqrt(pow(p1.x() - p2.x(), 2) + pow(p1.y() - p2.y(), 2));
|
|
|
|
}
|
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
void GraphicsScene::flush()
|
|
|
|
{
|
|
|
|
if (nullptr == m_activeItem)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_status == CreateText)
|
|
|
|
{
|
|
|
|
assert(typeid(*m_activeItem) == typeid(QGraphicsProxyWidget));
|
|
|
|
|
|
|
|
QString text = m_edit->document()->toPlainText();
|
|
|
|
QFont font = m_edit->font();
|
|
|
|
removeItem(m_activeItem);
|
|
|
|
m_activeItem = nullptr;
|
|
|
|
QGraphicsTextItem* item = addText(text, font);
|
|
|
|
item->setPos(m_edit->mapToParent(QPoint()));
|
|
|
|
item->setDefaultTextColor(m_pen.color());
|
|
|
|
for (int i = (int)m_ItemList.size() - 1; i > m_curItemIndex; --i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
m_ItemList.erase(m_ItemList.begin() + i);
|
|
|
|
}
|
|
|
|
m_ItemList.push_back(item);
|
|
|
|
++m_curItemIndex;
|
|
|
|
|
|
|
|
delete m_edit;
|
|
|
|
m_edit = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert(typeid(*m_activeItem) != typeid(QGraphicsProxyWidget));
|
|
|
|
|
|
|
|
for (int i = (int)m_ItemList.size() - 1; i > m_curItemIndex; --i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
m_ItemList.erase(m_ItemList.begin() + i);
|
|
|
|
}
|
|
|
|
m_ItemList.push_back(m_activeItem);
|
|
|
|
++m_curItemIndex;
|
|
|
|
m_activeItem = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::updateShow()
|
|
|
|
{
|
|
|
|
if (m_ItemList.empty() || -1 == m_curItemIndex || NULL == m_ItemList[m_curItemIndex])
|
|
|
|
{
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
QList<QGraphicsItem*> items = this->items();
|
|
|
|
if (items.count() < 2)
|
|
|
|
break;
|
|
|
|
removeItem(items.first());
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int startIndex = m_curItemIndex;
|
|
|
|
for (int i = m_curItemIndex; i >= 0; --i)
|
|
|
|
{
|
|
|
|
if (m_ItemList[i] == NULL)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
startIndex = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
QList<QGraphicsItem*> items = this->items();
|
|
|
|
if (items.count() < 2)
|
|
|
|
break;
|
|
|
|
removeItem(items.first());
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = startIndex; i <= m_curItemIndex; ++i)
|
|
|
|
{
|
|
|
|
this->addItem(m_ItemList[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
QPainterPath GraphicsScene::createArrowPath(const QPointF& p1, const QPointF& p2)
|
|
|
|
{
|
|
|
|
float angle;
|
|
|
|
if (p2.x() == p1.x())
|
|
|
|
if (p2.y() > p1.y())
|
|
|
|
angle = PI / 2;
|
|
|
|
else
|
|
|
|
angle = -PI / 2;
|
|
|
|
else
|
|
|
|
if (p2.x() < p1.x() && std::abs(p1.y() - p2.y()) < 0.000001)
|
|
|
|
angle = PI;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
angle = atan((p2.y() - p1.y()) / (p2.x() - p1.x()));
|
|
|
|
if (p2.y() < p1.y() && p2.x() < p1.x())
|
|
|
|
angle -= PI;
|
|
|
|
if (p2.y() > p1.y() && p2.x() < p1.x())
|
|
|
|
angle += PI;
|
|
|
|
}
|
|
|
|
|
|
|
|
float length = lineLength(p1, p2);
|
|
|
|
QPointF p_1 = rotate(p1, QPointF(p1.x() + length - 25, p1.y() + 15), angle);
|
|
|
|
QPointF p_2 = rotate(p1, QPointF(p1.x() + length - 25, p1.y() - 15), angle);
|
|
|
|
QPointF p_1_half = rotate(p1, QPointF(p1.x() + length - 22, p1.y() + 10), angle);
|
|
|
|
QPointF p_2_half = rotate(p1, QPointF(p1.x() + length - 22, p1.y() - 10), angle);
|
|
|
|
|
|
|
|
QPainterPath path;
|
|
|
|
path.moveTo(p2);
|
|
|
|
path.lineTo(p_2);
|
|
|
|
path.lineTo(p_2_half);
|
|
|
|
path.lineTo(p1);
|
|
|
|
path.lineTo(p_1_half);
|
|
|
|
path.lineTo(p_1);
|
|
|
|
path.lineTo(p2);
|
|
|
|
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)
|
|
|
|
{
|
|
|
|
if (m_activeItem == nullptr)
|
|
|
|
return;
|
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
if (!sceneRect().contains(mouseEvent->scenePos()))
|
|
|
|
return;
|
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
if (m_status == CreateMask)
|
|
|
|
{
|
|
|
|
QGraphicsRectItem* item = reinterpret_cast<QGraphicsRectItem*>(m_activeItem);
|
|
|
|
QPointF pos = mouseEvent->scenePos();
|
|
|
|
float left = qMin(pos.x(), m_startPoint.x());
|
|
|
|
float top = qMin(pos.y(), m_startPoint.y());
|
|
|
|
float right = qMax(pos.x(), m_startPoint.x());
|
|
|
|
float bottom = qMax(pos.y(), m_startPoint.y());
|
|
|
|
item->setRect(QRectF(QPointF(left, top), QPointF(right, bottom)));
|
|
|
|
}
|
|
|
|
else if (m_status == CreateRect)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
|
|
|
QGraphicsRectItem* item = reinterpret_cast<QGraphicsRectItem*>(m_activeItem);
|
|
|
|
QPointF pos = mouseEvent->scenePos();
|
|
|
|
float left = qMin(pos.x(), m_startPoint.x());
|
|
|
|
float top = qMin(pos.y(), m_startPoint.y());
|
|
|
|
float right = qMax(pos.x(), m_startPoint.x());
|
|
|
|
float bottom = qMax(pos.y(), m_startPoint.y());
|
|
|
|
item->setRect(QRectF(QPointF(left, top), QPointF(right, bottom)));
|
|
|
|
}
|
|
|
|
else if (m_status == CreateEllipse)
|
|
|
|
{
|
|
|
|
QGraphicsEllipseItem* item = reinterpret_cast<QGraphicsEllipseItem*>(m_activeItem);
|
|
|
|
QPointF pos = mouseEvent->scenePos();
|
|
|
|
float left = qMin(pos.x(), m_startPoint.x());
|
|
|
|
float top = qMin(pos.y(), m_startPoint.y());
|
|
|
|
float right = qMax(pos.x(), m_startPoint.x());
|
|
|
|
float bottom = qMax(pos.y(), m_startPoint.y());
|
|
|
|
item->setRect(QRectF(QPointF(left, top), QPointF(right, bottom)));
|
|
|
|
}
|
|
|
|
else if (m_status == CreateLine)
|
|
|
|
{
|
|
|
|
QGraphicsLineItem* item = reinterpret_cast<QGraphicsLineItem*>(m_activeItem);
|
|
|
|
item->setLine(QLineF(m_startPoint, mouseEvent->scenePos()));
|
|
|
|
}
|
|
|
|
else if (m_status == CreateArrow)
|
|
|
|
{
|
|
|
|
QGraphicsPathItem* item = reinterpret_cast<QGraphicsPathItem*>(m_activeItem);
|
|
|
|
item->setPath(createArrowPath(m_startPoint, mouseEvent->scenePos()));
|
|
|
|
}
|
|
|
|
else if (m_status == CreatePen)
|
|
|
|
{
|
|
|
|
QGraphicsPathItem* item = reinterpret_cast<QGraphicsPathItem*>(m_activeItem);
|
|
|
|
QPainterPath path = item->path();
|
|
|
|
path.lineTo(mouseEvent->scenePos());
|
|
|
|
item->setPath(path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)
|
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
if (m_status == CreateMask)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
|
|
|
m_activeItem = addRect(QRectF(mouseEvent->scenePos(), QSize(1, 1)), QPen(m_brush.color()), m_brush);
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
}
|
2023-08-14 10:11:27 +00:00
|
|
|
else if (m_status == CreateRect)
|
|
|
|
{
|
|
|
|
m_activeItem = addRect(QRectF(mouseEvent->scenePos(), QSize(1, 1)), m_pen, QBrush());
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
else if (m_status == CreateEllipse)
|
|
|
|
{
|
|
|
|
m_activeItem = addEllipse(QRectF(mouseEvent->scenePos(), QSize(1, 1)), m_pen, QBrush());
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
}
|
|
|
|
else if (m_status == CreateLine)
|
|
|
|
{
|
|
|
|
m_activeItem = addLine(QLineF(mouseEvent->scenePos(), mouseEvent->scenePos()), m_pen);
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
}
|
|
|
|
else if (m_status == CreateArrow)
|
|
|
|
{
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
m_activeItem = addPath(createArrowPath(m_startPoint, mouseEvent->scenePos()), m_pen, QBrush(m_pen.color()));
|
|
|
|
}
|
|
|
|
else if (m_status == CreatePen)
|
|
|
|
{
|
|
|
|
m_startPoint = mouseEvent->scenePos();
|
|
|
|
QPainterPath path(m_startPoint);
|
|
|
|
path.lineTo(m_startPoint + QPointF(1, 1));
|
|
|
|
m_activeItem = addPath(path, m_pen, QBrush());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
|
|
|
|
{
|
2022-08-12 07:32:35 +00:00
|
|
|
if (mouseEvent->button() == Qt::MouseButton::RightButton)
|
|
|
|
{
|
|
|
|
QGraphicsScene::mouseReleaseEvent(mouseEvent);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (m_status == CreateText)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-12 07:32:35 +00:00
|
|
|
if (m_activeItem != nullptr)
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2023-08-14 10:11:27 +00:00
|
|
|
assert(typeid(*m_activeItem) == typeid(QGraphicsProxyWidget));
|
2022-05-03 10:25:52 +00:00
|
|
|
QRectF r(m_edit->mapToParent(QPoint()), m_edit->size());
|
2022-08-12 07:32:35 +00:00
|
|
|
if (r.contains(mouseEvent->scenePos()))
|
2022-05-03 10:25:52 +00:00
|
|
|
{
|
2022-08-12 07:32:35 +00:00
|
|
|
QGraphicsScene::mouseReleaseEvent(mouseEvent);
|
|
|
|
return;
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
2023-08-14 10:11:27 +00:00
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
QString text = m_edit->document()->toPlainText();
|
|
|
|
QFont font = m_edit->font();
|
|
|
|
removeItem(m_activeItem);
|
2023-08-14 10:11:27 +00:00
|
|
|
m_activeItem = nullptr;
|
2022-08-12 07:32:35 +00:00
|
|
|
QGraphicsTextItem* item = addText(text, font);
|
|
|
|
item->setPos(m_edit->mapToParent(QPoint()));
|
|
|
|
item->setDefaultTextColor(m_pen.color());
|
2023-08-14 10:11:27 +00:00
|
|
|
for (int i = (int)m_ItemList.size() - 1; i > m_curItemIndex; --i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
m_ItemList.erase(m_ItemList.begin() + i);
|
|
|
|
}
|
|
|
|
m_ItemList.push_back(item);
|
|
|
|
++m_curItemIndex;
|
|
|
|
|
2022-08-12 07:32:35 +00:00
|
|
|
delete m_edit;
|
|
|
|
m_edit = nullptr;
|
2023-08-14 10:11:27 +00:00
|
|
|
emit itemChanged();
|
2022-08-12 07:32:35 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_edit = new GraphicsTextEdit();
|
|
|
|
m_edit->setDefeaultColor(m_pen.color());
|
|
|
|
m_edit->setFont(m_font);
|
|
|
|
QGraphicsProxyWidget* widget = addWidget(m_edit, Qt::FramelessWindowHint);
|
|
|
|
widget->setPos(mouseEvent->scenePos());
|
|
|
|
m_activeItem = widget;
|
|
|
|
m_edit->setFocus();
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
2023-08-14 10:11:27 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (m_activeItem != nullptr)
|
|
|
|
{
|
|
|
|
assert(typeid(*m_activeItem) != typeid(QGraphicsProxyWidget));
|
2022-05-03 10:25:52 +00:00
|
|
|
|
2023-08-14 10:11:27 +00:00
|
|
|
for (int i = (int)m_ItemList.size() - 1; i > m_curItemIndex; --i)
|
|
|
|
{
|
|
|
|
delete m_ItemList[i];
|
|
|
|
m_ItemList[i] = nullptr;
|
|
|
|
m_ItemList.erase(m_ItemList.begin() + i);
|
|
|
|
}
|
|
|
|
m_ItemList.push_back(m_activeItem);
|
|
|
|
++m_curItemIndex;
|
|
|
|
m_activeItem = nullptr;
|
|
|
|
emit itemChanged();
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
}
|
|
|
|
}
|