diff --git a/conducerprofile.cpp b/conducerprofile.cpp deleted file mode 100644 index 9cd4fffab..000000000 --- a/conducerprofile.cpp +++ /dev/null @@ -1,137 +0,0 @@ -#include "conducerprofile.h" -#include "conducer.h" -#include "conducersegmentprofile.h" - -/// Constructeur -ConducerProfile::ConducerProfile() { -} - -/** - Constructeur - @param Conducer conducteur dont il faut extraire le profil -*/ -ConducerProfile::ConducerProfile(Conducer *conducer) { - fromConducer(conducer); -} - -/** - Constructeur de copie - @param c autre conducteur -*/ -ConducerProfile::ConducerProfile(const ConducerProfile &c) { - beginOrientation = c.beginOrientation; - endOrientation = c.endOrientation; - foreach(ConducerSegmentProfile *csp, c.segments) { - segments << new ConducerSegmentProfile(*csp); - } -} - -/** - Operateur = - @param c autre conducteur -*/ -ConducerProfile &ConducerProfile::operator=(const ConducerProfile &c) { - if (&c == this) return(*this); - - // supprime ses informations - setNull(); - - // copie les informations de l'autre profil de conducteur - beginOrientation = c.beginOrientation; - endOrientation = c.endOrientation; - foreach(ConducerSegmentProfile *csp, c.segments) { - segments << new ConducerSegmentProfile(*csp); - } - return(*this); -} - -/// destructeur -ConducerProfile::~ConducerProfile() { - setNull(); -} - -/// @return true si le profil est nul -bool ConducerProfile::isNull() const { - return(segments.isEmpty()); -} - -/// supprime les segments du profil de conducteur -void ConducerProfile::setNull() { - foreach(ConducerSegmentProfile *csp, segments) delete csp; - segments.clear(); -} - -/// @return la largeur occupee par le conducteur -qreal ConducerProfile::width() const { - qreal width = 0.0; - foreach(ConducerSegmentProfile *csp, segments) { - if (csp -> isHorizontal) width += csp -> length; - } - return(width); -} - -/// @return la hauteur occupee par le conducteur -qreal ConducerProfile::height() const{ - qreal height = 0.0; - foreach(ConducerSegmentProfile *csp, segments) { - if (!csp -> isHorizontal) height += csp -> length; - } - return(height); -} - -/** - @param type Type de Segments - @return Le nombre de segments composant le conducteur. -*/ -uint ConducerProfile::nbSegments(QET::ConducerSegmentType type) const { - if (type == QET::Both) return(segments.count()); - uint nb_seg = 0; - foreach(ConducerSegmentProfile *csp, segments) { - if (type == QET::Horizontal && csp -> isHorizontal) ++ nb_seg; - else if (type == QET::Vertical && !csp -> isHorizontal) ++ nb_seg; - } - return(nb_seg); -} - -/// @return les segments horizontaux de ce profil -QList ConducerProfile::horizontalSegments() { - QList segments_list; - foreach(ConducerSegmentProfile *csp, segments) { - if (csp -> isHorizontal) segments_list << csp; - } - return(segments_list); -} - -/// @return les segments verticaux de ce profil -QList ConducerProfile::verticalSegments() { - QList segments_list; - foreach(ConducerSegmentProfile *csp, segments) { - if (!csp -> isHorizontal) segments_list << csp; - } - return(segments_list); -} - -void ConducerProfile::fromConducer(Conducer *conducer) { - // supprime les segments precedents - setNull(); - - foreach(ConducerSegment *conducer_segment, conducer -> segmentsList()) { - segments << new ConducerSegmentProfile(conducer_segment); - } - beginOrientation = conducer -> terminal1 -> orientation(); - endOrientation = conducer -> terminal2 -> orientation(); -} - -/** - Permet de debugger un profil de conducteur - @param d Object QDebug a utiliser pour l'affichage des informations de debug - @param t Profil de conducteur a debugger -*/ -QDebug &operator<<(QDebug d, ConducerProfile &t) { - d << "ConducerProfile {"; - foreach(ConducerSegmentProfile *csp, t.segments) { - d << "CSP" << (csp -> isHorizontal ? "horizontal" : "vertical") << ":" << csp -> length << ","; - } - d << "}"; - return(d.space()); -} diff --git a/conducerprofile.h b/conducerprofile.h deleted file mode 100644 index e305a2f39..000000000 --- a/conducerprofile.h +++ /dev/null @@ -1,38 +0,0 @@ -#ifndef CONDUCER_PROFILE_H -#define CONDUCER_PROFILE_H -#include -#include "qet.h" -class Conducer; -class ConducerSegmentProfile; -/** - Cette classe contient le profil (= les caracteristiques essentielles) d'un - conducteur. -*/ -class ConducerProfile { - public: - // constructeurs, destructeur - ConducerProfile(); - ConducerProfile(Conducer *conducer); - ConducerProfile(const ConducerProfile &); - ConducerProfile &operator=(const ConducerProfile &); - virtual ~ConducerProfile(); - - // attributs - public: - QList segments; - QET::Orientation beginOrientation; - QET::Orientation endOrientation; - - // methodes - public: - bool isNull() const; - void setNull(); - qreal width() const; - qreal height() const; - uint nbSegments(QET::ConducerSegmentType) const; - QList horizontalSegments(); - QList verticalSegments(); - void fromConducer(Conducer *); -}; -QDebug &operator<<(QDebug d, ConducerProfile &); -#endif diff --git a/conducer.cpp b/conductor.cpp similarity index 81% rename from conducer.cpp rename to conductor.cpp index 4bb366caa..dd87f5edc 100644 --- a/conducer.cpp +++ b/conductor.cpp @@ -1,15 +1,15 @@ #include -#include "conducer.h" -#include "conducersegment.h" -#include "conducersegmentprofile.h" +#include "conductor.h" +#include "conductorsegment.h" +#include "conductorsegmentprofile.h" #include "element.h" #include "diagram.h" #include "diagramcommands.h" #define PR(x) qDebug() << #x " = " << x; -bool Conducer::pen_and_brush_initialized = false; -QPen Conducer::conducer_pen = QPen(); -QBrush Conducer::conducer_brush = QBrush(); +bool Conductor::pen_and_brush_initialized = false; +QPen Conductor::conductor_pen = QPen(); +QBrush Conductor::conductor_brush = QBrush(); /** Constructeur @@ -18,7 +18,7 @@ QBrush Conducer::conducer_brush = QBrush(); @param parent Element parent du conducteur (0 par defaut) @param scene QGraphicsScene auquelle appartient le conducteur */ -Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *scene) : +Conductor::Conductor(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene *scene) : QGraphicsPathItem(parent, scene), terminal1(p1), terminal2(p2), @@ -29,26 +29,26 @@ Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene * has_to_save_profile(false) { // ajout du conducteur a la liste de conducteurs de chacune des deux bornes - bool ajout_p1 = terminal1 -> addConducer(this); - bool ajout_p2 = terminal2 -> addConducer(this); + bool ajout_p1 = terminal1 -> addConductor(this); + bool ajout_p2 = terminal2 -> addConductor(this); // en cas d'echec de l'ajout (conducteur deja existant notamment) if (!ajout_p1 || !ajout_p2) return; // attributs de dessin par defaut (communs a tous les conducteurs) if (!pen_and_brush_initialized) { - conducer_pen.setJoinStyle(Qt::MiterJoin); - conducer_pen.setCapStyle(Qt::SquareCap); - conducer_pen.setColor(Qt::black); - conducer_pen.setStyle(Qt::SolidLine); - conducer_pen.setWidthF(1.0); - conducer_brush.setColor(Qt::white); - conducer_brush.setStyle(Qt::NoBrush); + conductor_pen.setJoinStyle(Qt::MiterJoin); + conductor_pen.setCapStyle(Qt::SquareCap); + conductor_pen.setColor(Qt::black); + conductor_pen.setStyle(Qt::SolidLine); + conductor_pen.setWidthF(1.0); + conductor_brush.setColor(Qt::white); + conductor_brush.setStyle(Qt::NoBrush); pen_and_brush_initialized = true; } // calcul du rendu du conducteur - priv_calculeConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation()); + priv_calculeConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation()); setFlags(QGraphicsItem::ItemIsSelectable); setAcceptsHoverEvents(true); @@ -65,7 +65,7 @@ Conducer::Conducer(Terminal *p1, Terminal* p2, Element *parent, QGraphicsScene * Detruit le conducteur ainsi que ses segments. Il ne detruit pas les bornes mais s'en detache */ -Conducer::~Conducer() { +Conductor::~Conductor() { // se detache des bornes if (!isDestroyed()) destroy(); @@ -78,15 +78,15 @@ Conducer::~Conducer() { Met a jour la representation graphique du conducteur. @param rect Rectangle a mettre a jour */ -void Conducer::update(const QRectF &rect) { +void Conductor::update(const QRectF &rect) { // utilise soit la fonction priv_modifieConducteur soit la fonction priv_calculeConducteur - void (Conducer::* fonction_update) (const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); - fonction_update = (nbSegments() && modified_path) ? &Conducer::priv_modifieConducer : &Conducer::priv_calculeConducer; + void (Conductor::* fonction_update) (const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); + fonction_update = (nbSegments() && modified_path) ? &Conductor::priv_modifieConductor : &Conductor::priv_calculeConductor; // appelle la bonne fonction pour calculer l'aspect du conducteur (this ->* fonction_update)( - terminal1 -> amarrageConducer(), terminal1 -> orientation(), - terminal2 -> amarrageConducer(), terminal2 -> orientation() + terminal1 -> amarrageConductor(), terminal1 -> orientation(), + terminal2 -> amarrageConductor(), terminal2 -> orientation() ); calculateTextItemPosition(); QGraphicsPathItem::update(rect); @@ -99,22 +99,22 @@ void Conducer::update(const QRectF &rect) { @param b Borne @param newpos position de la borne b */ -void Conducer::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPointF &newpos) { +void Conductor::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPointF &newpos) { QPointF p1, p2; if (b == terminal1) { p1 = newpos; - p2 = terminal2 -> amarrageConducer(); + p2 = terminal2 -> amarrageConductor(); } else if (b == terminal2) { - p1 = terminal1 -> amarrageConducer(); + p1 = terminal1 -> amarrageConductor(); p2 = newpos; } else { - p1 = terminal1 -> amarrageConducer(); - p2 = terminal2 -> amarrageConducer(); + p1 = terminal1 -> amarrageConductor(); + p2 = terminal2 -> amarrageConductor(); } if (nbSegments() && modified_path) - priv_modifieConducer(p1, terminal1 -> orientation(), p2, terminal2 -> orientation()); + priv_modifieConductor(p1, terminal1 -> orientation(), p2, terminal2 -> orientation()); else - priv_calculeConducer(p1, terminal1 -> orientation(), p2, terminal2 -> orientation()); + priv_calculeConductor(p1, terminal1 -> orientation(), p2, terminal2 -> orientation()); calculateTextItemPosition(); QGraphicsPathItem::update(rect); } @@ -122,7 +122,7 @@ void Conducer::updateWithNewPos(const QRectF &rect, const Terminal *b, const QPo /** Genere le QPainterPath a partir de la liste des points */ -void Conducer::segmentsToPath() { +void Conductor::segmentsToPath() { // chemin qui sera dessine QPainterPath path; @@ -133,7 +133,7 @@ void Conducer::segmentsToPath() { path.moveTo(segments -> firstPoint()); // parcourt les segments pour dessiner le chemin - ConducerSegment *segment = segments; + ConductorSegment *segment = segments; while(segment -> hasNextSegment()) { path.lineTo(segment -> secondPoint()); segment = segment -> nextSegment(); @@ -153,9 +153,9 @@ void Conducer::segmentsToPath() { @param p2 Coordonnees du point d'amarrage de la borne 2 @param o2 Orientation de la borne 2 */ -void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const QPointF &p2, QET::Orientation) { - Q_ASSERT_X(conducer_profile.nbSegments(QET::Both) > 1, "Conducer::priv_modifieConducer", "pas de points a modifier"); - Q_ASSERT_X(!conducer_profile.isNull(), "Conducer::priv_modifieConducer", "pas de profil utilisable"); +void Conductor::priv_modifieConductor(const QPointF &p1, QET::Orientation, const QPointF &p2, QET::Orientation) { + Q_ASSERT_X(conductor_profile.nbSegments(QET::Both) > 1, "Conductor::priv_modifieConductor", "pas de points a modifier"); + Q_ASSERT_X(!conductor_profile.isNull(), "Conductor::priv_modifieConductor", "pas de profil utilisable"); // recupere les coordonnees fournies des bornes QPointF new_p1 = mapFromScene(p1); @@ -163,17 +163,17 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q QRectF new_rect = QRectF(new_p1, new_p2); // recupere la largeur et la hauteur du profil - qreal profile_width = conducer_profile.width(); - qreal profile_height = conducer_profile.height(); + qreal profile_width = conductor_profile.width(); + qreal profile_height = conductor_profile.height(); // calcule les differences verticales et horizontales a appliquer qreal h_diff = (qAbs(new_rect.width()) - qAbs(profile_width) ) * getSign(profile_width); qreal v_diff = (qAbs(new_rect.height()) - qAbs(profile_height)) * getSign(profile_height); // applique les differences aux segments - QHash segments_lengths; - segments_lengths.unite(shareOffsetBetweenSegments(h_diff, conducer_profile.horizontalSegments())); - segments_lengths.unite(shareOffsetBetweenSegments(v_diff, conducer_profile.verticalSegments())); + QHash segments_lengths; + segments_lengths.unite(shareOffsetBetweenSegments(h_diff, conductor_profile.horizontalSegments())); + segments_lengths.unite(shareOffsetBetweenSegments(v_diff, conductor_profile.verticalSegments())); // en deduit egalement les coefficients d'inversion (-1 pour une inversion, +1 pour conserver le meme sens) int horiz_coeff = getCoeff(new_rect.width(), profile_width); @@ -182,13 +182,13 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q // genere les nouveaux points QList points; points << new_p1; - int limit = conducer_profile.segments.count() - 1; + int limit = conductor_profile.segments.count() - 1; for (int i = 0 ; i < limit ; ++ i) { // dernier point QPointF previous_point = points.last(); // profil de segment de conducteur en cours - ConducerSegmentProfile *csp = conducer_profile.segments.at(i); + ConductorSegmentProfile *csp = conductor_profile.segments.at(i); // coefficient et offset a utiliser pour ce point qreal coeff = csp -> isHorizontal ? horiz_coeff : verti_coeff; @@ -217,20 +217,20 @@ void Conducer::priv_modifieConducer(const QPointF &p1, QET::Orientation, const Q @param segments_list Segments sur lesquels il faut repartir la longueur @param precision seuil en-deca duquel on considere qu'il ne reste rien a repartir */ -QHash Conducer::shareOffsetBetweenSegments( +QHash Conductor::shareOffsetBetweenSegments( const qreal &offset, - const QList &segments_list, + const QList &segments_list, const qreal &precision ) const { // construit le QHash qui sera retourne - QHash segments_hash; - foreach(ConducerSegmentProfile *csp, segments_list) { + QHash segments_hash; + foreach(ConductorSegmentProfile *csp, segments_list) { segments_hash.insert(csp, csp -> length); } // memorise le signe de la longueur de chaque segement - QHash segments_signs; - foreach(ConducerSegmentProfile *csp, segments_hash.keys()) { + QHash segments_signs; + foreach(ConductorSegmentProfile *csp, segments_hash.keys()) { segments_signs.insert(csp, getSign(csp -> length)); } @@ -241,12 +241,12 @@ QHash Conducer::shareOffsetBetweenSegments( while (remaining_offset > precision || remaining_offset < -precision) { // recupere le nombre de segments differents ayant une longueur non nulle uint segments_count = 0; - foreach(ConducerSegmentProfile *csp, segments_hash.keys()) if (segments_hash[csp]) ++ segments_count; + foreach(ConductorSegmentProfile *csp, segments_hash.keys()) if (segments_hash[csp]) ++ segments_count; //qDebug() << " remaining_offset =" << remaining_offset; qreal local_offset = remaining_offset / segments_count; //qDebug() << " repartition d'un offset local de" << local_offset << "px sur" << segments_count << "segments"; remaining_offset = 0.0; - foreach(ConducerSegmentProfile *csp, segments_hash.keys()) { + foreach(ConductorSegmentProfile *csp, segments_hash.keys()) { // ignore les segments de longueur nulle if (!segments_hash[csp]) continue; // applique l'offset au segment @@ -276,7 +276,7 @@ QHash Conducer::shareOffsetBetweenSegments( @param p2 Coordonnees du point d'amarrage de la borne 2 @param o2 Orientation de la borne 2 */ -void Conducer::priv_calculeConducer(const QPointF &p1, QET::Orientation o1, const QPointF &p2, QET::Orientation o2) { +void Conductor::priv_calculeConductor(const QPointF &p1, QET::Orientation o1, const QPointF &p2, QET::Orientation o2) { QPointF sp1, sp2, depart, newp1, newp2, arrivee, depart0, arrivee0; QET::Orientation ori_depart, ori_arrivee; @@ -375,7 +375,7 @@ void Conducer::priv_calculeConducer(const QPointF &p1, QET::Orientation o1, cons @param ext_size la taille de la prolongation @return le point correspondant a la borne apres prolongation */ -QPointF Conducer::extendTerminal(const QPointF &terminal, QET::Orientation terminal_orientation, qreal ext_size) { +QPointF Conductor::extendTerminal(const QPointF &terminal, QET::Orientation terminal_orientation, qreal ext_size) { QPointF extended_terminal; switch(terminal_orientation) { case QET::North: @@ -401,13 +401,13 @@ QPointF Conducer::extendTerminal(const QPointF &terminal, QET::Orientation termi @param qsogi Les options de style pour le conducteur @param qw Le QWidget sur lequel on dessine */ -void Conducer::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QWidget */*qw*/) { +void Conductor::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QWidget */*qw*/) { qp -> save(); qp -> setRenderHint(QPainter::Antialiasing, false); // affectation du QPen et de la QBrush modifies au QPainter - qp -> setBrush(conducer_brush); - qp -> setPen(conducer_pen); + qp -> setBrush(conductor_brush); + qp -> setPen(conductor_pen); if (isSelected()) { QPen tmp = qp -> pen(); tmp.setColor(Qt::red); @@ -454,14 +454,14 @@ void Conducer::paint(QPainter *qp, const QStyleOptionGraphicsItem */*qsogi*/, QW /** Methode de preparation a la destruction du conducteur ; le conducteur se detache de ses deux bornes */ -void Conducer::destroy() { +void Conductor::destroy() { destroyed = true; - terminal1 -> removeConducer(this); - terminal2 -> removeConducer(this); + terminal1 -> removeConductor(this); + terminal2 -> removeConductor(this); } /// @return le Diagram auquel ce conducteur appartient, ou 0 si ce conducteur est independant -Diagram *Conducer::diagram() const { +Diagram *Conductor::diagram() const { return(qobject_cast(scene())); } @@ -470,9 +470,9 @@ Diagram *Conducer::diagram() const { @param e Un element XML sense represente un Conducteur @return true si l'element XML represente bien un Conducteur ; false sinon */ -bool Conducer::valideXml(QDomElement &e){ +bool Conductor::valideXml(QDomElement &e){ // verifie le nom du tag - if (e.tagName() != "conducer") return(false); + if (e.tagName() != "conductor") return(false); // verifie la presence des attributs minimaux if (!e.hasAttribute("terminal1")) return(false); @@ -493,7 +493,7 @@ bool Conducer::valideXml(QDomElement &e){ Gere les clics sur le conducteur. @param e L'evenement decrivant le clic. */ -void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) { +void Conductor::mousePressEvent(QGraphicsSceneMouseEvent *e) { // clic gauche if (e -> buttons() & Qt::LeftButton) { // recupere les coordonnees du clic @@ -505,7 +505,7 @@ void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) { - sur le milieu d'un segment - ailleurs */ - ConducerSegment *segment = segments; + ConductorSegment *segment = segments; while (segment -> hasNextSegment()) { if (hasClickedOn(press_point, segment -> secondPoint())) { moving_point = true; @@ -532,7 +532,7 @@ void Conducer::mousePressEvent(QGraphicsSceneMouseEvent *e) { Gere les deplacements de souris sur le conducteur. @param e L'evenement decrivant le deplacement de souris. */ -void Conducer::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { +void Conductor::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { // clic gauche if (e -> buttons() & Qt::LeftButton) { // position pointee par la souris @@ -578,7 +578,7 @@ void Conducer::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { Gere les relachements de boutons de souris sur le conducteur @param e L'evenement decrivant le lacher de bouton. */ -void Conducer::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { +void Conductor::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { // clic gauche moving_point = false; moving_segment = false; @@ -595,11 +595,11 @@ void Conducer::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { Gere les mouvements de souris au dessus du conducteur @param e Le QGraphicsSceneHoverEvent decrivant l'evenement */ -void Conducer::hoverMoveEvent(QGraphicsSceneHoverEvent *e) { +void Conductor::hoverMoveEvent(QGraphicsSceneHoverEvent *e) { /* if (isSelected()) { QPointF hover_point = mapFromScene(e -> pos()); - ConducerSegment *segment = segments; + ConductorSegment *segment = segments; bool cursor_set = false; while (segment -> hasNextSegment()) { if (hasClickedOn(hover_point, segment -> secondPoint())) { @@ -620,7 +620,7 @@ void Conducer::hoverMoveEvent(QGraphicsSceneHoverEvent *e) { /** @return Le rectangle delimitant l'espace de dessin du conducteur */ -QRectF Conducer::boundingRect() const { +QRectF Conductor::boundingRect() const { QRectF retour = QGraphicsPathItem::boundingRect(); retour.adjust(-5.0, -5.0, 5.0, 5.0); return(retour); @@ -629,7 +629,7 @@ QRectF Conducer::boundingRect() const { /** @return La forme / zone "cliquable" du conducteur */ -QPainterPath Conducer::shape() const { +QPainterPath Conductor::shape() const { QList points = segmentsToPoints(); QPainterPath area; QPointF previous_point; @@ -675,7 +675,7 @@ QPainterPath Conducer::shape() const { @param bound2 borne 2 @return La valeur bornee */ -qreal Conducer::conducer_bound(qreal tobound, qreal bound1, qreal bound2, qreal space) { +qreal Conductor::conductor_bound(qreal tobound, qreal bound1, qreal bound2, qreal space) { qDebug() << "will bound" << tobound << "between" << bound1 << "and" << bound2 ; if (bound1 < bound2) { return(qBound(bound1 + space, tobound, bound2 - space)); @@ -691,7 +691,7 @@ qreal Conducer::conducer_bound(qreal tobound, qreal bound1, qreal bound2, qreal @param positive true pour borner la valeur avant la borne, false sinon @return La valeur bornee */ -qreal Conducer::conducer_bound(qreal tobound, qreal bound, bool positive) { +qreal Conductor::conductor_bound(qreal tobound, qreal bound, bool positive) { qreal space = 5.0; return(positive ? qMax(tobound, bound + space) : qMin(tobound, bound - space)); } @@ -700,12 +700,12 @@ qreal Conducer::conducer_bound(qreal tobound, qreal bound, bool positive) { @param type Type de Segments @return Le nombre de segments composant le conducteur. */ -uint Conducer::nbSegments(QET::ConducerSegmentType type) const { - QList segments_list = segmentsList(); +uint Conductor::nbSegments(QET::ConductorSegmentType type) const { + QList segments_list = segmentsList(); if (type == QET::Both) return(segments_list.count()); uint nb_seg = 0; - foreach(ConducerSegment *conducer_segment, segments_list) { - if (conducer_segment -> type() == type) ++ nb_seg; + foreach(ConductorSegment *conductor_segment, segments_list) { + if (conductor_segment -> type() == type) ++ nb_seg; } return(nb_seg); } @@ -714,7 +714,7 @@ uint Conducer::nbSegments(QET::ConducerSegmentType type) const { Genere une liste de points a partir des segments de ce conducteur @return La liste de points representant ce conducteur */ -QList Conducer::segmentsToPoints() const { +QList Conductor::segmentsToPoints() const { // liste qui sera retournee QList points_list; @@ -725,7 +725,7 @@ QList Conducer::segmentsToPoints() const { points_list << segments -> firstPoint(); // parcourt les segments pour recuperer les autres points - ConducerSegment *segment = segments; + ConductorSegment *segment = segments; while(segment -> hasNextSegment()) { points_list << segment -> secondPoint(); segment = segment -> nextSegment(); @@ -742,21 +742,21 @@ QList Conducer::segmentsToPoints() const { Regenere les segments de ce conducteur a partir de la liste de points passee en parametre @param points_list Liste de points a utiliser pour generer les segments */ -void Conducer::pointsToSegments(QList points_list) { +void Conductor::pointsToSegments(QList points_list) { // supprime les segments actuels if (segments != NULL) { - ConducerSegment *segment = segments; + ConductorSegment *segment = segments; while (segment -> hasNextSegment()) { - ConducerSegment *nextsegment = segment -> nextSegment(); + ConductorSegment *nextsegment = segment -> nextSegment(); delete segment; segment = nextsegment; } } // cree les segments a partir de la liste de points - ConducerSegment *last_segment = NULL; + ConductorSegment *last_segment = NULL; for (int i = 0 ; i < points_list.size() - 1 ; ++ i) { - last_segment = new ConducerSegment(points_list.at(i), points_list.at(i + 1), last_segment); + last_segment = new ConductorSegment(points_list.at(i), points_list.at(i + 1), last_segment); if (!i) segments = last_segment; } } @@ -768,7 +768,7 @@ void Conducer::pointsToSegments(QList points_list) { @param point point cliquable @return true si l'on peut considerer que le point a ete clique, false sinon */ -bool Conducer::hasClickedOn(QPointF press_point, QPointF point) const { +bool Conductor::hasClickedOn(QPointF press_point, QPointF point) const { return ( press_point.x() >= point.x() - 5.0 &&\ press_point.x() < point.x() + 5.0 &&\ @@ -782,7 +782,7 @@ bool Conducer::hasClickedOn(QPointF press_point, QPointF point) const { @param e Un element XML @return true si le chargement a reussi, false sinon */ -bool Conducer::fromXml(QDomElement &e) { +bool Conductor::fromXml(QDomElement &e) { // recupere la "configuration" du conducteur if (e.attribute("singleline") == "true") { // recupere les parametres specifiques a un conducteur unifilaire @@ -826,8 +826,8 @@ bool Conducer::fromXml(QDomElement &e) { qreal width = 0.0, height = 0.0; foreach (qreal t, segments_x) width += t; foreach (qreal t, segments_y) height += t; - QPointF t1 = terminal1 -> amarrageConducer(); - QPointF t2 = terminal2 -> amarrageConducer(); + QPointF t1 = terminal1 -> amarrageConductor(); + QPointF t2 = terminal2 -> amarrageConductor(); qreal expected_width = t2.x() - t1.x(); qreal expected_height = t2.y() - t1.y(); qreal precision = std::numeric_limits::epsilon(); @@ -866,8 +866,8 @@ bool Conducer::fromXml(QDomElement &e) { bornes dans le document XML et leur adresse en memoire @return Un element XML representant le conducteur */ -QDomElement Conducer::toXml(QDomDocument &d, QHash &table_adr_id) const { - QDomElement e = d.createElement("conducer"); +QDomElement Conductor::toXml(QDomDocument &d, QHash &table_adr_id) const { + QDomElement e = d.createElement("conductor"); e.setAttribute("terminal1", table_adr_id.value(terminal1)); e.setAttribute("terminal2", table_adr_id.value(terminal2)); @@ -876,7 +876,7 @@ QDomElement Conducer::toXml(QDomDocument &d, QHash &table_adr_i if (modified_path) { // parcours et export des segments QDomElement current_segment; - foreach(ConducerSegment *segment, segmentsList()) { + foreach(ConductorSegment *segment, segmentsList()) { current_segment = d.createElement("segment"); current_segment.setAttribute("orientation", segment -> isHorizontal() ? "horizontal" : "vertical"); current_segment.setAttribute("length", segment -> length()); @@ -895,11 +895,11 @@ QDomElement Conducer::toXml(QDomDocument &d, QHash &table_adr_i } /// @return les segments de ce conducteur -const QList Conducer::segmentsList() const { - if (segments == NULL) return(QList()); +const QList Conductor::segmentsList() const { + if (segments == NULL) return(QList()); - QList segments_vector; - ConducerSegment *segment = segments; + QList segments_vector; + ConductorSegment *segment = segments; while (segment -> hasNextSegment()) { segments_vector << segment; @@ -912,10 +912,10 @@ const QList Conducer::segmentsList() const { /** @return La longueur totale du conducteur */ -qreal Conducer::length() { +qreal Conductor::length() { qreal length = 0.0; - ConducerSegment *s = segments; + ConductorSegment *s = segments; while (s -> hasNextSegment()) { length += qAbs(s -> length()); s = s -> nextSegment(); @@ -927,12 +927,12 @@ qreal Conducer::length() { /** @return Le segment qui contient le point au milieu du conducteur */ -ConducerSegment *Conducer::middleSegment() { +ConductorSegment *Conductor::middleSegment() { if (segments == NULL) return(NULL); qreal half_length = length() / 2.0; - ConducerSegment *s = segments; + ConductorSegment *s = segments; qreal l = 0; while (s -> hasNextSegment()) { @@ -949,20 +949,20 @@ ConducerSegment *Conducer::middleSegment() { point au milieu du conducteur @see middleSegment() */ -void Conducer::calculateTextItemPosition() { +void Conductor::calculateTextItemPosition() { text_item -> setPos(middleSegment() -> middle()); } /** Sauvegarde le profil courant du conducteur pour l'utiliser ulterieurement - dans priv_modifieConducer. + dans priv_modifieConductor. */ -void Conducer::saveProfile(bool undo) { - ConducerProfile old_profile = conducer_profile; - conducer_profile.fromConducer(this); +void Conductor::saveProfile(bool undo) { + ConductorProfile old_profile = conductor_profile; + conductor_profile.fromConductor(this); Diagram *dia = diagram(); if (undo && dia) { - dia -> undoStack().push(new ChangeConducerCommand(this, old_profile, conducer_profile)); + dia -> undoStack().push(new ChangeConductorCommand(this, old_profile, conductor_profile)); } } @@ -971,7 +971,7 @@ void Conducer::saveProfile(bool undo) { @param value2 Deuxieme valeur @return 1 si les deux valeurs sont de meme signe, -1 sinon */ -int Conducer::getCoeff(const qreal &value1, const qreal &value2) { +int Conductor::getCoeff(const qreal &value1, const qreal &value2) { return(getSign(value1) * getSign(value2)); } @@ -979,7 +979,7 @@ int Conducer::getCoeff(const qreal &value1, const qreal &value2) { @param value valeur @return 1 si valeur est negatif, 1 s'il est positif ou nul */ -int Conducer::getSign(const qreal &value) { +int Conductor::getSign(const qreal &value) { return(value < 0 ? -1 : 1); } @@ -987,19 +987,19 @@ int Conducer::getSign(const qreal &value) { Applique un nouveau profil a ce conducteur @param cp Profil a appliquer a ce conducteur */ -void Conducer::setProfile(const ConducerProfile &cp) { - conducer_profile = cp; - if (conducer_profile.isNull()) { - priv_calculeConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation()); +void Conductor::setProfile(const ConductorProfile &cp) { + conductor_profile = cp; + if (conductor_profile.isNull()) { + priv_calculeConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation()); modified_path = false; } else { - priv_modifieConducer(terminal1 -> amarrageConducer(), terminal1 -> orientation(), terminal2 -> amarrageConducer(), terminal2 -> orientation()); + priv_modifieConductor(terminal1 -> amarrageConductor(), terminal1 -> orientation(), terminal2 -> amarrageConductor(), terminal2 -> orientation()); modified_path = true; } calculateTextItemPosition(); } -bool Conducer::isSingleLine() const { +bool Conductor::isSingleLine() const { return(is_single_line); } @@ -1009,20 +1009,20 @@ bool Conducer::isSingleLine() const { et vice-versa. @param sl true pour un conducteur unifilaire, false pour un conducteur multifilaire */ -void Conducer::setSingleLine(bool sl) { +void Conductor::setSingleLine(bool sl) { is_single_line = sl; text_item -> setVisible(!is_single_line); } /// @return le texte du conducteur -QString Conducer::text() const { +QString Conductor::text() const { return(text_item -> toPlainText()); } /** @param t Nouveau texte du conducteur */ -void Conducer::setText(const QString &t) { +void Conductor::setText(const QString &t) { text_item -> setPlainText(t); text_item -> previous_text = t; } @@ -1061,7 +1061,7 @@ unsigned short int SingleLineProperties::phasesCount() { @param direction direction du segment sur lequel les symboles apparaitront @param rect rectangle englobant le dessin ; utilise pour specifier a la fois la position et la taille du dessin */ -void SingleLineProperties::draw(QPainter *painter, QET::ConducerSegmentType direction, const QRectF &rect) { +void SingleLineProperties::draw(QPainter *painter, QET::ConductorSegmentType direction, const QRectF &rect) { // s'il n'y a rien a dessiner, on retourne immediatement if (!hasNeutral && !hasGround && !phases) return; @@ -1119,7 +1119,7 @@ void SingleLineProperties::draw(QPainter *painter, QET::ConducerSegmentType dire @param center centre du segment @param size taille du segment */ -void SingleLineProperties::drawGround(QPainter *painter, QET::ConducerSegmentType direction, QPointF center, qreal size) { +void SingleLineProperties::drawGround(QPainter *painter, QET::ConductorSegmentType direction, QPointF center, qreal size) { painter -> save(); // prepare le QPainter @@ -1151,7 +1151,7 @@ void SingleLineProperties::drawGround(QPainter *painter, QET::ConducerSegmentTyp @param center centre du cercle @param size diametre du cercle */ -void SingleLineProperties::drawNeutral(QPainter *painter, QET::ConducerSegmentType, QPointF center, qreal size) { +void SingleLineProperties::drawNeutral(QPainter *painter, QET::ConductorSegmentType, QPointF center, qreal size) { painter -> save(); // prepare le QPainter diff --git a/conducer.h b/conductor.h similarity index 70% rename from conducer.h rename to conductor.h index 75e3b8ec0..778282673 100644 --- a/conducer.h +++ b/conductor.h @@ -1,10 +1,10 @@ -#ifndef CONDUCTEUR_H -#define CONDUCTEUR_H +#ifndef CONDUCTOR_H +#define CONDUCTOR_H #include #include "terminal.h" -#include "conducerprofile.h" +#include "conductorprofile.h" #include "diagramtextitem.h" -class ConducerSegment; +class ConductorSegment; class Element; /** Cette classe represente les proprietes specifiques a un conducteur unifilaire @@ -15,29 +15,29 @@ class SingleLineProperties { virtual ~SingleLineProperties(); void setPhasesCount(int); unsigned short int phasesCount(); - void draw(QPainter *, QET::ConducerSegmentType, const QRectF &); + void draw(QPainter *, QET::ConductorSegmentType, const QRectF &); void toXml(QDomDocument &, QDomElement &) const; void fromXml(QDomElement &); bool hasGround; bool hasNeutral; private: unsigned short int phases; - void drawGround (QPainter *, QET::ConducerSegmentType, QPointF, qreal); - void drawNeutral(QPainter *, QET::ConducerSegmentType, QPointF, qreal); + void drawGround (QPainter *, QET::ConductorSegmentType, QPointF, qreal); + void drawNeutral(QPainter *, QET::ConductorSegmentType, QPointF, qreal); }; /** Cette classe represente un conducteur. Un conducteur relie deux bornes d'element. */ -class Conducer : public QGraphicsPathItem { +class Conductor : public QGraphicsPathItem { // constructeurs, destructeur public: - Conducer(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0); - virtual ~Conducer(); + Conductor(Terminal *, Terminal *, Element * = 0, QGraphicsScene * = 0); + virtual ~Conductor(); private: - Conducer(const Conducer &); + Conductor(const Conductor &); // attributs public: @@ -62,14 +62,14 @@ class Conducer : public QGraphicsPathItem { QRectF boundingRect() const; virtual QPainterPath shape() const; qreal length(); - ConducerSegment *middleSegment(); + ConductorSegment *middleSegment(); QString text() const; void setText(const QString &); static bool valideXml(QDomElement &); bool fromXml(QDomElement &); QDomElement toXml(QDomDocument &, QHash &) const; - const QList segmentsList() const; - void setProfile(const ConducerProfile &); + const QList segmentsList() const; + void setProfile(const ConductorProfile &); void setSingleLine(bool); bool isSingleLine() const; @@ -87,40 +87,40 @@ class Conducer : public QGraphicsPathItem { /// champ de texte editable pour les conducteurs non unifilaires DiagramTextItem *text_item; /// Segments composant le conducteur - ConducerSegment *segments; + ConductorSegment *segments; /// Attributs lies aux manipulations a la souris QPointF press_point; bool moving_point; bool moving_segment; int moved_point; qreal previous_z_value; - ConducerSegment *moved_segment; + ConductorSegment *moved_segment; /// booleen indiquant si le conducteur a ete modifie manuellement par l'utilisateur bool modified_path; /// booleen indiquant s'il faut sauver le profil courant au plus tot bool has_to_save_profile; /// profil du conducteur : "photo" de ce a quoi le conducteur doit ressembler - ConducerProfile conducer_profile; + ConductorProfile conductor_profile; /// QPen et QBrush utilises pour dessiner les conducteurs - static QPen conducer_pen; - static QBrush conducer_brush; + static QPen conductor_pen; + static QBrush conductor_brush; static bool pen_and_brush_initialized; private: void segmentsToPath(); void saveProfile(bool = true); - void priv_calculeConducer(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); - void priv_modifieConducer(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); - uint nbSegments(QET::ConducerSegmentType = QET::Both) const; + void priv_calculeConductor(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); + void priv_modifieConductor(const QPointF &, QET::Orientation, const QPointF &, QET::Orientation); + uint nbSegments(QET::ConductorSegmentType = QET::Both) const; QList segmentsToPoints() const; void pointsToSegments(QList); bool hasClickedOn(QPointF, QPointF) const; void calculateTextItemPosition(); static int getCoeff(const qreal &, const qreal &); static int getSign(const qreal &); - QHash shareOffsetBetweenSegments(const qreal &offset, const QList &, const qreal & = 0.01) const; + QHash shareOffsetBetweenSegments(const qreal &offset, const QList &, const qreal & = 0.01) const; static QPointF extendTerminal(const QPointF &, QET::Orientation, qreal = 12.0); - static qreal conducer_bound(qreal, qreal, qreal, qreal = 0.0); - static qreal conducer_bound(qreal, qreal, bool); + static qreal conductor_bound(qreal, qreal, qreal, qreal = 0.0); + static qreal conductor_bound(qreal, qreal, bool); }; #endif diff --git a/conductorprofile.cpp b/conductorprofile.cpp new file mode 100644 index 000000000..718eee7ed --- /dev/null +++ b/conductorprofile.cpp @@ -0,0 +1,137 @@ +#include "conductorprofile.h" +#include "conductor.h" +#include "conductorsegmentprofile.h" + +/// Constructeur +ConductorProfile::ConductorProfile() { +} + +/** + Constructeur + @param Conductor conducteur dont il faut extraire le profil +*/ +ConductorProfile::ConductorProfile(Conductor *conductor) { + fromConductor(conductor); +} + +/** + Constructeur de copie + @param c autre conducteur +*/ +ConductorProfile::ConductorProfile(const ConductorProfile &c) { + beginOrientation = c.beginOrientation; + endOrientation = c.endOrientation; + foreach(ConductorSegmentProfile *csp, c.segments) { + segments << new ConductorSegmentProfile(*csp); + } +} + +/** + Operateur = + @param c autre conducteur +*/ +ConductorProfile &ConductorProfile::operator=(const ConductorProfile &c) { + if (&c == this) return(*this); + + // supprime ses informations + setNull(); + + // copie les informations de l'autre profil de conducteur + beginOrientation = c.beginOrientation; + endOrientation = c.endOrientation; + foreach(ConductorSegmentProfile *csp, c.segments) { + segments << new ConductorSegmentProfile(*csp); + } + return(*this); +} + +/// destructeur +ConductorProfile::~ConductorProfile() { + setNull(); +} + +/// @return true si le profil est nul +bool ConductorProfile::isNull() const { + return(segments.isEmpty()); +} + +/// supprime les segments du profil de conducteur +void ConductorProfile::setNull() { + foreach(ConductorSegmentProfile *csp, segments) delete csp; + segments.clear(); +} + +/// @return la largeur occupee par le conducteur +qreal ConductorProfile::width() const { + qreal width = 0.0; + foreach(ConductorSegmentProfile *csp, segments) { + if (csp -> isHorizontal) width += csp -> length; + } + return(width); +} + +/// @return la hauteur occupee par le conducteur +qreal ConductorProfile::height() const{ + qreal height = 0.0; + foreach(ConductorSegmentProfile *csp, segments) { + if (!csp -> isHorizontal) height += csp -> length; + } + return(height); +} + +/** + @param type Type de Segments + @return Le nombre de segments composant le conducteur. +*/ +uint ConductorProfile::nbSegments(QET::ConductorSegmentType type) const { + if (type == QET::Both) return(segments.count()); + uint nb_seg = 0; + foreach(ConductorSegmentProfile *csp, segments) { + if (type == QET::Horizontal && csp -> isHorizontal) ++ nb_seg; + else if (type == QET::Vertical && !csp -> isHorizontal) ++ nb_seg; + } + return(nb_seg); +} + +/// @return les segments horizontaux de ce profil +QList ConductorProfile::horizontalSegments() { + QList segments_list; + foreach(ConductorSegmentProfile *csp, segments) { + if (csp -> isHorizontal) segments_list << csp; + } + return(segments_list); +} + +/// @return les segments verticaux de ce profil +QList ConductorProfile::verticalSegments() { + QList segments_list; + foreach(ConductorSegmentProfile *csp, segments) { + if (!csp -> isHorizontal) segments_list << csp; + } + return(segments_list); +} + +void ConductorProfile::fromConductor(Conductor *conductor) { + // supprime les segments precedents + setNull(); + + foreach(ConductorSegment *conductor_segment, conductor -> segmentsList()) { + segments << new ConductorSegmentProfile(conductor_segment); + } + beginOrientation = conductor -> terminal1 -> orientation(); + endOrientation = conductor -> terminal2 -> orientation(); +} + +/** + Permet de debugger un profil de conducteur + @param d Object QDebug a utiliser pour l'affichage des informations de debug + @param t Profil de conducteur a debugger +*/ +QDebug &operator<<(QDebug d, ConductorProfile &t) { + d << "ConductorProfile {"; + foreach(ConductorSegmentProfile *csp, t.segments) { + d << "CSP" << (csp -> isHorizontal ? "horizontal" : "vertical") << ":" << csp -> length << ","; + } + d << "}"; + return(d.space()); +} diff --git a/conductorprofile.h b/conductorprofile.h new file mode 100644 index 000000000..ea5878706 --- /dev/null +++ b/conductorprofile.h @@ -0,0 +1,38 @@ +#ifndef CONDUCTOR_PROFILE_H +#define CONDUCTOR_PROFILE_H +#include +#include "qet.h" +class Conductor; +class ConductorSegmentProfile; +/** + Cette classe contient le profil (= les caracteristiques essentielles) d'un + conducteur. +*/ +class ConductorProfile { + public: + // constructeurs, destructeur + ConductorProfile(); + ConductorProfile(Conductor *conductor); + ConductorProfile(const ConductorProfile &); + ConductorProfile &operator=(const ConductorProfile &); + virtual ~ConductorProfile(); + + // attributs + public: + QList segments; + QET::Orientation beginOrientation; + QET::Orientation endOrientation; + + // methodes + public: + bool isNull() const; + void setNull(); + qreal width() const; + qreal height() const; + uint nbSegments(QET::ConductorSegmentType) const; + QList horizontalSegments(); + QList verticalSegments(); + void fromConductor(Conductor *); +}; +QDebug &operator<<(QDebug d, ConductorProfile &); +#endif diff --git a/conducerproperties.cpp b/conductorproperties.cpp similarity index 84% rename from conducerproperties.cpp rename to conductorproperties.cpp index 0aadadd4a..be8fa5e65 100644 --- a/conducerproperties.cpp +++ b/conductorproperties.cpp @@ -1,13 +1,13 @@ -#include "conducerproperties.h" -#include "conducer.h" +#include "conductorproperties.h" +#include "conductor.h" -ConducerPropertiesWidget::ConducerPropertiesWidget(QWidget *parent) : +ConductorPropertiesWidget::ConductorPropertiesWidget(QWidget *parent) : QWidget(parent) { buildInterface(); } -void ConducerPropertiesWidget::buildInterface() { +void ConductorPropertiesWidget::buildInterface() { setFixedSize(380, 245); @@ -64,7 +64,7 @@ void ConducerPropertiesWidget::buildInterface() { setSingleLine(false); } -void ConducerPropertiesWidget::buildConnections() { +void ConductorPropertiesWidget::buildConnections() { connect(phase_slider, SIGNAL(valueChanged(int)), phase_spinbox, SLOT(setValue(int))); connect(phase_spinbox, SIGNAL(valueChanged(int)), phase_slider, SLOT(setValue(int))); connect(ground_checkbox, SIGNAL(toggled(bool)), this, SLOT(updateSingleLineConfig())); @@ -75,7 +75,7 @@ void ConducerPropertiesWidget::buildConnections() { } -void ConducerPropertiesWidget::destroyConnections() { +void ConductorPropertiesWidget::destroyConnections() { disconnect(phase_slider, SIGNAL(valueChanged(int)), phase_spinbox, SLOT(setValue(int))); disconnect(phase_spinbox, SIGNAL(valueChanged(int)), phase_slider, SLOT(setValue(int))); disconnect(ground_checkbox, SIGNAL(toggled(bool)), this, SLOT(updateSingleLineConfig())); @@ -85,18 +85,18 @@ void ConducerPropertiesWidget::destroyConnections() { disconnect(singleline, SIGNAL(toggled(bool)), this, SLOT(setSingleLine(bool))); } -ConducerPropertiesWidget::~ConducerPropertiesWidget() { +ConductorPropertiesWidget::~ConductorPropertiesWidget() { } -void ConducerPropertiesWidget::updateSingleLineConfig() { +void ConductorPropertiesWidget::updateSingleLineConfig() { slp.hasGround = ground_checkbox -> isChecked(); slp.hasNeutral = neutral_checkbox -> isChecked(); slp.setPhasesCount(phase_checkbox -> isChecked() ? phase_spinbox -> value() : 0); updatePreview(); } -void ConducerPropertiesWidget::updateSingleLineDisplay() { +void ConductorPropertiesWidget::updateSingleLineDisplay() { destroyConnections(); ground_checkbox -> setChecked(slp.hasGround); neutral_checkbox -> setChecked(slp.hasNeutral); @@ -106,7 +106,7 @@ void ConducerPropertiesWidget::updateSingleLineDisplay() { updatePreview(); } -void ConducerPropertiesWidget::updatePreview() { +void ConductorPropertiesWidget::updatePreview() { const QRect pixmap_rect(0, 0, 96, 96); QPixmap pixmap(pixmap_rect.width(), pixmap_rect.height()); QPainter painter; @@ -119,11 +119,11 @@ void ConducerPropertiesWidget::updatePreview() { preview -> setPixmap(pixmap); } -bool ConducerPropertiesWidget::isSingleLine() const { +bool ConductorPropertiesWidget::isSingleLine() const { return(singleline -> isChecked()); } -void ConducerPropertiesWidget::setSingleLine(bool sl) { +void ConductorPropertiesWidget::setSingleLine(bool sl) { singleline -> setChecked(sl); multiline -> setChecked(!sl); text_field -> setEnabled(!sl); @@ -137,22 +137,22 @@ void ConducerPropertiesWidget::setSingleLine(bool sl) { } /// @param prop Les nouvelles proprietes unifilaires de ce conducteur -void ConducerPropertiesWidget::setSingleLineProperties(const SingleLineProperties &prop) { +void ConductorPropertiesWidget::setSingleLineProperties(const SingleLineProperties &prop) { slp = prop; updateSingleLineDisplay(); } /// @return les proprietes unifilaires de ce conducteur -SingleLineProperties ConducerPropertiesWidget::singleLineProperties() const { +SingleLineProperties ConductorPropertiesWidget::singleLineProperties() const { return(slp); } /// @param text Le texte de ce conducteur -void ConducerPropertiesWidget::setConducerText(const QString &text) { +void ConductorPropertiesWidget::setConductorText(const QString &text) { text_field -> setText(text); } /// @return Le texte de ce conducteur -QString ConducerPropertiesWidget::conducerText() const { +QString ConductorPropertiesWidget::conductorText() const { return(text_field -> text()); } diff --git a/conducerproperties.h b/conductorproperties.h similarity index 66% rename from conducerproperties.h rename to conductorproperties.h index 6fbb5de18..710479e4c 100644 --- a/conducerproperties.h +++ b/conductorproperties.h @@ -1,24 +1,24 @@ -#ifndef CONDUCER_PROPERTIES_WIDGET_H -#define CONDUCER_PROPERTIES_WIDGET_H -#include "conducer.h" +#ifndef CONDUCTOR_PROPERTIES_WIDGET_H +#define CONDUCTOR_PROPERTIES_WIDGET_H +#include "conductor.h" #include -class ConducerPropertiesWidget : public QWidget { +class ConductorPropertiesWidget : public QWidget { Q_OBJECT // constructeurs, destructeur public: - ConducerPropertiesWidget(QWidget * = 0); - virtual ~ConducerPropertiesWidget(); + ConductorPropertiesWidget(QWidget * = 0); + virtual ~ConductorPropertiesWidget(); private: - ConducerPropertiesWidget(const ConducerPropertiesWidget &); + ConductorPropertiesWidget(const ConductorPropertiesWidget &); // methodes public: bool isSingleLine() const; void setSingleLineProperties(const SingleLineProperties &); SingleLineProperties singleLineProperties() const; - QString conducerText() const; - void setConducerText(const QString &); + QString conductorText() const; + void setConductorText(const QString &); public slots: void updatePreview(); @@ -39,7 +39,7 @@ class ConducerPropertiesWidget : public QWidget { QLabel *preview; SingleLineProperties slp; - QString conducer_text; + QString conductor_text; // methodes privees void buildInterface(); diff --git a/conducersegment.cpp b/conductorsegment.cpp similarity index 84% rename from conducersegment.cpp rename to conductorsegment.cpp index a4a561085..764cda1db 100644 --- a/conducersegment.cpp +++ b/conductorsegment.cpp @@ -1,4 +1,4 @@ -#include "conducersegment.h" +#include "conductorsegment.h" #include /** @@ -8,11 +8,11 @@ @param cs1 Le segment precedent @param cs2 Le segment suivant */ -ConducerSegment::ConducerSegment( +ConductorSegment::ConductorSegment( const QPointF &p1, const QPointF &p2, - ConducerSegment *cs1, - ConducerSegment *cs2 + ConductorSegment *cs1, + ConductorSegment *cs2 ) : point1(p1), point2(p2) @@ -24,7 +24,7 @@ ConducerSegment::ConducerSegment( /** Destructeur - Relie le segment precedent au suivant */ -ConducerSegment::~ConducerSegment() { +ConductorSegment::~ConductorSegment() { if (hasPreviousSegment()) previousSegment() -> setNextSegment(nextSegment()); if (hasNextSegment()) nextSegment() -> setPreviousSegment(previousSegment()); } @@ -38,9 +38,9 @@ ConducerSegment::~ConducerSegment() { @param possible_dx La valeur du mouvement possible (au maximum) @return true si le mouvement est possible ; false s'il doit etre limite */ -bool ConducerSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx) const { +bool ConductorSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx) const { - Q_ASSERT_X(isVertical(), "ConducerSegment::canMove1stPointX", "segment non vertical"); + Q_ASSERT_X(isVertical(), "ConductorSegment::canMove1stPointX", "segment non vertical"); /// On ne bouge jamais le premier point d'un segment statique. if (isStatic()) { @@ -97,9 +97,9 @@ bool ConducerSegment::canMove1stPointX(const qreal &asked_dx, qreal &possible_dx @param possible_dx La valeur du mouvement possible (au maximum) @return true si le mouvement est possible ; false s'il doit etre limite */ -bool ConducerSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx) const { +bool ConductorSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx) const { - Q_ASSERT_X(isVertical(), "ConducerSegment::canMove2ndPointX", "segment non vertical"); + Q_ASSERT_X(isVertical(), "ConductorSegment::canMove2ndPointX", "segment non vertical"); /// On ne modifie jamais l'abscisse du second point d'un segment statique. if (isStatic()) { @@ -156,9 +156,9 @@ bool ConducerSegment::canMove2ndPointX(const qreal &asked_dx, qreal &possible_dx @param possible_dy La valeur du mouvement possible (au maximum) @return true si le mouvement est possible ; false s'il doit etre limite */ -bool ConducerSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy) const { +bool ConductorSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy) const { - Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove1stPointY", "segment non horizontal"); + Q_ASSERT_X(isHorizontal(), "ConductorSegment::canMove1stPointY", "segment non horizontal"); /// On ne bouge jamais le premier point d'un segment statique. if (isStatic()) { @@ -215,9 +215,9 @@ bool ConducerSegment::canMove1stPointY(const qreal &asked_dy, qreal &possible_dy @param possible_dy La valeur du mouvement possible (au maximum) @return true si le mouvement est possible ; false s'il doit etre limite */ -bool ConducerSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy) const { +bool ConductorSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy) const { - Q_ASSERT_X(isHorizontal(), "ConducerSegment::canMove2ndPointY", "segment non horizontal"); + Q_ASSERT_X(isHorizontal(), "ConductorSegment::canMove2ndPointY", "segment non horizontal"); /// On ne modifie jamais l'abscisse du second point d'un segment statique. if (isStatic()) { @@ -270,9 +270,9 @@ bool ConducerSegment::canMove2ndPointY(const qreal &asked_dy, qreal &possible_dy Gere les mouvements sur l'axe horizontal @param dx taille du deplacement en pixels */ -void ConducerSegment::moveX(const qreal &dx) { +void ConductorSegment::moveX(const qreal &dx) { if (isHorizontal()) return; - Q_ASSERT_X(isVertical(), "ConducerSegment::moveX", "segment non vertical"); + Q_ASSERT_X(isVertical(), "ConductorSegment::moveX", "segment non vertical"); bool has_prev_segment = hasPreviousSegment(); bool has_next_segment = hasNextSegment(); @@ -291,7 +291,7 @@ void ConducerSegment::moveX(const qreal &dx) { if (has_prev_segment) { point1.rx() += final_movement; if (previous_segment -> isFirstSegment()) { - new ConducerSegment( + new ConductorSegment( previous_segment -> point2, point1, previous_segment, @@ -304,7 +304,7 @@ void ConducerSegment::moveX(const qreal &dx) { if (has_next_segment) { point2.rx() += final_movement; if (next_segment -> isLastSegment()) { - new ConducerSegment( + new ConductorSegment( point2, next_segment -> point1, this, @@ -318,9 +318,9 @@ void ConducerSegment::moveX(const qreal &dx) { Gere les mouvements sur l'axe vertical @param dx taille du deplacement en pixels */ -void ConducerSegment::moveY(const qreal &dy) { +void ConductorSegment::moveY(const qreal &dy) { if (isVertical()) return; - Q_ASSERT_X(isHorizontal(), "ConducerSegment::moveY", "segment non horizontal"); + Q_ASSERT_X(isHorizontal(), "ConductorSegment::moveY", "segment non horizontal"); bool has_prev_segment = hasPreviousSegment(); bool has_next_segment = hasNextSegment(); @@ -339,7 +339,7 @@ void ConducerSegment::moveY(const qreal &dy) { if (has_prev_segment) { point1.ry() += final_movement; if (previous_segment -> isFirstSegment()) { - new ConducerSegment( + new ConductorSegment( previous_segment -> point2, point1, previous_segment, @@ -352,7 +352,7 @@ void ConducerSegment::moveY(const qreal &dy) { if (has_next_segment) { point2.ry() += final_movement; if (next_segment -> isLastSegment()) { - new ConducerSegment( + new ConductorSegment( point2, next_segment -> point1, this, @@ -366,7 +366,7 @@ void ConducerSegment::moveY(const qreal &dy) { Change le segment precedent @param ps Le nouveau segment precedent */ -void ConducerSegment::setPreviousSegment(ConducerSegment *ps) { +void ConductorSegment::setPreviousSegment(ConductorSegment *ps) { previous_segment = ps; if (hasPreviousSegment()) { if (previousSegment() -> nextSegment() != this) previousSegment() -> setNextSegment(this); @@ -377,7 +377,7 @@ void ConducerSegment::setPreviousSegment(ConducerSegment *ps) { Change le segment suivant @param ps Le nouveau segment suivant */ -void ConducerSegment::setNextSegment(ConducerSegment *ns) { +void ConductorSegment::setNextSegment(ConductorSegment *ns) { next_segment = ns; if (hasNextSegment()) { if (nextSegment() -> previousSegment() != this) nextSegment() -> setPreviousSegment(this); @@ -385,59 +385,59 @@ void ConducerSegment::setNextSegment(ConducerSegment *ns) { } /// @return true si ce segment est un segment statique, cad un segment relie a une borne -bool ConducerSegment::isStatic() const { +bool ConductorSegment::isStatic() const { return(isFirstSegment() || isLastSegment()); } /// @return true si ce segment est le premier du conducteur -bool ConducerSegment::isFirstSegment() const { +bool ConductorSegment::isFirstSegment() const { return(!hasPreviousSegment()); } /// @return true si ce segment est le dernier du conducteur -bool ConducerSegment::isLastSegment() const { +bool ConductorSegment::isLastSegment() const { return(!hasNextSegment()); } /** @return Le segment precedent */ -ConducerSegment *ConducerSegment::previousSegment() const { +ConductorSegment *ConductorSegment::previousSegment() const { return(previous_segment); } /** @return Le segment suivant */ -ConducerSegment *ConducerSegment::nextSegment() const { +ConductorSegment *ConductorSegment::nextSegment() const { return(next_segment); } /** @return true si le segment est vertical, false sinon */ -bool ConducerSegment::isVertical() const { +bool ConductorSegment::isVertical() const { return(point1.x() == point2.x()); } /** @return true si le segment est horizontal, false sinon */ -bool ConducerSegment::isHorizontal() const { +bool ConductorSegment::isHorizontal() const { return(point1.y() == point2.y()); } /** @return le premier point du segment */ -QPointF ConducerSegment::firstPoint() const { +QPointF ConductorSegment::firstPoint() const { return(point1); } /** @return le second point du segment */ -QPointF ConducerSegment::secondPoint() const { +QPointF ConductorSegment::secondPoint() const { return(point2); } @@ -445,7 +445,7 @@ QPointF ConducerSegment::secondPoint() const { Permet de changer la position du premier point du segment @param p La nouvelle position du premier point */ -void ConducerSegment::setFirstPoint(const QPointF &p) { +void ConductorSegment::setFirstPoint(const QPointF &p) { point1 = p; } @@ -453,28 +453,28 @@ void ConducerSegment::setFirstPoint(const QPointF &p) { Permet de changer la position du second point du segment @param p La nouvelle position du second point */ -void ConducerSegment::setSecondPoint(const QPointF &p) { +void ConductorSegment::setSecondPoint(const QPointF &p) { point2 = p; } /** @return true si le segment a un segment precedent, false sinon */ -bool ConducerSegment::hasPreviousSegment() const { +bool ConductorSegment::hasPreviousSegment() const { return(previous_segment != NULL); } /** @return true si le segment a un segment suivant, false sinon */ -bool ConducerSegment::hasNextSegment() const { +bool ConductorSegment::hasNextSegment() const { return(next_segment != NULL); } /** @return Le centre du rectangle delimitant le conducteur */ -QPointF ConducerSegment::middle() const { +QPointF ConductorSegment::middle() const { return( QPointF( (point1.x() + point2.x()) / 2.0, @@ -486,7 +486,7 @@ QPointF ConducerSegment::middle() const { /** @return La longueur du conducteur */ -qreal ConducerSegment::length() const { +qreal ConductorSegment::length() const { if (isHorizontal()) { return(secondPoint().x() - firstPoint().x()); } else { @@ -494,6 +494,6 @@ qreal ConducerSegment::length() const { } } -QET::ConducerSegmentType ConducerSegment::type() const { +QET::ConductorSegmentType ConductorSegment::type() const { return(isHorizontal() ? QET::Horizontal : QET::Vertical); } diff --git a/conducersegment.h b/conductorsegment.h similarity index 62% rename from conducersegment.h rename to conductorsegment.h index 6008966d8..91f529c03 100644 --- a/conducersegment.h +++ b/conductorsegment.h @@ -1,24 +1,24 @@ -#ifndef CONDUCER_SEGMENT_H -#define CONDUCER_SEGMENT_H +#ifndef CONDUCTOR_SEGMENT_H +#define CONDUCTOR_SEGMENT_H #include #include "qet.h" /** Cette classe represente un segment de conducteur. */ -class ConducerSegment { +class ConductorSegment { // constructeurs, destructeur public: - ConducerSegment(const QPointF &, const QPointF &, ConducerSegment * = NULL, ConducerSegment * = NULL); - virtual ~ConducerSegment(); + ConductorSegment(const QPointF &, const QPointF &, ConductorSegment * = NULL, ConductorSegment * = NULL); + virtual ~ConductorSegment(); private: - ConducerSegment(const ConducerSegment &); + ConductorSegment(const ConductorSegment &); // attributs private: - ConducerSegment *previous_segment; - ConducerSegment *next_segment; + ConductorSegment *previous_segment; + ConductorSegment *next_segment; QPointF point1; QPointF point2; @@ -26,12 +26,12 @@ class ConducerSegment { public: void moveX(const qreal &); void moveY(const qreal &); - ConducerSegment *previousSegment() const; - ConducerSegment *nextSegment() const; + ConductorSegment *previousSegment() const; + ConductorSegment *nextSegment() const; bool hasPreviousSegment() const; bool hasNextSegment() const; - void setPreviousSegment(ConducerSegment *); - void setNextSegment(ConducerSegment *); + void setPreviousSegment(ConductorSegment *); + void setNextSegment(ConductorSegment *); bool isStatic() const; bool isFirstSegment() const; bool isLastSegment() const; @@ -42,7 +42,7 @@ class ConducerSegment { QPointF middle() const; bool isHorizontal() const; bool isVertical() const; - QET::ConducerSegmentType type() const; + QET::ConductorSegmentType type() const; qreal length() const; bool canMove1stPointX(const qreal &, qreal &) const; bool canMove2ndPointX(const qreal &, qreal &) const; diff --git a/conducersegmentprofile.h b/conductorsegmentprofile.h similarity index 62% rename from conducersegmentprofile.h rename to conductorsegmentprofile.h index 98dfd9da7..066dc9658 100644 --- a/conducersegmentprofile.h +++ b/conductorsegmentprofile.h @@ -1,12 +1,12 @@ -#ifndef CONDUCER_SEGMENT_PROFILE_H -#define CONDUCER_SEGMENT_PROFILE_H +#ifndef CONDUCTOR_SEGMENT_PROFILE_H +#define CONDUCTOR_SEGMENT_PROFILE_H #include -#include "conducersegment.h" +#include "conductorsegment.h" /** Cette classe contient le profil (= les caracteristiques essentielles) d'un segment de conducteur. */ -class ConducerSegmentProfile { +class ConductorSegmentProfile { // constructeurs, destructeur public: /** @@ -14,7 +14,7 @@ class ConducerSegmentProfile { @param l longueur du segment @param ori true si le segment est horizontal, false s'il est vertical */ - ConducerSegmentProfile(qreal l, bool ori = true) : + ConductorSegmentProfile(qreal l, bool ori = true) : length(l), isHorizontal(ori) { @@ -22,16 +22,16 @@ class ConducerSegmentProfile { /** Constructeur - @param segment ConducerSegment dont il faut extraire le profil + @param segment ConductorSegment dont il faut extraire le profil */ - ConducerSegmentProfile(ConducerSegment *segment) : + ConductorSegmentProfile(ConductorSegment *segment) : length(segment -> length()), isHorizontal(segment -> isHorizontal()) { } /// Destructeur - virtual ~ConducerSegmentProfile() { + virtual ~ConductorSegmentProfile() { } // attributs diff --git a/customelement.cpp b/customelement.cpp index baacd34a8..a80a9ea68 100644 --- a/customelement.cpp +++ b/customelement.cpp @@ -145,10 +145,10 @@ QList CustomElement::terminals() const { return(list_terminals); } -QList CustomElement::conducers() const { - QList conducers; - foreach(Terminal *t, list_terminals) conducers << t -> conducers(); - return(conducers); +QList CustomElement::conductors() const { + QList conductors; + foreach(Terminal *t, list_terminals) conductors << t -> conductors(); + return(conductors); } /** diff --git a/customelement.h b/customelement.h index 40f9f1fe1..c570285ff 100644 --- a/customelement.h +++ b/customelement.h @@ -34,7 +34,7 @@ class CustomElement : public FixedElement { // methodes public: virtual QList terminals() const; - virtual QList conducers() const; + virtual QList conductors() const; virtual int nbTerminals() const; virtual void paint(QPainter *, const QStyleOptionGraphicsItem *); QString typeId() const; diff --git a/diagram.cpp b/diagram.cpp index 6b8483c4c..8eccc562e 100644 --- a/diagram.cpp +++ b/diagram.cpp @@ -1,6 +1,6 @@ #include #include "qetapp.h" -#include "conducer.h" +#include "conductor.h" #include "customelement.h" #include "diagram.h" #include "exportdialog.h" @@ -12,14 +12,14 @@ */ Diagram::Diagram(QObject *parent) : QGraphicsScene(parent), qgi_manager(this) { setBackgroundBrush(Qt::white); - conducer_setter = new QGraphicsLineItem(0, 0); - conducer_setter -> setZValue(1000000); + conductor_setter = new QGraphicsLineItem(0, 0); + conductor_setter -> setZValue(1000000); QPen t; t.setColor(Qt::black); t.setWidthF(1.5); t.setStyle(Qt::DashLine); - conducer_setter -> setPen(t); - conducer_setter -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0))); + conductor_setter -> setPen(t); + conductor_setter -> setLine(QLineF(QPointF(0.0, 0.0), QPointF(0.0, 0.0))); draw_grid = true; use_border = true; moved_elements_fetched = false; @@ -112,8 +112,8 @@ void Diagram::keyReleaseEvent(QKeyEvent *e) { new MoveElementsCommand( this, elementsToMove(), - conducersToMove(), - conducersToUpdate(), + conductorsToMove(), + conductorsToUpdate(), current_movement ) ); @@ -227,18 +227,18 @@ QDomDocument Diagram::toXml(bool diagram) { // creation de deux listes : une qui contient les elements, une qui contient les conducteurs QList liste_elements; - QList liste_conducers; + QList liste_conductors; // Determine les elements a « XMLiser » foreach(QGraphicsItem *qgi, items()) { if (Element *elmt = qgraphicsitem_cast(qgi)) { if (diagram) liste_elements << elmt; else if (elmt -> isSelected()) liste_elements << elmt; - } else if (Conducer *f = qgraphicsitem_cast(qgi)) { - if (diagram) liste_conducers << f; + } else if (Conductor *f = qgraphicsitem_cast(qgi)) { + if (diagram) liste_conductors << f; // lorsqu'on n'exporte pas tout le diagram, il faut retirer les conducteurs non selectionnes // et pour l'instant, les conducteurs non selectionnes sont les conducteurs dont un des elements n'est pas relie - else if (f -> terminal1 -> parentItem() -> isSelected() && f -> terminal2 -> parentItem() -> isSelected()) liste_conducers << f; + else if (f -> terminal1 -> parentItem() -> isSelected() && f -> terminal2 -> parentItem() -> isSelected()) liste_conductors << f; } } @@ -254,12 +254,12 @@ QDomDocument Diagram::toXml(bool diagram) { racine.appendChild(elements); // enregistrement des conducteurs - if (liste_conducers.isEmpty()) return(document); - QDomElement conducers = document.createElement("conducers"); - foreach(Conducer *cond, liste_conducers) { - conducers.appendChild(cond -> toXml(document, table_adr_id)); + if (liste_conductors.isEmpty()) return(document); + QDomElement conductors = document.createElement("conductors"); + foreach(Conductor *cond, liste_conductors) { + conductors.appendChild(cond -> toXml(document, table_adr_id)); } - racine.appendChild(conducers); + racine.appendChild(conductors); // on retourne le document XML ainsi genere return(document); @@ -281,7 +281,7 @@ QDomDocument Diagram::toXml(bool diagram) { fromXml @return true si l'import a reussi, false sinon */ -bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList *added_elements, QList *added_conducers) { +bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList *added_elements, QList *added_conductors) { QDomElement racine = document.documentElement(); // le premier element doit etre un schema if (racine.tagName() != "diagram") return(false); @@ -381,13 +381,13 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in // chargement de tous les Conducteurs du fichier XML for (QDomNode node = racine.firstChild() ; !node.isNull() ; node = node.nextSibling()) { // on s'interesse a l'element XML "conducteurs" (= groupe de conducteurs) - QDomElement conducers = node.toElement(); - if(conducers.isNull() || conducers.tagName() != "conducers") continue; + QDomElement conductors = node.toElement(); + if(conductors.isNull() || conductors.tagName() != "conductors") continue; // parcours des enfants de l'element XML "conducteurs" - for (QDomNode n = conducers.firstChild() ; !n.isNull() ; n = n.nextSibling()) { + for (QDomNode n = conductors.firstChild() ; !n.isNull() ; n = n.nextSibling()) { // on s'interesse a l'element XML "element" (elements eux-memes) QDomElement f = n.toElement(); - if (f.isNull() || !Conducer::valideXml(f)) continue; + if (f.isNull() || !Conductor::valideXml(f)) continue; // verifie que les bornes que le conducteur relie sont connues int id_p1 = f.attribute("terminal1").toInt(); int id_p2 = f.attribute("terminal2").toInt(); @@ -396,16 +396,16 @@ bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_in Terminal *p1 = table_adr_id.value(id_p1); Terminal *p2 = table_adr_id.value(id_p2); if (p1 != p2) { - bool peut_poser_conducer = true; + bool peut_poser_conductor = true; bool cia = ((Element *)p2 -> parentItem()) -> connexionsInternesAcceptees(); - if (!cia) foreach(QGraphicsItem *item, p2 -> parentItem() -> children()) if (item == p1) peut_poser_conducer = false; - if (peut_poser_conducer) { - Conducer *c = new Conducer(table_adr_id.value(id_p1), table_adr_id.value(id_p2), 0, this); + if (!cia) foreach(QGraphicsItem *item, p2 -> parentItem() -> children()) if (item == p1) peut_poser_conductor = false; + if (peut_poser_conductor) { + Conductor *c = new Conductor(table_adr_id.value(id_p1), table_adr_id.value(id_p2), 0, this); c -> fromXml(f); - if (added_conducers) (*added_conducers) << c; + if (added_conductors) (*added_conductors) << c; } } - } else qDebug() << "Le chargement du conducer" << id_p1 << id_p2 << "a echoue"; + } else qDebug() << "Le chargement du conductor" << id_p1 << id_p2 << "a echoue"; } } return(true); @@ -444,8 +444,8 @@ void Diagram::invalidateMovedElements() { if (!moved_elements_fetched) return; moved_elements_fetched = false; elements_to_move.clear(); - conducers_to_move.clear(); - conducers_to_update.clear(); + conductors_to_move.clear(); + conductors_to_update.clear(); } /// reconstruit la liste des elements et conducteurs en mouvement @@ -460,18 +460,18 @@ void Diagram::fetchMovedElements() { // pour chaque element deplace, determine les conducteurs qui seront modifies foreach(Element *elmt, elements_to_move) { foreach(Terminal *terminal, elmt -> terminals()) { - foreach(Conducer *conducer, terminal -> conducers()) { + foreach(Conductor *conductor, terminal -> conductors()) { Terminal *other_terminal; - if (conducer -> terminal1 == terminal) { - other_terminal = conducer -> terminal2; + if (conductor -> terminal1 == terminal) { + other_terminal = conductor -> terminal2; } else { - other_terminal = conducer -> terminal1; + other_terminal = conductor -> terminal1; } // si les deux elements du conducteur sont deplaces if (elements_to_move.contains(static_cast(other_terminal -> parentItem()))) { - conducers_to_move << conducer; + conductors_to_move << conductor; } else { - conducers_to_update.insert(conducer, terminal); + conductors_to_update.insert(conductor, terminal); } } } @@ -487,12 +487,12 @@ void Diagram::setDrawTerminals(bool dt) { } } -QSet Diagram::selectedConducers() const { - QSet conducers_set; +QSet Diagram::selectedConductors() const { + QSet conductors_set; foreach(QGraphicsItem *qgi, selectedItems()) { - if (Conducer *c = qgraphicsitem_cast(qgi)) { - conducers_set << c; + if (Conductor *c = qgraphicsitem_cast(qgi)) { + conductors_set << c; } } - return(conducers_set); + return(conductors_set); } diff --git a/diagram.h b/diagram.h index 700aa089b..8cbd1d049 100644 --- a/diagram.h +++ b/diagram.h @@ -10,7 +10,7 @@ #include "qgimanager.h" class Element; class Terminal; -class Conducer; +class Conductor; class Diagram : public QGraphicsScene { Q_OBJECT @@ -29,13 +29,13 @@ class Diagram : public QGraphicsScene { QPointF current_movement; private: - QGraphicsLineItem *conducer_setter; + QGraphicsLineItem *conductor_setter; bool draw_grid; bool use_border; bool moved_elements_fetched; QSet elements_to_move; - QSet conducers_to_move; - QHash conducers_to_update; + QSet conductors_to_move; + QHash conductors_to_update; QGIManager qgi_manager; QUndoStack undo_stack; bool draw_terminals; @@ -47,13 +47,13 @@ class Diagram : public QGraphicsScene { void keyReleaseEvent(QKeyEvent *); // fonctions relatives a la pose de conducteurs - void setConducer(bool); - void setConducerStart (QPointF); - void setConducerStop(QPointF); + void setConductor(bool); + void setConductorStart (QPointF); + void setConductorStop(QPointF); // fonctions relatives a l'import / export XML QDomDocument toXml(bool = true); - bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList * = NULL, QList * = NULL); + bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList * = NULL, QList * = NULL); // fonctions relatives aux options graphiques void setDisplayGrid(bool); @@ -73,9 +73,9 @@ class Diagram : public QGraphicsScene { void invalidateMovedElements(); void fetchMovedElements(); const QSet &elementsToMove(); - const QSet &conducersToMove(); - const QHash &conducersToUpdate(); - QSet selectedConducers() const; + const QSet &conductorsToMove(); + const QHash &conductorsToUpdate(); + QSet selectedConductors() const; QUndoStack &undoStack(); QGIManager &qgiManager(); @@ -93,11 +93,11 @@ class Diagram : public QGraphicsScene { bornes. @param true pour ajouter le poseur de conducteur, false pour l'enlever */ -inline void Diagram::setConducer(bool pf) { +inline void Diagram::setConductor(bool pf) { if (pf) { - if (!conducer_setter -> scene()) addItem(conducer_setter); + if (!conductor_setter -> scene()) addItem(conductor_setter); } else { - if (conducer_setter -> scene()) removeItem(conducer_setter); + if (conductor_setter -> scene()) removeItem(conductor_setter); } } @@ -105,16 +105,16 @@ inline void Diagram::setConducer(bool pf) { Specifie les coordonnees du point de depart du poseur de conducteur @param d Le nouveau point de depart du poseur de conducteur */ -inline void Diagram::setConducerStart(QPointF d) { - conducer_setter -> setLine(QLineF(d, conducer_setter -> line().p2())); +inline void Diagram::setConductorStart(QPointF d) { + conductor_setter -> setLine(QLineF(d, conductor_setter -> line().p2())); } /** Specifie les coordonnees du point d'arrivee du poseur de conducteur @param d Le nouveau point d'arrivee du poseur de conducteur */ -inline void Diagram::setConducerStop(QPointF a) { - conducer_setter -> setLine(QLineF(conducer_setter -> line().p1(), a)); +inline void Diagram::setConductorStop(QPointF a) { + conductor_setter -> setLine(QLineF(conductor_setter -> line().p1(), a)); } /** @@ -181,15 +181,15 @@ inline const QSet &Diagram::elementsToMove() { } /// @return la liste des conducteurs a deplacer -inline const QSet &Diagram::conducersToMove() { +inline const QSet &Diagram::conductorsToMove() { if (!moved_elements_fetched) fetchMovedElements(); - return(conducers_to_move); + return(conductors_to_move); } /// @return la liste des conducteurs a modifier (typiquement les conducteurs dont seul un element est deplace) -inline const QHash &Diagram::conducersToUpdate() { +inline const QHash &Diagram::conductorsToUpdate() { if (!moved_elements_fetched) fetchMovedElements(); - return(conducers_to_update); + return(conductors_to_update); } /// @return la pile d'annulations de ce schema diff --git a/diagramcommands.cpp b/diagramcommands.cpp index 3a44350cd..8f0790ae0 100644 --- a/diagramcommands.cpp +++ b/diagramcommands.cpp @@ -1,6 +1,6 @@ #include "diagramcommands.h" #include "element.h" -#include "conducer.h" +#include "conductor.h" #include "diagram.h" #include "qgimanager.h" /** @@ -47,63 +47,63 @@ void AddElementCommand::redo() { @param t2 Seconde borne du conducteur @param parent QUndoCommand parent */ -AddConducerCommand::AddConducerCommand( +AddConductorCommand::AddConductorCommand( Diagram *d, - Conducer *c, + Conductor *c, QUndoCommand *parent ) : QUndoCommand(QObject::tr("ajouter un conducteur"), parent), - conducer(c), + conductor(c), diagram(d) { - diagram -> qgiManager().manage(conducer); + diagram -> qgiManager().manage(conductor); } /// Destructeur -AddConducerCommand::~AddConducerCommand() { - diagram -> qgiManager().release(conducer); +AddConductorCommand::~AddConductorCommand() { + diagram -> qgiManager().release(conductor); } /// Annule l'ajout -void AddConducerCommand::undo() { +void AddConductorCommand::undo() { // detache le conducteur sans le detruire - conducer -> terminal1 -> removeConducer(conducer); - conducer -> terminal2 -> removeConducer(conducer); - diagram -> removeItem(conducer); + conductor -> terminal1 -> removeConductor(conductor); + conductor -> terminal2 -> removeConductor(conductor); + diagram -> removeItem(conductor); } /// Refait l'ajout -void AddConducerCommand::redo() { - diagram -> addItem(conducer); +void AddConductorCommand::redo() { + diagram -> addItem(conductor); } /** Constructeur @param dia Schema dont on supprime des elements et conducteurs @param elements Elements supprimes - @param conducers Conducteurs supprimes + @param conductors Conducteurs supprimes @param parent QUndoCommand parent */ DeleteElementsCommand::DeleteElementsCommand( Diagram *dia, QSet elements, - QSet conducers, + QSet conductors, QUndoCommand *parent ) : QUndoCommand(parent), removed_elements(elements), - removed_conducers(conducers), + removed_conductors(conductors), diagram(dia) { - setText(QObject::tr("supprimer ") + QET::ElementsAndConducersSentence(removed_elements.count(), removed_conducers.count())); + setText(QObject::tr("supprimer ") + QET::ElementsAndConductorsSentence(removed_elements.count(), removed_conductors.count())); foreach(QGraphicsItem *qgi, removed_elements) diagram -> qgiManager().manage(qgi); - foreach(QGraphicsItem *qgi, removed_conducers) diagram -> qgiManager().manage(qgi); + foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().manage(qgi); } /// Destructeur DeleteElementsCommand::~DeleteElementsCommand() { foreach(QGraphicsItem *qgi, removed_elements) diagram -> qgiManager().release(qgi); - foreach(QGraphicsItem *qgi, removed_conducers) diagram -> qgiManager().release(qgi); + foreach(QGraphicsItem *qgi, removed_conductors) diagram -> qgiManager().release(qgi); } /// annule les suppressions @@ -114,19 +114,19 @@ void DeleteElementsCommand::undo() { } // remet les conducteurs - foreach(Conducer *c, removed_conducers) { + foreach(Conductor *c, removed_conductors) { diagram -> addItem(c); - c -> terminal1 -> addConducer(c); - c -> terminal2 -> addConducer(c); + c -> terminal1 -> addConductor(c); + c -> terminal2 -> addConductor(c); } } /// refait les suppressions void DeleteElementsCommand::redo() { // enleve les conducteurs - foreach(Conducer *c, removed_conducers) { - c -> terminal1 -> removeConducer(c); - c -> terminal2 -> removeConducer(c); + foreach(Conductor *c, removed_conductors) { + c -> terminal1 -> removeConductor(c); + c -> terminal2 -> removeConductor(c); diagram -> removeItem(c); } @@ -146,32 +146,32 @@ void DeleteElementsCommand::redo() { PasteDiagramCommand::PasteDiagramCommand( Diagram *dia, const QList &e, - const QList &c, + const QList &c, QUndoCommand *parent ) : QUndoCommand(parent), elements(e), - conducers(c), + conductors(c), diagram(dia), first_redo(true) { - setText(QObject::tr("coller ") + QET::ElementsAndConducersSentence(elements.count(), conducers.count())); + setText(QObject::tr("coller ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count())); foreach(QGraphicsItem *qgi, elements) diagram -> qgiManager().manage(qgi); - foreach(QGraphicsItem *qgi, conducers) diagram -> qgiManager().manage(qgi); + foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().manage(qgi); } /// Destructeur PasteDiagramCommand::~PasteDiagramCommand() { foreach(QGraphicsItem *qgi, elements) diagram -> qgiManager().release(qgi); - foreach(QGraphicsItem *qgi, conducers) diagram -> qgiManager().release(qgi); + foreach(QGraphicsItem *qgi, conductors) diagram -> qgiManager().release(qgi); } /// annule le coller void PasteDiagramCommand::undo() { // enleve les conducteurs - foreach(Conducer *c, conducers) { - c -> terminal1 -> removeConducer(c); - c -> terminal2 -> removeConducer(c); + foreach(Conductor *c, conductors) { + c -> terminal1 -> removeConductor(c); + c -> terminal2 -> removeConductor(c); diagram -> removeItem(c); } @@ -187,32 +187,32 @@ void PasteDiagramCommand::redo() { foreach(Element *e, elements) diagram -> addItem(e); // pose les conducteurs - foreach(Conducer *c, conducers) { + foreach(Conductor *c, conductors) { diagram -> addItem(c); - c -> terminal1 -> addConducer(c); - c -> terminal2 -> addConducer(c); + c -> terminal1 -> addConductor(c); + c -> terminal2 -> addConductor(c); } } foreach(Element *e, elements) e -> setSelected(true); - foreach(Conducer *c, conducers) c -> setSelected(true); + foreach(Conductor *c, conductors) c -> setSelected(true); } /** Constructeur @param dia Schema dont on supprime des elements et conducteurs @param elements Elements supprimes - @param conducers Conducteurs supprimes + @param conductors Conducteurs supprimes @param parent QUndoCommand parent */ CutDiagramCommand::CutDiagramCommand( Diagram *dia, QSet elements, - QSet conducers, + QSet conductors, QUndoCommand *parent ) : - DeleteElementsCommand(dia, elements, conducers, parent) + DeleteElementsCommand(dia, elements, conductors, parent) { - setText(QObject::tr("couper ") + QET::ElementsAndConducersSentence(elements.count(), conducers.count())); + setText(QObject::tr("couper ") + QET::ElementsAndConductorsSentence(elements.count(), conductors.count())); } /// Destructeur @@ -223,27 +223,27 @@ CutDiagramCommand::~CutDiagramCommand() { Constructeur @param dia Schema sur lequel on deplace des elements @param move_elements Elements a deplacer - @param move_conducers Conducteurs a deplacer - @param modify_conducers Conducteurs a mettre a jour + @param move_conductors Conducteurs a deplacer + @param modify_conductors Conducteurs a mettre a jour @param m translation subie par les elements @param parent QUndoCommand parent */ MoveElementsCommand::MoveElementsCommand( Diagram *dia, const QSet &move_elements, - const QSet &move_conducers, - const QHash &modify_conducers, + const QSet &move_conductors, + const QHash &modify_conductors, const QPointF &m, QUndoCommand *parent ) : QUndoCommand(parent), diagram(dia), elements_to_move(move_elements), - conducers_to_move(move_conducers), - conducers_to_update(modify_conducers), + conductors_to_move(move_conductors), + conductors_to_update(modify_conductors), movement(m) { - setText(QObject::tr("d\351placer ") + QET::ElementsAndConducersSentence(elements_to_move.count(), conducers_to_move.count())); + setText(QObject::tr("d\351placer ") + QET::ElementsAndConductorsSentence(elements_to_move.count(), conductors_to_move.count())); } /// Destructeur @@ -272,13 +272,13 @@ void MoveElementsCommand::move(const QPointF &actual_movement) { } // deplace certains conducteurs - foreach(Conducer *conducer, conducers_to_move) { - conducer -> setPos(conducer -> pos() + actual_movement); + foreach(Conductor *conductor, conductors_to_move) { + conductor -> setPos(conductor -> pos() + actual_movement); } // recalcule les autres conducteurs - foreach(Conducer *conducer, conducers_to_update.keys()) { - conducer -> updateWithNewPos(QRectF(), conducers_to_update[conducer], conducers_to_update[conducer] -> amarrageConducer()); + foreach(Conductor *conductor, conductors_to_update.keys()) { + conductor -> updateWithNewPos(QRectF(), conductors_to_update[conductor], conductors_to_update[conductor] -> amarrageConductor()); } } @@ -328,7 +328,7 @@ void ChangeDiagramTextCommand::redo() { @param parent QUndoCommand parent */ RotateElementsCommand::RotateElementsCommand(const QHash &elements, QUndoCommand *parent) : - QUndoCommand(QObject::tr("pivoter ") + QET::ElementsAndConducersSentence(elements.count(), 0), parent), + QUndoCommand(QObject::tr("pivoter ") + QET::ElementsAndConductorsSentence(elements.count(), 0), parent), elements_to_rotate(elements) { } @@ -359,14 +359,14 @@ void RotateElementsCommand::redo() { @param new_p nouveau profil du conducteur @param parent QUndoCommand parent */ -ChangeConducerCommand::ChangeConducerCommand( - Conducer *c, - const ConducerProfile &old_p, - const ConducerProfile &new_p, +ChangeConductorCommand::ChangeConductorCommand( + Conductor *c, + const ConductorProfile &old_p, + const ConductorProfile &new_p, QUndoCommand *parent ) : QUndoCommand(QObject::tr("modifier un conducteur"), parent), - conducer(c), + conductor(c), old_profile(old_p), new_profile(new_p), first_redo(true) @@ -374,18 +374,18 @@ ChangeConducerCommand::ChangeConducerCommand( } /// Destructeur -ChangeConducerCommand::~ChangeConducerCommand() { +ChangeConductorCommand::~ChangeConductorCommand() { } /// Annule la modification du conducteur -void ChangeConducerCommand::undo() { - conducer -> setProfile(old_profile); +void ChangeConductorCommand::undo() { + conductor -> setProfile(old_profile); } /// Refait la modification du conducteur -void ChangeConducerCommand::redo() { +void ChangeConductorCommand::redo() { if (first_redo) first_redo = false; - else conducer -> setProfile(new_profile); + else conductor -> setProfile(new_profile); } /** @@ -473,45 +473,45 @@ void ChangeBorderCommand::redo() { applyChanges(1); } -ChangeConducerPropertiesCommand::ChangeConducerPropertiesCommand(Conducer *c, QUndoCommand *parent) : +ChangeConductorPropertiesCommand::ChangeConductorPropertiesCommand(Conductor *c, QUndoCommand *parent) : QUndoCommand(QObject::tr("modifier les propri\351t\351s d'un conducteur"), parent), - conducer(c), + conductor(c), old_settings_set(false), new_settings_set(false) { } -ChangeConducerPropertiesCommand::~ChangeConducerPropertiesCommand() { +ChangeConductorPropertiesCommand::~ChangeConductorPropertiesCommand() { } -void ChangeConducerPropertiesCommand::setOldSettings(bool single, const QString &text, const SingleLineProperties &slp) { +void ChangeConductorPropertiesCommand::setOldSettings(bool single, const QString &text, const SingleLineProperties &slp) { old_is_single_line = single; - old_conducer_text = text; + old_conductor_text = text; old_slp = slp; old_settings_set = true; } -void ChangeConducerPropertiesCommand::setNewSettings(bool single, const QString &text, const SingleLineProperties &slp) { +void ChangeConductorPropertiesCommand::setNewSettings(bool single, const QString &text, const SingleLineProperties &slp) { new_is_single_line = single; - new_conducer_text = text; + new_conductor_text = text; new_slp = slp; new_settings_set = true; } -void ChangeConducerPropertiesCommand::undo() { +void ChangeConductorPropertiesCommand::undo() { if (old_settings_set && new_settings_set) { - conducer -> setSingleLine(old_is_single_line); - conducer -> setText(old_conducer_text); - conducer -> singleLineProperties = old_slp; - conducer -> update(); + conductor -> setSingleLine(old_is_single_line); + conductor -> setText(old_conductor_text); + conductor -> singleLineProperties = old_slp; + conductor -> update(); } } -void ChangeConducerPropertiesCommand::redo() { +void ChangeConductorPropertiesCommand::redo() { if (old_settings_set && new_settings_set) { - conducer -> setSingleLine(new_is_single_line); - conducer -> setText(new_conducer_text); - conducer -> singleLineProperties = new_slp; - conducer -> update(); + conductor -> setSingleLine(new_is_single_line); + conductor -> setText(new_conductor_text); + conductor -> singleLineProperties = new_slp; + conductor -> update(); } } diff --git a/diagramcommands.h b/diagramcommands.h index 5451afd1b..21a2d46d6 100644 --- a/diagramcommands.h +++ b/diagramcommands.h @@ -3,7 +3,7 @@ #include "qet.h" #include "diagram.h" #include "diagramtextitem.h" -#include "conducer.h" +#include "conductor.h" #include /** Cette classe represente l'action d'ajouter un element au schema @@ -34,13 +34,13 @@ class AddElementCommand : public QUndoCommand { /** Cette classe represente l'action d'ajouter un conducteur au schema */ -class AddConducerCommand : public QUndoCommand { +class AddConductorCommand : public QUndoCommand { // constructeurs, destructeur public: - AddConducerCommand(Diagram *, Conducer *, QUndoCommand * = 0); - virtual ~AddConducerCommand(); + AddConductorCommand(Diagram *, Conductor *, QUndoCommand * = 0); + virtual ~AddConductorCommand(); private: - AddConducerCommand(const AddConducerCommand &); + AddConductorCommand(const AddConductorCommand &); // methodes public: @@ -50,7 +50,7 @@ class AddConducerCommand : public QUndoCommand { // attributs private: /// Conducteur ajoute - Conducer *conducer; + Conductor *conductor; /// schema auquel on ajoute le conducteur Diagram *diagram; }; @@ -62,7 +62,7 @@ class AddConducerCommand : public QUndoCommand { class DeleteElementsCommand : public QUndoCommand { // constructeurs, destructeur public: - DeleteElementsCommand(Diagram *, QSet, QSet, QUndoCommand * = 0); + DeleteElementsCommand(Diagram *, QSet, QSet, QUndoCommand * = 0); virtual ~DeleteElementsCommand(); private: DeleteElementsCommand(const DeleteElementsCommand &); @@ -77,7 +77,7 @@ class DeleteElementsCommand : public QUndoCommand { /// Liste des elements enleves QSet removed_elements; /// List des conducteurs enleves - QSet removed_conducers; + QSet removed_conductors; /// schema dont on supprime des elements et conducteurs Diagram *diagram; }; @@ -88,7 +88,7 @@ class DeleteElementsCommand : public QUndoCommand { class PasteDiagramCommand : public QUndoCommand { // constructeurs, destructeur public: - PasteDiagramCommand(Diagram *, const QList &, const QList &, QUndoCommand * = 0); + PasteDiagramCommand(Diagram *, const QList &, const QList &, QUndoCommand * = 0); virtual ~PasteDiagramCommand(); private: PasteDiagramCommand(const PasteDiagramCommand &); @@ -103,7 +103,7 @@ class PasteDiagramCommand : public QUndoCommand { /// Elements ajoutes QList elements; /// conducteurs ajoutes - QList conducers; + QList conductors; /// schema sur lequel on colle les elements et conducteurs Diagram *diagram; /// booleen pour empecher le premier appel a redo @@ -117,7 +117,7 @@ class PasteDiagramCommand : public QUndoCommand { class CutDiagramCommand : public DeleteElementsCommand { // constructeurs, destructeur public: - CutDiagramCommand(Diagram *, QSet, QSet, QUndoCommand * = 0); + CutDiagramCommand(Diagram *, QSet, QSet, QUndoCommand * = 0); virtual ~CutDiagramCommand(); private: CutDiagramCommand(const CutDiagramCommand &); @@ -130,7 +130,7 @@ class CutDiagramCommand : public DeleteElementsCommand { class MoveElementsCommand : public QUndoCommand { // constructeurs, destructeur public: - MoveElementsCommand(Diagram *, const QSet &, const QSet &, const QHash &, const QPointF &m, QUndoCommand * = 0); + MoveElementsCommand(Diagram *, const QSet &, const QSet &, const QHash &, const QPointF &m, QUndoCommand * = 0); virtual ~MoveElementsCommand(); private: MoveElementsCommand(const MoveElementsCommand &); @@ -148,9 +148,9 @@ class MoveElementsCommand : public QUndoCommand { /// Elements a deplacer QSet elements_to_move; /// Conducteurs a deplacer - QSet conducers_to_move; + QSet conductors_to_move; /// Conducteurs a actualiser - QHash conducers_to_update; + QHash conductors_to_update; /// mouvement effectue QPointF movement; /// booleen pour ne pas executer le premier redo() @@ -210,13 +210,13 @@ class RotateElementsCommand : public QUndoCommand { /** Cette classe represente l'action de modifier un conducteur */ -class ChangeConducerCommand : public QUndoCommand { +class ChangeConductorCommand : public QUndoCommand { // constructeurs, destructeur public: - ChangeConducerCommand(Conducer *, const ConducerProfile &, const ConducerProfile &, QUndoCommand * = 0); - virtual ~ChangeConducerCommand(); + ChangeConductorCommand(Conductor *, const ConductorProfile &, const ConductorProfile &, QUndoCommand * = 0); + virtual ~ChangeConductorCommand(); private: - ChangeConducerCommand(const ChangeConducerCommand &); + ChangeConductorCommand(const ChangeConductorCommand &); // methodes public: @@ -226,11 +226,11 @@ class ChangeConducerCommand : public QUndoCommand { // attributs private: /// DiagramTextItem modifie - Conducer *conducer; + Conductor *conductor; /// texte avant changement - ConducerProfile old_profile; + ConductorProfile old_profile; /// texte apres changement - ConducerProfile new_profile; + ConductorProfile new_profile; /// booleen pour ne pas executer le premier redo() bool first_redo; }; @@ -301,13 +301,13 @@ class ChangeBorderCommand : public QUndoCommand { /** Cette classe represente l'action de modifier les proprietes d'un conducteur */ -class ChangeConducerPropertiesCommand : public QUndoCommand { +class ChangeConductorPropertiesCommand : public QUndoCommand { // constructeurs, destructeur public: - ChangeConducerPropertiesCommand(Conducer *, QUndoCommand * = 0); - virtual ~ChangeConducerPropertiesCommand(); + ChangeConductorPropertiesCommand(Conductor *, QUndoCommand * = 0); + virtual ~ChangeConductorPropertiesCommand(); private: - ChangeConducerPropertiesCommand(const ChangeConducerPropertiesCommand &); + ChangeConductorPropertiesCommand(const ChangeConductorPropertiesCommand &); // methodes public: @@ -319,14 +319,14 @@ class ChangeConducerPropertiesCommand : public QUndoCommand { // attributs private: /// Conducteur modifie - Conducer *conducer; + Conductor *conductor; /// anciennes proprietes bool old_is_single_line; - QString old_conducer_text; + QString old_conductor_text; SingleLineProperties old_slp; /// nouvelles proprietes bool new_is_single_line; - QString new_conducer_text; + QString new_conductor_text; SingleLineProperties new_slp; bool old_settings_set; bool new_settings_set; diff --git a/diagramview.cpp b/diagramview.cpp index 1b4ba337a..968865f15 100644 --- a/diagramview.cpp +++ b/diagramview.cpp @@ -2,9 +2,9 @@ #include "diagram.h" #include "customelement.h" #include "exportdialog.h" -#include "conducer.h" +#include "conductor.h" #include "diagramcommands.h" -#include "conducerproperties.h" +#include "conductorproperties.h" /** Constructeur @@ -72,22 +72,22 @@ void DiagramView::selectInvert() { void DiagramView::deleteSelection() { QSet garbage_elmt; - QSet garbage_conducers; + QSet garbage_conductors; // creation de deux listes : une pour les conducteurs, une pour les elements foreach (QGraphicsItem *qgi, scene -> selectedItems()) { // pour chaque qgi selectionne, il s'agit soit d'un element soit d'un conducteur - if (Conducer * c = qgraphicsitem_cast(qgi)) { + if (Conductor * c = qgraphicsitem_cast(qgi)) { // s'il s'agit d'un conducteur, on le met dans la liste des conducteurs - garbage_conducers << c; + garbage_conductors << c; } else if (Element *e = qgraphicsitem_cast(qgi)) { garbage_elmt << e; // s'il s'agit d'un element, on veille a enlever ses conducteurs - garbage_conducers += e -> conducers().toSet(); + garbage_conductors += e -> conductors().toSet(); } } scene -> clearSelection(); - scene -> undoStack().push(new DeleteElementsCommand(scene, garbage_elmt, garbage_conducers)); + scene -> undoStack().push(new DeleteElementsCommand(scene, garbage_elmt, garbage_conductors)); } /** @@ -206,22 +206,22 @@ void DiagramView::zoomReset() { void DiagramView::cut() { copy(); QSet cut_elmt; - QSet cut_conducers; + QSet cut_conductors; // creation de deux listes : une pour les conducteurs, une pour les elements foreach (QGraphicsItem *qgi, scene -> selectedItems()) { // pour chaque qgi selectionne, il s'agit soit d'un element soit d'un conducteur - if (Conducer * c = qgraphicsitem_cast(qgi)) { + if (Conductor * c = qgraphicsitem_cast(qgi)) { // s'il s'agit d'un conducteur, on le met dans la liste des conducteurs - cut_conducers << c; + cut_conductors << c; } else if (Element *e = qgraphicsitem_cast(qgi)) { cut_elmt << e; // s'il s'agit d'un element, on veille a enlever ses conducteurs - cut_conducers += e -> conducers().toSet(); + cut_conductors += e -> conductors().toSet(); } } scene -> clearSelection(); - scene -> undoStack().push(new CutDiagramCommand(scene, cut_elmt, cut_conducers)); + scene -> undoStack().push(new CutDiagramCommand(scene, cut_elmt, cut_conductors)); } /** @@ -245,13 +245,13 @@ void DiagramView::paste() { // listes pour recupere les elements et conducteurs ajoutes au schema par le coller QList elements_pasted; - QList conducers_pasted; - scene -> fromXml(document_xml, QPointF(), false, &elements_pasted, &conducers_pasted); + QList conductors_pasted; + scene -> fromXml(document_xml, QPointF(), false, &elements_pasted, &conductors_pasted); // si quelque chose a effectivement ete ajoute au schema, on cree - if (elements_pasted.count() || conducers_pasted.count()) { + if (elements_pasted.count() || conductors_pasted.count()) { scene -> clearSelection(); - scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conducers_pasted)); + scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conductors_pasted)); } } @@ -267,13 +267,13 @@ void DiagramView::mousePressEvent(QMouseEvent *e) { // listes pour recupere les elements et conducteurs ajoutes au schema par le coller QList elements_pasted; - QList conducers_pasted; - scene -> fromXml(document_xml, mapToScene(e -> pos()), false, &elements_pasted, &conducers_pasted); + QList conductors_pasted; + scene -> fromXml(document_xml, mapToScene(e -> pos()), false, &elements_pasted, &conductors_pasted); // si quelque chose a effectivement ete ajoute au schema, on cree - if (elements_pasted.count() || conducers_pasted.count()) { + if (elements_pasted.count() || conductors_pasted.count()) { scene -> clearSelection(); - scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conducers_pasted)); + scene -> undoStack().push(new PasteDiagramCommand(scene, elements_pasted, conductors_pasted)); } } else { QGraphicsView::mousePressEvent(e); @@ -605,36 +605,36 @@ QRectF DiagramView::viewedSceneRect() const { return(QRectF(scene_left_top, scene_right_bottom)); } -void DiagramView::editConducer() { - QList selected_conducers(scene -> selectedConducers().toList()); +void DiagramView::editConductor() { + QList selected_conductors(scene -> selectedConductors().toList()); // on ne peut editer qu'un conducteur a la fois - if (selected_conducers.count() != 1) return; - Conducer *edited_conducer = selected_conducers.first(); + if (selected_conductors.count() != 1) return; + Conductor *edited_conductor = selected_conductors.first(); // initialise l'editeur de proprietes pour le conducteur - ConducerPropertiesWidget *cpw = new ConducerPropertiesWidget(); - cpw -> setSingleLine(edited_conducer -> isSingleLine()); - cpw -> setConducerText(edited_conducer -> text()); - cpw -> setSingleLineProperties(edited_conducer -> singleLineProperties); + ConductorPropertiesWidget *cpw = new ConductorPropertiesWidget(); + cpw -> setSingleLine(edited_conductor -> isSingleLine()); + cpw -> setConductorText(edited_conductor -> text()); + cpw -> setSingleLineProperties(edited_conductor -> singleLineProperties); // initialise egalement l'objet UndoCommand correspondant - ChangeConducerPropertiesCommand *ccpc = new ChangeConducerPropertiesCommand(edited_conducer); - ccpc -> setOldSettings(edited_conducer -> isSingleLine(), edited_conducer -> text(), edited_conducer -> singleLineProperties); + ChangeConductorPropertiesCommand *ccpc = new ChangeConductorPropertiesCommand(edited_conductor); + ccpc -> setOldSettings(edited_conductor -> isSingleLine(), edited_conductor -> text(), edited_conductor -> singleLineProperties); // l'insere dans un dialogue - QDialog conducer_dialog; - conducer_dialog.setWindowTitle(tr("\311diter les propri\351t\351s d'un conducteur")); - QVBoxLayout *dialog_layout = new QVBoxLayout(&conducer_dialog); + QDialog conductor_dialog; + conductor_dialog.setWindowTitle(tr("\311diter les propri\351t\351s d'un conducteur")); + QVBoxLayout *dialog_layout = new QVBoxLayout(&conductor_dialog); dialog_layout -> addWidget(cpw); QDialogButtonBox *dbb = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel); dialog_layout -> addWidget(dbb); - connect(dbb, SIGNAL(accepted()), &conducer_dialog, SLOT(accept())); - connect(dbb, SIGNAL(rejected()), &conducer_dialog, SLOT(reject())); + connect(dbb, SIGNAL(accepted()), &conductor_dialog, SLOT(accept())); + connect(dbb, SIGNAL(rejected()), &conductor_dialog, SLOT(reject())); // execute le dialogue et met a jour le conducteur - if (conducer_dialog.exec() == QDialog::Accepted) { - ccpc -> setNewSettings(cpw -> isSingleLine(), cpw -> conducerText(), cpw -> singleLineProperties()); + if (conductor_dialog.exec() == QDialog::Accepted) { + ccpc -> setNewSettings(cpw -> isSingleLine(), cpw -> conductorText(), cpw -> singleLineProperties()); diagram() -> undoStack().push(ccpc); } else { delete ccpc; diff --git a/diagramview.h b/diagramview.h index 60d9870cb..083d12653 100644 --- a/diagramview.h +++ b/diagramview.h @@ -70,7 +70,7 @@ class DiagramView : public QGraphicsView { void paste(); void adjustSceneRect(); void updateWindowTitle(); - void editConducer(); + void editConductor(); private slots: void slot_selectionChanged(); diff --git a/element.cpp b/element.cpp index dd4a0f6d8..fe290299c 100644 --- a/element.cpp +++ b/element.cpp @@ -1,7 +1,7 @@ #include "element.h" #include "qetapp.h" #include "diagram.h" -#include "conducer.h" +#include "conductor.h" #include "elementtextitem.h" #include "diagramcommands.h" #include @@ -121,7 +121,7 @@ bool Element::setOrientation(QET::Orientation o) { ori.setCurrent(o); update(); foreach(QGraphicsItem *qgi, children()) { - if (Terminal *p = qgraphicsitem_cast(qgi)) p -> updateConducer(); + if (Terminal *p = qgraphicsitem_cast(qgi)) p -> updateConductor(); else if (ElementTextItem *eti = qgraphicsitem_cast(qgi)) { // applique une rotation contraire si besoin if (!eti -> followParentRotations()) { @@ -251,14 +251,14 @@ void Element::moveOtherElements(const QPointF &diff) { } // deplace certains conducteurs - foreach(Conducer *conducer, diagram_ptr -> conducersToMove()) { - conducer -> setPos(conducer -> pos() + diff); + foreach(Conductor *conductor, diagram_ptr -> conductorsToMove()) { + conductor -> setPos(conductor -> pos() + diff); } // recalcule les autres conducteurs - const QHash &conducers_modify = diagram_ptr -> conducersToUpdate(); - foreach(Conducer *conducer, conducers_modify.keys()) { - conducer -> updateWithNewPos(QRectF(), conducers_modify[conducer], conducers_modify[conducer] -> amarrageConducer()); + const QHash &conductors_modify = diagram_ptr -> conductorsToUpdate(); + foreach(Conductor *conductor, conductors_modify.keys()) { + conductor -> updateWithNewPos(QRectF(), conductors_modify[conductor], conductors_modify[conductor] -> amarrageConductor()); } } @@ -270,8 +270,8 @@ void Element::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { new MoveElementsCommand( diagram_ptr, diagram_ptr -> elementsToMove(), - diagram_ptr -> conducersToMove(), - diagram_ptr -> conducersToUpdate(), + diagram_ptr -> conductorsToMove(), + diagram_ptr -> conductorsToUpdate(), diagram_ptr -> current_movement ) ); diff --git a/element.h b/element.h index 212b18632..c664f6b39 100644 --- a/element.h +++ b/element.h @@ -36,7 +36,7 @@ class Element : public QGraphicsItem { // methodes virtuelles pures a definir dans les classes enfants virtual QList terminals() const = 0; - virtual QList conducers() const = 0; + virtual QList conductors() const = 0; virtual int nbTerminals() const = 0; virtual int nbTerminalsMin() const = 0; virtual int nbTerminalsMax() const = 0; diff --git a/lang/qet_en.qm b/lang/qet_en.qm index a9ad8177a..c9de19c5c 100644 Binary files a/lang/qet_en.qm and b/lang/qet_en.qm differ diff --git a/lang/qet_en.ts b/lang/qet_en.ts index fe293b64f..5c360a1e8 100644 --- a/lang/qet_en.ts +++ b/lang/qet_en.ts @@ -1,5 +1,6 @@ + AboutQET @@ -219,25 +220,63 @@ Whoops, we have no website diameter + + ConductorPropertiesWidget + + + Type de conducteur + Conductor Type + + + + Multifilaire + Multiline + + + + Texte : + Text : + + + + Unifilaire + SIngleline + + + + phase + phase + + + + terre + ground + + + + neutre + neutral + + DiagramView - + ? ? - + Auteur : Author : - + Cartouche du schéma Diagram inset - + Date : Date : @@ -247,32 +286,32 @@ Whoops, we have no website Diagram QElectroTech (*.qet) - + Enregistrer le schéma en cours ? Save the current diagram ? - + Enregistrer sous Save as - + Erreur Error - + Fichier : File : - + Folio : Folio : - + Impossible d'ecrire dans ce fichier Can't write to the file @@ -287,25 +326,30 @@ Whoops, we have no website Diagram QElectroTech (*.qet) - + Schéma QElectroTech (*.qet) QElectroTech Diagram (*.qet) - + Titre : Title : - + Voulez-vous enregistrer le schéma Do you wish to save the diagram - + nouveau schéma new diagram + + + Éditer les propriétés d'un conducteur + Edit conductor properties + ElementDeleter @@ -1383,17 +1427,17 @@ Please check rights of the directory Render the current plan with or without antialiasing - + Active la fenêtre Activates the window - + Active la fenêtre précédente Activates the previous window - + Active la fenêtre suivante Activates the next window @@ -1403,87 +1447,87 @@ Please check rights of the directory Render with &Antialiasing - + Adapte la taille du schéma afin qu'il soit entièrement visible Changes the size of the plan so that it fits in the view - + Afficha&ge Displ&ay - + Affiche des informations sur la bibliothèque Qt Displays informations about Qt library - + Affiche des informations sur QElectroTech Displays informations about QElectroTech - + Affiche ou non la barre d'outils Displays or not the toolbar - + Affiche ou non le panel d'appareils Displays or not the elements panel - + Affiche QElectroTech en mode fenêtré Displays QElectroTech in windowed mode - + Affiche QElectroTech en mode plein écran Displays QELectroTech in full screen mode - + Afficher Display - + Agrandir le schéma Expand the diagram - + Agrandit le schéma Expand the diagram - + Agrandit le schéma en hauteur Expand the diagram's height - + &Aide &Help - + Ajouter une colonne Add a column - + Ajoute une colonne au schéma Add a column to the diagram - + Aligne les fenêtres réduites Arranges all iconized windows at the bottom of the workspace - + Annule l'action précédente Undoes the previous action @@ -1493,17 +1537,17 @@ Please check rights of the directory &Undo - + À &propos de QElectroTech A&bout QElectroTech - + À propos de &Qt About &Qt - + Arranger les fenêtres réduites Arranges iconized windows @@ -1513,27 +1557,27 @@ Please check rights of the directory Hide Too&lbar - + &Cascade &Cascade - + Ce fichier n'est pas un document XML valide. This file is not a valid XML Document. - + Ce fichier n'existe pas. This file does not exist. - + C&oller &Paste - + &Configuration &Settings @@ -1543,77 +1587,77 @@ Please check rights of the directory Configure tool&bars - + &Configurer QElectroTech &Configure QElectroTech - + Copie les éléments sélectionnés dans le presse-papier Copies selected elements - + Cop&ier &Copy - + Co&uper Cu&t - + Crée un nouveau schéma Opens a new diagram - + Ctrl+0 - + Ctrl+9 - + Ctrl+I - + Ctrl+Q - + Ctrl+R Ctrl+R - + Ctrl+Shift+A - + Ctrl+Shift+F Ctrl+Shift+F - + Ctrl+Shift+I - + Ctrl+Shift+X - + Ctrl+Suppr Ctrl+Suppr @@ -1623,17 +1667,17 @@ Please check rights of the directory Render without &Antialiasing - + Désélectionne les éléments sélectionnés et sélectionne les éléments non sélectionnés Deselects selected elements and select non-selected elements - + Désélectionner tout Select none - + Désélectionne tous les éléments du schéma Deselect all elements on the plan @@ -1643,52 +1687,52 @@ Please check rights of the directory Diagram QelectroTech (*.qet);;XML Files(*.xml);;All files (*) - + Dispose les fenêtres en cascade Arranges windows in a cascade pattern - + Dispose les fenêtres en mosaïque Arranges windows in a tile pattern - + Édite les informations affichées par le cartouche Edit informations displayed by the inset - + &Édition &Edit - + Enlève les éléments sélectionnés du schéma Removes selected elements from the plan - + Enlever une colonne Remove a column - + Enlève une colonne au schéma Remove a column from the diagram - + Enregistre le schéma courant Saves the current plan - + Enregistre le schéma courant avec un autre nom de fichier Saves the current plan as another filename - + &Enregistrer &Save @@ -1698,22 +1742,22 @@ Please check rights of the directory Save the current schema ? - + Enregistrer sous Save as - + Erreur Error - + Exporte le schéma courant dans un autre format Exports the curent plan to another format - + E&xporter &Export @@ -1723,37 +1767,37 @@ Please check rights of the directory Export to file - + Fenêtre précédente Previous Window - + Fe&nêtres Wi&ndows - + Fenêtre suivante Next Window - + Ferme l'application QElectroTech Closes QElectroTech - + Ferme le schéma courant Closes the current plan - + &Fermer &Close - + &Fichier &File @@ -1763,12 +1807,12 @@ Please check rights of the directory PNG Picture (*.png) - + &Importer &Import - + Importe un schéma dans le schéma courant Imports a plan into the current plan @@ -1783,27 +1827,27 @@ Please check rights of the directory Can't read that file - + Impossible de lire ce fichier. Could not read file. - + Imprime le schéma courant Prints the current plan - + Imprimer Print - + Informations sur le schéma Diagram informations - + Inverser la sélection Invert selection @@ -1818,47 +1862,47 @@ Please check rights of the directory &Fullscreen Mode - + Mode Selection Selection Mode - + Mode Visualisation View Mode - + &Mosaïque &Tile - + &Nouveau &New - + O&utils &Tools - + Outils Tools - + Ouvre un schéma existant Open an existing diagram - + &Ouvrir &Open - + Ouvrir un fichier Open a file @@ -1868,47 +1912,47 @@ Please check rights of the directory P - + Panel d'appareils Elements Panel - + Pas de zoom Reset zoom - + Passer en &mode plein écran - F&ullScreen Screen Mode + F&ullScreen Mode - + Permet de régler différents paramètres de QElectroTech Allows to specify various parameters for QElectroTech - + Permet de sélectionner les éléments Allows to select elements - + Permet de visualiser le schéma sans pouvoir le modifier Allows to view the plan without modifying it - + Pivote les éléments sélectionnés Rotates selected elements - + Pivoter Rotate - + Place les éléments du presse-papier sur le schéma Pastes elements from the clipboard into the plan @@ -1918,7 +1962,7 @@ Please check rights of the directory QElectrotech - + QElectroTech QElectroTech @@ -1928,7 +1972,7 @@ Please check rights of the directory QElectrotech : Size of the drawing area : - + &Quitter &Quit @@ -1943,12 +1987,12 @@ Please check rights of the directory &Redo - + Restaure l'action annulée Restores the undone action - + Restaure le zoom par défaut Restores default zoom level @@ -1963,17 +2007,17 @@ Please check rights of the directory Restore QElectroTech - + Rétrécir le schéma Shrink the diagram - + Rétrécit le schéma Shrinks the plan - + Rétrécit le schéma en hauteur Shrink the diagram's height @@ -1998,37 +2042,37 @@ Please check rights of the directory QElectroTech Diagram (*.qet);;XML Files (*.xml);;All files (*) - + Schémas QElectroTech (*.qet);;Fichiers XML (*.xml);;Tous les fichiers (*) QElectroTech Diagrams (*.qet);;XML Files (*.xml);;All files (*) - + Sélectionne tous les éléments du schéma Selects all elements on the plan - + Sortir du &mode plein écran Exit F&ullScreen Screen Mode - + Supprimer Delete - + Tout sélectionner Select All - + Transfère les éléments sélectionnés dans le presse-papier Puts selected elements into the clipboard - + Une erreur s'est produite lors de l'ouverture du fichier. An error occured while opening the file. @@ -2043,30 +2087,40 @@ Please check rights of the directory x - + Zoom adapté Fit in view - + Zoom arrière Zoom Out - + Zoom avant Zoom In - + Annuler Undo - + Refaire Redo + + + Propriétés du conducteur + Conductor properties + + + + Édite les propriétés du conducteur sélectionné + Edit the selected conductor properties + QETElementEditor @@ -2441,7 +2495,7 @@ Please check rights of the directory ajouter un conducteur - add a conducer + add a conductor @@ -2476,7 +2530,7 @@ Please check rights of the directory modifier un conducteur - modify a conducer + modify a conductor @@ -2521,18 +2575,23 @@ Please check rights of the directory conducteurs - conducers + conductors conducteur - conducer + conductor Borne Terminal + + + modifier les propriétés d'un conducteur + modify conductor properties + Schema diff --git a/qelectrotech.pro b/qelectrotech.pro index 020d78768..1cc89ad22 100644 --- a/qelectrotech.pro +++ b/qelectrotech.pro @@ -10,10 +10,10 @@ INCLUDEPATH += . editor # Input HEADERS += aboutqet.h \ borderinset.h \ - conducer.h \ - conducerprofile.h \ - conducersegment.h \ - conducersegmentprofile.h \ + conductor.h \ + conductorprofile.h \ + conductorsegment.h \ + conductorsegmentprofile.h \ customelement.h \ diagram.h \ diagramview.h \ @@ -67,12 +67,12 @@ HEADERS += aboutqet.h \ diagramcommands.h \ diagramtextitem.h \ insetproperties.h \ - conducerproperties.h + conductorproperties.h SOURCES += aboutqet.cpp \ borderinset.cpp \ - conducer.cpp \ - conducerprofile.cpp \ - conducersegment.cpp \ + conductor.cpp \ + conductorprofile.cpp \ + conductorsegment.cpp \ customelement.cpp \ diagram.cpp \ diagramview.cpp \ @@ -126,7 +126,7 @@ SOURCES += aboutqet.cpp \ editor/textfieldeditor.cpp \ diagramcommands.cpp \ diagramtextitem.cpp \ - conducerproperties.cpp + conductorproperties.cpp RESOURCES += qelectrotech.qrc TRANSLATIONS += lang/qet_en.ts lang/qt_fr.ts RC_FILE = ico/windows_icon/application_icon/qelectrotech.rc diff --git a/qet.cpp b/qet.cpp index 264560262..a2a152b4a 100644 --- a/qet.cpp +++ b/qet.cpp @@ -127,19 +127,19 @@ bool QET::attributeIsAReal(const QDomElement &e, QString nom_attribut, double *r /** Permet de composer rapidement la proposition "x elements et y conducteurs" @param elements_count nombre d élements - @param conducers_count nombre de conducteurs + @param conductors_count nombre de conducteurs @return la proposition decrivant le nombre d'elements et de conducteurs */ -QString QET::ElementsAndConducersSentence(int elements_count, int conducers_count) { +QString QET::ElementsAndConductorsSentence(int elements_count, int conductors_count) { QString text; if (elements_count) { text += QString::number(elements_count) + " "; text += elements_count > 1 ? QObject::tr("\351l\351ments") : QObject::tr("\351l\351ment"); - if (conducers_count) text += QObject::tr(" et "); + if (conductors_count) text += QObject::tr(" et "); } - if (conducers_count) { - text += QString::number(conducers_count) + " "; - text += conducers_count > 1 ? QObject::tr("conducteurs") : QObject::tr("conducteur"); + if (conductors_count) { + text += QString::number(conductors_count) + " "; + text += conductors_count > 1 ? QObject::tr("conducteurs") : QObject::tr("conducteur"); } return(text); } diff --git a/qet.h b/qet.h index 338532698..dc75fcaa0 100644 --- a/qet.h +++ b/qet.h @@ -8,7 +8,7 @@ */ namespace QET { enum Orientation {North, East, South, West}; - enum ConducerSegmentType { Horizontal = 1, Vertical = 2, Both = 3 }; + enum ConductorSegmentType { Horizontal = 1, Vertical = 2, Both = 3 }; QET::Orientation nextOrientation(QET::Orientation); QET::Orientation previousOrientation(QET::Orientation); QET::Orientation orientationFromString(const QString &); @@ -18,6 +18,6 @@ namespace QET { bool estVerticale(QET::Orientation); bool attributeIsAnInteger(const QDomElement &, QString , int * = NULL); bool attributeIsAReal(const QDomElement &, QString , double * = NULL); - QString ElementsAndConducersSentence(int, int); + QString ElementsAndConductorsSentence(int, int); } #endif diff --git a/qetdiagrameditor.cpp b/qetdiagrameditor.cpp index c1c0f1b70..3a8bdcd07 100644 --- a/qetdiagrameditor.cpp +++ b/qetdiagrameditor.cpp @@ -4,7 +4,7 @@ #include "diagram.h" #include "elementspanelwidget.h" #include "aboutqet.h" -#include "conducerproperties.h" +#include "conductorproperties.h" /** constructeur @@ -161,7 +161,7 @@ void QETDiagramEditor::actions() { select_invert = new QAction( tr("Inverser la s\351lection"), this); delete_selection = new QAction(QIcon(":/ico/delete.png"), tr("Supprimer"), this); rotate_selection = new QAction(QIcon(":/ico/pivoter.png"), tr("Pivoter"), this); - conducer_prop = new QAction(QIcon(":/ico/conductor.png"), tr("Propri\351t\351s du conducteur"), this); + conductor_prop = new QAction(QIcon(":/ico/conductor.png"), tr("Propri\351t\351s du conducteur"), this); infos_diagram = new QAction(QIcon(":/ico/info.png"), tr("Informations sur le sch\351ma"), this); add_column = new QAction(QIcon(":/ico/add_col.png"), tr("Ajouter une colonne"), this); remove_column = new QAction(QIcon(":/ico/remove_col.png"), tr("Enlever une colonne"), this); @@ -242,7 +242,7 @@ void QETDiagramEditor::actions() { select_invert -> setStatusTip(tr("D\351s\351lectionne les \351l\351ments s\351lectionn\351s et s\351lectionne les \351l\351ments non s\351lectionn\351s")); delete_selection -> setStatusTip(tr("Enl\350ve les \351l\351ments s\351lectionn\351s du sch\351ma")); rotate_selection -> setStatusTip(tr("Pivote les \351l\351ments s\351lectionn\351s")); - conducer_prop -> setStatusTip(tr("\311dite les propri\351t\351s du conducteur s\351lectionn\351")); + conductor_prop -> setStatusTip(tr("\311dite les propri\351t\351s du conducteur s\351lectionn\351")); infos_diagram -> setStatusTip(tr("\311dite les informations affich\351es par le cartouche")); add_column -> setStatusTip(tr("Ajoute une colonne au sch\351ma")); remove_column -> setStatusTip(tr("Enl\350ve une colonne au sch\351ma")); @@ -312,7 +312,7 @@ void QETDiagramEditor::actions() { connect(arrange_window, SIGNAL(triggered()), &workspace, SLOT(arrangeIcons()) ); connect(next_window, SIGNAL(triggered()), &workspace, SLOT(activateNextWindow()) ); connect(prev_window, SIGNAL(triggered()), &workspace, SLOT(activatePreviousWindow()) ); - connect(conducer_prop, SIGNAL(triggered()), this, SLOT(slot_editConducer()) ); + connect(conductor_prop, SIGNAL(triggered()), this, SLOT(slot_editConductor()) ); connect(infos_diagram, SIGNAL(triggered()), this, SLOT(slot_editInfos()) ); connect(add_column, SIGNAL(triggered()), this, SLOT(slot_addColumn()) ); connect(remove_column, SIGNAL(triggered()), this, SLOT(slot_removeColumn()) ); @@ -370,7 +370,7 @@ void QETDiagramEditor::menus() { menu_edition -> addAction(delete_selection); menu_edition -> addAction(rotate_selection); menu_edition -> addSeparator(); - menu_edition -> addAction(conducer_prop); + menu_edition -> addAction(conductor_prop); menu_edition -> addSeparator(); menu_edition -> addAction(infos_diagram); menu_edition -> addAction(add_column); @@ -666,7 +666,7 @@ void QETDiagramEditor::slot_updateActions() { zoom_out -> setEnabled(opened_document); zoom_fit -> setEnabled(opened_document); zoom_reset -> setEnabled(opened_document); - conducer_prop -> setEnabled(opened_document && sv -> diagram() -> selectedConducers().count() == 1); + conductor_prop -> setEnabled(opened_document && sv -> diagram() -> selectedConductors().count() == 1); infos_diagram -> setEnabled(opened_document); add_column -> setEnabled(opened_document); remove_column -> setEnabled(opened_document); @@ -830,8 +830,8 @@ void QETDiagramEditor::slot_shrink() { sv -> shrink(); } -void QETDiagramEditor::slot_editConducer() { +void QETDiagramEditor::slot_editConductor() { if (DiagramView *dv = currentDiagram()) { - dv -> editConducer(); + dv -> editConductor(); } } diff --git a/qetdiagrameditor.h b/qetdiagrameditor.h index 82b23f812..345d5f648 100644 --- a/qetdiagrameditor.h +++ b/qetdiagrameditor.h @@ -65,7 +65,7 @@ class QETDiagramEditor : public QMainWindow { void slot_removeColumn(); void slot_expand(); void slot_shrink(); - void slot_editConducer(); + void slot_editConductor(); // attributs protected: @@ -91,7 +91,7 @@ class QETDiagramEditor : public QMainWindow { QAction *select_invert; QAction *delete_selection; QAction *rotate_selection; - QAction *conducer_prop; + QAction *conductor_prop; QAction *infos_diagram; QAction *add_column; QAction *remove_column; diff --git a/terminal.cpp b/terminal.cpp index 645c89b6e..4a388f64f 100644 --- a/terminal.cpp +++ b/terminal.cpp @@ -1,7 +1,7 @@ #include "terminal.h" #include "diagram.h" #include "element.h" -#include "conducer.h" +#include "conductor.h" #include "diagramcommands.h" QColor Terminal::couleur_neutre = QColor(Qt::blue); @@ -16,14 +16,14 @@ QColor Terminal::couleur_interdit = QColor(Qt::red); */ void Terminal::initialise(QPointF pf, QET::Orientation o) { // definition du pount d'amarrage pour un conducteur - amarrage_conducer = pf; + amarrage_conductor = pf; // definition de l'orientation de la terminal (par defaut : sud) if (o < QET::North || o > QET::West) sens = QET::South; else sens = o; // calcul de la position du point d'amarrage a l'element - amarrage_elmt = amarrage_conducer; + amarrage_elmt = amarrage_conductor; switch(sens) { case QET::North: amarrage_elmt += QPointF(0, TAILLE_BORNE); break; case QET::East : amarrage_elmt += QPointF(-TAILLE_BORNE, 0); break; @@ -90,7 +90,7 @@ Terminal::Terminal(qreal pf_x, qreal pf_y, QET::Orientation o, Element *e, Diagr */ Terminal::~Terminal() { //qDebug() << "Terminal::~Terminal" << (void *)this; - foreach(Conducer *c, liste_conducers) delete c; + foreach(Conductor *c, liste_conductors) delete c; delete br; } @@ -118,30 +118,30 @@ QET::Orientation Terminal::orientation() const { } /** - Attribue un conducer a la borne + Attribue un conductor a la borne @param f Le conducteur a rattacher a cette borne */ -bool Terminal::addConducer(Conducer *f) { +bool Terminal::addConductor(Conductor *f) { // pointeur 0 refuse if (!f) return(false); // une seule des deux bornes du conducteur doit etre this - Q_ASSERT_X((f -> terminal1 == this ^ f -> terminal2 == this), "Terminal::addConducer", "Le conducer devrait etre relie exactement une fois a la terminal en cours"); + Q_ASSERT_X((f -> terminal1 == this ^ f -> terminal2 == this), "Terminal::addConductor", "Le conductor devrait etre relie exactement une fois a la terminal en cours"); // determine l'autre borne a laquelle cette borne va etre relie grace au conducteur Terminal *autre_terminal = (f -> terminal1 == this) ? f -> terminal2 : f -> terminal1; // verifie que la borne n'est pas deja reliee avec l'autre borne bool deja_liees = false; - foreach (Conducer* conducer, liste_conducers) { - if (conducer -> terminal1 == autre_terminal || conducer -> terminal2 == autre_terminal) deja_liees = true; + foreach (Conductor* conductor, liste_conductors) { + if (conductor -> terminal1 == autre_terminal || conductor -> terminal2 == autre_terminal) deja_liees = true; } // si les deux bornes sont deja reliees, on refuse d'ajouter le conducteur if (deja_liees) return(false); // sinon on ajoute le conducteur - liste_conducers.append(f); + liste_conductors.append(f); return(true); } @@ -149,11 +149,11 @@ bool Terminal::addConducer(Conducer *f) { Enleve un conducteur donne a la borne @param f Conducteur a enlever */ -void Terminal::removeConducer(Conducer *f) { - //qDebug() << "Terminal::removeConducer" << (void *)this; - int index = liste_conducers.indexOf(f); +void Terminal::removeConductor(Conductor *f) { + //qDebug() << "Terminal::removeConductor" << (void *)this; + int index = liste_conductors.indexOf(f); if (index == -1) return; - liste_conducers.removeAt(index); + liste_conductors.removeAt(index); } /** @@ -171,7 +171,7 @@ void Terminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *) { p -> setRenderHint(QPainter::SmoothPixmapTransform, false); // on travaille avec les coordonnees de l'element parent - QPointF f = mapFromParent(amarrage_conducer); + QPointF f = mapFromParent(amarrage_conductor); QPointF e = mapFromParent(amarrage_elmt); QPen t; @@ -199,12 +199,12 @@ void Terminal::paint(QPainter *p, const QStyleOptionGraphicsItem *, QWidget *) { */ QRectF Terminal::boundingRect() const { if (br -> isNull()) { - qreal afx = amarrage_conducer.x(); - qreal afy = amarrage_conducer.y(); + qreal afx = amarrage_conductor.x(); + qreal afy = amarrage_conductor.y(); qreal aex = amarrage_elmt.x(); qreal aey = amarrage_elmt.y(); QPointF origine; - origine = (afx <= aex && afy <= aey ? amarrage_conducer : amarrage_elmt); + origine = (afx <= aex && afy <= aey ? amarrage_conductor : amarrage_elmt); origine += QPointF(-3.0, -3.0); qreal w = qAbs((int)(afx - aex)) + 7; qreal h = qAbs((int)(afy - aey)) + 7; @@ -241,9 +241,9 @@ void Terminal::hoverLeaveEvent(QGraphicsSceneHoverEvent *) { */ void Terminal::mousePressEvent(QGraphicsSceneMouseEvent *e) { if (Diagram *s = diagram()) { - s -> setConducerStart(mapToScene(QPointF(amarrage_conducer))); - s -> setConducerStop(e -> scenePos()); - s -> setConducer(true); + s -> setConductorStart(mapToScene(QPointF(amarrage_conductor))); + s -> setConductorStop(e -> scenePos()); + s -> setConductor(true); //setCursor(Qt::CrossCursor); } } @@ -268,13 +268,13 @@ void Terminal::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { Diagram *s = diagram(); if (!s) return; // si la scene est un Diagram, on actualise le poseur de conducteur - s -> setConducerStop(e -> scenePos()); + s -> setConductorStop(e -> scenePos()); // on recupere la liste des qgi sous le pointeur QList qgis = s -> items(e -> scenePos()); /* le qgi le plus haut - = le poseur de conducer + = le poseur de conductor = le premier element de la liste = la liste ne peut etre vide = on prend le deuxieme element de la liste @@ -296,11 +296,11 @@ void Terminal::mouseMoveEvent(QGraphicsSceneMouseEvent *e) { if (((Element *)parentItem()) -> connexionsInternesAcceptees()) p -> couleur_hovered = p -> couleur_autorise; else p -> couleur_hovered = p -> couleur_interdit; - } else if (p -> nbConducers()) { + } else if (p -> nbConductors()) { // si la borne a deja un conducteur // verifie que cette borne n'est pas deja reliee a l'autre borne bool deja_reliee = false; - foreach (Conducer *f, liste_conducers) { + foreach (Conductor *f, liste_conductors) { if (f -> terminal1 == p || f -> terminal2 == p) { deja_reliee = true; break; @@ -330,7 +330,7 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { // verifie que la scene est bien un Diagram if (Diagram *s = diagram()) { // on arrete de dessiner l'apercu du conducteur - s -> setConducer(false); + s -> setConductor(false); // on recupere l'element sous le pointeur lors du MouseReleaseEvent QGraphicsItem *qgi = s -> itemAt(e -> scenePos()); // s'il n'y a rien, on arrete la @@ -346,9 +346,9 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { bool cia = ((Element *)parentItem()) -> connexionsInternesAcceptees(); if (!cia) foreach(QGraphicsItem *item, parentItem() -> children()) if (item == p) return; // derniere verification : verifier que cette borne n'est pas deja reliee a l'autre borne - foreach (Conducer *f, liste_conducers) if (f -> terminal1 == p || f -> terminal2 == p) return; + foreach (Conductor *f, liste_conductors) if (f -> terminal1 == p || f -> terminal2 == p) return; // autrement, on pose un conducteur - s -> undoStack().push(new AddConducerCommand(s, new Conducer(this, p))); + s -> undoStack().push(new AddConductorCommand(s, new Conductor(this, p))); } } @@ -356,16 +356,16 @@ void Terminal::mouseReleaseEvent(QGraphicsSceneMouseEvent *e) { Met a jour l'eventuel conducteur relie a la Terminal. @param newpos Position de l'element parent a prendre en compte */ -void Terminal::updateConducer(QPointF newpos) { +void Terminal::updateConductor(QPointF newpos) { if (!scene() || !parentItem()) return; - foreach (Conducer *conducer, liste_conducers) { - if (conducer -> isDestroyed()) continue; - if (newpos == QPointF()) conducer -> update(QRectF()); + foreach (Conductor *conductor, liste_conductors) { + if (conductor -> isDestroyed()) continue; + if (newpos == QPointF()) conductor -> update(QRectF()); else { // determine la translation subie par l'element parent QPointF translation = newpos - parentItem() -> pos(); // rafraichit le conducteur en tenant compte de la translation - conducer -> updateWithNewPos(QRectF(), this, amarrageConducer() + translation); + conductor -> updateWithNewPos(QRectF(), this, amarrageConductor() + translation); } } } @@ -373,8 +373,8 @@ void Terminal::updateConducer(QPointF newpos) { /** @return La liste des conducteurs lies a cette borne */ -QList Terminal::conducers() const { - return(liste_conducers); +QList Terminal::conductors() const { + return(liste_conductors); } /** diff --git a/terminal.h b/terminal.h index 12b0c7cb9..432810a43 100644 --- a/terminal.h +++ b/terminal.h @@ -4,7 +4,7 @@ #include #include #include "qet.h" -class Conducer; +class Conductor; class Diagram; class Element; /** @@ -33,16 +33,16 @@ class Terminal : public QGraphicsItem { QRectF boundingRect() const; // methodes de manipulation des conducteurs lies a cette borne - bool addConducer(Conducer *); - void removeConducer(Conducer *); - int nbConducers() const; + bool addConductor(Conductor *); + void removeConductor(Conductor *); + int nbConductors() const; Diagram *diagram() const; // methodes de lecture - QList conducers() const; + QList conductors() const; QET::Orientation orientation() const; - QPointF amarrageConducer() const; - void updateConducer(QPointF = QPointF()); + QPointF amarrageConductor() const; + void updateConductor(QPointF = QPointF()); // methodes relatives a l'import/export au format XML static bool valideXml(QDomElement &); @@ -70,12 +70,12 @@ class Terminal : public QGraphicsItem { private: // coordonnees des points d'amarrage - QPointF amarrage_conducer; + QPointF amarrage_conductor; QPointF amarrage_elmt; // orientation de la borne QET::Orientation sens; - // liste des conducers lies a cette borne - QList liste_conducers; + // liste des conductors lies a cette borne + QList liste_conductors; // pointeur vers un rectangle correspondant au bounding rect ; permet de ne calculer le bounding rect qu'une seule fois ; le pointeur c'est parce que le compilo exige une methode const QRectF *br; Terminal *terminal_precedente; @@ -89,15 +89,15 @@ class Terminal : public QGraphicsItem { /** @return Le nombre de conducteurs associes a la borne */ -inline int Terminal::nbConducers() const { - return(liste_conducers.size()); +inline int Terminal::nbConductors() const { + return(liste_conductors.size()); } /** @return La position du point d'amarrage de la borne */ -inline QPointF Terminal::amarrageConducer() const { - return(mapToScene(amarrage_conducer)); +inline QPointF Terminal::amarrageConductor() const { + return(mapToScene(amarrage_conductor)); } #endif