realAscot/qelectrotech-source-mirror
realAscot/qelectrotech-source-mirror
1
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2025-09-13 20:23:04 +02:00
Code Packages Releases 1 Activity

Revamp RealTerminal class...... again

Browse Source 
I don't know what I want, I'm crazy :D.
Next commit will also revamp PhysicalTerminal
and TerminalStripBridge class, code will be more clear and
easy to understand.
This commit is contained in:
joshua 2021-12-23 18:37:17 +01:00
parent 02b385e0b7
commit a2e5989f3b
7 changed files with 342 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sources/TerminalStrip/UndoCommand/changeterminallevel.cpp
View File

@ -25,7 +25,7 @@ ChangeTerminalLevel::ChangeTerminalLevel(TerminalStrip *strip,
m_strip(strip),
m_real_terminal(real_terminal),
m_new_level(level),
m_old_level(m_strip->realTerminalDataFor(real_terminal).level())
m_old_level(real_terminal.toStrongRef()->level())
{}
void ChangeTerminalLevel::undo()

4
sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp
View File

@ -54,7 +54,7 @@ void SortTerminalStripCommand::sort()
if (arg1.realTerminalCount())
{
str1 = arg1.realTerminalDatas().constLast().label();
str1 = arg1.realTerminals().constLast().toStrongRef()->label();
auto match = rx.match(str1);
if (match.hasMatch()) {
@ -64,7 +64,7 @@ void SortTerminalStripCommand::sort()
if (arg2.realTerminalCount())
{
str2 = arg2.realTerminalDatas().constLast().label();
str2 = arg2.realTerminals().constLast().toStrongRef()->label();
auto match = rx.match(str2);
if (match.hasMatch()) {

611
sources/TerminalStrip/terminalstrip.cpp
View File

@ -1,4 +1,4 @@
/*
/*
Copyright 2006-2021 The QElectroTech Team
This file is part of QElectroTech.
@ -26,7 +26,6 @@
using shared_real_terminal = QSharedPointer<RealTerminal>;
using shared_physical_terminal = QSharedPointer<PhysicalTerminal>;
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
@ -34,165 +33,268 @@ using shared_physical_terminal = QSharedPointer<PhysicalTerminal>;
/************************************************************************************/
/**
* @brief The RealTerminal class
* Represent a real terminal.
* A real terminal can be a drawed terminal in a folio
* or a terminal set by user but not present
* on any folio (for example a reserved terminal).
* @sa RealTerminalData
* @brief RealTerminal
* @param parent_strip : parent terminal strip
* @param terminal : terminal element (if any) in a folio
*/
class RealTerminal
RealTerminal::RealTerminal(TerminalStrip *parent_strip,
Element *terminal) :
m_element(terminal),
m_parent_terminal_strip(parent_strip)
{}
/**
* @brief RealTerminal::sharedRef
* @return a QSharedPointer of this
*/
QSharedPointer<RealTerminal> RealTerminal::sharedRef()
{
public :
QSharedPointer<RealTerminal> this_shared(this->weakRef());
if (this_shared.isNull())
{
this_shared = QSharedPointer<RealTerminal>(this);
m_this_weak = this_shared.toWeakRef();
}
/**
* @brief RealTerminal
* @param parent_strip : parent terminal strip
* @param terminal : terminal element (if any) in a folio
*/
RealTerminal(TerminalStrip *parent_strip, Element *terminal = nullptr) :
m_element(terminal),
m_parent_terminal_strip(parent_strip)
{}
return this_shared;
}
/**
/**
* @brief RealTerminal::weakRef
* @return a QWeakPointer of this
*/
QWeakPointer<RealTerminal> RealTerminal::weakRef() {
return m_this_weak;
}
/**
* @brief fromXml
* @param xml_element
* @return
*/
bool RealTerminal::fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector)
{
if (xml_element.tagName() != xmlTagName()) {
return true;
}
auto is_draw = xml_element.attribute(QStringLiteral("is_draw")) == QLatin1String("true")
? true : false;
QUuid uuid_(xml_element.attribute(QStringLiteral("uuid")));
if (is_draw) {
for (auto terminal : terminal_vector) {
if (terminal->uuid() == uuid_)
{
m_element = terminal;
break;
}
}
} else {
m_uuid = uuid_;
}
return true;
}
/**
* @brief toXml
* @param parent_document
* @return this real terminal to xml
*/
QDomElement RealTerminal::toXml(QDomDocument &parent_document) const
{
auto root_elmt = parent_document.createElement(this->xmlTagName());
root_elmt.setAttribute("is_draw", m_element ? "true" : "false");
root_elmt.setAttribute("uuid", m_element ? m_element->uuid().toString() :
m_uuid.toString());
return root_elmt;
}
/**
* @brief parentStrip
* @return parent terminal strip
*/
TerminalStrip *parentStrip() const {
return m_parent_terminal_strip.data();
}
/**
* @brief isElement
* @return true if this real terminal is linked to a terminal element
*/
bool isElement() const {
return m_element.isNull() ? false : true;
TerminalStrip *RealTerminal::parentStrip() const {
return m_parent_terminal_strip.data();
}
/**
* @brief RealTerminal::level
* @return
*/
int RealTerminal::level() const
{
if (m_parent_terminal_strip) {
const auto phy_t = m_parent_terminal_strip->physicalTerminalData(m_this_weak);
if (!phy_t.isNull()) {
return phy_t.realTerminals().indexOf(m_this_weak);
}
}
/**
* @brief element
* @return the element linked to this real terminal
* or nullptr if not linked to an Element.
*/
Element *element() const {
return m_element.data();
}
return -1;
}
/**
* @brief label
* @return the label of this real terminal
*/
QString label() const {
if (!m_element.isNull()) {
return m_element->actualLabel();
} else {
return QLatin1String();
}
}
/**
* @brief label
* @return the label of this real terminal
*/
QString RealTerminal::label() const {
if (!m_element.isNull()) {
return m_element->actualLabel();
} else {
return QLatin1String();
}
}
ElementData::TerminalType type() const {
if (m_element) {
return m_element->elementData().terminalType();
} else {
return ElementData::TTGeneric;
}
}
/**
* @brief RealTerminal::Xref
* @return Conveniant method to get the XRef
* formated to string
*/
QString RealTerminal::Xref() const
{
if (!m_element.isNull()) {
return autonum::AssignVariables::genericXref(m_element.data());
} else {
return QString();
}
}
ElementData::TerminalFunction function() const {
if (m_element) {
return m_element->elementData().terminalFunction();
} else {
return ElementData::TFGeneric;
}
}
/**
* @brief RealTerminal::cable
* @return
*/
QString RealTerminal::cable() const {
return QString();
}
bool led() const {
if (m_element) {
return m_element->elementData().terminalLed();
} else {
return false;
}
}
/**
* @brief RealTerminal::cableWire
* @return
*/
QString RealTerminal::cableWire() const {
return QString();
}
/**
* @brief elementUuid
* @return if this real terminal is an element
* in a folio, return the uuid of the element
* else return a null uuid.
*/
QUuid elementUuid() const {
if (!m_element.isNull()) {
return m_element->uuid();
} else {
return QUuid();
}
}
/**
* @brief RealTerminal::conductor
* @return
*/
QString RealTerminal::conductor() const {
return QString();
}
/**
* @brief uuid
* @return the uuid of this real terminal
*/
QUuid uuid() const {
return m_uuid;
}
/**
* @brief RealTerminal::type
* @return
*/
ElementData::TerminalType RealTerminal::type() const {
if (m_element) {
return m_element->elementData().terminalType();
} else {
return ElementData::TTGeneric;
}
}
static QString xmlTagName() {
return QStringLiteral("real_terminal");
}
/**
* @brief RealTerminal::function
* @return
*/
ElementData::TerminalFunction RealTerminal::function() const {
if (m_element) {
return m_element->elementData().terminalFunction();
} else {
return ElementData::TFGeneric;
}
}
/**
* @brief toXml
* @param parent_document
* @return this real terminal to xml
*/
QDomElement toXml(QDomDocument &parent_document) const
{
auto root_elmt = parent_document.createElement(this->xmlTagName());
root_elmt.setAttribute("is_draw", m_element ? "true" : "false");
root_elmt.setAttribute("uuid", m_element ? m_element->uuid().toString() :
m_uuid.toString());
/**
* @brief RealTerminal::isLed
* @return
*/
bool RealTerminal::isLed() const {
if (m_element) {
return m_element->elementData().terminalLed();
} else {
return false;
}
}
return root_elmt;
}
/**
* @brief isElement
* @return true if this real terminal is linked to a terminal element
*/
bool RealTerminal::isElement() const {
return m_element.isNull() ? false : true;
}
/**
* @brief fromXml
* @param xml_element
* @return
*/
bool fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector)
{
if (xml_element.tagName() != xmlTagName()) {
return true;
}
/**
* @brief RealTerminal::isBridged
* @return
*/
bool RealTerminal::isBridged() const
{
if (m_parent_terminal_strip) {
return !m_parent_terminal_strip->bridgeFor(m_this_weak).isNull();
} else {
return false;
}
}
auto is_draw = xml_element.attribute(QStringLiteral("is_draw")) == QLatin1String("true")
? true : false;
/**
* @brief RealTerminal::bridge
* @return
*/
QSharedPointer<TerminalStripBridge> RealTerminal::bridge() const
{
if (m_parent_terminal_strip) {
return m_parent_terminal_strip->bridgeFor(m_this_weak);
} else {
return QSharedPointer<TerminalStripBridge>();
}
}
QUuid uuid_(xml_element.attribute(QStringLiteral("uuid")));
/**
* @brief element
* @return the element linked to this real terminal
* or nullptr if not linked to an Element.
*/
Element *RealTerminal::element() const {
return m_element.data();
}
if (is_draw) {
for (auto terminal : terminal_vector) {
if (terminal->uuid() == uuid_)
{
m_element = terminal;
break;
}
}
} else {
m_uuid = uuid_;
}
/**
* @brief elementUuid
* @return if this real terminal is an element
* in a folio, return the uuid of the element
* else return a null uuid.
*/
QUuid RealTerminal::elementUuid() const {
if (!m_element.isNull()) {
return m_element->uuid();
} else {
return QUuid();
}
}
return true;
}
private :
QPointer<Element> m_element;
QPointer<TerminalStrip> m_parent_terminal_strip;
QUuid m_uuid = QUuid::createUuid();
};
/**
* @brief uuid
* @return the uuid of this real terminal
*/
QUuid RealTerminal::uuid() const {
return m_uuid;
}
/**
* @brief RealTerminal::RealTerminal::xmlTagName
* @return
*/
QString RealTerminal::RealTerminal::xmlTagName() {
return QStringLiteral("real_terminal");
}
/************************************************************************************/
/************************************************************************************/
@ -200,9 +302,6 @@ class RealTerminal
/************************************************************************************/
/************************************************************************************/
/**
* @brief The PhysicalTerminal class
* Represent a physical terminal.
@ -455,7 +554,8 @@ bool TerminalStrip::addTerminal(Element *terminal)
m_terminal_elements_vector.append(terminal);
//Create the real terminal
const shared_real_terminal real_terminal(new RealTerminal(this, terminal));
auto raw_ptr = new RealTerminal(this, terminal);
auto real_terminal = raw_ptr->sharedRef();
m_real_terminals.append(real_terminal);
//Create a new single level physical terminal
@ -748,8 +848,7 @@ bool TerminalStrip::isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real
}
// Get the level of the first terminal
const auto rtd_ = realTerminalDataFor(real_terminals.first());
const int level_ = rtd_.level();
const int level_ = real_terminals.first().toStrongRef()->level();
// Get the physical terminal and pos
auto first_physical_terminal = physicalTerminal(first_real_terminal);
@ -770,7 +869,7 @@ bool TerminalStrip::isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real
}
// at the same level
if (level_ != realTerminalDataFor(real_terminals.first()).level()) {
if (level_ != real_terminals.first().toStrongRef()->level()) {
return false;
}
@ -943,7 +1042,7 @@ bool TerminalStrip::canUnBridge(const QVector<QWeakPointer<RealTerminal> > &real
if (previous_real_t.isNull())
return true;
else {
const auto previous_bridge = isBridged(previous_real_t.realTerminal());
const auto previous_bridge = isBridged(previous_real_t);
if (compar_bridge != previous_bridge) {
return true;
}
@ -954,7 +1053,7 @@ bool TerminalStrip::canUnBridge(const QVector<QWeakPointer<RealTerminal> > &real
if (next_real_t.isNull()) {
return true;
} else {
const auto next_bridge = isBridged(next_real_t.realTerminal());
const auto next_bridge = isBridged(next_real_t);
if (compar_bridge != next_bridge) {
return true;
}
@ -975,7 +1074,7 @@ QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QWeakPointer<
* @return The previous real terminal at the samne level of @a real_t
* or a null RealTerminalData if there not a previous real terminal
*/
RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
QWeakPointer<RealTerminal> TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
{
const auto real_t = real_terminal.toStrongRef();
const auto phy_t = physicalTerminal(real_t);
@ -987,12 +1086,12 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealT
{
const auto t_vector = m_physical_terminals.at(index-1)->terminals();
if (t_vector.size() > level_) {
return RealTerminalData(t_vector.at(level_));
return t_vector.at(level_);
}
}
}
return RealTerminalData();
return QWeakPointer<RealTerminal>();
}
/**
@ -1001,7 +1100,7 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealT
* @return The next real terminal at the same level of @a real_t
* or a null RealTerminalData if there not a next real terminal
*/
RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
QWeakPointer<RealTerminal> TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
{
const auto real_t = real_terminal.toStrongRef();
const auto phy_t = physicalTerminal(real_t);
@ -1013,41 +1112,32 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTermi
{
const auto t_vector = m_physical_terminals.at(index+1)->terminals();
if (t_vector.size() > level_) {
return RealTerminalData(t_vector.at(level_));
return t_vector.at(level_);
}
}
}
return RealTerminalData();
return QWeakPointer<RealTerminal>();
}
RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
QWeakPointer<RealTerminal> TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
{
const auto real = real_terminal.toStrongRef();
const auto index = m_real_terminals.indexOf(real);
if (index) {
return RealTerminalData(m_real_terminals.at(index-1));
return m_real_terminals.at(index-1);
}
return RealTerminalData();
return QWeakPointer<RealTerminal>();
}
RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
QWeakPointer<RealTerminal> TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
{
const auto real = real_terminal.toStrongRef();
const auto index = m_real_terminals.indexOf(real);
if (index != m_real_terminals.size()-1) {
return RealTerminalData(m_real_terminals.at(index+1));
return m_real_terminals.at(index+1);
}
return RealTerminalData();
}
RealTerminalData TerminalStrip::realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const
{
const auto rt = real_terminal.toStrongRef();
if (rt && m_real_terminals.contains(rt))
return RealTerminalData(rt);
else
return RealTerminalData();
return QWeakPointer<RealTerminal>();
}
/**
@ -1112,7 +1202,8 @@ bool TerminalStrip::fromXml(QDomElement &xml_element)
//Read each real terminal of the current physical terminal of the loop
for (auto &xml_real : QETXML::findInDomElement(xml_physical, RealTerminal::xmlTagName()))
{
shared_real_terminal real_t(new RealTerminal(this));
auto raw_ptr = new RealTerminal(this);
auto real_t = raw_ptr->sharedRef();
real_t->fromXml(xml_real, free_terminals);
if(real_t->isElement())
{
@ -1241,171 +1332,6 @@ void TerminalStrip::rebuildRealVector()
/************************************************************************************/
/**
* @brief RealTerminalData::RealTerminalData
* @param real_terminal
*/
RealTerminalData::RealTerminalData(QSharedPointer<RealTerminal> real_terminal) :
m_real_terminal(real_terminal.toWeakRef())
{}
RealTerminalData::RealTerminalData(QWeakPointer<RealTerminal> real_terminal) :
m_real_terminal(real_terminal)
{}
bool RealTerminalData::isNull() const
{
return m_real_terminal.isNull();
}
int RealTerminalData::level() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
auto strip = shared_->parentStrip();
if (strip) {
auto phys = strip->physicalTerminal(shared_);
if (phys) {
return phys->levelOf(shared_);
}
}
}
return -1;
}
QString RealTerminalData::label() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->label();
} else {
return QString();
}
}
QString RealTerminalData::Xref() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_ && shared_->isElement()) {
return autonum::AssignVariables::genericXref(shared_->element());
} else {
return QString();
}
}
QString RealTerminalData::cable() const {
return QString();
}
QString RealTerminalData::cableWire() const {
return QString();
}
QString RealTerminalData::conductor() const {
return QString();
}
ElementData::TerminalType RealTerminalData::type() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->type();
}
return ElementData::TerminalType::TTGeneric;
}
ElementData::TerminalFunction RealTerminalData::function() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->function();
}
return ElementData::TerminalFunction::TFGeneric;
}
bool RealTerminalData::isLed() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->led();
}
return false;
}
bool RealTerminalData::isElement() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->isElement();
}
return false;
}
bool RealTerminalData::isBridged() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
auto strip = shared_->parentStrip();
if (strip) {
return !strip->isBridged(shared_).isNull();
}
}
return false;
}
/**
* @brief RealTerminalData::element
* @return The element represented by this real
* terminal, or nullptr
*/
Element *RealTerminalData::element() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
return shared_->element();
}
return nullptr;
}
QUuid RealTerminalData::elementUuid() const
{
const auto element_ = element();
if (element_) {
return element_->uuid();
}
return QUuid();
}
QSharedPointer<TerminalStripBridge> RealTerminalData::bridge() const
{
const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) {
auto strip = shared_->parentStrip();
if (strip) {
return strip->isBridged(shared_);
}
}
return QSharedPointer<TerminalStripBridge>();
}
QWeakPointer<RealTerminal> RealTerminalData::realTerminal() const
{
return m_real_terminal;
}
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
PhysicalTerminalData::PhysicalTerminalData(const TerminalStrip *strip, QSharedPointer<PhysicalTerminal> terminal) :
m_strip(strip),
m_physical_terminal(terminal.toWeakRef())
@ -1446,18 +1372,21 @@ int PhysicalTerminalData::realTerminalCount() const
}
QVector<RealTerminalData> PhysicalTerminalData::realTerminalDatas() const
QVector<QWeakPointer<RealTerminal>> PhysicalTerminalData::realTerminals() const
{
QVector<RealTerminalData> rtd_vector;
const auto pt_ = m_physical_terminal.toStrongRef();
if (pt_ && m_strip)
const auto phy_t = m_physical_terminal.toStrongRef();
if (phy_t)
{
for (const auto & rt_ : pt_->terminals()) {
rtd_vector.append(m_strip->realTerminalDataFor(rt_.toWeakRef()));
QVector<QWeakPointer<RealTerminal>> vector_;
for (const auto &real_t : phy_t->terminals()) {
vector_.append(real_t.toWeakRef());
}
return vector_;
}
else
{
return QVector<QWeakPointer<RealTerminal>>();
}
return rtd_vector;
}
QWeakPointer<PhysicalTerminal> PhysicalTerminalData::physicalTerminal() const {

52
sources/TerminalStrip/terminalstrip.h
View File

@ -40,18 +40,32 @@ struct TerminalStripBridge
QUuid uuid_ = QUuid::createUuid();
};
class RealTerminalData
/**
* @brief The RealTerminal class
* Represent a real terminal.
* A real terminal can be a drawed terminal in a folio
* or a terminal set by user but not present
* on any folio (for example a reserved terminal).
*
* When create a new instance of RealTerminal you must
* call sharedRef() and only use the returned QSharedPointer
* instead of the raw pointer
*/
class RealTerminal
{
friend class TerminalStrip;
friend class PhysicalTerminalData;
friend class PhysicalTerminal;
private:
RealTerminalData(QSharedPointer<RealTerminal> real_terminal);
RealTerminalData(QWeakPointer<RealTerminal> real_terminal);
RealTerminal(TerminalStrip *strip, Element *element = nullptr);
QSharedPointer<RealTerminal> sharedRef();
QWeakPointer<RealTerminal> weakRef();
bool fromXml(QDomElement xml_element, const QVector<TerminalElement *> &terminal_vector);
QDomElement toXml(QDomDocument &parent_document) const;
public:
RealTerminalData() {}
bool isNull() const;
TerminalStrip *parentStrip() const;
int level() const;
QString label() const;
QString Xref() const;
@ -66,14 +80,19 @@ class RealTerminalData
bool isElement() const;
bool isBridged() const;
QSharedPointer<TerminalStripBridge> bridge() const;
Element* element() const;
QUuid elementUuid() const;
QUuid uuid() const;
QSharedPointer<TerminalStripBridge> bridge() const;
QWeakPointer<RealTerminal> realTerminal() const;
static QString xmlTagName();
private:
QWeakPointer<RealTerminal> m_real_terminal;
private :
QPointer<Element> m_element;
QPointer<TerminalStrip> m_parent_terminal_strip;
QUuid m_uuid = QUuid::createUuid();
QWeakPointer<RealTerminal> m_this_weak;
};
/**
@ -95,7 +114,7 @@ class PhysicalTerminalData
int pos() const;
QUuid uuid() const;
int realTerminalCount() const;
QVector<RealTerminalData> realTerminalDatas() const;
QVector<QWeakPointer<RealTerminal>> realTerminals() const;
QWeakPointer<PhysicalTerminal> physicalTerminal() const;
private:
@ -177,11 +196,10 @@ class TerminalStrip : public QObject
bool canUnBridge(const QVector <QWeakPointer<RealTerminal>> &real_terminals) const;
QSharedPointer<TerminalStripBridge> bridgeFor(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const;
QWeakPointer<RealTerminal> previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
QWeakPointer<RealTerminal> nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
QWeakPointer<RealTerminal> previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
QWeakPointer<RealTerminal> nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const;
QVector<QPointer<Element>> terminalElement() const;

12
sources/TerminalStrip/ui/terminalstripeditor.cpp
View File

@ -234,13 +234,13 @@ QTreeWidgetItem* TerminalStripEditor::addTerminalStrip(TerminalStrip *terminal_s
auto ptd = terminal_strip->physicalTerminalData(i);
if (ptd.realTerminalCount())
{
const auto real_t = ptd.realTerminalDatas().at(0);
auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t.label()), TerminalStripTreeWidget::Terminal);
terminal_item->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t.elementUuid());
const auto real_t = ptd.realTerminals().at(0).toStrongRef();
auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t->label()), TerminalStripTreeWidget::Terminal);
terminal_item->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t->elementUuid());
terminal_item->setIcon(0, QET::Icons::ElementTerminal);
if (real_t.element()) {
m_uuid_terminal_H.insert(real_t.elementUuid(), qgraphicsitem_cast<TerminalElement *>(real_t.element()));
if (real_t->element()) {
m_uuid_terminal_H.insert(real_t->elementUuid(), qgraphicsitem_cast<TerminalElement *>(real_t->element()));
}
}
}
@ -644,7 +644,7 @@ void TerminalStripEditor::on_m_dialog_button_box_clicked(QAbstractButton *button
if (element->elementData() != current_data)
m_project->undoStack()->push(new ChangeElementDataCommand(element, current_data));
if (data_.level_ != m_current_strip->realTerminalDataFor(data_.real_terminal).level())
if (data_.level_ != data_.real_terminal.toStrongRef()->level())
m_project->undoStack()->push(new ChangeTerminalLevel(m_current_strip, data_.real_terminal, data_.level_));
}
}

46
sources/TerminalStrip/ui/terminalstripmodel.cpp
View File

@ -487,11 +487,11 @@ void TerminalStripModel::fillPhysicalTerminalData()
mptd.pos_ = ptd.pos();
mptd.uuid_ = ptd.uuid();
for (const auto &rtd : ptd.realTerminalDatas())
for (const auto &real_t : ptd.realTerminals())
{
if (!rtd.isNull())
if (!real_t.isNull())
{
mptd.real_data.append(modelRealData(rtd));
mptd.real_data.append(modelRealData(real_t));
}
}
@ -644,8 +644,15 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
auto bridge_ = m_terminal_strip->bridgeFor(mrtd.real_terminal);
if (bridge_)
{
auto previous_bridge = m_terminal_strip->previousTerminalInLevel(mrtd.real_terminal).bridge();
auto next_bridge = m_terminal_strip->nextTerminalInLevel(mrtd.real_terminal).bridge();
const auto previous_t = m_terminal_strip->previousTerminalInLevel(mrtd.real_terminal).toStrongRef();
QSharedPointer<TerminalStripBridge> previous_bridge;
if (previous_t)
previous_bridge = previous_t->bridge();
const auto next_t = m_terminal_strip->nextTerminalInLevel(mrtd.real_terminal).toStrongRef();
QSharedPointer<TerminalStripBridge> next_bridge;
if (next_t)
next_bridge = next_t->bridge();
auto color_ = bridge_->color_;
auto pixmap_ = m_bridges_pixmaps.value(color_);
@ -747,23 +754,24 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
return QPixmap();
}
modelRealTerminalData TerminalStripModel::modelRealData(const RealTerminalData &data)
modelRealTerminalData TerminalStripModel::modelRealData(const QWeakPointer<RealTerminal> &real_terminal)
{
modelRealTerminalData mrtd;
if (!data.isNull())
const auto real_t = real_terminal.toStrongRef();
if (!real_terminal.isNull())
{
mrtd.level_ = data.level();
mrtd.label_ = data.label();
mrtd.Xref_ = data.Xref();
mrtd.cable_ = data.cable();
mrtd.cable_wire = data.cableWire();
mrtd.conductor_ = data.conductor();
mrtd.led_ = data.isLed();
mrtd.type_ = data.type();
mrtd.function_ = data.function();
mrtd.element_ = data.element();
mrtd.real_terminal = data.realTerminal();
mrtd.bridged_ = data.isBridged();
mrtd.level_ = real_t->level();
mrtd.label_ = real_t->label();
mrtd.Xref_ = real_t->Xref();
mrtd.cable_ = real_t->cable();
mrtd.cable_wire = real_t->cableWire();
mrtd.conductor_ = real_t->conductor();
mrtd.led_ = real_t->isLed();
mrtd.type_ = real_t->type();
mrtd.function_ = real_t->function();
mrtd.element_ = real_t->element();
mrtd.real_terminal = real_terminal;
mrtd.bridged_ = real_t->isBridged();
}
return mrtd;

2
sources/TerminalStrip/ui/terminalstripmodel.h
View File

@ -124,7 +124,7 @@ class TerminalStripModel : public QAbstractTableModel
modelRealTerminalData realDataAtIndex(int index) const;
QPixmap bridgePixmapFor(const QModelIndex &index) const;
static modelRealTerminalData modelRealData(const RealTerminalData &data);
static modelRealTerminalData modelRealData(const QWeakPointer<RealTerminal> &real_terminal);
private:
QPointer<TerminalStrip> m_terminal_strip;