YXS
/
nmWTAI-Platform
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

清理plot中不需要的图元文件

Browse Source
feature/nm-para-property-20260615
lvjunjie 2 weeks ago
parent 9b36d2ad1d
commit 403ef6c1e3
12 changed files with 0 additions and 2002 deletions
Show Stats Download Patch File Download Diff File

67
Include/nmNum/nmPlot/nmObjFault.h
Unescape Escape View File

@ -1,67 +0,0 @@
#pragma once
#include "nmObjBase.h"
#include "nmDefines.h"
#include "nmPlot_global.h"
// 数值试井绘图对象(断层，其实就是多条折线，或者说不封闭的多边形)
class NM_PLOT_EXPORT nmObjFault : public nmObjBase
{
Q_OBJECT
ZX_DECLARE_DYNAMIC
public:
nmObjFault();
nmObjFault(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY);
~nmObjFault();
// 设置初始参数
virtual void init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY) override;
// 设置Tools
virtual void initTools() override;
protected:
// 设置图元对象的属性标志
virtual void initFlags() override;
public:
// 击中
virtual bool hitTest(const QPointF& pt) override;
// 具体击中实现的函数，单纯击中，不做选项的改变
// nOption用int是因为Rect类的击中选项不一致
// nOption为负值，表示未击中，此时返回false
virtual bool _runHitTest(const QPointF& pt, \
int& nOption, int& nSubIndex) override;
// 击中后，ButtonUp后的处理
// pt1:鼠标Down点，pt2：鼠标Up点
virtual bool runMove(const QPointF& pt1, const QPointF& pt2) override;
public:
// 属性填充内容
virtual void fillPtyPano(IxPtyPano* sheet) override;
// 成果序列化
virtual void onSerialize(ZxSerializer* ser) override;
virtual void onDeserialize(ZxSerializer* ser) override;
// 模版处理（从道理上讲，模版处理与成果序列化机制完全一致）
// 但此处放开是为了调用方更灵活的控制
virtual void onLoadTempl(ZxSerializer* ser) override;
virtual void onSaveTempl(ZxSerializer* ser) override;
virtual void paintBack(QPainter* painter, \
const ZxPaintParam& param) override;
public:
};

48
Include/nmNum/nmPlot/nmObjFaultTool.h
Unescape Escape View File

@ -1,48 +0,0 @@
#pragma once
#include "nmObjToolBase.h"
// 数值试井绘图对象之工具(断层，其实就是多条折线，或者说不封闭的多边形)
class NM_PLOT_EXPORT nmObjFaultTool : public nmObjToolBase
{
Q_OBJECT
public:
nmObjFaultTool();
public:
// 鼠标各种响应
virtual bool onLeftDown(const QPointF& pt) override;
virtual bool onLeftUp(const QPointF& pt) override;
virtual bool onMouseMove(const QPointF& pt) override;
virtual bool onMouseWheel(const QPointF& pt, int delta) override;
virtual bool onLeftDoubleClick(const QPointF& pt) override;
// 绘制
virtual void onPaint(QPainter* painter, const ZxPaintParam& param) override;
private:
// 绑定数据对象情况下绘制(真实)
void paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param);
// 尚未绑定数据对象情况下绘制(虚拟)
void paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param);
protected:
// 根据鼠标当前选择情况确定不同的光标类型
virtual Qt::CursorShape getCursorBy(const int& nOption,
const int& nSubIndex) override;
protected:
// 鼠标点缓存
QVector<QPointF> m_vecPoints;
};

75
Include/nmNum/nmPlot/nmObjFracture.h
Unescape Escape View File

@ -1,75 +0,0 @@
#pragma once
#include "nmObjBase.h"
#include "nmDefines.h"
#include "nmPlot_global.h"
// 数值试井绘图对象(断层，其实就是多条折线，或者说不封闭的多边形)
class NM_PLOT_EXPORT nmObjFracture : public nmObjBase
{
Q_OBJECT
ZX_DECLARE_DYNAMIC
public:
nmObjFracture();
nmObjFracture(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY);
~nmObjFracture();
// 设置初始参数
virtual void init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY) override;
// 设置Tools
virtual void initTools() override;
protected:
// 设置图元对象的属性标志
virtual void initFlags() override;
public:
// 击中
virtual bool hitTest(const QPointF& pt) override;
// 具体击中实现的函数，单纯击中，不做选项的改变
// nOption用int是因为Rect类的击中选项不一致
// nOption为负值，表示未击中，此时返回false
virtual bool _runHitTest(const QPointF& pt, \
int& nOption, int& nSubIndex) override;
// 击中后，ButtonUp后的处理
// pt1:鼠标Down点，pt2：鼠标Up点
virtual bool runMove(const QPointF& pt1, const QPointF& pt2) override;
public:
// 属性填充内容
virtual void fillPtyPano(IxPtyPano* sheet) override;
// 成果序列化
virtual void onSerialize(ZxSerializer* ser) override;
virtual void onDeserialize(ZxSerializer* ser) override;
// 模版处理（从道理上讲，模版处理与成果序列化机制完全一致）
// 但此处放开是为了调用方更灵活的控制
virtual void onLoadTempl(ZxSerializer* ser) override;
virtual void onSaveTempl(ZxSerializer* ser) override;
virtual void paintBack(QPainter* painter, \
const ZxPaintParam& param) override;
public:
// 填充背景颜色
QColor getBackgrdColor() const;
void setBackgrdColor(QColor color);
public:
QColor m_clrBackgrd;//填充颜色
};

48
Include/nmNum/nmPlot/nmObjFractureTool.h
Unescape Escape View File

@ -1,48 +0,0 @@
#pragma once
#include "nmObjToolBase.h"
// 数值试井绘图对象之工具(裂缝)
class NM_PLOT_EXPORT nmObjFractureTool : public nmObjToolBase
{
Q_OBJECT
public:
nmObjFractureTool();
public:
// 鼠标各种响应
virtual bool onLeftDown(const QPointF& pt) override;
virtual bool onLeftUp(const QPointF& pt) override;
virtual bool onMouseMove(const QPointF& pt) override;
virtual bool onMouseWheel(const QPointF& pt, int delta) override;
virtual bool onLeftDoubleClick(const QPointF& pt) override;
// 绘制
virtual void onPaint(QPainter* painter, const ZxPaintParam& param) override;
private:
// 绑定数据对象情况下绘制(真实)
void paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param);
// 尚未绑定数据对象情况下绘制(虚拟)
void paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param);
protected:
// 根据鼠标当前选择情况确定不同的光标类型
virtual Qt::CursorShape getCursorBy(const int& nOption,
const int& nSubIndex) override;
protected:
// 鼠标点缓存
QVector<QPointF> m_vecPoints;
};

79
Include/nmNum/nmPlot/nmObjLimit.h
Unescape Escape View File

@ -1,79 +0,0 @@
#pragma once
#include "nmObjBase.h"
#include "nmDefines.h"
#include "nmPlot_global.h"
// 数值试井绘图对象(边界范围，其实也是多边形)
class NM_PLOT_EXPORT nmObjLimit : public nmObjBase
{
Q_OBJECT
ZX_DECLARE_DYNAMIC
public:
nmObjLimit();
nmObjLimit(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY);
~nmObjLimit();
// 设置初始参数
virtual void init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY) override;
// 设置Tools
virtual void initTools() override;
protected:
// 设置图元对象的属性标志
virtual void initFlags() override;
public:
// 击中
virtual bool hitTest(const QPointF& pt) override;
// 具体击中实现的函数，单纯击中，不做选项的改变
// nOption用int是因为Rect类的击中选项不一致
// nOption为负值，表示未击中，此时返回false
virtual bool _runHitTest(const QPointF& pt, \
int& nOption, int& nSubIndex) override;
// 击中后，ButtonUp后的处理
// pt1:鼠标Down点，pt2：鼠标Up点
virtual bool runMove(const QPointF& pt1, const QPointF& pt2) override;
public:
// 属性填充内容
virtual void fillPtyPano(IxPtyPano* sheet) override;
// 成果序列化
virtual void onSerialize(ZxSerializer* ser) override;
virtual void onDeserialize(ZxSerializer* ser) override;
// 模版处理（从道理上讲，模版处理与成果序列化机制完全一致）
// 但此处放开是为了调用方更灵活的控制
virtual void onLoadTempl(ZxSerializer* ser) override;
virtual void onSaveTempl(ZxSerializer* ser) override;
virtual void paintBack(QPainter* painter, \
const ZxPaintParam& param) override;
public:
// 填充背景颜色
QColor getBackgrdColor() const;
void setBackgrdColor(QColor color);
// 背景透明度
int getBackgrdAlpha() const;
void setBackgrdAlpha(int nAlpha);
public:
QColor m_clrBackgrd;//填充颜色
};

47
Include/nmNum/nmPlot/nmObjLimitTool.h
Unescape Escape View File

@ -1,47 +0,0 @@
#pragma once
#include "nmObjToolBase.h"
// 数值试井绘图对象之工具(边界范围，其实也是多边形)
class NM_PLOT_EXPORT nmObjLimitTool : public nmObjToolBase
{
Q_OBJECT
public:
nmObjLimitTool();
public:
// 鼠标各种响应
virtual bool onLeftDown(const QPointF& pt) override;
virtual bool onLeftUp(const QPointF& pt) override;
virtual bool onMouseMove(const QPointF& pt) override;
virtual bool onMouseWheel(const QPointF& pt, int delta) override;
virtual bool onLeftDoubleClick(const QPointF& pt) override;
// 绘制
virtual void onPaint(QPainter* painter, const ZxPaintParam& param) override;
private:
// 绑定数据对象情况下绘制(真实)
void paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param);
// 尚未绑定数据对象情况下绘制(虚拟)
void paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param);
protected:
// 根据鼠标当前选择情况确定不同的光标类型
virtual Qt::CursorShape getCursorBy(const int& nOption,
const int& nSubIndex) override;
protected:
QVector<QPointF> m_vecPoints; // 鼠标点缓存
};

257
Src/nmNum/nmPlot/nmObjFault.cpp
Unescape Escape View File

@ -1,257 +0,0 @@
#include <QPainter>
#include "ZxSerializer.h"
#include "IxPtyPano.h"
#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"
#include "nmObjFaultTool.h"
#include "nmObjFault.h"
ZX_DEFINE_DYNAMIC(nObjFault, nmObjFault)
nmObjFault::nmObjFault()
{
m_sObjTag = "nObjFault";
nmObjFault::init("", nullptr, nullptr);
}
nmObjFault::nmObjFault(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
m_sObjTag = "nObjFault";
nmObjFault::init(sName, pAxisX, pAxisY);
}
nmObjFault::~nmObjFault()
{
}
void nmObjFault::init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
nmObjBase::init(sName, pAxisX, pAxisY);
nmObjFault::initFlags();
m_oPen = QPen(QBrush(QColor(0, 255, 164)), \
0.5, Qt::SolidLine);
loadTempl();
}
void nmObjFault::initTools()
{
m_pTool = new nmObjFaultTool();
nmObjBase::initTools();
}
void nmObjFault::initFlags()
{
setLockPos(false);
setLockSize(false);
setReadOnly(false);
}
bool nmObjFault::hitTest(const QPointF& pt)
{
return nmObjBase::hitTest(pt);
}
bool nmObjFault::_runHitTest(const QPointF& pt, int& nOption, int& nSubIndex)
{
if (!nmObjBase::_runHitTest(pt, nOption, nSubIndex))
{
return false;
}
nOption = -1;
nSubIndex = 0;
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
QVector<QPointF> pts = getPosOf(m_vecPoints);
// 点
double r = 1.0;
for (int i = 0; i < pts.count(); i++)
{
QPointF ptTopLeft = QPointF(pts[i].x() - r,
pts[i].y() - r);
QSizeF sz = QSizeF(r * 2.0, r * 2.0);
QRectF rt = QRectF(ptTopLeft, sz);
bool b = rt.contains(pt);
if (b)
{
nOption = (int)OHO_Point;
nSubIndex = i;
return true;
}
}
// 线
for (int i = 0; i < pts.count()/* - 1*/; i++)
{
int n1 = i;
int n2 = (i == pts.count() - 1 ? 0 : i + 1);
if (_isNearLine(pt, pts[n1], pts[n2], 1.0 * 2))
{
nOption = (int)OHO_Bound;
nSubIndex = i;
return true;
}
}
return false;
}
bool nmObjFault::runMove(const QPointF& pt1,
const QPointF& pt2)
{
if (isLockPos())
{
return false;
}
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
//emit sigRunMoveTo(pt1, pt2);
int nCount = m_vecPoints.count();
QVector<QPointF> vecPts = getPosOf(m_vecPoints); //屏幕值
if (m_oHitOption == OHO_Point && m_nHitIndex >= 0)
{
vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
pt1, pt2);
return moveToPos(vecPts);
}
else if (m_oHitOption == OHO_Bound && m_nHitIndex >= 0)
{
for (int i = 0; i < nCount; i++)
{
vecPts[i] = offsetPoint(vecPts[i], pt1, pt2);
}
m_dOffsetX = pt2.x() - pt1.x();
m_dOffsetY = pt2.y() - pt1.y();
return moveToPos(vecPts);
}
else
{
return false;
}
return true;
}
void nmObjFault::fillPtyPano(IxPtyPano* sheet)
{
nmObjBase::fillPtyPano(sheet);
ZX_PROP("ObjFault.Pen", getPen, setPen);
// ZX_PROP("ObjFault.BackgrdColor", getBackgrdColor, setBackgrdColor);
}
void nmObjFault::onSerialize(ZxSerializer* ser)
{
nmObjBase::onSerialize(ser);
// ser->write("BackgrdColor", m_clrBackgrd);
}
void nmObjFault::onDeserialize(ZxSerializer* ser)
{
nmObjBase::onDeserialize(ser);
// ser->read("BackgrdColor", m_clrBackgrd);
}
void nmObjFault::onSaveTempl(ZxSerializer* ser)
{
nmObjBase::onSaveTempl(ser);
// ser->write("BackgrdColor", m_clrBackgrd);
}
void nmObjFault::onLoadTempl(ZxSerializer* ser)
{
nmObjBase::onLoadTempl(ser);
// ser->read("BackgrdColor", m_clrBackgrd);
}
void nmObjFault::paintBack(QPainter* painter, const ZxPaintParam& param)
{
if (nullptr == m_pAxisX || nullptr == m_pAxisY || \
m_pAxisX->getRangeMin() == m_pAxisX->getRangeMax() || \
m_pAxisY->getRangeMin() == m_pAxisY->getRangeMax())
{
return;
}
QVector<QPointF> pts = getPosOf(m_vecPoints);
if (!pts.empty())
{
painter->save();
QRectF rt = getOuterRect();
painter->setClipRect(rt);
QPen pen = m_oPen;
if (isSelected()) //选中状态下
{
//pen = QPen(QBrush(Qt::red), 0.0f, Qt::DotLine);
pen.setStyle(Qt::DotLine);
painter->setPen(pen);
}
painter->setPen(pen);
for (int i = 1; i < pts.count(); i++)
{
QPointF pt1 = pts[i - 1];
QPointF pt2 = pts[i];
QLineF oLine = QLineF(pt1, pt2);
painter->drawLine(oLine);
}
if (isSelected()) //选中状态下
{
for (int i = 0; i < pts.count(); i++)
{
double w = 2.2;
QPointF pt = pts[i];
QRectF rect(pt.x() - w * 0.5, pt.y() - w * 0.5, w, w);
{
painter->setPen(QColor(0, 0, 128));
painter->drawRect(rect);
}
}
}
// 绘制名称文字
QRectF bound = getBounds();
QFont ft = qApp->font();
ft.setPointSize(8);
painter->setFont(ft);
painter->setPen(Qt::black);
ZxDrawHelper::drawText(painter,
bound,
Qt::AlignCenter|Qt::AlignVCenter,
m_sName);
painter->restore();
}
}

227
Src/nmNum/nmPlot/nmObjFaultTool.cpp
Unescape Escape View File

@ -1,227 +0,0 @@
#include <QPainter>
#include "ZxBaseUtil.h"
#include "nmObjFault.h"
#include "nmObjFaultTool.h"
nmObjFaultTool::nmObjFaultTool() : nmObjToolBase()
{
setText(tr("nObjFaultTool"));
m_oNot = NMOT_Fault;
}
bool nmObjFaultTool::onLeftDown(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_bTracking = true;
m_ptStart = pt;
changeCursor(Qt::CrossCursor);
// 对于持续性选点的工具，需要设置
getView()->setCursorKeeping(true);
m_vecPoints.push_back(pt);
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDown(pt);
}
}
bool nmObjFaultTool::onMouseMove(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_ptMove = pt;
if (m_bTracking)
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onMouseMove(pt);
}
}
bool nmObjFaultTool::onLeftUp(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
if (!m_vecPoints.isEmpty()) //避免本工具被Detach之后无法update
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftUp(pt);
}
}
bool nmObjFaultTool::onLeftDoubleClick(const QPointF& pt)
{
if (nullptr == m_pObj && m_vecPoints.count() >= 2) //绘图对象尚未创建(鼠标选点ing）
{
changeCursor(Qt::ArrowCursor);
emit sigPtsFinished(m_vecPoints); //注：该句正确执行之后，会把本工具nmObjFaultTool
//与View之间detach
m_vecPoints.clear();
if (m_bTracking)
{
m_bTracking = false;
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDoubleClick(pt);
}
}
bool nmObjFaultTool::onMouseWheel(const QPointF& pt, int delta)
{
return nmObjToolBase::onMouseWheel(pt, delta);
}
void nmObjFaultTool::onPaint(QPainter* painter, const ZxPaintParam& param)
{
nmObjFault* pObj = dynamic_cast<nmObjFault*>(m_pObj);
if (pObj == nullptr) //绘图对象尚未创建(鼠标选点ing）
{
Qt::CursorShape o = Qt::CrossCursor;
changeCursor(o);
paintTrackingVirtualObj(painter, param);
}
else //业已绑定绘图对象
{
paintTrackingRealObj(painter, param);
}
}
void nmObjFaultTool::paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param)
{
painter->save();
// 已经选的点
{
QPen pen(Qt::SolidLine);
painter->setPen(pen);
for (int i = 0; i < m_vecPoints.count() - 1; i++)
{
painter->drawLine(m_vecPoints[i], m_vecPoints[i + 1]);
}
}
// 当前正在进行的点
if (m_bTracking || !m_vecPoints.isEmpty())
{
QPen pen(Qt::DashLine);
painter->setPen(pen);
painter->drawLine(m_ptStart, m_ptMove);
}
painter->restore();
}
void nmObjFaultTool::paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param)
{
if (!m_bTracking)
{
return;
}
nmObjFault* pObj = dynamic_cast<nmObjFault*>(m_pObj);
Q_ASSERT (nullptr != pObj);
if (nullptr == pObj)
{
return; // 如果pObj为nullptr，直接返回
}
int nIndex = pObj->m_nHitIndex;
Qt::CursorShape o = getCursorBy((int)m_oHitOption, nIndex);
QVector<QPointF> vec = pObj->getAllPos();
QPointF ptOld = m_ptStart;
QPointF ptNew = getCurrentPos();
if (m_oHitOption == OHO_Point)
{
if (nIndex >= 0 && nIndex < vec.count())
{
vec[nIndex] = getCurrentPos();
}
}
else if (m_oHitOption == OHO_Bound)
{
// if (nIndex >= 0 && nIndex < vec.count() - 1)
// {
// vec[nIndex] = pObj->offsetPoint(vec[nIndex], ptOld, ptNew);
// vec[nIndex + 1] = pObj->offsetPoint(vec[nIndex + 1], ptOld, ptNew);
// }
// }
// else if (m_oHitOption == OHO_Inner)
// {
for (int i = 0; i < vec.count(); i++)
{
vec[i] = pObj->offsetPoint(vec[i], ptOld, ptNew);
}
}
else
{
return;
}
painter->save();
QPen pen(Qt::DashLine);
painter->setPen(pen);
for (int i = 1; i < vec.count(); i++)
{
QPointF pt1 = vec[i - 1];
QPointF pt2 = vec[i];
QLineF oLine = QLineF(pt1, pt2);
painter->drawLine(oLine);
}
// QColor clr = pObj->getBackgrdColor();
// clr.setAlpha(128);
// painter->fillPath(oPath, QBrush(clr));
changeCursor(o);
painter->restore();
}
Qt::CursorShape nmObjFaultTool::getCursorBy(const int& nOption,
const int& nSubIndex)
{
if (nOption < 0)
{
return Qt::ArrowCursor;
}
ObjHitOption oHitOption = (ObjHitOption)nOption;
if (oHitOption == OHO_Point)
{
return (Qt::CrossCursor);
}
else if (oHitOption == OHO_Bound)
{
// return (Qt::SizeAllCursor);
// }
// else if (oHitOption == OHO_Inner)
// {
return (Qt::SizeAllCursor);
}
return Qt::ArrowCursor;
}

312
Src/nmNum/nmPlot/nmObjFracture.cpp
Unescape Escape View File

@ -1,312 +0,0 @@
#include <QPainter>
#include "ZxSerializer.h"
#include "IxPtyPano.h"
#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"
#include "nmObjFractureTool.h"
#include "nmObjFracture.h"
ZX_DEFINE_DYNAMIC(nObjFracture, nmObjFracture)
nmObjFracture::nmObjFracture()
{
m_sObjTag = "nObjFracture";
nmObjFracture::init("", nullptr, nullptr);
}
nmObjFracture::nmObjFracture(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
m_sObjTag = "nObjFracture";
nmObjFracture::init(sName, pAxisX, pAxisY);
}
nmObjFracture::~nmObjFracture()
{
}
void nmObjFracture::init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
nmObjBase::init(sName, pAxisX, pAxisY);
nmObjFracture::initFlags();
m_oPen = QPen(QBrush(QColor(128, 128, 128)), \
0.3, Qt::SolidLine);
m_clrBackgrd = QColor(255, 170, 255, 100);
loadTempl();
}
void nmObjFracture::initTools()
{
m_pTool = new nmObjFractureTool();
nmObjBase::initTools();
}
void nmObjFracture::initFlags()
{
setLockPos(false);
setLockSize(false);
setReadOnly(false);
}
bool nmObjFracture::hitTest(const QPointF& pt)
{
return nmObjBase::hitTest(pt);
}
bool nmObjFracture::_runHitTest(const QPointF& pt, int& nOption, int& nSubIndex)
{
if (!nmObjBase::_runHitTest(pt, nOption, nSubIndex))
{
return false;
}
nOption = -1;
nSubIndex = 0;
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
QVector<QPointF> pts = getPosOf(m_vecPoints);
// 点
double r = 1.0;
for (int i = 0; i < pts.count(); i++)
{
QPointF ptTopLeft = QPointF(pts[i].x() - r,
pts[i].y() - r);
QSizeF sz = QSizeF(r * 2.0, r * 2.0);
QRectF rt = QRectF(ptTopLeft, sz);
bool b = rt.contains(pt);
if (b)
{
nOption = (int)OHO_Point;
nSubIndex = i;
return true;
}
}
// 线
for (int i = 0; i < pts.count()/* - 1*/; i++)
{
int n1 = i;
int n2 = (i == pts.count() - 1 ? 0 : i + 1);
if (_isNearLine(pt, pts[n1], pts[n2], 1.0 * 2))
{
nOption = (int)OHO_Bound;
nSubIndex = i;
return true;
}
}
// 内部
QPainterPath oPath;
oPath.moveTo(pts[0]);
for (int i = 1; i < pts.count(); i++)
{
oPath.lineTo(pts[i]);
}
oPath.closeSubpath();
if (oPath.contains(pt))
{
nOption = (int)OHO_Inner;
nSubIndex = 0;
return true;
}
return false;
}
bool nmObjFracture::runMove(const QPointF& pt1,
const QPointF& pt2)
{
if (isLockPos())
{
return false;
}
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
//emit sigRunMoveTo(pt1, pt2);
int nCount = m_vecPoints.count();
QVector<QPointF> vecPts = getPosOf(m_vecPoints); //屏幕值
if (m_oHitOption == OHO_Point && m_nHitIndex >= 0)
{
vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
pt1, pt2);
return moveToPos(vecPts);
}
else if (m_oHitOption == OHO_Bound && m_nHitIndex >= 0)
{
vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
pt1, pt2);
vecPts[m_nHitIndex + 1] = offsetPoint(vecPts[m_nHitIndex + 1],
pt1, pt2);
return moveToPos(vecPts);
}
else if (m_oHitOption == OHO_Inner)
{
for (int i = 0; i < nCount; i++)
{
vecPts[i] = offsetPoint(vecPts[i], pt1, pt2);
}
m_dOffsetX = pt2.x() - pt1.x();
m_dOffsetY = pt2.y() - pt1.y();
return moveToPos(vecPts);
}
else
{
return false;
}
return true;
}
void nmObjFracture::fillPtyPano(IxPtyPano* sheet)
{
nmObjBase::fillPtyPano(sheet);
ZX_PROP("ObjFracture.Pen", getPen, setPen);
ZX_PROP("ObjFracture.BackgrdColor", getBackgrdColor, setBackgrdColor);
}
void nmObjFracture::onSerialize(ZxSerializer* ser)
{
nmObjBase::onSerialize(ser);
ser->write("BackgrdColor", m_clrBackgrd);
// for ()
// {
// ser->write("BackgrdColor", m_clrBackgrd);
// }
}
void nmObjFracture::onDeserialize(ZxSerializer* ser)
{
nmObjBase::onDeserialize(ser);
ser->read("BackgrdColor", m_clrBackgrd);
}
void nmObjFracture::onSaveTempl(ZxSerializer* ser)
{
nmObjBase::onSaveTempl(ser);
ser->write("BackgrdColor", m_clrBackgrd);
}
void nmObjFracture::onLoadTempl(ZxSerializer* ser)
{
nmObjBase::onLoadTempl(ser);
ser->read("BackgrdColor", m_clrBackgrd);
}
QColor nmObjFracture::getBackgrdColor() const
{
//if (m_nLineIndex)
//return m_vecPresType[m_nLineIndex]
return m_clrBackgrd;
}
void nmObjFracture::setBackgrdColor(QColor color)
{
if (m_clrBackgrd != color)
{
//m_vecPresType[m_nLineIndex] =
m_clrBackgrd = color;
update();
}
}
void nmObjFracture::paintBack(QPainter* painter, const ZxPaintParam& param)
{
if (nullptr == m_pAxisX || nullptr == m_pAxisY || \
m_pAxisX->getRangeMin() == m_pAxisX->getRangeMax() || \
m_pAxisY->getRangeMin() == m_pAxisY->getRangeMax())
{
return;
}
painter->save();
QVector<QPointF> pts = getPosOf(m_vecPoints);
QRectF bound = getBounds();
if (!pts.empty())
{
// 填充
QPainterPath oPath;
oPath.moveTo(pts[0]);
for (int i = 1; i < pts.count(); i++)
{
oPath.lineTo(pts[i]);
}
oPath.closeSubpath();
// m_clrBackgrd.setAlpha(100);
painter->fillPath(oPath, QBrush(m_clrBackgrd));
// 边界
QPen pen = m_oPen;
painter->setPen(pen);
painter->drawPolygon(&pts[0], pts.count());
// 绘制名称文字
QFont ft = qApp->font();
ft.setPointSize(8);
painter->setFont(ft);
painter->setPen(Qt::black);
ZxDrawHelper::drawText(painter,
bound,
Qt::AlignCenter|Qt::AlignVCenter,
m_sName);
}
if (isSelected()) //选中状态下
{
QPen pen(QBrush(Qt::black), 0.0f, Qt::DotLine);
painter->setPen(pen);
painter->drawPolygon(&pts[0], pts.count());
for (int i = 0; i < pts.count(); i++)
{
double w = 2.2;
QPointF pt = pts[i];
QRectF rect(pt.x() - w * 0.5, pt.y() - w * 0.5, w, w);
if (m_nHitIndex == i && m_oHitOption == OHO_Point)
{
QBrush br(Qt::red);
painter->fillRect(rect, br);
}
// else if (m_nHitIndex == i && m_oHitOption == OHO_Bound)
// {
// //QBrush br(Qt::red);
// painter->setPen(QColor(0, 0, 255));
// painter->drawLine(pts[i], pts[i + 1]);
// }
else
{
painter->setPen(QColor(0, 0, 128));
painter->drawRect(rect);
}
}
}
painter->restore();
}

254
Src/nmNum/nmPlot/nmObjFractureTool.cpp
Unescape Escape View File

@ -1,254 +0,0 @@
#include <QPainter>
#include "ZxBaseUtil.h"
#include "nmObjFracture.h"
#include "nmObjFractureTool.h"
nmObjFractureTool::nmObjFractureTool() : nmObjToolBase()
{
setText(tr("nObjFractureTool"));
m_oNot = NMOT_Fracture;
}
bool nmObjFractureTool::onLeftDown(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_bTracking = true;
m_ptStart = pt;
changeCursor(Qt::CrossCursor);
// 对于持续性选点的工具，需要设置
getView()->setCursorKeeping(true);
if (m_vecPoints.count() > 2) //如果与第一个点非常接近，自动封闭处理
{
double nDistance = 3.0f;
if ((qAbs(m_vecPoints[0].x() - pt.x()) < nDistance) && \
(qAbs(m_vecPoints[0].y() - pt.y()) < nDistance))
{
getView()->setCursorKeeping(false);
changeCursor(Qt::ArrowCursor);
emit sigPtsFinished(m_vecPoints); //注：该句正确执行之后，会把本工具nmObjFractureTool
//与View之间detach
m_vecPoints.clear();
m_bTracking = false;
return true;
}
}
m_vecPoints.push_back(pt);
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDown(pt);
}
}
bool nmObjFractureTool::onMouseMove(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_ptMove = pt;
if (m_bTracking)
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onMouseMove(pt);
}
}
bool nmObjFractureTool::onLeftUp(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
// if (m_bTracking)
// {
// m_bTracking = false;
// }
if (!m_vecPoints.isEmpty()) //避免本工具被Detach之后无法update
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftUp(pt);
}
}
bool nmObjFractureTool::onLeftDoubleClick(const QPointF& pt)
{
if (nullptr == m_pObj && m_vecPoints.count() >= 2) //绘图对象尚未创建(鼠标选点ing）
{
changeCursor(Qt::ArrowCursor);
emit sigPtsFinished(m_vecPoints); //注：该句正确执行之后，会把本工具nmObjFractureTool
//与View之间detach
m_vecPoints.clear();
if (m_bTracking)
{
m_bTracking = false;
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDoubleClick(pt);
}
}
bool nmObjFractureTool::onMouseWheel(const QPointF& pt, int delta)
{
return nmObjToolBase::onMouseWheel(pt, delta);
}
void nmObjFractureTool::onPaint(QPainter* painter, const ZxPaintParam& param)
{
nmObjFracture* pObj = dynamic_cast<nmObjFracture*>(m_pObj);
if (pObj == nullptr) //绘图对象尚未创建(鼠标选点ing）
{
Qt::CursorShape o = Qt::CrossCursor;
changeCursor(o);
paintTrackingVirtualObj(painter, param);
}
else //业已绑定绘图对象
{
paintTrackingRealObj(painter, param);
}
}
void nmObjFractureTool::paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param)
{
painter->save();
// 已经选的点
{
QPen pen(Qt::SolidLine);
painter->setPen(pen);
for (int i = 0; i < m_vecPoints.count() - 1; i++)
{
painter->drawLine(m_vecPoints[i], m_vecPoints[i + 1]);
}
}
// 当前正在进行的点
if (m_bTracking || !m_vecPoints.isEmpty())
{
QPen pen(Qt::DashLine);
painter->setPen(pen);
painter->drawLine(m_ptStart, m_ptMove);
if (m_vecPoints.count() >= 2)
{
painter->drawLine(m_vecPoints[0], m_ptMove);
}
}
painter->restore();
}
void nmObjFractureTool::paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param)
{
if (!m_bTracking)
{
return;
}
nmObjFracture* pObj = dynamic_cast<nmObjFracture*>(m_pObj);
Q_ASSERT (nullptr != pObj);
if (nullptr == pObj)
{
return; // 如果pObj为nullptr，直接返回
}
int nIndex = pObj->m_nHitIndex;
Qt::CursorShape o = getCursorBy((int)m_oHitOption, nIndex);
QVector<QPointF> vec = pObj->getAllPos();
QPointF ptOld = m_ptStart;
QPointF ptNew = getCurrentPos();
if (m_oHitOption == OHO_Point)
{
if (nIndex >= 0 && nIndex < vec.count())
{
vec[nIndex] = getCurrentPos();
}
}
else if (m_oHitOption == OHO_Bound)
{
if (nIndex >= 0 && nIndex < vec.count() - 1)
{
vec[nIndex] = pObj->offsetPoint(vec[nIndex], ptOld, ptNew);
vec[nIndex + 1] = pObj->offsetPoint(vec[nIndex + 1], ptOld, ptNew);
}
}
else if (m_oHitOption == OHO_Inner)
{
for (int i = 0; i < vec.count(); i++)
{
vec[i] = pObj->offsetPoint(vec[i], ptOld, ptNew);
}
}
else
{
return;
}
painter->save();
QPen pen(Qt::DashLine);
painter->setPen(pen);
QPainterPath oPath;
oPath.moveTo(vec[0]);
for (int i = 1; i < vec.count(); i++)
{
oPath.lineTo(vec[i]);
}
oPath.closeSubpath();
QColor clr = pObj->getBackgrdColor();
clr.setAlpha(128);
painter->fillPath(oPath, QBrush(clr));
changeCursor(o);
painter->restore();
}
Qt::CursorShape nmObjFractureTool::getCursorBy(const int& nOption,
const int& nSubIndex)
{
if (nOption < 0)
{
return Qt::ArrowCursor;
}
ObjHitOption oHitOption = (ObjHitOption)nOption;
if (oHitOption == OHO_Point)
{
return (Qt::CrossCursor);
}
else if (oHitOption == OHO_Bound)
{
return (Qt::SizeAllCursor);
}
else if (oHitOption == OHO_Inner)
{
return (Qt::SizeAllCursor);
}
return Qt::ArrowCursor;
}

334
Src/nmNum/nmPlot/nmObjLimit.cpp
Unescape Escape View File

@ -1,334 +0,0 @@
#include <QPainter>
#include "ZxSerializer.h"
#include "IxPtyPano.h"
#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"
#include "nmObjLimitTool.h"
#include "nmObjLimit.h"
ZX_DEFINE_DYNAMIC(nObjLimit, nmObjLimit)
nmObjLimit::nmObjLimit()
{
m_sObjTag = "nObjLimit";
nmObjLimit::init("", nullptr, nullptr);
}
nmObjLimit::nmObjLimit(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
m_sObjTag = "nObjLimit";
nmObjLimit::init(sName, pAxisX, pAxisY);
}
nmObjLimit::~nmObjLimit()
{
}
void nmObjLimit::init(const QString& sName, \
ZxSubAxisX* pAxisX, \
ZxSubAxisY* pAxisY)
{
nmObjBase::init(sName, pAxisX, pAxisY);
nmObjLimit::initFlags();
m_oPen = QPen(QBrush(QColor(128, 128, 128)), \
0.3, Qt::SolidLine);
m_clrBackgrd = QColor(170, 170, 0, 30);
loadTempl();
}
void nmObjLimit::initTools()
{
m_pTool = new nmObjLimitTool();
nmObjBase::initTools();
}
void nmObjLimit::initFlags()
{
setLockPos(false);
setLockSize(false);
setReadOnly(false);
}
bool nmObjLimit::hitTest(const QPointF& pt)
{
return nmObjBase::hitTest(pt);
}
bool nmObjLimit::_runHitTest(const QPointF& pt, int& nOption, int& nSubIndex)
{
if (!nmObjBase::_runHitTest(pt, nOption, nSubIndex))
{
return false;
}
nOption = -1;
nSubIndex = 0;
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
QVector<QPointF> pts = getPosOf(m_vecPoints);
// 点
double r = 1.0;
for (int i = 0; i < pts.count(); i++)
{
QPointF ptTopLeft = QPointF(pts[i].x() - r,
pts[i].y() - r);
QSizeF sz = QSizeF(r * 2.0, r * 2.0);
QRectF rt = QRectF(ptTopLeft, sz);
bool b = rt.contains(pt);
if (b)
{
nOption = (int)OHO_Point;
nSubIndex = i;
return true;
}
}
// 线
for (int i = 0; i < pts.count()/* - 1*/; i++)
{
int n1 = i;
int n2 = (i == pts.count() - 1 ? 0 : i + 1);
if (_isNearLine(pt, pts[n1], pts[n2], 1.0 * 2))
{
nOption = (int)OHO_Bound;
nSubIndex = i;
return true;
}
}
// 内部
QPainterPath oPath;
oPath.moveTo(pts[0]);
for (int i = 1; i < pts.count(); i++)
{
oPath.lineTo(pts[i]);
}
oPath.closeSubpath();
if (oPath.contains(pt))
{
nOption = (int)OHO_Inner;
nSubIndex = 0;
return true;
}
return false;
}
bool nmObjLimit::runMove(const QPointF& pt1,
const QPointF& pt2)
{
if (isLockPos())
{
return false;
}
if (nullptr == m_pAxisX || nullptr == m_pAxisY)
{
return false;
}
//emit sigRunMoveTo(pt1, pt2);
int nCount = m_vecPoints.count();
QVector<QPointF> vecPts = getPosOf(m_vecPoints); //屏幕值
if (m_oHitOption == OHO_Point && m_nHitIndex >= 0)
{
vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
pt1, pt2);
return moveToPos(vecPts);
}
else if (m_oHitOption == OHO_Bound && m_nHitIndex >= 0)
{
vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
pt1, pt2);
vecPts[m_nHitIndex + 1] = offsetPoint(vecPts[m_nHitIndex + 1],
pt1, pt2);
return moveToPos(vecPts);
}
else if (m_oHitOption == OHO_Inner)
{
for (int i = 0; i < nCount; i++)
{
vecPts[i] = offsetPoint(vecPts[i], pt1, pt2);
}
m_dOffsetX = pt2.x() - pt1.x();
m_dOffsetY = pt2.y() - pt1.y();
return moveToPos(vecPts);
}
else
{
return false;
}
return true;
}
void nmObjLimit::fillPtyPano(IxPtyPano* sheet)
{
nmObjBase::fillPtyPano(sheet);
ZX_PROP("ObjLimit.Pen", getPen, setPen);
ZX_PROP("ObjLimit.BackgrdColor", getBackgrdColor, setBackgrdColor);
ZX_PROP("ObjLimit.BackgrdColorAlpha", getBackgrdAlpha, setBackgrdAlpha);
}
void nmObjLimit::onSerialize(ZxSerializer* ser)
{
nmObjBase::onSerialize(ser);
ser->write("BackgrdColor", m_clrBackgrd);
// for ()
// {
// ser->write("BackgrdColor", m_clrBackgrd);
// }
}
void nmObjLimit::onDeserialize(ZxSerializer* ser)
{
nmObjBase::onDeserialize(ser);
ser->read("BackgrdColor", m_clrBackgrd);
}
void nmObjLimit::onSaveTempl(ZxSerializer* ser)
{
nmObjBase::onSaveTempl(ser);
ser->write("BackgrdColor", m_clrBackgrd);
}
void nmObjLimit::onLoadTempl(ZxSerializer* ser)
{
nmObjBase::onLoadTempl(ser);
ser->read("BackgrdColor", m_clrBackgrd);
}
//QColor nmObjLimit::getBackgrdColor() const
//{
// //if (m_nLineIndex)
// //return m_vecPresType[m_nLineIndex]
// return m_clrBackgrd;
//}
//void nmObjLimit::setBackgrdColor(QColor color)
//{
// if (m_clrBackgrd != color)
// {
// //m_vecPresType[m_nLineIndex] =
// m_clrBackgrd = color;
// update();
// }
//}
QColor nmObjLimit::getBackgrdColor() const
{
return m_clrBackgrd;
}
void nmObjLimit::setBackgrdColor(QColor clr)
{
m_clrBackgrd.setRed(clr.red());
m_clrBackgrd.setGreen(clr.green());
m_clrBackgrd.setBlue(clr.blue());
update();
}
int nmObjLimit::getBackgrdAlpha() const
{
return m_clrBackgrd.alpha();
}
void nmObjLimit::setBackgrdAlpha(int nAlpha)
{
m_clrBackgrd.setAlpha(nAlpha);
update();
}
void nmObjLimit::paintBack(QPainter* painter, const ZxPaintParam& param)
{
if (nullptr == m_pAxisX || nullptr == m_pAxisY || \
m_pAxisX->getRangeMin() == m_pAxisX->getRangeMax() || \
m_pAxisY->getRangeMin() == m_pAxisY->getRangeMax())
{
return;
}
painter->save();
QVector<QPointF> pts = getPosOf(m_vecPoints);
QRectF bound = getBounds();
if (!pts.empty())
{
// 填充
QPainterPath oPath;
oPath.moveTo(pts[0]);
for (int i = 1; i < pts.count(); i++)
{
oPath.lineTo(pts[i]);
}
oPath.closeSubpath();
// m_clrBackgrd.setAlpha(100);
painter->fillPath(oPath, QBrush(m_clrBackgrd));
// 边界
QPen pen = m_oPen;
painter->setPen(pen);
painter->drawPolygon(&pts[0], pts.count());
// 绘制名称文字
QFont ft = qApp->font();
ft.setPointSize(8);
painter->setFont(ft);
painter->setPen(Qt::black);
ZxDrawHelper::drawText(painter,
bound,
Qt::AlignCenter|Qt::AlignVCenter,
m_sName);
}
if (isSelected()) //选中状态下
{
QPen pen(QBrush(Qt::black), 0.0f, Qt::DotLine);
painter->setPen(pen);
painter->drawPolygon(&pts[0], pts.count());
for (int i = 0; i < pts.count(); i++)
{
double w = 2.2;
QPointF pt = pts[i];
QRectF rect(pt.x() - w * 0.5, pt.y() - w * 0.5, w, w);
if (m_nHitIndex == i && m_oHitOption == OHO_Point)
{
QBrush br(Qt::red);
painter->fillRect(rect, br);
}
// else if (m_nHitIndex == i && m_oHitOption == OHO_Bound)
// {
// //QBrush br(Qt::red);
// painter->setPen(QColor(0, 0, 255));
// painter->drawLine(pts[i], pts[i + 1]);
// }
else
{
painter->setPen(QColor(0, 0, 128));
painter->drawRect(rect);
}
}
}
painter->restore();
}

254
Src/nmNum/nmPlot/nmObjLimitTool.cpp
Unescape Escape View File

@ -1,254 +0,0 @@
#include <QPainter>
#include "ZxBaseUtil.h"
#include "nmObjLimit.h"
#include "nmObjLimitTool.h"
nmObjLimitTool::nmObjLimitTool() : nmObjToolBase()
{
setText(tr("nObjLimitTool"));
m_oNot = NMOT_Limit;
}
bool nmObjLimitTool::onLeftDown(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_bTracking = true;
m_ptStart = pt;
changeCursor(Qt::CrossCursor);
// 对于持续性选点的工具，需要设置
getView()->setCursorKeeping(true);
if (m_vecPoints.count() > 2) //如果与第一个点非常接近，自动封闭处理
{
double nDistance = 3.0f;
if ((qAbs(m_vecPoints[0].x() - pt.x()) < nDistance) && \
(qAbs(m_vecPoints[0].y() - pt.y()) < nDistance))
{
getView()->setCursorKeeping(false);
changeCursor(Qt::ArrowCursor);
emit sigPtsFinished(m_vecPoints); //注：该句正确执行之后，会把本工具nmObjLimitTool
//与View之间detach
m_vecPoints.clear();
m_bTracking = false;
return true;
}
}
m_vecPoints.push_back(pt);
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDown(pt);
}
}
bool nmObjLimitTool::onMouseMove(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
m_ptMove = pt;
if (m_bTracking)
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onMouseMove(pt);
}
}
bool nmObjLimitTool::onLeftUp(const QPointF& pt)
{
if (nullptr == m_pObj) //绘图对象尚未创建(鼠标选点ing）
{
// if (m_bTracking)
// {
// m_bTracking = false;
// }
if (!m_vecPoints.isEmpty()) //避免本工具被Detach之后无法update
{
updateLastMoveArea(true);
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftUp(pt);
}
}
bool nmObjLimitTool::onLeftDoubleClick(const QPointF& pt)
{
if (nullptr == m_pObj && m_vecPoints.count() >= 2) //绘图对象尚未创建(鼠标选点ing）
{
changeCursor(Qt::ArrowCursor);
emit sigPtsFinished(m_vecPoints); //注：该句正确执行之后，会把本工具nmObjLimitTool
//与View之间detach
m_vecPoints.clear();
if (m_bTracking)
{
m_bTracking = false;
}
return true;
}
else //业已绑定绘图对象
{
return nmObjToolBase::onLeftDoubleClick(pt);
}
}
bool nmObjLimitTool::onMouseWheel(const QPointF& pt, int delta)
{
return nmObjToolBase::onMouseWheel(pt, delta);
}
void nmObjLimitTool::onPaint(QPainter* painter, const ZxPaintParam& param)
{
nmObjLimit* pObj = dynamic_cast<nmObjLimit*>(m_pObj);
if (pObj == nullptr) //绘图对象尚未创建(鼠标选点ing）
{
Qt::CursorShape o = Qt::CrossCursor;
changeCursor(o);
paintTrackingVirtualObj(painter, param);
}
else //业已绑定绘图对象
{
paintTrackingRealObj(painter, param);
}
}
void nmObjLimitTool::paintTrackingVirtualObj(QPainter* painter, const ZxPaintParam& param)
{
painter->save();
// 已经选的点
{
QPen pen(Qt::SolidLine);
painter->setPen(pen);
for (int i = 0; i < m_vecPoints.count() - 1; i++)
{
painter->drawLine(m_vecPoints[i], m_vecPoints[i + 1]);
}
}
// 当前正在进行的点
if (m_bTracking || !m_vecPoints.isEmpty())
{
QPen pen(Qt::DashLine);
painter->setPen(pen);
painter->drawLine(m_ptStart, m_ptMove);
if (m_vecPoints.count() >= 2)
{
painter->drawLine(m_vecPoints[0], m_ptMove);
}
}
painter->restore();
}
void nmObjLimitTool::paintTrackingRealObj(QPainter* painter, const ZxPaintParam& param)
{
if (!m_bTracking)
{
return;
}
nmObjLimit* pObj = dynamic_cast<nmObjLimit*>(m_pObj);
Q_ASSERT (nullptr != pObj);
if (nullptr == pObj)
{
return; // 如果pObj为nullptr，直接返回
}
int nIndex = pObj->m_nHitIndex;
Qt::CursorShape o = getCursorBy((int)m_oHitOption, nIndex);
QVector<QPointF> vec = pObj->getAllPos();
QPointF ptOld = m_ptStart;
QPointF ptNew = getCurrentPos();
if (m_oHitOption == OHO_Point)
{
if (nIndex >= 0 && nIndex < vec.count())
{
vec[nIndex] = getCurrentPos();
}
}
else if (m_oHitOption == OHO_Bound)
{
if (nIndex >= 0 && nIndex < vec.count() - 1)
{
vec[nIndex] = pObj->offsetPoint(vec[nIndex], ptOld, ptNew);
vec[nIndex + 1] = pObj->offsetPoint(vec[nIndex + 1], ptOld, ptNew);
}
}
else if (m_oHitOption == OHO_Inner)
{
for (int i = 0; i < vec.count(); i++)
{
vec[i] = pObj->offsetPoint(vec[i], ptOld, ptNew);
}
}
else
{
return;
}
painter->save();
QPen pen(Qt::DashLine);
painter->setPen(pen);
QPainterPath oPath;
oPath.moveTo(vec[0]);
for (int i = 1; i < vec.count(); i++)
{
oPath.lineTo(vec[i]);
}
oPath.closeSubpath();
QColor clr = pObj->getBackgrdColor();
clr.setAlpha(128);
painter->fillPath(oPath, QBrush(clr));
changeCursor(o);
painter->restore();
}
Qt::CursorShape nmObjLimitTool::getCursorBy(const int& nOption,
const int& nSubIndex)
{
if (nOption < 0)
{
return Qt::ArrowCursor;
}
ObjHitOption oHitOption = (ObjHitOption)nOption;
if (oHitOption == OHO_Point)
{
return (Qt::CrossCursor);
}
else if (oHitOption == OHO_Bound)
{
return (Qt::SizeAllCursor);
}
else if (oHitOption == OHO_Inner)
{
return (Qt::SizeAllCursor);
}
return Qt::ArrowCursor;
}
Write Preview
Loading…
Cancel
Save