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

Improve code readability

Browse Source
This commit is contained in:
joshua 2021-12-19 21:05:48 +01:00
parent 57e80e7b5e
commit e2454faa36
7 changed files with 215 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -84,7 +84,7 @@ void UnGroupTerminalsCommand::setUp(const QVector<QWeakPointer<RealTerminal>> &t
auto ptd_ = m_terminal_strip->physicalTerminalData(rt_); auto ptd_ = m_terminal_strip->physicalTerminalData(rt_);
//Physical have only one real terminal, no need to ungroup it //Physical have only one real terminal, no need to ungroup it
if (ptd_.real_terminals_vector.size() <= 1) { if (ptd_.realTerminalCount() <= 1) {
continue; continue;
} }

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

@ -52,9 +52,9 @@ void SortTerminalStripCommand::sort()
int int1 =-1; int int1 =-1;
int int2 =-1; int int2 =-1;
if (arg1.real_terminals_vector.count()) if (arg1.realTerminalCount())
{ {
str1 = arg1.real_terminals_vector.constLast().label(); str1 = arg1.realTerminalDatas().constLast().label();
auto match = rx.match(str1); auto match = rx.match(str1);
if (match.hasMatch()) { if (match.hasMatch()) {
@ -62,9 +62,9 @@ void SortTerminalStripCommand::sort()
} }
} }
if (arg2.real_terminals_vector.count()) if (arg2.realTerminalCount())
{ {
str2 = arg2.real_terminals_vector.constLast().label(); str2 = arg2.realTerminalDatas().constLast().label();
auto match = rx.match(str2); auto match = rx.match(str2);
if (match.hasMatch()) { if (match.hasMatch()) {

2
sources/TerminalStrip/UndoCommand/sortterminalstripcommand.h
View File

@ -23,7 +23,7 @@
#include <QVector> #include <QVector>
class TerminalStrip; class TerminalStrip;
struct PhysicalTerminalData; class PhysicalTerminalData;
/** /**
* @brief The SortTerminalStripCommand class * @brief The SortTerminalStripCommand class

331
sources/TerminalStrip/terminalstrip.cpp
View File

@ -431,11 +431,8 @@ TerminalStripData TerminalStrip::data() const {
* of the terminal strip unchanged * of the terminal strip unchanged
* @param data * @param data
*/ */
void TerminalStrip::setData(const TerminalStripData &data) void TerminalStrip::setData(const TerminalStripData &data) {
{
auto uuid_ = m_data.m_uuid;
m_data = data; m_data = data;
m_data.m_uuid = uuid_;
} }
/** /**
@ -458,11 +455,11 @@ bool TerminalStrip::addTerminal(Element *terminal)
m_terminal_elements_vector.append(terminal); m_terminal_elements_vector.append(terminal);
//Create the real terminal //Create the real terminal
shared_real_terminal real_terminal(new RealTerminal(this, terminal)); const shared_real_terminal real_terminal(new RealTerminal(this, terminal));
m_real_terminals.append(real_terminal); m_real_terminals.append(real_terminal);
//Create a new single level physical terminal //Create a new single level physical terminal
shared_physical_terminal physical_terminal( const shared_physical_terminal physical_terminal(
new PhysicalTerminal(this, new PhysicalTerminal(this,
QVector<shared_real_terminal>{real_terminal})); QVector<shared_real_terminal>{real_terminal}));
@ -511,6 +508,16 @@ bool TerminalStrip::removeTerminal(Element *terminal)
return false; return false;
} }
/**
* @brief TerminalStrip::pos
* @param terminal
* @return the position of the physical terminal
* or -1 if not found
*/
int TerminalStrip::pos(const QWeakPointer<PhysicalTerminal> &terminal) const {
return m_physical_terminals.indexOf(terminal.toStrongRef());
}
/** /**
* @brief TerminalStrip::physicalTerminalCount * @brief TerminalStrip::physicalTerminalCount
* @return the number of physical terminal. * @return the number of physical terminal.
@ -528,20 +535,11 @@ int TerminalStrip::physicalTerminalCount() const {
*/ */
PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const
{ {
PhysicalTerminalData ptd; if (index < m_physical_terminals.size()) {
return PhysicalTerminalData(this, m_physical_terminals.at(index));
if (index < m_physical_terminals.size()) } else {
{ return PhysicalTerminalData();
auto physical_terminal = m_physical_terminals.at(index);
ptd.pos_ = index;
for (auto real_terminal : physical_terminal->terminals()) {
auto rtd = RealTerminalData(real_terminal);
ptd.real_terminals_vector.append(rtd);
}
ptd.uuid_ = physical_terminal->uuid();
} }
return ptd;
} }
/** /**
@ -550,28 +548,19 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const
* @return the parent PhysicalTerminalData of \p real_terminal. * @return the parent PhysicalTerminalData of \p real_terminal.
* the PhysicalTerminalData can be invalid if \p real_terminal don't belong to this strip * the PhysicalTerminalData can be invalid if \p real_terminal don't belong to this strip
*/ */
PhysicalTerminalData TerminalStrip::physicalTerminalData (QWeakPointer<RealTerminal> real_terminal) const PhysicalTerminalData TerminalStrip::physicalTerminalData (const QWeakPointer<RealTerminal> &real_terminal) const
{ {
PhysicalTerminalData ptd_;
const auto real_t = real_terminal.toStrongRef(); const auto real_t = real_terminal.toStrongRef();
if (real_t.isNull()) { if (real_t.isNull()) {
return ptd_; return PhysicalTerminalData();
} }
const auto phy_t = physicalTerminal(real_t); const auto phy_t = physicalTerminal(real_t);
if (phy_t.isNull()) { if (phy_t) {
return ptd_; return PhysicalTerminalData(this, phy_t);
} }
ptd_.pos_ = m_physical_terminals.indexOf(phy_t); return PhysicalTerminalData();
for (auto real_terminal : phy_t->terminals()) {
auto rtd = RealTerminalData(real_terminal);
ptd_.real_terminals_vector.append(rtd);
}
ptd_.uuid_ = phy_t->uuid();
return ptd_;
} }
/** /**
@ -612,7 +601,7 @@ bool TerminalStrip::setOrderTo(const QVector<PhysicalTerminalData> &sorted_vecto
QVector<QSharedPointer<PhysicalTerminal>> new_order; QVector<QSharedPointer<PhysicalTerminal>> new_order;
for (const auto &ptd : sorted_vector) for (const auto &ptd : sorted_vector)
{ {
const auto physical_t = physicalTerminalForUuid(ptd.uuid_); const auto physical_t = ptd.physicalTerminal().toStrongRef();
if (physical_t.isNull()) { if (physical_t.isNull()) {
continue; continue;
} }
@ -643,7 +632,7 @@ bool TerminalStrip::setOrderTo(const QVector<PhysicalTerminalData> &sorted_vecto
*/ */
bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals) bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals)
{ {
const auto receiver_ = physicalTerminalForUuid(receiver_terminal.uuid_); const auto receiver_ = receiver_terminal.physicalTerminal().toStrongRef();
if (receiver_.isNull()) { if (receiver_.isNull()) {
qDebug() << "TerminalStrip::groupTerminal : Arguments terminals don't belong to this strip. Operation aborted."; qDebug() << "TerminalStrip::groupTerminal : Arguments terminals don't belong to this strip. Operation aborted.";
return false; return false;
@ -696,7 +685,7 @@ void TerminalStrip::unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &
if (physical_terminal->terminals().size() > 1) //Check if physical have more than one real terminal if (physical_terminal->terminals().size() > 1) //Check if physical have more than one real terminal
{ {
physical_terminal->removeTerminal(real_terminal); physical_terminal->removeTerminal(real_terminal);
shared_physical_terminal new_physical_terminal ( const shared_physical_terminal new_physical_terminal (
new PhysicalTerminal(this, QVector<shared_real_terminal>{real_terminal})); new PhysicalTerminal(this, QVector<shared_real_terminal>{real_terminal}));
m_physical_terminals.append(new_physical_terminal); m_physical_terminals.append(new_physical_terminal);
@ -719,7 +708,7 @@ void TerminalStrip::unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &
*/ */
bool TerminalStrip::setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level) bool TerminalStrip::setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level)
{ {
auto real_t = real_terminal.toStrongRef(); const auto real_t = real_terminal.toStrongRef();
if (real_t) if (real_t)
{ {
auto physical_terminal = physicalTerminal(real_t); auto physical_terminal = physicalTerminal(real_t);
@ -739,26 +728,29 @@ bool TerminalStrip::setLevel(const QWeakPointer<RealTerminal> &real_terminal, in
/** /**
* @brief TerminalStrip::isBridgeable * @brief TerminalStrip::isBridgeable
* Check if all realTerminal in @a real_terminals_data are bridgeable together. * Check if all realTerminal in @a real_terminals are bridgeable together.
* To be bridgeable, each real terminal must belong to this terminal strip * To be bridgeable, each real terminal must belong to this terminal strip
* be at the same level, be consecutive and not belong to the same physicalTerminal * be at the same level, be consecutive and not belong to the same physicalTerminal
* and at least one terminal must be not bridged * and at least one terminal must be not bridged
* @param real_terminals_data : a vector of RealTerminalData * @param real_terminals : a vector of realterminal
* @return * @return
*/ */
bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals_data) const bool TerminalStrip::isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const
{ {
if (real_terminals_data.size() < 2) { if (real_terminals.size() < 2) {
return false; return false;
} }
// Check if first terminal belong to this strip // Check if first terminal belong to this strip
auto first_real_terminal = real_terminals_data.first().m_real_terminal.toStrongRef(); const auto first_real_terminal = real_terminals.first().toStrongRef();
if (!first_real_terminal) { if (!first_real_terminal) {
return false; return false;
} }
// Get the level of the first terminal // Get the level of the first terminal
int level_ = real_terminals_data.first().level(); const auto rtd_ = realTerminalDataFor(real_terminals.first());
const int level_ = rtd_.level();
// Get the physical terminal and pos // Get the physical terminal and pos
auto first_physical_terminal = physicalTerminal(first_real_terminal); auto first_physical_terminal = physicalTerminal(first_real_terminal);
QVector<shared_physical_terminal> physical_vector{first_physical_terminal}; QVector<shared_physical_terminal> physical_vector{first_physical_terminal};
@ -768,17 +760,17 @@ bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals
//bool to know at the end of this function if at least one terminal is not bridged //bool to know at the end of this function if at least one terminal is not bridged
bool no_bridged = bridge_ ? false : true; bool no_bridged = bridge_ ? false : true;
// Check for each terminals // Check for each terminals
for (int i=1 ; i<real_terminals_data.size() ; ++i) for (int i=1 ; i<real_terminals.size() ; ++i)
{ {
// If belong to this strip // If belong to this strip
auto real_terminal = real_terminals_data.at(i).m_real_terminal.toStrongRef(); const auto real_terminal = real_terminals.at(i).toStrongRef();
if (!real_terminal) { if (!real_terminal) {
return false; return false;
} }
// at the same level // at the same level
if (level_ != real_terminals_data.at(i).level()) { if (level_ != realTerminalDataFor(real_terminals.first()).level()) {
return false; return false;
} }
@ -791,7 +783,7 @@ bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals
} }
// Not in another bridge of a previous checked real terminal // Not in another bridge of a previous checked real terminal
auto checked_bridge = isBridged(real_terminal); const auto checked_bridge = isBridged(real_terminal);
if (checked_bridge) if (checked_bridge)
{ {
if (bridge_.isNull()) { if (bridge_.isNull()) {
@ -807,8 +799,8 @@ bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals
} }
// Check if concecutive // Check if concecutive
auto count_ = pos_vector.size(); const auto count_ = pos_vector.size();
auto min_max = std::minmax_element(pos_vector.constBegin(), pos_vector.constEnd()); const auto min_max = std::minmax_element(pos_vector.constBegin(), pos_vector.constEnd());
if ((*min_max.second - *min_max.first) + 1 != count_) { if ((*min_max.second - *min_max.first) + 1 != count_) {
return false; return false;
} }
@ -816,17 +808,6 @@ bool TerminalStrip::isBridgeable(const QVector<RealTerminalData> &real_terminals
return no_bridged; return no_bridged;
} }
bool TerminalStrip::isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const
{
QVector<RealTerminalData> data;
for (const auto &wrt : real_terminals)
{
data.append(RealTerminalData(wrt.toStrongRef()));
}
return isBridgeable(data);
}
/** /**
* @brief TerminalStrip::setBridge * @brief TerminalStrip::setBridge
* Set a bridge betwen all real terminal of @a real_terminals * Set a bridge betwen all real terminal of @a real_terminals
@ -842,7 +823,7 @@ bool TerminalStrip::setBridge(const QVector<QWeakPointer<RealTerminal>> &real_te
for (const auto &real_terminal : real_terminals) for (const auto &real_terminal : real_terminals)
{ {
auto real_t = real_terminal.toStrongRef(); const auto real_t = real_terminal.toStrongRef();
if (real_t) { if (real_t) {
real_terminals_vector.append(real_t); real_terminals_vector.append(real_t);
} }
@ -871,7 +852,7 @@ bool TerminalStrip::setBridge(const QVector<QWeakPointer<RealTerminal>> &real_te
* @param real_terminals_data * @param real_terminals_data
* @return true if all RealTerminal was successfully bridged * @return true if all RealTerminal was successfully bridged
*/ */
bool TerminalStrip::setBridge(QSharedPointer<TerminalStripBridge> bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals) bool TerminalStrip::setBridge(const QSharedPointer<TerminalStripBridge> &bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals)
{ {
if (bridge) if (bridge)
{ {
@ -882,7 +863,7 @@ bool TerminalStrip::setBridge(QSharedPointer<TerminalStripBridge> bridge, const
bool b_ = false; bool b_ = false;
for (const auto & rt_ : real_terminals) for (const auto & rt_ : real_terminals)
{ {
auto real_t = rt_.toStrongRef(); const auto real_t = rt_.toStrongRef();
if (real_t && if (real_t &&
!bridge->real_terminals.contains(real_t)) !bridge->real_terminals.contains(real_t))
{ {
@ -918,7 +899,7 @@ void TerminalStrip::unBridge(const QVector<QWeakPointer<RealTerminal>> &real_ter
emit bridgeChanged(); emit bridgeChanged();
} }
QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(QWeakPointer<RealTerminal> real_terminal) const QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
return this->isBridged(real_terminal.toStrongRef()); return this->isBridged(real_terminal.toStrongRef());
} }
@ -931,21 +912,17 @@ QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(QWeakPointer<RealTe
*/ */
RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
auto real_t = real_terminal.toStrongRef(); const auto real_t = real_terminal.toStrongRef();
if (real_t) const auto phy_t = physicalTerminal(real_t);
if (real_t && phy_t)
{ {
auto phy_t = physicalTerminal(real_t); const auto level_ = phy_t->levelOf(real_t);
if (phy_t) const auto index = m_physical_terminals.indexOf(phy_t);
if (index >= 1)
{ {
auto level_ = phy_t->levelOf(real_t); const auto t_vector = m_physical_terminals.at(index-1)->terminals();
auto index = m_physical_terminals.indexOf(phy_t); if (t_vector.size() > level_) {
if (index >= 1) return RealTerminalData(t_vector.at(level_));
{
auto t_vector = m_physical_terminals.at(index-1)->terminals();
if (t_vector.size() > level_)
{
return RealTerminalData(t_vector.at(level_));
}
} }
} }
} }
@ -961,21 +938,17 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer<RealT
*/ */
RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
auto real_t = real_terminal.toStrongRef(); const auto real_t = real_terminal.toStrongRef();
if (real_t) const auto phy_t = physicalTerminal(real_t);
if (real_t && phy_t)
{ {
auto phy_t = physicalTerminal(real_t); const auto level_ = phy_t->levelOf(real_t);
if (phy_t) const auto index = m_physical_terminals.indexOf(phy_t);
if (index < m_physical_terminals.size()-1)
{ {
auto level_ = phy_t->levelOf(real_t); const auto t_vector = m_physical_terminals.at(index+1)->terminals();
auto index = m_physical_terminals.indexOf(phy_t); if (t_vector.size() > level_) {
if (index < m_physical_terminals.size()-1) return RealTerminalData(t_vector.at(level_));
{
auto t_vector = m_physical_terminals.at(index+1)->terminals();
if (t_vector.size() > level_)
{
return RealTerminalData(t_vector.at(level_));
}
} }
} }
} }
@ -985,8 +958,8 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer<RealTermi
RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
auto real = real_terminal.toStrongRef(); const auto real = real_terminal.toStrongRef();
auto index = m_real_terminals.indexOf(real); const auto index = m_real_terminals.indexOf(real);
if (index) { if (index) {
return RealTerminalData(m_real_terminals.at(index-1)); return RealTerminalData(m_real_terminals.at(index-1));
} }
@ -995,8 +968,8 @@ RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer<RealTerm
RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
auto real = real_terminal.toStrongRef(); const auto real = real_terminal.toStrongRef();
auto index = m_real_terminals.indexOf(real); const auto index = m_real_terminals.indexOf(real);
if (index != m_real_terminals.size()-1) { if (index != m_real_terminals.size()-1) {
return RealTerminalData(m_real_terminals.at(index+1)); return RealTerminalData(m_real_terminals.at(index+1));
} }
@ -1005,7 +978,7 @@ RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer<RealTerminal
RealTerminalData TerminalStrip::realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const RealTerminalData TerminalStrip::realTerminalDataFor(const QWeakPointer<RealTerminal> &real_terminal) const
{ {
auto rt = real_terminal.toStrongRef(); const auto rt = real_terminal.toStrongRef();
if (rt && m_real_terminals.contains(rt)) if (rt && m_real_terminals.contains(rt))
return RealTerminalData(rt); return RealTerminalData(rt);
else else
@ -1063,8 +1036,8 @@ bool TerminalStrip::fromXml(QDomElement &xml_element)
if (!xml_layout.isNull()) if (!xml_layout.isNull())
{ {
//Get all free elements terminal of the project //Get all free elements terminal of the project
ElementProvider ep(m_project); const ElementProvider ep(m_project);
auto free_terminals = ep.freeTerminal(); const auto free_terminals = ep.freeTerminal();
//Read each physical terminal //Read each physical terminal
for(auto &xml_physical : QETXML::findInDomElement(xml_layout, PhysicalTerminal::xmlTagName())) for(auto &xml_physical : QETXML::findInDomElement(xml_layout, PhysicalTerminal::xmlTagName()))
@ -1084,7 +1057,7 @@ bool TerminalStrip::fromXml(QDomElement &xml_element)
real_t_vector.append(real_t); real_t_vector.append(real_t);
} }
shared_physical_terminal phy_t(new PhysicalTerminal(this, real_t_vector)); const shared_physical_terminal phy_t(new PhysicalTerminal(this, real_t_vector));
m_physical_terminals.append(phy_t); m_physical_terminals.append(phy_t);
m_real_terminals.append(real_t_vector); m_real_terminals.append(real_t_vector);
} }
@ -1102,15 +1075,13 @@ bool TerminalStrip::fromXml(QDomElement &xml_element)
*/ */
QSharedPointer<RealTerminal> TerminalStrip::realTerminal(Element *terminal) QSharedPointer<RealTerminal> TerminalStrip::realTerminal(Element *terminal)
{ {
shared_real_terminal rt;
for (auto &real : qAsConst(m_real_terminals)) { for (auto &real : qAsConst(m_real_terminals)) {
if (real->element() == terminal) { if (real->element() == terminal) {
return real; return real;
} }
} }
return rt; return shared_real_terminal();
} }
/** /**
@ -1123,10 +1094,12 @@ QSharedPointer<PhysicalTerminal> TerminalStrip::physicalTerminal(QSharedPointer<
{ {
shared_physical_terminal pt; shared_physical_terminal pt;
for (auto &physical : qAsConst(m_physical_terminals)) if (terminal.isNull()) {
{ return pt;
if (physical->terminals().contains(terminal)) }
{
for (auto &physical : qAsConst(m_physical_terminals)) {
if (physical->terminals().contains(terminal)) {
pt = physical; pt = physical;
break; break;
} }
@ -1135,47 +1108,6 @@ QSharedPointer<PhysicalTerminal> TerminalStrip::physicalTerminal(QSharedPointer<
return pt; return pt;
} }
/**
* @brief TerminalStrip::physicalTerminalForUuid
* Return the PhysicalTerminal with uuid \p uuid or a null
* PhysicalTerminal if uuid don't match
* @param uuid
* @return
*/
QSharedPointer<PhysicalTerminal> TerminalStrip::physicalTerminalForUuid(const QUuid &uuid) const
{
shared_physical_terminal return_pt;
for (const auto &pt_ : qAsConst(m_physical_terminals)) {
if (pt_->uuid() == uuid) {
return_pt = pt_;
break;
}
}
return return_pt;
}
/**
* @brief TerminalStrip::realTerminalForUuid
* @param uuid
* @return the RealTerminal with uuid \p uuid or a null
* RealTerminal if uuid don't match
*/
QSharedPointer<RealTerminal> TerminalStrip::realTerminalForUuid(const QUuid &uuid) const
{
shared_real_terminal return_rt;
for (const auto &rt_ : qAsConst(m_real_terminals)) {
if (rt_->uuid() == uuid) {
return_rt = rt_;
break;
}
}
return return_rt;
}
/** /**
* @brief TerminalStrip::isBridged * @brief TerminalStrip::isBridged
* Check if @a real_terminal is bridged * Check if @a real_terminal is bridged
@ -1209,7 +1141,7 @@ QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QVector<QShar
for (const auto &terminal : terminal_vector) for (const auto &terminal : terminal_vector)
{ {
auto bridge_ = isBridged(terminal); const auto bridge_ = isBridged(terminal);
if (!bridge_.isNull()) if (!bridge_.isNull())
{ {
if (return_bridge.isNull()) { if (return_bridge.isNull()) {
@ -1232,9 +1164,8 @@ QSharedPointer<TerminalStripBridge> TerminalStrip::bridgeFor(const QVector<QShar
void TerminalStrip::rebuildRealVector() void TerminalStrip::rebuildRealVector()
{ {
m_real_terminals.clear(); m_real_terminals.clear();
for (const auto phy : m_physical_terminals) { for (const auto &phy : qAsConst(m_physical_terminals)) {
for (const auto real : phy->terminals()) m_real_terminals.append(phy->terminals());
m_real_terminals.append(real);
} }
} }
@ -1249,10 +1180,13 @@ void TerminalStrip::rebuildRealVector()
* @brief RealTerminalData::RealTerminalData * @brief RealTerminalData::RealTerminalData
* @param real_terminal * @param real_terminal
*/ */
RealTerminalData::RealTerminalData(QSharedPointer<RealTerminal> real_terminal) RealTerminalData::RealTerminalData(QSharedPointer<RealTerminal> real_terminal) :
{ m_real_terminal(real_terminal.toWeakRef())
m_real_terminal = real_terminal.toWeakRef(); {}
}
RealTerminalData::RealTerminalData(QWeakPointer<RealTerminal> real_terminal) :
m_real_terminal(real_terminal)
{}
bool RealTerminalData::isNull() const bool RealTerminalData::isNull() const
{ {
@ -1261,7 +1195,7 @@ bool RealTerminalData::isNull() const
int RealTerminalData::level() const int RealTerminalData::level() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
auto strip = shared_->parentStrip(); auto strip = shared_->parentStrip();
if (strip) { if (strip) {
@ -1277,7 +1211,7 @@ int RealTerminalData::level() const
QString RealTerminalData::label() const QString RealTerminalData::label() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->label(); return shared_->label();
} else { } else {
@ -1287,7 +1221,7 @@ QString RealTerminalData::label() const
QString RealTerminalData::Xref() const QString RealTerminalData::Xref() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_ && shared_->isElement()) { if (shared_ && shared_->isElement()) {
return autonum::AssignVariables::genericXref(shared_->element()); return autonum::AssignVariables::genericXref(shared_->element());
} else { } else {
@ -1309,7 +1243,7 @@ QString RealTerminalData::conductor() const {
ElementData::TerminalType RealTerminalData::type() const ElementData::TerminalType RealTerminalData::type() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->type(); return shared_->type();
} }
@ -1319,7 +1253,7 @@ ElementData::TerminalType RealTerminalData::type() const
ElementData::TerminalFunction RealTerminalData::function() const ElementData::TerminalFunction RealTerminalData::function() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->function(); return shared_->function();
} }
@ -1329,7 +1263,7 @@ ElementData::TerminalFunction RealTerminalData::function() const
bool RealTerminalData::isLed() const bool RealTerminalData::isLed() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->led(); return shared_->led();
} }
@ -1339,7 +1273,7 @@ bool RealTerminalData::isLed() const
bool RealTerminalData::isElement() const bool RealTerminalData::isElement() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->isElement(); return shared_->isElement();
} }
@ -1349,7 +1283,7 @@ bool RealTerminalData::isElement() const
bool RealTerminalData::isBridged() const bool RealTerminalData::isBridged() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
auto strip = shared_->parentStrip(); auto strip = shared_->parentStrip();
if (strip) { if (strip) {
@ -1366,7 +1300,7 @@ bool RealTerminalData::isBridged() const
*/ */
Element *RealTerminalData::element() const Element *RealTerminalData::element() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
return shared_->element(); return shared_->element();
} }
@ -1376,7 +1310,7 @@ Element *RealTerminalData::element() const
QUuid RealTerminalData::elementUuid() const QUuid RealTerminalData::elementUuid() const
{ {
auto element_ = element(); const auto element_ = element();
if (element_) { if (element_) {
return element_->uuid(); return element_->uuid();
} }
@ -1385,7 +1319,7 @@ QUuid RealTerminalData::elementUuid() const
QSharedPointer<TerminalStripBridge> RealTerminalData::bridge() const QSharedPointer<TerminalStripBridge> RealTerminalData::bridge() const
{ {
auto shared_ = m_real_terminal.toStrongRef(); const auto shared_ = m_real_terminal.toStrongRef();
if (shared_) { if (shared_) {
auto strip = shared_->parentStrip(); auto strip = shared_->parentStrip();
if (strip) { if (strip) {
@ -1399,3 +1333,68 @@ QWeakPointer<RealTerminal> RealTerminalData::realTerminal() const
{ {
return m_real_terminal; return m_real_terminal;
} }
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
/************************************************************************************/
PhysicalTerminalData::PhysicalTerminalData(const TerminalStrip *strip, QSharedPointer<PhysicalTerminal> terminal) :
m_strip(strip),
m_physical_terminal(terminal.toWeakRef())
{}
bool PhysicalTerminalData::isNull() const
{
return m_physical_terminal.isNull();
}
int PhysicalTerminalData::pos() const
{
if (m_strip) {
return m_strip->pos(m_physical_terminal);
} else {
return -1;
}
}
QUuid PhysicalTerminalData::uuid() const
{
const auto pt_ = m_physical_terminal.toStrongRef();
if (pt_) {
return pt_->uuid();
} else {
return QUuid();
}
}
int PhysicalTerminalData::realTerminalCount() const
{
const auto pt_ = m_physical_terminal.toStrongRef();
if (pt_) {
return pt_->terminals().size();
} else {
return 0;
}
}
QVector<RealTerminalData> PhysicalTerminalData::realTerminalDatas() const
{
QVector<RealTerminalData> rtd_vector;
const auto pt_ = m_physical_terminal.toStrongRef();
if (pt_ && m_strip)
{
for (const auto & rt_ : pt_->terminals()) {
rtd_vector.append(m_strip->realTerminalDataFor(rt_.toWeakRef()));
}
}
return rtd_vector;
}
QWeakPointer<PhysicalTerminal> PhysicalTerminalData::physicalTerminal() const {
return m_physical_terminal;
}

43
sources/TerminalStrip/terminalstrip.h
View File

@ -31,6 +31,7 @@ class QETProject;
class PhysicalTerminal; class PhysicalTerminal;
class TerminalStripIndex; class TerminalStripIndex;
class TerminalElement; class TerminalElement;
class TerminalStrip;
struct TerminalStripBridge struct TerminalStripBridge
{ {
@ -56,8 +57,10 @@ inline uint qHash(const QWeakPointer<TerminalStripBridge> &key, uint seed)
class RealTerminalData class RealTerminalData
{ {
friend class TerminalStrip; friend class TerminalStrip;
friend class PhysicalTerminalData;
private: private:
RealTerminalData(QSharedPointer<RealTerminal> real_terminal); RealTerminalData(QSharedPointer<RealTerminal> real_terminal);
RealTerminalData(QWeakPointer<RealTerminal> real_terminal);
public: public:
RealTerminalData() {} RealTerminalData() {}
@ -88,24 +91,39 @@ class RealTerminalData
}; };
/** /**
* @brief The PhysicalTerminalData struct * @brief The PhysicalTerminalData
* Conveniant struct to quickly get some values * Conveniant struct to quickly get some values
* of a PhysicalTerminal * of a PhysicalTerminal
*/ */
struct PhysicalTerminalData class PhysicalTerminalData
{ {
QVector<RealTerminalData> real_terminals_vector; friend class TerminalStrip;
int pos_ = -1;
QUuid uuid_; private:
PhysicalTerminalData(const TerminalStrip *strip, QSharedPointer<PhysicalTerminal> terminal);
public:
PhysicalTerminalData(){}
bool isNull() const;
int pos() const;
QUuid uuid() const;
int realTerminalCount() const;
QVector<RealTerminalData> realTerminalDatas() const;
QWeakPointer<PhysicalTerminal> physicalTerminal() const;
private:
QPointer<const TerminalStrip> m_strip;
QWeakPointer<PhysicalTerminal> m_physical_terminal;
}; };
//Code to use PhysicalTerminalData as key for QHash //Code to use PhysicalTerminalData as key for QHash
inline bool operator == (const PhysicalTerminalData &phy_1, const PhysicalTerminalData &phy_2) { inline bool operator == (const PhysicalTerminalData &phy_1, const PhysicalTerminalData &phy_2) {
return phy_1.uuid_ == phy_2.uuid_; return phy_1.uuid() == phy_2.uuid();
} }
inline uint qHash(const PhysicalTerminalData &key, uint seed) { inline uint qHash(const PhysicalTerminalData &key, uint seed) {
return qHash(key.uuid_, seed); return qHash(key.uuid(), seed);
} }
/** /**
@ -155,21 +173,22 @@ class TerminalStrip : public QObject
bool addTerminal (Element *terminal); bool addTerminal (Element *terminal);
bool removeTerminal (Element *terminal); bool removeTerminal (Element *terminal);
int pos(const QWeakPointer<PhysicalTerminal> &terminal) const;
int physicalTerminalCount() const; int physicalTerminalCount() const;
PhysicalTerminalData physicalTerminalData(int index) const; PhysicalTerminalData physicalTerminalData(int index) const;
PhysicalTerminalData physicalTerminalData (QWeakPointer<RealTerminal> real_terminal) const; PhysicalTerminalData physicalTerminalData (const QWeakPointer<RealTerminal> &real_terminal) const;
QVector<PhysicalTerminalData> physicalTerminalData() const; QVector<PhysicalTerminalData> physicalTerminalData() const;
bool setOrderTo(const QVector<PhysicalTerminalData> &sorted_vector); bool setOrderTo(const QVector<PhysicalTerminalData> &sorted_vector);
bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals); bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector<QWeakPointer<RealTerminal>> &added_terminals);
void unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &terminals_to_ungroup); void unGroupTerminals(const QVector<QWeakPointer<RealTerminal>> &terminals_to_ungroup);
bool setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level); bool setLevel(const QWeakPointer<RealTerminal> &real_terminal, int level);
bool isBridgeable(const QVector<RealTerminalData> &real_terminals_data) const;
bool isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const; bool isBridgeable(const QVector<QWeakPointer<RealTerminal>> &real_terminals) const;
bool setBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals); bool setBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
bool setBridge(QSharedPointer<TerminalStripBridge> bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals); bool setBridge(const QSharedPointer<TerminalStripBridge> &bridge, const QVector<QWeakPointer<RealTerminal>> &real_terminals);
void unBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals); void unBridge(const QVector<QWeakPointer<RealTerminal>> &real_terminals);
QSharedPointer<TerminalStripBridge> bridgeFor(QWeakPointer<RealTerminal> real_terminal) const; QSharedPointer<TerminalStripBridge> bridgeFor(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const; RealTerminalData previousTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
RealTerminalData nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const; RealTerminalData nextTerminalInLevel(const QWeakPointer<RealTerminal> &real_terminal) const;
@ -186,8 +205,6 @@ class TerminalStrip : public QObject
private: private:
QSharedPointer<RealTerminal> realTerminal(Element *terminal); QSharedPointer<RealTerminal> realTerminal(Element *terminal);
QSharedPointer<PhysicalTerminal> physicalTerminal(QSharedPointer<RealTerminal> terminal) const; QSharedPointer<PhysicalTerminal> physicalTerminal(QSharedPointer<RealTerminal> terminal) const;
QSharedPointer<PhysicalTerminal> physicalTerminalForUuid (const QUuid &uuid) const;
QSharedPointer<RealTerminal> realTerminalForUuid(const QUuid &uuid) const;
QSharedPointer<TerminalStripBridge> isBridged(const QSharedPointer<RealTerminal> real_terminal) const; QSharedPointer<TerminalStripBridge> isBridged(const QSharedPointer<RealTerminal> real_terminal) const;
QSharedPointer<TerminalStripBridge> bridgeFor (const QVector<QSharedPointer<RealTerminal>> &terminal_vector) const; QSharedPointer<TerminalStripBridge> bridgeFor (const QVector<QSharedPointer<RealTerminal>> &terminal_vector) const;
void rebuildRealVector(); void rebuildRealVector();

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

@ -232,9 +232,9 @@ QTreeWidgetItem* TerminalStripEditor::addTerminalStrip(TerminalStrip *terminal_s
for (auto i=0 ; i<terminal_strip->physicalTerminalCount() ; ++i) for (auto i=0 ; i<terminal_strip->physicalTerminalCount() ; ++i)
{ {
auto ptd = terminal_strip->physicalTerminalData(i); auto ptd = terminal_strip->physicalTerminalData(i);
if (ptd.real_terminals_vector.size()) if (ptd.realTerminalCount())
{ {
auto real_t = ptd.real_terminals_vector.first(); const auto real_t = ptd.realTerminalDatas().at(0);
auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t.label()), TerminalStripTreeWidget::Terminal); 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->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t.elementUuid());
terminal_item->setIcon(0, QET::Icons::ElementTerminal); terminal_item->setIcon(0, QET::Icons::ElementTerminal);
@ -352,7 +352,7 @@ void TerminalStripEditor::spanMultiLevelTerminals()
auto current_row = 0; auto current_row = 0;
for (auto i = 0 ; i < m_current_strip->physicalTerminalCount() ; ++i) for (auto i = 0 ; i < m_current_strip->physicalTerminalCount() ; ++i)
{ {
const auto level_count = m_current_strip->physicalTerminalData(i).real_terminals_vector.size(); const auto level_count = m_current_strip->physicalTerminalData(i).realTerminalCount();
if (level_count > 1) { if (level_count > 1) {
ui->m_table_widget->setSpan(current_row, 0, level_count, 1); ui->m_table_widget->setSpan(current_row, 0, level_count, 1);
} }
@ -446,7 +446,7 @@ void TerminalStripEditor::selectionChanged()
if (m_current_strip) if (m_current_strip)
{ {
QVector<QWeakPointer<RealTerminal>> vector_; QVector<QWeakPointer<RealTerminal>> vector_;
for (const auto &mrtd : model_rtd_vector) { for (const auto &mrtd : qAsConst(model_rtd_vector)) {
vector_.append(mrtd.real_terminal); vector_.append(mrtd.real_terminal);
} }
enable_bridge = m_current_strip->isBridgeable(vector_); enable_bridge = m_current_strip->isBridgeable(vector_);
@ -650,8 +650,7 @@ void TerminalStripEditor::on_m_dialog_button_box_clicked(QAbstractButton *button
{ {
for (const auto &data_ : m_model->modifiedmodelRealTerminalData()) for (const auto &data_ : m_model->modifiedmodelRealTerminalData())
{ {
auto element = data_.element_; if (auto element = data_.element_)
if (element)
{ {
auto current_data = element->elementData(); auto current_data = element->elementData();
current_data.setTerminalType(data_.type_); current_data.setTerminalType(data_.type_);

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

@ -484,10 +484,10 @@ void TerminalStripModel::fillPhysicalTerminalData()
for (const auto &ptd : m_terminal_strip->physicalTerminalData()) for (const auto &ptd : m_terminal_strip->physicalTerminalData())
{ {
modelPhysicalTerminalData mptd; modelPhysicalTerminalData mptd;
mptd.pos_ = ptd.pos_; mptd.pos_ = ptd.pos();
mptd.uuid_ = ptd.uuid_; mptd.uuid_ = ptd.uuid();
for (const auto &rtd : ptd.real_terminals_vector) for (const auto &rtd : ptd.realTerminalDatas())
{ {
if (!rtd.isNull()) if (!rtd.isNull())
{ {
@ -668,7 +668,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
//Check previous //Check previous
auto physical_data = m_terminal_strip->physicalTerminalData(mrtd.real_terminal); auto physical_data = m_terminal_strip->physicalTerminalData(mrtd.real_terminal);
auto current_real_terminal = mrtd; auto current_real_terminal = mrtd;
auto current_phy_uuid = physical_data.uuid_; auto current_phy_uuid = physical_data.uuid();
bool already_jumped_to_previous = false; bool already_jumped_to_previous = false;
modelRealTerminalData previous_data; modelRealTerminalData previous_data;
@ -680,7 +680,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
} }
//We are in the same physical terminal as previous loop //We are in the same physical terminal as previous loop
if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_) if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid())
{ {
if (current_real_terminal.bridged_ && if (current_real_terminal.bridged_ &&
current_real_terminal.level_ == level_column) { current_real_terminal.level_ == level_column) {
@ -692,7 +692,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
break; break;
} else { } else {
already_jumped_to_previous = true; already_jumped_to_previous = true;
current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_; current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid();
if (current_real_terminal.bridged_ && if (current_real_terminal.bridged_ &&
current_real_terminal.level_ == level_column) { current_real_terminal.level_ == level_column) {
previous_data = current_real_terminal; previous_data = current_real_terminal;
@ -703,7 +703,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
//Check next //Check next
current_real_terminal = mrtd; current_real_terminal = mrtd;
current_phy_uuid = physical_data.uuid_; current_phy_uuid = physical_data.uuid();
bool already_jumped_to_next = false; bool already_jumped_to_next = false;
modelRealTerminalData next_data; modelRealTerminalData next_data;
@ -715,7 +715,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
} }
//We are in the same physical terminal as previous loop //We are in the same physical terminal as previous loop
if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_) if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid())
{ {
if (current_real_terminal.bridged_ && if (current_real_terminal.bridged_ &&
current_real_terminal.level_ == level_column) { current_real_terminal.level_ == level_column) {
@ -727,7 +727,7 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const
break; break;
} else { } else {
already_jumped_to_next = true; already_jumped_to_next = true;
current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_; current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid();
if (current_real_terminal.bridged_ && if (current_real_terminal.bridged_ &&
current_real_terminal.level_ == level_column) { current_real_terminal.level_ == level_column) {
next_data = current_real_terminal; next_data = current_real_terminal;