kotschak/qelectrotech-source-mirror
0
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2025-12-19 14:50:53 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Classe Conducer renommee en Conductor

Browse Source 
git-svn-id: svn+ssh://svn.tuxfamily.org/svnroot/qet/qet/trunk@153 bfdf4180-ca20-0410-9c96-a3a8aa849046
This commit is contained in:
xavierqet
2007-10-03 17:02:39 +00:00
parent bb00094c0a
commit 2293cf1f37
30 changed files with 891 additions and 832 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
conducerprofile.cpp
View File

@@ -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<ConducerSegmentProfile *> ConducerProfile::horizontalSegments() {
QList<ConducerSegmentProfile *> segments_list;
foreach(ConducerSegmentProfile *csp, segments) {
if (csp -> isHorizontal) segments_list << csp;
}
return(segments_list);
}
/// @return les segments verticaux de ce profil
QList<ConducerSegmentProfile *> ConducerProfile::verticalSegments() {
QList<ConducerSegmentProfile *> 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());
}

38
conducerprofile.h
View File

@@ -1,38 +0,0 @@
#ifndef CONDUCER_PROFILE_H
#define CONDUCER_PROFILE_H
#include <QList>
#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<ConducerSegmentProfile *> 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<ConducerSegmentProfile *> horizontalSegments();
QList<ConducerSegmentProfile *> verticalSegments();
void fromConducer(Conducer *);
};
QDebug &operator<<(QDebug d, ConducerProfile &);
#endif

234
conducer.cpp → conductor.cpp
View File

@@ -1,15 +1,15 @@
#include <QtDebug>
#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<ConducerSegmentProfile *, qreal> segments_lengths;
segments_lengths.unite(shareOffsetBetweenSegments(h_diff, conducer_profile.horizontalSegments()));
segments_lengths.unite(shareOffsetBetweenSegments(v_diff, conducer_profile.verticalSegments()));
QHash<ConductorSegmentProfile *, qreal> 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<QPointF> 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<ConducerSegmentProfile *, qreal> Conducer::shareOffsetBetweenSegments(
QHash<ConductorSegmentProfile *, qreal> Conductor::shareOffsetBetweenSegments(
const qreal &offset,
const QList<ConducerSegmentProfile *> &segments_list,
const QList<ConductorSegmentProfile *> &segments_list,
const qreal &precision
) const {
// construit le QHash qui sera retourne
QHash<ConducerSegmentProfile *, qreal> segments_hash;
foreach(ConducerSegmentProfile *csp, segments_list) {
QHash<ConductorSegmentProfile *, qreal> segments_hash;
foreach(ConductorSegmentProfile *csp, segments_list) {
segments_hash.insert(csp, csp -> length);
}
// memorise le signe de la longueur de chaque segement
QHash<ConducerSegmentProfile *, int> segments_signs;
foreach(ConducerSegmentProfile *csp, segments_hash.keys()) {
QHash<ConductorSegmentProfile *, int> segments_signs;
foreach(ConductorSegmentProfile *csp, segments_hash.keys()) {
segments_signs.insert(csp, getSign(csp -> length));
}
@@ -241,12 +241,12 @@ QHash<ConducerSegmentProfile *, qreal> 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<ConducerSegmentProfile *, qreal> 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<Diagram *>(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<QPointF> 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<ConducerSegment *> segments_list = segmentsList();
uint Conductor::nbSegments(QET::ConductorSegmentType type) const {
QList<ConductorSegment *> 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<QPointF> Conducer::segmentsToPoints() const {
QList<QPointF> Conductor::segmentsToPoints() const {
// liste qui sera retournee
QList<QPointF> points_list;
@@ -725,7 +725,7 @@ QList<QPointF> 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<QPointF> 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<QPointF> points_list) {
void Conductor::pointsToSegments(QList<QPointF> 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<QPointF> 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<qreal>::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<Terminal *, int> &table_adr_id) const {
QDomElement e = d.createElement("conducer");
QDomElement Conductor::toXml(QDomDocument &d, QHash<Terminal *, int> &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<Terminal *, int> &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<Terminal *, int> &table_adr_i
}
/// @return les segments de ce conducteur
const QList<ConducerSegment *> Conducer::segmentsList() const {
if (segments == NULL) return(QList<ConducerSegment *>());
const QList<ConductorSegment *> Conductor::segmentsList() const {
if (segments == NULL) return(QList<ConductorSegment *>());
QList<ConducerSegment *> segments_vector;
ConducerSegment *segment = segments;
QList<ConductorSegment *> segments_vector;
ConductorSegment *segment = segments;
while (segment -> hasNextSegment()) {
segments_vector << segment;
@@ -912,10 +912,10 @@ const QList<ConducerSegment *> 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

50
conducer.h → conductor.h
View File

@@ -1,10 +1,10 @@
#ifndef CONDUCTEUR_H
#define CONDUCTEUR_H
#ifndef CONDUCTOR_H
#define CONDUCTOR_H
#include <QtGui>
#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<Terminal *, int> &) const;
const QList<ConducerSegment *> segmentsList() const;
void setProfile(const ConducerProfile &);
const QList<ConductorSegment *> 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<QPointF> segmentsToPoints() const;
void pointsToSegments(QList<QPointF>);
bool hasClickedOn(QPointF, QPointF) const;
void calculateTextItemPosition();
static int getCoeff(const qreal &, const qreal &);
static int getSign(const qreal &);
QHash<ConducerSegmentProfile *, qreal> shareOffsetBetweenSegments(const qreal &offset, const QList<ConducerSegmentProfile *> &, const qreal & = 0.01) const;
QHash<ConductorSegmentProfile *, qreal> shareOffsetBetweenSegments(const qreal &offset, const QList<ConductorSegmentProfile *> &, 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

137
conductorprofile.cpp Normal file
View File

@@ -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<ConductorSegmentProfile *> ConductorProfile::horizontalSegments() {
QList<ConductorSegmentProfile *> segments_list;
foreach(ConductorSegmentProfile *csp, segments) {
if (csp -> isHorizontal) segments_list << csp;
}
return(segments_list);
}
/// @return les segments verticaux de ce profil
QList<ConductorSegmentProfile *> ConductorProfile::verticalSegments() {
QList<ConductorSegmentProfile *> 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());
}

38
conductorprofile.h Normal file
View File

@@ -0,0 +1,38 @@
#ifndef CONDUCTOR_PROFILE_H
#define CONDUCTOR_PROFILE_H
#include <QList>
#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<ConductorSegmentProfile *> 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<ConductorSegmentProfile *> horizontalSegments();
QList<ConductorSegmentProfile *> verticalSegments();
void fromConductor(Conductor *);
};
QDebug &operator<<(QDebug d, ConductorProfile &);
#endif

32
conducerproperties.cpp → conductorproperties.cpp
View File

@@ -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());
}

20
conducerproperties.h → conductorproperties.h
View File

@@ -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 <QtGui>
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();

78
conducersegment.cpp → conductorsegment.cpp
View File

@@ -1,4 +1,4 @@
#include "conducersegment.h"
#include "conductorsegment.h"
#include <QDebug>
/**
@@ -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);
}

26
conducersegment.h → conductorsegment.h
View File

@@ -1,24 +1,24 @@
#ifndef CONDUCER_SEGMENT_H
#define CONDUCER_SEGMENT_H
#ifndef CONDUCTOR_SEGMENT_H
#define CONDUCTOR_SEGMENT_H
#include <QPointF>
#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;

16
conducersegmentprofile.h → conductorsegmentprofile.h
View File

@@ -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 <QtCore>
#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

8
customelement.cpp
View File

@@ -145,10 +145,10 @@ QList<Terminal *> CustomElement::terminals() const {
return(list_terminals);
}
QList<Conducer *> CustomElement::conducers() const {
QList<Conducer *> conducers;
foreach(Terminal *t, list_terminals) conducers << t -> conducers();
return(conducers);
QList<Conductor *> CustomElement::conductors() const {
QList<Conductor *> conductors;
foreach(Terminal *t, list_terminals) conductors << t -> conductors();
return(conductors);
}
/**

2
customelement.h
View File

@@ -34,7 +34,7 @@ class CustomElement : public FixedElement {
// methodes
public:
virtual QList<Terminal *> terminals() const;
virtual QList<Conducer *> conducers() const;
virtual QList<Conductor *> conductors() const;
virtual int nbTerminals() const;
virtual void paint(QPainter *, const QStyleOptionGraphicsItem *);
QString typeId() const;

80
diagram.cpp
View File

@@ -1,6 +1,6 @@
#include <math.h>
#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<Element *> liste_elements;
QList<Conducer *> liste_conducers;
QList<Conductor *> liste_conductors;
// Determine les elements a « XMLiser »
foreach(QGraphicsItem *qgi, items()) {
if (Element *elmt = qgraphicsitem_cast<Element *>(qgi)) {
if (diagram) liste_elements << elmt;
else if (elmt -> isSelected()) liste_elements << elmt;
} else if (Conducer *f = qgraphicsitem_cast<Conducer *>(qgi)) {
if (diagram) liste_conducers << f;
} else if (Conductor *f = qgraphicsitem_cast<Conductor *>(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<Element *> *added_elements, QList<Conducer *> *added_conducers) {
bool Diagram::fromXml(QDomDocument &document, QPointF position, bool consider_informations, QList<Element *> *added_elements, QList<Conductor *> *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<Element *>(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<Conducer *> Diagram::selectedConducers() const {
QSet<Conducer *> conducers_set;
QSet<Conductor *> Diagram::selectedConductors() const {
QSet<Conductor *> conductors_set;
foreach(QGraphicsItem *qgi, selectedItems()) {
if (Conducer *c = qgraphicsitem_cast<Conducer *>(qgi)) {
conducers_set << c;
if (Conductor *c = qgraphicsitem_cast<Conductor *>(qgi)) {
conductors_set << c;
}
}
return(conducers_set);
return(conductors_set);
}

44
diagram.h
View File

@@ -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<Element *> elements_to_move;
QSet<Conducer *> conducers_to_move;
QHash<Conducer *, Terminal *> conducers_to_update;
QSet<Conductor *> conductors_to_move;
QHash<Conductor *, Terminal *> 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<Element *> * = NULL, QList<Conducer *> * = NULL);
bool fromXml(QDomDocument &, QPointF = QPointF(), bool = true, QList<Element *> * = NULL, QList<Conductor *> * = NULL);
// fonctions relatives aux options graphiques
void setDisplayGrid(bool);
@@ -73,9 +73,9 @@ class Diagram : public QGraphicsScene {
void invalidateMovedElements();
void fetchMovedElements();
const QSet<Element *> &elementsToMove();
const QSet<Conducer *> &conducersToMove();
const QHash<Conducer *, Terminal *> &conducersToUpdate();
QSet<Conducer *> selectedConducers() const;
const QSet<Conductor *> &conductorsToMove();
const QHash<Conductor *, Terminal *> &conductorsToUpdate();
QSet<Conductor *> 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<Element *> &Diagram::elementsToMove() {
}
/// @return la liste des conducteurs a deplacer
inline const QSet<Conducer *> &Diagram::conducersToMove() {
inline const QSet<Conductor *> &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<Conducer *, Terminal *> &Diagram::conducersToUpdate() {
inline const QHash<Conductor *, Terminal *> &Diagram::conductorsToUpdate() {
if (!moved_elements_fetched) fetchMovedElements();
return(conducers_to_update);
return(conductors_to_update);
}
/// @return la pile d'annulations de ce schema

160
diagramcommands.cpp
View File

@@ -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<Element *> elements,
QSet<Conducer *> conducers,
QSet<Conductor *> 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<Element *> &e,
const QList<Conducer *> &c,
const QList<Conductor *> &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<Element *> elements,
QSet<Conducer *> conducers,
QSet<Conductor *> 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<Element *> &move_elements,
const QSet<Conducer *> &move_conducers,
const QHash<Conducer *, Terminal *> &modify_conducers,
const QSet<Conductor *> &move_conductors,
const QHash<Conductor *, Terminal *> &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<Element *, QET::Orientation> &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();
}
}

56
diagramcommands.h
View File

@@ -3,7 +3,7 @@
#include "qet.h"
#include "diagram.h"
#include "diagramtextitem.h"
#include "conducer.h"
#include "conductor.h"
#include <QtGui>
/**
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<Element *>, QSet<Conducer *>, QUndoCommand * = 0);
DeleteElementsCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, QUndoCommand * = 0);
virtual ~DeleteElementsCommand();
private:
DeleteElementsCommand(const DeleteElementsCommand &);
@@ -77,7 +77,7 @@ class DeleteElementsCommand : public QUndoCommand {
/// Liste des elements enleves
QSet<Element *> removed_elements;
/// List des conducteurs enleves
QSet<Conducer *> removed_conducers;
QSet<Conductor *> 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<Element *> &, const QList<Conducer *> &, QUndoCommand * = 0);
PasteDiagramCommand(Diagram *, const QList<Element *> &, const QList<Conductor *> &, QUndoCommand * = 0);
virtual ~PasteDiagramCommand();
private:
PasteDiagramCommand(const PasteDiagramCommand &);
@@ -103,7 +103,7 @@ class PasteDiagramCommand : public QUndoCommand {
/// Elements ajoutes
QList<Element *> elements;
/// conducteurs ajoutes
QList<Conducer *> conducers;
QList<Conductor *> 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<Element *>, QSet<Conducer *>, QUndoCommand * = 0);
CutDiagramCommand(Diagram *, QSet<Element *>, QSet<Conductor *>, 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<Element *> &, const QSet<Conducer *> &, const QHash<Conducer *, Terminal *> &, const QPointF &m, QUndoCommand * = 0);
MoveElementsCommand(Diagram *, const QSet<Element *> &, const QSet<Conductor *> &, const QHash<Conductor *, Terminal *> &, const QPointF &m, QUndoCommand * = 0);
virtual ~MoveElementsCommand();
private:
MoveElementsCommand(const MoveElementsCommand &);
@@ -148,9 +148,9 @@ class MoveElementsCommand : public QUndoCommand {
/// Elements a deplacer
QSet<Element *> elements_to_move;
/// Conducteurs a deplacer
QSet<Conducer *> conducers_to_move;
QSet<Conductor *> conductors_to_move;
/// Conducteurs a actualiser
QHash<Conducer *, Terminal *> conducers_to_update;
QHash<Conductor *, Terminal *> 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;

74
diagramview.cpp
View File

@@ -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<Element *> garbage_elmt;
QSet<Conducer *> garbage_conducers;
QSet<Conductor *> 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<Conducer *>(qgi)) {
if (Conductor * c = qgraphicsitem_cast<Conductor *>(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<Element *>(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<Element *> cut_elmt;
QSet<Conducer *> cut_conducers;
QSet<Conductor *> 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<Conducer *>(qgi)) {
if (Conductor * c = qgraphicsitem_cast<Conductor *>(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<Element *>(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<Element *> elements_pasted;
QList<Conducer *> conducers_pasted;
scene -> fromXml(document_xml, QPointF(), false, &elements_pasted, &conducers_pasted);
QList<Conductor *> 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<Element *> elements_pasted;
QList<Conducer *> conducers_pasted;
scene -> fromXml(document_xml, mapToScene(e -> pos()), false, &elements_pasted, &conducers_pasted);
QList<Conductor *> 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<Conducer *> selected_conducers(scene -> selectedConducers().toList());
void DiagramView::editConductor() {
QList<Conductor *> 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;

2
diagramview.h
View File

@@ -70,7 +70,7 @@ class DiagramView : public QGraphicsView {
void paste();
void adjustSceneRect();
void updateWindowTitle();
void editConducer();
void editConductor();
private slots:
void slot_selectionChanged();

18
element.cpp
View File

@@ -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 <QtDebug>
@@ -121,7 +121,7 @@ bool Element::setOrientation(QET::Orientation o) {
ori.setCurrent(o);
update();
foreach(QGraphicsItem *qgi, children()) {
if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConducer();
if (Terminal *p = qgraphicsitem_cast<Terminal *>(qgi)) p -> updateConductor();
else if (ElementTextItem *eti = qgraphicsitem_cast<ElementTextItem *>(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<Conducer *, Terminal *> &conducers_modify = diagram_ptr -> conducersToUpdate();
foreach(Conducer *conducer, conducers_modify.keys()) {
conducer -> updateWithNewPos(QRectF(), conducers_modify[conducer], conducers_modify[conducer] -> amarrageConducer());
const QHash<Conductor *, Terminal *> &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
)
);

2
element.h
View File

@@ -36,7 +36,7 @@ class Element : public QGraphicsItem {
// methodes virtuelles pures a definir dans les classes enfants
virtual QList<Terminal *> terminals() const = 0;
virtual QList<Conducer *> conducers() const = 0;
virtual QList<Conductor *> conductors() const = 0;
virtual int nbTerminals() const = 0;
virtual int nbTerminalsMin() const = 0;
virtual int nbTerminalsMax() const = 0;

BIN
lang/qet_en.qm
View File

Binary file not shown.

319
lang/qet_en.ts
View File

@@ -1,5 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS><TS version="1.1" language="en">
<defaultcodec></defaultcodec>
<context>
<name>AboutQET</name>
<message>
@@ -219,25 +220,63 @@ Whoops, we have no website</translation>
<translation>diameter</translation>
</message>
</context>
<context>
<name>ConductorPropertiesWidget</name>
<message>
<location filename="../conductorproperties.cpp" line="16"/>
<source>Type de conducteur</source>
<translation>Conductor Type</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="22"/>
<source>Multifilaire</source>
<translation>Multiline</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="25"/>
<source>Texte :</source>
<translation>Text :</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="30"/>
<source>Unifilaire</source>
<translation>SIngleline</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="33"/>
<source>phase</source>
<translation>phase</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="44"/>
<source>terre</source>
<translation>ground</translation>
</message>
<message>
<location filename="../conductorproperties.cpp" line="46"/>
<source>neutre</source>
<translation>neutral</translation>
</message>
</context>
<context>
<name>DiagramView</name>
<message>
<location filename="../diagramview.cpp" line="345"/>
<location filename="../diagramview.cpp" line="347"/>
<source> ?</source>
<translation> ?</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="478"/>
<location filename="../diagramview.cpp" line="480"/>
<source>Auteur : </source>
<translation>Author : </translation>
</message>
<message>
<location filename="../diagramview.cpp" line="464"/>
<location filename="../diagramview.cpp" line="466"/>
<source>Cartouche du sch&#xe9;ma</source>
<translation>Diagram inset</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="480"/>
<location filename="../diagramview.cpp" line="482"/>
<source>Date : </source>
<translation>Date : </translation>
</message>
@@ -247,32 +286,32 @@ Whoops, we have no website</translation>
<translation type="obsolete">Diagram QElectroTech (*.qet)</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="344"/>
<location filename="../diagramview.cpp" line="346"/>
<source>Enregistrer le sch&#xe9;ma en cours ?</source>
<translation>Save the current diagram ?</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="385"/>
<location filename="../diagramview.cpp" line="387"/>
<source>Enregistrer sous</source>
<translation>Save as</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="414"/>
<location filename="../diagramview.cpp" line="416"/>
<source>Erreur</source>
<translation>Error</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="482"/>
<location filename="../diagramview.cpp" line="484"/>
<source>Fichier : </source>
<translation>File : </translation>
</message>
<message>
<location filename="../diagramview.cpp" line="484"/>
<location filename="../diagramview.cpp" line="486"/>
<source>Folio : </source>
<translation>Folio : </translation>
</message>
<message>
<location filename="../diagramview.cpp" line="414"/>
<location filename="../diagramview.cpp" line="416"/>
<source>Impossible d&apos;ecrire dans ce fichier</source>
<translation>Can&apos;t write to the file</translation>
</message>
@@ -287,25 +326,30 @@ Whoops, we have no website</translation>
<translation type="obsolete">Diagram QElectroTech (*.qet)</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="388"/>
<location filename="../diagramview.cpp" line="390"/>
<source>Sch&#xe9;ma QElectroTech (*.qet)</source>
<translation>QElectroTech Diagram (*.qet)</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="476"/>
<location filename="../diagramview.cpp" line="478"/>
<source>Titre : </source>
<translation>Title :</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="345"/>
<location filename="../diagramview.cpp" line="347"/>
<source>Voulez-vous enregistrer le sch&#xe9;ma </source>
<translation>Do you wish to save the diagram </translation>
</message>
<message>
<location filename="../diagramview.cpp" line="579"/>
<location filename="../diagramview.cpp" line="581"/>
<source>nouveau sch&#xe9;ma</source>
<translation>new diagram</translation>
</message>
<message>
<location filename="../diagramview.cpp" line="627"/>
<source>&#xc9;diter les propri&#xe9;t&#xe9;s d&apos;un conducteur</source>
<translation>Edit conductor properties</translation>
</message>
</context>
<context>
<name>ElementDeleter</name>
@@ -1383,17 +1427,17 @@ Please check rights of the directory </translation>
<translation type="obsolete">Render the current plan with or without antialiasing</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="773"/>
<location filename="../qetdiagrameditor.cpp" line="780"/>
<source>Active la fen&#xea;tre </source>
<translation>Activates the window </translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="265"/>
<location filename="../qetdiagrameditor.cpp" line="268"/>
<source>Active la fen&#xea;tre pr&#xe9;c&#xe9;dente</source>
<translation>Activates the previous window</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="264"/>
<location filename="../qetdiagrameditor.cpp" line="267"/>
<source>Active la fen&#xea;tre suivante</source>
<translation>Activates the next window</translation>
</message>
@@ -1403,87 +1447,87 @@ Please check rights of the directory </translation>
<translation type="obsolete">Render with &amp;Antialiasing</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="251"/>
<location filename="../qetdiagrameditor.cpp" line="254"/>
<source>Adapte la taille du sch&#xe9;ma afin qu&apos;il soit enti&#xe8;rement visible</source>
<translation>Changes the size of the plan so that it fits in the view</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="325"/>
<location filename="../qetdiagrameditor.cpp" line="329"/>
<source>Afficha&amp;ge</source>
<translation>Displ&amp;ay</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="268"/>
<location filename="../qetdiagrameditor.cpp" line="271"/>
<source>Affiche des informations sur la biblioth&#xe8;que Qt</source>
<translation>Displays informations about Qt library</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="267"/>
<location filename="../qetdiagrameditor.cpp" line="270"/>
<source>Affiche des informations sur QElectroTech</source>
<translation>Displays informations about QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="379"/>
<location filename="../qetdiagrameditor.cpp" line="385"/>
<source>Affiche ou non la barre d&apos;outils</source>
<translation>Displays or not the toolbar</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="381"/>
<location filename="../qetdiagrameditor.cpp" line="387"/>
<source>Affiche ou non le panel d&apos;appareils</source>
<translation>Displays or not the elements panel</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="258"/>
<location filename="../qetdiagrameditor.cpp" line="261"/>
<source>Affiche QElectroTech en mode fen&#xea;tr&#xe9;</source>
<translation>Displays QElectroTech in windowed mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="257"/>
<location filename="../qetdiagrameditor.cpp" line="260"/>
<source>Affiche QElectroTech en mode plein &#xe9;cran</source>
<translation>Displays QELectroTech in full screen mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="376"/>
<location filename="../qetdiagrameditor.cpp" line="382"/>
<source>Afficher</source>
<translation>Display</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="166"/>
<location filename="../qetdiagrameditor.cpp" line="168"/>
<source>Agrandir le sch&#xe9;ma</source>
<translation>Expand the diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="249"/>
<location filename="../qetdiagrameditor.cpp" line="252"/>
<source>Agrandit le sch&#xe9;ma</source>
<translation>Expand the diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="246"/>
<location filename="../qetdiagrameditor.cpp" line="249"/>
<source>Agrandit le sch&#xe9;ma en hauteur</source>
<translation>Expand the diagram&apos;s height</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="329"/>
<location filename="../qetdiagrameditor.cpp" line="333"/>
<source>&amp;Aide</source>
<translation>&amp;Help</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="164"/>
<location filename="../qetdiagrameditor.cpp" line="166"/>
<source>Ajouter une colonne</source>
<translation>Add a column</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="244"/>
<location filename="../qetdiagrameditor.cpp" line="247"/>
<source>Ajoute une colonne au sch&#xe9;ma</source>
<translation>Add a column to the diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="263"/>
<location filename="../qetdiagrameditor.cpp" line="266"/>
<source>Aligne les fen&#xea;tres r&#xe9;duites</source>
<translation>Arranges all iconized windows at the bottom of the workspace</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="233"/>
<location filename="../qetdiagrameditor.cpp" line="235"/>
<source>Annule l&apos;action pr&#xe9;c&#xe9;dente</source>
<translation>Undoes the previous action</translation>
</message>
@@ -1493,17 +1537,17 @@ Please check rights of the directory </translation>
<translation type="obsolete">&amp;Undo</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="187"/>
<location filename="../qetdiagrameditor.cpp" line="189"/>
<source>&#xc0; &amp;propos de QElectroTech</source>
<translation>A&amp;bout QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="188"/>
<location filename="../qetdiagrameditor.cpp" line="190"/>
<source>&#xc0; propos de &amp;Qt</source>
<translation>About &amp;Qt</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="183"/>
<location filename="../qetdiagrameditor.cpp" line="185"/>
<source>Arranger les fen&#xea;tres r&#xe9;duites</source>
<translation>Arranges iconized windows</translation>
</message>
@@ -1513,27 +1557,27 @@ Please check rights of the directory </translation>
<translation type="obsolete">Hide Too&amp;lbar</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="182"/>
<location filename="../qetdiagrameditor.cpp" line="184"/>
<source>&amp;Cascade</source>
<translation>&amp;Cascade</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="517"/>
<location filename="../qetdiagrameditor.cpp" line="523"/>
<source>Ce fichier n&apos;est pas un document XML valide.</source>
<translation>This file is not a valid XML Document.</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="515"/>
<location filename="../qetdiagrameditor.cpp" line="521"/>
<source>Ce fichier n&apos;existe pas.</source>
<translation>This file does not exist.</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="157"/>
<location filename="../qetdiagrameditor.cpp" line="158"/>
<source>C&amp;oller</source>
<translation>&amp;Paste</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="327"/>
<location filename="../qetdiagrameditor.cpp" line="331"/>
<source>&amp;Configuration</source>
<translation>&amp;Settings</translation>
</message>
@@ -1543,77 +1587,77 @@ Please check rights of the directory </translation>
<translation type="obsolete">Configure tool&amp;bars</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="179"/>
<location filename="../qetdiagrameditor.cpp" line="181"/>
<source>&amp;Configurer QElectroTech</source>
<translation>&amp;Configure QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="236"/>
<location filename="../qetdiagrameditor.cpp" line="238"/>
<source>Copie les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s dans le presse-papier</source>
<translation>Copies selected elements</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="156"/>
<location filename="../qetdiagrameditor.cpp" line="157"/>
<source>Cop&amp;ier</source>
<translation>&amp;Copy</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="155"/>
<location filename="../qetdiagrameditor.cpp" line="156"/>
<source>Co&amp;uper</source>
<translation>Cu&amp;t</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="223"/>
<location filename="../qetdiagrameditor.cpp" line="225"/>
<source>Cr&#xe9;e un nouveau sch&#xe9;ma</source>
<translation>Opens a new diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="214"/>
<location filename="../qetdiagrameditor.cpp" line="216"/>
<source>Ctrl+0</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="213"/>
<location filename="../qetdiagrameditor.cpp" line="215"/>
<source>Ctrl+9</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="207"/>
<location filename="../qetdiagrameditor.cpp" line="209"/>
<source>Ctrl+I</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="198"/>
<location filename="../qetdiagrameditor.cpp" line="200"/>
<source>Ctrl+Q</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="209"/>
<location filename="../qetdiagrameditor.cpp" line="211"/>
<source>Ctrl+R</source>
<translation>Ctrl+R</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="206"/>
<location filename="../qetdiagrameditor.cpp" line="208"/>
<source>Ctrl+Shift+A</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="217"/>
<location filename="../qetdiagrameditor.cpp" line="219"/>
<source>Ctrl+Shift+F</source>
<translation>Ctrl+Shift+F</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="195"/>
<location filename="../qetdiagrameditor.cpp" line="197"/>
<source>Ctrl+Shift+I</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="196"/>
<location filename="../qetdiagrameditor.cpp" line="198"/>
<source>Ctrl+Shift+X</source>
<translation></translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="208"/>
<location filename="../qetdiagrameditor.cpp" line="210"/>
<source>Ctrl+Suppr</source>
<translation>Ctrl+Suppr</translation>
</message>
@@ -1623,17 +1667,17 @@ Please check rights of the directory </translation>
<translation type="obsolete">Render without &amp;Antialiasing</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="240"/>
<location filename="../qetdiagrameditor.cpp" line="242"/>
<source>D&#xe9;s&#xe9;lectionne les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s et s&#xe9;lectionne les &#xe9;l&#xe9;ments non s&#xe9;lectionn&#xe9;s</source>
<translation>Deselects selected elements and select non-selected elements</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="159"/>
<location filename="../qetdiagrameditor.cpp" line="160"/>
<source>D&#xe9;s&#xe9;lectionner tout</source>
<translation>Select none</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="239"/>
<location filename="../qetdiagrameditor.cpp" line="241"/>
<source>D&#xe9;s&#xe9;lectionne tous les &#xe9;l&#xe9;ments du sch&#xe9;ma</source>
<translation>Deselect all elements on the plan</translation>
</message>
@@ -1643,52 +1687,52 @@ Please check rights of the directory </translation>
<translation type="obsolete">Diagram QelectroTech (*.qet);;XML Files(*.xml);;All files (*)</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="262"/>
<location filename="../qetdiagrameditor.cpp" line="265"/>
<source>Dispose les fen&#xea;tres en cascade</source>
<translation>Arranges windows in a cascade pattern</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="261"/>
<location filename="../qetdiagrameditor.cpp" line="264"/>
<source>Dispose les fen&#xea;tres en mosa&#xef;que</source>
<translation>Arranges windows in a tile pattern</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="243"/>
<location filename="../qetdiagrameditor.cpp" line="246"/>
<source>&#xc9;dite les informations affich&#xe9;es par le cartouche</source>
<translation>Edit informations displayed by the inset</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="324"/>
<location filename="../qetdiagrameditor.cpp" line="328"/>
<source>&amp;&#xc9;dition</source>
<translation>&amp;Edit</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="241"/>
<location filename="../qetdiagrameditor.cpp" line="243"/>
<source>Enl&#xe8;ve les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s du sch&#xe9;ma</source>
<translation>Removes selected elements from the plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="165"/>
<location filename="../qetdiagrameditor.cpp" line="167"/>
<source>Enlever une colonne</source>
<translation>Remove a column</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="245"/>
<location filename="../qetdiagrameditor.cpp" line="248"/>
<source>Enl&#xe8;ve une colonne au sch&#xe9;ma</source>
<translation>Remove a column from the diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="226"/>
<location filename="../qetdiagrameditor.cpp" line="228"/>
<source>Enregistre le sch&#xe9;ma courant</source>
<translation>Saves the current plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="227"/>
<location filename="../qetdiagrameditor.cpp" line="229"/>
<source>Enregistre le sch&#xe9;ma courant avec un autre nom de fichier</source>
<translation>Saves the current plan as another filename</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="144"/>
<location filename="../qetdiagrameditor.cpp" line="145"/>
<source>&amp;Enregistrer</source>
<translation>&amp;Save</translation>
</message>
@@ -1698,22 +1742,22 @@ Please check rights of the directory </translation>
<translation type="obsolete">Save the current schema ?</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="145"/>
<location filename="../qetdiagrameditor.cpp" line="146"/>
<source>Enregistrer sous</source>
<translation>Save as</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="520"/>
<location filename="../qetdiagrameditor.cpp" line="526"/>
<source>Erreur</source>
<translation>Error</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="229"/>
<location filename="../qetdiagrameditor.cpp" line="231"/>
<source>Exporte le sch&#xe9;ma courant dans un autre format</source>
<translation>Exports the curent plan to another format</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="147"/>
<location filename="../qetdiagrameditor.cpp" line="148"/>
<source>E&amp;xporter</source>
<translation>&amp;Export</translation>
</message>
@@ -1723,37 +1767,37 @@ Please check rights of the directory </translation>
<translation type="obsolete">Export to file</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="185"/>
<location filename="../qetdiagrameditor.cpp" line="187"/>
<source>Fen&#xea;tre pr&#xe9;c&#xe9;dente</source>
<translation>Previous Window</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="328"/>
<location filename="../qetdiagrameditor.cpp" line="332"/>
<source>Fe&amp;n&#xea;tres</source>
<translation>Wi&amp;ndows</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="184"/>
<location filename="../qetdiagrameditor.cpp" line="186"/>
<source>Fen&#xea;tre suivante</source>
<translation>Next Window</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="231"/>
<location filename="../qetdiagrameditor.cpp" line="233"/>
<source>Ferme l&apos;application QElectroTech</source>
<translation>Closes QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="225"/>
<location filename="../qetdiagrameditor.cpp" line="227"/>
<source>Ferme le sch&#xe9;ma courant</source>
<translation>Closes the current plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="143"/>
<location filename="../qetdiagrameditor.cpp" line="144"/>
<source>&amp;Fermer</source>
<translation>&amp;Close</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="323"/>
<location filename="../qetdiagrameditor.cpp" line="327"/>
<source>&amp;Fichier</source>
<translation>&amp;File</translation>
</message>
@@ -1763,12 +1807,12 @@ Please check rights of the directory </translation>
<translation type="obsolete">PNG Picture (*.png)</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="146"/>
<location filename="../qetdiagrameditor.cpp" line="147"/>
<source>&amp;Importer</source>
<translation>&amp;Import</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="228"/>
<location filename="../qetdiagrameditor.cpp" line="230"/>
<source>Importe un sch&#xe9;ma dans le sch&#xe9;ma courant</source>
<translation>Imports a plan into the current plan</translation>
</message>
@@ -1783,27 +1827,27 @@ Please check rights of the directory </translation>
<translation type="obsolete">Can&apos;t read that file</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="516"/>
<location filename="../qetdiagrameditor.cpp" line="522"/>
<source>Impossible de lire ce fichier.</source>
<translation>Could not read file.</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="230"/>
<location filename="../qetdiagrameditor.cpp" line="232"/>
<source>Imprime le sch&#xe9;ma courant</source>
<translation>Prints the current plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="148"/>
<location filename="../qetdiagrameditor.cpp" line="149"/>
<source>Imprimer</source>
<translation>Print</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="163"/>
<location filename="../qetdiagrameditor.cpp" line="165"/>
<source>Informations sur le sch&#xe9;ma</source>
<translation>Diagram informations</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="160"/>
<location filename="../qetdiagrameditor.cpp" line="161"/>
<source>Inverser la s&#xe9;lection</source>
<translation>Invert selection</translation>
</message>
@@ -1818,47 +1862,47 @@ Please check rights of the directory </translation>
<translation type="obsolete">&amp;Fullscreen Mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="174"/>
<location filename="../qetdiagrameditor.cpp" line="176"/>
<source>Mode Selection</source>
<translation>Selection Mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="175"/>
<location filename="../qetdiagrameditor.cpp" line="177"/>
<source>Mode Visualisation</source>
<translation>View Mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="181"/>
<location filename="../qetdiagrameditor.cpp" line="183"/>
<source>&amp;Mosa&#xef;que</source>
<translation>&amp;Tile</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="141"/>
<location filename="../qetdiagrameditor.cpp" line="142"/>
<source>&amp;Nouveau</source>
<translation>&amp;New</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="326"/>
<location filename="../qetdiagrameditor.cpp" line="330"/>
<source>O&amp;utils</source>
<translation>&amp;Tools</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="411"/>
<location filename="../qetdiagrameditor.cpp" line="417"/>
<source>Outils</source>
<translation>Tools</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="224"/>
<location filename="../qetdiagrameditor.cpp" line="226"/>
<source>Ouvre un sch&#xe9;ma existant</source>
<translation>Open an existing diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="142"/>
<location filename="../qetdiagrameditor.cpp" line="143"/>
<source>&amp;Ouvrir</source>
<translation>&amp;Open</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="490"/>
<location filename="../qetdiagrameditor.cpp" line="496"/>
<source>Ouvrir un fichier</source>
<translation>Open a file</translation>
</message>
@@ -1868,47 +1912,47 @@ Please check rights of the directory </translation>
<translation type="obsolete">P</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="55"/>
<location filename="../qetdiagrameditor.cpp" line="56"/>
<source>Panel d&apos;appareils</source>
<translation>Elements Panel</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="172"/>
<location filename="../qetdiagrameditor.cpp" line="174"/>
<source>Pas de zoom</source>
<translation>Reset zoom</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="177"/>
<location filename="../qetdiagrameditor.cpp" line="179"/>
<source>Passer en &amp;mode plein &#xe9;cran</source>
<translation>F&amp;ullScreen Screen Mode</translation>
<translation>F&amp;ullScreen Mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="259"/>
<location filename="../qetdiagrameditor.cpp" line="262"/>
<source>Permet de r&#xe9;gler diff&#xe9;rents param&#xe8;tres de QElectroTech</source>
<translation>Allows to specify various parameters for QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="254"/>
<location filename="../qetdiagrameditor.cpp" line="257"/>
<source>Permet de s&#xe9;lectionner les &#xe9;l&#xe9;ments</source>
<translation>Allows to select elements</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="255"/>
<location filename="../qetdiagrameditor.cpp" line="258"/>
<source>Permet de visualiser le sch&#xe9;ma sans pouvoir le modifier</source>
<translation>Allows to view the plan without modifying it</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="242"/>
<location filename="../qetdiagrameditor.cpp" line="244"/>
<source>Pivote les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s</source>
<translation>Rotates selected elements</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="162"/>
<location filename="../qetdiagrameditor.cpp" line="163"/>
<source>Pivoter</source>
<translation>Rotate</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="237"/>
<location filename="../qetdiagrameditor.cpp" line="239"/>
<source>Place les &#xe9;l&#xe9;ments du presse-papier sur le sch&#xe9;ma</source>
<translation>Pastes elements from the clipboard into the plan</translation>
</message>
@@ -1918,7 +1962,7 @@ Please check rights of the directory </translation>
<translation type="obsolete">QElectrotech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="52"/>
<location filename="../qetdiagrameditor.cpp" line="53"/>
<source>QElectroTech</source>
<translation>QElectroTech</translation>
</message>
@@ -1928,7 +1972,7 @@ Please check rights of the directory </translation>
<translation type="obsolete">QElectrotech : Size of the drawing area :</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="149"/>
<location filename="../qetdiagrameditor.cpp" line="150"/>
<source>&amp;Quitter</source>
<translation>&amp;Quit</translation>
</message>
@@ -1943,12 +1987,12 @@ Please check rights of the directory </translation>
<translation type="obsolete">&amp;Redo</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="234"/>
<location filename="../qetdiagrameditor.cpp" line="236"/>
<source>Restaure l&apos;action annul&#xe9;e</source>
<translation>Restores the undone action</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="252"/>
<location filename="../qetdiagrameditor.cpp" line="255"/>
<source>Restaure le zoom par d&#xe9;faut</source>
<translation>Restores default zoom level</translation>
</message>
@@ -1963,17 +2007,17 @@ Please check rights of the directory </translation>
<translation type="obsolete">Restore QElectroTech</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="167"/>
<location filename="../qetdiagrameditor.cpp" line="169"/>
<source>R&#xe9;tr&#xe9;cir le sch&#xe9;ma</source>
<translation>Shrink the diagram</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="250"/>
<location filename="../qetdiagrameditor.cpp" line="253"/>
<source>R&#xe9;tr&#xe9;cit le sch&#xe9;ma</source>
<translation>Shrinks the plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="247"/>
<location filename="../qetdiagrameditor.cpp" line="250"/>
<source>R&#xe9;tr&#xe9;cit le sch&#xe9;ma en hauteur</source>
<translation>Shrink the diagram&apos;s height</translation>
</message>
@@ -1998,37 +2042,37 @@ Please check rights of the directory </translation>
<translation type="obsolete">QElectroTech Diagram (*.qet);;XML Files (*.xml);;All files (*)</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="493"/>
<location filename="../qetdiagrameditor.cpp" line="499"/>
<source>Sch&#xe9;mas QElectroTech (*.qet);;Fichiers XML (*.xml);;Tous les fichiers (*)</source>
<translation>QElectroTech Diagrams (*.qet);;XML Files (*.xml);;All files (*)</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="238"/>
<location filename="../qetdiagrameditor.cpp" line="240"/>
<source>S&#xe9;lectionne tous les &#xe9;l&#xe9;ments du sch&#xe9;ma</source>
<translation>Selects all elements on the plan</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="178"/>
<location filename="../qetdiagrameditor.cpp" line="180"/>
<source>Sortir du &amp;mode plein &#xe9;cran</source>
<translation>Exit F&amp;ullScreen Screen Mode</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="161"/>
<location filename="../qetdiagrameditor.cpp" line="162"/>
<source>Supprimer</source>
<translation>Delete</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="158"/>
<location filename="../qetdiagrameditor.cpp" line="159"/>
<source>Tout s&#xe9;lectionner</source>
<translation>Select All</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="235"/>
<location filename="../qetdiagrameditor.cpp" line="237"/>
<source>Transf&#xe8;re les &#xe9;l&#xe9;ments s&#xe9;lectionn&#xe9;s dans le presse-papier</source>
<translation>Puts selected elements into the clipboard</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="518"/>
<location filename="../qetdiagrameditor.cpp" line="524"/>
<source>Une erreur s&apos;est produite lors de l&apos;ouverture du fichier.</source>
<translation>An error occured while opening the file.</translation>
</message>
@@ -2043,30 +2087,40 @@ Please check rights of the directory </translation>
<translation type="obsolete">x</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="171"/>
<location filename="../qetdiagrameditor.cpp" line="173"/>
<source>Zoom adapt&#xe9;</source>
<translation>Fit in view</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="170"/>
<location filename="../qetdiagrameditor.cpp" line="172"/>
<source>Zoom arri&#xe8;re</source>
<translation>Zoom Out</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="169"/>
<location filename="../qetdiagrameditor.cpp" line="171"/>
<source>Zoom avant</source>
<translation>Zoom In</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="151"/>
<location filename="../qetdiagrameditor.cpp" line="152"/>
<source>Annuler</source>
<translation>Undo</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="153"/>
<location filename="../qetdiagrameditor.cpp" line="154"/>
<source>Refaire</source>
<translation>Redo</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="164"/>
<source>Propri&#xe9;t&#xe9;s du conducteur</source>
<translation>Conductor properties</translation>
</message>
<message>
<location filename="../qetdiagrameditor.cpp" line="245"/>
<source>&#xc9;dite les propri&#xe9;t&#xe9;s du conducteur s&#xe9;lectionn&#xe9;</source>
<translation>Edit the selected conductor properties</translation>
</message>
</context>
<context>
<name>QETElementEditor</name>
@@ -2441,7 +2495,7 @@ Please check rights of the directory </translation>
<message>
<location filename="../diagramcommands.cpp" line="55"/>
<source>ajouter un conducteur</source>
<translation>add a conducer</translation>
<translation>add a conductor</translation>
</message>
<message>
<location filename="../diagramcommands.cpp" line="98"/>
@@ -2476,7 +2530,7 @@ Please check rights of the directory </translation>
<message>
<location filename="../diagramcommands.cpp" line="368"/>
<source>modifier un conducteur</source>
<translation>modify a conducer</translation>
<translation>modify a conductor</translation>
</message>
<message>
<location filename="../diagramcommands.cpp" line="404"/>
@@ -2521,18 +2575,23 @@ Please check rights of the directory </translation>
<message>
<location filename="../qet.cpp" line="142"/>
<source>conducteurs</source>
<translation>conducers</translation>
<translation>conductors</translation>
</message>
<message>
<location filename="../qet.cpp" line="142"/>
<source>conducteur</source>
<translation>conducer</translation>
<translation>conductor</translation>
</message>
<message>
<location filename="../terminal.cpp" line="44"/>
<source>Borne</source>
<translation>Terminal</translation>
</message>
<message>
<location filename="../diagramcommands.cpp" line="477"/>
<source>modifier les propri&#xe9;t&#xe9;s d&apos;un conducteur</source>
<translation>modify conductor properties</translation>
</message>
</context>
<context>
<name>Schema</name>

18
qelectrotech.pro
View File

@@ -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

12
qet.cpp
View File

@@ -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);
}

4
qet.h
View File

@@ -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

16
qetdiagrameditor.cpp
View File

@@ -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();
}
}

4
qetdiagrameditor.h
View File

@@ -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;

70
terminal.cpp
View File

@@ -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<QGraphicsItem *> 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<Conducer *> Terminal::conducers() const {
return(liste_conducers);
QList<Conductor *> Terminal::conductors() const {
return(liste_conductors);
}
/**

28
terminal.h
View File

@@ -4,7 +4,7 @@
#include <QtGui>
#include <QtXml>
#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<Conducer *> conducers() const;
QList<Conductor *> 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<Conducer *> liste_conducers;
// liste des conductors lies a cette borne
QList<Conductor *> 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