diff --git a/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp b/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp index 663683a7e..7c3a19b61 100644 --- a/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp +++ b/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.cpp @@ -16,14 +16,13 @@ along with QElectroTech. If not, see . */ #include "bridgeterminalscommand.h" -#include "../terminalstrip.h" BridgeTerminalsCommand::BridgeTerminalsCommand(TerminalStrip *strip, - QVector real_terminal_uuid, + QVector> real_terminal, QUndoCommand *parent): QUndoCommand(parent), m_strip(strip), - m_uuid_vector(real_terminal_uuid) + m_real_terminal_vector(real_terminal) { setText(QObject::tr("Ponter des bornes entre-elles")); } @@ -31,40 +30,44 @@ BridgeTerminalsCommand::BridgeTerminalsCommand(TerminalStrip *strip, void BridgeTerminalsCommand::undo() { if (m_strip) { - m_strip->unBridge(m_uuid_vector); + m_strip->unBridge(m_real_terminal_vector); } } void BridgeTerminalsCommand::redo() { if (m_strip) { - m_strip->setBridge(m_uuid_vector); + m_strip->setBridge(m_real_terminal_vector); } } UnBridgeTerminalsCommand::UnBridgeTerminalsCommand(TerminalStrip *strip, - QVector real_terminal_uuid, + QVector> real_terminal, QUndoCommand *parent): QUndoCommand(parent), m_strip(strip) { setText(QObject::tr("Supprimer des ponts de bornes")); - for (const auto &t_uuid : real_terminal_uuid) + for (const auto &real_t : real_terminal) { - auto bridge = m_strip->bridgeFor(t_uuid); - if (bridge) { - m_bridge_terminal_map.insert(bridge->uuid_, t_uuid); + auto bridge_ = strip->bridgeFor(real_t); + if (bridge_) { + m_bridge_terminal_hash.insert(bridge_.toWeakRef(), real_t); } } } void UnBridgeTerminalsCommand::undo() { - if (m_strip) { - for (const auto &bridge_uuid : m_bridge_terminal_map.uniqueKeys()) { - auto terminal_list = m_bridge_terminal_map.values(bridge_uuid); - m_strip->setBridge(bridge_uuid, terminal_list.toVector()); + if (m_strip) + { + for (const auto &bridge_ : m_bridge_terminal_hash.uniqueKeys()) + { + if (!bridge_.isNull()) { + auto terminal_list = m_bridge_terminal_hash.values(bridge_); + m_strip->setBridge(bridge_.toStrongRef() , terminal_list.toVector()); + } } } } @@ -72,6 +75,6 @@ void UnBridgeTerminalsCommand::undo() void UnBridgeTerminalsCommand::redo() { if (m_strip) { - m_strip->unBridge(m_bridge_terminal_map.values().toVector()); + m_strip->unBridge(m_bridge_terminal_hash.values().toVector()); } } diff --git a/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h b/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h index 03a6e8b17..96f1c795a 100644 --- a/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h +++ b/sources/TerminalStrip/UndoCommand/bridgeterminalscommand.h @@ -20,11 +20,10 @@ #include #include -#include #include #include -class TerminalStrip; +#include "../terminalstrip.h" /** * @brief The BridgeTerminalsCommand class @@ -34,7 +33,7 @@ class TerminalStrip; class BridgeTerminalsCommand : public QUndoCommand { public: - BridgeTerminalsCommand(TerminalStrip *strip, QVector real_terminal_uuid, QUndoCommand *parent = nullptr); + BridgeTerminalsCommand(TerminalStrip *strip, QVector> real_terminal, QUndoCommand *parent = nullptr); ~BridgeTerminalsCommand() override {} void undo() override; @@ -42,7 +41,7 @@ class BridgeTerminalsCommand : public QUndoCommand private: QPointer m_strip; - QVector m_uuid_vector; + QVector> m_real_terminal_vector; }; @@ -54,7 +53,7 @@ class BridgeTerminalsCommand : public QUndoCommand class UnBridgeTerminalsCommand : public QUndoCommand { public: - UnBridgeTerminalsCommand(TerminalStrip *strip, QVector real_terminal_uuid, QUndoCommand *parent = nullptr); + UnBridgeTerminalsCommand(TerminalStrip *strip, QVector> real_terminal, QUndoCommand *parent = nullptr); ~UnBridgeTerminalsCommand() override{} void undo() override; @@ -62,7 +61,7 @@ class UnBridgeTerminalsCommand : public QUndoCommand private: QPointer m_strip; - QMultiMap m_bridge_terminal_map; ///Key is bridge uuid, value is real terminal uuid + QMultiHash, QWeakPointer> m_bridge_terminal_hash; ///Key a is bridge, value is real terminal }; diff --git a/sources/TerminalStrip/UndoCommand/changeterminallevel.cpp b/sources/TerminalStrip/UndoCommand/changeterminallevel.cpp index 42c5dceba..004a3e46e 100644 --- a/sources/TerminalStrip/UndoCommand/changeterminallevel.cpp +++ b/sources/TerminalStrip/UndoCommand/changeterminallevel.cpp @@ -18,14 +18,14 @@ #include "changeterminallevel.h" ChangeTerminalLevel::ChangeTerminalLevel(TerminalStrip *strip, - const RealTerminalData &real_terminal, + const QWeakPointer &real_terminal, int level, QUndoCommand *parent) : QUndoCommand(parent), m_strip(strip), m_real_terminal(real_terminal), m_new_level(level), - m_old_level(real_terminal.level_) + m_old_level(m_strip->realTerminalDataFor(real_terminal).level()) {} void ChangeTerminalLevel::undo() diff --git a/sources/TerminalStrip/UndoCommand/changeterminallevel.h b/sources/TerminalStrip/UndoCommand/changeterminallevel.h index 39b9a3c1a..248695161 100644 --- a/sources/TerminalStrip/UndoCommand/changeterminallevel.h +++ b/sources/TerminalStrip/UndoCommand/changeterminallevel.h @@ -26,7 +26,7 @@ class ChangeTerminalLevel : public QUndoCommand { public: ChangeTerminalLevel(TerminalStrip *strip, - const RealTerminalData &real_terminal, + const QWeakPointer &real_terminal, int level, QUndoCommand *parent = nullptr); @@ -35,7 +35,7 @@ class ChangeTerminalLevel : public QUndoCommand private: QPointer m_strip; - RealTerminalData m_real_terminal; + QWeakPointer m_real_terminal; int m_new_level, m_old_level; }; diff --git a/sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp b/sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp index 1ded81741..a2857de50 100644 --- a/sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp +++ b/sources/TerminalStrip/UndoCommand/groupterminalscommand.cpp @@ -25,7 +25,7 @@ */ GroupTerminalsCommand::GroupTerminalsCommand(TerminalStrip *strip, const PhysicalTerminalData &receiver_, - const QVector &to_group, + const QVector> &to_group, QUndoCommand *parent): QUndoCommand(parent), m_terminal_strip(strip), @@ -48,7 +48,7 @@ void GroupTerminalsCommand::redo() { } UnGroupTerminalsCommand::UnGroupTerminalsCommand(TerminalStrip *strip, - const QVector &to_ungroup, + const QVector> &to_ungroup, QUndoCommand *parent) : QUndoCommand(parent), m_terminal_strip(strip) @@ -77,11 +77,11 @@ void UnGroupTerminalsCommand::redo() } } -void UnGroupTerminalsCommand::setUp(const QVector &to_ungroup) +void UnGroupTerminalsCommand::setUp(const QVector> &to_ungroup) { - for (auto rtd_ : to_ungroup) + for (const auto &rt_ : to_ungroup) { - auto ptd_ = m_terminal_strip->physicalTerminalData(rtd_); + auto ptd_ = m_terminal_strip->physicalTerminalData(rt_); //Physical have only one real terminal, no need to ungroup it if (ptd_.real_terminals_vector.size() <= 1) { @@ -89,7 +89,7 @@ void UnGroupTerminalsCommand::setUp(const QVector &to_ungroup) } auto vector_ = m_physical_real_H.value(ptd_); - vector_.append(rtd_); + vector_.append(rt_); m_physical_real_H.insert(ptd_, vector_); } } diff --git a/sources/TerminalStrip/UndoCommand/groupterminalscommand.h b/sources/TerminalStrip/UndoCommand/groupterminalscommand.h index 9ef37b19d..55b250319 100644 --- a/sources/TerminalStrip/UndoCommand/groupterminalscommand.h +++ b/sources/TerminalStrip/UndoCommand/groupterminalscommand.h @@ -32,7 +32,7 @@ class GroupTerminalsCommand : public QUndoCommand public: GroupTerminalsCommand(TerminalStrip *strip, const PhysicalTerminalData &receiver_, - const QVector &to_group, + const QVector> &to_group, QUndoCommand *parent = nullptr); void undo() override; @@ -41,7 +41,7 @@ class GroupTerminalsCommand : public QUndoCommand private: QPointer m_terminal_strip; PhysicalTerminalData m_receiver; - QVector m_to_group; + QVector> m_to_group; }; /** @@ -52,18 +52,18 @@ class UnGroupTerminalsCommand : public QUndoCommand { public: UnGroupTerminalsCommand(TerminalStrip *strip, - const QVector &to_ungroup, + const QVector> &to_ungroup, QUndoCommand *parent = nullptr); void undo() override; void redo() override; private: - void setUp(const QVector &to_ungroup); + void setUp(const QVector> &to_ungroup); private: QPointer m_terminal_strip; - QHash > m_physical_real_H; + QHash >> m_physical_real_H; }; #endif // GROUPTERMINALSCOMMAND_H diff --git a/sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp b/sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp index 538a5e516..51287faca 100644 --- a/sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp +++ b/sources/TerminalStrip/UndoCommand/sortterminalstripcommand.cpp @@ -54,7 +54,7 @@ void SortTerminalStripCommand::sort() if (arg1.real_terminals_vector.count()) { - str1 = arg1.real_terminals_vector.constLast().label_; + str1 = arg1.real_terminals_vector.constLast().label(); auto match = rx.match(str1); if (match.hasMatch()) { @@ -64,7 +64,7 @@ void SortTerminalStripCommand::sort() if (arg2.real_terminals_vector.count()) { - str2 = arg2.real_terminals_vector.constLast().label_; + str2 = arg2.real_terminals_vector.constLast().label(); auto match = rx.match(str2); if (match.hasMatch()) { diff --git a/sources/TerminalStrip/terminalstrip.cpp b/sources/TerminalStrip/terminalstrip.cpp index adce9d1c0..f5e394c89 100644 --- a/sources/TerminalStrip/terminalstrip.cpp +++ b/sources/TerminalStrip/terminalstrip.cpp @@ -55,6 +55,13 @@ class RealTerminal m_parent_terminal_strip(parent_strip) {} + /** + * @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 @@ -528,7 +535,7 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const auto physical_terminal = m_physical_terminals.at(index); ptd.pos_ = index; for (auto real_terminal : physical_terminal->terminals()) { - auto rtd = realTerminalData(real_terminal); + auto rtd = RealTerminalData(real_terminal); ptd.real_terminals_vector.append(rtd); } ptd.uuid_ = physical_terminal->uuid(); @@ -539,15 +546,15 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(int index) const /** * @brief TerminalStrip::physicalTerminalData - * @param real_data - * @return the parent PhysicalTerminalData of \p real_data. - * the PhysicalTerminalData can be invalid if \p real_data don't belong to this strip + * @param 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 */ -PhysicalTerminalData TerminalStrip::physicalTerminalData(const RealTerminalData &real_data) const +PhysicalTerminalData TerminalStrip::physicalTerminalData (QWeakPointer real_terminal) const { PhysicalTerminalData ptd_; - const auto real_t = realTerminalForUuid(real_data.real_terminal_uuid); + const auto real_t = real_terminal.toStrongRef(); if (real_t.isNull()) { return ptd_; } @@ -559,7 +566,7 @@ PhysicalTerminalData TerminalStrip::physicalTerminalData(const RealTerminalData ptd_.pos_ = m_physical_terminals.indexOf(phy_t); for (auto real_terminal : phy_t->terminals()) { - auto rtd = realTerminalData(real_terminal); + auto rtd = RealTerminalData(real_terminal); ptd_.real_terminals_vector.append(rtd); } ptd_.uuid_ = phy_t->uuid(); @@ -634,7 +641,7 @@ bool TerminalStrip::setOrderTo(const QVector &sorted_vecto * @param receiver_terminal * @return true if success */ -bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector &added_terminals) +bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector> &added_terminals) { const auto receiver_ = physicalTerminalForUuid(receiver_terminal.uuid_); if (receiver_.isNull()) { @@ -645,7 +652,7 @@ bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal bool have_grouped = false; for (const auto &added : added_terminals) { - const auto added_terminal = realTerminalForUuid(added.real_terminal_uuid); + const auto added_terminal = added.toStrongRef(); if (added_terminal.isNull()) { continue; @@ -677,12 +684,12 @@ bool TerminalStrip::groupTerminals(const PhysicalTerminalData &receiver_terminal * Ungroup all real terminals of \p terminals_to_ungroup * @param terminals_to_ungroup */ -void TerminalStrip::unGroupTerminals(const QVector &terminals_to_ungroup) +void TerminalStrip::unGroupTerminals(const QVector> &terminals_to_ungroup) { bool ungrouped = false; - for (const auto &rtd_ : terminals_to_ungroup) + for (const auto &rt_ : terminals_to_ungroup) { - if (auto real_terminal = realTerminalForUuid(rtd_.real_terminal_uuid)) //Get the shared real terminal + if (auto real_terminal = rt_.toStrongRef()) //Get the shared real terminal { if (auto physical_terminal = physicalTerminal(real_terminal)) //Get the physical terminal { @@ -710,16 +717,16 @@ void TerminalStrip::unGroupTerminals(const QVector &terminals_ * @param level * @return */ -bool TerminalStrip::setLevel(const RealTerminalData &real_terminal_data, int level) +bool TerminalStrip::setLevel(const QWeakPointer &real_terminal, int level) { - auto real_terminal = realTerminalForUuid(real_terminal_data.real_terminal_uuid); - if (real_terminal) + auto real_t = real_terminal.toStrongRef(); + if (real_t) { - auto physical_terminal = physicalTerminal(real_terminal); + auto physical_terminal = physicalTerminal(real_t); if (physical_terminal) { if (physical_terminal->terminals().size() > 1 && - physical_terminal->setLevelOf(real_terminal, level)) + physical_terminal->setLevelOf(real_t, level)) { emit orderChanged(); return true; @@ -732,27 +739,26 @@ bool TerminalStrip::setLevel(const RealTerminalData &real_terminal_data, int lev /** * @brief TerminalStrip::isBridgeable - * Check if all realTerminal represented by the uuid of @a real_terminals_uuid are bridgeable together. + * Check if all realTerminal in @a real_terminals_data are bridgeable together. * 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 * and at least one terminal must be not bridged - * @param real_terminals_uuid : a vector of RealTerminal uuid - * @sa member real_terminal_uuid of struct RealTerminalData + * @param real_terminals_data : a vector of RealTerminalData * @return */ -bool TerminalStrip::isBridgeable(const QVector &real_terminals_uuid) const +bool TerminalStrip::isBridgeable(const QVector &real_terminals_data) const { - if (real_terminals_uuid.size() < 2) { + if (real_terminals_data.size() < 2) { return false; } // Check if first terminal belong to this strip - auto first_real_terminal = realTerminalForUuid(real_terminals_uuid.first()); + auto first_real_terminal = real_terminals_data.first().m_real_terminal.toStrongRef(); if (!first_real_terminal) { return false; } // Get the level of the first terminal - int level_ = realTerminalData(first_real_terminal).level_; + int level_ = real_terminals_data.first().level(); // Get the physical terminal and pos auto first_physical_terminal = physicalTerminal(first_real_terminal); QVector physical_vector{first_physical_terminal}; @@ -763,16 +769,16 @@ bool TerminalStrip::isBridgeable(const QVector &real_terminals_uuid) cons bool no_bridged = bridge_ ? false : true; // Check for each terminals - for (int i=1 ; i &real_terminals_uuid) cons return no_bridged; } +bool TerminalStrip::isBridgeable(const QVector> &real_terminals) const +{ + QVector data; + + for (const auto &wrt : real_terminals) + { + data.append(RealTerminalData(wrt.toStrongRef())); + } + return isBridgeable(data); +} + /** * @brief TerminalStrip::setBridge - * Set a bridge betwen all real terminal represented by they uuid - * @param real_terminals_uuid + * Set a bridge betwen all real terminal of @a real_terminals * @sa TerminalStrip::isBridgeable * @return true if bridge was successfully created */ -bool TerminalStrip::setBridge(const QVector &real_terminals_uuid) +bool TerminalStrip::setBridge(const QVector> &real_terminals) { - if (!isBridgeable(real_terminals_uuid)) { + if (!isBridgeable(real_terminals)) { return false; } QVector real_terminals_vector; - for (const auto & uuid_ : real_terminals_uuid) { - auto real_t = realTerminalForUuid(uuid_); - if (real_t) - real_terminals_vector << real_t; + for (const auto &real_terminal : real_terminals) + { + auto real_t = real_terminal.toStrongRef(); + if (real_t) { + real_terminals_vector.append(real_t); + } } auto bridge = bridgeFor(real_terminals_vector); @@ -848,29 +866,27 @@ bool TerminalStrip::setBridge(const QVector &real_terminals_uuid) /** * @brief TerminalStrip::setBridge - * Bridge the RealTerminal with uuid in @a real_terminals_uuid to - * the bridge with uuid @a bridge_uuid. - * @param bridge_uuid - * @param real_terminals_uuid + * Bridge the RealTerminal of @a real_terminals_data to @a bridge + * @param bridge + * @param real_terminals_data * @return true if all RealTerminal was successfully bridged */ -bool TerminalStrip::setBridge(const QUuid &bridge_uuid, const QVector &real_terminals_uuid) +bool TerminalStrip::setBridge(QSharedPointer bridge, const QVector> &real_terminals) { - auto bridge_ = bridgeForUuid(bridge_uuid); - if (bridge_) + if (bridge) { - if (!isBridgeable(real_terminals_uuid)) { + if (!isBridgeable(real_terminals)) { return false; } bool b_ = false; - for (const auto & uuid_ : real_terminals_uuid) + for (const auto & rt_ : real_terminals) { - auto real_t = realTerminalForUuid(uuid_); + auto real_t = rt_.toStrongRef(); if (real_t && - !bridge_->real_terminals.contains(real_t)) + !bridge->real_terminals.contains(real_t)) { - bridge_->real_terminals.append(real_t); + bridge->real_terminals.append(real_t); b_ = true; } } @@ -886,46 +902,36 @@ bool TerminalStrip::setBridge(const QUuid &bridge_uuid, const QVector &re /** * @brief TerminalStrip::unBridge - * Unbridge all real terminal represented by they uuid + * Unbridge all real terminal of @a real_terminals * @param real_terminals_uuid */ -void TerminalStrip::unBridge(const QVector &real_terminals_uuid) +void TerminalStrip::unBridge(const QVector> &real_terminals) { - for (const auto & uuid_ : real_terminals_uuid) + for (const auto &real_t : qAsConst(real_terminals)) { - auto real_t = realTerminalForUuid(uuid_); - if (real_t) - { - auto bridge_ = isBridged(real_t); - if (bridge_) - bridge_->real_terminals.removeOne(real_t); + auto bridge_ = bridgeFor(real_t); + if (bridge_) { + bridge_->real_terminals.removeOne(real_t.toStrongRef()); } } emit bridgeChanged(); } -/** - * @brief TerminalStrip::bridgeFor - * @param real_terminal_uuid - * @return - */ -const QSharedPointer TerminalStrip::bridgeFor(const QUuid &real_terminal_uuid) const +QSharedPointer TerminalStrip::bridgeFor(QWeakPointer real_terminal) const { - auto rt = realTerminalForUuid(real_terminal_uuid); - return bridgeFor(QVector{rt}); + return this->isBridged(real_terminal.toStrongRef()); } /** * @brief TerminalStrip::previousTerminalInLevel - * @param real_terminal_uuid - * @return The previous real terminal at the samne level - * as the real terminal with uuid @a real_terminal_uuid - * If there is not a previous terminal, return a null RealTerminalData + * @param real_terminal + * @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 QUuid &real_terminal_uuid) const +RealTerminalData TerminalStrip::previousTerminalInLevel(const QWeakPointer &real_terminal) const { - auto real_t = realTerminalForUuid(real_terminal_uuid); + auto real_t = real_terminal.toStrongRef(); if (real_t) { auto phy_t = physicalTerminal(real_t); @@ -938,7 +944,7 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QUuid &real_termin auto t_vector = m_physical_terminals.at(index-1)->terminals(); if (t_vector.size() > level_) { - return realTerminalData(t_vector.at(level_)); + return RealTerminalData(t_vector.at(level_)); } } } @@ -949,14 +955,13 @@ RealTerminalData TerminalStrip::previousTerminalInLevel(const QUuid &real_termin /** * @brief TerminalStrip::nextTerminalInLevel - * @param real_terminal_uuid - * @return The next real terminal at the samne level - * as the real terminal with uuid @a real_terminal_uuid - * If there is not a next terminal, return a null RealTerminalData + * @param real_terminal + * @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 QUuid &real_terminal_uuid) const +RealTerminalData TerminalStrip::nextTerminalInLevel(const QWeakPointer &real_terminal) const { - auto real_t = realTerminalForUuid(real_terminal_uuid); + auto real_t = real_terminal.toStrongRef(); if (real_t) { auto phy_t = physicalTerminal(real_t); @@ -969,7 +974,7 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QUuid &real_terminal_u auto t_vector = m_physical_terminals.at(index+1)->terminals(); if (t_vector.size() > level_) { - return realTerminalData(t_vector.at(level_)); + return RealTerminalData(t_vector.at(level_)); } } } @@ -978,26 +983,35 @@ RealTerminalData TerminalStrip::nextTerminalInLevel(const QUuid &real_terminal_u return RealTerminalData(); } -RealTerminalData TerminalStrip::previousRealTerminal(const QUuid &real_terminal_uuid) const +RealTerminalData TerminalStrip::previousRealTerminal(const QWeakPointer &real_terminal) const { - auto real = realTerminalForUuid(real_terminal_uuid); + auto real = real_terminal.toStrongRef(); auto index = m_real_terminals.indexOf(real); if (index) { - return realTerminalData(m_real_terminals.at(index-1)); + return RealTerminalData(m_real_terminals.at(index-1)); } return RealTerminalData(); } -RealTerminalData TerminalStrip::nextRealTerminal(const QUuid &real_terminal_uuid) const +RealTerminalData TerminalStrip::nextRealTerminal(const QWeakPointer &real_terminal) const { - auto real = realTerminalForUuid(real_terminal_uuid); + auto real = real_terminal.toStrongRef(); auto index = m_real_terminals.indexOf(real); if (index != m_real_terminals.size()-1) { - return realTerminalData(m_real_terminals.at(index+1)); + return RealTerminalData(m_real_terminals.at(index+1)); } return RealTerminalData(); } +RealTerminalData TerminalStrip::realTerminalDataFor(const QWeakPointer &real_terminal) const +{ + auto rt = real_terminal.toStrongRef(); + if (rt && m_real_terminals.contains(rt)) + return RealTerminalData(rt); + else + return RealTerminalData(); +} + /** * @brief TerminalStrip::terminalElement * @return A vector of all terminal element owned by this strip @@ -1121,38 +1135,6 @@ QSharedPointer TerminalStrip::physicalTerminal(QSharedPointer< return pt; } -RealTerminalData TerminalStrip::realTerminalData(const QSharedPointer real_terminal) const -{ - RealTerminalData rtd; - - auto physical_terminal = physicalTerminal(real_terminal); - - rtd.real_terminal_uuid = real_terminal->uuid(); - rtd.level_ = physical_terminal->levelOf(real_terminal); - rtd.label_ = real_terminal->label(); - - if (real_terminal->isElement()) { - rtd.Xref_ = autonum::AssignVariables::genericXref(real_terminal->element()); - rtd.element_uuid = real_terminal->elementUuid(); - rtd.element_ = real_terminal->element(); - } - rtd.type_ = real_terminal->type(); - rtd.function_ = real_terminal->function(); - rtd.led_ = real_terminal->led(); - rtd.is_element = real_terminal->isElement(); - rtd.is_bridged = isBridged(real_terminal); - if (rtd.is_bridged) { - for (auto bridge : m_bridge) { - if (bridge->real_terminals.contains(real_terminal)) { - rtd.bridge_uuid = bridge->uuid_; - break; - } - } - } - - return rtd; -} - /** * @brief TerminalStrip::physicalTerminalForUuid * Return the PhysicalTerminal with uuid \p uuid or a null @@ -1242,22 +1224,6 @@ QSharedPointer TerminalStrip::bridgeFor(const QVector TerminalStrip::bridgeForUuid(const QUuid &bridge_uuid) -{ - for (const auto &bridge : qAsConst(m_bridge)) { - if (bridge->uuid_ == bridge_uuid) { - return bridge; - } - } - - return QSharedPointer(); -} - /** * @brief TerminalStrip::rebuildRealVector * Rebuild the real terminal vector @@ -1267,7 +1233,169 @@ void TerminalStrip::rebuildRealVector() { m_real_terminals.clear(); for (const auto phy : m_physical_terminals) { - for (const auto &real : phy->terminals()) + for (const auto real : phy->terminals()) m_real_terminals.append(real); } } + +/************************************************************************************/ +/************************************************************************************/ +/************************************************************************************/ +/************************************************************************************/ +/************************************************************************************/ + + +/** + * @brief RealTerminalData::RealTerminalData + * @param real_terminal + */ +RealTerminalData::RealTerminalData(QSharedPointer real_terminal) +{ + m_real_terminal = real_terminal.toWeakRef(); +} + +bool RealTerminalData::isNull() const +{ + return m_real_terminal.isNull(); +} + +int RealTerminalData::level() 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 +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->label(); + } else { + return QString(); + } +} + +QString RealTerminalData::Xref() 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 +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->type(); + } + + return ElementData::TerminalType::TTGeneric; +} + +ElementData::TerminalFunction RealTerminalData::function() const +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->function(); + } + + return ElementData::TerminalFunction::TFGeneric; +} + +bool RealTerminalData::isLed() const +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->led(); + } + + return false; +} + +bool RealTerminalData::isElement() const +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->isElement(); + } + + return false; +} + +bool RealTerminalData::isBridged() 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 +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + return shared_->element(); + } + + return nullptr; +} + +QUuid RealTerminalData::elementUuid() const +{ + auto element_ = element(); + if (element_) { + return element_->uuid(); + } + return QUuid(); +} + +QSharedPointer RealTerminalData::bridge() const +{ + auto shared_ = m_real_terminal.toStrongRef(); + if (shared_) { + auto strip = shared_->parentStrip(); + if (strip) { + return strip->isBridged(shared_); + } + } + return QSharedPointer(); +} + +QWeakPointer RealTerminalData::realTerminal() const +{ + return m_real_terminal; +} diff --git a/sources/TerminalStrip/terminalstrip.h b/sources/TerminalStrip/terminalstrip.h index da16cca39..5d68bba6c 100644 --- a/sources/TerminalStrip/terminalstrip.h +++ b/sources/TerminalStrip/terminalstrip.h @@ -32,36 +32,59 @@ class PhysicalTerminal; class TerminalStripIndex; class TerminalElement; - -/** - * @brief The RealTerminalData struct - * Conveniant struct to quickly get some values - * of a RealTerminal - * A RealTerminalData with level_ = -1 - * is considered as a null data - */ -struct RealTerminalData +struct TerminalStripBridge { - int level_ = -1; + QVector> real_terminals; + QColor color_ = Qt::darkGray; + QUuid uuid_ = QUuid::createUuid(); +}; - QString label_, - Xref_, - cable_, - cable_wire_, - conductor_; +inline bool operator == (const TerminalStripBridge &bridge_1, const TerminalStripBridge &bridge_2) { + return (bridge_1.uuid_ == bridge_2.uuid_); +} - QUuid element_uuid, - real_terminal_uuid, - bridge_uuid; +inline uint qHash(const QWeakPointer &key, uint seed) +{ + const auto bridge = key.toStrongRef(); + if (bridge) { + return qHash(bridge->uuid_, seed); + } else { + return qHash(QUuid (), seed); + } +} - ElementData::TerminalType type_; - ElementData::TerminalFunction function_; +class RealTerminalData +{ + friend class TerminalStrip; + private: + RealTerminalData(QSharedPointer real_terminal); - bool led_ = false, - is_element = false, - is_bridged = false; + public: + RealTerminalData() {} - QPointer element_; + bool isNull() const; + int level() const; + QString label() const; + QString Xref() const; + QString cable() const; + QString cableWire() const; + QString conductor() const; + + ElementData::TerminalType type() const; + ElementData::TerminalFunction function() const; + + bool isLed() const; + bool isElement() const; + bool isBridged() const; + + Element* element() const; + QUuid elementUuid() const; + + QSharedPointer bridge() const; + QWeakPointer realTerminal() const; + + private: + QWeakPointer m_real_terminal; }; /** @@ -85,13 +108,6 @@ inline uint qHash(const PhysicalTerminalData &key, uint seed) { return qHash(key.uuid_, seed); } -struct TerminalStripBridge -{ - QVector> real_terminals; - QColor color_ = Qt::darkGray; - QUuid uuid_ = QUuid::createUuid(); -}; - /** * @brief The TerminalStrip class * This class hold all the datas and configurations @@ -102,6 +118,7 @@ struct TerminalStripBridge class TerminalStrip : public QObject { friend class TerminalStripModel; + friend class RealTerminalData; Q_OBJECT @@ -140,22 +157,25 @@ class TerminalStrip : public QObject int physicalTerminalCount() const; PhysicalTerminalData physicalTerminalData(int index) const; - PhysicalTerminalData physicalTerminalData (const RealTerminalData &real_data) const; + PhysicalTerminalData physicalTerminalData (QWeakPointer real_terminal) const; QVector physicalTerminalData() const; bool setOrderTo(const QVector &sorted_vector); - bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector &added_terminals); - void unGroupTerminals(const QVector &terminals_to_ungroup); - bool setLevel(const RealTerminalData &real_terminal_data, int level); - bool isBridgeable(const QVector &real_terminals_uuid) const; - bool setBridge(const QVector &real_terminals_uuid); - bool setBridge(const QUuid &bridge_uuid, const QVector &real_terminals_uuid); - void unBridge(const QVector &real_terminals_uuid); - const QSharedPointer bridgeFor(const QUuid &real_terminal_uuid) const; + bool groupTerminals(const PhysicalTerminalData &receiver_terminal, const QVector> &added_terminals); + void unGroupTerminals(const QVector> &terminals_to_ungroup); + bool setLevel(const QWeakPointer &real_terminal, int level); - RealTerminalData previousTerminalInLevel(const QUuid &real_terminal_uuid) const; - RealTerminalData nextTerminalInLevel(const QUuid &real_terminal_uuid) const; - RealTerminalData previousRealTerminal(const QUuid &real_terminal_uuid) const; - RealTerminalData nextRealTerminal(const QUuid &real_terminal_uuid) const; + bool isBridgeable(const QVector &real_terminals_data) const; + bool isBridgeable(const QVector> &real_terminals) const; + bool setBridge(const QVector> &real_terminals); + bool setBridge(QSharedPointer bridge, const QVector> &real_terminals); + void unBridge(const QVector> &real_terminals); + QSharedPointer bridgeFor(QWeakPointer real_terminal) const; + + RealTerminalData previousTerminalInLevel(const QWeakPointer &real_terminal) const; + RealTerminalData nextTerminalInLevel(const QWeakPointer &real_terminal) const; + RealTerminalData previousRealTerminal(const QWeakPointer &real_terminal) const; + RealTerminalData nextRealTerminal(const QWeakPointer &real_terminal) const; + RealTerminalData realTerminalDataFor(const QWeakPointer &real_terminal) const; QVector> terminalElement() const; @@ -166,12 +186,10 @@ class TerminalStrip : public QObject private: QSharedPointer realTerminal(Element *terminal); QSharedPointer physicalTerminal(QSharedPointer terminal) const; - RealTerminalData realTerminalData(const QSharedPointer real_terminal) const; QSharedPointer physicalTerminalForUuid (const QUuid &uuid) const; QSharedPointer realTerminalForUuid(const QUuid &uuid) const; QSharedPointer isBridged(const QSharedPointer real_terminal) const; QSharedPointer bridgeFor (const QVector> &terminal_vector) const; - QSharedPointer bridgeForUuid (const QUuid &bridge_uuid); void rebuildRealVector(); private: diff --git a/sources/TerminalStrip/ui/terminalstripeditor.cpp b/sources/TerminalStrip/ui/terminalstripeditor.cpp index eb193c1ea..f6753534d 100644 --- a/sources/TerminalStrip/ui/terminalstripeditor.cpp +++ b/sources/TerminalStrip/ui/terminalstripeditor.cpp @@ -72,10 +72,10 @@ TerminalStripEditor::TerminalStripEditor(QETProject *project, QWidget *parent) : { if (m_model->columnTypeForIndex(index) == TerminalStripModel::XRef) { - auto rtd = m_model->realTerminalDataForIndex(index); - if (rtd.element_) + auto mrtd = m_model->modelRealTerminalDataForIndex(index); + if (mrtd.element_) { - auto elmt = rtd.element_; + auto elmt = mrtd.element_; auto diagram = elmt->diagram(); if (diagram) { @@ -235,12 +235,12 @@ QTreeWidgetItem* TerminalStripEditor::addTerminalStrip(TerminalStrip *terminal_s if (ptd.real_terminals_vector.size()) { auto real_t = ptd.real_terminals_vector.first(); - auto terminal_item = new QTreeWidgetItem(strip_item, QStringList(real_t.label_), TerminalStripTreeWidget::Terminal); - terminal_item->setData(0, TerminalStripTreeWidget::UUID_USER_ROLE, real_t.element_uuid.toString()); + 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.element_uuid, qgraphicsitem_cast(real_t.element_)); + if (real_t.element()) { + m_uuid_terminal_H.insert(real_t.elementUuid(), qgraphicsitem_cast(real_t.element())); } } } @@ -395,28 +395,28 @@ void TerminalStripEditor::selectionChanged() ui->m_led_cb ->setEnabled(true); } - const auto physical_terminal_vector = m_model->physicalTerminalDataForIndex(index_list); - const auto real_terminal_vector = m_model->realTerminalDataForIndex(index_list); + const auto model_physical_terminal_vector = m_model->modelPhysicalTerminalDataForIndex(index_list); + const auto model_real_terminal_vector = m_model->modelRealTerminalDataForIndex(index_list); //Enable/disable group button - ui->m_group_terminals_pb->setEnabled(physical_terminal_vector.size() > 1 ? true : false); + ui->m_group_terminals_pb->setEnabled(model_physical_terminal_vector.size() > 1 ? true : false); //Enable/disable ungroup button - auto it_= std::find_if(physical_terminal_vector.constBegin(), physical_terminal_vector.constEnd(), [](const PhysicalTerminalData &data) + auto it_= std::find_if(model_physical_terminal_vector.constBegin(), model_physical_terminal_vector.constEnd(), [](const modelPhysicalTerminalData &data) { - if (data.real_terminals_vector.size() >= 2) { + if (data.real_data.size() >= 2) { return true; } else { return false; } }); - ui->m_ungroup_pb->setDisabled(it_ == physical_terminal_vector.constEnd()); + ui->m_ungroup_pb->setDisabled(it_ == model_physical_terminal_vector.constEnd()); //Enable/disable level spinbox bool enable_ = false; - for (const auto &physical : physical_terminal_vector) + for (const auto &physical : model_physical_terminal_vector) { - if (physical.real_terminals_vector.size() > 1) { + if (physical.real_data.size() > 1) { enable_ = true; break; } @@ -432,25 +432,30 @@ void TerminalStripEditor::selectionChanged() if (level_ >= 0) { //Select only terminals of corresponding level cell selection - QVector real_terminal_level_vector; - for (const auto &rtd : real_terminal_vector) { - if (rtd.level_ == level_) { - real_terminal_level_vector.append(rtd); + QVector model_real_terminal_level_vector; + for (const auto &mrtd : model_real_terminal_vector) { + if (mrtd.level_ == level_) { + model_real_terminal_level_vector.append(mrtd); } } - QVector uuid_v; - for (const auto &rtd : real_terminal_level_vector) { - uuid_v << rtd.real_terminal_uuid; + QVector model_rtd_vector; + for (const auto &mrtd : model_real_terminal_level_vector) { + model_rtd_vector << mrtd; } - if (m_current_strip) { - enable_bridge = m_current_strip->isBridgeable(uuid_v); + if (m_current_strip) + { + QVector> vector_; + for (const auto &mrtd : model_rtd_vector) { + vector_.append(mrtd.real_terminal); + } + enable_bridge = m_current_strip->isBridgeable(vector_); } - for (const auto &rtd : real_terminal_level_vector) + for (const auto &mrtd : model_real_terminal_level_vector) { - if (rtd.is_bridged && - rtd.level_ == level_) { + if (mrtd.bridged_ && + mrtd.level_ == level_) { enable_unbridge = true; break; } @@ -643,22 +648,21 @@ void TerminalStripEditor::on_m_dialog_button_box_clicked(QAbstractButton *button if (m_model) { - for (const auto &data_ : m_model->modifiedRealTerminalData()) + for (const auto &data_ : m_model->modifiedmodelRealTerminalData()) { - auto original_ = data_.first; - auto edited_ = data_.second; - auto element = original_.element_; - if (element) { + auto element = data_.element_; + if (element) + { auto current_data = element->elementData(); - current_data.setTerminalType(edited_.type_); - current_data.setTerminalFunction(edited_.function_); - current_data.setTerminalLED(edited_.led_); - current_data.m_informations.addValue(QStringLiteral("label"), edited_.label_); + current_data.setTerminalType(data_.type_); + current_data.setTerminalFunction(data_.function_); + current_data.setTerminalLED(data_.led_); + current_data.m_informations.addValue(QStringLiteral("label"), data_.label_); if (element->elementData() != current_data) m_project->undoStack()->push(new ChangeElementDataCommand(element, current_data)); - if (edited_.level_) - m_project->undoStack()->push(new ChangeTerminalLevel(m_current_strip, original_, edited_.level_)); + if (data_.level_ != m_current_strip->realTerminalDataFor(data_.real_terminal).level()) + m_project->undoStack()->push(new ChangeTerminalLevel(m_current_strip, data_.real_terminal, data_.level_)); } } } @@ -687,11 +691,16 @@ void TerminalStripEditor::on_m_group_terminals_pb_clicked() { if (m_model && m_current_strip && m_project) { - auto rtd_vector = m_model->realTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes()); - if (rtd_vector.size() >= 2) + auto mrtd_vector = m_model->modelRealTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes()); + if (mrtd_vector.size() >= 2) { - auto receiver_ = m_current_strip->physicalTerminalData(rtd_vector.takeFirst()); - m_project->undoStack()->push(new GroupTerminalsCommand(m_current_strip, receiver_, rtd_vector)); + auto receiver_ = m_current_strip->physicalTerminalData(mrtd_vector.takeFirst().real_terminal); + + QVector> vector_; + for (const auto & mrtd : mrtd_vector) { + vector_.append(mrtd.real_terminal); + } + m_project->undoStack()->push(new GroupTerminalsCommand(m_current_strip, receiver_, vector_)); } } } @@ -703,8 +712,13 @@ void TerminalStripEditor::on_m_ungroup_pb_clicked() { if (m_model && m_current_strip) { - const auto rtd_vector = m_model->realTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes()); - m_project->undoStack()->push(new UnGroupTerminalsCommand(m_current_strip, rtd_vector)); + const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(ui->m_table_widget->selectionModel()->selectedIndexes()); + + QVector> vector_; + for (const auto &mrtd : mrtd_vector) { + vector_.append(mrtd.real_terminal); + } + m_project->undoStack()->push(new UnGroupTerminalsCommand(m_current_strip, vector_)); } } @@ -826,16 +840,18 @@ void TerminalStripEditor::on_m_bridge_terminals_pb_clicked() else if(level_ == TerminalStripModel::Level3){level_ = 3;} const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes(); - const auto rtd_vector = m_model->realTerminalDataForIndex(index_list); - QVector uuid_vector; - for (const auto &rtd : rtd_vector) + const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list); + + QVector > match_vector; + for (const auto &mrtd : mrtd_vector) { - if (rtd.level_ == level_) { - uuid_vector.append(rtd.real_terminal_uuid); + if (mrtd.level_ == level_) { + match_vector.append(mrtd.real_terminal); } } - if (m_current_strip->isBridgeable(uuid_vector)) { - m_project->undoStack()->push(new BridgeTerminalsCommand(m_current_strip, uuid_vector)); + + if (m_current_strip->isBridgeable(match_vector)) { + m_project->undoStack()->push(new BridgeTerminalsCommand(m_current_strip, match_vector)); } } } @@ -858,16 +874,16 @@ void TerminalStripEditor::on_m_unbridge_terminals_pb_clicked() else if(level_ == TerminalStripModel::Level3){level_ = 3;} const auto index_list = ui->m_table_widget->selectionModel()->selectedIndexes(); - const auto rtd_vector = m_model->realTerminalDataForIndex(index_list); - QVector uuid_vector; - for (const auto &rtd : rtd_vector) + const auto mrtd_vector = m_model->modelRealTerminalDataForIndex(index_list); + QVector> match_vector; + for (const auto &mrtd : mrtd_vector) { - if (rtd.level_ == level_ - && rtd.is_bridged) { - uuid_vector.append(rtd.real_terminal_uuid); + if (mrtd.level_ == level_ + && mrtd.bridged_) { + match_vector.append(mrtd.real_terminal); } } - m_project->undoStack()->push(new UnBridgeTerminalsCommand(m_current_strip, uuid_vector)); + m_project->undoStack()->push(new UnBridgeTerminalsCommand(m_current_strip, match_vector)); } } } diff --git a/sources/TerminalStrip/ui/terminalstripmodel.cpp b/sources/TerminalStrip/ui/terminalstripmodel.cpp index a5dc20747..2d14ec95a 100644 --- a/sources/TerminalStrip/ui/terminalstripmodel.cpp +++ b/sources/TerminalStrip/ui/terminalstripmodel.cpp @@ -117,8 +117,8 @@ int TerminalStripModel::rowCount(const QModelIndex &parent) const } auto count = 0; - for (const auto &ptd : m_edited_terminal_data) { - count += ptd.real_terminals_vector.size(); + for (const auto &mptd : m_physical_data) { + count += mptd.real_data.size(); } return count; @@ -136,28 +136,28 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const return QVariant(); } - const auto rtd = dataAtRow(index.row()); + const auto mrtd = dataAtRow(index.row()); if (role == Qt::DisplayRole) { switch (index.column()) { case POS_CELL : return physicalDataAtIndex(index.row()).pos_; - case LEVEL_CELL : return rtd.level_; - case LABEL_CELL : return rtd.label_; - case XREF_CELL : return rtd.Xref_; - case CABLE_CELL : return rtd.cable_; - case CABLE_WIRE_CELL : return rtd.cable_wire_; - case TYPE_CELL : return ElementData::translatedTerminalType(rtd.type_); - case FUNCTION_CELL : return ElementData::translatedTerminalFunction(rtd.function_); - case CONDUCTOR_CELL : return rtd.conductor_; + case LEVEL_CELL : return mrtd.level_; + case LABEL_CELL : return mrtd.label_; + case XREF_CELL : return mrtd.Xref_; + case CABLE_CELL : return mrtd.cable_; + case CABLE_WIRE_CELL : return mrtd.cable_wire; + case TYPE_CELL : return ElementData::translatedTerminalType(mrtd.type_); + case FUNCTION_CELL : return ElementData::translatedTerminalFunction(mrtd.function_); + case CONDUCTOR_CELL : return mrtd.conductor_; default : return QVariant(); } } else if (role == Qt::EditRole) { switch (index.column()) { - case LABEL_CELL : return rtd.label_; + case LABEL_CELL : return mrtd.label_; default: return QVariant(); } @@ -165,12 +165,12 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const else if (role == Qt::CheckStateRole && index.column() == LED_CELL) { - return rtd.led_ ? Qt::Checked : Qt::Unchecked; + return mrtd.led_ ? Qt::Checked : Qt::Unchecked; } else if (role == Qt::BackgroundRole && index.column() <= CONDUCTOR_CELL ) { - if (m_modified_cell.contains(rtd.element_) && - m_modified_cell.value(rtd.element_).at(index.column())) + if (m_modified_cell.contains(mrtd.element_) && + m_modified_cell.value(mrtd.element_).at(index.column())) { return QBrush(Qt::yellow); } @@ -193,7 +193,7 @@ QVariant TerminalStripModel::data(const QModelIndex &index, int role) const bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value, int role) { - auto rtd = dataAtRow(index.row()); + auto mrtd = dataAtRow(index.row()); bool modified_ = false; int modified_cell = -1; auto column_ = index.column(); @@ -201,35 +201,35 @@ bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value if (column_ == LEVEL_CELL && role == Qt::EditRole) { - rtd.level_ = value.toInt(); + mrtd.level_ = value.toInt(); modified_ = true; modified_cell = LEVEL_CELL; } else if (column_ == LED_CELL) { - rtd.led_ = value.toBool(); + mrtd.led_ = value.toBool(); modified_ = true; modified_cell = LED_CELL; } else if (column_ == TYPE_CELL && role == Qt::EditRole) { - rtd.type_ = value.value(); + mrtd.type_ = value.value(); modified_ = true; modified_cell = TYPE_CELL; } else if (column_ == FUNCTION_CELL && role == Qt::EditRole) { - rtd.function_ = value.value(); + mrtd.function_ = value.value(); modified_ = true; modified_cell = FUNCTION_CELL; } else if (column_ == LABEL_CELL && role == Qt::EditRole && - rtd.label_ != value.toString()) + mrtd.label_ != value.toString()) { - rtd.label_ = value.toString(); + mrtd.label_ = value.toString(); modified_ = true; modified_cell = LABEL_CELL; } @@ -237,19 +237,19 @@ bool TerminalStripModel::setData(const QModelIndex &index, const QVariant &value //Set the modification to the terminal data if (modified_) { - replaceDataAtRow(rtd, index.row()); + replaceDataAtRow(mrtd, index.row()); - if (rtd.element_) + if (mrtd.element_) { QVector vector_; - if (m_modified_cell.contains(rtd.element_)) { - vector_ = m_modified_cell.value(rtd.element_); + if (m_modified_cell.contains(mrtd.element_)) { + vector_ = m_modified_cell.value(mrtd.element_); } else { vector_ = UNMODIFIED_CELL_VECTOR; } vector_.replace(modified_cell, true); - m_modified_cell.insert(rtd.element_, vector_); + m_modified_cell.insert(mrtd.element_, vector_); } emit dataChanged(index, index); return true; @@ -305,22 +305,21 @@ Qt::ItemFlags TerminalStripModel::flags(const QModelIndex &index) const * @return a vector of QPair of modified terminal. * the first value of the QPair is the original data, the second value is the edited data */ -QVector> TerminalStripModel::modifiedRealTerminalData() const +QVector TerminalStripModel::modifiedmodelRealTerminalData() const { - QVector> returned_vector; + QVector returned_vector; const auto modified_real_terminal = m_modified_cell.keys(); - for (auto i = 0 ; i> TerminalStripModel::modifiedR * @return A vector of PhysicalTerminalData represented by index_list. * If sereval index point to the same terminal the vector have only one PhysicalTerminalData */ -QVector TerminalStripModel::physicalTerminalDataForIndex(QModelIndexList index_list) const +QVector TerminalStripModel::modelPhysicalTerminalDataForIndex(QModelIndexList index_list) const { - QVector vector_; + QVector vector_; if (index_list.isEmpty()) { return vector_; } @@ -350,7 +349,8 @@ QVector TerminalStripModel::physicalTerminalDataForIndex(Q } } - for (auto i : set_) { + for (const auto i : set_) + { const auto phy = physicalDataAtIndex(i); if (!vector_.contains(phy)) { vector_.append(phy); @@ -365,9 +365,9 @@ QVector TerminalStripModel::physicalTerminalDataForIndex(Q * @param index_list * @return */ -QVector TerminalStripModel::realTerminalDataForIndex(QModelIndexList index_list) const +QVector TerminalStripModel::modelRealTerminalDataForIndex(QModelIndexList index_list) const { - QVector vector_; + QVector vector_; if (index_list.isEmpty()) { return vector_; } @@ -393,14 +393,14 @@ QVector TerminalStripModel::realTerminalDataForIndex(QModelInd /** * @brief TerminalStripModel::realTerminalDataForIndex * @param index - * @return RealTerminalData at index @a index or null RealTerminalData if invalid + * @return modelRealTerminalData at index @a index or null modelRealTerminalData if invalid */ -RealTerminalData TerminalStripModel::realTerminalDataForIndex(const QModelIndex &index) const +modelRealTerminalData TerminalStripModel::modelRealTerminalDataForIndex(const QModelIndex &index) const { if (index.isValid()) { return realDataAtIndex(index.row()); } else { - return RealTerminalData(); + return modelRealTerminalData(); } } @@ -479,25 +479,38 @@ void TerminalStripModel::buildBridgePixmap(const QSize &pixmap_size) void TerminalStripModel::fillPhysicalTerminalData() { //Get all physical terminal - if (m_terminal_strip) { - for (auto i=0 ; i < m_terminal_strip->physicalTerminalCount() ; ++i) { - m_original_terminal_data.append(m_terminal_strip->physicalTerminalData(i)); + if (m_terminal_strip) + { + for (const auto &ptd : m_terminal_strip->physicalTerminalData()) + { + modelPhysicalTerminalData mptd; + mptd.pos_ = ptd.pos_; + mptd.uuid_ = ptd.uuid_; + + for (const auto &rtd : ptd.real_terminals_vector) + { + if (!rtd.isNull()) + { + mptd.real_data.append(modelRealData(rtd)); + } + } + + m_physical_data.append(mptd); } - m_edited_terminal_data = m_original_terminal_data; } } -RealTerminalData TerminalStripModel::dataAtRow(int row) const +modelRealTerminalData TerminalStripModel::dataAtRow(int row) const { if (row > rowCount(QModelIndex())) { - return RealTerminalData(); + return modelRealTerminalData(); } else { auto current_row = 0; - for (const auto &physical_data : m_edited_terminal_data) + for (const auto &physical_data : qAsConst(m_physical_data)) { - for (const auto &real_data : physical_data.real_terminals_vector) + for (const auto &real_data : physical_data.real_data) { if (current_row == row) { return real_data; @@ -508,7 +521,7 @@ RealTerminalData TerminalStripModel::dataAtRow(int row) const } } - return RealTerminalData(); + return modelRealTerminalData(); } /** @@ -517,7 +530,7 @@ RealTerminalData TerminalStripModel::dataAtRow(int row) const * @param data * @param row */ -void TerminalStripModel::replaceDataAtRow(RealTerminalData data, int row) +void TerminalStripModel::replaceDataAtRow(modelRealTerminalData data, int row) { if (row > rowCount(QModelIndex())) { return; @@ -527,15 +540,15 @@ void TerminalStripModel::replaceDataAtRow(RealTerminalData data, int row) auto current_row = 0; auto current_physical = 0; - for (const auto &physical_data : qAsConst(m_edited_terminal_data)) + for (const auto &physical_data : qAsConst(m_physical_data)) { auto current_real = 0; - for (int i=0 ; i= index) { @@ -578,9 +591,9 @@ PhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const } if (match_) { - return m_edited_terminal_data.at(current_phy); + return m_physical_data.at(current_phy); } else { - return PhysicalTerminalData(); + return modelPhysicalTerminalData(); } } @@ -589,17 +602,17 @@ PhysicalTerminalData TerminalStripModel::physicalDataAtIndex(int index) const * @param index * @return the realTerminalData at index \p index. */ -RealTerminalData TerminalStripModel::realDataAtIndex(int index) const +modelRealTerminalData TerminalStripModel::realDataAtIndex(int index) const { - if (m_edited_terminal_data.isEmpty()) { - return RealTerminalData(); + if (m_physical_data.isEmpty()) { + return modelRealTerminalData(); } int current_checked_index = -1; - for (const auto & ptd_ : qAsConst(m_edited_terminal_data)) + for (const auto & ptd_ : qAsConst(m_physical_data)) { - for (const auto & rtd_ : qAsConst(ptd_.real_terminals_vector)) { + for (const auto & rtd_ : qAsConst(ptd_.real_data)) { ++current_checked_index; if (current_checked_index == index) { return rtd_; @@ -607,7 +620,7 @@ RealTerminalData TerminalStripModel::realDataAtIndex(int index) const } } - return RealTerminalData(); + return modelRealTerminalData(); } QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const @@ -621,28 +634,31 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const return QPixmap(); } - auto rtd = realTerminalDataForIndex(index); + auto mrtd = modelRealTerminalDataForIndex(index); //Terminal level correspond to the column level of index - if (level_column == rtd.level_) + if (level_column == mrtd.level_) { - if (rtd.is_bridged) + if (mrtd.bridged_) { - auto bridge_uuid = rtd.bridge_uuid; - auto previous_bridge_uuid = m_terminal_strip->previousTerminalInLevel(rtd.real_terminal_uuid).bridge_uuid; - auto next_bridge_uuid = m_terminal_strip->nextTerminalInLevel(rtd.real_terminal_uuid).bridge_uuid; + 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(); - auto color_ = m_terminal_strip->bridgeFor(rtd.real_terminal_uuid)->color_; - auto pixmap_ = m_bridges_pixmaps.value(color_); + auto color_ = bridge_->color_; + auto pixmap_ = m_bridges_pixmaps.value(color_); //Current real terminal between two bridged terminal - if ((bridge_uuid == previous_bridge_uuid) && - (bridge_uuid == next_bridge_uuid)) { - return pixmap_.middle_; - } else if (bridge_uuid == previous_bridge_uuid) { - return pixmap_.bottom_; - } else if (bridge_uuid == next_bridge_uuid) { - return pixmap_.top_; + if ((bridge_ == previous_bridge) && + (bridge_ == next_bridge)) { + return pixmap_.middle_; + } else if (bridge_ == previous_bridge) { + return pixmap_.bottom_; + } else if (bridge_ == next_bridge) { + return pixmap_.top_; + } } } } @@ -650,26 +666,25 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const //Check if we need to draw a none bridge pixmap //Check previous - auto physical_data = m_terminal_strip->physicalTerminalData(rtd); - auto current_real_uuid = rtd.real_terminal_uuid; + auto physical_data = m_terminal_strip->physicalTerminalData(mrtd.real_terminal); + auto current_real_terminal = mrtd; auto current_phy_uuid = physical_data.uuid_; bool already_jumped_to_previous = false; - RealTerminalData previous_data; + modelRealTerminalData previous_data; do { - auto previous_rtd = m_terminal_strip->previousRealTerminal(current_real_uuid); - current_real_uuid = previous_rtd.real_terminal_uuid; + current_real_terminal = modelRealData(m_terminal_strip->previousRealTerminal(current_real_terminal.real_terminal)); - if (previous_rtd.level_ == -1) { + if (current_real_terminal.level_ == -1) { break; } //We are in the same physical terminal as previous loop - if (current_phy_uuid == m_terminal_strip->physicalTerminalData(previous_rtd).uuid_) + if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_) { - if (previous_rtd.is_bridged && - previous_rtd.level_ == level_column) { - previous_data = previous_rtd; + if (current_real_terminal.bridged_ && + current_real_terminal.level_ == level_column) { + previous_data = current_real_terminal; break; } } @@ -677,34 +692,34 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const break; } else { already_jumped_to_previous = true; - current_phy_uuid = m_terminal_strip->physicalTerminalData(previous_rtd).uuid_; - if (previous_rtd.is_bridged && - previous_rtd.level_ == level_column) { - previous_data = previous_rtd; + current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_; + if (current_real_terminal.bridged_ && + current_real_terminal.level_ == level_column) { + previous_data = current_real_terminal; break; } } } while(true); //Check next - current_real_uuid = rtd.real_terminal_uuid; + current_real_terminal = mrtd; current_phy_uuid = physical_data.uuid_; bool already_jumped_to_next = false; - RealTerminalData next_data; - do { - auto next_rtd = m_terminal_strip->nextRealTerminal(current_real_uuid); - current_real_uuid = next_rtd.real_terminal_uuid; + modelRealTerminalData next_data; - if (next_rtd.level_ == -1) { + do { + current_real_terminal = modelRealData(m_terminal_strip->nextRealTerminal(current_real_terminal.real_terminal)); + + if (current_real_terminal.level_ == -1) { break; } //We are in the same physical terminal as previous loop - if (current_phy_uuid == m_terminal_strip->physicalTerminalData(next_rtd).uuid_) + if (current_phy_uuid == m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_) { - if (next_rtd.is_bridged && - next_rtd.level_ == level_column) { - next_data = next_rtd; + if (current_real_terminal.bridged_ && + current_real_terminal.level_ == level_column) { + next_data = current_real_terminal; break; } } @@ -712,27 +727,50 @@ QPixmap TerminalStripModel::bridgePixmapFor(const QModelIndex &index) const break; } else { already_jumped_to_next = true; - current_phy_uuid = m_terminal_strip->physicalTerminalData(next_rtd).uuid_; - if (next_rtd.is_bridged && - next_rtd.level_ == level_column) { - next_data = next_rtd; + current_phy_uuid = m_terminal_strip->physicalTerminalData(current_real_terminal.real_terminal).uuid_; + if (current_real_terminal.bridged_ && + current_real_terminal.level_ == level_column) { + next_data = current_real_terminal; break; } } } while(true); - if (previous_data.bridge_uuid == next_data.bridge_uuid) { - auto bridge_ = m_terminal_strip->bridgeFor(previous_data.real_terminal_uuid); - if (bridge_) { - return m_bridges_pixmaps.value(bridge_->color_).none_; + auto previous_bridge = m_terminal_strip->bridgeFor(previous_data.real_terminal); + if (previous_bridge == m_terminal_strip->bridgeFor(next_data.real_terminal)) + { + if (previous_bridge) { + return m_bridges_pixmaps.value(previous_bridge->color_).none_; } } return QPixmap(); } +modelRealTerminalData TerminalStripModel::modelRealData(const RealTerminalData &data) +{ + modelRealTerminalData mrtd; + if (!data.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(); + } + + return mrtd; +} + /*********************************************************** - * Alittle delegate for add a combobox to edit type + * A little delegate for add a combobox to edit type * and a spinbox to edit the level of a terminal **********************************************************/ diff --git a/sources/TerminalStrip/ui/terminalstripmodel.h b/sources/TerminalStrip/ui/terminalstripmodel.h index 7c8ea6d70..245727a07 100644 --- a/sources/TerminalStrip/ui/terminalstripmodel.h +++ b/sources/TerminalStrip/ui/terminalstripmodel.h @@ -26,14 +26,54 @@ #include #include "../terminalstrip.h" +#include "../../qetgraphicsitem/element.h" //Code to use QColor as key for QHash inline uint qHash(const QColor &key, uint seed) { return qHash(key.name(), seed); } +//needed to use QPointer as key of QHash +inline uint qHash(const QPointer &key, uint seed) { + if (key) + return qHash(key->uuid(), seed); + else + return qHash(nullptr, seed); +} + class TerminalStrip; + +struct modelRealTerminalData +{ + int level_ = -1; + QString label_; + QString Xref_; + QString cable_; + QString cable_wire; + QString conductor_; + bool led_ = false; + bool bridged_ = false; + + ElementData::TerminalType type_ = ElementData::TerminalType::TTGeneric; + ElementData::TerminalFunction function_ = ElementData::TerminalFunction::TFGeneric; + QPointer element_; + + QWeakPointer real_terminal; + +}; + +struct modelPhysicalTerminalData +{ + QVector real_data; + int pos_ = -1; + QUuid uuid_; +}; + +inline bool operator == (const modelPhysicalTerminalData &data_1, const modelPhysicalTerminalData &data_2) { + return data_1.uuid_ == data_2.uuid_; +} + class TerminalStripModel : public QAbstractTableModel { public: @@ -68,27 +108,28 @@ class TerminalStripModel : public QAbstractTableModel virtual bool setData (const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override; virtual QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override; virtual Qt::ItemFlags flags (const QModelIndex &index) const override; - QVector> modifiedRealTerminalData() const; + QVector modifiedmodelRealTerminalData() const; - QVector physicalTerminalDataForIndex(QModelIndexList index_list) const; - QVector realTerminalDataForIndex(QModelIndexList index_list) const; - RealTerminalData realTerminalDataForIndex(const QModelIndex &index) const; + QVector modelPhysicalTerminalDataForIndex(QModelIndexList index_list) const; + QVector modelRealTerminalDataForIndex(QModelIndexList index_list) const; + modelRealTerminalData modelRealTerminalDataForIndex(const QModelIndex &index) const; void buildBridgePixmap(const QSize &pixmap_size); private: void fillPhysicalTerminalData(); - RealTerminalData dataAtRow(int row) const; - void replaceDataAtRow(RealTerminalData data, int row); - PhysicalTerminalData physicalDataAtIndex(int index) const; - RealTerminalData realDataAtIndex(int index) const; + modelRealTerminalData dataAtRow(int row) const; + void replaceDataAtRow(modelRealTerminalData data, int row); + modelPhysicalTerminalData physicalDataAtIndex(int index) const; + modelRealTerminalData realDataAtIndex(int index) const; QPixmap bridgePixmapFor(const QModelIndex &index) const; + static modelRealTerminalData modelRealData(const RealTerminalData &data); + private: QPointer m_terminal_strip; - QVector m_edited_terminal_data, m_original_terminal_data; - QHash> m_modified_cell; - + QHash, QVector> m_modified_cell; + QVector m_physical_data; struct BridgePixmap { QPixmap top_,